remote-reload-utils 0.0.13 → 0.0.16

package/dist/main.cjs

@@ -1,14 +1,5 @@
 "use strict";
 var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
 (()=>{
     __webpack_require__.d = (exports1, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
@@ -36,39 +27,31 @@ __webpack_require__.d(__webpack_exports__, {
     compareVersions: ()=>compareVersions,
     fetchAvailableVersions: ()=>fetchAvailableVersions,
     sortVersions: ()=>sortVersions,
-    useRemoteModuleHook: ()=>useRemoteModuleHook,
     registerRemoteInstance: ()=>registerRemoteInstance,
     fallbackPlugin: ()=>fallbackPlugin,
     createEventBus: ()=>createEventBus,
-    withRemote: ()=>withRemote,
     getPreloadStatus: ()=>getPreloadStatus,
     parseVersion: ()=>parseVersion,
     resolveFinalVersion: ()=>resolveFinalVersion,
     buildFinalUrls: ()=>buildFinalUrls,
     fetchLatestVersion: ()=>fetchLatestVersion,
-    ErrorBoundary: ()=>ErrorBoundary,
-    getFinalSharedConfig: ()=>getFinalSharedConfig,
     isRemoteLoaded: ()=>isRemoteLoaded,
+    getFinalSharedConfig: ()=>getFinalSharedConfig,
     tryLoadRemote: ()=>tryLoadRemote,
     getVersionCache: ()=>getVersionCache,
     eventBus: ()=>eventBus,
-    RemoteModuleRenderer: ()=>RemoteModuleRenderer,
-    clearPreloadCache: ()=>clearPreloadCache,
     loadRemoteMultiVersion: ()=>loadRemoteMultiVersion,
+    clearPreloadCache: ()=>clearPreloadCache,
+    loadReactVersion: ()=>loadReactVersion,
     getRemoteHealthReport: ()=>getRemoteHealthReport,
-    checkModuleLoadable: ()=>checkModuleLoadable,
     getStableVersions: ()=>getStableVersions,
-    extractMajorVersion: ()=>extractMajorVersion,
+    checkModuleLoadable: ()=>checkModuleLoadable,
     buildCdnUrls: ()=>buildCdnUrls,
-    loadReactVersion: ()=>loadReactVersion,
+    extractMajorVersion: ()=>extractMajorVersion,
     preloadRemoteList: ()=>preloadRemoteList,
-    SuspenseRemoteLoader: ()=>SuspenseRemoteLoader,
     registerLoadedModule: ()=>registerLoadedModule,
-    getCompatibleReactVersions: ()=>getCompatibleReactVersions,
-    SuspenseRemote: ()=>SuspenseRemote,
     unloadRemote: ()=>unloadRemote,
-    useRemoteModule: ()=>useRemoteModule,
-    RemoteModuleProvider: ()=>RemoteModuleProvider,
+    getCompatibleReactVersions: ()=>getCompatibleReactVersions,
     cancelPreload: ()=>cancelPreload,
     findCompatibleVersion: ()=>findCompatibleVersion,
     getLoadedRemotes: ()=>getLoadedRemotes,
@@ -78,9 +61,8 @@ __webpack_require__.d(__webpack_exports__, {
     formatHealthStatus: ()=>formatHealthStatus,
     unloadAll: ()=>unloadAll,
     setVersionCache: ()=>setVersionCache,
-    lazyRemote: ()=>lazyRemote,
-    checkRemoteHealth: ()=>checkRemoteHealth,
     isPrerelease: ()=>isPrerelease,
+    checkRemoteHealth: ()=>checkRemoteHealth,
     checkVersionCompatibility: ()=>checkVersionCompatibility
 });
 const runtime_namespaceObject = require("@module-federation/enhanced/runtime");
@@ -265,15 +247,46 @@ const DEFAULT_SHARED_CONFIG = {
         shareConfig: {
             singleton: true,
             eager: true,
-            requiredVersion: false
-        }
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
     },
     'react-dom': {
         shareConfig: {
             singleton: true,
             eager: true,
-            requiredVersion: false
-        }
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
+    },
+    'react-dom/client': {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
+    },
+    'react/jsx-runtime': {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
+    },
+    'react/jsx-dev-runtime': {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
     }
 };
 async function fetchLatestVersion(pkg) {
@@ -308,41 +321,146 @@ function setVersionCache(pkg, version) {
 function buildCdnUrls(pkg, version) {
     return DEFAULT_CDN_TEMPLATES.map((template)=>template.replace('{pkg}', pkg).replace('{version}', version));
 }
+const mfInstanceCache = new Map();
+const mfInstanceLoadingCache = new Map();
 async function tryLoadRemote(scopeName, url, retries, delay, sharedConfig, plugins) {
-    let lastError;
-    for(let i = 0; i < retries; i++)try {
-        const mf = (0, runtime_namespaceObject.createInstance)({
-            name: 'host',
-            remotes: [
-                {
-                    name: scopeName,
-                    entry: url
-                }
-            ],
-            shared: sharedConfig,
-            plugins: [
-                ...plugins,
-                fallbackPlugin()
-            ]
+    const cacheKey = `${scopeName}::${url}`;
+    const cachedMfs = mfInstanceCache.get(cacheKey);
+    if (cachedMfs) return {
+        scopeName,
+        mf: cachedMfs
+    };
+    const loadingMfs = mfInstanceLoadingCache.get(cacheKey);
+    if (loadingMfs) return loadingMfs;
+    const createProcess = (async ()=>{
+        let lastError;
+        for(let i = 0; i < retries; i++)try {
+            const mf = (0, runtime_namespaceObject.createInstance)({
+                name: 'host',
+                remotes: [
+                    {
+                        name: scopeName,
+                        entry: url
+                    }
+                ],
+                shared: sharedConfig,
+                plugins: [
+                    ...plugins,
+                    fallbackPlugin()
+                ]
+            });
+            const result = {
+                scopeName,
+                mf
+            };
+            mfInstanceCache.set(cacheKey, mf);
+            return result;
+        } catch (e) {
+            lastError = e;
+            console.warn(`[MF] URL ${url} 加载失败，第 ${i + 1} 次重试...`);
+            if (i < retries - 1) await new Promise((res)=>setTimeout(res, delay));
+        }
+        throw new Error(`[MF] URL ${url} 经过 ${retries} 次重试仍加载失败。`, {
+            cause: lastError
         });
-        return {
-            scopeName,
-            mf
-        };
-    } catch (e) {
-        lastError = e;
-        console.warn(`[MF] URL ${url} 加载失败，第 ${i + 1} 次重试...`);
-        if (i < retries - 1) await new Promise((res)=>setTimeout(res, delay));
+    })();
+    mfInstanceLoadingCache.set(cacheKey, createProcess);
+    try {
+        return await createProcess;
+    } finally{
+        mfInstanceLoadingCache.delete(cacheKey);
     }
-    throw new Error(`[MF] URL ${url} 经过 ${retries} 次重试仍加载失败。`, {
-        cause: lastError
-    });
 }
 function getFinalSharedConfig(customShared) {
-    return {
+    const globalReact = window.React;
+    const globalReactDOM = window.ReactDOM;
+    const globalShared = {};
+    if (globalReact && globalReactDOM) {
+        const isValidReact = 'object' == typeof globalReact && 'function' == typeof globalReact.useCallback;
+        if (isValidReact) {
+            globalShared.react = {
+                version: globalReact.version || '18.0.0',
+                lib: ()=>globalReact,
+                shareConfig: {
+                    singleton: true,
+                    eager: true,
+                    requiredVersion: false,
+                    strictVersion: false
+                },
+                strategy: 'loaded-first'
+            };
+            globalShared['react-dom'] = {
+                version: globalReactDOM.version || '18.0.0',
+                lib: ()=>globalReactDOM,
+                shareConfig: {
+                    singleton: true,
+                    eager: true,
+                    requiredVersion: false,
+                    strictVersion: false
+                },
+                strategy: 'loaded-first'
+            };
+            globalShared['react-dom/client'] = {
+                version: globalReactDOM.version || '18.0.0',
+                lib: ()=>globalReactDOM,
+                shareConfig: {
+                    singleton: true,
+                    eager: true,
+                    requiredVersion: false,
+                    strictVersion: false
+                },
+                strategy: 'loaded-first'
+            };
+            console.log('[getFinalSharedConfig] Using global React instance', {
+                version: globalReact.version
+            });
+        } else console.warn('[getFinalSharedConfig] Global React found but is invalid', {
+            type: typeof globalReact,
+            useCallback: typeof globalReact?.useCallback
+        });
+    } else console.log('[getFinalSharedConfig] No global React found, using default shared config');
+    const mergedShared = {
         ...DEFAULT_SHARED_CONFIG,
+        ...globalShared,
         ...customShared || {}
     };
+    const keepSingletonPackages = [
+        'react',
+        'react-dom',
+        'react-dom/client',
+        'react/jsx-runtime',
+        'react/jsx-dev-runtime'
+    ];
+    for (const pkgName of keepSingletonPackages){
+        const base = mergedShared[pkgName] || {};
+        mergedShared[pkgName] = {
+            ...base,
+            strategy: 'loaded-first',
+            shareConfig: {
+                singleton: true,
+                eager: true,
+                requiredVersion: false,
+                strictVersion: false,
+                ...base.shareConfig || {}
+            }
+        };
+    }
+    if ('function' == typeof globalShared.react?.lib) mergedShared.react = {
+        ...mergedShared.react || {},
+        lib: globalShared.react.lib,
+        version: globalShared.react.version
+    };
+    if ('function' == typeof globalShared['react-dom']?.lib) mergedShared['react-dom'] = {
+        ...mergedShared['react-dom'] || {},
+        lib: globalShared['react-dom'].lib,
+        version: globalShared['react-dom'].version
+    };
+    if ('function' == typeof globalShared['react-dom/client']?.lib) mergedShared['react-dom/client'] = {
+        ...mergedShared['react-dom/client'] || {},
+        lib: globalShared['react-dom/client'].lib,
+        version: globalShared['react-dom/client'].version
+    };
+    return mergedShared;
 }
 async function resolveFinalVersion(pkg, version, cacheTTL, revalidate) {
     let finalVersion = version;
@@ -376,6 +494,7 @@ async function loadRemoteMultiVersion(options, plugins) {
     const scopeName = `${name}`;
     const urls = buildFinalUrls(pkg, finalVersion, localFallback);
     const finalSharedConfig = getFinalSharedConfig(customShared);
+    console.log(finalSharedConfig, 'finalSharedConfig');
     for (const url of urls)try {
         return await tryLoadRemote(scopeName, url, retries, delay, finalSharedConfig, plugins);
     } catch (e) {
@@ -769,303 +888,6 @@ const eventBus = EventBusClass.create();
 function createEventBus() {
     return EventBusClass.create();
 }
-const external_react_namespaceObject = require("react");
-var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
-class ErrorBoundary extends external_react_default().Component {
-    constructor(props){
-        super(props);
-        this.state = {
-            hasError: false,
-            error: null,
-            errorInfo: null
-        };
-    }
-    static getDerivedStateFromError(error) {
-        return {
-            hasError: true,
-            error,
-            errorInfo: null
-        };
-    }
-    componentDidCatch(error, errorInfo) {
-        this.setState({
-            errorInfo
-        });
-        this.props.onError?.(error, errorInfo);
-        console.error('[RemoteReloadUtils] ErrorBoundary caught error:', error, errorInfo);
-    }
-    handleReset = ()=>{
-        this.setState({
-            hasError: false,
-            error: null,
-            errorInfo: null
-        });
-        this.props.onReset?.();
-    };
-    render() {
-        if (this.state.hasError && this.state.error) {
-            if ('function' == typeof this.props.fallback) return this.props.fallback(this.state.error, this.handleReset);
-            if (void 0 !== this.props.fallback) return this.props.fallback;
-            return /*#__PURE__*/ external_react_default().createElement("div", {
-                role: "alert",
-                style: {
-                    padding: '16px',
-                    border: '1px solid #ffcccc',
-                    backgroundColor: '#fff5f5',
-                    borderRadius: '4px'
-                }
-            }, /*#__PURE__*/ external_react_default().createElement("h3", null, "Something went wrong"), /*#__PURE__*/ external_react_default().createElement("p", null, this.state.error.message), /*#__PURE__*/ external_react_default().createElement("button", {
-                onClick: this.handleReset,
-                style: {
-                    marginTop: '8px',
-                    padding: '8px 16px',
-                    cursor: 'pointer'
-                }
-            }, "Try again"));
-        }
-        return this.props.children;
-    }
-}
-function useRemoteModule({ pkg, version, moduleName, scopeName, onError, onLoad, retryKey = 0 }) {
-    const [moduleState, setModuleState] = (0, external_react_namespaceObject.useState)({
-        loading: true,
-        error: null,
-        component: null
-    });
-    (0, external_react_namespaceObject.useEffect)(()=>{
-        let mounted = true;
-        async function loadModule() {
-            try {
-                setModuleState((prev)=>({
-                        ...prev,
-                        loading: true,
-                        error: null
-                    }));
-                const { mf } = await loadRemoteMultiVersion({
-                    name: scopeName,
-                    pkg,
-                    version
-                }, []);
-                if (!mf || !mounted) return;
-                const mod = await mf.loadRemote(`${scopeName}/${moduleName}`);
-                if (!mounted) return;
-                if (mod && 'object' == typeof mod && 'default' in mod) {
-                    const Component = mod.default;
-                    setModuleState({
-                        loading: false,
-                        error: null,
-                        component: Component
-                    });
-                    onLoad?.(Component);
-                } else throw new Error(`Module "${scopeName}/${moduleName}" does not export a default component`);
-            } catch (err) {
-                if (mounted) {
-                    const error = err instanceof Error ? err : new Error(String(err));
-                    setModuleState({
-                        loading: false,
-                        error,
-                        component: null
-                    });
-                    onError?.(error);
-                }
-            }
-        }
-        loadModule();
-        return ()=>{
-            mounted = false;
-        };
-    }, [
-        pkg,
-        version,
-        moduleName,
-        scopeName,
-        onError,
-        onLoad,
-        retryKey
-    ]);
-    return moduleState;
-}
-function RemoteModuleRenderer({ pkg, version, moduleName, scopeName, loadingFallback, errorFallback, componentProps, className, style, onError, onLoad }) {
-    const moduleState = useRemoteModule({
-        pkg,
-        version,
-        moduleName,
-        scopeName,
-        onError,
-        onLoad
-    });
-    const [retryKey, setRetryKey] = (0, external_react_namespaceObject.useState)(0);
-    const handleRetry = (0, external_react_namespaceObject.useCallback)(()=>{
-        setRetryKey((prev)=>prev + 1);
-    }, []);
-    (0, external_react_namespaceObject.useEffect)(()=>{}, [
-        retryKey
-    ]);
-    if (moduleState.loading) return /*#__PURE__*/ external_react_default().createElement("div", {
-        className: className,
-        style: style,
-        role: "status",
-        "aria-live": "polite"
-    }, loadingFallback || /*#__PURE__*/ external_react_default().createElement("div", {
-        className: "module-card module-card--loading"
-    }, /*#__PURE__*/ external_react_default().createElement("div", {
-        className: "loading-spinner",
-        "aria-hidden": "true"
-    }), /*#__PURE__*/ external_react_default().createElement("span", null, "Loading ", moduleName, "...")));
-    if (moduleState.error) {
-        if ('function' == typeof errorFallback) return /*#__PURE__*/ external_react_default().createElement(external_react_default().Fragment, null, errorFallback(moduleState.error, handleRetry));
-        if (void 0 !== errorFallback) return /*#__PURE__*/ external_react_default().createElement(external_react_default().Fragment, null, errorFallback);
-        return /*#__PURE__*/ external_react_default().createElement("div", {
-            className: className,
-            style: style,
-            role: "alert"
-        }, /*#__PURE__*/ external_react_default().createElement("div", {
-            className: "module-card module-card--error"
-        }, /*#__PURE__*/ external_react_default().createElement("span", {
-            className: "error-icon",
-            "aria-hidden": "true"
-        }, "!"), /*#__PURE__*/ external_react_default().createElement("span", null, "Failed to load ", moduleName), /*#__PURE__*/ external_react_default().createElement("p", {
-            className: "error-message"
-        }, moduleState.error.message), /*#__PURE__*/ external_react_default().createElement("button", {
-            onClick: handleRetry,
-            className: "retry-button",
-            type: "button"
-        }, "Retry")));
-    }
-    if (!moduleState.component) return null;
-    const Component = moduleState.component;
-    return /*#__PURE__*/ external_react_default().createElement("div", {
-        className: className,
-        style: style
-    }, /*#__PURE__*/ external_react_default().createElement(Component, componentProps));
-}
-function RemoteModuleProvider(props) {
-    const { disableErrorBoundary, errorFallback, loadingFallback, errorBoundaryOptions } = props;
-    if (disableErrorBoundary) return /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
-        fallback: loadingFallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
-    }, /*#__PURE__*/ external_react_default().createElement(RemoteModuleRenderer, props));
-    return /*#__PURE__*/ external_react_default().createElement(ErrorBoundary, {
-        fallback: errorFallback,
-        onError: errorBoundaryOptions?.onError,
-        onReset: errorBoundaryOptions?.onReset
-    }, /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
-        fallback: loadingFallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
-    }, /*#__PURE__*/ external_react_default().createElement(RemoteModuleRenderer, props)));
-}
-function lazyRemote(options) {
-    const { pkg, version = 'latest', moduleName, scopeName, maxRetries = 3, retryDelay = 1000 } = options;
-    let retryCount = 0;
-    const loadComponent = async ()=>{
-        try {
-            const { mf } = await loadRemoteMultiVersion({
-                name: scopeName,
-                pkg,
-                version
-            }, []);
-            if (!mf) throw new Error(`[RemoteReloadUtils] Failed to get Module Federation instance for ${scopeName}`);
-            const mod = await mf.loadRemote(`${scopeName}/${moduleName}`);
-            if (!mod || 'object' != typeof mod || !('default' in mod)) throw new Error(`[RemoteReloadUtils] Module "${scopeName}/${moduleName}" does not export a default component`);
-            return {
-                default: mod.default
-            };
-        } catch (error) {
-            if (retryCount < maxRetries) {
-                retryCount++;
-                await new Promise((resolve)=>setTimeout(resolve, retryDelay * retryCount));
-                return loadComponent();
-            }
-            throw error;
-        }
-    };
-    return /*#__PURE__*/ (0, external_react_namespaceObject.lazy)(loadComponent);
-}
-function SuspenseRemote({ fallback, children }) {
-    return /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
-        fallback: fallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
-    }, children);
-}
-function SuspenseRemoteLoader({ pkg, version = 'latest', moduleName, scopeName, fallback, errorFallback, componentProps }) {
-    const RemoteComponent = lazyRemote({
-        pkg,
-        version,
-        moduleName,
-        scopeName
-    });
-    if (errorFallback) return /*#__PURE__*/ external_react_default().createElement(ErrorBoundary, {
-        fallback: errorFallback
-    }, /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
-        fallback: fallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
-    }, /*#__PURE__*/ external_react_default().createElement(RemoteComponent, componentProps)));
-    return /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
-        fallback: fallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
-    }, /*#__PURE__*/ external_react_default().createElement(RemoteComponent, componentProps));
-}
-function withRemote(WrappedComponent, options) {
-    const RemoteComponent = lazyRemote(options);
-    return function(props) {
-        return /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
-            fallback: /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
-        }, /*#__PURE__*/ external_react_default().createElement(RemoteComponent, props));
-    };
-}
-function useRemoteModuleHook(options) {
-    const { pkg, version = 'latest', moduleName, scopeName } = options;
-    const [state, setState] = (0, external_react_namespaceObject.useState)({
-        component: null,
-        loading: true,
-        error: null
-    });
-    (0, external_react_namespaceObject.useEffect)(()=>{
-        let mounted = true;
-        async function load() {
-            try {
-                setState((prev)=>({
-                        ...prev,
-                        loading: true,
-                        error: null
-                    }));
-                const { mf } = await loadRemoteMultiVersion({
-                    name: scopeName,
-                    pkg,
-                    version
-                }, []);
-                if (!mf) throw new Error(`[RemoteReloadUtils] Failed to get Module Federation instance for ${scopeName}`);
-                const mod = await mf.loadRemote(`${scopeName}/${moduleName}`);
-                if (mounted) if (mod && 'object' == typeof mod && 'default' in mod) setState({
-                    component: mod.default,
-                    loading: false,
-                    error: null
-                });
-                else throw new Error(`[RemoteReloadUtils] Module "${scopeName}/${moduleName}" does not export a default component`);
-            } catch (err) {
-                if (mounted) setState({
-                    component: null,
-                    loading: false,
-                    error: err instanceof Error ? err : new Error(String(err))
-                });
-            }
-        }
-        load();
-        return ()=>{
-            mounted = false;
-        };
-    }, [
-        pkg,
-        version,
-        moduleName,
-        scopeName
-    ]);
-    return {
-        component: state.component,
-        loading: state.loading,
-        error: state.error
-    };
-}
-exports.ErrorBoundary = __webpack_exports__.ErrorBoundary;
-exports.RemoteModuleProvider = __webpack_exports__.RemoteModuleProvider;
-exports.RemoteModuleRenderer = __webpack_exports__.RemoteModuleRenderer;
-exports.SuspenseRemote = __webpack_exports__.SuspenseRemote;
-exports.SuspenseRemoteLoader = __webpack_exports__.SuspenseRemoteLoader;
 exports.buildCdnUrls = __webpack_exports__.buildCdnUrls;
 exports.buildFinalUrls = __webpack_exports__.buildFinalUrls;
 exports.cancelPreload = __webpack_exports__.cancelPreload;
@@ -1092,7 +914,6 @@ exports.getStableVersions = __webpack_exports__.getStableVersions;
 exports.getVersionCache = __webpack_exports__.getVersionCache;
 exports.isPrerelease = __webpack_exports__.isPrerelease;
 exports.isRemoteLoaded = __webpack_exports__.isRemoteLoaded;
-exports.lazyRemote = __webpack_exports__.lazyRemote;
 exports.loadReactVersion = __webpack_exports__.loadReactVersion;
 exports.loadRemoteMultiVersion = __webpack_exports__.loadRemoteMultiVersion;
 exports.parseVersion = __webpack_exports__.parseVersion;
@@ -1107,15 +928,7 @@ exports.sortVersions = __webpack_exports__.sortVersions;
 exports.tryLoadRemote = __webpack_exports__.tryLoadRemote;
 exports.unloadAll = __webpack_exports__.unloadAll;
 exports.unloadRemote = __webpack_exports__.unloadRemote;
-exports.useRemoteModule = __webpack_exports__.useRemoteModule;
-exports.useRemoteModuleHook = __webpack_exports__.useRemoteModuleHook;
-exports.withRemote = __webpack_exports__.withRemote;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "ErrorBoundary",
-    "RemoteModuleProvider",
-    "RemoteModuleRenderer",
-    "SuspenseRemote",
-    "SuspenseRemoteLoader",
     "buildCdnUrls",
     "buildFinalUrls",
     "cancelPreload",
@@ -1142,7 +955,6 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "getVersionCache",
     "isPrerelease",
     "isRemoteLoaded",
-    "lazyRemote",
     "loadReactVersion",
     "loadRemoteMultiVersion",
     "parseVersion",
@@ -1156,10 +968,7 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "sortVersions",
     "tryLoadRemote",
     "unloadAll",
-    "unloadRemote",
-    "useRemoteModule",
-    "useRemoteModuleHook",
-    "withRemote"
+    "unloadRemote"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true