@module-federation/runtime-core 0.0.0-next-20241115035905

package/dist/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@module-federation/runtime-core",
+  "version": "0.6.14",
+  "author": "zhouxiao <codingzx@gmail.com>",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "types": "./dist/index.cjs.d.ts",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.cjs.d.ts",
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js"
+    },
+    "./types": {
+      "types": "./dist/types.cjs.d.ts",
+      "import": "./dist/types.esm.js",
+      "require": "./dist/types.cjs.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.cjs.d.ts"
+      ],
+      "types": [
+        "./dist/types.cjs.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@module-federation/sdk": "workspace:*",
+    "@module-federation/error-codes": "workspace:*"
+  }
+}

package/dist/polyfills.cjs.js

@@ -0,0 +1,28 @@
+'use strict';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+
+exports._extends = _extends;
+exports._object_without_properties_loose = _object_without_properties_loose;

package/dist/polyfills.esm.js

@@ -0,0 +1,25 @@
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+
+export { _extends as _, _object_without_properties_loose as a };

package/dist/src/constant.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_SCOPE = "default";
+export declare const DEFAULT_REMOTE_TYPE = "global";

package/dist/src/core.d.ts

@@ -0,0 +1,105 @@
+import type { CreateScriptHookReturn, ModuleInfo } from '@module-federation/sdk';
+import { Options, PreloadRemoteArgs, RemoteEntryExports, Remote, Shared, ShareInfos, UserOptions, RemoteInfo, ShareScopeMap, InitScope, RemoteEntryInitOptions, CallFrom } from './type';
+import { Module } from './module';
+import { AsyncHook, AsyncWaterfallHook, PluginSystem, SyncHook, SyncWaterfallHook } from './utils/hooks';
+import { SnapshotHandler } from './plugins/snapshot/SnapshotHandler';
+import { SharedHandler } from './shared';
+import { RemoteHandler } from './remote';
+export declare class FederationHost {
+    options: Options;
+    hooks: PluginSystem<{
+        beforeInit: SyncWaterfallHook<{
+            userOptions: UserOptions;
+            options: Options;
+            origin: FederationHost;
+            shareInfo: ShareInfos;
+        }>;
+        init: SyncHook<[{
+            options: Options;
+            origin: FederationHost;
+        }], void>;
+        beforeInitContainer: AsyncWaterfallHook<{
+            shareScope: ShareScopeMap[string];
+            initScope: InitScope;
+            remoteEntryInitOptions: RemoteEntryInitOptions;
+            remoteInfo: RemoteInfo;
+            origin: FederationHost;
+        }>;
+        initContainer: AsyncWaterfallHook<{
+            shareScope: ShareScopeMap[string];
+            initScope: InitScope;
+            remoteEntryInitOptions: RemoteEntryInitOptions;
+            remoteInfo: RemoteInfo;
+            remoteEntryExports: RemoteEntryExports;
+            origin: FederationHost;
+            id: string;
+            remoteSnapshot?: ModuleInfo;
+        }>;
+    }>;
+    version: string;
+    name: string;
+    moduleCache: Map<string, Module>;
+    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>>;
+        getModuleFactory: AsyncHook<[{
+            remoteEntryExports: RemoteEntryExports;
+            expose: string;
+            moduleInfo: RemoteInfo;
+        }], Promise<(() => Promise<Module>) | 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>>;
+    }>;
+    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;
+    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;
+}

package/dist/src/global.d.ts

@@ -0,0 +1,42 @@
+import { FederationHost } from './core';
+import { RemoteEntryExports, GlobalShareScopeMap, Remote, Optional } from './type';
+import { GlobalModuleInfo, ModuleInfo } from '@module-federation/sdk';
+import { FederationRuntimePlugin } from './type/plugin';
+export interface Federation {
+    __GLOBAL_PLUGIN__: Array<FederationRuntimePlugin>;
+    __DEBUG_CONSTRUCTOR_VERSION__?: string;
+    moduleInfo: GlobalModuleInfo;
+    __DEBUG_CONSTRUCTOR__?: typeof FederationHost;
+    __INSTANCES__: Array<FederationHost>;
+    __SHARE__: GlobalShareScopeMap;
+    __MANIFEST_LOADING__: Record<string, Promise<ModuleInfo>>;
+    __PRELOADED_MAP__: Map<string, boolean>;
+}
+export declare const CurrentGlobal: typeof globalThis;
+export declare const nativeGlobal: typeof global;
+export declare const Global: typeof globalThis;
+declare global {
+    var __FEDERATION__: Federation, __VMOK__: Federation, __GLOBAL_LOADING_REMOTE_ENTRY__: Record<string, undefined | Promise<RemoteEntryExports | void>>;
+}
+export declare const globalLoading: Record<string, Promise<void | RemoteEntryExports> | undefined>;
+export declare function resetFederationGlobalInfo(): void;
+export declare function setGlobalFederationInstance(FederationInstance: FederationHost): void;
+export declare function getGlobalFederationConstructor(): typeof FederationHost | undefined;
+export declare function setGlobalFederationConstructor(FederationConstructor: typeof FederationHost | undefined, isDebug?: boolean): void;
+export declare function getInfoWithoutType<T extends object>(target: T, key: keyof T): {
+    value: T[keyof T] | undefined;
+    key: string;
+};
+export declare const getGlobalSnapshot: () => GlobalModuleInfo;
+export declare const getTargetSnapshotInfoByModuleInfo: (moduleInfo: Optional<Remote, "alias">, snapshot: GlobalModuleInfo) => GlobalModuleInfo[string] | undefined;
+export declare const getGlobalSnapshotInfoByModuleInfo: (moduleInfo: Optional<Remote, "alias">) => GlobalModuleInfo[string] | undefined;
+export declare const setGlobalSnapshotInfoByModuleInfo: (remoteInfo: Remote, moduleDetailInfo: GlobalModuleInfo[string]) => GlobalModuleInfo;
+export declare const addGlobalSnapshot: (moduleInfos: GlobalModuleInfo) => (() => void);
+export declare const getRemoteEntryExports: (name: string, globalName: string | undefined) => {
+    remoteEntryKey: string;
+    entryExports: RemoteEntryExports | undefined;
+};
+export declare const registerGlobalPlugins: (plugins: Array<FederationRuntimePlugin>) => void;
+export declare const getGlobalHostPlugins: () => Array<FederationRuntimePlugin>;
+export declare const getPreloaded: (id: string) => boolean | undefined;
+export declare const setPreloaded: (id: string) => Map<string, boolean>;

package/dist/src/helpers.d.ts

@@ -0,0 +1,31 @@
+import { resetFederationGlobalInfo, setGlobalFederationInstance, getGlobalFederationConstructor, setGlobalFederationConstructor, getInfoWithoutType, getGlobalSnapshot, getTargetSnapshotInfoByModuleInfo, getGlobalSnapshotInfoByModuleInfo, setGlobalSnapshotInfoByModuleInfo, addGlobalSnapshot, getRemoteEntryExports, registerGlobalPlugins, getGlobalHostPlugins, getPreloaded, setPreloaded, Global } from './global';
+import { getRegisteredShare, getGlobalShareScope } from './utils/share';
+interface IShareUtils {
+    getRegisteredShare: typeof getRegisteredShare;
+    getGlobalShareScope: typeof getGlobalShareScope;
+}
+interface IGlobalUtils {
+    Global: typeof Global;
+    nativeGlobal: typeof global;
+    resetFederationGlobalInfo: typeof resetFederationGlobalInfo;
+    setGlobalFederationInstance: typeof setGlobalFederationInstance;
+    getGlobalFederationConstructor: typeof getGlobalFederationConstructor;
+    setGlobalFederationConstructor: typeof setGlobalFederationConstructor;
+    getInfoWithoutType: typeof getInfoWithoutType;
+    getGlobalSnapshot: typeof getGlobalSnapshot;
+    getTargetSnapshotInfoByModuleInfo: typeof getTargetSnapshotInfoByModuleInfo;
+    getGlobalSnapshotInfoByModuleInfo: typeof getGlobalSnapshotInfoByModuleInfo;
+    setGlobalSnapshotInfoByModuleInfo: typeof setGlobalSnapshotInfoByModuleInfo;
+    addGlobalSnapshot: typeof addGlobalSnapshot;
+    getRemoteEntryExports: typeof getRemoteEntryExports;
+    registerGlobalPlugins: typeof registerGlobalPlugins;
+    getGlobalHostPlugins: typeof getGlobalHostPlugins;
+    getPreloaded: typeof getPreloaded;
+    setPreloaded: typeof setPreloaded;
+}
+declare const _default: {
+    global: IGlobalUtils;
+    share: IShareUtils;
+};
+export default _default;
+export type { IGlobalUtils, IShareUtils };

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+import helpers, { type IGlobalUtils, type IShareUtils } from './helpers';
+export { FederationHost } from './core';
+export { type Federation, CurrentGlobal, Global, getGlobalFederationConstructor, setGlobalFederationInstance, setGlobalFederationConstructor, resetFederationGlobalInfo, addGlobalSnapshot, getGlobalSnapshot, getInfoWithoutType, } from './global';
+export type { UserOptions, FederationRuntimePlugin } from './type';
+export { assert } from './utils/logger';
+export { registerGlobalPlugins } from './global';
+export { getRemoteEntry, getRemoteInfo, isStaticResourcesEqual, matchRemoteWithNameAndExpose, safeWrapper, } from './utils';
+export { getRegisteredShare } from '../src/utils/share';
+export { loadScript, loadScriptNode } from '@module-federation/sdk';
+export { Module } from './module';
+export * as types from './type';
+export { helpers };
+export { satisfy } from '../src/utils/semver';
+export type { IGlobalUtils, IShareUtils };

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

@@ -0,0 +1,21 @@
+import { ModuleInfo } from '@module-federation/sdk';
+import { FederationHost } from '../core';
+import { RemoteEntryExports, RemoteInfo } from '../type';
+export type ModuleOptions = ConstructorParameters<typeof Module>[0];
+declare class Module {
+    remoteInfo: RemoteInfo;
+    inited: boolean;
+    remoteEntryExports?: RemoteEntryExports;
+    lib: RemoteEntryExports | undefined;
+    host: FederationHost;
+    constructor({ remoteInfo, host, }: {
+        remoteInfo: RemoteInfo;
+        host: FederationHost;
+    });
+    getEntry(): Promise<RemoteEntryExports>;
+    get(id: string, expose: string, options?: {
+        loadFactory?: boolean;
+    }, remoteSnapshot?: ModuleInfo): Promise<any>;
+    private wraperFactory;
+}
+export { Module };

package/dist/src/plugins/generate-preload-assets.d.ts

@@ -0,0 +1,8 @@
+import { GlobalModuleInfo, ModuleInfo } from '@module-federation/sdk';
+import { FederationRuntimePlugin, PreloadAssets, PreloadOptions, RemoteInfoOptionalVersion } from '../type';
+import { FederationHost } from '../core';
+declare global {
+    var __INIT_VMOK_DEPLOY_GLOBAL_DATA__: boolean | undefined;
+}
+export declare function generatePreloadAssets(origin: FederationHost, preloadOptions: PreloadOptions[number], remote: RemoteInfoOptionalVersion, globalSnapshot: GlobalModuleInfo, remoteSnapshot: ModuleInfo): PreloadAssets;
+export declare const generatePreloadAssetsPlugin: () => FederationRuntimePlugin;

package/dist/src/plugins/snapshot/SnapshotHandler.d.ts

@@ -0,0 +1,58 @@
+import { GlobalModuleInfo, Manifest, ModuleInfo } from '@module-federation/sdk';
+import { Options, Remote } from '../../type';
+import { getGlobalSnapshot } from '../../global';
+import { PluginSystem, AsyncHook, AsyncWaterfallHook } from '../../utils/hooks';
+import { FederationHost } from '../../core';
+export declare function getGlobalRemoteInfo(moduleInfo: Remote, origin: FederationHost): {
+    hostGlobalSnapshot: ModuleInfo | undefined;
+    globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
+    remoteSnapshot: GlobalModuleInfo[string] | undefined;
+};
+export declare class SnapshotHandler {
+    loadingHostSnapshot: Promise<GlobalModuleInfo | void> | null;
+    HostInstance: FederationHost;
+    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<{
+            options: Options;
+            moduleInfo: Remote;
+            remoteSnapshot: ModuleInfo;
+        }>;
+    }>;
+    loaderHook: FederationHost['loaderHook'];
+    manifestLoading: Record<string, Promise<ModuleInfo>>;
+    constructor(HostInstance: FederationHost);
+    loadSnapshot(moduleInfo: Remote): Promise<{
+        remoteSnapshot: GlobalModuleInfo[string] | undefined;
+        globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
+    }>;
+    loadRemoteSnapshotInfo(moduleInfo: Remote): Promise<{
+        remoteSnapshot: ModuleInfo;
+        globalSnapshot: GlobalModuleInfo;
+    }> | never;
+    getGlobalRemoteInfo(moduleInfo: Remote): {
+        hostGlobalSnapshot: ModuleInfo | undefined;
+        globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
+        remoteSnapshot: GlobalModuleInfo[string] | undefined;
+    };
+    private getManifestJson;
+}

package/dist/src/plugins/snapshot/index.d.ts

@@ -0,0 +1,5 @@
+import { ModuleInfo } from '@module-federation/sdk';
+import { FederationRuntimePlugin } from '../../type/plugin';
+import { RemoteInfo } from '../../type';
+export declare function assignRemoteInfo(remoteInfo: RemoteInfo, remoteSnapshot: ModuleInfo): void;
+export declare function snapshotPlugin(): FederationRuntimePlugin;

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

@@ -0,0 +1,109 @@
+import { ModuleInfo, GlobalModuleInfo } from '@module-federation/sdk';
+import { Options, UserOptions, PreloadAssets, PreloadOptions, PreloadRemoteArgs, Remote, RemoteInfo, RemoteEntryExports, CallFrom } from '../type';
+import { FederationHost } from '../core';
+import { PluginSystem, AsyncHook, AsyncWaterfallHook, SyncHook, SyncWaterfallHook } 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;
+    idToRemoteMap: Record<string, {
+        name: string;
+        expose: string;
+    }>;
+    hooks: PluginSystem<{
+        beforeRegisterRemote: SyncWaterfallHook<{
+            remote: Remote;
+            origin: FederationHost;
+        }>;
+        registerRemote: SyncWaterfallHook<{
+            remote: Remote;
+            origin: FederationHost;
+        }>;
+        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: CallFrom;
+            lifecycle: "onLoad" | "beforeRequest" | "beforeLoadShare";
+            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>>;
+        loadEntry: AsyncHook<[{
+            loaderHook: FederationHost["loaderHook"];
+            remoteInfo: RemoteInfo;
+            remoteEntryExports?: RemoteEntryExports;
+        }], Promise<RemoteEntryExports>>;
+    }>;
+    constructor(host: FederationHost);
+    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;
+        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,66 @@
+import { Federation } from '../global';
+import { Options, ShareScopeMap, ShareInfos, Shared, UserOptions, ShareStrategy, InitScope, InitTokens, CallFrom } 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;
+            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: SyncWaterfallHook<{
+            shareScope: ShareScopeMap[string];
+            options: Options;
+            origin: FederationHost;
+            scopeName: string;
+            hostShareScopeMap?: ShareScopeMap;
+        }>;
+    }>;
+    initTokens: InitTokens;
+    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, 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;
+}