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

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,3 @@
+import "./config.js";
+import "./preload.js";
+import "./plugin.js";

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

@@ -0,0 +1,28 @@
+import { RemoteHandler } from "../remote/index.js";
+import { SharedHandler } from "../shared/index.js";
+import { SnapshotHandler } from "../plugins/snapshot/SnapshotHandler.js";
+import { ModuleFederation } from "../core.js";
+import { Module$1 } from "../module/index.js";
+
+//#region ../runtime-core/dist/type/plugin.d.ts
+//#region src/type/plugin.d.ts
+type CoreLifeCycle = ModuleFederation['hooks']['lifecycle'];
+type CoreLifeCyclePartial = Partial<{ [k in keyof CoreLifeCycle]: Parameters<CoreLifeCycle[k]['on']>[0] }>;
+type SnapshotLifeCycle = SnapshotHandler['hooks']['lifecycle'];
+type SnapshotLifeCycleCyclePartial = Partial<{ [k in keyof SnapshotLifeCycle]: Parameters<SnapshotLifeCycle[k]['on']>[0] }>;
+type ModuleLifeCycle = Module$1['host']['loaderHook']['lifecycle'];
+type ModuleLifeCycleCyclePartial = Partial<{ [k in keyof ModuleLifeCycle]: Parameters<ModuleLifeCycle[k]['on']>[0] }>;
+type ModuleBridgeLifeCycle = Module$1['host']['bridgeHook']['lifecycle'];
+type ModuleBridgeLifeCycleCyclePartial = Partial<{ [k in keyof ModuleBridgeLifeCycle]: Parameters<ModuleBridgeLifeCycle[k]['on']>[0] }>;
+type SharedLifeCycle = SharedHandler['hooks']['lifecycle'];
+type SharedLifeCycleCyclePartial = Partial<{ [k in keyof SharedLifeCycle]: Parameters<SharedLifeCycle[k]['on']>[0] }>;
+type RemoteLifeCycle = RemoteHandler['hooks']['lifecycle'];
+type RemoteLifeCycleCyclePartial = Partial<{ [k in keyof RemoteLifeCycle]: Parameters<RemoteLifeCycle[k]['on']>[0] }>;
+type ModuleFederationRuntimePlugin = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & SharedLifeCycleCyclePartial & RemoteLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & ModuleBridgeLifeCycleCyclePartial & {
+  name: string;
+  version?: string;
+  apply?: (instance: ModuleFederation) => void;
+}; //#endregion
+//#endregion
+export { ModuleFederationRuntimePlugin };
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1,32 @@
+import { Remote, RemoteInfo } from "./config.js";
+
+//#region ../runtime-core/dist/type/preload.d.ts
+//#region src/type/preload.d.ts
+type depsPreloadArg = Omit<PreloadRemoteArgs, 'depsRemote'>;
+interface PreloadRemoteArgs {
+  nameOrAlias: string;
+  exposes?: Array<string>;
+  resourceCategory?: 'all' | 'sync';
+  share?: boolean;
+  depsRemote?: boolean | Array<depsPreloadArg>;
+  filter?: (assetUrl: string) => boolean;
+  prefetchInterface?: boolean;
+}
+type PreloadConfig = PreloadRemoteArgs;
+type PreloadOptions = Array<{
+  remote: Remote;
+  preloadConfig: PreloadConfig;
+}>;
+type EntryAssets = {
+  name: string;
+  url: string;
+  moduleInfo: RemoteInfo;
+};
+interface PreloadAssets {
+  cssAssets: Array<string>;
+  jsAssetsWithoutEntry: Array<string>;
+  entryAssets: Array<EntryAssets>;
+} //#endregion
+//#endregion
+export { EntryAssets, PreloadAssets, PreloadConfig, PreloadOptions, PreloadRemoteArgs, depsPreloadArg };
+//# sourceMappingURL=preload.d.ts.map

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

@@ -0,0 +1,4 @@
+import { CallFrom, GlobalShareScopeMap, InitScope, InitTokens, Optional, Options, Remote, RemoteEntryExports, RemoteEntryInitOptions, RemoteInfo, RemoteInfoCommon, ShareArgs, ShareInfos, ShareScopeMap, ShareStrategy, Shared, SharedConfig, SharedGetter, TreeShakingArgs, UserOptions } from "./type/config.js";
+import { EntryAssets, PreloadAssets, PreloadConfig, PreloadOptions, PreloadRemoteArgs, depsPreloadArg } from "./type/preload.js";
+import "./type/index.js";
+import { ModuleFederationRuntimePlugin } from "./type/plugin.js";

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

@@ -0,0 +1 @@
+import "@module-federation/sdk";

package/dist/runtime-core/dist/utils/hooks/asyncHook.d.ts

@@ -0,0 +1,11 @@
+import { ArgsType, SyncHook } from "./syncHook.js";
+
+//#region ../runtime-core/dist/utils/hooks/asyncHook.d.ts
+//#region src/utils/hooks/asyncHook.d.ts
+type CallbackReturnType = void | false | Promise<void | false>;
+declare class AsyncHook<T, ExternalEmitReturnType = CallbackReturnType> extends SyncHook<T, ExternalEmitReturnType> {
+  emit(...data: ArgsType<T>): Promise<void | false | ExternalEmitReturnType>;
+} //#endregion
+//#endregion
+export { AsyncHook };
+//# sourceMappingURL=asyncHook.d.ts.map

package/dist/runtime-core/dist/utils/hooks/asyncWaterfallHooks.d.ts

@@ -0,0 +1,13 @@
+import { SyncHook } from "./syncHook.js";
+
+//#region ../runtime-core/dist/utils/hooks/asyncWaterfallHooks.d.ts
+//#region src/utils/hooks/asyncWaterfallHooks.d.ts
+type CallbackReturnType<T> = T | Promise<T>;
+declare class AsyncWaterfallHook<T extends Record<string, any>> extends SyncHook<[T], CallbackReturnType<T>> {
+  onerror: (errMsg: string | Error | unknown) => void;
+  constructor(type: string);
+  emit(data: T): Promise<T>;
+} //#endregion
+//#endregion
+export { AsyncWaterfallHook };
+//# sourceMappingURL=asyncWaterfallHooks.d.ts.map

package/dist/runtime-core/dist/utils/hooks/pluginSystem.d.ts

@@ -0,0 +1,20 @@
+import { ModuleFederation } from "../../core.js";
+
+//#region ../runtime-core/dist/utils/hooks/pluginSystem.d.ts
+//#region src/utils/hooks/pluginSystem.d.ts
+type Plugin<T extends Record<string, any>> = { [k in keyof T]?: Parameters<T[k]['on']>[0] } & {
+  name: string;
+  version?: string;
+  apply?: (instance: ModuleFederation) => void;
+};
+declare class PluginSystem<T extends Record<string, any>> {
+  lifecycle: T;
+  lifecycleKeys: Array<keyof T>;
+  registerPlugins: Record<string, Plugin<T>>;
+  constructor(lifecycle: T);
+  applyPlugin(plugin: Plugin<T>, instance: ModuleFederation): void;
+  removePlugin(pluginName: string): void;
+} //#endregion
+//#endregion
+export { PluginSystem };
+//# sourceMappingURL=pluginSystem.d.ts.map

package/dist/runtime-core/dist/utils/hooks/syncHook.d.ts

@@ -0,0 +1,17 @@
+//#region ../runtime-core/dist/utils/hooks/syncHook.d.ts
+//#region src/utils/hooks/syncHook.d.ts
+type Callback<T, K> = (...args: ArgsType<T>) => K;
+type ArgsType<T> = T extends Array<any> ? T : Array<any>;
+declare class SyncHook<T, K> {
+  type: string;
+  listeners: Set<Callback<T, K>>;
+  constructor(type?: string);
+  on(fn: Callback<T, K>): void;
+  once(fn: Callback<T, K>): void;
+  emit(...data: ArgsType<T>): void | K | Promise<any>;
+  remove(fn: Callback<T, K>): void;
+  removeAll(): void;
+} //#endregion
+//#endregion
+export { ArgsType, SyncHook };
+//# sourceMappingURL=syncHook.d.ts.map

package/dist/runtime-core/dist/utils/hooks/syncWaterfallHook.d.ts

@@ -0,0 +1,12 @@
+import { SyncHook } from "./syncHook.js";
+
+//#region ../runtime-core/dist/utils/hooks/syncWaterfallHook.d.ts
+//#region src/utils/hooks/syncWaterfallHook.d.ts
+declare class SyncWaterfallHook<T extends Record<string, any>> extends SyncHook<[T], T> {
+  onerror: (errMsg: string | Error | unknown) => void;
+  constructor(type: string);
+  emit(data: T): T;
+} //#endregion
+//#endregion
+export { SyncWaterfallHook };
+//# sourceMappingURL=syncWaterfallHook.d.ts.map

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

@@ -0,0 +1,2 @@
+import "./env.js";
+import "./plugin.js";

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

@@ -0,0 +1,16 @@
+import { RemoteEntryExports, RemoteInfo } from "../type/config.js";
+import "../type/index.js";
+import { ModuleFederation } from "../core.js";
+
+//#region ../runtime-core/dist/utils/load.d.ts
+//#region src/utils/load.d.ts
+declare function getRemoteEntry(params: {
+  origin: ModuleFederation;
+  remoteInfo: RemoteInfo;
+  remoteEntryExports?: RemoteEntryExports | undefined;
+  getEntryUrl?: (url: string) => string;
+  _inErrorHandling?: boolean;
+}): Promise<RemoteEntryExports | false | void>;
+//#endregion
+export { getRemoteEntry };
+//# sourceMappingURL=load.d.ts.map

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

@@ -0,0 +1 @@
+import "@module-federation/sdk";

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

@@ -0,0 +1,2 @@
+import "../type/config.js";
+import "../type/index.js";

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

@@ -0,0 +1,2 @@
+import "../type/index.js";
+import "../core.js";

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

@@ -0,0 +1,4 @@
+import "../type/config.js";
+import "../type/preload.js";
+import "../type/index.js";
+import "../core.js";

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

@@ -0,0 +1,3 @@
+import "../type/config.js";
+import "../type/index.js";
+import "../global.js";

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

@@ -0,0 +1 @@
+import "../type/index.js";

package/dist/sdk/dist/types/plugins/ModuleFederationPlugin.d.ts

@@ -0,0 +1,13 @@
+import "webpack";
+
+//#region ../sdk/dist/types/plugins/ModuleFederationPlugin.d.ts
+/**
+ * Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).
+ */
+type ExternalsType = 'var' | 'module' | 'assign' | 'this' | 'window' | 'self' | 'global' | 'commonjs' | 'commonjs2' | 'commonjs-module' | 'commonjs-static' | 'amd' | 'amd-require' | 'umd' | 'umd2' | 'jsonp' | 'system' | 'promise' | 'import' | 'script' | 'module-import' | 'node-commonjs';
+/**
+ * Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.
+ */
+//#endregion
+export { ExternalsType };
+//# sourceMappingURL=ModuleFederationPlugin.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,201 @@
+import { initializeSharing } from "./initializeSharing.js";
+import { attachShareScopeMap } from "./attachShareScopeMap.js";
+import { initContainerEntry } from "./initContainerEntry.js";
+import * as runtime from "@module-federation/runtime";
+import { moduleFederationPlugin } from "@module-federation/sdk";
+import { Remote, RemoteEntryInitOptions, SharedConfig, SharedGetter, TreeShakingArgs } from "@module-federation/runtime/types";
+
+//#region src/types.d.ts
+type ExcludeUndefined<T> = T extends undefined ? never : T;
+type Shared = InitOptions['shared'];
+type NonUndefined<T = Shared> = ExcludeUndefined<T>;
+type InitOptions = Omit<Parameters<typeof runtime.init>[0], 'remotes'> & {
+  remotes: Array<Remote & {
+    externalType: moduleFederationPlugin.ExternalsType;
+  }>;
+};
+type ModuleCache = runtime.ModuleFederation['moduleCache'];
+type InferModule<T> = T extends Map<string, infer U> ? U : never;
+type InferredModule = InferModule<ModuleCache>;
+type ShareScopeMap = runtime.ModuleFederation['shareScopeMap'];
+type InitToken = Record<string, Record<string, any>>;
+interface InitializeSharingOptions {
+  shareScopeName: string | string[];
+  webpackRequire: WebpackRequire;
+  initPromises: Record<string, Promise<boolean> | boolean>;
+  initTokens: InitToken;
+  initScope: InitToken[];
+}
+type RemoteEntryExports = NonUndefined<InferredModule['remoteEntryExports']>;
+type ExtractInitParameters<T> = T extends {
+  init: (shareScope: infer U, ...args: any[]) => void;
+} ? U : never;
+type InferredShareScope = ExtractInitParameters<RemoteEntryExports>;
+type InferredGlobalShareScope = {
+  [scope: string]: InferredShareScope;
+};
+type IdToExternalAndNameMappingItem = [string | string[], string, string | number];
+interface IdToExternalAndNameMappingItemWithPromise extends IdToExternalAndNameMappingItem {
+  p?: Promise<any> | number;
+}
+type IdToExternalAndNameMapping = Record<string, IdToExternalAndNameMappingItemWithPromise>;
+type ModuleId = string | number;
+type RemoteDataItem = {
+  shareScope: string | string[];
+  name: string;
+  externalModuleId: ModuleId;
+  remoteName: string;
+};
+type ModuleIdToRemoteDataMapping = Record<ModuleId, RemoteDataItem>;
+type ModuleIdToConsumeDataMapping = {
+  fallback: () => Promise<any>;
+  shareKey: string;
+  shareScope: string | string[];
+  treeShakingMode?: 'server-calc' | 'runtime-infer';
+} & SharedConfig;
+type WithStatus<T> = T & {
+  _updated: number;
+};
+type ConsumesLoadingData = WithStatus<{
+  chunkMapping?: Record<string, Array<string | number>>;
+  moduleIdToConsumeDataMapping?: Record<string, ModuleIdToConsumeDataMapping>;
+  initialConsumes?: Array<ModuleId>;
+}>;
+type RemotesLoadingData = WithStatus<{
+  chunkMapping?: Record<string, Array<ModuleId>>;
+  moduleIdToRemoteDataMapping?: ModuleIdToRemoteDataMapping;
+}>;
+type InitializeSharingData = WithStatus<{
+  scopeToSharingDataMapping: {
+    [shareScope: string]: Array<{
+      name: string;
+      version: string;
+      factory: SharedGetter;
+      eager?: boolean;
+      singleton?: boolean;
+      requiredVersion?: string;
+      strictVersion?: boolean;
+    }>;
+  };
+  uniqueName: string;
+}>;
+interface WebpackRequire {
+  (moduleId: string | number): any;
+  p: string;
+  o: (obj: Record<string, any>, key: string | number) => boolean;
+  R: Array<string | number>;
+  m: Record<string, (mod: any) => any>;
+  j?: string;
+  c: Record<string, any>;
+  I: (scopeName: string | string[], initScope?: InitializeSharingOptions['initScope']) => ReturnType<typeof initializeSharing>;
+  S?: InferredGlobalShareScope;
+  federation: Federation;
+  consumesLoadingData?: ConsumesLoadingData;
+  remotesLoadingData?: RemotesLoadingData;
+  initializeSharingData?: InitializeSharingData;
+}
+interface ShareInfo {
+  shareConfig: SharedConfig;
+  scope: Array<string>;
+  treeShaking?: TreeShakingArgs;
+}
+interface ModuleToHandlerMappingItem {
+  getter: () => Promise<any>;
+  shareInfo: ShareInfo;
+  shareKey: string;
+  treeShakingGetter?: () => Promise<any>;
+}
+interface IdToRemoteMapItem {
+  externalType: string;
+  name: string;
+}
+type IdToRemoteMap = Record<string, IdToRemoteMapItem[]>;
+type RemoteInfos = Record<string, Array<IdToRemoteMapItem & {
+  alias: string;
+  entry?: string;
+  shareScope: string;
+}>>;
+type RemoteChunkMapping = Record<string, Array<ModuleId>>;
+type CoreRemotesOptions = {
+  idToRemoteMap: IdToRemoteMap;
+  chunkMapping: RemoteChunkMapping;
+  idToExternalAndNameMapping: IdToExternalAndNameMapping;
+};
+type RemotesOptions = {
+  chunkId: string | number;
+  promises: Promise<any>[];
+  webpackRequire: WebpackRequire;
+} & CoreRemotesOptions;
+interface HandleInitialConsumesOptions {
+  moduleId: string | number;
+  moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
+  webpackRequire: WebpackRequire;
+  asyncLoad?: boolean;
+}
+interface InstallInitialConsumesOptions {
+  moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
+  webpackRequire: WebpackRequire;
+  installedModules: Record<string, Promise<any> | 0>;
+  initialConsumes: Array<string | number>;
+  asyncLoad?: boolean;
+}
+interface ConsumesOptions {
+  chunkId: string | number;
+  promises: Promise<any>[];
+  chunkMapping: Record<string, Array<string | number>>;
+  installedModules: Record<string, Promise<any> | 0>;
+  moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
+  webpackRequire: WebpackRequire;
+}
+interface InitContainerEntryOptions {
+  shareScope: ShareScopeMap[string];
+  shareScopeKey: string | string[];
+  webpackRequire: WebpackRequire;
+  remoteEntryInitOptions?: RemoteEntryInitOptions;
+  initScope?: InitializeSharingOptions['initScope'];
+}
+interface GetSharedFallbackGetterOptions {
+  shareKey: string;
+  factory: SharedGetter;
+  version?: string;
+  webpackRequire: WebpackRequire;
+  libraryType?: string;
+}
+interface Federation {
+  runtime?: typeof runtime;
+  instance?: runtime.ModuleFederation;
+  initOptions?: InitOptions;
+  installInitialConsumes?: (options: InstallInitialConsumesOptions) => any;
+  bundlerRuntime?: {
+    remotes: (options: RemotesOptions) => void;
+    consumes: (options: ConsumesOptions) => void;
+    I: typeof initializeSharing;
+    S: InferredGlobalShareScope;
+    installInitialConsumes: (options: InstallInitialConsumesOptions) => any;
+    initContainerEntry: typeof initContainerEntry;
+    init: ({
+      webpackRequire,
+      libraryType
+    }: {
+      webpackRequire: WebpackRequire;
+      libraryType: string;
+    }) => void;
+    getSharedFallbackGetter: (options: GetSharedFallbackGetterOptions) => SharedGetter;
+  };
+  bundlerRuntimeOptions: {
+    remotes?: Exclude<RemotesOptions, 'chunkId' | 'promises'> & {
+      remoteInfos?: RemoteInfos;
+    };
+  };
+  attachShareScopeMap?: typeof attachShareScopeMap;
+  hasAttachShareScopeMap?: boolean;
+  prefetch?: () => void;
+  usedExports?: {
+    [sharedName: string]: string[];
+  };
+  libraryType?: string;
+  sharedFallback?: Record<string, Array<[string, string, string]>>;
+}
+//#endregion
+export { ConsumesLoadingData, ConsumesOptions, CoreRemotesOptions, Federation, GetSharedFallbackGetterOptions, HandleInitialConsumesOptions, IdToExternalAndNameMapping, IdToRemoteMap, IdToRemoteMapItem, InitContainerEntryOptions, InitializeSharingData, InitializeSharingOptions, InstallInitialConsumesOptions, ModuleId, ModuleIdToRemoteDataMapping, RemoteChunkMapping, RemoteDataItem, RemoteEntryExports, RemoteInfos, RemotesLoadingData, RemotesOptions, ShareScopeMap, WebpackRequire };
+//# sourceMappingURL=types.d.ts.map

package/dist/updateOptions.cjs

@@ -0,0 +1,112 @@
+
+//#region src/updateOptions.ts
+function updateConsumeOptions(options) {
+	const { webpackRequire, moduleToHandlerMapping } = options;
+	const { consumesLoadingData, initializeSharingData } = webpackRequire;
+	const { sharedFallback, bundlerRuntime, libraryType } = webpackRequire.federation;
+	if (consumesLoadingData && !consumesLoadingData._updated) {
+		const { moduleIdToConsumeDataMapping: updatedModuleIdToConsumeDataMapping = {}, initialConsumes: updatedInitialConsumes = [], chunkMapping: updatedChunkMapping = {} } = consumesLoadingData;
+		Object.entries(updatedModuleIdToConsumeDataMapping).forEach(([id, data]) => {
+			if (!moduleToHandlerMapping[id]) moduleToHandlerMapping[id] = {
+				getter: sharedFallback ? bundlerRuntime?.getSharedFallbackGetter({
+					shareKey: data.shareKey,
+					factory: data.fallback,
+					webpackRequire,
+					libraryType
+				}) : data.fallback,
+				treeShakingGetter: sharedFallback ? data.fallback : void 0,
+				shareInfo: {
+					shareConfig: {
+						requiredVersion: data.requiredVersion,
+						strictVersion: data.strictVersion,
+						singleton: data.singleton,
+						eager: data.eager,
+						layer: data.layer
+					},
+					scope: Array.isArray(data.shareScope) ? data.shareScope : [data.shareScope || "default"],
+					treeShaking: sharedFallback ? {
+						get: data.fallback,
+						mode: data.treeShakingMode
+					} : void 0
+				},
+				shareKey: data.shareKey
+			};
+		});
+		if ("initialConsumes" in options) {
+			const { initialConsumes = [] } = options;
+			updatedInitialConsumes.forEach((id) => {
+				if (!initialConsumes.includes(id)) initialConsumes.push(id);
+			});
+		}
+		if ("chunkMapping" in options) {
+			const { chunkMapping = {} } = options;
+			Object.entries(updatedChunkMapping).forEach(([id, chunkModules]) => {
+				if (!chunkMapping[id]) chunkMapping[id] = [];
+				chunkModules.forEach((moduleId) => {
+					if (!chunkMapping[id].includes(moduleId)) chunkMapping[id].push(moduleId);
+				});
+			});
+		}
+		consumesLoadingData._updated = 1;
+	}
+	if (initializeSharingData && !initializeSharingData._updated) {
+		const { federation } = webpackRequire;
+		if (!federation.instance || !initializeSharingData.scopeToSharingDataMapping) return;
+		const shared = {};
+		for (let [scope, stages] of Object.entries(initializeSharingData.scopeToSharingDataMapping)) for (let stage of stages) if (typeof stage === "object" && stage !== null) {
+			const { name, version, factory, eager, singleton, requiredVersion, strictVersion } = stage;
+			const shareConfig = { requiredVersion: `^${version}` };
+			const isValidValue = function(val) {
+				return typeof val !== "undefined";
+			};
+			if (isValidValue(singleton)) shareConfig.singleton = singleton;
+			if (isValidValue(requiredVersion)) shareConfig.requiredVersion = requiredVersion;
+			if (isValidValue(eager)) shareConfig.eager = eager;
+			if (isValidValue(strictVersion)) shareConfig.strictVersion = strictVersion;
+			const options = {
+				version,
+				scope: [scope],
+				shareConfig,
+				get: factory
+			};
+			if (shared[name]) shared[name].push(options);
+			else shared[name] = [options];
+		}
+		federation.instance.registerShared(shared);
+		initializeSharingData._updated = 1;
+	}
+}
+function updateRemoteOptions(options) {
+	const { webpackRequire, idToExternalAndNameMapping = {}, idToRemoteMap = {}, chunkMapping = {} } = options;
+	const { remotesLoadingData } = webpackRequire;
+	const remoteInfos = webpackRequire.federation?.bundlerRuntimeOptions?.remotes?.remoteInfos;
+	if (!remotesLoadingData || remotesLoadingData._updated || !remoteInfos) return;
+	const { chunkMapping: updatedChunkMapping, moduleIdToRemoteDataMapping } = remotesLoadingData;
+	if (!updatedChunkMapping || !moduleIdToRemoteDataMapping) return;
+	for (let [moduleId, data] of Object.entries(moduleIdToRemoteDataMapping)) {
+		if (!idToExternalAndNameMapping[moduleId]) idToExternalAndNameMapping[moduleId] = [
+			data.shareScope,
+			data.name,
+			data.externalModuleId
+		];
+		if (!idToRemoteMap[moduleId] && remoteInfos[data.remoteName]) {
+			const items = remoteInfos[data.remoteName];
+			idToRemoteMap[moduleId] ||= [];
+			items.forEach((item) => {
+				if (!idToRemoteMap[moduleId].includes(item)) idToRemoteMap[moduleId].push(item);
+			});
+		}
+	}
+	if (chunkMapping) Object.entries(updatedChunkMapping).forEach(([id, chunkModules]) => {
+		if (!chunkMapping[id]) chunkMapping[id] = [];
+		chunkModules.forEach((moduleId) => {
+			if (!chunkMapping[id].includes(moduleId)) chunkMapping[id].push(moduleId);
+		});
+	});
+	remotesLoadingData._updated = 1;
+}
+
+//#endregion
+exports.updateConsumeOptions = updateConsumeOptions;
+exports.updateRemoteOptions = updateRemoteOptions;
+//# sourceMappingURL=updateOptions.cjs.map