@module-federation/webpack-bundler-runtime 2.0.1 → 2.2.0

package/dist/remotes.js

@@ -0,0 +1,73 @@
+import { attachShareScopeMap } from "./attachShareScopeMap.js";
+import { FEDERATION_SUPPORTED_TYPES } from "./constant.js";
+import { updateRemoteOptions } from "./updateOptions.js";
+import { ENCODE_NAME_PREFIX, decodeName } from "@module-federation/sdk";
+
+//#region src/remotes.ts
+function remotes(options) {
+	updateRemoteOptions(options);
+	const { chunkId, promises, webpackRequire, chunkMapping, idToExternalAndNameMapping, idToRemoteMap } = options;
+	attachShareScopeMap(webpackRequire);
+	if (webpackRequire.o(chunkMapping, chunkId)) chunkMapping[chunkId].forEach((id) => {
+		let getScope = webpackRequire.R;
+		if (!getScope) getScope = [];
+		const data = idToExternalAndNameMapping[id];
+		const remoteInfos = idToRemoteMap[id] || [];
+		if (getScope.indexOf(data) >= 0) return;
+		getScope.push(data);
+		if (data.p) return promises.push(data.p);
+		const onError = (error) => {
+			if (!error) error = /* @__PURE__ */ new Error("Container missing");
+			if (typeof error.message === "string") error.message += `\nwhile loading "${data[1]}" from ${data[2]}`;
+			webpackRequire.m[id] = () => {
+				throw error;
+			};
+			data.p = 0;
+		};
+		const handleFunction = (fn, arg1, arg2, d, next, first) => {
+			try {
+				const promise = fn(arg1, arg2);
+				if (promise && promise.then) {
+					const p = promise.then((result) => next(result, d), onError);
+					if (first) promises.push(data.p = p);
+					else return p;
+				} else return next(promise, d, first);
+			} catch (error) {
+				onError(error);
+			}
+		};
+		const onExternal = (external, _, first) => external ? handleFunction(webpackRequire.I, data[0], 0, external, onInitialized, first) : onError();
+		var onInitialized = (_, external, first) => handleFunction(external.get, data[1], getScope, 0, onFactory, first);
+		var onFactory = (factory) => {
+			data.p = 1;
+			webpackRequire.m[id] = (module) => {
+				module.exports = factory();
+			};
+		};
+		const onRemoteLoaded = () => {
+			try {
+				const remoteModuleName = decodeName(remoteInfos[0].name, ENCODE_NAME_PREFIX) + data[1].slice(1);
+				const instance = webpackRequire.federation.instance;
+				const loadRemote = () => webpackRequire.federation.instance.loadRemote(remoteModuleName, {
+					loadFactory: false,
+					from: "build"
+				});
+				if (instance.options.shareStrategy === "version-first") {
+					const shareScopes = Array.isArray(data[0]) ? data[0] : [data[0]];
+					return Promise.all(shareScopes.map((shareScope) => instance.sharedHandler.initializeSharing(shareScope))).then(() => {
+						return loadRemote();
+					});
+				}
+				return loadRemote();
+			} catch (error) {
+				onError(error);
+			}
+		};
+		if (remoteInfos.length === 1 && FEDERATION_SUPPORTED_TYPES.includes(remoteInfos[0].externalType) && remoteInfos[0].name) handleFunction(onRemoteLoaded, data[2], 0, 0, onFactory, 1);
+		else handleFunction(webpackRequire, data[2], 0, 0, onExternal, 1);
+	});
+}
+
+//#endregion
+export { remotes };
+//# sourceMappingURL=remotes.js.map

package/dist/remotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remotes.js","names":[],"sources":["../src/remotes.ts"],"sourcesContent":["import { attachShareScopeMap } from './attachShareScopeMap';\nimport type { RemoteEntryExports } from './types';\nimport { RemotesOptions } from './types';\nimport { FEDERATION_SUPPORTED_TYPES } from './constant';\nimport { decodeName, ENCODE_NAME_PREFIX } from '@module-federation/sdk';\nimport { updateRemoteOptions } from './updateOptions';\n\nexport function remotes(options: RemotesOptions) {\n  updateRemoteOptions(options);\n\n  const {\n    chunkId,\n    promises,\n    webpackRequire,\n    chunkMapping,\n    idToExternalAndNameMapping,\n    idToRemoteMap,\n  } = options;\n  attachShareScopeMap(webpackRequire);\n\n  if (webpackRequire.o(chunkMapping, chunkId)) {\n    chunkMapping[chunkId].forEach((id) => {\n      let getScope = webpackRequire.R;\n      if (!getScope) {\n        getScope = [];\n      }\n      const data = idToExternalAndNameMapping[id];\n      const remoteInfos = idToRemoteMap[id] || [];\n      // @ts-ignore seems not work\n      if (getScope.indexOf(data) >= 0) {\n        return;\n      }\n      // @ts-ignore seems not work\n      getScope.push(data);\n      if (data.p) {\n        return promises.push(data.p as Promise<any>);\n      }\n      const onError = (error?: Error) => {\n        if (!error) {\n          error = new Error('Container missing');\n        }\n        if (typeof error.message === 'string') {\n          error.message += `\\nwhile loading \"${data[1]}\" from ${data[2]}`;\n        }\n        webpackRequire.m[id] = () => {\n          throw error;\n        };\n        data.p = 0;\n      };\n      const handleFunction = (\n        fn: (...args: any[]) => any,\n        arg1: any,\n        arg2: any,\n        d: any,\n        next: (...args: any[]) => any,\n        first: 1 | 0,\n      ) => {\n        try {\n          const promise = fn(arg1, arg2);\n          if (promise && promise.then) {\n            const p = promise.then((result: any) => next(result, d), onError);\n            if (first) {\n              promises.push((data.p = p));\n            } else {\n              return p;\n            }\n          } else {\n            return next(promise, d, first);\n          }\n        } catch (error) {\n          onError(error as Error);\n        }\n      };\n      const onExternal = (\n        external: (...args: any[]) => any,\n        _: any,\n        first: 1 | 0,\n      ) =>\n        external\n          ? handleFunction(\n              webpackRequire.I,\n              data[0],\n              0,\n              external,\n              onInitialized,\n              first,\n            )\n          : onError();\n\n      // eslint-disable-next-line no-var\n      var onInitialized = (\n        _: any,\n        external: RemoteEntryExports,\n        first: 1 | 0,\n      ) => handleFunction(external.get, data[1], getScope, 0, onFactory, first);\n      // eslint-disable-next-line no-var\n      var onFactory = (factory: () => any) => {\n        data.p = 1;\n        webpackRequire.m[id] = (module) => {\n          module.exports = factory();\n        };\n      };\n      const onRemoteLoaded = () => {\n        try {\n          const remoteName = decodeName(\n            remoteInfos[0].name,\n            ENCODE_NAME_PREFIX,\n          );\n\n          const remoteModuleName = remoteName + data[1].slice(1);\n          const instance = webpackRequire.federation.instance!;\n          const loadRemote = () =>\n            webpackRequire.federation.instance!.loadRemote(remoteModuleName, {\n              loadFactory: false,\n              from: 'build',\n            });\n\n          if (instance.options.shareStrategy === 'version-first') {\n            const shareScopes = Array.isArray(data[0]) ? data[0] : [data[0]];\n\n            return Promise.all(\n              shareScopes.map((shareScope) =>\n                instance.sharedHandler.initializeSharing(shareScope),\n              ),\n            ).then(() => {\n              return loadRemote();\n            });\n          }\n\n          return loadRemote();\n        } catch (error) {\n          onError(error as Error);\n        }\n      };\n\n      const useRuntimeLoad =\n        remoteInfos.length === 1 &&\n        FEDERATION_SUPPORTED_TYPES.includes(remoteInfos[0].externalType) &&\n        remoteInfos[0].name;\n\n      if (useRuntimeLoad) {\n        handleFunction(onRemoteLoaded, data[2], 0, 0, onFactory, 1);\n      } else {\n        handleFunction(webpackRequire, data[2], 0, 0, onExternal, 1);\n      }\n    });\n  }\n}\n"],"mappings":";;;;;;AAOA,SAAgB,QAAQ,SAAyB;AAC/C,qBAAoB,QAAQ;CAE5B,MAAM,EACJ,SACA,UACA,gBACA,cACA,4BACA,kBACE;AACJ,qBAAoB,eAAe;AAEnC,KAAI,eAAe,EAAE,cAAc,QAAQ,CACzC,cAAa,SAAS,SAAS,OAAO;EACpC,IAAI,WAAW,eAAe;AAC9B,MAAI,CAAC,SACH,YAAW,EAAE;EAEf,MAAM,OAAO,2BAA2B;EACxC,MAAM,cAAc,cAAc,OAAO,EAAE;AAE3C,MAAI,SAAS,QAAQ,KAAK,IAAI,EAC5B;AAGF,WAAS,KAAK,KAAK;AACnB,MAAI,KAAK,EACP,QAAO,SAAS,KAAK,KAAK,EAAkB;EAE9C,MAAM,WAAW,UAAkB;AACjC,OAAI,CAAC,MACH,yBAAQ,IAAI,MAAM,oBAAoB;AAExC,OAAI,OAAO,MAAM,YAAY,SAC3B,OAAM,WAAW,oBAAoB,KAAK,GAAG,SAAS,KAAK;AAE7D,kBAAe,EAAE,YAAY;AAC3B,UAAM;;AAER,QAAK,IAAI;;EAEX,MAAM,kBACJ,IACA,MACA,MACA,GACA,MACA,UACG;AACH,OAAI;IACF,MAAM,UAAU,GAAG,MAAM,KAAK;AAC9B,QAAI,WAAW,QAAQ,MAAM;KAC3B,MAAM,IAAI,QAAQ,MAAM,WAAgB,KAAK,QAAQ,EAAE,EAAE,QAAQ;AACjE,SAAI,MACF,UAAS,KAAM,KAAK,IAAI,EAAG;SAE3B,QAAO;UAGT,QAAO,KAAK,SAAS,GAAG,MAAM;YAEzB,OAAO;AACd,YAAQ,MAAe;;;EAG3B,MAAM,cACJ,UACA,GACA,UAEA,WACI,eACE,eAAe,GACf,KAAK,IACL,GACA,UACA,eACA,MACD,GACD,SAAS;EAGf,IAAI,iBACF,GACA,UACA,UACG,eAAe,SAAS,KAAK,KAAK,IAAI,UAAU,GAAG,WAAW,MAAM;EAEzE,IAAI,aAAa,YAAuB;AACtC,QAAK,IAAI;AACT,kBAAe,EAAE,OAAO,WAAW;AACjC,WAAO,UAAU,SAAS;;;EAG9B,MAAM,uBAAuB;AAC3B,OAAI;IAMF,MAAM,mBALa,WACjB,YAAY,GAAG,MACf,mBACD,GAEqC,KAAK,GAAG,MAAM,EAAE;IACtD,MAAM,WAAW,eAAe,WAAW;IAC3C,MAAM,mBACJ,eAAe,WAAW,SAAU,WAAW,kBAAkB;KAC/D,aAAa;KACb,MAAM;KACP,CAAC;AAEJ,QAAI,SAAS,QAAQ,kBAAkB,iBAAiB;KACtD,MAAM,cAAc,MAAM,QAAQ,KAAK,GAAG,GAAG,KAAK,KAAK,CAAC,KAAK,GAAG;AAEhE,YAAO,QAAQ,IACb,YAAY,KAAK,eACf,SAAS,cAAc,kBAAkB,WAAW,CACrD,CACF,CAAC,WAAW;AACX,aAAO,YAAY;OACnB;;AAGJ,WAAO,YAAY;YACZ,OAAO;AACd,YAAQ,MAAe;;;AAS3B,MAJE,YAAY,WAAW,KACvB,2BAA2B,SAAS,YAAY,GAAG,aAAa,IAChE,YAAY,GAAG,KAGf,gBAAe,gBAAgB,KAAK,IAAI,GAAG,GAAG,WAAW,EAAE;MAE3D,gBAAe,gBAAgB,KAAK,IAAI,GAAG,GAAG,YAAY,EAAE;GAE9D"}

package/dist/runtime-core/dist/core.d.ts

@@ -0,0 +1,130 @@
+import { SyncHook } from "./utils/hooks/syncHook.js";
+import { AsyncHook } from "./utils/hooks/asyncHook.js";
+import { SyncWaterfallHook } from "./utils/hooks/syncWaterfallHook.js";
+import { AsyncWaterfallHook } from "./utils/hooks/asyncWaterfallHooks.js";
+import { PluginSystem } from "./utils/hooks/pluginSystem.js";
+import { CallFrom, InitScope, Options, Remote, RemoteEntryExports, RemoteEntryInitOptions, RemoteInfo, ShareInfos, ShareScopeMap, Shared, UserOptions } from "./type/config.js";
+import { PreloadRemoteArgs } from "./type/preload.js";
+import { RemoteHandler } from "./remote/index.js";
+import { SharedHandler } from "./shared/index.js";
+import { SnapshotHandler } from "./plugins/snapshot/SnapshotHandler.js";
+import { getRemoteEntry } from "./utils/load.js";
+import { Module$1 } from "./module/index.js";
+import { CreateScriptHookReturn, GlobalModuleInfo, ModuleInfo } from "@module-federation/sdk";
+
+//#region ../runtime-core/dist/core.d.ts
+//#region src/core.d.ts
+declare class ModuleFederation {
+  options: Options;
+  hooks: PluginSystem<{
+    beforeInit: SyncWaterfallHook<{
+      userOptions: UserOptions;
+      options: Options;
+      origin: ModuleFederation;
+      /**
+       * @deprecated shareInfo will be removed soon, please use userOptions directly!
+       */
+      shareInfo: ShareInfos;
+    }>;
+    init: SyncHook<[{
+      options: Options;
+      origin: ModuleFederation;
+    }], void>;
+    beforeInitContainer: AsyncWaterfallHook<{
+      shareScope: ShareScopeMap[string];
+      initScope: InitScope;
+      remoteEntryInitOptions: RemoteEntryInitOptions;
+      remoteInfo: RemoteInfo;
+      origin: ModuleFederation;
+    }>;
+    initContainer: AsyncWaterfallHook<{
+      shareScope: ShareScopeMap[string];
+      initScope: InitScope;
+      remoteEntryInitOptions: RemoteEntryInitOptions;
+      remoteInfo: RemoteInfo;
+      remoteEntryExports: RemoteEntryExports;
+      origin: ModuleFederation;
+      id?: string;
+      remoteSnapshot?: ModuleInfo;
+    }>;
+  }>;
+  version: string;
+  name: string;
+  moduleCache: Map<string, Module$1>;
+  snapshotHandler: SnapshotHandler;
+  sharedHandler: SharedHandler;
+  remoteHandler: RemoteHandler;
+  shareScopeMap: ShareScopeMap;
+  loaderHook: PluginSystem<{
+    getModuleInfo: SyncHook<[{
+      target: Record<string, any>;
+      key: any;
+    }], void | {
+      value: any | undefined;
+      key: string;
+    }>;
+    createScript: SyncHook<[{
+      url: string;
+      attrs?: Record<string, any>;
+    }], CreateScriptHookReturn>;
+    createLink: SyncHook<[{
+      url: string;
+      attrs?: Record<string, any>;
+    }], void | HTMLLinkElement>;
+    fetch: AsyncHook<[string, RequestInit], false | void | Promise<Response>>;
+    loadEntryError: AsyncHook<[{
+      getRemoteEntry: typeof getRemoteEntry;
+      origin: ModuleFederation;
+      remoteInfo: RemoteInfo;
+      remoteEntryExports?: RemoteEntryExports | undefined;
+      globalLoading: Record<string, Promise<void | RemoteEntryExports> | undefined>;
+      uniqueKey: string;
+    }], Promise<Promise<RemoteEntryExports | undefined> | undefined>>;
+    getModuleFactory: AsyncHook<[{
+      remoteEntryExports: RemoteEntryExports;
+      expose: string;
+      moduleInfo: RemoteInfo;
+    }], Promise<(() => Promise<Module$1>) | undefined>>;
+  }>;
+  bridgeHook: PluginSystem<{
+    beforeBridgeRender: SyncHook<[Record<string, any>], void | Record<string, any>>;
+    afterBridgeRender: SyncHook<[Record<string, any>], void | Record<string, any>>;
+    beforeBridgeDestroy: SyncHook<[Record<string, any>], void | Record<string, any>>;
+    afterBridgeDestroy: SyncHook<[Record<string, any>], void | Record<string, any>>;
+  }>;
+  moduleInfo?: GlobalModuleInfo[string];
+  constructor(userOptions: UserOptions);
+  initOptions(userOptions: UserOptions): Options;
+  loadShare<T>(pkgName: string, extraOptions?: {
+    customShareInfo?: Partial<Shared>;
+    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
+  }): Promise<false | (() => T | undefined)>;
+  loadShareSync<T>(pkgName: string, extraOptions?: {
+    customShareInfo?: Partial<Shared>;
+    from?: 'build' | 'runtime';
+    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
+  }): () => T | never;
+  initializeSharing(shareScopeName?: string, extraOptions?: {
+    initScope?: InitScope;
+    from?: CallFrom;
+    strategy?: Shared['strategy'];
+  }): Array<Promise<void>>;
+  initRawContainer(name: string, url: string, container: RemoteEntryExports): Module$1;
+  loadRemote<T>(id: string, options?: {
+    loadFactory?: boolean;
+    from: CallFrom;
+  }): Promise<T | null>;
+  preloadRemote(preloadOptions: Array<PreloadRemoteArgs>): Promise<void>;
+  initShareScopeMap(scopeName: string, shareScope: ShareScopeMap[string], extraOptions?: {
+    hostShareScopeMap?: ShareScopeMap;
+  }): void;
+  formatOptions(globalOptions: Options, userOptions: UserOptions): Options;
+  registerPlugins(plugins: UserOptions['plugins']): void;
+  registerRemotes(remotes: Remote[], options?: {
+    force?: boolean;
+  }): void;
+  registerShared(shared: UserOptions['shared']): void;
+} //#endregion
+//#endregion
+export { ModuleFederation };
+//# sourceMappingURL=core.d.ts.map

package/dist/runtime-core/dist/global.d.ts

@@ -0,0 +1,24 @@
+import { GlobalShareScopeMap, RemoteEntryExports } from "./type/config.js";
+import { ModuleFederationRuntimePlugin } from "./type/plugin.js";
+import { ModuleFederation } from "./core.js";
+import { GlobalModuleInfo, ModuleInfo } from "@module-federation/sdk";
+
+//#region ../runtime-core/dist/global.d.ts
+//#region src/global.d.ts
+interface Federation {
+  __GLOBAL_PLUGIN__: Array<ModuleFederationRuntimePlugin>;
+  __DEBUG_CONSTRUCTOR_VERSION__?: string;
+  moduleInfo: GlobalModuleInfo;
+  __DEBUG_CONSTRUCTOR__?: typeof ModuleFederation;
+  __INSTANCES__: Array<ModuleFederation>;
+  __SHARE__: GlobalShareScopeMap;
+  __MANIFEST_LOADING__: Record<string, Promise<ModuleInfo>>;
+  __PRELOADED_MAP__: Map<string, boolean>;
+}
+declare global {
+  var __FEDERATION__: Federation, __VMOK__: Federation, __GLOBAL_LOADING_REMOTE_ENTRY__: Record<string, undefined | Promise<RemoteEntryExports | void>>;
+}
+declare const getGlobalSnapshot: () => GlobalModuleInfo;
+//#endregion
+export { Federation, getGlobalSnapshot };
+//# sourceMappingURL=global.d.ts.map

package/dist/runtime-core/dist/helpers.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/runtime-core/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { UserOptions } from "./type/config.js";
+import { ModuleFederationRuntimePlugin } from "./type/plugin.js";
+import { Federation, getGlobalSnapshot } from "./global.js";
+import { getRemoteEntry } from "./utils/load.js";
+import { ModuleFederation } from "./core.js";
+import { Module$1 } from "./module/index.js";

package/dist/runtime-core/dist/module/index.d.ts

@@ -0,0 +1,32 @@
+import { InitScope, RemoteEntryExports, RemoteInfo } from "../type/config.js";
+import { ModuleFederation } from "../core.js";
+import { ModuleInfo } from "@module-federation/sdk";
+
+//#region ../runtime-core/dist/module/index.d.ts
+//#region src/module/index.d.ts
+type ModuleOptions = ConstructorParameters<typeof Module$1>[0];
+declare class Module$1 {
+  remoteInfo: RemoteInfo;
+  inited: boolean;
+  initing: boolean;
+  initPromise?: Promise<void>;
+  remoteEntryExports?: RemoteEntryExports;
+  lib: RemoteEntryExports | undefined;
+  host: ModuleFederation;
+  constructor({
+    remoteInfo,
+    host
+  }: {
+    remoteInfo: RemoteInfo;
+    host: ModuleFederation;
+  });
+  getEntry(): Promise<RemoteEntryExports>;
+  init(id?: string, remoteSnapshot?: ModuleInfo, rawInitScope?: InitScope): Promise<RemoteEntryExports>;
+  get(id: string, expose: string, options?: {
+    loadFactory?: boolean;
+  }, remoteSnapshot?: ModuleInfo): Promise<any>;
+  private wraperFactory;
+} //#endregion
+//#endregion
+export { Module$1, ModuleOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime-core/dist/plugins/snapshot/SnapshotHandler.d.ts

@@ -0,0 +1,67 @@
+import { AsyncHook } from "../../utils/hooks/asyncHook.js";
+import { AsyncWaterfallHook } from "../../utils/hooks/asyncWaterfallHooks.js";
+import { PluginSystem } from "../../utils/hooks/pluginSystem.js";
+import { Options, Remote } from "../../type/config.js";
+import { getGlobalSnapshot } from "../../global.js";
+import { ModuleFederation } from "../../core.js";
+import { GlobalModuleInfo, Manifest, ModuleInfo } from "@module-federation/sdk";
+
+//#region ../runtime-core/dist/plugins/snapshot/SnapshotHandler.d.ts
+//#region src/plugins/snapshot/SnapshotHandler.d.ts
+declare class SnapshotHandler {
+  loadingHostSnapshot: Promise<GlobalModuleInfo | void> | null;
+  HostInstance: ModuleFederation;
+  manifestCache: Map<string, Manifest>;
+  hooks: PluginSystem<{
+    beforeLoadRemoteSnapshot: AsyncHook<[{
+      options: Options;
+      moduleInfo: Remote;
+    }], void>;
+    loadSnapshot: AsyncWaterfallHook<{
+      options: Options;
+      moduleInfo: Remote;
+      hostGlobalSnapshot: GlobalModuleInfo[string] | undefined;
+      globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
+      remoteSnapshot?: GlobalModuleInfo[string] | undefined;
+    }>;
+    loadRemoteSnapshot: AsyncWaterfallHook<{
+      options: Options;
+      moduleInfo: Remote;
+      manifestJson?: Manifest;
+      manifestUrl?: string;
+      remoteSnapshot: ModuleInfo;
+      from: "global" | "manifest";
+    }>;
+    afterLoadSnapshot: AsyncWaterfallHook<{
+      id?: string;
+      host: ModuleFederation;
+      options: Options;
+      moduleInfo: Remote;
+      remoteSnapshot: ModuleInfo;
+    }>;
+  }>;
+  loaderHook: ModuleFederation['loaderHook'];
+  manifestLoading: Record<string, Promise<ModuleInfo>>;
+  constructor(HostInstance: ModuleFederation);
+  loadRemoteSnapshotInfo({
+    moduleInfo,
+    id,
+    expose
+  }: {
+    moduleInfo: Remote;
+    id?: string;
+    expose?: string;
+  }): Promise<{
+    remoteSnapshot: ModuleInfo;
+    globalSnapshot: GlobalModuleInfo;
+  }> | never;
+  getGlobalRemoteInfo(moduleInfo: Remote): {
+    hostGlobalSnapshot: ModuleInfo | undefined;
+    globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
+    remoteSnapshot: GlobalModuleInfo[string] | undefined;
+  };
+  private getManifestJson;
+} //#endregion
+//#endregion
+export { SnapshotHandler };
+//# sourceMappingURL=SnapshotHandler.d.ts.map

package/dist/runtime-core/dist/remote/index.d.ts

@@ -0,0 +1,120 @@
+import { SyncHook } from "../utils/hooks/syncHook.js";
+import { AsyncHook } from "../utils/hooks/asyncHook.js";
+import { SyncWaterfallHook } from "../utils/hooks/syncWaterfallHook.js";
+import { AsyncWaterfallHook } from "../utils/hooks/asyncWaterfallHooks.js";
+import { PluginSystem } from "../utils/hooks/pluginSystem.js";
+import { CallFrom, Options, Remote, RemoteEntryExports, RemoteInfo, UserOptions } from "../type/config.js";
+import { PreloadAssets, PreloadOptions, PreloadRemoteArgs } from "../type/preload.js";
+import { ModuleFederation } from "../core.js";
+import { Module$1, ModuleOptions } from "../module/index.js";
+import { GlobalModuleInfo, ModuleInfo } from "@module-federation/sdk";
+
+//#region ../runtime-core/dist/remote/index.d.ts
+//#region src/remote/index.d.ts
+interface LoadRemoteMatch {
+  id: string;
+  pkgNameOrAlias: string;
+  expose: string;
+  remote: Remote;
+  options: Options;
+  origin: ModuleFederation;
+  remoteInfo: RemoteInfo;
+  remoteSnapshot?: ModuleInfo;
+}
+declare class RemoteHandler {
+  host: ModuleFederation;
+  idToRemoteMap: Record<string, {
+    name: string;
+    expose: string;
+  }>;
+  hooks: PluginSystem<{
+    beforeRegisterRemote: SyncWaterfallHook<{
+      remote: Remote;
+      origin: ModuleFederation;
+    }>;
+    registerRemote: SyncWaterfallHook<{
+      remote: Remote;
+      origin: ModuleFederation;
+    }>;
+    beforeRequest: AsyncWaterfallHook<{
+      id: string;
+      options: Options;
+      origin: ModuleFederation;
+    }>;
+    onLoad: AsyncHook<[{
+      id: string;
+      expose: string;
+      pkgNameOrAlias: string;
+      remote: Remote;
+      options: ModuleOptions;
+      origin: ModuleFederation;
+      exposeModule: any;
+      exposeModuleFactory: any;
+      moduleInstance: Module$1;
+    }], void>;
+    handlePreloadModule: SyncHook<[{
+      id: string;
+      name: string;
+      remote: Remote;
+      remoteSnapshot: ModuleInfo;
+      preloadConfig: PreloadRemoteArgs;
+      origin: ModuleFederation;
+    }], void>;
+    errorLoadRemote: AsyncHook<[{
+      id: string;
+      error: unknown;
+      options?: any;
+      from: CallFrom;
+      lifecycle: "beforeRequest" | "beforeLoadShare" | "afterResolve" | "onLoad";
+      origin: ModuleFederation;
+    }], unknown>;
+    beforePreloadRemote: AsyncHook<[{
+      preloadOps: Array<PreloadRemoteArgs>;
+      options: Options;
+      origin: ModuleFederation;
+    }], false | void | Promise<false | void>>;
+    generatePreloadAssets: AsyncHook<[{
+      origin: ModuleFederation;
+      preloadOptions: PreloadOptions[number];
+      remote: Remote;
+      remoteInfo: RemoteInfo;
+      remoteSnapshot: ModuleInfo;
+      globalSnapshot: GlobalModuleInfo;
+    }], Promise<PreloadAssets>>;
+    afterPreloadRemote: AsyncHook<{
+      preloadOps: Array<PreloadRemoteArgs>;
+      options: Options;
+      origin: ModuleFederation;
+    }, false | void | Promise<false | void>>;
+    loadEntry: AsyncHook<[{
+      loaderHook: ModuleFederation["loaderHook"];
+      remoteInfo: RemoteInfo;
+      remoteEntryExports?: RemoteEntryExports;
+    }], Promise<RemoteEntryExports>>;
+  }>;
+  constructor(host: ModuleFederation);
+  formatAndRegisterRemote(globalOptions: Options, userOptions: UserOptions): Remote[];
+  setIdToRemoteMap(id: string, remoteMatchInfo: LoadRemoteMatch): void;
+  loadRemote<T>(id: string, options?: {
+    loadFactory?: boolean;
+    from: CallFrom;
+  }): Promise<T | null>;
+  preloadRemote(preloadOptions: Array<PreloadRemoteArgs>): Promise<void>;
+  registerRemotes(remotes: Remote[], options?: {
+    force?: boolean;
+  }): void;
+  getRemoteModuleAndOptions(options: {
+    id: string;
+  }): Promise<{
+    module: Module$1;
+    moduleOptions: ModuleOptions;
+    remoteMatchInfo: LoadRemoteMatch;
+  }>;
+  registerRemote(remote: Remote, targetRemotes: Remote[], options?: {
+    force?: boolean;
+  }): void;
+  private removeRemote;
+} //#endregion
+//#endregion
+export { LoadRemoteMatch, RemoteHandler };
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime-core/dist/shared/index.d.ts

@@ -0,0 +1,84 @@
+import { AsyncHook } from "../utils/hooks/asyncHook.js";
+import { SyncWaterfallHook } from "../utils/hooks/syncWaterfallHook.js";
+import { AsyncWaterfallHook } from "../utils/hooks/asyncWaterfallHooks.js";
+import { PluginSystem } from "../utils/hooks/pluginSystem.js";
+import { CallFrom, InitScope, InitTokens, Options, ShareInfos, ShareScopeMap, ShareStrategy, Shared, UserOptions } from "../type/config.js";
+import { LoadRemoteMatch } from "../remote/index.js";
+import { Federation } from "../global.js";
+import { ModuleFederation } from "../core.js";
+
+//#region ../runtime-core/dist/shared/index.d.ts
+//#region src/shared/index.d.ts
+declare class SharedHandler {
+  host: ModuleFederation;
+  shareScopeMap: ShareScopeMap;
+  hooks: PluginSystem<{
+    beforeRegisterShare: SyncWaterfallHook<{
+      pkgName: string;
+      shared: Shared;
+      origin: ModuleFederation;
+    }>;
+    afterResolve: AsyncWaterfallHook<LoadRemoteMatch>;
+    beforeLoadShare: AsyncWaterfallHook<{
+      pkgName: string;
+      shareInfo?: Shared;
+      shared: Options["shared"];
+      origin: ModuleFederation;
+    }>;
+    loadShare: AsyncHook<[ModuleFederation, string, ShareInfos], false | void | Promise<false | void>>;
+    resolveShare: SyncWaterfallHook<{
+      shareScopeMap: ShareScopeMap;
+      scope: string;
+      pkgName: string;
+      version: string;
+      shareInfo: Shared;
+      GlobalFederation: Federation;
+      resolver: () => {
+        shared: Shared;
+        useTreesShaking: boolean;
+      } | undefined;
+    }>;
+    initContainerShareScopeMap: SyncWaterfallHook<{
+      shareScope: ShareScopeMap[string];
+      options: Options;
+      origin: ModuleFederation;
+      scopeName: string;
+      hostShareScopeMap?: ShareScopeMap;
+    }>;
+  }>;
+  initTokens: InitTokens;
+  constructor(host: ModuleFederation);
+  registerShared(globalOptions: Options, userOptions: UserOptions): {
+    newShareInfos: ShareInfos;
+    allShareInfos: {
+      [pkgName: string]: Shared[];
+    };
+  };
+  loadShare<T>(pkgName: string, extraOptions?: {
+    customShareInfo?: Partial<Shared>;
+    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
+  }): Promise<false | (() => T | undefined)>;
+  /**
+   * This function initializes the sharing sequence (executed only once per share scope).
+   * It accepts one argument, the name of the share scope.
+   * If the share scope does not exist, it creates one.
+   */
+  initializeSharing(shareScopeName?: string, extraOptions?: {
+    initScope?: InitScope;
+    from?: CallFrom;
+    strategy?: ShareStrategy;
+  }): Array<Promise<void>>;
+  loadShareSync<T>(pkgName: string, extraOptions?: {
+    from?: 'build' | 'runtime';
+    customShareInfo?: Partial<Shared>;
+    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
+  }): () => T | never;
+  initShareScopeMap(scopeName: string, shareScope: ShareScopeMap[string], extraOptions?: {
+    hostShareScopeMap?: ShareScopeMap;
+  }): void;
+  private setShared;
+  private _setGlobalShareScopeMap;
+} //#endregion
+//#endregion
+export { SharedHandler };
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime-core/dist/type/config.d.ts

@@ -0,0 +1,117 @@
+import { ModuleFederationRuntimePlugin } from "./plugin.js";
+import { Module, RemoteEntryType, RemoteWithEntry, RemoteWithVersion, TreeShakingStatus } from "@module-federation/sdk";
+
+//#region ../runtime-core/dist/type/config.d.ts
+//#region src/type/config.d.ts
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+interface RemoteInfoCommon {
+  alias?: string;
+  shareScope?: string | string[];
+  type?: RemoteEntryType;
+  entryGlobalName?: string;
+}
+type Remote = (RemoteWithEntry | RemoteWithVersion) & RemoteInfoCommon;
+interface RemoteInfo {
+  alias?: string;
+  name: string;
+  version?: string;
+  buildVersion?: string;
+  entry: string;
+  type: RemoteEntryType;
+  entryGlobalName: string;
+  shareScope: string | string[];
+}
+interface SharedConfig {
+  singleton?: boolean;
+  requiredVersion: false | string;
+  eager?: boolean;
+  strictVersion?: boolean;
+  layer?: string | null;
+}
+type TreeShakingArgs = {
+  usedExports?: string[];
+  get?: SharedGetter;
+  lib?: () => Module;
+  status?: TreeShakingStatus;
+  mode?: 'server-calc' | 'runtime-infer';
+  loading?: null | Promise<any>;
+  loaded?: boolean;
+  useIn?: Array<string>;
+};
+type SharedBaseArgs = {
+  version?: string;
+  shareConfig?: SharedConfig;
+  scope?: string | Array<string>;
+  deps?: Array<string>;
+  strategy?: 'version-first' | 'loaded-first';
+  loaded?: boolean;
+  treeShaking?: TreeShakingArgs;
+};
+type SharedGetter = (() => () => Module) | (() => Promise<() => Module>);
+type ShareArgs = (SharedBaseArgs & {
+  get: SharedGetter;
+}) | (SharedBaseArgs & {
+  lib: () => Module;
+}) | SharedBaseArgs;
+type ShareStrategy = 'version-first' | 'loaded-first';
+type Shared = {
+  version: string;
+  get: SharedGetter;
+  shareConfig: SharedConfig;
+  scope: Array<string>;
+  useIn: Array<string>;
+  from: string;
+  deps: Array<string>;
+  lib?: () => Module;
+  loaded?: boolean;
+  loading?: null | Promise<any>;
+  eager?: boolean;
+  /**
+   * @deprecated set in initOptions.shareStrategy instead
+   */
+  strategy: ShareStrategy;
+  treeShaking?: TreeShakingArgs;
+};
+type ShareScopeMap = {
+  [scope: string]: {
+    [pkgName: string]: {
+      [sharedVersion: string]: Shared;
+    };
+  };
+};
+type GlobalShareScopeMap = {
+  [instanceName: string]: ShareScopeMap;
+};
+type ShareInfos = {
+  [pkgName: string]: Shared[];
+};
+interface Options {
+  id?: string;
+  name: string;
+  version?: string;
+  remotes: Array<Remote>;
+  shared: ShareInfos;
+  plugins: Array<ModuleFederationRuntimePlugin>;
+  inBrowser: boolean;
+  shareStrategy?: ShareStrategy;
+}
+type UserOptions = Omit<Optional<Options, 'plugins'>, 'shared' | 'inBrowser'> & {
+  shared?: {
+    [pkgName: string]: ShareArgs | ShareArgs[];
+  };
+};
+type RemoteEntryInitOptions = {
+  version: string;
+  shareScopeMap?: ShareScopeMap;
+  shareScopeKeys: string | string[];
+};
+type InitTokens = Record<string, Record<string, any>>;
+type InitScope = InitTokens[];
+type CallFrom = 'build' | 'runtime';
+type RemoteEntryExports = {
+  get: (id: string) => () => Promise<Module>;
+  init: (shareScope: ShareScopeMap[string], initScope?: InitScope, remoteEntryInitOPtions?: RemoteEntryInitOptions) => void | Promise<void>;
+}; //#endregion
+//#endregion
+export { CallFrom, GlobalShareScopeMap, InitScope, InitTokens, Optional, Options, Remote, RemoteEntryExports, RemoteEntryInitOptions, RemoteInfo, RemoteInfoCommon, ShareArgs, ShareInfos, ShareScopeMap, ShareStrategy, Shared, SharedConfig, SharedGetter, TreeShakingArgs, UserOptions };
+//# sourceMappingURL=config.d.ts.map

package/dist/runtime-core/dist/type/index.d.ts

@@ -0,0 +1 @@
+export { };