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

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

@@ -0,0 +1,112 @@
+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];
+};
+export 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 type LoadShareExtraOptions = {
+    customShareInfo?: Partial<Shared>;
+    resolver?: (sharedOptions: ShareInfos[string]) => Shared;
+};
+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;
+    strictVersion?: boolean;
+}
+type SharedBaseArgs = {
+    version?: string;
+    shareConfig?: SharedConfig;
+    scope?: string | Array<string>;
+    deps?: Array<string>;
+    strategy?: 'version-first' | 'loaded-first';
+    loaded?: boolean;
+};
+export type SharedGetter = (() => () => Module) | (() => Promise<() => Module>);
+export type ShareArgs = (SharedBaseArgs & {
+    get: SharedGetter;
+}) | (SharedBaseArgs & {
+    lib: () => Module;
+}) | SharedBaseArgs;
+export type ShareStrategy = 'version-first' | 'loaded-first';
+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;
+    /**
+     * @deprecated set in initOptions.shareStrategy instead
+     */
+    strategy: ShareStrategy;
+};
+export type ShareScopeMap = {
+    [scope: string]: {
+        [pkgName: string]: {
+            [sharedVersion: string]: Shared;
+        };
+    };
+};
+export type GlobalShareScopeMap = {
+    [instanceName: string]: ShareScopeMap;
+};
+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;
+    shareStrategy?: ShareStrategy;
+}
+export type UserOptions = Omit<Optional<Options, 'plugins'>, 'shared' | 'inBrowser'> & {
+    shared?: {
+        [pkgName: string]: ShareArgs | ShareArgs[];
+    };
+};
+export type LoadModuleOptions = {
+    version?: string;
+};
+export type RemoteEntryInitOptions = {
+    version: string;
+    shareScopeMap: ShareScopeMap;
+};
+export type InitTokens = Record<string, Record<string, any>>;
+export type InitScope = InitTokens[];
+export type CallFrom = 'build' | 'runtime';
+export type RemoteEntryExports = {
+    get: (id: string) => () => Promise<Module>;
+    init: (shareScope: ShareScopeMap[string], initScope?: InitScope, remoteEntryInitOPtions?: RemoteEntryInitOptions) => void | Promise<void>;
+};
+export {};

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

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

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

@@ -0,0 +1,34 @@
+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];
+}>;
+type SnapshotLifeCycle = SnapshotHandler['hooks']['lifecycle'];
+type SnapshotLifeCycleCyclePartial = Partial<{
+    [k in keyof SnapshotLifeCycle]: Parameters<SnapshotLifeCycle[k]['on']>[0];
+}>;
+type ModuleLifeCycle = Module['host']['loaderHook']['lifecycle'];
+type ModuleLifeCycleCyclePartial = Partial<{
+    [k in keyof ModuleLifeCycle]: Parameters<ModuleLifeCycle[k]['on']>[0];
+}>;
+type ModuleBridgeLifeCycle = Module['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];
+}>;
+export type FederationRuntimePlugin = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & SharedLifeCycleCyclePartial & RemoteLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & ModuleBridgeLifeCycleCyclePartial & {
+    name: string;
+    version?: string;
+};
+export {};

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

@@ -0,0 +1,26 @@
+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;
+    prefetchInterface?: 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/dist/src/types.d.ts

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

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

@@ -0,0 +1,3 @@
+export { isBrowserEnv, isDebugMode } from '@module-federation/sdk';
+export declare function isDevelopmentMode(): boolean;
+export declare function getBuilderId(): string;

package/dist/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/dist/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/dist/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/dist/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);
+    applyPlugin(plugin: Plugin<T>): void;
+    removePlugin(pluginName: string): void;
+    inherit<T extends PluginSystem<any>>({ lifecycle, registerPlugins, }: T): void;
+}

package/dist/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/dist/src/utils/hooks/syncWaterfallHook.d.ts

@@ -0,0 +1,9 @@
+import { SyncHook } from './syncHook';
+export declare function checkReturnData(originalData: any, returnedData: 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/dist/src/utils/index.d.ts

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

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

@@ -0,0 +1,9 @@
+import { FederationHost } from '../core';
+import { Remote, RemoteEntryExports, RemoteInfo } from '../type';
+export declare function getRemoteEntryUniqueKey(remoteInfo: RemoteInfo): string;
+export declare function getRemoteEntry({ origin, remoteEntryExports, remoteInfo, }: {
+    origin: FederationHost;
+    remoteInfo: RemoteInfo;
+    remoteEntryExports?: RemoteEntryExports | undefined;
+}): Promise<RemoteEntryExports | false | void>;
+export declare function getRemoteInfo(remote: Remote): RemoteInfo;

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

@@ -0,0 +1,6 @@
+declare const logger: import("@module-federation/sdk").Logger;
+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;
+export declare function log(...args: unknown[]): void;
+export { logger };

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

@@ -0,0 +1,7 @@
+import { Remote } from '../type';
+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/dist/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'] | FederationHost['sharedHandler']['hooks'] | FederationHost['remoteHandler']['hooks'] | Module['host']['loaderHook'] | Module['host']['bridgeHook']>): import("../type").FederationRuntimePlugin[] | undefined;

package/dist/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, useLinkPreload?: boolean): void;

package/dist/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/dist/src/utils/semver/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const hyphenRange = "^\\s*([v=\\s]*(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*)))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?)\\s+-\\s+([v=\\s]*(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*)))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?)\\s*$";
+export declare const comparatorTrim = "(\\s*)((?:<|>)?=?)\\s*([v=\\s]*([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-?((?:[0-9]+|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:[0-9]+|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?|[v=\\s]*(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*)))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?)";
+export declare const tildeTrim = "(\\s*)(?:~>?)\\s+";
+export declare const caretTrim = "(\\s*)(?:\\^)\\s+";
+export declare const star = "(<|>)?=?\\s*\\*";
+export declare const caret = "^(?:\\^)[v=\\s]*(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*)))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?$";
+export declare const tilde = "^(?:~>?)[v=\\s]*(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*)))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?$";
+export declare const xRange = "^((?:<|>)?=?)\\s*[v=\\s]*(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:\\.(0|[1-9]\\d*|x|X|\\*)(?:(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*)))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)?)?$";
+export declare const comparator = "^((?:<|>)?=?)\\s*(v?(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][a-zA-Z0-9-]*))*))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?)$|^$";
+export declare const gte0 = "^\\s*>=\\s*0.0.0\\s*$";

package/dist/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/dist/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/dist/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;

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

@@ -0,0 +1,27 @@
+import { Federation } from '../global';
+import { GlobalShareScopeMap, Shared, ShareArgs, ShareInfos, ShareScopeMap, LoadShareExtraOptions, UserOptions, Options, ShareStrategy } from '../type';
+import { SyncWaterfallHook } from './hooks';
+export declare function formatShare(shareArgs: ShareArgs, from: string, name: string, shareStrategy?: ShareStrategy): Shared;
+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) => string;
+export declare const isLoaded: (shared: Shared) => boolean;
+export declare function getRegisteredShare(localShareScopeMap: ShareScopeMap, pkgName: string, shareInfo: Shared, resolveShare: SyncWaterfallHook<{
+    shareScopeMap: ShareScopeMap;
+    scope: string;
+    pkgName: string;
+    version: string;
+    GlobalFederation: Federation;
+    resolver: () => Shared | undefined;
+}>): Shared | void;
+export declare function getGlobalShareScope(): GlobalShareScopeMap;
+export declare function getTargetSharedOptions(options: {
+    pkgName: string;
+    extraOptions?: LoadShareExtraOptions;
+    shareInfos: ShareInfos;
+}): Shared & Partial<Shared>;

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

@@ -0,0 +1,18 @@
+import { RemoteWithEntry, ModuleInfo, RemoteEntryType } from '@module-federation/sdk';
+import { Remote, RemoteInfoOptionalVersion } from '../type';
+export declare function addUniqueItem(arr: Array<string>, item: string): Array<string>;
+export declare function getFMId(remoteInfo: RemoteInfoOptionalVersion | RemoteWithEntry): string;
+export declare function isRemoteInfoWithEntry(remote: Remote): remote is RemoteWithEntry;
+export declare function isPureRemoteEntry(remote: RemoteWithEntry): boolean;
+export declare function safeWrapper<T extends (...args: Array<any>) => any>(callback: T, disableWarn?: boolean): Promise<ReturnType<T> | undefined>;
+export declare function isObject(val: any): boolean;
+export declare const objectToString: () => string;
+export declare function isPlainObject(val: any): val is object;
+export declare function isStaticResourcesEqual(url1: string, url2: string): boolean;
+export declare function arrayOptions<T>(options: T | Array<T>): Array<T>;
+export declare function getRemoteEntryInfoFromSnapshot(snapshot: ModuleInfo): {
+    url: string;
+    type: RemoteEntryType;
+    globalName: string;
+};
+export declare const processModuleAlias: (name: string, subPath: string) => string;

package/dist/types.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/types";

package/dist/types.cjs.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/types";

package/dist/types.esm.js

@@ -0,0 +1 @@
+

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@module-federation/runtime-core",
+  "version": "0.0.0-next-20241115035905",
+  "author": "zhouxiao <codingzx@gmail.com>",
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/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": "0.0.0-next-20241115035905",
+    "@module-federation/error-codes": "0.0.0-next-20241115035905"
+  }
+}