@module-federation/esbuild 0.0.95 → 0.0.97

package/dist/adapters/lib/commonjs.mjs

@@ -0,0 +1,209 @@
+import * as __WEBPACK_EXTERNAL_MODULE_esbuild__ from "esbuild";
+import { promises } from "fs";
+import { Lexer } from "./lexer.mjs";
+import { cachedReduce, makeLegalIdentifier, orderedUniq } from "./utils.mjs";
+var __webpack_modules__ = ({
+"esbuild": (function (module) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE_esbuild__;
+
+
+}),
+
+});
+/************************************************************************/
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+/************************************************************************/
+
+;// CONCATENATED MODULE: external "fs"
+
+;// CONCATENATED MODULE: external "./lexer.mjs"
+
+;// CONCATENATED MODULE: external "./utils.mjs"
+
+;// CONCATENATED MODULE: ./src/adapters/lib/commonjs.ts
+
+
+
+function commonjs_commonjs({ filter = /\.c?js$/, transform = true, transformConfig, requireReturnsDefault = true, ignore } = {}) {
+    const init_cjs_module_lexer = transform ? import("cjs-module-lexer") : undefined;
+    const use_default_export = typeof requireReturnsDefault === 'function' ? requireReturnsDefault : (_path)=>requireReturnsDefault;
+    const is_ignored = typeof ignore === 'function' ? ignore : Array.isArray(ignore) ? (path)=>ignore.includes(path) : ()=>false;
+    return {
+        name: 'commonjs',
+        setup ({ onLoad, esbuild, initialOptions }) {
+            let esbuild_shim;
+            const require_esbuild = ()=>esbuild || (esbuild_shim ||= __webpack_require__("esbuild"));
+            const read = promises.readFile;
+            const lexer = new Lexer();
+            //@ts-ignore
+            onLoad({
+                filter: filter
+            }, async (args)=>{
+                let parseCJS;
+                if (init_cjs_module_lexer) {
+                    const { init, parse } = await init_cjs_module_lexer;
+                    await init();
+                    parseCJS = parse;
+                }
+                let contents;
+                try {
+                    //@ts-ignore
+                    contents = await read(args.path, 'utf8');
+                } catch  {
+                    return null;
+                }
+                const willTransform = transform === true || typeof transform === 'function' && transform(args.path);
+                let cjsExports;
+                try {
+                    if (parseCJS && willTransform) {
+                        // move sourcemap to the end of the transformed file
+                        const sourcemapIndex = contents.lastIndexOf('//# sourceMappingURL=');
+                        let sourcemap;
+                        if (sourcemapIndex !== -1) {
+                            sourcemap = contents.slice(sourcemapIndex);
+                            const sourcemapEnd = sourcemap.indexOf('\n');
+                            if (sourcemapEnd !== -1 && sourcemap.slice(sourcemapEnd + 1).trimStart().length > 0) {
+                                // if there's code after sourcemap, it is invalid, don't do this.
+                                sourcemap = undefined;
+                            } else {
+                                contents = contents.slice(0, sourcemapIndex);
+                            }
+                        }
+                        // transform commonjs to es modules, easy mode
+                        cjsExports = parseCJS(contents);
+                        let { behavior, exports, sideEffects } = typeof willTransform === 'object' ? willTransform : {};
+                        behavior ??= (transformConfig === null || transformConfig === void 0 ? void 0 : transformConfig.behavior) ?? 'node';
+                        exports = orderedUniq(cjsExports.exports.concat(exports ?? []));
+                        sideEffects ??= (transformConfig === null || transformConfig === void 0 ? void 0 : transformConfig.sideEffects) ?? true;
+                        let exportDefault = behavior === 'node' ? 'export default exports;' : 'export default exports.__esModule ? exports.default : exports;';
+                        let exportsMap = exports.map((e)=>[
+                                e,
+                                makeLegalIdentifier(e)
+                            ]);
+                        if (exportsMap.some(([e])=>e === 'default')) {
+                            if (behavior === 'node') {
+                                exportsMap = exportsMap.filter(([e])=>e !== 'default');
+                            } else {
+                                exportDefault = '';
+                            }
+                        }
+                        const reexports = cjsExports.reexports.map((e)=>`export * from ${JSON.stringify(e)};`).join('');
+                        let transformed;
+                        if (sideEffects === false) {
+                            transformed = [
+                                // make sure we don't manipulate the first line so that sourcemap is fine
+                                reexports + 'var mod, exports = /* @__PURE__ */ ((exports, module) => {' + contents,
+                                'return module.exports})((mod = { exports: {} }).exports, mod); ' + exportDefault
+                            ];
+                            if (exportsMap.length > 0) {
+                                for (const [e, name] of exportsMap){
+                                    transformed.push(`var ${name} = /* @__PURE__ */ (() => exports[${JSON.stringify(e)}])();`);
+                                }
+                                transformed.push(`export { ${exportsMap.map(([e, name])=>e === name ? e : `${name} as ${JSON.stringify(e)}`).join(', ')} };`);
+                            }
+                        } else {
+                            transformed = [
+                                reexports + 'var exports = {}, module = { exports }; {' + contents,
+                                '}; exports = module.exports; ' + exportDefault
+                            ];
+                            if (exportsMap.length > 0) {
+                                transformed.push(`var { ${exportsMap.map(([e, name])=>e === name ? e : `${JSON.stringify(e)}: ${name}`).join(', ')} } = exports;`, `export { ${exportsMap.map(([e, name])=>e === name ? e : `${name} as ${JSON.stringify(e)}`).join(', ')} };`);
+                            }
+                        }
+                        contents = transformed.join('\n') + (sourcemap ? '\n' + sourcemap : '');
+                    }
+                } catch (e) {
+                    return null;
+                }
+                function makeName(path) {
+                    let name = `__import_${makeLegalIdentifier(path)}`;
+                    if (contents.includes(name)) {
+                        let suffix = 2;
+                        while(contents.includes(`${name}${suffix}`))suffix++;
+                        name = `${name}${suffix}`;
+                    }
+                    return name;
+                }
+                let warnings;
+                try {
+                    ({ warnings } = await require_esbuild().transform(contents, {
+                        format: 'esm',
+                        logLevel: 'silent'
+                    }));
+                } catch (err) {
+                    ({ warnings } = err);
+                }
+                const lines = contents.split('\n');
+                const getOffset = cachedReduce(lines, (a, b)=>a + 1 + b.length, 0);
+                if (warnings && (warnings = warnings.filter((e)=>e.text.includes('"require" to "esm"'))).length) {
+                    const edits = [];
+                    let imports = [];
+                    for (const { location } of warnings){
+                        if (location === null) continue;
+                        const { line, lineText, column, length } = location;
+                        const leftBrace = column + length + 1;
+                        const path = lexer.readString(lineText, leftBrace);
+                        if (path === null || is_ignored(path)) continue;
+                        const rightBrace = lineText.indexOf(')', leftBrace + 2 + path.length) + 1;
+                        const name = makeName(path);
+                        let import_statement;
+                        if (use_default_export(path)) {
+                            import_statement = `import ${name} from ${JSON.stringify(path)};`;
+                        } else {
+                            import_statement = `import * as ${name} from ${JSON.stringify(path)};`;
+                        }
+                        const offset = getOffset(line - 1);
+                        edits.push([
+                            offset + column,
+                            offset + rightBrace,
+                            name
+                        ]);
+                        imports.push(import_statement);
+                    }
+                    if (imports.length === 0) return null;
+                    imports = orderedUniq(imports);
+                    let offset = 0;
+                    for (const [start, end, name] of edits){
+                        contents = contents.slice(0, start + offset) + name + contents.slice(end + offset);
+                        offset += name.length - (end - start);
+                    }
+                    // if we have transformed this module (i.e. having `cjsExports`), don't make the file commonjs
+                    contents = [
+                        ...imports,
+                        cjsExports ? 'exports;' : '',
+                        contents
+                    ].join('');
+                    return {
+                        contents
+                    };
+                }
+            });
+        }
+    };
+}
+/* ESM default export */ const commonjs = (commonjs_commonjs);
+
+export { commonjs_commonjs as commonjs, commonjs as default };

package/dist/adapters/lib/containerPlugin.js

@@ -0,0 +1,232 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+/************************************************************************/
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  createContainerPlugin: () => (/* binding */ createContainerPlugin)
+});
+
+;// CONCATENATED MODULE: external "../../lib/core/createContainerTemplate.js"
+const createContainerTemplate_js_namespaceObject = require("../../lib/core/createContainerTemplate.js");
+;// CONCATENATED MODULE: ./src/adapters/lib/containerPlugin.ts
+
+const buildContainerHost = (config)=>{
+    const { name, remotes = {}, shared = {}, exposes = {} } = config;
+    const remoteConfigs = Object.entries(remotes).map(([remoteAlias, remote])=>({
+            type: 'esm',
+            name: remoteAlias,
+            entry: remote.entry,
+            alias: remoteAlias
+        }));
+    const sharedConfig = Object.entries(shared).reduce((acc, [pkg, config])=>{
+        var _config_requiredVersion;
+        const version = ((_config_requiredVersion = config.requiredVersion) === null || _config_requiredVersion === void 0 ? void 0 : _config_requiredVersion.replace(/^[^0-9]/, '')) || '';
+        acc += `${JSON.stringify(pkg)}: {
+      "package": "${pkg}",
+      "version": "${version}",
+      "scope": "default",
+      "get": async () => import('federationShare/${pkg}'),
+      "shareConfig": {
+        "singleton": ${config.singleton},
+        "requiredVersion": "${config.requiredVersion}",
+        "eager": ${config.eager},
+        "strictVersion": ${config.strictVersion}
+      }
+    },\n`;
+        return acc;
+    }, '{') + '}';
+    let exposesConfig = Object.entries(exposes).map(([exposeName, exposePath])=>`${JSON.stringify(exposeName)}: async () => await import('${exposePath}')`).join(',\n');
+    exposesConfig = `{${exposesConfig}}`;
+    const injectedContent = `
+    export const moduleMap = '__MODULE_MAP__';
+
+    function appendImportMap(importMap) {
+      const script = document.createElement('script');
+      script.type = 'importmap-shim';
+      script.innerHTML = JSON.stringify(importMap);
+      document.head.appendChild(script);
+    }
+
+    export const createVirtualRemoteModule = (name, ref, exports) => {
+      const genExports = exports.map(e =>
+        e === 'default' ? 'export default mfLsZJ92.default' : \`export const \${e} = mfLsZJ92[\${JSON.stringify(e)}];\`
+      ).join('');
+
+      const loadRef = \`const mfLsZJ92 = await container.loadRemote(\${JSON.stringify(ref)});\`;
+
+      return \`
+        const container = __FEDERATION__.__INSTANCES__.find(container => container.name === name) || __FEDERATION__.__INSTANCES__[0];
+        \${loadRef}
+        \${genExports}
+      \`;
+    };
+
+    function encodeInlineESM(code) {
+      const encodedCode = encodeURIComponent(code);
+      return \`data:text/javascript;charset=utf-8,\${encodedCode}\`;
+    }
+
+    const runtimePlugin = () => ({
+        name: 'import-maps-plugin',
+        async init(args) {
+
+            const remotePrefetch = args.options.remotes.map(async (remote) => {
+                if (remote.type === 'esm') {
+                    await import(remote.entry);
+                }
+            });
+
+
+            await Promise.all(remotePrefetch);
+
+            const map = Object.keys(moduleMap).reduce((acc, expose) => {
+                const importMap = importShim.getImportMap().imports;
+                const key = args.origin.name + expose.replace('.', '');
+                if (!importMap[key]) {
+                    const encodedModule = encodeInlineESM(
+                        createVirtualRemoteModule(args.origin.name, key, moduleMap[expose].exports)
+                    );
+                    acc[key] = encodedModule;
+                }
+                return acc;
+            }, {});
+            await importShim.addImportMap({ imports: map });
+
+            return args;
+        }
+    });
+
+    const createdContainer = await createContainer({
+      name: ${JSON.stringify(name)},
+      exposes: ${exposesConfig},
+      remotes: ${JSON.stringify(remoteConfigs)},
+      shared: ${sharedConfig},
+      plugins: [runtimePlugin()],
+    });
+
+    export const get = createdContainer.get;
+    export const init = createdContainer.init;
+  `;
+    //replace with createContainer from bundler runtime - import it in the string as a dep etc
+    return [
+        createContainerTemplate_js_namespaceObject.createContainerCode,
+        injectedContent
+    ].join('\n');
+};
+const createContainerPlugin = (config)=>({
+        name: 'createContainer',
+        setup (build) {
+            const { filename } = config;
+            const filter = new RegExp([
+                filename
+            ].map((name)=>`${name}$`).join('|'));
+            const hasShared = Object.keys(config.shared || {}).length;
+            const shared = Object.keys(config.shared || {}).map((name)=>`${name}$`).join('|');
+            const sharedExternals = new RegExp(shared);
+            build.onResolve({
+                filter
+            }, async (args)=>({
+                    path: args.path,
+                    namespace: 'container',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
+            build.onResolve({
+                filter: /^federationShare/
+            }, async (args)=>({
+                    path: args.path.replace('federationShare/', ''),
+                    namespace: 'esm-shares',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
+            if (hasShared) {
+                build.onResolve({
+                    filter: sharedExternals
+                }, (args)=>{
+                    if (args.namespace === 'esm-shares') return null;
+                    return {
+                        path: args.path,
+                        namespace: 'virtual-share-module',
+                        pluginData: {
+                            kind: args.kind,
+                            resolveDir: args.resolveDir
+                        }
+                    };
+                });
+                build.onResolve({
+                    filter: /.*/,
+                    namespace: 'esm-shares'
+                }, async (args)=>{
+                    if (sharedExternals.test(args.path)) {
+                        return {
+                            path: args.path,
+                            namespace: 'virtual-share-module',
+                            pluginData: {
+                                kind: args.kind,
+                                resolveDir: args.resolveDir
+                            }
+                        };
+                    }
+                    return undefined;
+                });
+            }
+            build.onLoad({
+                filter,
+                namespace: 'container'
+            }, async (args)=>({
+                    contents: buildContainerHost(config),
+                    loader: 'js',
+                    resolveDir: args.pluginData.resolveDir
+                }));
+        }
+    });
+
+exports.createContainerPlugin = __webpack_exports__.createContainerPlugin;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["createContainerPlugin"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/adapters/lib/containerPlugin.mjs

@@ -0,0 +1,182 @@
+import { createContainerCode } from "../../lib/core/createContainerTemplate.mjs";
+
+;// CONCATENATED MODULE: external "../../lib/core/createContainerTemplate.mjs"
+
+;// CONCATENATED MODULE: ./src/adapters/lib/containerPlugin.ts
+
+const buildContainerHost = (config)=>{
+    const { name, remotes = {}, shared = {}, exposes = {} } = config;
+    const remoteConfigs = Object.entries(remotes).map(([remoteAlias, remote])=>({
+            type: 'esm',
+            name: remoteAlias,
+            entry: remote.entry,
+            alias: remoteAlias
+        }));
+    const sharedConfig = Object.entries(shared).reduce((acc, [pkg, config])=>{
+        var _config_requiredVersion;
+        const version = ((_config_requiredVersion = config.requiredVersion) === null || _config_requiredVersion === void 0 ? void 0 : _config_requiredVersion.replace(/^[^0-9]/, '')) || '';
+        acc += `${JSON.stringify(pkg)}: {
+      "package": "${pkg}",
+      "version": "${version}",
+      "scope": "default",
+      "get": async () => import('federationShare/${pkg}'),
+      "shareConfig": {
+        "singleton": ${config.singleton},
+        "requiredVersion": "${config.requiredVersion}",
+        "eager": ${config.eager},
+        "strictVersion": ${config.strictVersion}
+      }
+    },\n`;
+        return acc;
+    }, '{') + '}';
+    let exposesConfig = Object.entries(exposes).map(([exposeName, exposePath])=>`${JSON.stringify(exposeName)}: async () => await import('${exposePath}')`).join(',\n');
+    exposesConfig = `{${exposesConfig}}`;
+    const injectedContent = `
+    export const moduleMap = '__MODULE_MAP__';
+
+    function appendImportMap(importMap) {
+      const script = document.createElement('script');
+      script.type = 'importmap-shim';
+      script.innerHTML = JSON.stringify(importMap);
+      document.head.appendChild(script);
+    }
+
+    export const createVirtualRemoteModule = (name, ref, exports) => {
+      const genExports = exports.map(e =>
+        e === 'default' ? 'export default mfLsZJ92.default' : \`export const \${e} = mfLsZJ92[\${JSON.stringify(e)}];\`
+      ).join('');
+
+      const loadRef = \`const mfLsZJ92 = await container.loadRemote(\${JSON.stringify(ref)});\`;
+
+      return \`
+        const container = __FEDERATION__.__INSTANCES__.find(container => container.name === name) || __FEDERATION__.__INSTANCES__[0];
+        \${loadRef}
+        \${genExports}
+      \`;
+    };
+
+    function encodeInlineESM(code) {
+      const encodedCode = encodeURIComponent(code);
+      return \`data:text/javascript;charset=utf-8,\${encodedCode}\`;
+    }
+
+    const runtimePlugin = () => ({
+        name: 'import-maps-plugin',
+        async init(args) {
+
+            const remotePrefetch = args.options.remotes.map(async (remote) => {
+                if (remote.type === 'esm') {
+                    await import(remote.entry);
+                }
+            });
+
+
+            await Promise.all(remotePrefetch);
+
+            const map = Object.keys(moduleMap).reduce((acc, expose) => {
+                const importMap = importShim.getImportMap().imports;
+                const key = args.origin.name + expose.replace('.', '');
+                if (!importMap[key]) {
+                    const encodedModule = encodeInlineESM(
+                        createVirtualRemoteModule(args.origin.name, key, moduleMap[expose].exports)
+                    );
+                    acc[key] = encodedModule;
+                }
+                return acc;
+            }, {});
+            await importShim.addImportMap({ imports: map });
+
+            return args;
+        }
+    });
+
+    const createdContainer = await createContainer({
+      name: ${JSON.stringify(name)},
+      exposes: ${exposesConfig},
+      remotes: ${JSON.stringify(remoteConfigs)},
+      shared: ${sharedConfig},
+      plugins: [runtimePlugin()],
+    });
+
+    export const get = createdContainer.get;
+    export const init = createdContainer.init;
+  `;
+    //replace with createContainer from bundler runtime - import it in the string as a dep etc
+    return [
+        createContainerCode,
+        injectedContent
+    ].join('\n');
+};
+const createContainerPlugin = (config)=>({
+        name: 'createContainer',
+        setup (build) {
+            const { filename } = config;
+            const filter = new RegExp([
+                filename
+            ].map((name)=>`${name}$`).join('|'));
+            const hasShared = Object.keys(config.shared || {}).length;
+            const shared = Object.keys(config.shared || {}).map((name)=>`${name}$`).join('|');
+            const sharedExternals = new RegExp(shared);
+            build.onResolve({
+                filter
+            }, async (args)=>({
+                    path: args.path,
+                    namespace: 'container',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
+            build.onResolve({
+                filter: /^federationShare/
+            }, async (args)=>({
+                    path: args.path.replace('federationShare/', ''),
+                    namespace: 'esm-shares',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
+            if (hasShared) {
+                build.onResolve({
+                    filter: sharedExternals
+                }, (args)=>{
+                    if (args.namespace === 'esm-shares') return null;
+                    return {
+                        path: args.path,
+                        namespace: 'virtual-share-module',
+                        pluginData: {
+                            kind: args.kind,
+                            resolveDir: args.resolveDir
+                        }
+                    };
+                });
+                build.onResolve({
+                    filter: /.*/,
+                    namespace: 'esm-shares'
+                }, async (args)=>{
+                    if (sharedExternals.test(args.path)) {
+                        return {
+                            path: args.path,
+                            namespace: 'virtual-share-module',
+                            pluginData: {
+                                kind: args.kind,
+                                resolveDir: args.resolveDir
+                            }
+                        };
+                    }
+                    return undefined;
+                });
+            }
+            build.onLoad({
+                filter,
+                namespace: 'container'
+            }, async (args)=>({
+                    contents: buildContainerHost(config),
+                    loader: 'js',
+                    resolveDir: args.pluginData.resolveDir
+                }));
+        }
+    });
+
+export { createContainerPlugin };