@module-federation/esbuild 0.0.0-next-20240530210646 → 0.0.2

package/dist/plugin.cjs.js

@@ -12,6 +12,24 @@ var getExternals = require('./get-externals.cjs.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+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 fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var enhancedResolve__default = /*#__PURE__*/_interopDefaultLegacy(enhancedResolve);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
@@ -59,7 +77,7 @@ async function getExports(modulePath) {
     }
 }
 
-var version = "0.0.1";
+var version = "0.0.2";
 
 function _extends$1() {
     _extends$1 = Object.assign || function(target) {
@@ -515,7 +533,9 @@ const createContainerPlugin = (config)=>({
             const filter = new RegExp([
                 filename
             ].map((name)=>`${name}$`).join('|'));
-            const sharedExternals = new RegExp(Object.keys(config.shared || {}).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)=>({
@@ -536,24 +556,11 @@ const createContainerPlugin = (config)=>({
                         resolveDir: args.resolveDir
                     }
                 }));
-            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)) {
+            if (hasShared) {
+                build.onResolve({
+                    filter: sharedExternals
+                }, (args)=>{
+                    if (args.namespace === 'esm-shares') return null;
                     return {
                         path: args.path,
                         namespace: 'virtual-share-module',
@@ -562,9 +569,24 @@ const createContainerPlugin = (config)=>({
                             resolveDir: args.resolveDir
                         }
                     };
-                }
-                return undefined;
-            });
+                });
+                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'
@@ -605,7 +627,7 @@ const buildFederationHost = (config)=>{
     return `
     import { init as initFederationHost } from "@module-federation/runtime";
 
-    export const createVirtualRemoteModule = (name, ref, exports) => {
+    const createVirtualRemoteModule = (name, ref, exports) => {
       const genExports = exports.map(e =>
         e === 'default'
           ? 'export default mfLsZJ92.default;'
@@ -656,14 +678,14 @@ const buildFederationHost = (config)=>{
       }
     });
 
-     const host = initFederationHost({
+     const mfHoZJ92 = initFederationHost({
       name: ${JSON.stringify(name)},
       remotes: ${remoteConfigs},
       shared: ${sharedConfig},
       plugins: [runtimePlugin()],
     });
 
-    await Promise.all(host.initializeSharing('default', 'version-first'));
+    await Promise.all(mfHoZJ92.initializeSharing('default', 'version-first'));
 
 
   `;
@@ -766,6 +788,331 @@ const linkRemotesPlugin = (config)=>({
         }
     });
 
+// 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;
+    }
+}
+
+function orderedUniq(array) {
+    // prettier-ignore
+    const ret = [], visited = new Set();
+    for (const val of array)if (!visited.has(val)) visited.add(val), ret.push(val);
+    return ret;
+}
+function cachedReduce(array, reducer, s) {
+    // prettier-ignore
+    const cache = [
+        s
+    ];
+    let cacheLen = 1, last = s;
+    return (len)=>{
+        while(cacheLen <= len)cacheLen = cache.push(last = reducer(last, array[cacheLen - 1]));
+        return cache[len];
+    };
+}
+// from @rollup/pluginutils
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtin = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtin}`.split(' '));
+forbiddenIdentifiers.add('');
+const makeLegalIdentifier = function makeLegalIdentifier(str) {
+    let identifier = str.replace(/-(\w)/g, (_, letter)=>letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) {
+        identifier = `_${identifier}`;
+    }
+    return identifier || '_';
+};
+
+function commonjs({ filter = /\.c?js$/, transform = true, transformConfig, requireReturnsDefault = true, ignore } = {}) {
+    const init_cjs_module_lexer = transform ? Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('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 || (esbuild_shim = require('esbuild'));
+            const read = fs.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 (e) {
+                    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 : {};
+                        var _transformConfig_behavior;
+                        behavior != null ? behavior : behavior = (_transformConfig_behavior = transformConfig == null ? void 0 : transformConfig.behavior) != null ? _transformConfig_behavior : 'node';
+                        exports = orderedUniq(cjsExports.exports.concat(exports != null ? exports : []));
+                        var _transformConfig_sideEffects;
+                        sideEffects != null ? sideEffects : sideEffects = (_transformConfig_sideEffects = transformConfig == null ? void 0 : transformConfig.sideEffects) != null ? _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
+                    };
+                }
+            });
+        }
+    };
+}
+
 function _extends() {
     _extends = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
@@ -799,36 +1146,32 @@ const cjsToEsmPlugin = {
             filter: /.*/,
             namespace: 'esm-shares'
         }, async (args)=>{
-            const { transform } = await new Function('return import("@chialab/cjs-to-esm")')();
-            const resolver = await resolve(args.pluginData.resolveDir, args.path);
-            if (typeof resolver !== 'string') {
-                throw new Error(`Unable to resolve path: ${args.path}`);
-            }
-            const fileContent = fs__default["default"].readFileSync(resolver, 'utf-8');
-            try {
-                const result = await transform(fileContent);
-                if (result) {
-                    const { code } = result;
-                    return {
-                        contents: code,
-                        loader: 'js',
-                        resolveDir: path__default["default"].dirname(resolver),
-                        pluginData: _extends({}, args.pluginData, {
-                            path: resolver
-                        })
-                    };
-                }
-            } catch (e) {
-                return {
-                    contents: fileContent,
-                    loader: 'js',
-                    resolveDir: path__default["default"].dirname(resolver),
-                    pluginData: _extends({}, args.pluginData, {
-                        path: resolver
+            var _build_initialOptions_external;
+            let esbuild_shim;
+            const require_esbuild = ()=>build.esbuild || esbuild_shim || (esbuild_shim = require('esbuild'));
+            const packageBuilder = await require_esbuild().build(_extends({}, build.initialOptions, {
+                external: (_build_initialOptions_external = build.initialOptions.external) == null ? void 0 : _build_initialOptions_external.filter((e)=>{
+                    if (e.includes('*')) {
+                        const prefix = e.split('*')[0];
+                        return !args.path.startsWith(prefix);
+                    }
+                    return e !== args.path;
+                }),
+                entryPoints: [
+                    args.path
+                ],
+                plugins: [
+                    commonjs({
+                        filter: /.*/
                     })
-                };
-            }
-            return undefined;
+                ],
+                write: false
+            }));
+            return {
+                contents: packageBuilder.outputFiles[0].text,
+                loader: 'js',
+                resolveDir: args.pluginData.resolveDir
+            };
         });
     }
 };