@module-federation/vite 1.9.4 → 1.9.6

package/lib/index.cjs

@@ -4,6 +4,9 @@ var path = require('pathe');
 var MagicString = require('magic-string');
 var pluginutils = require('@rollup/pluginutils');
 var estreeWalker = require('estree-walker');
+var sdk = require('@module-federation/sdk');
+var dtsPlugin = require('@module-federation/dts-plugin');
+var core = require('@module-federation/dts-plugin/core');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -587,6 +590,96 @@ function createFile(filePath, content) {
   fs.writeFileSync(filePath, content);
 }
 
+/**
+ * Serializes a JavaScript object into a string of source code that can be evaluated.
+ * This function is used to create runtime plugin options without relying solely on JSON.stringify,
+ * allowing support for non-JSON types like RegExp, Date, Map, Set, and Functions.
+ * It also safely handles circular references.
+ *
+ * @param {Record<string, unknown>} options - The options object to serialize.
+ * @returns {string} The resulting JavaScript source code string.
+ */
+function serializeRuntimeOptions(options) {
+  // Use a WeakSet to track objects already encountered, which helps in detecting circular references.
+  var seenObjects = new WeakSet();
+  /**
+   * Recursive inner function to serialize any value into a source code string.
+   */
+  function valueToCode(val) {
+    // 1. Handle primitive values
+    if (val === null) return 'null';
+    var type = typeof val;
+    if (type === 'string') return JSON.stringify(val);
+    if (type === 'number' || type === 'boolean') return String(val);
+    if (type === 'undefined') return 'undefined';
+    // Handle Symbol
+    if (type === 'symbol') {
+      var _val$description;
+      var desc = (_val$description = val.description) != null ? _val$description : '';
+      return "Symbol(" + JSON.stringify(desc) + ")";
+    }
+    // Handle Function (returns the function's source code)
+    if (type === 'function') return val.toString();
+    // 2. Handle special built-in objects
+    if (val instanceof Date) return "new Date(" + JSON.stringify(val.toISOString()) + ")";
+    if (val instanceof RegExp) {
+      return "new RegExp(" + JSON.stringify(val.source) + ", " + JSON.stringify(val.flags) + ")";
+    }
+    // 3. Check for circular references and mark object as seen
+    // This applies to objects, arrays, maps, and sets.
+    if (type === 'object') {
+      if (seenObjects.has(val)) {
+        // This object has been seen previously in the recursion path
+        return "\"__circular__\"";
+      }
+      seenObjects.add(val);
+    }
+    // 4. Handle Array, Map, Set
+    if (Array.isArray(val)) {
+      // Recursively serialize each element
+      return "[" + val.map(valueToCode).join(', ') + "]";
+    }
+    if (val instanceof Map) {
+      // Serialize Map entries into an array of [key, value] pairs
+      var entries = Array.from(val.entries()).map(function (_ref) {
+        var k = _ref[0],
+          v = _ref[1];
+        return "[" + valueToCode(k) + ", " + valueToCode(v) + "]";
+      });
+      return "new Map([" + entries.join(', ') + "])";
+    }
+    if (val instanceof Set) {
+      // Serialize Set values into an array
+      var items = Array.from(val.values()).map(valueToCode);
+      return "new Set([" + items.join(', ') + "])";
+    }
+    // 5. Handle plain objects (the default object type)
+    if (type === 'object') {
+      var properties = [];
+      // Iterate over the object's own enumerable properties
+      for (var key in val) {
+        if (Object.prototype.hasOwnProperty.call(val, key)) {
+          // Wrap the key in JSON.stringify to handle non-identifier keys
+          properties.push(JSON.stringify(key) + ": " + valueToCode(val[key]));
+        }
+      }
+      return "{" + properties.join(', ') + "}";
+    }
+    // 6. Fallback case (e.g., BigInt, other object types)
+    // Coerce to string and then JSON.stringify that string for safety
+    return JSON.stringify(String(val));
+  }
+  // Start serialization for the top-level object
+  var topLevelProps = [];
+  // Iterate over the properties of the root 'options' object
+  for (var key in options) {
+    if (Object.prototype.hasOwnProperty.call(options, key)) {
+      topLevelProps.push(JSON.stringify(key) + ": " + valueToCode(options[key]));
+    }
+  }
+  return "{" + topLevelProps.join(', ') + "}";
+}
+
 // Cache root path
 var rootDir;
 function findNodeModulesDir(root) {
@@ -823,12 +916,16 @@ function generateLocalSharedImportMap() {
 var REMOTE_ENTRY_ID = 'virtual:mf-REMOTE_ENTRY_ID';
 function generateRemoteEntry(options) {
   var pluginImportNames = options.runtimePlugins.map(function (p, i) {
-    return ["$runtimePlugin_" + i, "import $runtimePlugin_" + i + " from \"" + p + "\";"];
+    if (typeof p === 'string') {
+      return ["$runtimePlugin_" + i, "import $runtimePlugin_" + i + " from \"" + p + "\";", "undefined"];
+    } else {
+      return ["$runtimePlugin_" + i, "import $runtimePlugin_" + i + " from \"" + p[0] + "\";", serializeRuntimeOptions(p[1])];
+    }
   });
   return "\n  import {init as runtimeInit, loadRemote} from \"@module-federation/runtime\";\n  " + pluginImportNames.map(function (item) {
     return item[1];
   }).join('\n') + "\n  import exposesMap from \"" + VIRTUAL_EXPOSES + "\"\n  import {usedShared, usedRemotes} from \"" + getLocalSharedImportMapPath() + "\"\n  import {\n    initResolve\n  } from \"" + virtualRuntimeInitStatus.getImportId() + "\"\n  const initTokens = {}\n  const shareScopeName = " + JSON.stringify(options.shareScope) + "\n  const mfName = " + JSON.stringify(options.name) + "\n  async function init(shared = {}, initScope = []) {\n    const initRes = runtimeInit({\n      name: mfName,\n      remotes: usedRemotes,\n      shared: usedShared,\n      plugins: [" + pluginImportNames.map(function (item) {
-    return item[0] + "()";
+    return item[0] + "(" + item[2] + ")";
   }).join(', ') + "],\n      " + (options.shareStrategy ? "shareStrategy: '" + options.shareStrategy + "'" : '') + "\n    });\n    // handling circular init calls\n    var initToken = initTokens[shareScopeName];\n    if (!initToken)\n      initToken = initTokens[shareScopeName] = { from: mfName };\n    if (initScope.indexOf(initToken) >= 0) return;\n    initScope.push(initToken);\n    initRes.initShareScopeMap('" + options.shareScope + "', shared);\n    try {\n      await Promise.all(await initRes.initializeSharing('" + options.shareScope + "', {\n        strategy: '" + options.shareStrategy + "',\n        from: \"build\",\n        initScope\n      }));\n    } catch (e) {\n      console.error(e)\n    }\n    initResolve(initRes)\n    return initRes\n  }\n\n  function getExposes(moduleName) {\n    if (!(moduleName in exposesMap)) throw new Error(`Module ${moduleName} does not exist in container.`)\n    return (exposesMap[moduleName])().then(res => () => res)\n  }\n  export {\n      init,\n      getExposes as get\n  }\n  ";
 }
 /**
@@ -1442,6 +1539,322 @@ function pluginProxyRemotes (options) {
   };
 }
 
+function _catch(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+var DEFAULT_DEV_OPTIONS = {
+  disableLiveReload: true,
+  disableHotTypesReload: false,
+  disableDynamicRemoteTypeHints: false
+};
+var DYNAMIC_HINTS_PLUGIN = '@module-federation/dts-plugin/dynamic-remote-type-hints-plugin';
+var getIPv4 = function getIPv4() {
+  return process.env['FEDERATION_IPV4'] || '127.0.0.1';
+};
+var forkDevWorkerPath = function () {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return require.resolve('@module-federation/dts-plugin/dist/fork-dev-worker.js');
+}();
+var DevWorker = /*#__PURE__*/function () {
+  function DevWorker(options) {
+    this.worker = core.rpc.createRpcWorker(forkDevWorkerPath, {}, undefined, false);
+    this.worker.connect(options);
+  }
+  var _proto = DevWorker.prototype;
+  _proto.update = function update() {
+    var _this$worker$process;
+    (_this$worker$process = this.worker.process) == null || _this$worker$process.send == null || _this$worker$process.send({
+      type: core.rpc.RpcGMCallTypes.CALL,
+      id: this.worker.id,
+      args: [undefined, 'update']
+    });
+  };
+  _proto.exit = function exit() {
+    this.worker.terminate();
+  };
+  return DevWorker;
+}();
+var normalizeDevOptions = function normalizeDevOptions(dev) {
+  if (dev === false) {
+    return false;
+  }
+  if (dev === true || typeof dev === 'undefined') {
+    return _extends({}, DEFAULT_DEV_OPTIONS);
+  }
+  return _extends({}, DEFAULT_DEV_OPTIONS, dev);
+};
+var buildDtsModuleFederationConfig = function buildDtsModuleFederationConfig(options) {
+  var exposes = {};
+  Object.entries(options.exposes).forEach(function (_ref) {
+    var key = _ref[0],
+      value = _ref[1];
+    if (typeof value === 'string') {
+      exposes[key] = value;
+      return;
+    }
+    var importValue = Array.isArray(value["import"]) ? value["import"][0] : value["import"];
+    if (importValue) {
+      exposes[key] = importValue;
+    }
+  });
+  var remotes = {};
+  Object.entries(options.remotes).forEach(function (_ref2) {
+    var _remote$entryGlobalNa, _remote$entryGlobalNa2;
+    var key = _ref2[0],
+      remote = _ref2[1];
+    if (typeof remote === 'string') {
+      remotes[key] = remote;
+      return;
+    }
+    if (!remote.entry) {
+      return;
+    }
+    var entryLooksLikeUrl = ((_remote$entryGlobalNa = remote.entryGlobalName) == null ? void 0 : _remote$entryGlobalNa.startsWith('http')) || ((_remote$entryGlobalNa2 = remote.entryGlobalName) == null ? void 0 : _remote$entryGlobalNa2.includes('.json'));
+    var entryGlobalName = entryLooksLikeUrl ? remote.name || key : remote.entryGlobalName || remote.name || key;
+    remotes[key] = entryGlobalName + "@" + remote.entry;
+  });
+  return _extends({}, options, {
+    exposes: exposes,
+    remotes: remotes
+  });
+};
+var resolveOutputDir = function resolveOutputDir(config) {
+  var outDir = config.build.outDir;
+  if (path__namespace.isAbsolute(outDir)) {
+    return path__namespace.relative(config.root, outDir);
+  }
+  return outDir;
+};
+var ensureRuntimePlugin = function ensureRuntimePlugin(options, pluginId) {
+  var hasPlugin = options.runtimePlugins.some(function (plugin) {
+    if (typeof plugin === 'string') {
+      return plugin === pluginId;
+    }
+    return plugin[0] === pluginId;
+  });
+  if (!hasPlugin) {
+    options.runtimePlugins.push(pluginId);
+  }
+};
+var normalizeDevDtsOptions = function normalizeDevDtsOptions(dts, context) {
+  var defaultGenerateTypes = {
+    compileInChildProcess: true
+  };
+  var defaultConsumeTypes = {
+    consumeAPITypes: true
+  };
+  return sdk.normalizeOptions(dtsPlugin.isTSProject(dts, context), {
+    generateTypes: defaultGenerateTypes,
+    consumeTypes: defaultConsumeTypes,
+    extraOptions: {},
+    displayErrorInTerminal: typeof dts === 'object' && dts ? dts.displayErrorInTerminal : undefined
+  }, 'mfOptions.dts')(dts);
+};
+var logDtsError = function logDtsError(error, dtsOptions) {
+  if (dtsOptions && dtsOptions.displayErrorInTerminal !== false) {
+    console.error(error);
+  }
+};
+function pluginDts(options) {
+  if (options.dts === false) {
+    return [];
+  }
+  var dtsModuleFederationConfig = buildDtsModuleFederationConfig(options);
+  var resolvedConfig;
+  var devWorker;
+  var normalizedDevOptions;
+  var hasGeneratedBundle = false;
+  var devPlugin = {
+    name: 'module-federation-dts-dev',
+    apply: 'serve',
+    config: function config(_config) {
+      normalizedDevOptions = normalizeDevOptions(options.dev);
+      if (!normalizedDevOptions) {
+        return;
+      }
+      if (normalizedDevOptions.disableDynamicRemoteTypeHints) {
+        return;
+      }
+      ensureRuntimePlugin(options, DYNAMIC_HINTS_PLUGIN);
+      var define = _config.define ? _extends({}, _config.define) : {};
+      if (!('FEDERATION_IPV4' in define)) {
+        define.FEDERATION_IPV4 = JSON.stringify(getIPv4());
+      }
+      _config.define = define;
+    },
+    configResolved: function configResolved(config) {
+      resolvedConfig = config;
+    },
+    configureServer: function configureServer(server) {
+      if (!normalizedDevOptions || !resolvedConfig) {
+        return;
+      }
+      var devOptions = normalizedDevOptions;
+      if (devOptions.disableDynamicRemoteTypeHints && devOptions.disableHotTypesReload && devOptions.disableLiveReload) {
+        return;
+      }
+      if (!options.name) {
+        throw new Error('name is required if you want to enable dev server!');
+      }
+      var outputDir = resolveOutputDir(resolvedConfig);
+      var normalizedDtsOptions = normalizeDevDtsOptions(options.dts, resolvedConfig.root);
+      if (typeof normalizedDtsOptions !== 'object') {
+        return;
+      }
+      var normalizedGenerateTypes = sdk.normalizeOptions(Boolean(normalizedDtsOptions), {
+        compileInChildProcess: true
+      }, 'mfOptions.dts.generateTypes')(normalizedDtsOptions.generateTypes);
+      var remote = normalizedGenerateTypes === false ? undefined : _extends({
+        implementation: normalizedDtsOptions.implementation,
+        context: resolvedConfig.root,
+        outputDir: outputDir,
+        moduleFederationConfig: _extends({}, dtsModuleFederationConfig),
+        hostRemoteTypesFolder: normalizedGenerateTypes.typesFolder || '@mf-types'
+      }, normalizedGenerateTypes, {
+        typesFolder: '.dev-server'
+      });
+      if (remote && !remote.tsConfigPath && typeof normalizedDtsOptions === 'object' && normalizedDtsOptions.tsConfigPath) {
+        remote.tsConfigPath = normalizedDtsOptions.tsConfigPath;
+      }
+      var normalizedConsumeTypes = sdk.normalizeOptions(Boolean(normalizedDtsOptions), {
+        consumeAPITypes: true
+      }, 'mfOptions.dts.consumeTypes')(normalizedDtsOptions.consumeTypes);
+      var host = normalizedConsumeTypes === false ? undefined : _extends({
+        implementation: normalizedDtsOptions.implementation,
+        context: resolvedConfig.root,
+        moduleFederationConfig: dtsModuleFederationConfig,
+        typesFolder: normalizedConsumeTypes.typesFolder || '@mf-types',
+        abortOnError: false
+      }, normalizedConsumeTypes);
+      var extraOptions = normalizedDtsOptions.extraOptions || {};
+      if (!remote && !host && devOptions.disableLiveReload) {
+        return;
+      }
+      var startDevWorker = function startDevWorker() {
+        try {
+          var _temp2 = function _temp2() {
+            var _server$httpServer;
+            devWorker = new DevWorker({
+              name: options.name,
+              remote: remote,
+              host: host ? _extends({}, host, {
+                remoteTypeUrls: remoteTypeUrls
+              }) : undefined,
+              extraOptions: extraOptions,
+              disableLiveReload: devOptions.disableLiveReload,
+              disableHotTypesReload: devOptions.disableHotTypesReload
+            });
+            var update = function update() {
+              var _devWorker;
+              return (_devWorker = devWorker) == null ? void 0 : _devWorker.update();
+            };
+            server.watcher.on('change', update);
+            server.watcher.on('add', update);
+            server.watcher.on('unlink', update);
+            (_server$httpServer = server.httpServer) == null || _server$httpServer.once('close', function () {
+              var _devWorker2;
+              (_devWorker2 = devWorker) == null || _devWorker2.exit();
+              server.watcher.off('change', update);
+              server.watcher.off('add', update);
+              server.watcher.off('unlink', update);
+            });
+          };
+          var remoteTypeUrls;
+          var _temp = function () {
+            if (host) {
+              return Promise.resolve(new Promise(function (resolve) {
+                dtsPlugin.consumeTypesAPI({
+                  host: host,
+                  extraOptions: extraOptions,
+                  displayErrorInTerminal: normalizedDtsOptions.displayErrorInTerminal
+                }, resolve);
+              })).then(function (_Promise) {
+                remoteTypeUrls = _Promise;
+              });
+            }
+          }();
+          return Promise.resolve(_temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp));
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      };
+      startDevWorker()["catch"](function (error) {
+        logDtsError(error, normalizedDtsOptions);
+      });
+    }
+  };
+  var buildPlugin = {
+    name: 'module-federation-dts-build',
+    apply: 'build',
+    configResolved: function configResolved(config) {
+      resolvedConfig = config;
+    },
+    generateBundle: function generateBundle() {
+      try {
+        var _temp6 = function _temp6() {
+          var generateOptions = dtsPlugin.normalizeGenerateTypesOptions({
+            context: context,
+            outputDir: outputDir,
+            dtsOptions: normalizedDtsOptions,
+            pluginOptions: dtsModuleFederationConfig
+          });
+          if (!generateOptions) {
+            return;
+          }
+          var _temp4 = _catch(function () {
+            return Promise.resolve(dtsPlugin.generateTypesAPI({
+              dtsManagerOptions: generateOptions
+            })).then(function () {});
+          }, function (error) {
+            logDtsError(error, normalizedDtsOptions);
+          });
+          if (_temp4 && _temp4.then) return _temp4.then(function () {});
+        };
+        if (hasGeneratedBundle) {
+          return Promise.resolve();
+        }
+        hasGeneratedBundle = true;
+        if (!resolvedConfig) {
+          return Promise.resolve();
+        }
+        var normalizedDtsOptions = dtsPlugin.normalizeDtsOptions(dtsModuleFederationConfig, resolvedConfig.root);
+        if (typeof normalizedDtsOptions !== 'object') {
+          return Promise.resolve();
+        }
+        var context = resolvedConfig.root;
+        var outputDir = resolveOutputDir(resolvedConfig);
+        var consumeOptions = dtsPlugin.normalizeConsumeTypesOptions({
+          context: context,
+          dtsOptions: normalizedDtsOptions,
+          pluginOptions: dtsModuleFederationConfig
+        });
+        var _temp5 = function (_consumeOptions$host) {
+          if (consumeOptions != null && (_consumeOptions$host = consumeOptions.host) != null && _consumeOptions$host.typesOnBuild) {
+            var _temp3 = _catch(function () {
+              return Promise.resolve(dtsPlugin.consumeTypesAPI(consumeOptions)).then(function () {});
+            }, function (error) {
+              logDtsError(error, normalizedDtsOptions);
+            });
+            if (_temp3 && _temp3.then) return _temp3.then(function () {});
+          }
+        }();
+        return Promise.resolve(_temp5 && _temp5.then ? _temp5.then(_temp6) : _temp6(_temp5));
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  };
+  return [devPlugin, buildPlugin];
+}
+
 /**
  * example:
  * const store = new PromiseStore<number>();
@@ -1619,7 +2032,7 @@ function federation(mfUserOptions) {
     }
   }, aliasToArrayPlugin, checkAliasConflicts({
     shared: shared
-  }), normalizeOptimizeDepsPlugin].concat(addEntry({
+  }), normalizeOptimizeDepsPlugin].concat(pluginDts(options), addEntry({
     entryName: 'remoteEntry',
     entryPath: REMOTE_ENTRY_ID,
     fileName: filename