@module-federation/webpack-bundler-runtime 0.0.0-canary-1701669627295

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present zhanghang(2heal1)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/index";
+export { default } from "./src/index";

package/index.cjs.js

@@ -0,0 +1,222 @@
+'use strict';
+
+var runtime = require('@module-federation/runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var runtime__namespace = /*#__PURE__*/_interopNamespace(runtime);
+
+function remotes(options) {
+    var chunkId = options.chunkId, promises = options.promises, chunkMapping = options.chunkMapping, idToExternalAndNameMapping = options.idToExternalAndNameMapping, webpackRequire = options.webpackRequire;
+    if (webpackRequire.o(chunkMapping, chunkId)) {
+        chunkMapping[chunkId].forEach(function(id) {
+            var getScope = webpackRequire.R;
+            if (!getScope) {
+                getScope = [];
+            }
+            var data = idToExternalAndNameMapping[id];
+            // @ts-ignore seems not work
+            if (getScope.indexOf(data) >= 0) {
+                return;
+            }
+            // @ts-ignore seems not work
+            getScope.push(data);
+            if (data.p) {
+                return promises.push(data.p);
+            }
+            var onError = function(error) {
+                if (!error) {
+                    error = new Error("Container missing");
+                }
+                if (typeof error.message === "string") {
+                    error.message += '\nwhile loading "'.concat(data[1], '" from ').concat(data[2]);
+                }
+                webpackRequire.m[id] = function() {
+                    throw error;
+                };
+                data.p = 0;
+            };
+            var handleFunction = function(fn, arg1, arg2, d, next, first) {
+                try {
+                    var promise = fn(arg1, arg2);
+                    if (promise && promise.then) {
+                        var p = promise.then(function(result) {
+                            return next(result, d);
+                        }, onError);
+                        if (first) {
+                            promises.push(data.p = p);
+                        } else {
+                            return p;
+                        }
+                    } else {
+                        return next(promise, d, first);
+                    }
+                } catch (error) {
+                    onError(error);
+                }
+            };
+            var onExternal = function(external, _, first) {
+                return external ? handleFunction(webpackRequire.I, data[0], 0, external, onInitialized, first) : onError();
+            };
+            // eslint-disable-next-line no-var
+            var onInitialized = function(_, external, first) {
+                return handleFunction(external.get, data[1], getScope, 0, onFactory, first);
+            };
+            var useRuntimeLoad = [
+                "script"
+            ].includes(data[3]) && data[4];
+            // eslint-disable-next-line no-var
+            var onFactory = function(factory) {
+                data.p = 1;
+                webpackRequire.m[id] = function(module) {
+                    module.exports = factory();
+                };
+            };
+            var onRemoteLoaded = function() {
+                try {
+                    var remoteModuleName = data[4] + data[1].slice(1);
+                    return webpackRequire.federation.instance.loadRemote(remoteModuleName, {
+                        loadFactory: false
+                    });
+                } catch (error) {
+                    onError(error);
+                }
+            };
+            if (useRuntimeLoad) {
+                handleFunction(onRemoteLoaded, data[2], 0, 0, onFactory, 1);
+            } else {
+                handleFunction(webpackRequire, data[2], 0, 0, onExternal, 1);
+            }
+        });
+    }
+}
+
+function proxyShareScopeMap(__webpack_require__) {
+    if (!__webpack_require__.S) {
+        return;
+    }
+    // @ts-ignore FIXME: ideal situation is import type from @module-federation/runtime/type ,but the compile will throw error
+    __webpack_require__.S = new Proxy(globalThis.__VMOK__.__SHARE__, {
+        get: function get(target, prop, receiver) {
+            return globalThis.__VMOK__.__SHARE__[prop];
+        },
+        set: function set(target, prop, value) {
+            globalThis.__VMOK__.__SHARE__[prop] = value;
+            return true;
+        }
+    });
+}
+
+function consumes(options) {
+    var chunkId = options.chunkId, promises = options.promises, chunkMapping = options.chunkMapping, installedModules = options.installedModules, moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire;
+    proxyShareScopeMap(webpackRequire);
+    if (webpackRequire.o(chunkMapping, chunkId)) {
+        chunkMapping[chunkId].forEach(function(id) {
+            if (webpackRequire.o(installedModules, id)) {
+                return promises.push(installedModules[id]);
+            }
+            var onFactory = function(factory) {
+                installedModules[id] = 0;
+                webpackRequire.m[id] = function(module) {
+                    delete webpackRequire.c[id];
+                    module.exports = factory();
+                };
+            };
+            var onError = function(error) {
+                delete installedModules[id];
+                webpackRequire.m[id] = function(module) {
+                    delete webpackRequire.c[id];
+                    throw error;
+                };
+            };
+            try {
+                var federationInstance = webpackRequire.federation.instance;
+                if (!federationInstance) {
+                    throw new Error("Federation instance not found!");
+                }
+                var _moduleToHandlerMapping_id = moduleToHandlerMapping[id], shareKey = _moduleToHandlerMapping_id.shareKey, getter = _moduleToHandlerMapping_id.getter, shareInfo = _moduleToHandlerMapping_id.shareInfo;
+                var promise = federationInstance.loadShare(shareKey, shareInfo).then(function(factory) {
+                    if (factory === false) {
+                        return getter();
+                    }
+                    return factory;
+                });
+                if (promise.then) {
+                    promises.push(installedModules[id] = promise.then(onFactory).catch(onError));
+                } else {
+                    // @ts-ignore maintain previous logic
+                    onFactory(promise);
+                }
+            } catch (e) {
+                onError(e);
+            }
+        });
+    }
+}
+
+function initializeSharing(shareScopeName, webpackRequire) {
+    return webpackRequire.federation.instance.initializeSharing(shareScopeName);
+}
+
+function handleInitialConsumes(options) {
+    var moduleId = options.moduleId, moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire;
+    var federationInstance = webpackRequire.federation.instance;
+    if (!federationInstance) {
+        throw new Error("Federation instance not found!");
+    }
+    var _moduleToHandlerMapping_moduleId = moduleToHandlerMapping[moduleId], shareKey = _moduleToHandlerMapping_moduleId.shareKey, shareInfo = _moduleToHandlerMapping_moduleId.shareInfo;
+    if (!shareInfo.shareConfig.eager) {
+        throw new Error('Shared: "'.concat(shareKey, '" cannot be loaded synchronously unless "eager:true" is set or async entry is enabled.'));
+    }
+    return federationInstance.loadShareSync(shareKey);
+}
+function installInitialConsumes(options) {
+    var moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire, installedModules = options.installedModules, initialConsumes = options.initialConsumes;
+    initialConsumes.forEach(function(id) {
+        webpackRequire.m[id] = function(module) {
+            // Handle scenario when module is used synchronously
+            installedModules[id] = 0;
+            delete webpackRequire.c[id];
+            var factory = handleInitialConsumes({
+                moduleId: id,
+                moduleToHandlerMapping: moduleToHandlerMapping,
+                webpackRequire: webpackRequire
+            });
+            if (typeof factory !== "function") {
+                throw new Error("Shared module is not available for eager consumption: ".concat(id));
+            }
+            module.exports = factory();
+        };
+    });
+}
+
+var federation = {
+    runtime: runtime__namespace,
+    instance: undefined,
+    initOptions: undefined,
+    bundlerRuntime: {
+        remotes: remotes,
+        consumes: consumes,
+        I: initializeSharing,
+        S: {},
+        installInitialConsumes: installInitialConsumes
+    }
+};
+
+module.exports = federation;

package/index.esm.js

@@ -0,0 +1,200 @@
+import * as runtime from '@module-federation/runtime';
+
+function remotes(options) {
+    var chunkId = options.chunkId, promises = options.promises, chunkMapping = options.chunkMapping, idToExternalAndNameMapping = options.idToExternalAndNameMapping, webpackRequire = options.webpackRequire;
+    if (webpackRequire.o(chunkMapping, chunkId)) {
+        chunkMapping[chunkId].forEach(function(id) {
+            var getScope = webpackRequire.R;
+            if (!getScope) {
+                getScope = [];
+            }
+            var data = idToExternalAndNameMapping[id];
+            // @ts-ignore seems not work
+            if (getScope.indexOf(data) >= 0) {
+                return;
+            }
+            // @ts-ignore seems not work
+            getScope.push(data);
+            if (data.p) {
+                return promises.push(data.p);
+            }
+            var onError = function(error) {
+                if (!error) {
+                    error = new Error("Container missing");
+                }
+                if (typeof error.message === "string") {
+                    error.message += '\nwhile loading "'.concat(data[1], '" from ').concat(data[2]);
+                }
+                webpackRequire.m[id] = function() {
+                    throw error;
+                };
+                data.p = 0;
+            };
+            var handleFunction = function(fn, arg1, arg2, d, next, first) {
+                try {
+                    var promise = fn(arg1, arg2);
+                    if (promise && promise.then) {
+                        var p = promise.then(function(result) {
+                            return next(result, d);
+                        }, onError);
+                        if (first) {
+                            promises.push(data.p = p);
+                        } else {
+                            return p;
+                        }
+                    } else {
+                        return next(promise, d, first);
+                    }
+                } catch (error) {
+                    onError(error);
+                }
+            };
+            var onExternal = function(external, _, first) {
+                return external ? handleFunction(webpackRequire.I, data[0], 0, external, onInitialized, first) : onError();
+            };
+            // eslint-disable-next-line no-var
+            var onInitialized = function(_, external, first) {
+                return handleFunction(external.get, data[1], getScope, 0, onFactory, first);
+            };
+            var useRuntimeLoad = [
+                "script"
+            ].includes(data[3]) && data[4];
+            // eslint-disable-next-line no-var
+            var onFactory = function(factory) {
+                data.p = 1;
+                webpackRequire.m[id] = function(module) {
+                    module.exports = factory();
+                };
+            };
+            var onRemoteLoaded = function() {
+                try {
+                    var remoteModuleName = data[4] + data[1].slice(1);
+                    return webpackRequire.federation.instance.loadRemote(remoteModuleName, {
+                        loadFactory: false
+                    });
+                } catch (error) {
+                    onError(error);
+                }
+            };
+            if (useRuntimeLoad) {
+                handleFunction(onRemoteLoaded, data[2], 0, 0, onFactory, 1);
+            } else {
+                handleFunction(webpackRequire, data[2], 0, 0, onExternal, 1);
+            }
+        });
+    }
+}
+
+function proxyShareScopeMap(__webpack_require__) {
+    if (!__webpack_require__.S) {
+        return;
+    }
+    // @ts-ignore FIXME: ideal situation is import type from @module-federation/runtime/type ,but the compile will throw error
+    __webpack_require__.S = new Proxy(globalThis.__VMOK__.__SHARE__, {
+        get: function get(target, prop, receiver) {
+            return globalThis.__VMOK__.__SHARE__[prop];
+        },
+        set: function set(target, prop, value) {
+            globalThis.__VMOK__.__SHARE__[prop] = value;
+            return true;
+        }
+    });
+}
+
+function consumes(options) {
+    var chunkId = options.chunkId, promises = options.promises, chunkMapping = options.chunkMapping, installedModules = options.installedModules, moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire;
+    proxyShareScopeMap(webpackRequire);
+    if (webpackRequire.o(chunkMapping, chunkId)) {
+        chunkMapping[chunkId].forEach(function(id) {
+            if (webpackRequire.o(installedModules, id)) {
+                return promises.push(installedModules[id]);
+            }
+            var onFactory = function(factory) {
+                installedModules[id] = 0;
+                webpackRequire.m[id] = function(module) {
+                    delete webpackRequire.c[id];
+                    module.exports = factory();
+                };
+            };
+            var onError = function(error) {
+                delete installedModules[id];
+                webpackRequire.m[id] = function(module) {
+                    delete webpackRequire.c[id];
+                    throw error;
+                };
+            };
+            try {
+                var federationInstance = webpackRequire.federation.instance;
+                if (!federationInstance) {
+                    throw new Error("Federation instance not found!");
+                }
+                var _moduleToHandlerMapping_id = moduleToHandlerMapping[id], shareKey = _moduleToHandlerMapping_id.shareKey, getter = _moduleToHandlerMapping_id.getter, shareInfo = _moduleToHandlerMapping_id.shareInfo;
+                var promise = federationInstance.loadShare(shareKey, shareInfo).then(function(factory) {
+                    if (factory === false) {
+                        return getter();
+                    }
+                    return factory;
+                });
+                if (promise.then) {
+                    promises.push(installedModules[id] = promise.then(onFactory).catch(onError));
+                } else {
+                    // @ts-ignore maintain previous logic
+                    onFactory(promise);
+                }
+            } catch (e) {
+                onError(e);
+            }
+        });
+    }
+}
+
+function initializeSharing(shareScopeName, webpackRequire) {
+    return webpackRequire.federation.instance.initializeSharing(shareScopeName);
+}
+
+function handleInitialConsumes(options) {
+    var moduleId = options.moduleId, moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire;
+    var federationInstance = webpackRequire.federation.instance;
+    if (!federationInstance) {
+        throw new Error("Federation instance not found!");
+    }
+    var _moduleToHandlerMapping_moduleId = moduleToHandlerMapping[moduleId], shareKey = _moduleToHandlerMapping_moduleId.shareKey, shareInfo = _moduleToHandlerMapping_moduleId.shareInfo;
+    if (!shareInfo.shareConfig.eager) {
+        throw new Error('Shared: "'.concat(shareKey, '" cannot be loaded synchronously unless "eager:true" is set or async entry is enabled.'));
+    }
+    return federationInstance.loadShareSync(shareKey);
+}
+function installInitialConsumes(options) {
+    var moduleToHandlerMapping = options.moduleToHandlerMapping, webpackRequire = options.webpackRequire, installedModules = options.installedModules, initialConsumes = options.initialConsumes;
+    initialConsumes.forEach(function(id) {
+        webpackRequire.m[id] = function(module) {
+            // Handle scenario when module is used synchronously
+            installedModules[id] = 0;
+            delete webpackRequire.c[id];
+            var factory = handleInitialConsumes({
+                moduleId: id,
+                moduleToHandlerMapping: moduleToHandlerMapping,
+                webpackRequire: webpackRequire
+            });
+            if (typeof factory !== "function") {
+                throw new Error("Shared module is not available for eager consumption: ".concat(id));
+            }
+            module.exports = factory();
+        };
+    });
+}
+
+var federation = {
+    runtime: runtime,
+    instance: undefined,
+    initOptions: undefined,
+    bundlerRuntime: {
+        remotes: remotes,
+        consumes: consumes,
+        I: initializeSharing,
+        S: {},
+        installInitialConsumes: installInitialConsumes
+    }
+};
+
+export { federation as default };

package/package.json

@@ -0,0 +1,22 @@
+{
+  "public": true,
+  "name": "@module-federation/webpack-bundler-runtime",
+  "version": "0.0.0-canary-1701669627295",
+  "license": "MIT",
+  "description": "Module Federation Runtime for webpack",
+  "keywords": [
+    "Module Federation",
+    "bundler runtime"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "zhanghang <hanric.zhang@gmail.com>",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "types": "./index.cjs.d.ts",
+  "dependencies": {
+    "@module-federation/runtime": "0.0.0-canary-1701669627295"
+  },
+  "peerDependencies": {}
+}

package/src/consumes.d.ts

@@ -0,0 +1,2 @@
+import { ConsumesOptions } from './types';
+export declare function consumes(options: ConsumesOptions): void;

package/src/index.d.ts

@@ -0,0 +1,3 @@
+import { Federation } from './types';
+declare const federation: Federation;
+export default federation;

package/src/initializeSharing.d.ts

@@ -0,0 +1,2 @@
+import { WebpackRequire } from './types';
+export declare function initializeSharing(shareScopeName: string, webpackRequire: WebpackRequire): Promise<boolean> | boolean;

package/src/installInitialConsumes.d.ts

@@ -0,0 +1,2 @@
+import { InstallInitialConsumesOptions } from './types';
+export declare function installInitialConsumes(options: InstallInitialConsumesOptions): void;

package/src/proxyShareScopeMap.d.ts

@@ -0,0 +1,2 @@
+import { WebpackRequire } from './types';
+export declare function proxyShareScopeMap(__webpack_require__: WebpackRequire): void;

package/src/remotes.d.ts

@@ -0,0 +1,2 @@
+import { RemotesOptions } from './types';
+export declare function remotes(options: RemotesOptions): void;

package/src/types.d.ts

@@ -0,0 +1,87 @@
+import * as runtime from '@module-federation/runtime';
+import { initializeSharing } from './initializeSharing';
+type ExcludeUndefined<T> = T extends undefined ? never : T;
+type NonUndefined<T = Shared> = ExcludeUndefined<T>;
+type InitOptions = Parameters<typeof runtime.init>[0];
+type Shared = InitOptions['shared'];
+type SharedConfig = NonUndefined<NonUndefined[string]['shareConfig']>;
+type ModuleCache = runtime.FederationHost['moduleCache'];
+type InferModule<T> = T extends Map<string, infer U> ? U : never;
+type InferredModule = InferModule<ModuleCache>;
+export type RemoteEntryExports = NonUndefined<InferredModule['remoteEntryExports']>;
+type ExtractInitParameters<T> = T extends {
+    init: (shareScope: infer U, ...args: any[]) => void;
+} ? U : never;
+type InferredShareScope = ExtractInitParameters<RemoteEntryExports>;
+type InferredGlobalShareScope = {
+    [scope: string]: InferredShareScope;
+};
+type IdToExternalAndNameMappingItem = [
+    string,
+    string,
+    string | number,
+    string,
+    string
+];
+interface IdToExternalAndNameMappingItemWithPromise extends IdToExternalAndNameMappingItem {
+    p?: Promise<any> | number;
+}
+export interface WebpackRequire {
+    (moduleId: string | number): any;
+    o: (obj: Record<string, any>, key: string | number) => boolean;
+    R: Array<string | number>;
+    m: Record<string, (mod: any) => any>;
+    c: Record<string, any>;
+    I: typeof initializeSharing;
+    S?: InferredGlobalShareScope;
+    federation: Federation;
+}
+interface ShareInfo {
+    shareConfig: SharedConfig;
+    scope: Array<string>;
+}
+interface ModuleToHandlerMappingItem {
+    getter: () => Promise<any>;
+    shareInfo: ShareInfo;
+    shareKey: string;
+}
+export interface RemotesOptions {
+    chunkId: string | number;
+    promises: Promise<any>[];
+    chunkMapping: Record<string, Array<string | number>>;
+    idToExternalAndNameMapping: Record<string, IdToExternalAndNameMappingItemWithPromise>;
+    webpackRequire: WebpackRequire;
+}
+export interface HandleInitialConsumesOptions {
+    moduleId: string | number;
+    moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
+    webpackRequire: WebpackRequire;
+}
+export interface InstallInitialConsumesOptions {
+    moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
+    webpackRequire: WebpackRequire;
+    installedModules: Record<string, Promise<any> | 0>;
+    initialConsumes: Array<string | number>;
+}
+export interface ConsumesOptions {
+    chunkId: string | number;
+    promises: Promise<any>[];
+    chunkMapping: Record<string, Array<string | number>>;
+    installedModules: Record<string, Promise<any> | 0>;
+    moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
+    webpackRequire: WebpackRequire;
+}
+export interface Federation {
+    runtime?: typeof runtime;
+    instance?: runtime.FederationHost;
+    initOptions?: InitOptions;
+    installInitialConsumes?: (options: InstallInitialConsumesOptions) => any;
+    bundlerRuntime?: {
+        remotes: (options: RemotesOptions) => void;
+        consumes: (options: ConsumesOptions) => void;
+        I: (name: string, webpackRequire: WebpackRequire) => Promise<boolean> | boolean;
+        S: InferredGlobalShareScope;
+        installInitialConsumes: (options: InstallInitialConsumesOptions) => any;
+    };
+}
+export {};