@module-federation/runtime 0.1.12 → 0.1.13

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/runtime",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "author": "zhouxiao <codingzx@gmail.com>",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",

package/dist/share.cjs.js

@@ -190,7 +190,7 @@ function getGlobalFederationConstructor() {
 function setGlobalFederationConstructor(FederationConstructor, isDebug = isDebugMode()) {
     if (isDebug) {
         globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
-        globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.1.12";
+        globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.1.13";
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -697,11 +697,10 @@ function formatShare(shareArgs, from, name) {
         strategy: shareArgs.strategy || 'version-first'
     });
 }
-function formatShareConfigs(shareArgs, from) {
-    if (!shareArgs) {
-        return {};
-    }
-    return Object.keys(shareArgs).reduce((res, pkgName)=>{
+function formatShareConfigs(globalOptions, userOptions) {
+    const shareArgs = userOptions.shared || {};
+    const from = userOptions.name;
+    const shareInfos = Object.keys(shareArgs).reduce((res, pkgName)=>{
         const arrayShareArgs = arrayOptions(shareArgs[pkgName]);
         res[pkgName] = res[pkgName] || [];
         arrayShareArgs.forEach((shareConfig)=>{
@@ -709,6 +708,23 @@ function formatShareConfigs(shareArgs, from) {
         });
         return res;
     }, {});
+    const shared = _extends({}, globalOptions.shared);
+    Object.keys(shareInfos).forEach((shareKey)=>{
+        if (!shared[shareKey]) {
+            shared[shareKey] = shareInfos[shareKey];
+        } else {
+            shareInfos[shareKey].forEach((newUserSharedOptions)=>{
+                const isSameVersion = shared[shareKey].find((sharedVal)=>sharedVal.version === newUserSharedOptions.version);
+                if (!isSameVersion) {
+                    shared[shareKey].push(newUserSharedOptions);
+                }
+            });
+        }
+    });
+    return {
+        shared,
+        shareInfos
+    };
 }
 function versionLt(a, b) {
     const transformInvalidVersion = (version)=>{

package/dist/share.esm.js

@@ -188,7 +188,7 @@ function getGlobalFederationConstructor() {
 function setGlobalFederationConstructor(FederationConstructor, isDebug = isDebugMode()) {
     if (isDebug) {
         globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
-        globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.1.12";
+        globalThis.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.1.13";
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -695,11 +695,10 @@ function formatShare(shareArgs, from, name) {
         strategy: shareArgs.strategy || 'version-first'
     });
 }
-function formatShareConfigs(shareArgs, from) {
-    if (!shareArgs) {
-        return {};
-    }
-    return Object.keys(shareArgs).reduce((res, pkgName)=>{
+function formatShareConfigs(globalOptions, userOptions) {
+    const shareArgs = userOptions.shared || {};
+    const from = userOptions.name;
+    const shareInfos = Object.keys(shareArgs).reduce((res, pkgName)=>{
         const arrayShareArgs = arrayOptions(shareArgs[pkgName]);
         res[pkgName] = res[pkgName] || [];
         arrayShareArgs.forEach((shareConfig)=>{
@@ -707,6 +706,23 @@ function formatShareConfigs(shareArgs, from) {
         });
         return res;
     }, {});
+    const shared = _extends({}, globalOptions.shared);
+    Object.keys(shareInfos).forEach((shareKey)=>{
+        if (!shared[shareKey]) {
+            shared[shareKey] = shareInfos[shareKey];
+        } else {
+            shareInfos[shareKey].forEach((newUserSharedOptions)=>{
+                const isSameVersion = shared[shareKey].find((sharedVal)=>sharedVal.version === newUserSharedOptions.version);
+                if (!isSameVersion) {
+                    shared[shareKey].push(newUserSharedOptions);
+                }
+            });
+        }
+    });
+    return {
+        shared,
+        shareInfos
+    };
 }
 function versionLt(a, b) {
     const transformInvalidVersion = (version)=>{
@@ -854,4 +870,4 @@ function getTargetSharedOptions(options) {
     return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions == null ? void 0 : extraOptions.customShareInfo);
 }
 
-export { isBrowserEnv as A, addUniqueItem as B, setGlobalFederationConstructor as C, DEFAULT_REMOTE_TYPE as D, getGlobalFederationInstance as E, getGlobalFederationConstructor as F, Global as G, setGlobalFederationInstance as H, registerGlobalPlugins as I, nativeGlobal as J, resetFederationGlobalInfo as K, getTargetSnapshotInfoByModuleInfo as L, globalLoading as a, DEFAULT_SCOPE as b, getRemoteEntryExports as c, assert as d, getFMId as e, error as f, getGlobalHostPlugins as g, isPlainObject as h, isObject as i, isRemoteInfoWithEntry as j, isPureRemoteEntry as k, getInfoWithoutType as l, getPreloaded as m, setPreloaded as n, getRegisteredShare as o, arrayOptions as p, getGlobalSnapshotInfoByModuleInfo as q, addGlobalSnapshot as r, safeToString as s, setGlobalSnapshotInfoByModuleInfo as t, getGlobalSnapshot as u, getGlobalShareScope as v, warn as w, getTargetSharedOptions as x, formatShareConfigs as y, getBuilderId as z };
+export { getBuilderId as A, isBrowserEnv as B, setGlobalFederationConstructor as C, DEFAULT_REMOTE_TYPE as D, getGlobalFederationInstance as E, getGlobalFederationConstructor as F, Global as G, setGlobalFederationInstance as H, registerGlobalPlugins as I, nativeGlobal as J, resetFederationGlobalInfo as K, getTargetSnapshotInfoByModuleInfo as L, globalLoading as a, DEFAULT_SCOPE as b, getRemoteEntryExports as c, assert as d, getFMId as e, error as f, getGlobalHostPlugins as g, isPlainObject as h, isObject as i, isRemoteInfoWithEntry as j, isPureRemoteEntry as k, getInfoWithoutType as l, getPreloaded as m, setPreloaded as n, getRegisteredShare as o, arrayOptions as p, getGlobalSnapshotInfoByModuleInfo as q, addGlobalSnapshot as r, safeToString as s, setGlobalSnapshotInfoByModuleInfo as t, getGlobalSnapshot as u, formatShareConfigs as v, warn as w, getTargetSharedOptions as x, getGlobalShareScope as y, addUniqueItem as z };

package/dist/src/core.d.ts

@@ -1,19 +1,9 @@
-import type { ModuleInfo, GlobalModuleInfo } from '@module-federation/sdk';
-import { Options, PreloadAssets, PreloadOptions, PreloadRemoteArgs, RemoteEntryExports, Remote, Shared, ShareInfos, UserOptions, RemoteInfo, ShareScopeMap, InitScope, RemoteEntryInitOptions } from './type';
-import { Module, ModuleOptions } from './module';
+import { Options, PreloadRemoteArgs, RemoteEntryExports, Remote, Shared, ShareInfos, UserOptions, RemoteInfo, ShareScopeMap, InitScope, RemoteEntryInitOptions } from './type';
+import { Module } from './module';
 import { AsyncHook, AsyncWaterfallHook, PluginSystem, SyncHook, SyncWaterfallHook } from './utils/hooks';
-import { Federation } from './global';
 import { SnapshotHandler } from './plugins/snapshot/SnapshotHandler';
-interface LoadRemoteMatch {
-    id: string;
-    pkgNameOrAlias: string;
-    expose: string;
-    remote: Remote;
-    options: Options;
-    origin: FederationHost;
-    remoteInfo: RemoteInfo;
-    remoteSnapshot?: ModuleInfo;
-}
+import { SharedHandler } from './shared';
+import { RemoteHandler } from './remote';
 export declare class FederationHost {
     options: Options;
     hooks: PluginSystem<{
@@ -27,12 +17,6 @@ export declare class FederationHost {
             options: Options;
             origin: FederationHost;
         }], void>;
-        beforeRequest: AsyncWaterfallHook<{
-            id: string;
-            options: Options;
-            origin: FederationHost;
-        }>;
-        afterResolve: AsyncWaterfallHook<LoadRemoteMatch>;
         beforeInitContainer: AsyncWaterfallHook<{
             shareScope: ShareScopeMap[string];
             initScope: InitScope;
@@ -40,11 +24,6 @@ export declare class FederationHost {
             remoteInfo: RemoteInfo;
             origin: FederationHost;
         }>;
-        initContainerShareScopeMap: AsyncWaterfallHook<{
-            shareScope: ShareScopeMap[string];
-            options: Options;
-            origin: FederationHost;
-        }>;
         initContainer: AsyncWaterfallHook<{
             shareScope: ShareScopeMap[string];
             initScope: InitScope;
@@ -53,71 +32,13 @@ export declare class FederationHost {
             remoteEntryExports: RemoteEntryExports;
             origin: FederationHost;
         }>;
-        onLoad: AsyncHook<[{
-            id: string;
-            expose: string;
-            pkgNameOrAlias: string;
-            remote: Remote;
-            options: ModuleOptions;
-            origin: FederationHost;
-            exposeModule: any;
-            exposeModuleFactory: any;
-            moduleInstance: Module;
-        }], void>;
-        handlePreloadModule: SyncHook<{
-            id: string;
-            name: string;
-            remote: Remote;
-            remoteSnapshot: ModuleInfo;
-            preloadConfig: PreloadRemoteArgs;
-            origin: FederationHost;
-        }, void>;
-        errorLoadRemote: AsyncHook<[{
-            id: string;
-            error: unknown;
-            options?: any;
-            from: 'build' | 'runtime';
-            lifecycle: 'onLoad' | 'beforeRequest';
-            origin: FederationHost;
-        }], unknown>;
-        beforeLoadShare: AsyncWaterfallHook<{
-            pkgName: string;
-            shareInfo?: Shared | undefined;
-            shared: Options['shared'];
-            origin: FederationHost;
-        }>;
-        loadShare: AsyncHook<[FederationHost, string, ShareInfos], false | void | Promise<false | void>>;
-        resolveShare: SyncWaterfallHook<{
-            shareScopeMap: ShareScopeMap;
-            scope: string;
-            pkgName: string;
-            version: string;
-            GlobalFederation: Federation;
-            resolver: () => Shared | undefined;
-        }>;
-        beforePreloadRemote: AsyncHook<{
-            preloadOps: Array<PreloadRemoteArgs>;
-            options: Options;
-            origin: FederationHost;
-        }, false | void | Promise<false | void>>;
-        generatePreloadAssets: AsyncHook<[{
-            origin: FederationHost;
-            preloadOptions: PreloadOptions[number];
-            remote: Remote;
-            remoteInfo: RemoteInfo;
-            remoteSnapshot: ModuleInfo;
-            globalSnapshot: GlobalModuleInfo;
-        }], Promise<PreloadAssets>>;
-        afterPreloadRemote: AsyncHook<{
-            preloadOps: Array<PreloadRemoteArgs>;
-            options: Options;
-            origin: FederationHost;
-        }, false | void | Promise<false | void>>;
     }>;
     version: string;
     name: string;
     moduleCache: Map<string, Module>;
     snapshotHandler: SnapshotHandler;
+    sharedHandler: SharedHandler;
+    remoteHandler: RemoteHandler;
     shareScopeMap: ShareScopeMap;
     loaderHook: PluginSystem<{
         getModuleInfo: SyncHook<[{
@@ -136,7 +57,6 @@ export declare class FederationHost {
         fetch: AsyncHook<[string, RequestInit], false | void | Promise<Response>>;
     }>;
     constructor(userOptions: UserOptions);
-    private _setGlobalShareScopeMap;
     initOptions(userOptions: UserOptions): Options;
     loadShare<T>(pkgName: string, extraOptions?: {
         customShareInfo?: Partial<Shared>;
@@ -146,27 +66,17 @@ export declare class FederationHost {
         customShareInfo?: Partial<Shared>;
         resolver?: (sharedOptions: ShareInfos[string]) => Shared;
     }): () => T | never;
+    initializeSharing(shareScopeName?: string, strategy?: Shared['strategy']): Array<Promise<void>>;
     initRawContainer(name: string, url: string, container: RemoteEntryExports): Module;
-    private _getRemoteModuleAndOptions;
     loadRemote<T>(id: string, options?: {
         loadFactory?: boolean;
         from: 'build' | 'runtime';
     }): Promise<T | null>;
     preloadRemote(preloadOptions: Array<PreloadRemoteArgs>): Promise<void>;
-    /**
-     * 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, strategy?: Shared['strategy']): Array<Promise<void>>;
     initShareScopeMap(scopeName: string, shareScope: ShareScopeMap[string]): void;
     private formatOptions;
     registerPlugins(plugins: UserOptions['plugins']): void;
-    private setShared;
-    private removeRemote;
-    private registerRemote;
     registerRemotes(remotes: Remote[], options?: {
         force?: boolean;
     }): void;
 }
-export {};

package/dist/src/remote/index.d.ts

@@ -0,0 +1,91 @@
+import { type ModuleInfo, type GlobalModuleInfo } from '@module-federation/sdk';
+import { Options, UserOptions, PreloadAssets, PreloadOptions, PreloadRemoteArgs, Remote, RemoteInfo } from '../type';
+import { FederationHost } from '../core';
+import { PluginSystem, AsyncHook, AsyncWaterfallHook, SyncHook } from '../utils/hooks';
+import { Module, ModuleOptions } from '../module';
+export interface LoadRemoteMatch {
+    id: string;
+    pkgNameOrAlias: string;
+    expose: string;
+    remote: Remote;
+    options: Options;
+    origin: FederationHost;
+    remoteInfo: RemoteInfo;
+    remoteSnapshot?: ModuleInfo;
+}
+export declare class RemoteHandler {
+    host: FederationHost;
+    hooks: PluginSystem<{
+        beforeRequest: AsyncWaterfallHook<{
+            id: string;
+            options: Options;
+            origin: FederationHost;
+        }>;
+        onLoad: AsyncHook<[{
+            id: string;
+            expose: string;
+            pkgNameOrAlias: string;
+            remote: Remote;
+            options: ModuleOptions;
+            origin: FederationHost;
+            exposeModule: any;
+            exposeModuleFactory: any;
+            moduleInstance: Module;
+        }], void>;
+        handlePreloadModule: SyncHook<{
+            id: string;
+            name: string;
+            remote: Remote;
+            remoteSnapshot: ModuleInfo;
+            preloadConfig: PreloadRemoteArgs;
+            origin: FederationHost;
+        }, void>;
+        errorLoadRemote: AsyncHook<[{
+            id: string;
+            error: unknown;
+            options?: any;
+            from: 'build' | 'runtime';
+            lifecycle: 'onLoad' | 'beforeRequest';
+            origin: FederationHost;
+        }], unknown>;
+        beforePreloadRemote: AsyncHook<{
+            preloadOps: Array<PreloadRemoteArgs>;
+            options: Options;
+            origin: FederationHost;
+        }, false | void | Promise<false | void>>;
+        generatePreloadAssets: AsyncHook<[{
+            origin: FederationHost;
+            preloadOptions: PreloadOptions[number];
+            remote: Remote;
+            remoteInfo: RemoteInfo;
+            remoteSnapshot: ModuleInfo;
+            globalSnapshot: GlobalModuleInfo;
+        }], Promise<PreloadAssets>>;
+        afterPreloadRemote: AsyncHook<{
+            preloadOps: Array<PreloadRemoteArgs>;
+            options: Options;
+            origin: FederationHost;
+        }, false | void | Promise<false | void>>;
+    }>;
+    constructor(host: FederationHost);
+    formatAndRegisterRemote(globalOptions: Options, userOptions: UserOptions): Remote[];
+    loadRemote<T>(id: string, options?: {
+        loadFactory?: boolean;
+        from: 'build' | 'runtime';
+    }): Promise<T | null>;
+    preloadRemote(preloadOptions: Array<PreloadRemoteArgs>): Promise<void>;
+    registerRemotes(remotes: Remote[], options?: {
+        force?: boolean;
+    }): void;
+    getRemoteModuleAndOptions(options: {
+        id: string;
+    }): Promise<{
+        module: Module;
+        moduleOptions: ModuleOptions;
+        remoteMatchInfo: LoadRemoteMatch;
+    }>;
+    registerRemote(remote: Remote, targetRemotes: Remote[], options?: {
+        force?: boolean;
+    }): void;
+    private removeRemote;
+}

package/dist/src/shared/index.d.ts

@@ -0,0 +1,56 @@
+import { Federation } from '../global';
+import { Options, ShareScopeMap, ShareInfos, Shared, UserOptions } from '../type';
+import { FederationHost } from '../core';
+import { PluginSystem, AsyncHook, AsyncWaterfallHook, SyncWaterfallHook } from '../utils/hooks';
+import { LoadRemoteMatch } from '../remote';
+export declare class SharedHandler {
+    host: FederationHost;
+    shareScopeMap: ShareScopeMap;
+    hooks: PluginSystem<{
+        afterResolve: AsyncWaterfallHook<LoadRemoteMatch>;
+        beforeLoadShare: AsyncWaterfallHook<{
+            pkgName: string;
+            shareInfo?: Shared | undefined;
+            shared: Options['shared'];
+            origin: FederationHost;
+        }>;
+        loadShare: AsyncHook<[FederationHost, string, ShareInfos], false | void | Promise<false | void>>;
+        resolveShare: SyncWaterfallHook<{
+            shareScopeMap: ShareScopeMap;
+            scope: string;
+            pkgName: string;
+            version: string;
+            GlobalFederation: Federation;
+            resolver: () => Shared | undefined;
+        }>;
+        initContainerShareScopeMap: AsyncWaterfallHook<{
+            shareScope: ShareScopeMap[string];
+            options: Options;
+            origin: FederationHost;
+        }>;
+    }>;
+    constructor(host: FederationHost);
+    registerShared(globalOptions: Options, userOptions: UserOptions): {
+        shareInfos: ShareInfos;
+        shared: {
+            [x: 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, strategy?: Shared['strategy']): Array<Promise<void>>;
+    loadShareSync<T>(pkgName: string, extraOptions?: {
+        customShareInfo?: Partial<Shared>;
+        resolver?: (sharedOptions: ShareInfos[string]) => Shared;
+    }): () => T | never;
+    initShareScopeMap(scopeName: string, shareScope: ShareScopeMap[string]): void;
+    private setShared;
+    private _setGlobalShareScopeMap;
+}

package/dist/src/type/plugin.d.ts

@@ -1,6 +1,8 @@
 import { FederationHost } from '../core';
 import { Module } from '../module';
 import { SnapshotHandler } from '../plugins/snapshot/SnapshotHandler';
+import { SharedHandler } from '../shared';
+import { RemoteHandler } from '../remote';
 type CoreLifeCycle = FederationHost['hooks']['lifecycle'];
 type CoreLifeCyclePartial = Partial<{
     [k in keyof CoreLifeCycle]: Parameters<CoreLifeCycle[k]['on']>[0];
@@ -13,7 +15,15 @@ type ModuleLifeCycle = Module['host']['loaderHook']['lifecycle'];
 type ModuleLifeCycleCyclePartial = Partial<{
     [k in keyof ModuleLifeCycle]: Parameters<ModuleLifeCycle[k]['on']>[0];
 }>;
-export type FederationRuntimePlugin = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & {
+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];
+}>;
+export type FederationRuntimePlugin = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & SharedLifeCycleCyclePartial & RemoteLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & {
     name: string;
     version?: string;
 };

package/dist/src/utils/plugin.d.ts

@@ -1,4 +1,4 @@
 import { FederationHost } from '../core';
 import { UserOptions } from '../type';
 import { Module } from '../module';
-export declare function registerPlugins(plugins: UserOptions['plugins'], hookInstances: Array<FederationHost['hooks'] | FederationHost['snapshotHandler']['hooks'] | Module['host']['loaderHook']>): import("../type").FederationRuntimePlugin[] | undefined;
+export declare function registerPlugins(plugins: UserOptions['plugins'], hookInstances: Array<FederationHost['hooks'] | FederationHost['snapshotHandler']['hooks'] | FederationHost['sharedHandler']['hooks'] | FederationHost['remoteHandler']['hooks'] | Module['host']['loaderHook']>): import("../type").FederationRuntimePlugin[] | undefined;

package/dist/src/utils/share.d.ts

@@ -1,8 +1,13 @@
 import { Federation } from '../global';
-import { GlobalShareScopeMap, Shared, ShareArgs, ShareInfos, ShareScopeMap, LoadShareExtraOptions, UserOptions } from '../type';
+import { GlobalShareScopeMap, Shared, ShareArgs, ShareInfos, ShareScopeMap, LoadShareExtraOptions, UserOptions, Options } from '../type';
 import { SyncWaterfallHook } from './hooks';
 export declare function formatShare(shareArgs: ShareArgs, from: string, name: string): Shared;
-export declare function formatShareConfigs(shareArgs: UserOptions['shared'], from: string): ShareInfos;
+export declare function formatShareConfigs(globalOptions: Options, userOptions: UserOptions): {
+    shared: {
+        [x: string]: Shared[];
+    };
+    shareInfos: ShareInfos;
+};
 export declare function versionLt(a: string, b: string): boolean;
 export declare const findVersion: (shareVersionMap: ShareScopeMap[string][string], cb?: ((prev: string, cur: string) => boolean) | undefined) => string;
 export declare const isLoaded: (shared: Shared) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/runtime",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "author": "zhouxiao <codingzx@gmail.com>",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",
@@ -45,6 +45,6 @@
     }
   },
   "dependencies": {
-    "@module-federation/sdk": "0.1.12"
+    "@module-federation/sdk": "0.1.13"
   }
 }