@module-federation/runtime 1.0.0-canary.1

package/src/constant.d.ts

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

package/src/core.d.ts

@@ -0,0 +1,113 @@
+import type { ModuleInfo, GlobalModuleInfo } from '@module-federation/sdk';
+import { Options, PreloadAssets, PreloadOptions, PreloadRemoteArgs, Remote, Shared, ShareInfos, UserOptions, RemoteInfo } from './type';
+import { Module, ModuleOptions } from './module';
+import { AsyncHook, AsyncWaterfallHook, PluginSystem, SyncHook, SyncWaterfallHook } from './utils/hooks';
+import { SnapshotHandler } from './plugins/snapshot/SnapshotHandler';
+interface LoadRemoteMatch {
+    id: string;
+    pkgNameOrAlias: string;
+    expose: string;
+    remote: Remote;
+    options: Options;
+    origin: FederationHost;
+    remoteInfo: RemoteInfo;
+}
+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>;
+        beforeLoadRemote: AsyncWaterfallHook<{
+            id: string;
+            options: Options;
+            origin: FederationHost;
+        }>;
+        loadRemoteMatch: AsyncWaterfallHook<LoadRemoteMatch>;
+        loadRemote: AsyncHook<[{
+            id: string;
+            expose: string;
+            pkgNameOrAlias: string;
+            remote: Remote;
+            options: ModuleOptions;
+            origin: FederationHost;
+            exposeModule: any;
+            exposeModuleFactory: any;
+            moduleInstance: Module;
+        }], void>;
+        errorLoadRemote: AsyncHook<[{
+            id: string;
+            error: unknown;
+        }], void>;
+        beforeLoadShare: AsyncWaterfallHook<{
+            pkgName: string;
+            shareInfo?: Shared | undefined;
+            shared: Options['shared'];
+            origin: FederationHost;
+        }>;
+        loadShare: AsyncHook<[FederationHost, string, ShareInfos], false | void | Promise<false | void>>;
+        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;
+    loaderHook: PluginSystem<{
+        getModuleInfo: SyncHook<[{
+            target: Record<string, any>;
+            key: any;
+        }], void | {
+            value: any | undefined;
+            key: string;
+        }>;
+        createScript: SyncHook<[{
+            url: string;
+        }], void | HTMLScriptElement>;
+    }>;
+    loadingShare: {
+        [key: string]: Promise<any>;
+    };
+    constructor(userOptions: UserOptions);
+    initOptions(userOptions: UserOptions): Options;
+    loadShare<T>(pkgName: string, customShareInfo?: Partial<Shared>): Promise<false | (() => T | undefined)>;
+    loadShareSync<T>(pkgName: string): () => T | never;
+    private _getRemoteModuleAndOptions;
+    loadRemote<T>(id: string, options?: {
+        loadFactory?: boolean;
+    }): Promise<T | null>;
+    preloadRemote(preloadOptions: Array<PreloadRemoteArgs>): Promise<void>;
+    /**
+     * The sharing init sequence function (only runs once per share scope).
+     * Has one argument, the name of the share scope.
+     * Creates a share scope if not existing
+     */
+    initializeSharing(shareScopeName?: string): boolean | Promise<boolean>;
+    private formatOptions;
+    private registerPlugins;
+    private setShared;
+}
+export {};

package/src/global.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+import { FederationHost } from './core';
+import { RemoteEntryExports, GlobalShareScope, Remote, Optional } from './type';
+import { GlobalModuleInfo, ModuleInfo } from '@module-federation/sdk';
+import { FederationRuntimePlugin } from './type/plugin';
+export type Federation = {
+    __GLOBAL_PLUGIN__: Array<FederationRuntimePlugin>;
+    __DEBUG_CONSTRUCTOR_VERSION__?: string;
+    moduleInfo: GlobalModuleInfo;
+    __DEBUG_CONSTRUCTOR__?: typeof FederationHost;
+    __INSTANCES__: Array<FederationHost>;
+    __SHARE__: GlobalShareScope;
+    __MANIFEST_LOADING__: Record<string, Promise<ModuleInfo>>;
+    __SHARE_SCOPE_LOADING__: Record<string, boolean | Promise<boolean>>;
+    __PRELOADED_MAP__: Map<string, boolean>;
+};
+export declare const nativeGlobal: typeof global;
+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 const Global: {
+    readonly __FEDERATION__: Federation;
+};
+export declare function resetFederationGlobalInfo(): void;
+export declare function getGlobalFederationInstance(name: string, version: string | undefined): FederationHost | undefined;
+export declare function setGlobalFederationInstance(FederationInstance: FederationHost): void;
+export declare function getGlobalFederationConstructor(): typeof FederationHost | undefined;
+export declare function setGlobalFederationConstructor(FederationConstructor: typeof FederationHost): void;
+export declare function getInfoWithoutType<T extends object>(target: T, key: keyof T, getModuleInfoHook?: (target: any, key: string | number | symbol) => {
+    value: any | undefined;
+    key: string;
+} | void): {
+    value: T[keyof T] | undefined;
+    key: string;
+};
+export declare const getGlobalSnapshot: () => GlobalModuleInfo;
+export declare const getTargetSnapshotInfoByModuleInfo: (moduleInfo: Optional<Remote, 'alias'>, snapshot: GlobalModuleInfo, getModuleInfoHook?: ((target: any, key: string | number | symbol) => void | {
+    value: any | undefined;
+    key: string;
+}) | undefined) => GlobalModuleInfo[string] | undefined;
+export declare const getGlobalSnapshotInfoByModuleInfo: (moduleInfo: Optional<Remote, 'alias'>, extraOptions?: {
+    getModuleInfoHook?: ((target: any, key: string | number | symbol) => void | {
+        value: any | undefined;
+        key: string;
+    }) | undefined;
+} | undefined) => 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/src/helpers.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { resetFederationGlobalInfo, getGlobalFederationInstance, setGlobalFederationInstance, getGlobalFederationConstructor, setGlobalFederationConstructor, getInfoWithoutType, getGlobalSnapshot, getTargetSnapshotInfoByModuleInfo, getGlobalSnapshotInfoByModuleInfo, setGlobalSnapshotInfoByModuleInfo, addGlobalSnapshot, getRemoteEntryExports, registerGlobalPlugins, getGlobalHostPlugins, getPreloaded, setPreloaded } from './global';
+import { getGlobalShare, getGlobalShareScope } from './utils/share';
+interface IShareUtils {
+    getGlobalShare: typeof getGlobalShare;
+    getGlobalShareScope: typeof getGlobalShareScope;
+}
+interface IGlobalUtils {
+    nativeGlobal: typeof global;
+    resetFederationGlobalInfo: typeof resetFederationGlobalInfo;
+    getGlobalFederationInstance: typeof getGlobalFederationInstance;
+    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/src/index.d.ts

@@ -0,0 +1,10 @@
+import { FederationHost } from './core';
+import { UserOptions } from './type';
+export { FederationHost } from './core';
+export { registerGlobalPlugins } from './global';
+export { loadScript } from './utils';
+export declare function init(options: UserOptions): FederationHost;
+export declare function loadRemote(...args: Parameters<FederationHost['loadRemote']>): ReturnType<FederationHost['loadRemote']>;
+export declare function loadShare(...args: Parameters<FederationHost['loadShare']>): ReturnType<FederationHost['loadShare']>;
+export declare function loadShareSync(...args: Parameters<FederationHost['loadShareSync']>): ReturnType<FederationHost['loadShareSync']>;
+export declare function preloadRemote(...args: Parameters<FederationHost['preloadRemote']>): ReturnType<FederationHost['preloadRemote']>;

package/src/module/index.d.ts

@@ -0,0 +1,25 @@
+import { FederationHost } from '../core';
+import { RemoteEntryExports, Options, Remote, ShareInfos, RemoteInfo } from '../type';
+export type ModuleOptions = ConstructorParameters<typeof Module>[0];
+type HostInfo = Remote;
+declare class Module {
+    hostInfo: HostInfo;
+    remoteInfo: RemoteInfo;
+    inited: boolean;
+    shared: ShareInfos;
+    remoteEntryExports?: RemoteEntryExports;
+    lib: RemoteEntryExports | undefined;
+    loaderHook: FederationHost['loaderHook'];
+    constructor({ hostInfo, remoteInfo, shared, loaderHook, }: {
+        hostInfo: HostInfo;
+        remoteInfo: RemoteInfo;
+        shared: ShareInfos;
+        plugins: Options['plugins'];
+        loaderHook: FederationHost['loaderHook'];
+    });
+    getEntry(): Promise<RemoteEntryExports>;
+    get(expose: string, options?: {
+        loadFactory?: boolean;
+    }): Promise<any>;
+}
+export { Module };

package/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/src/plugins/snapshot/SnapshotHandler.d.ts

@@ -0,0 +1,43 @@
+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 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<import("@module-federation/sdk").BasicStatsMetaData, import("@module-federation/sdk").ManifestRemoteCommonInfo> | undefined;
+            manifestUrl?: string | undefined;
+            remoteSnapshot: ModuleInfo;
+            from: 'global' | 'manifest';
+        }>;
+    }>;
+    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;
+    private getGlobalRemoteInfo;
+    private getManifestJson;
+}

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

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

package/src/type/config.d.ts

@@ -0,0 +1,94 @@
+import type { RemoteWithEntry, RemoteWithVersion, Module, RemoteEntryType } from '@module-federation/sdk';
+import { FederationRuntimePlugin } from './plugin';
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+export type PartialOptional<T, K extends keyof T> = Omit<T, K> & {
+    [P in K]-?: T[P];
+};
+interface RemoteInfoCommon {
+    alias?: string;
+    shareScope?: string;
+    type?: RemoteEntryType;
+    entryGlobalName?: string;
+}
+export type RemoteInfoOptionalVersion = {
+    name: string;
+    version?: string;
+} & RemoteInfoCommon;
+export type Remote = (RemoteWithEntry | RemoteWithVersion) & RemoteInfoCommon;
+export interface RemoteInfo {
+    name: string;
+    version?: string;
+    buildVersion?: string;
+    entry: string;
+    type: RemoteEntryType;
+    entryGlobalName: string;
+    shareScope: string;
+}
+export type HostInfo = Pick<Options, 'name' | 'version' | 'remotes' | 'version'>;
+export interface SharedConfig {
+    singleton?: boolean;
+    requiredVersion: false | string;
+    eager?: boolean;
+}
+type SharedBaseArgs = {
+    version: string;
+    shareConfig?: SharedConfig;
+    scope?: string | Array<string>;
+    deps?: Array<string>;
+    strategy?: 'version-first' | 'loaded-first';
+};
+export type ShareArgs = (SharedBaseArgs & {
+    get: () => () => Module | Promise<() => Module>;
+}) | (SharedBaseArgs & {
+    lib: () => Module;
+});
+export type SharedGetter = () => () => Promise<() => Module> | Module;
+export 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;
+    strategy: 'version-first' | 'loaded-first';
+};
+export type GlobalShareScope = {
+    [scope: string]: {
+        [pkgName: string]: {
+            [sharedVersion: string]: Shared;
+        };
+    };
+};
+export type ShareInfos = {
+    [pkgName: string]: Shared;
+};
+export interface Options {
+    id?: string;
+    name: string;
+    version?: string;
+    remotes: Array<Remote>;
+    shared: ShareInfos;
+    plugins: Array<FederationRuntimePlugin>;
+    inBrowser: boolean;
+}
+export type UserOptions = Omit<Optional<Options, 'plugins'>, 'shared' | 'inBrowser'> & {
+    shared?: {
+        [pkgName: string]: ShareArgs;
+    };
+};
+export type LoadModuleOptions = {
+    version?: string;
+};
+export type RemoteEntryInitOptions = {
+    version: string;
+};
+export type RemoteEntryExports = {
+    get: (id: string) => () => Promise<Module>;
+    init: (shareScope: GlobalShareScope[string], initScope?: Array<Record<string, never>>, remoteEntryInitOPtions?: RemoteEntryInitOptions) => void;
+};
+export {};

package/src/type/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './plugin';
+export * from './preload';

package/src/type/plugin.d.ts

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

package/src/type/preload.d.ts

@@ -0,0 +1,25 @@
+import { Remote, RemoteInfo } from './config';
+export type depsPreloadArg = Omit<PreloadRemoteArgs, 'depsRemote'>;
+export interface PreloadRemoteArgs {
+    nameOrAlias: string;
+    exposes?: Array<string>;
+    resourceCategory?: 'all' | 'sync';
+    share?: boolean;
+    depsRemote?: boolean | Array<depsPreloadArg>;
+    filter?: (assetUrl: string) => boolean;
+}
+export type PreloadConfig = PreloadRemoteArgs;
+export type PreloadOptions = Array<{
+    remote: Remote;
+    preloadConfig: PreloadConfig;
+}>;
+export type EntryAssets = {
+    name: string;
+    url: string;
+    moduleInfo: RemoteInfo;
+};
+export interface PreloadAssets {
+    cssAssets: Array<string>;
+    jsAssetsWithoutEntry: Array<string>;
+    entryAssets: Array<EntryAssets>;
+}

package/src/types.d.ts

@@ -0,0 +1 @@
+export * from './type';

package/src/utils/dom.d.ts

@@ -0,0 +1,8 @@
+export declare function createScript(url: string, cb: (value: void | PromiseLike<void>) => void, attrs?: Record<string, any>, createScriptHook?: (url: string) => HTMLScriptElement | void): {
+    script: HTMLScriptElement;
+    needAttach: boolean;
+};
+export declare function loadScript(url: string, info: {
+    attrs?: Record<string, any>;
+    createScriptHook?: (url: string) => HTMLScriptElement | void;
+}): Promise<void>;

package/src/utils/env.d.ts

@@ -0,0 +1,4 @@
+export declare function isDevelopmentMode(): boolean;
+export declare function getBuilderId(): string;
+export declare function isDebugMode(): boolean;
+export declare function isBrowserEnv(): boolean;

package/src/utils/hooks/asyncHook.d.ts

@@ -0,0 +1,6 @@
+import { ArgsType, SyncHook } from './syncHook';
+type CallbackReturnType = void | false | Promise<void | false>;
+export declare class AsyncHook<T, ExternalEmitReturnType = CallbackReturnType> extends SyncHook<T, ExternalEmitReturnType> {
+    emit(...data: ArgsType<T>): Promise<void | false | ExternalEmitReturnType>;
+}
+export {};

package/src/utils/hooks/asyncWaterfallHooks.d.ts

@@ -0,0 +1,10 @@
+import { SyncHook } from './syncHook';
+type CallbackReturnType<T> = T | Promise<T>;
+export 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>;
+}
+export {};

package/src/utils/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { SyncHook } from './syncHook';
+export { AsyncHook } from './asyncHook';
+export { SyncWaterfallHook } from './syncWaterfallHook';
+export { AsyncWaterfallHook } from './asyncWaterfallHooks';
+export { PluginSystem } from './pluginSystem';
+export type { Plugin } from './pluginSystem';

package/src/utils/hooks/pluginSystem.d.ts

@@ -0,0 +1,15 @@
+export type Plugin<T extends Record<string, any>> = {
+    [k in keyof T]?: Parameters<T[k]['on']>[0];
+} & {
+    name: string;
+    version?: string;
+};
+export declare class PluginSystem<T extends Record<string, any>> {
+    lifecycle: T;
+    lifecycleKeys: Array<keyof T>;
+    registerPlugins: Record<string, Plugin<T>>;
+    constructor(lifecycle: T);
+    usePlugin(plugin: Plugin<T>): void;
+    removePlugin(pluginName: string): void;
+    inherit<T extends PluginSystem<any>>({ lifecycle, registerPlugins, }: T): void;
+}

package/src/utils/hooks/syncHook.d.ts

@@ -0,0 +1,12 @@
+export type Callback<T, K> = (...args: ArgsType<T>) => K;
+export type ArgsType<T> = T extends Array<any> ? T : Array<any>;
+export 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;
+}

package/src/utils/hooks/syncWaterfallHook.d.ts

@@ -0,0 +1,9 @@
+import { SyncHook } from './syncHook';
+export declare function checkReturnData(originData: any, returnData: any): boolean;
+export 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;
+}

package/src/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './env';
+export * from './tool';
+export * from './manifest';
+export * from './logger';
+export * from './dom';
+export * from './plugin';

package/src/utils/load.d.ts

@@ -0,0 +1,17 @@
+import { Remote, RemoteEntryExports, RemoteInfo } from '../type';
+export declare function loadEsmEntry({ entry, remoteEntryExports, }: {
+    entry: string;
+    remoteEntryExports: RemoteEntryExports | undefined;
+}): Promise<RemoteEntryExports>;
+export declare function loadEntryScript({ name, globalName, entry, createScriptHook, }: {
+    name: string;
+    globalName: string;
+    entry: string;
+    createScriptHook?: (url: string) => HTMLScriptElement | void;
+}): Promise<RemoteEntryExports>;
+export declare function getRemoteEntry({ remoteEntryExports, remoteInfo, createScriptHook, }: {
+    remoteInfo: RemoteInfo;
+    remoteEntryExports?: RemoteEntryExports | undefined;
+    createScriptHook?: (url: string) => HTMLScriptElement | void;
+}): Promise<RemoteEntryExports | void>;
+export declare function getRemoteInfo(remote: Remote): RemoteInfo;

package/src/utils/logger.d.ts

@@ -0,0 +1,3 @@
+export declare function assert(condition: any, msg: string): asserts condition;
+export declare function error(msg: string | Error | unknown): never;
+export declare function warn(msg: Parameters<typeof console.warn>[0]): void;

package/src/utils/manifest.d.ts

@@ -0,0 +1,9 @@
+import { ModuleInfo } from '@module-federation/sdk';
+import { Remote } from '../type';
+export declare function getResourceUrl(module: ModuleInfo, sourceUrl: string): string;
+export declare function matchRemoteWithNameAndExpose(remotes: Array<Remote>, id: string): {
+    pkgNameOrAlias: string;
+    expose: string;
+    remote: Remote;
+} | undefined;
+export declare function matchRemote(remotes: Array<Remote>, nameOrAlias: string): Remote | undefined;

package/src/utils/plugin.d.ts

@@ -0,0 +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['loaderHook']>): void;

package/src/utils/preload.d.ts

@@ -0,0 +1,6 @@
+import { PreloadAssets, PreloadConfig, PreloadOptions, PreloadRemoteArgs, Remote, RemoteInfo, depsPreloadArg } from '../type';
+import { FederationHost } from '../core';
+export declare function defaultPreloadArgs(preloadConfig: PreloadRemoteArgs | depsPreloadArg): PreloadConfig;
+export declare function formatPreloadArgs(remotes: Array<Remote>, preloadArgs: Array<PreloadRemoteArgs>): PreloadOptions;
+export declare function normalizePreloadExposes(exposes?: string[]): string[];
+export declare function preloadAssets(remoteInfo: RemoteInfo, host: FederationHost, assets: PreloadAssets): void;

package/src/utils/semver/compare.d.ts

@@ -0,0 +1,9 @@
+export interface CompareAtom {
+    operator: string;
+    version: string;
+    major: string;
+    minor: string;
+    patch: string;
+    preRelease?: string[];
+}
+export declare function compare(rangeAtom: CompareAtom, versionAtom: CompareAtom): boolean;

package/src/utils/semver/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const hyphenRange: string;
+export declare const comparatorTrim: string;
+export declare const tildeTrim: string;
+export declare const caretTrim: string;
+export declare const star = "(<|>)?=?\\s*\\*";
+export declare const caret: string;
+export declare const tilde: string;
+export declare const xRange: string;
+export declare const comparator: string;
+export declare const gte0 = "^\\s*>=\\s*0.0.0\\s*$";

package/src/utils/semver/index.d.ts

@@ -0,0 +1,2 @@
+export declare function satisfy(version: string, range: string): boolean;
+export declare function isLegallyVersion(version: string): boolean;

package/src/utils/semver/parser.d.ts

@@ -0,0 +1,9 @@
+export declare function parseHyphen(range: string): string;
+export declare function parseComparatorTrim(range: string): string;
+export declare function parseTildeTrim(range: string): string;
+export declare function parseCaretTrim(range: string): string;
+export declare function parseCarets(range: string): string;
+export declare function parseTildes(range: string): string;
+export declare function parseXRanges(range: string): string;
+export declare function parseStar(range: string): string;
+export declare function parseGTE0(comparatorString: string): string;

package/src/utils/semver/utils.d.ts

@@ -0,0 +1,11 @@
+export declare function parseRegex(source: string): RegExp;
+export declare function isXVersion(version: string): boolean;
+export declare function pipe<TArgs extends any[], R1, R2, R3, R4, R5, R6, R7>(f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (...args: TArgs) => R7;
+export declare function pipe<TArgs extends any[], R1, R2, R3, R4, R5, R6>(f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: TArgs) => R6;
+export declare function pipe<TArgs extends any[], R1, R2, R3, R4, R5>(f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: TArgs) => R5;
+export declare function pipe<TArgs extends any[], R1, R2, R3, R4>(f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: TArgs) => R4;
+export declare function pipe<TArgs extends any[], R1, R2, R3>(f1: (...args: TArgs) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: TArgs) => R3;
+export declare function pipe<TArgs extends any[], R1, R2>(f1: (...args: TArgs) => R1, f2: (a: R1) => R2): (...args: TArgs) => R2;
+export declare function pipe<TArgs extends any[], R1>(f1: (...args: TArgs) => R1): (...args: TArgs) => R1;
+export declare function extractComparator(comparatorString: string): RegExpMatchArray | null;
+export declare function combineVersion(major: string, minor: string, patch: string, preRelease: string): string;