#Runtime API

type InitOptions {
    // Name of the current host
    name: string;
    // List of dependent remote modules
    // tip: The remotes configured at runtime are not completely consistent in type and data with those passed in by the build plugin.
    remotes: Array<RemoteInfo>;
    // List of dependencies that the current host needs to share
    // When using the build plugin, users can configure the dependencies to be shared in the build plugin, and the build plugin will inject the dependencies to be shared into the shared configuration at runtime.
    // When shared is passed in at runtime, the version instance reference must be passed in manually, because it cannot be directly obtained at runtime.
    shared?: {
      [pkgName: string]: ShareArgs | ShareArgs[];
    };
};

type ShareArgs =
  | (SharedBaseArgs & { get: SharedGetter })
  | (SharedBaseArgs & { lib: () => Module });

type SharedBaseArgs = {
  version: string;
  shareConfig?: SharedConfig;
  scope?: string | Array<string>;
  deps?: Array<string>;
  strategy?: 'version-first' | 'loaded-first';
};

type SharedGetter = (() => () => Module) | (() => Promise<() => Module>);

type RemoteInfo = {
  alias?: string;
};

interface RemotesWithEntry {
  name: string;
  entry: string;
}

type ShareInfos = {
  // Package name and basic information of the dependency, sharing strategy
  [pkgName: string]: Share;
};

type Share = {
  // Version of the shared dependency
  version: string;
  // Which modules consume the current shared dependency
  useIn?: Array<string>;
  // Which module the shared dependency comes from
  from?: string;
  // Factory function to get the instance of the shared dependency. When the cached shared instance cannot be loaded, it will load its own shared dependency.
  lib: () => Module;
  // Sharing strategy, which strategy will be used to determine the reuse of shared dependencies
  shareConfig?: SharedConfig;
  // Dependencies between shares
  deps?: Array<string>;
  // Under which scope the current shared dependency is placed, the default is default
  scope?: string | Array<string>;
};

import { init, preloadRemote } from '@module-federation/enhanced/runtime';
init({
    name: 'mf_host',
    remotes: [
        {
            name: 'sub1',
            entry: "http://localhost:2001/mf-manifest.json"
        },
        {
            name: 'sub2',
            entry: "http://localhost:2002/mf-manifest.json"
        },
        {
            name: 'sub3',
            entry: "http://localhost:2003/mf-manifest.json"
        },
    ],
});

// Preload the @demo/sub1 module
// Filter resource information that contains 'ignore' in the resource name
// Only preload the sub-dependency @demo/sub1-button module
preloadRemote([
    {
        nameOrAlias: 'sub1',
        filter(assetUrl) {
            return assetUrl.indexOf('ignore') === -1;
        },
        depsRemote: [{ nameOrAlias: 'sub1-button' }],
    },
]);


// Preload the @demo/sub2 module
// Preload all exposes under @demo/sub2
// Preload the synchronous and asynchronous resources of @demo/sub2
preloadRemote([
    {
        nameOrAlias: 'sub2',
        resourceCategory: 'all',
    },
]);

// Preload the add expose of the @demo/sub3 module
preloadRemote([
    {
        nameOrAlias: 'sub3',
        resourceCategory: 'all',
        exposes: ['add'],
    },
]);

import { init, registerRemotes } from '@module-federation/enhanced/runtime';

init({
  name: 'mf_host',
  remotes: [
    {
      name: 'sub1',
      entry: 'http://localhost:2001/mf-manifest.json',
    }
  ],
});

// Add a new remote @demo/sub2
registerRemotes([
  {
      name: 'sub2',
      entry: 'http://localhost:2002/mf-manifest.json',
  }
]);

// Overwrite the previous remote @demo/sub1
registerRemotes([
  {
      name: 'sub1',
      entry: 'http://localhost:2003/mf-manifest.json',
  }
],{ force:true });

import { init, registerPlugins } from '@module-federation/enhanced/runtime';
import runtimePlugin from './custom-runtime-plugin';

init({
  name: 'mf_host',
  remotes: [
    {
      name: 'sub1',
      entry: 'http://localhost:2001/mf-manifest.json',
    }
  ],
});

// Add a new runtime plugin
registerPlugins([runtimePlugin()]);

registerPlugins([
  {
    name: 'custom-plugin-runtime',
    beforeInit(args) {
      const { userOptions, origin } = args;
      if (origin.options.name && origin.options.name !== userOptions.name) {
        userOptions.name = origin.options.name;
      }
      console.log('[build time inject] beforeInit: ', args);
      return args;
    },
    beforeLoadShare(args) {
      console.log('[build time inject] beforeLoadShare: ', args);
      return args;
    },
    createLink({ url }) {
      const link = document.createElement('link');
      link.setAttribute('href', url);
      link.setAttribute('rel', 'preload');
      link.setAttribute('as', 'script');
      link.setAttribute('crossorigin', 'anonymous');
      return link;
    },
  }
]);