@module-federation/vite 1.9.4 → 1.9.6

package/lib/index.modern.js

@@ -6,6 +6,9 @@ import path__default, { resolve, basename, parse, join, dirname } from 'pathe';
 import MagicString from 'magic-string';
 import { createFilter } from '@rollup/pluginutils';
 import { walk } from 'estree-walker';
+import { normalizeOptions } from '@module-federation/sdk';
+import { normalizeDtsOptions, normalizeConsumeTypesOptions, consumeTypesAPI, normalizeGenerateTypesOptions, generateTypesAPI, isTSProject } from '@module-federation/dts-plugin';
+import { rpc } from '@module-federation/dts-plugin/core';
 
 async function mapCodeToCodeWithSourcemap(code) {
   const resolvedCode = await code;
@@ -537,6 +540,92 @@ function createFile(filePath, content) {
   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.
+  const 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';
+    const 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;
+      const 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
+      const entries = Array.from(val.entries()).map(([k, v]) => `[${valueToCode(k)}, ${valueToCode(v)}]`);
+      return `new Map([${entries.join(', ')}])`;
+    }
+    if (val instanceof Set) {
+      // Serialize Set values into an array
+      const items = Array.from(val.values()).map(valueToCode);
+      return `new Set([${items.join(', ')}])`;
+    }
+    // 5. Handle plain objects (the default object type)
+    if (type === 'object') {
+      const properties = [];
+      // Iterate over the object's own enumerable properties
+      for (const 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
+  const topLevelProps = [];
+  // Iterate over the properties of the root 'options' object
+  for (const key in options) {
+    if (Object.prototype.hasOwnProperty.call(options, key)) {
+      topLevelProps.push(`${JSON.stringify(key)}: ${valueToCode(options[key])}`);
+    }
+  }
+  return `{${topLevelProps.join(', ')}}`;
+}
+
 // Cache root path
 let rootDir;
 function findNodeModulesDir(root = process.cwd()) {
@@ -859,7 +948,13 @@ function generateLocalSharedImportMap() {
 }
 const REMOTE_ENTRY_ID = 'virtual:mf-REMOTE_ENTRY_ID';
 function generateRemoteEntry(options) {
-  const pluginImportNames = options.runtimePlugins.map((p, i) => [`$runtimePlugin_${i}`, `import $runtimePlugin_${i} from "${p}";`]);
+  const pluginImportNames = options.runtimePlugins.map((p, i) => {
+    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 `
   import {init as runtimeInit, loadRemote} from "@module-federation/runtime";
   ${pluginImportNames.map(item => item[1]).join('\n')}
@@ -876,7 +971,7 @@ function generateRemoteEntry(options) {
       name: mfName,
       remotes: usedRemotes,
       shared: usedShared,
-      plugins: [${pluginImportNames.map(item => `${item[0]}()`).join(', ')}],
+      plugins: [${pluginImportNames.map(item => `${item[0]}(${item[2]})`).join(', ')}],
       ${options.shareStrategy ? `shareStrategy: '${options.shareStrategy}'` : ''}
     });
     // handling circular init calls
@@ -1496,6 +1591,284 @@ function pluginProxyRemotes (options) {
   };
 }
 
+const DEFAULT_DEV_OPTIONS = {
+  disableLiveReload: true,
+  disableHotTypesReload: false,
+  disableDynamicRemoteTypeHints: false
+};
+const DYNAMIC_HINTS_PLUGIN = '@module-federation/dts-plugin/dynamic-remote-type-hints-plugin';
+const getIPv4 = () => process.env['FEDERATION_IPV4'] || '127.0.0.1';
+const forkDevWorkerPath = (() => {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return require.resolve('@module-federation/dts-plugin/dist/fork-dev-worker.js');
+})();
+class DevWorker {
+  constructor(options) {
+    this.worker = rpc.createRpcWorker(forkDevWorkerPath, {}, undefined, false);
+    this.worker.connect(options);
+  }
+  update() {
+    var _this$worker$process;
+    (_this$worker$process = this.worker.process) == null || _this$worker$process.send == null || _this$worker$process.send({
+      type: rpc.RpcGMCallTypes.CALL,
+      id: this.worker.id,
+      args: [undefined, 'update']
+    });
+  }
+  exit() {
+    this.worker.terminate();
+  }
+}
+const normalizeDevOptions = dev => {
+  if (dev === false) {
+    return false;
+  }
+  if (dev === true || typeof dev === 'undefined') {
+    return _extends({}, DEFAULT_DEV_OPTIONS);
+  }
+  return _extends({}, DEFAULT_DEV_OPTIONS, dev);
+};
+const buildDtsModuleFederationConfig = options => {
+  const exposes = {};
+  Object.entries(options.exposes).forEach(([key, value]) => {
+    if (typeof value === 'string') {
+      exposes[key] = value;
+      return;
+    }
+    const importValue = Array.isArray(value.import) ? value.import[0] : value.import;
+    if (importValue) {
+      exposes[key] = importValue;
+    }
+  });
+  const remotes = {};
+  Object.entries(options.remotes).forEach(([key, remote]) => {
+    var _remote$entryGlobalNa, _remote$entryGlobalNa2;
+    if (typeof remote === 'string') {
+      remotes[key] = remote;
+      return;
+    }
+    if (!remote.entry) {
+      return;
+    }
+    const entryLooksLikeUrl = ((_remote$entryGlobalNa = remote.entryGlobalName) == null ? void 0 : _remote$entryGlobalNa.startsWith('http')) || ((_remote$entryGlobalNa2 = remote.entryGlobalName) == null ? void 0 : _remote$entryGlobalNa2.includes('.json'));
+    const entryGlobalName = entryLooksLikeUrl ? remote.name || key : remote.entryGlobalName || remote.name || key;
+    remotes[key] = `${entryGlobalName}@${remote.entry}`;
+  });
+  return _extends({}, options, {
+    exposes,
+    remotes
+  });
+};
+const resolveOutputDir = config => {
+  const {
+    outDir
+  } = config.build;
+  if (path.isAbsolute(outDir)) {
+    return path.relative(config.root, outDir);
+  }
+  return outDir;
+};
+const ensureRuntimePlugin = (options, pluginId) => {
+  const hasPlugin = options.runtimePlugins.some(plugin => {
+    if (typeof plugin === 'string') {
+      return plugin === pluginId;
+    }
+    return plugin[0] === pluginId;
+  });
+  if (!hasPlugin) {
+    options.runtimePlugins.push(pluginId);
+  }
+};
+const normalizeDevDtsOptions = (dts, context) => {
+  const defaultGenerateTypes = {
+    compileInChildProcess: true
+  };
+  const defaultConsumeTypes = {
+    consumeAPITypes: true
+  };
+  return normalizeOptions(isTSProject(dts, context), {
+    generateTypes: defaultGenerateTypes,
+    consumeTypes: defaultConsumeTypes,
+    extraOptions: {},
+    displayErrorInTerminal: typeof dts === 'object' && dts ? dts.displayErrorInTerminal : undefined
+  }, 'mfOptions.dts')(dts);
+};
+const logDtsError = (error, dtsOptions) => {
+  if (dtsOptions && dtsOptions.displayErrorInTerminal !== false) {
+    console.error(error);
+  }
+};
+function pluginDts(options) {
+  if (options.dts === false) {
+    return [];
+  }
+  const dtsModuleFederationConfig = buildDtsModuleFederationConfig(options);
+  let resolvedConfig;
+  let devWorker;
+  let normalizedDevOptions;
+  let hasGeneratedBundle = false;
+  const devPlugin = {
+    name: 'module-federation-dts-dev',
+    apply: 'serve',
+    config(config) {
+      normalizedDevOptions = normalizeDevOptions(options.dev);
+      if (!normalizedDevOptions) {
+        return;
+      }
+      if (normalizedDevOptions.disableDynamicRemoteTypeHints) {
+        return;
+      }
+      ensureRuntimePlugin(options, DYNAMIC_HINTS_PLUGIN);
+      const define = config.define ? _extends({}, config.define) : {};
+      if (!('FEDERATION_IPV4' in define)) {
+        define.FEDERATION_IPV4 = JSON.stringify(getIPv4());
+      }
+      config.define = define;
+    },
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    configureServer(server) {
+      if (!normalizedDevOptions || !resolvedConfig) {
+        return;
+      }
+      const 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!');
+      }
+      const outputDir = resolveOutputDir(resolvedConfig);
+      const normalizedDtsOptions = normalizeDevDtsOptions(options.dts, resolvedConfig.root);
+      if (typeof normalizedDtsOptions !== 'object') {
+        return;
+      }
+      const normalizedGenerateTypes = normalizeOptions(Boolean(normalizedDtsOptions), {
+        compileInChildProcess: true
+      }, 'mfOptions.dts.generateTypes')(normalizedDtsOptions.generateTypes);
+      const remote = normalizedGenerateTypes === false ? undefined : _extends({
+        implementation: normalizedDtsOptions.implementation,
+        context: resolvedConfig.root,
+        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;
+      }
+      const normalizedConsumeTypes = normalizeOptions(Boolean(normalizedDtsOptions), {
+        consumeAPITypes: true
+      }, 'mfOptions.dts.consumeTypes')(normalizedDtsOptions.consumeTypes);
+      const host = normalizedConsumeTypes === false ? undefined : _extends({
+        implementation: normalizedDtsOptions.implementation,
+        context: resolvedConfig.root,
+        moduleFederationConfig: dtsModuleFederationConfig,
+        typesFolder: normalizedConsumeTypes.typesFolder || '@mf-types',
+        abortOnError: false
+      }, normalizedConsumeTypes);
+      const extraOptions = normalizedDtsOptions.extraOptions || {};
+      if (!remote && !host && devOptions.disableLiveReload) {
+        return;
+      }
+      const startDevWorker = async () => {
+        var _server$httpServer;
+        let remoteTypeUrls;
+        if (host) {
+          remoteTypeUrls = await new Promise(resolve => {
+            consumeTypesAPI({
+              host,
+              extraOptions,
+              displayErrorInTerminal: normalizedDtsOptions.displayErrorInTerminal
+            }, resolve);
+          });
+        }
+        devWorker = new DevWorker({
+          name: options.name,
+          remote,
+          host: host ? _extends({}, host, {
+            remoteTypeUrls
+          }) : undefined,
+          extraOptions,
+          disableLiveReload: devOptions.disableLiveReload,
+          disableHotTypesReload: devOptions.disableHotTypesReload
+        });
+        const 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', () => {
+          var _devWorker2;
+          (_devWorker2 = devWorker) == null || _devWorker2.exit();
+          server.watcher.off('change', update);
+          server.watcher.off('add', update);
+          server.watcher.off('unlink', update);
+        });
+      };
+      startDevWorker().catch(error => {
+        logDtsError(error, normalizedDtsOptions);
+      });
+    }
+  };
+  const buildPlugin = {
+    name: 'module-federation-dts-build',
+    apply: 'build',
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    async generateBundle() {
+      var _consumeOptions$host;
+      if (hasGeneratedBundle) {
+        return;
+      }
+      hasGeneratedBundle = true;
+      if (!resolvedConfig) {
+        return;
+      }
+      const normalizedDtsOptions = normalizeDtsOptions(dtsModuleFederationConfig, resolvedConfig.root);
+      if (typeof normalizedDtsOptions !== 'object') {
+        return;
+      }
+      const context = resolvedConfig.root;
+      const outputDir = resolveOutputDir(resolvedConfig);
+      const consumeOptions = normalizeConsumeTypesOptions({
+        context,
+        dtsOptions: normalizedDtsOptions,
+        pluginOptions: dtsModuleFederationConfig
+      });
+      if (consumeOptions != null && (_consumeOptions$host = consumeOptions.host) != null && _consumeOptions$host.typesOnBuild) {
+        try {
+          await consumeTypesAPI(consumeOptions);
+        } catch (error) {
+          logDtsError(error, normalizedDtsOptions);
+        }
+      }
+      const generateOptions = normalizeGenerateTypesOptions({
+        context,
+        outputDir,
+        dtsOptions: normalizedDtsOptions,
+        pluginOptions: dtsModuleFederationConfig
+      });
+      if (!generateOptions) {
+        return;
+      }
+      try {
+        await generateTypesAPI({
+          dtsManagerOptions: generateOptions
+        });
+      } catch (error) {
+        logDtsError(error, normalizedDtsOptions);
+      }
+    }
+  };
+  return [devPlugin, buildPlugin];
+}
+
 /**
  * example:
  * const store = new PromiseStore<number>();
@@ -1665,7 +2038,7 @@ function federation(mfUserOptions) {
     }
   }, aliasToArrayPlugin, checkAliasConflicts({
     shared
-  }), normalizeOptimizeDepsPlugin, ...addEntry({
+  }), normalizeOptimizeDepsPlugin, ...pluginDts(options), ...addEntry({
     entryName: 'remoteEntry',
     entryPath: REMOTE_ENTRY_ID,
     fileName: filename