@module-federation/esbuild 0.0.95 → 0.0.97

package/dist/adapters/lib/containerReference.js

@@ -0,0 +1,219 @@
+"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/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// 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__, {
+  buildFederationHost: () => (/* binding */ buildFederationHost),
+  initializeHostPlugin: () => (/* binding */ initializeHostPlugin)
+});
+
+;// CONCATENATED MODULE: external "fs"
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/__webpack_require__.n(external_fs_namespaceObject);
+;// CONCATENATED MODULE: ./src/adapters/lib/containerReference.ts
+
+// Builds the federation host code
+const buildFederationHost = (config)=>{
+    const { name, remotes, shared } = config;
+    const remoteConfigs = remotes ? JSON.stringify(Object.entries(remotes).map(([remoteAlias, remote])=>({
+            name: remoteAlias,
+            entry: remote,
+            alias: remoteAlias,
+            type: 'esm'
+        }))) : '[]';
+    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 () => await import('federationShare/${pkg}'),
+      "shareConfig": {
+        "singleton": ${config.singleton},
+        "requiredVersion": "${config.requiredVersion}",
+        "eager": ${config.eager},
+        "strictVersion": ${config.strictVersion}
+      }
+    },\n`;
+        return acc;
+    }, '{') + '}';
+    return `
+    import { init as initFederationHost } from "@module-federation/runtime";
+
+    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) {
+      return 'data:text/javascript;charset=utf-8,' + encodeURIComponent(code);
+    }
+
+    const runtimePlugin = () => ({
+      name: 'import-maps-plugin',
+      async init(args) {
+        const remotePrefetch = args.options.remotes.map(async (remote) => {
+          console.log('remote', remote);
+          if (remote.type === 'esm') {
+            await import(remote.entry);
+          }
+        });
+
+        await Promise.all(remotePrefetch);
+        if (typeof moduleMap !== 'undefined') {
+          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 mfHoZJ92 = initFederationHost({
+      name: ${JSON.stringify(name)},
+      remotes: ${remoteConfigs},
+      shared: ${sharedConfig},
+      plugins: [runtimePlugin()],
+    });
+
+    await Promise.all(mfHoZJ92.initializeSharing('default', 'version-first'));
+
+
+  `;
+};
+const initializeHostPlugin = (config)=>({
+        name: 'host-initialization',
+        setup (build) {
+            build.onResolve({
+                filter: /federation-host/
+            }, (args)=>({
+                    path: args.path,
+                    namespace: 'federation-host',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
+            build.onLoad({
+                filter: /.*/,
+                namespace: 'federation-host'
+            }, async (args)=>({
+                    contents: buildFederationHost(config),
+                    resolveDir: args.pluginData.resolveDir
+                }));
+            // Add custom loaders
+            const loaders = build.initialOptions.loader || {};
+            // Apply custom loaders
+            for (const [ext, loader] of Object.entries(loaders)){
+                build.onLoad({
+                    filter: new RegExp(`\\${ext}$`),
+                    namespace: 'file'
+                }, async (args)=>{
+                    const contents = await external_fs_default().promises.readFile(args.path, 'utf8');
+                    return {
+                        contents: buildFederationHost(config) + contents,
+                        loader
+                    };
+                });
+            }
+            // Fallback loader for files not matched by custom loaders
+            const fallbackFilter = new RegExp(Object.keys(loaders).map((ext)=>`\\${ext}$`).join('|'));
+            build.onLoad({
+                filter: /.*\.(ts|js|mjs)$/,
+                namespace: 'file'
+            }, //@ts-ignore
+            async (args)=>{
+                if (!fallbackFilter.test(args.path)) {
+                    if (!build.initialOptions.entryPoints.some((e)=>args.path.includes(e))) {
+                        return;
+                    }
+                    const contents = await external_fs_default().promises.readFile(args.path, 'utf8');
+                    return {
+                        contents: 'import "federation-host"; \n ' + contents
+                    };
+                }
+            });
+        }
+    });
+
+exports.buildFederationHost = __webpack_exports__.buildFederationHost;
+exports.initializeHostPlugin = __webpack_exports__.initializeHostPlugin;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["buildFederationHost","initializeHostPlugin"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/adapters/lib/containerReference.mjs

@@ -0,0 +1,154 @@
+import fs from "fs";
+
+;// CONCATENATED MODULE: external "fs"
+
+;// CONCATENATED MODULE: ./src/adapters/lib/containerReference.ts
+
+// Builds the federation host code
+const buildFederationHost = (config)=>{
+    const { name, remotes, shared } = config;
+    const remoteConfigs = remotes ? JSON.stringify(Object.entries(remotes).map(([remoteAlias, remote])=>({
+            name: remoteAlias,
+            entry: remote,
+            alias: remoteAlias,
+            type: 'esm'
+        }))) : '[]';
+    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 () => await import('federationShare/${pkg}'),
+      "shareConfig": {
+        "singleton": ${config.singleton},
+        "requiredVersion": "${config.requiredVersion}",
+        "eager": ${config.eager},
+        "strictVersion": ${config.strictVersion}
+      }
+    },\n`;
+        return acc;
+    }, '{') + '}';
+    return `
+    import { init as initFederationHost } from "@module-federation/runtime";
+
+    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) {
+      return 'data:text/javascript;charset=utf-8,' + encodeURIComponent(code);
+    }
+
+    const runtimePlugin = () => ({
+      name: 'import-maps-plugin',
+      async init(args) {
+        const remotePrefetch = args.options.remotes.map(async (remote) => {
+          console.log('remote', remote);
+          if (remote.type === 'esm') {
+            await import(remote.entry);
+          }
+        });
+
+        await Promise.all(remotePrefetch);
+        if (typeof moduleMap !== 'undefined') {
+          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 mfHoZJ92 = initFederationHost({
+      name: ${JSON.stringify(name)},
+      remotes: ${remoteConfigs},
+      shared: ${sharedConfig},
+      plugins: [runtimePlugin()],
+    });
+
+    await Promise.all(mfHoZJ92.initializeSharing('default', 'version-first'));
+
+
+  `;
+};
+const initializeHostPlugin = (config)=>({
+        name: 'host-initialization',
+        setup (build) {
+            build.onResolve({
+                filter: /federation-host/
+            }, (args)=>({
+                    path: args.path,
+                    namespace: 'federation-host',
+                    pluginData: {
+                        kind: args.kind,
+                        resolveDir: args.resolveDir
+                    }
+                }));
+            build.onLoad({
+                filter: /.*/,
+                namespace: 'federation-host'
+            }, async (args)=>({
+                    contents: buildFederationHost(config),
+                    resolveDir: args.pluginData.resolveDir
+                }));
+            // Add custom loaders
+            const loaders = build.initialOptions.loader || {};
+            // Apply custom loaders
+            for (const [ext, loader] of Object.entries(loaders)){
+                build.onLoad({
+                    filter: new RegExp(`\\${ext}$`),
+                    namespace: 'file'
+                }, async (args)=>{
+                    const contents = await fs.promises.readFile(args.path, 'utf8');
+                    return {
+                        contents: buildFederationHost(config) + contents,
+                        loader
+                    };
+                });
+            }
+            // Fallback loader for files not matched by custom loaders
+            const fallbackFilter = new RegExp(Object.keys(loaders).map((ext)=>`\\${ext}$`).join('|'));
+            build.onLoad({
+                filter: /.*\.(ts|js|mjs)$/,
+                namespace: 'file'
+            }, //@ts-ignore
+            async (args)=>{
+                if (!fallbackFilter.test(args.path)) {
+                    if (!build.initialOptions.entryPoints.some((e)=>args.path.includes(e))) {
+                        return;
+                    }
+                    const contents = await fs.promises.readFile(args.path, 'utf8');
+                    return {
+                        contents: 'import "federation-host"; \n ' + contents
+                    };
+                }
+            });
+        }
+    });
+
+export { buildFederationHost, initializeHostPlugin };

package/dist/adapters/lib/lexer.js

@@ -0,0 +1,184 @@
+"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__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  Lexer: () => (Lexer)
+});
+// simplified from acorn (MIT license)
+function isNewLine(code) {
+    return code === 10 || code === 13 || code === 0x2028 || code === 0x2029;
+}
+function codePointToString(ch) {
+    if (ch <= 0xffff) return String.fromCharCode(ch);
+    ch -= 0x10000;
+    return String.fromCharCode((ch >> 10) + 0xd800, (ch & 0x03ff) + 0xdc00);
+}
+class Lexer {
+    readString(input, pos) {
+        if (pos >= input.length) return null;
+        this.input = input;
+        this.pos = pos;
+        const quote = this.input.charCodeAt(pos);
+        if (!(quote === 34 || quote === 39)) return null;
+        let out = '';
+        let chunkStart = ++this.pos;
+        //eslint-disable-next-line no-constant-condition
+        while(true){
+            if (this.pos >= this.input.length) return null;
+            const ch = this.input.charCodeAt(this.pos);
+            if (ch === quote) break;
+            if (ch === 92) {
+                out += this.input.slice(chunkStart, this.pos);
+                const escaped = this.readEscapedChar();
+                if (escaped === null) return null;
+                out += escaped;
+                chunkStart = this.pos;
+            } else {
+                if (isNewLine(ch)) return null;
+                ++this.pos;
+            }
+        }
+        out += this.input.slice(chunkStart, this.pos++);
+        return out;
+    }
+    readEscapedChar() {
+        const ch = this.input.charCodeAt(++this.pos);
+        let code;
+        ++this.pos;
+        switch(ch){
+            case 110:
+                return '\n';
+            case 114:
+                return '\r';
+            case 120:
+                code = this.readHexChar(2);
+                if (code === null) return null;
+                return String.fromCharCode(code);
+            case 117:
+                code = this.readCodePoint();
+                if (code === null) return null;
+                return codePointToString(code);
+            case 116:
+                return '\t';
+            case 98:
+                return '\b';
+            case 118:
+                return '\u000b';
+            case 102:
+                return '\f';
+            //@ts-ignore
+            case 13:
+                if (this.input.charCodeAt(this.pos) === 10) {
+                    ++this.pos;
+                }
+            // fall through
+            case 10:
+                return '';
+            case 56:
+            case 57:
+                return null;
+            default:
+                if (ch >= 48 && ch <= 55) {
+                    const match = this.input.slice(this.pos - 1, this.pos + 2).match(/^[0-7]+/);
+                    if (match === null) return null;
+                    let octalStr = match[0];
+                    let octal = parseInt(octalStr, 8);
+                    if (octal > 255) {
+                        octalStr = octalStr.slice(0, -1);
+                        octal = parseInt(octalStr, 8);
+                    }
+                    this.pos += octalStr.length - 1;
+                    const nextCh = this.input.charCodeAt(this.pos);
+                    if (octalStr !== '0' || nextCh === 56 || nextCh === 57) return null;
+                    return String.fromCharCode(octal);
+                }
+                if (isNewLine(ch)) return '';
+                return String.fromCharCode(ch);
+        }
+    }
+    readInt(radix, len) {
+        const start = this.pos;
+        let total = 0;
+        for(let i = 0; i < len; ++i, ++this.pos){
+            const code = this.input.charCodeAt(this.pos);
+            let val;
+            if (code >= 97) {
+                val = code - 97 + 10;
+            } else if (code >= 65) {
+                val = code - 65 + 10;
+            } else if (code >= 48 && code <= 57) {
+                val = code - 48;
+            } else {
+                val = Infinity;
+            }
+            if (val >= radix) break;
+            total = total * radix + val;
+        }
+        if (this.pos === start || len != null && this.pos - start !== len) return null;
+        return total;
+    }
+    readHexChar(len) {
+        return this.readInt(16, len);
+    }
+    readCodePoint() {
+        const ch = this.input.charCodeAt(this.pos);
+        let code;
+        if (ch === 123) {
+            ++this.pos;
+            code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
+            ++this.pos;
+            if (code && code > 0x10ffff) return null;
+        } else {
+            code = this.readHexChar(4);
+        }
+        return code;
+    }
+    constructor(){
+        this.input = '';
+        this.pos = 0;
+    }
+}
+
+exports.Lexer = __webpack_exports__.Lexer;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["Lexer"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/adapters/lib/lexer.mjs

@@ -0,0 +1,138 @@
+
+;// CONCATENATED MODULE: ./src/adapters/lib/lexer.ts
+// simplified from acorn (MIT license)
+function isNewLine(code) {
+    return code === 10 || code === 13 || code === 0x2028 || code === 0x2029;
+}
+function codePointToString(ch) {
+    if (ch <= 0xffff) return String.fromCharCode(ch);
+    ch -= 0x10000;
+    return String.fromCharCode((ch >> 10) + 0xd800, (ch & 0x03ff) + 0xdc00);
+}
+class Lexer {
+    readString(input, pos) {
+        if (pos >= input.length) return null;
+        this.input = input;
+        this.pos = pos;
+        const quote = this.input.charCodeAt(pos);
+        if (!(quote === 34 || quote === 39)) return null;
+        let out = '';
+        let chunkStart = ++this.pos;
+        //eslint-disable-next-line no-constant-condition
+        while(true){
+            if (this.pos >= this.input.length) return null;
+            const ch = this.input.charCodeAt(this.pos);
+            if (ch === quote) break;
+            if (ch === 92) {
+                out += this.input.slice(chunkStart, this.pos);
+                const escaped = this.readEscapedChar();
+                if (escaped === null) return null;
+                out += escaped;
+                chunkStart = this.pos;
+            } else {
+                if (isNewLine(ch)) return null;
+                ++this.pos;
+            }
+        }
+        out += this.input.slice(chunkStart, this.pos++);
+        return out;
+    }
+    readEscapedChar() {
+        const ch = this.input.charCodeAt(++this.pos);
+        let code;
+        ++this.pos;
+        switch(ch){
+            case 110:
+                return '\n';
+            case 114:
+                return '\r';
+            case 120:
+                code = this.readHexChar(2);
+                if (code === null) return null;
+                return String.fromCharCode(code);
+            case 117:
+                code = this.readCodePoint();
+                if (code === null) return null;
+                return codePointToString(code);
+            case 116:
+                return '\t';
+            case 98:
+                return '\b';
+            case 118:
+                return '\u000b';
+            case 102:
+                return '\f';
+            //@ts-ignore
+            case 13:
+                if (this.input.charCodeAt(this.pos) === 10) {
+                    ++this.pos;
+                }
+            // fall through
+            case 10:
+                return '';
+            case 56:
+            case 57:
+                return null;
+            default:
+                if (ch >= 48 && ch <= 55) {
+                    const match = this.input.slice(this.pos - 1, this.pos + 2).match(/^[0-7]+/);
+                    if (match === null) return null;
+                    let octalStr = match[0];
+                    let octal = parseInt(octalStr, 8);
+                    if (octal > 255) {
+                        octalStr = octalStr.slice(0, -1);
+                        octal = parseInt(octalStr, 8);
+                    }
+                    this.pos += octalStr.length - 1;
+                    const nextCh = this.input.charCodeAt(this.pos);
+                    if (octalStr !== '0' || nextCh === 56 || nextCh === 57) return null;
+                    return String.fromCharCode(octal);
+                }
+                if (isNewLine(ch)) return '';
+                return String.fromCharCode(ch);
+        }
+    }
+    readInt(radix, len) {
+        const start = this.pos;
+        let total = 0;
+        for(let i = 0; i < len; ++i, ++this.pos){
+            const code = this.input.charCodeAt(this.pos);
+            let val;
+            if (code >= 97) {
+                val = code - 97 + 10;
+            } else if (code >= 65) {
+                val = code - 65 + 10;
+            } else if (code >= 48 && code <= 57) {
+                val = code - 48;
+            } else {
+                val = Infinity;
+            }
+            if (val >= radix) break;
+            total = total * radix + val;
+        }
+        if (this.pos === start || len != null && this.pos - start !== len) return null;
+        return total;
+    }
+    readHexChar(len) {
+        return this.readInt(16, len);
+    }
+    readCodePoint() {
+        const ch = this.input.charCodeAt(this.pos);
+        let code;
+        if (ch === 123) {
+            ++this.pos;
+            code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
+            ++this.pos;
+            if (code && code > 0x10ffff) return null;
+        } else {
+            code = this.readHexChar(4);
+        }
+        return code;
+    }
+    constructor(){
+        this.input = '';
+        this.pos = 0;
+    }
+}
+
+export { Lexer };