@ice/mf-runtime 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# @ali/ice-mf-runtime
+
+组件功能描述
+
+## Install
+
+```bash
+$ npm i @ali/ice-mf-runtime --save
+```
+
+## Usage
+
+```jsx
+import IceMfRuntime from '@ali/ice-mf-runtime';
+```

package/es2017/FallBack.d.ts

@@ -0,0 +1,62 @@
+import * as React from 'react';
+interface FallBackOptions {
+    Original: React.ComponentType<any>;
+    remoteVersion?: () => string;
+    hostVersion?: () => string;
+    remoteReactDOM: () => typeof import('react-dom');
+    remoteReact: () => typeof import('react');
+}
+export declare const FallBack: ({ Original, remoteReactDOM, remoteReact, }: FallBackOptions) => {
+    new (props: {}): {
+        containerRef: React.RefObject<HTMLDivElement>;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        mountOriginalComponent(shouldRender?: boolean): void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: {}, context: any): {
+        containerRef: React.RefObject<HTMLDivElement>;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        mountOriginalComponent(shouldRender?: boolean): void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any>;
+};
+export {};

package/es2017/FallBack.js

@@ -0,0 +1,43 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { jsx as _jsx } from "@ice/jsx-runtime/jsx-runtime";
+import * as React from 'react';
+class Component extends React.Component {
+    render() {
+        const { containerRef } = this.props;
+        return /*#__PURE__*/ _jsx("div", {
+            ref: containerRef
+        });
+    }
+}
+export const FallBack = ({ Original, remoteReactDOM, remoteReact })=>{
+    const ReactDOM = remoteReactDOM();
+    const React = remoteReact();
+    class WrappedComponent extends React.Component {
+        componentDidMount() {
+            this.mountOriginalComponent(true);
+        }
+        componentDidUpdate() {
+            this.mountOriginalComponent();
+        }
+        componentWillUnmount() {
+            if (this.containerRef.current) {
+                ReactDOM.unmountComponentAtNode(this.containerRef.current);
+            }
+        }
+        mountOriginalComponent(shouldRender = false) {
+            const element = React.createElement(Original, this.props);
+            const renderMethod = shouldRender ? ReactDOM.render : ReactDOM.hydrate;
+            renderMethod(element, this.containerRef.current);
+        }
+        render() {
+            return /*#__PURE__*/ _jsx(Component, {
+                containerRef: this.containerRef
+            });
+        }
+        constructor(...args){
+            super(...args);
+            _define_property(this, "containerRef", React.createRef());
+        }
+    }
+    return WrappedComponent;
+};

package/es2017/RemoteModule.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+interface RemoteModuleOptions {
+    module: string;
+    scope: string;
+    runtime?: {
+        react: typeof import('react');
+        reactDOM: typeof import('react-dom');
+    };
+    publicPath?: string;
+    LoadingComponent?: React.ReactNode;
+}
+export declare const RemoteModule: ({ module, scope, runtime, publicPath, LoadingComponent, }: RemoteModuleOptions) => string | number | true | Iterable<React.ReactNode> | React.JSX.Element;
+export {};

package/es2017/RemoteModule.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "@ice/jsx-runtime/jsx-runtime";
+import { loadRemote } from '@module-federation/runtime';
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { FallBack } from './FallBack';
+import { setFederatedModulePublicPath } from './set-public-path';
+function useDynamicImport({ module, scope }) {
+    const [component, setComponent] = useState(null);
+    useEffect(()=>{
+        if (!module || !scope) return;
+        const loadComponent = async ()=>{
+            try {
+                const res = await loadRemote(`${scope}/${module}`);
+                setComponent(res);
+            } catch (error) {
+                console.error(`Error loading remote module ${scope}/${module}:`, error);
+            }
+        };
+        loadComponent();
+    }, [
+        module,
+        scope
+    ]);
+    return component;
+}
+export const RemoteModule = ({ module, scope, runtime, publicPath, LoadingComponent })=>{
+    var _remoteModule;
+    if (publicPath) {
+        setFederatedModulePublicPath(scope, publicPath);
+    }
+    const remoteModule = useDynamicImport({
+        module,
+        scope
+    });
+    let Component = null;
+    if ((_remoteModule = remoteModule) === null || _remoteModule === void 0 ? void 0 : _remoteModule.default) {
+        if (runtime) {
+            const { react, reactDOM } = runtime;
+            const w = FallBack({
+                Original: remoteModule.default,
+                remoteReact: ()=>react,
+                remoteReactDOM: ()=>reactDOM
+            });
+            Component = w;
+        } else {
+            Component = /*#__PURE__*/ React.lazy(()=>Promise.resolve({
+                    default: remoteModule.default
+                }));
+        }
+    } else {
+        Component = remoteModule;
+    }
+    const Loading = LoadingComponent || /*#__PURE__*/ _jsx("div", {
+        children: "Loading..."
+    });
+    if (Component) {
+        return /*#__PURE__*/ _jsx(React.Suspense, {
+            fallback: Loading,
+            children: /*#__PURE__*/ _jsx(Component, {})
+        });
+    }
+    return Loading;
+};

package/es2017/index.d.ts

@@ -0,0 +1,5 @@
+import type { ExtendedUserOptions } from './types';
+export { loadRemote, registerPlugins } from '@module-federation/runtime';
+export * from './FallBack';
+export * from './RemoteModule';
+export declare function init(options: ExtendedUserOptions): void;

package/es2017/index.js

@@ -0,0 +1,11 @@
+import { registerPlugins, init as mfInit } from '@module-federation/runtime';
+import { runtimePlugin } from './runtime-plugin';
+export { loadRemote, registerPlugins } from '@module-federation/runtime';
+export * from './FallBack';
+export * from './RemoteModule';
+export function init(options) {
+    mfInit(options);
+    registerPlugins([
+        runtimePlugin()
+    ]);
+}

package/es2017/mf-global-store.d.ts

@@ -0,0 +1,27 @@
+import type { ExtraInfo, ExtendedUserOptions } from './types';
+export interface RemoteModuleInfo {
+    key: string;
+    name: string;
+    entry: string;
+    hostName: string;
+    version?: string;
+    extraInfo?: ExtraInfo;
+}
+export interface HostRemoteInfo {
+    keys: Set<string>;
+    nameKeyMap: Map<string, string>;
+    conflictingModules: Set<string>;
+}
+declare global {
+    interface Window {
+        __MF_GLOBAL_STORE__: {
+            remotes: Map<string, RemoteModuleInfo>;
+            hostRemotes: Map<string, HostRemoteInfo>;
+        };
+    }
+}
+export declare function initGlobalStore(options: ExtendedUserOptions): void;
+export declare function generateRemoteKey(name: string, entry: string): string;
+export declare function getRemoteInfoFromStore(hostName: string, remoteName: string): RemoteModuleInfo | undefined;
+export declare function hasConflict(hostName: string, remoteName: string): boolean;
+export declare function getExtraInfo(hostName: string, remoteName: string): ExtraInfo;

package/es2017/mf-global-store.js

@@ -0,0 +1,66 @@
+export function initGlobalStore(options) {
+    if (!window.__MF_GLOBAL_STORE__) {
+        window.__MF_GLOBAL_STORE__ = {
+            remotes: new Map(),
+            hostRemotes: new Map()
+        };
+    }
+    const store = window.__MF_GLOBAL_STORE__;
+    const hostInfo = {
+        keys: new Set(),
+        nameKeyMap: new Map(),
+        conflictingModules: new Set()
+    };
+    // 更新每个 remote 模块的信息
+    options.remotes.forEach((remote)=>{
+        if (!remote.name) return;
+        const { entry } = remote;
+        const remoteKey = generateRemoteKey(remote.name, entry);
+        const newInfo = {
+            key: remoteKey,
+            name: remote.name,
+            entry,
+            hostName: options.name,
+            extraInfo: remote.extraInfo
+        };
+        // 记录这个 host 使用的 remote key 和 name 到 key 的映射
+        hostInfo.keys.add(remoteKey);
+        hostInfo.nameKeyMap.set(remote.name, remoteKey);
+        // 检查是否与现有模块冲突
+        for (const [, info] of store.remotes.entries()){
+            if (info.name === remote.name && info.entry !== entry) {
+                console.warn(`[Module Federation] Remote module "${remote.name}" has multiple versions:`, `\nHost "${info.hostName}": ${info.entry}`, `\nHost "${options.name}": ${entry}`);
+                // 在 host 环境中标记该模块存在冲突
+                hostInfo.conflictingModules.add(remote.name);
+            }
+        }
+        store.remotes.set(remoteKey, newInfo);
+    });
+    // 更新 host 的 remote 信息
+    store.hostRemotes.set(options.name, hostInfo);
+}
+// 生成 remote 模块的唯一标识
+export function generateRemoteKey(name, entry) {
+    return `${name}@${entry}`;
+}
+export function getRemoteInfoFromStore(hostName, remoteName) {
+    const store = window.__MF_GLOBAL_STORE__;
+    const hostInfo = store.hostRemotes.get(hostName);
+    if (!hostInfo) return undefined;
+    const remoteKey = hostInfo.nameKeyMap.get(remoteName);
+    if (!remoteKey) return undefined;
+    return store.remotes.get(remoteKey);
+}
+// 检查指定的 remote 模块在当前 host 环境中是否存在冲突
+export function hasConflict(hostName, remoteName) {
+    var _hostInfo;
+    const store = window.__MF_GLOBAL_STORE__;
+    const hostInfo = store.hostRemotes.get(hostName);
+    var _hostInfo_conflictingModules_has;
+    return (_hostInfo_conflictingModules_has = (_hostInfo = hostInfo) === null || _hostInfo === void 0 ? void 0 : _hostInfo.conflictingModules.has(remoteName)) !== null && _hostInfo_conflictingModules_has !== void 0 ? _hostInfo_conflictingModules_has : false;
+}
+export function getExtraInfo(hostName, remoteName) {
+    var _remoteInfo;
+    const remoteInfo = getRemoteInfoFromStore(hostName, remoteName);
+    return (_remoteInfo = remoteInfo) === null || _remoteInfo === void 0 ? void 0 : _remoteInfo.extraInfo;
+}

package/es2017/runtime-plugin.d.ts

@@ -0,0 +1,2 @@
+import { type FederationRuntimePlugin } from '@module-federation/runtime';
+export declare const runtimePlugin: () => FederationRuntimePlugin;

package/es2017/runtime-plugin.js

@@ -0,0 +1,101 @@
+import * as React from 'react';
+import { getExtraInfo, getRemoteInfoFromStore, hasConflict } from './mf-global-store';
+const loadRemotePackagedReactAndRender = async (args)=>{
+    var _args_origin_options_shared_reactdom_, _args_origin_options_shared_reactdom, _args_origin_options_shared, _args_origin_options, _remoteInstance_options_shared_reactdom_, _remoteInstance_options_shared_reactdom, _remoteInstance_options_shared, _remoteInstance_options;
+    const hostVersion = ((_args_origin_options = args.origin.options) === null || _args_origin_options === void 0 ? void 0 : (_args_origin_options_shared = _args_origin_options.shared) === null || _args_origin_options_shared === void 0 ? void 0 : (_args_origin_options_shared_reactdom = _args_origin_options_shared['react-dom']) === null || _args_origin_options_shared_reactdom === void 0 ? void 0 : (_args_origin_options_shared_reactdom_ = _args_origin_options_shared_reactdom[0]) === null || _args_origin_options_shared_reactdom_ === void 0 ? void 0 : _args_origin_options_shared_reactdom_.version) || React.version;
+    const remoteInstance = __FEDERATION__.__INSTANCES__.find(// @ts-expect-error wrong type
+    (instance)=>instance.name === args.remote.name);
+    const remoteVersion = remoteInstance ? (_remoteInstance_options = remoteInstance.options) === null || _remoteInstance_options === void 0 ? void 0 : (_remoteInstance_options_shared = _remoteInstance_options.shared) === null || _remoteInstance_options_shared === void 0 ? void 0 : (_remoteInstance_options_shared_reactdom = _remoteInstance_options_shared['react-dom']) === null || _remoteInstance_options_shared_reactdom === void 0 ? void 0 : (_remoteInstance_options_shared_reactdom_ = _remoteInstance_options_shared_reactdom[0]) === null || _remoteInstance_options_shared_reactdom_ === void 0 ? void 0 : _remoteInstance_options_shared_reactdom_.version : false;
+    if (remoteVersion && hostVersion && remoteVersion !== hostVersion) {
+        var _sharedOptions_find;
+        const remoteReactDOM = await remoteInstance.loadShare('react-dom', {
+            resolver: (sharedOptions)=>(_sharedOptions_find = sharedOptions.find((i)=>i.version === remoteVersion)) !== null && _sharedOptions_find !== void 0 ? _sharedOptions_find : sharedOptions[0]
+        });
+        var _sharedOptions_find1;
+        const remoteReact = await remoteInstance.loadShare('react', {
+            resolver: (sharedOptions)=>(_sharedOptions_find1 = sharedOptions.find((i)=>i.version === remoteVersion)) !== null && _sharedOptions_find1 !== void 0 ? _sharedOptions_find1 : sharedOptions[0]
+        });
+        if (!remoteReact || !remoteReactDOM) {
+            return null;
+        }
+        const res = (await import('./FallBack')).FallBack;
+        return ()=>res({
+                Original: args.exposeModule.default,
+                remoteVersion: ()=>remoteVersion,
+                hostVersion: ()=>hostVersion,
+                remoteReactDOM: remoteReactDOM,
+                remoteReact: remoteReact
+            });
+    }
+    return null;
+};
+export const runtimePlugin = ()=>({
+        name: 'ice-runtime-plugin',
+        afterResolve (args) {
+            var _extraInfo;
+            const hostName = args.options.name;
+            const remoteName = args.remote.name;
+            const extraInfo = getExtraInfo(hostName, remoteName);
+            if ((_extraInfo = extraInfo) === null || _extraInfo === void 0 ? void 0 : _extraInfo.legacy) {
+                if (args.expose.startsWith('./')) {
+                    args.expose = args.expose.slice(2);
+                }
+            }
+            return args;
+        },
+        async onLoad (args) {
+            var _args_origin_options_shared_reactdom_, _args_origin_options_shared_reactdom, _args_origin_options_shared, _args_origin_options, _extraInfo;
+            const hostName = args.origin.name;
+            const remoteName = args.remote.name;
+            const hostVersion = ((_args_origin_options = args.origin.options) === null || _args_origin_options === void 0 ? void 0 : (_args_origin_options_shared = _args_origin_options.shared) === null || _args_origin_options_shared === void 0 ? void 0 : (_args_origin_options_shared_reactdom = _args_origin_options_shared['react-dom']) === null || _args_origin_options_shared_reactdom === void 0 ? void 0 : (_args_origin_options_shared_reactdom_ = _args_origin_options_shared_reactdom[0]) === null || _args_origin_options_shared_reactdom_ === void 0 ? void 0 : _args_origin_options_shared_reactdom_.version) || React.version;
+            const extraInfo = getExtraInfo(hostName, remoteName);
+            if ((_extraInfo = extraInfo) === null || _extraInfo === void 0 ? void 0 : _extraInfo.external) {
+                const externalReact = extraInfo.external['react'];
+                const externalReactDOM = extraInfo.external['react-dom'];
+                if (externalReact && externalReactDOM) {
+                    const remoteReact = ()=>window[externalReact];
+                    const remoteReactDOM = ()=>window[externalReactDOM];
+                    if (remoteReactDOM().version === hostVersion) {
+                        console.log('[runtime Plugin onLoad] use same external react');
+                        return args;
+                    }
+                    // 当 external 版本不一致，走降级渲染
+                    const res = (await import('./FallBack')).FallBack;
+                    return ()=>res({
+                            Original: args.exposeModule.default,
+                            remoteReactDOM: remoteReactDOM,
+                            remoteReact: remoteReact
+                        });
+                }
+            }
+            const fallBackRender = await loadRemotePackagedReactAndRender(args);
+            if (fallBackRender) {
+                return fallBackRender;
+            }
+            return args;
+        },
+        async beforeRequest (args) {
+            const remoteName = args.id.split('/')[0];
+            const hostName = args.options.name;
+            if (!hasConflict(hostName, remoteName)) {
+                return args;
+            }
+            const newRemoteInfo = getRemoteInfoFromStore(hostName, remoteName);
+            if (!newRemoteInfo) {
+                return args;
+            }
+            const requestRemote = args.options.remotes.find((remote)=>remote.name === remoteName);
+            if (requestRemote) {
+                requestRemote.entry = newRemoteInfo.entry;
+            }
+            const hostInstance = __FEDERATION__.__INSTANCES__.find((instance)=>instance.name === hostName);
+            if (hostInstance) {
+                hostInstance.moduleCache.delete(remoteName);
+                hostInstance.options.remotes.find((remote)=>remote.name === remoteName).entry = newRemoteInfo.entry;
+            }
+            args.origin.moduleCache.delete(remoteName);
+            // @ts-expect-error for global module
+            window[remoteName] = null;
+            return args;
+        }
+    });

package/es2017/set-public-path.d.ts

@@ -0,0 +1,2 @@
+export declare const ensureSlash: (input: string, needSlash: boolean, position: 'tail' | 'head') => string;
+export declare const setFederatedModulePublicPath: (scope: string, publicPath: string) => void;

package/es2017/set-public-path.js

@@ -0,0 +1,28 @@
+export const ensureSlash = (input, needSlash, position)=>{
+    if (input == null) return input;
+    if (position === 'head') {
+        const startWithSlash = input.startsWith('/');
+        if (startWithSlash && !needSlash) {
+            return input.slice(1);
+        } else if (!startWithSlash && needSlash) {
+            return `/${input}`;
+        }
+        return input;
+    } else if (position === 'tail') {
+        const endsWithSlash = input.endsWith('/');
+        if (endsWithSlash && !needSlash) {
+            return input.substr(0, input.length - 1);
+        } else if (!endsWithSlash && needSlash) {
+            return `${input}/`;
+        } else {
+            return input;
+        }
+    } else {
+        return input;
+    }
+};
+export const setFederatedModulePublicPath = (scope, publicPath)=>{
+    const publicPathReference = `${scope}_public_path`;
+    // @ts-expect-error for global public path
+    window[publicPathReference] = ensureSlash(publicPath, true, 'tail');
+};

package/es2017/types.d.ts

@@ -0,0 +1,12 @@
+import type { UserOptions } from '@module-federation/runtime-core';
+import type { Remote } from '@module-federation/runtime-core/dist/src/types';
+export interface ExtraInfo {
+    external?: Record<string, string>;
+    legacy?: boolean;
+}
+export type ExtendedRemote = Remote & {
+    extraInfo?: ExtraInfo;
+};
+export interface ExtendedUserOptions extends Omit<UserOptions, 'remotes'> {
+    remotes: ExtendedRemote[];
+}

package/es2017/types.js

@@ -0,0 +1 @@
+export { };

package/es2017/typings.d.ts

@@ -0,0 +1 @@
+/// <reference types="@ice/pkg/types" />

package/esm/FallBack.d.ts

@@ -0,0 +1,62 @@
+import * as React from 'react';
+interface FallBackOptions {
+    Original: React.ComponentType<any>;
+    remoteVersion?: () => string;
+    hostVersion?: () => string;
+    remoteReactDOM: () => typeof import('react-dom');
+    remoteReact: () => typeof import('react');
+}
+export declare const FallBack: ({ Original, remoteReactDOM, remoteReact, }: FallBackOptions) => {
+    new (props: {}): {
+        containerRef: React.RefObject<HTMLDivElement>;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        mountOriginalComponent(shouldRender?: boolean): void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: {}, context: any): {
+        containerRef: React.RefObject<HTMLDivElement>;
+        componentDidMount(): void;
+        componentDidUpdate(): void;
+        componentWillUnmount(): void;
+        mountOriginalComponent(shouldRender?: boolean): void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any>;
+};
+export {};

package/esm/FallBack.js

@@ -0,0 +1,87 @@
+import { _ as _assert_this_initialized } from "@swc/helpers/_/_assert_this_initialized";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _inherits } from "@swc/helpers/_/_inherits";
+import { _ as _create_super } from "@swc/helpers/_/_create_super";
+import { jsx as _jsx } from "@ice/jsx-runtime/jsx-runtime";
+import * as React from "react";
+var Component = /*#__PURE__*/ function(_React_Component) {
+    "use strict";
+    _inherits(Component, _React_Component);
+    var _super = _create_super(Component);
+    function Component() {
+        _class_call_check(this, Component);
+        return _super.apply(this, arguments);
+    }
+    _create_class(Component, [
+        {
+            key: "render",
+            value: function render() {
+                var containerRef = this.props.containerRef;
+                return /*#__PURE__*/ _jsx("div", {
+                    ref: containerRef
+                });
+            }
+        }
+    ]);
+    return Component;
+}(React.Component);
+export var FallBack = function(param) {
+    var Original = param.Original, remoteReactDOM = param.remoteReactDOM, remoteReact = param.remoteReact;
+    var ReactDOM = remoteReactDOM();
+    var _$React = remoteReact();
+    var WrappedComponent = /*#__PURE__*/ function(_React_Component) {
+        "use strict";
+        _inherits(WrappedComponent, _React_Component);
+        var _super = _create_super(WrappedComponent);
+        function WrappedComponent() {
+            _class_call_check(this, WrappedComponent);
+            var _this;
+            _this = _super.apply(this, arguments);
+            _define_property(_assert_this_initialized(_this), "containerRef", _$React.createRef());
+            return _this;
+        }
+        _create_class(WrappedComponent, [
+            {
+                key: "componentDidMount",
+                value: function componentDidMount() {
+                    this.mountOriginalComponent(true);
+                }
+            },
+            {
+                key: "componentDidUpdate",
+                value: function componentDidUpdate() {
+                    this.mountOriginalComponent();
+                }
+            },
+            {
+                key: "componentWillUnmount",
+                value: function componentWillUnmount() {
+                    if (this.containerRef.current) {
+                        ReactDOM.unmountComponentAtNode(this.containerRef.current);
+                    }
+                }
+            },
+            {
+                key: "mountOriginalComponent",
+                value: function mountOriginalComponent() {
+                    var shouldRender = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+                    var element = _$React.createElement(Original, this.props);
+                    var renderMethod = shouldRender ? ReactDOM.render : ReactDOM.hydrate;
+                    renderMethod(element, this.containerRef.current);
+                }
+            },
+            {
+                key: "render",
+                value: function render() {
+                    return /*#__PURE__*/ _jsx(Component, {
+                        containerRef: this.containerRef
+                    });
+                }
+            }
+        ]);
+        return WrappedComponent;
+    }(_$React.Component);
+    return WrappedComponent;
+};

package/esm/RemoteModule.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+interface RemoteModuleOptions {
+    module: string;
+    scope: string;
+    runtime?: {
+        react: typeof import('react');
+        reactDOM: typeof import('react-dom');
+    };
+    publicPath?: string;
+    LoadingComponent?: React.ReactNode;
+}
+export declare const RemoteModule: ({ module, scope, runtime, publicPath, LoadingComponent, }: RemoteModuleOptions) => string | number | true | Iterable<React.ReactNode> | React.JSX.Element;
+export {};

package/esm/RemoteModule.js

@@ -0,0 +1,107 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { jsx as _jsx } from "@ice/jsx-runtime/jsx-runtime";
+import { loadRemote } from "@module-federation/runtime";
+import * as React from "react";
+import { useEffect, useState } from "react";
+import { FallBack } from "./FallBack";
+import { setFederatedModulePublicPath } from "./set-public-path";
+function useDynamicImport(param) {
+    var module = param.module, scope = param.scope;
+    var _useState = _sliced_to_array(useState(null), 2), component = _useState[0], setComponent = _useState[1];
+    useEffect(function() {
+        if (!module || !scope) return;
+        var loadComponent = function() {
+            var _ref = _async_to_generator(function() {
+                var res, error;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            _state.trys.push([
+                                0,
+                                2,
+                                ,
+                                3
+                            ]);
+                            return [
+                                4,
+                                loadRemote("".concat(scope, "/").concat(module))
+                            ];
+                        case 1:
+                            res = _state.sent();
+                            setComponent(res);
+                            return [
+                                3,
+                                3
+                            ];
+                        case 2:
+                            error = _state.sent();
+                            console.error("Error loading remote module ".concat(scope, "/").concat(module, ":"), error);
+                            return [
+                                3,
+                                3
+                            ];
+                        case 3:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            });
+            return function loadComponent() {
+                return _ref.apply(this, arguments);
+            };
+        }();
+        loadComponent();
+    }, [
+        module,
+        scope
+    ]);
+    return component;
+}
+export var RemoteModule = function(param) {
+    var module = param.module, scope = param.scope, runtime = param.runtime, publicPath = param.publicPath, LoadingComponent = param.LoadingComponent;
+    var _remoteModule;
+    if (publicPath) {
+        setFederatedModulePublicPath(scope, publicPath);
+    }
+    var remoteModule = useDynamicImport({
+        module: module,
+        scope: scope
+    });
+    var Component = null;
+    if ((_remoteModule = remoteModule) === null || _remoteModule === void 0 ? void 0 : _remoteModule.default) {
+        if (runtime) {
+            var react = runtime.react, reactDOM = runtime.reactDOM;
+            var w = FallBack({
+                Original: remoteModule.default,
+                remoteReact: function() {
+                    return react;
+                },
+                remoteReactDOM: function() {
+                    return reactDOM;
+                }
+            });
+            Component = w;
+        } else {
+            Component = /*#__PURE__*/ React.lazy(function() {
+                return Promise.resolve({
+                    default: remoteModule.default
+                });
+            });
+        }
+    } else {
+        Component = remoteModule;
+    }
+    var Loading = LoadingComponent || /*#__PURE__*/ _jsx("div", {
+        children: "Loading..."
+    });
+    if (Component) {
+        return /*#__PURE__*/ _jsx(React.Suspense, {
+            fallback: Loading,
+            children: /*#__PURE__*/ _jsx(Component, {})
+        });
+    }
+    return Loading;
+};

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+import type { ExtendedUserOptions } from './types';
+export { loadRemote, registerPlugins } from '@module-federation/runtime';
+export * from './FallBack';
+export * from './RemoteModule';
+export declare function init(options: ExtendedUserOptions): void;

package/esm/index.js

@@ -0,0 +1,11 @@
+import { registerPlugins, init as mfInit } from "@module-federation/runtime";
+import { runtimePlugin } from "./runtime-plugin";
+export { loadRemote, registerPlugins } from "@module-federation/runtime";
+export * from "./FallBack";
+export * from "./RemoteModule";
+export function init(options) {
+    mfInit(options);
+    registerPlugins([
+        runtimePlugin()
+    ]);
+}

package/esm/mf-global-store.d.ts

@@ -0,0 +1,27 @@
+import type { ExtraInfo, ExtendedUserOptions } from './types';
+export interface RemoteModuleInfo {
+    key: string;
+    name: string;
+    entry: string;
+    hostName: string;
+    version?: string;
+    extraInfo?: ExtraInfo;
+}
+export interface HostRemoteInfo {
+    keys: Set<string>;
+    nameKeyMap: Map<string, string>;
+    conflictingModules: Set<string>;
+}
+declare global {
+    interface Window {
+        __MF_GLOBAL_STORE__: {
+            remotes: Map<string, RemoteModuleInfo>;
+            hostRemotes: Map<string, HostRemoteInfo>;
+        };
+    }
+}
+export declare function initGlobalStore(options: ExtendedUserOptions): void;
+export declare function generateRemoteKey(name: string, entry: string): string;
+export declare function getRemoteInfoFromStore(hostName: string, remoteName: string): RemoteModuleInfo | undefined;
+export declare function hasConflict(hostName: string, remoteName: string): boolean;
+export declare function getExtraInfo(hostName: string, remoteName: string): ExtraInfo;

package/esm/mf-global-store.js

@@ -0,0 +1,84 @@
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+export function initGlobalStore(options) {
+    if (!window.__MF_GLOBAL_STORE__) {
+        window.__MF_GLOBAL_STORE__ = {
+            remotes: new Map(),
+            hostRemotes: new Map()
+        };
+    }
+    var store = window.__MF_GLOBAL_STORE__;
+    var hostInfo = {
+        keys: new Set(),
+        nameKeyMap: new Map(),
+        conflictingModules: new Set()
+    };
+    // 更新每个 remote 模块的信息
+    options.remotes.forEach(function(remote) {
+        if (!remote.name) return;
+        var entry = remote.entry;
+        var remoteKey = generateRemoteKey(remote.name, entry);
+        var newInfo = {
+            key: remoteKey,
+            name: remote.name,
+            entry: entry,
+            hostName: options.name,
+            extraInfo: remote.extraInfo
+        };
+        // 记录这个 host 使用的 remote key 和 name 到 key 的映射
+        hostInfo.keys.add(remoteKey);
+        hostInfo.nameKeyMap.set(remote.name, remoteKey);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            // 检查是否与现有模块冲突
+            for(var _iterator = store.remotes.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), info = _step_value[1];
+                if (info.name === remote.name && info.entry !== entry) {
+                    console.warn('[Module Federation] Remote module "'.concat(remote.name, '" has multiple versions:'), '\nHost "'.concat(info.hostName, '": ').concat(info.entry), '\nHost "'.concat(options.name, '": ').concat(entry));
+                    // 在 host 环境中标记该模块存在冲突
+                    hostInfo.conflictingModules.add(remote.name);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        store.remotes.set(remoteKey, newInfo);
+    });
+    // 更新 host 的 remote 信息
+    store.hostRemotes.set(options.name, hostInfo);
+}
+// 生成 remote 模块的唯一标识
+export function generateRemoteKey(name, entry) {
+    return "".concat(name, "@").concat(entry);
+}
+export function getRemoteInfoFromStore(hostName, remoteName) {
+    var store = window.__MF_GLOBAL_STORE__;
+    var hostInfo = store.hostRemotes.get(hostName);
+    if (!hostInfo) return undefined;
+    var remoteKey = hostInfo.nameKeyMap.get(remoteName);
+    if (!remoteKey) return undefined;
+    return store.remotes.get(remoteKey);
+}
+// 检查指定的 remote 模块在当前 host 环境中是否存在冲突
+export function hasConflict(hostName, remoteName) {
+    var _hostInfo;
+    var store = window.__MF_GLOBAL_STORE__;
+    var hostInfo = store.hostRemotes.get(hostName);
+    var _hostInfo_conflictingModules_has;
+    return (_hostInfo_conflictingModules_has = (_hostInfo = hostInfo) === null || _hostInfo === void 0 ? void 0 : _hostInfo.conflictingModules.has(remoteName)) !== null && _hostInfo_conflictingModules_has !== void 0 ? _hostInfo_conflictingModules_has : false;
+}
+export function getExtraInfo(hostName, remoteName) {
+    var _remoteInfo;
+    var remoteInfo = getRemoteInfoFromStore(hostName, remoteName);
+    return (_remoteInfo = remoteInfo) === null || _remoteInfo === void 0 ? void 0 : _remoteInfo.extraInfo;
+}

package/esm/runtime-plugin.d.ts

@@ -0,0 +1,2 @@
+import { type FederationRuntimePlugin } from '@module-federation/runtime';
+export declare const runtimePlugin: () => FederationRuntimePlugin;

package/esm/runtime-plugin.js

@@ -0,0 +1,215 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import * as React from "react";
+import { getExtraInfo, getRemoteInfoFromStore, hasConflict } from "./mf-global-store";
+var loadRemotePackagedReactAndRender = function() {
+    var _ref = _async_to_generator(function(args) {
+        var _args_origin_options_shared_reactdom_, _args_origin_options_shared_reactdom, _args_origin_options_shared, _args_origin_options, _remoteInstance_options_shared_reactdom_, _remoteInstance_options_shared_reactdom, _remoteInstance_options_shared, _remoteInstance_options, hostVersion, remoteInstance, remoteVersion, _sharedOptions_find, remoteReactDOM, _sharedOptions_find1, remoteReact, res;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    hostVersion = ((_args_origin_options = args.origin.options) === null || _args_origin_options === void 0 ? void 0 : (_args_origin_options_shared = _args_origin_options.shared) === null || _args_origin_options_shared === void 0 ? void 0 : (_args_origin_options_shared_reactdom = _args_origin_options_shared["react-dom"]) === null || _args_origin_options_shared_reactdom === void 0 ? void 0 : (_args_origin_options_shared_reactdom_ = _args_origin_options_shared_reactdom[0]) === null || _args_origin_options_shared_reactdom_ === void 0 ? void 0 : _args_origin_options_shared_reactdom_.version) || React.version;
+                    remoteInstance = __FEDERATION__.__INSTANCES__.find(// @ts-expect-error wrong type
+                    function(instance) {
+                        return instance.name === args.remote.name;
+                    });
+                    remoteVersion = remoteInstance ? (_remoteInstance_options = remoteInstance.options) === null || _remoteInstance_options === void 0 ? void 0 : (_remoteInstance_options_shared = _remoteInstance_options.shared) === null || _remoteInstance_options_shared === void 0 ? void 0 : (_remoteInstance_options_shared_reactdom = _remoteInstance_options_shared["react-dom"]) === null || _remoteInstance_options_shared_reactdom === void 0 ? void 0 : (_remoteInstance_options_shared_reactdom_ = _remoteInstance_options_shared_reactdom[0]) === null || _remoteInstance_options_shared_reactdom_ === void 0 ? void 0 : _remoteInstance_options_shared_reactdom_.version : false;
+                    if (!(remoteVersion && hostVersion && remoteVersion !== hostVersion)) return [
+                        3,
+                        4
+                    ];
+                    return [
+                        4,
+                        remoteInstance.loadShare("react-dom", {
+                            resolver: function(sharedOptions) {
+                                return (_sharedOptions_find = sharedOptions.find(function(i) {
+                                    return i.version === remoteVersion;
+                                })) !== null && _sharedOptions_find !== void 0 ? _sharedOptions_find : sharedOptions[0];
+                            }
+                        })
+                    ];
+                case 1:
+                    remoteReactDOM = _state.sent();
+                    return [
+                        4,
+                        remoteInstance.loadShare("react", {
+                            resolver: function(sharedOptions) {
+                                return (_sharedOptions_find1 = sharedOptions.find(function(i) {
+                                    return i.version === remoteVersion;
+                                })) !== null && _sharedOptions_find1 !== void 0 ? _sharedOptions_find1 : sharedOptions[0];
+                            }
+                        })
+                    ];
+                case 2:
+                    remoteReact = _state.sent();
+                    if (!remoteReact || !remoteReactDOM) {
+                        return [
+                            2,
+                            null
+                        ];
+                    }
+                    return [
+                        4,
+                        import("./FallBack")
+                    ];
+                case 3:
+                    res = _state.sent().FallBack;
+                    return [
+                        2,
+                        function() {
+                            return res({
+                                Original: args.exposeModule.default,
+                                remoteVersion: function() {
+                                    return remoteVersion;
+                                },
+                                hostVersion: function() {
+                                    return hostVersion;
+                                },
+                                remoteReactDOM: remoteReactDOM,
+                                remoteReact: remoteReact
+                            });
+                        }
+                    ];
+                case 4:
+                    return [
+                        2,
+                        null
+                    ];
+            }
+        });
+    });
+    return function loadRemotePackagedReactAndRender(args) {
+        return _ref.apply(this, arguments);
+    };
+}();
+export var runtimePlugin = function() {
+    return {
+        name: "ice-runtime-plugin",
+        afterResolve: function afterResolve(args) {
+            var _extraInfo;
+            var hostName = args.options.name;
+            var remoteName = args.remote.name;
+            var extraInfo = getExtraInfo(hostName, remoteName);
+            if ((_extraInfo = extraInfo) === null || _extraInfo === void 0 ? void 0 : _extraInfo.legacy) {
+                if (args.expose.startsWith("./")) {
+                    args.expose = args.expose.slice(2);
+                }
+            }
+            return args;
+        },
+        onLoad: function onLoad(args) {
+            return _async_to_generator(function() {
+                var _args_origin_options_shared_reactdom_, _args_origin_options_shared_reactdom, _args_origin_options_shared, _args_origin_options, _extraInfo, hostName, remoteName, hostVersion, extraInfo, externalReact, externalReactDOM, remoteReact, remoteReactDOM, res, fallBackRender;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            hostName = args.origin.name;
+                            remoteName = args.remote.name;
+                            hostVersion = ((_args_origin_options = args.origin.options) === null || _args_origin_options === void 0 ? void 0 : (_args_origin_options_shared = _args_origin_options.shared) === null || _args_origin_options_shared === void 0 ? void 0 : (_args_origin_options_shared_reactdom = _args_origin_options_shared["react-dom"]) === null || _args_origin_options_shared_reactdom === void 0 ? void 0 : (_args_origin_options_shared_reactdom_ = _args_origin_options_shared_reactdom[0]) === null || _args_origin_options_shared_reactdom_ === void 0 ? void 0 : _args_origin_options_shared_reactdom_.version) || React.version;
+                            extraInfo = getExtraInfo(hostName, remoteName);
+                            if (!((_extraInfo = extraInfo) === null || _extraInfo === void 0 ? void 0 : _extraInfo.external)) return [
+                                3,
+                                2
+                            ];
+                            externalReact = extraInfo.external["react"];
+                            externalReactDOM = extraInfo.external["react-dom"];
+                            if (!(externalReact && externalReactDOM)) return [
+                                3,
+                                2
+                            ];
+                            remoteReact = function() {
+                                return window[externalReact];
+                            };
+                            remoteReactDOM = function() {
+                                return window[externalReactDOM];
+                            };
+                            if (remoteReactDOM().version === hostVersion) {
+                                console.log("[runtime Plugin onLoad] use same external react");
+                                return [
+                                    2,
+                                    args
+                                ];
+                            }
+                            return [
+                                4,
+                                import("./FallBack")
+                            ];
+                        case 1:
+                            res = _state.sent().FallBack;
+                            return [
+                                2,
+                                function() {
+                                    return res({
+                                        Original: args.exposeModule.default,
+                                        remoteReactDOM: remoteReactDOM,
+                                        remoteReact: remoteReact
+                                    });
+                                }
+                            ];
+                        case 2:
+                            return [
+                                4,
+                                loadRemotePackagedReactAndRender(args)
+                            ];
+                        case 3:
+                            fallBackRender = _state.sent();
+                            if (fallBackRender) {
+                                return [
+                                    2,
+                                    fallBackRender
+                                ];
+                            }
+                            return [
+                                2,
+                                args
+                            ];
+                    }
+                });
+            })();
+        },
+        beforeRequest: function beforeRequest(args) {
+            return _async_to_generator(function() {
+                var remoteName, hostName, newRemoteInfo, requestRemote, hostInstance;
+                return _ts_generator(this, function(_state) {
+                    remoteName = args.id.split("/")[0];
+                    hostName = args.options.name;
+                    if (!hasConflict(hostName, remoteName)) {
+                        return [
+                            2,
+                            args
+                        ];
+                    }
+                    newRemoteInfo = getRemoteInfoFromStore(hostName, remoteName);
+                    if (!newRemoteInfo) {
+                        return [
+                            2,
+                            args
+                        ];
+                    }
+                    requestRemote = args.options.remotes.find(function(remote) {
+                        return remote.name === remoteName;
+                    });
+                    if (requestRemote) {
+                        requestRemote.entry = newRemoteInfo.entry;
+                    }
+                    hostInstance = __FEDERATION__.__INSTANCES__.find(function(instance) {
+                        return instance.name === hostName;
+                    });
+                    if (hostInstance) {
+                        hostInstance.moduleCache.delete(remoteName);
+                        hostInstance.options.remotes.find(function(remote) {
+                            return remote.name === remoteName;
+                        }).entry = newRemoteInfo.entry;
+                    }
+                    args.origin.moduleCache.delete(remoteName);
+                    // @ts-expect-error for global module
+                    window[remoteName] = null;
+                    return [
+                        2,
+                        args
+                    ];
+                });
+            })();
+        }
+    };
+};

package/esm/set-public-path.d.ts

@@ -0,0 +1,2 @@
+export declare const ensureSlash: (input: string, needSlash: boolean, position: 'tail' | 'head') => string;
+export declare const setFederatedModulePublicPath: (scope: string, publicPath: string) => void;

package/esm/set-public-path.js

@@ -0,0 +1,28 @@
+export var ensureSlash = function(input, needSlash, position) {
+    if (input == null) return input;
+    if (position === "head") {
+        var startWithSlash = input.startsWith("/");
+        if (startWithSlash && !needSlash) {
+            return input.slice(1);
+        } else if (!startWithSlash && needSlash) {
+            return "/".concat(input);
+        }
+        return input;
+    } else if (position === "tail") {
+        var endsWithSlash = input.endsWith("/");
+        if (endsWithSlash && !needSlash) {
+            return input.substr(0, input.length - 1);
+        } else if (!endsWithSlash && needSlash) {
+            return "".concat(input, "/");
+        } else {
+            return input;
+        }
+    } else {
+        return input;
+    }
+};
+export var setFederatedModulePublicPath = function(scope, publicPath) {
+    var publicPathReference = "".concat(scope, "_public_path");
+    // @ts-expect-error for global public path
+    window[publicPathReference] = ensureSlash(publicPath, true, "tail");
+};

package/esm/types.d.ts

@@ -0,0 +1,12 @@
+import type { UserOptions } from '@module-federation/runtime-core';
+import type { Remote } from '@module-federation/runtime-core/dist/src/types';
+export interface ExtraInfo {
+    external?: Record<string, string>;
+    legacy?: boolean;
+}
+export type ExtendedRemote = Remote & {
+    extraInfo?: ExtraInfo;
+};
+export interface ExtendedUserOptions extends Omit<UserOptions, 'remotes'> {
+    remotes: ExtendedRemote[];
+}

package/esm/types.js

@@ -0,0 +1 @@
+export { };

package/esm/typings.d.ts

@@ -0,0 +1 @@
+/// <reference types="@ice/pkg/types" />

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@ice/mf-runtime",
+  "version": "0.0.1",
+  "description": "组件功能描述",
+  "files": [
+    "esm",
+    "es2017",
+    "cjs",
+    "dist"
+  ],
+  "main": "esm/index.js",
+  "module": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "exports": {
+    ".": {
+      "es2017": {
+        "types": "./es2017/index.d.ts",
+        "default": "./es2017/index.js"
+      },
+      "default": {
+        "types": "./esm/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./*": "./*"
+  },
+  "sideEffects": [
+    "dist/*",
+    "*.scss",
+    "*.less",
+    "*.css"
+  ],
+  "scripts": {
+    "start": "ice-pkg start",
+    "build": "ice-pkg build",
+    "prepublishOnly": "npm run build",
+    "eslint": "eslint --cache --ext .js,.jsx,.ts,.tsx ./",
+    "eslint:fix": "npm run eslint -- --fix",
+    "stylelint": "stylelint \"**/*.{css,scss,less}\"",
+    "lint": "npm run eslint && npm run stylelint"
+  },
+  "keywords": [
+    "ice",
+    "react",
+    "component"
+  ],
+  "dependencies": {
+    "@ice/jsx-runtime": "^0.2.0",
+    "@module-federation/runtime": "^0.11.2",
+    "@module-federation/runtime-core": "^0.11.2",
+    "@swc/helpers": "^0.5.1"
+  },
+  "devDependencies": {
+    "@ali/pkg-plugin-dev": "^1.0.0",
+    "@ali/pkg-plugin-dev-client": "^1.0.0",
+    "@applint/spec": "^1.2.3",
+    "@ice/pkg": "^1.0.0",
+    "@ice/runtime": "^1.0.0",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "eslint": "^8.0.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "stylelint": "^15.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "react": "^16 || ^17 || ^18"
+  },
+  "license": "MIT"
+}