@module-federation/vite 1.9.3 → 1.9.5

package/lib/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('defu'), require('fs'), require('pathe'), require('magic-string'), require('@rollup/pluginutils'), require('estree-walker')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'defu', 'fs', 'pathe', 'magic-string', '@rollup/pluginutils', 'estree-walker'], factory) :
-  (global = global || self, factory(global.vite = {}, global.defu, global.fs, global.pathe, global.magicString, global.pluginutils, global.estreeWalker));
-})(this, (function (exports, defu, fs, path, MagicString, pluginutils, estreeWalker) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('defu'), require('fs'), require('pathe'), require('magic-string'), require('@rollup/pluginutils'), require('estree-walker'), require('@module-federation/sdk'), require('@module-federation/dts-plugin'), require('@module-federation/dts-plugin/core')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'defu', 'fs', 'pathe', 'magic-string', '@rollup/pluginutils', 'estree-walker', '@module-federation/sdk', '@module-federation/dts-plugin', '@module-federation/dts-plugin/core'], factory) :
+  (global = global || self, factory(global.vite = {}, global.defu, global.fs, global.pathe, global.magicString, global.pluginutils, global.estreeWalker, global.sdk, global.dtsPlugin, global.core));
+})(this, (function (exports, defu, fs, path, MagicString, pluginutils, estreeWalker, sdk, dtsPlugin, core) {
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
   function _interopNamespace(e) {
@@ -145,9 +145,11 @@
         }
       },
       generateBundle: function generateBundle(options, bundle) {
+        var _viteConfig$experimen, _viteConfig$experimen2;
         if (!injectHtml()) return;
         var file = this.getFileName(emitFileId);
-        var scriptContent = "\n          <script type=\"module\" src=\"" + (viteConfig.base + file) + "\"></script>\n        ";
+        var path = (_viteConfig$experimen = viteConfig.experimental) != null && _viteConfig$experimen.renderBuiltUrl ? (_viteConfig$experimen2 = viteConfig.experimental) == null ? void 0 : _viteConfig$experimen2.renderBuiltUrl(file) : viteConfig.base + file;
+        var scriptContent = "\n          <script type=\"module\" src=\"" + path + "\"></script>\n        ";
         for (var _fileName in bundle) {
           if (_fileName.endsWith('.html')) {
             var htmlAsset = bundle[_fileName];
@@ -583,6 +585,96 @@
     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) {
@@ -819,12 +911,16 @@
   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  ";
   }
   /**
@@ -1438,6 +1534,317 @@
     };
   }
 
+  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 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;
+      },
+      closeBundle: function closeBundle() {
+        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 (!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>();
@@ -1615,7 +2022,7 @@
       }
     }, aliasToArrayPlugin, checkAliasConflicts({
       shared: shared
-    }), normalizeOptimizeDepsPlugin].concat(addEntry({
+    }), normalizeOptimizeDepsPlugin].concat(pluginDts(options), addEntry({
       entryName: 'remoteEntry',
       entryPath: REMOTE_ENTRY_ID,
       fileName: filename

package/lib/plugins/pluginDts.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { NormalizedModuleFederationOptions } from '../utils/normalizeModuleFederationOptions';
+export default function pluginDts(options: NormalizedModuleFederationOptions): Plugin[];

package/lib/utils/__tests__/serializeRuntimeOptions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/normalizeModuleFederationOptions.d.ts

@@ -57,7 +57,7 @@ export type ModuleFederationOptions = {
         strictVersion?: boolean;
         import?: sharePlugin.SharedConfig['import'];
     }> | undefined;
-    runtimePlugins?: string[];
+    runtimePlugins?: Array<string | [string, Record<string, unknown>]>;
     getPublicPath?: string;
     implementation?: string;
     manifest?: ManifestOptions | boolean;
@@ -77,7 +77,7 @@ export interface NormalizedModuleFederationOptions {
     runtime: any;
     shareScope: string;
     shared: NormalizedShared;
-    runtimePlugins: string[];
+    runtimePlugins: Array<string | [string, Record<string, unknown>]>;
     implementation: string;
     manifest: ManifestOptions | boolean;
     dev?: boolean | PluginDevOptions;
@@ -101,22 +101,38 @@ interface PluginDevOptions {
     disableHotTypesReload?: boolean;
     disableDynamicRemoteTypeHints?: boolean;
 }
+interface RemoteTypeUrl {
+    alias?: string;
+    api: string;
+    zip: string;
+}
+interface RemoteTypeUrls {
+    [remoteName: string]: RemoteTypeUrl;
+}
 interface PluginDtsOptions {
     generateTypes?: boolean | DtsRemoteOptions;
     consumeTypes?: boolean | DtsHostOptions;
     tsConfigPath?: string;
+    extraOptions?: Record<string, unknown>;
+    implementation?: string;
+    cwd?: string;
+    displayErrorInTerminal?: boolean;
 }
 interface DtsRemoteOptions {
     tsConfigPath?: string;
     typesFolder?: string;
+    compiledTypesFolder?: string;
     deleteTypesFolder?: boolean;
     additionalFilesToCompile?: string[];
-    compilerInstance?: 'tsc' | 'vue-tsc';
+    compilerInstance?: 'tsc' | 'vue-tsc' | 'tspc' | string;
     compileInChildProcess?: boolean;
     generateAPITypes?: boolean;
-    extractThirdParty?: boolean;
+    extractThirdParty?: boolean | {
+        exclude?: Array<string | RegExp>;
+    };
     extractRemoteTypes?: boolean;
     abortOnError?: boolean;
+    deleteTsConfig?: boolean;
 }
 interface DtsHostOptions {
     typesFolder?: string;
@@ -125,6 +141,11 @@ interface DtsHostOptions {
     deleteTypesFolder?: boolean;
     maxRetries?: number;
     consumeAPITypes?: boolean;
+    runtimePkgs?: string[];
+    remoteTypeUrls?: (() => Promise<RemoteTypeUrls>) | RemoteTypeUrls;
+    timeout?: number;
+    family?: 4 | 6;
+    typesOnBuild?: boolean;
 }
 export declare function getNormalizeModuleFederationOptions(): NormalizedModuleFederationOptions;
 export declare function getNormalizeShareItem(key: string): ShareItem;

package/lib/utils/serializeRuntimeOptions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+export declare function serializeRuntimeOptions(options: Record<string, unknown>): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "source": "src/index.ts",
@@ -9,22 +9,6 @@
   "files": [
     "lib/**/*"
   ],
-  "scripts": {
-    "prepare": "husky install",
-    "fmt": "prettier --write src",
-    "fmt.check": "prettier --check src",
-    "format": "pretty-quick",
-    "dev": "microbundle watch --no-sourcemap --compress=false",
-    "build": "rimraf lib && microbundle --no-sourcemap --compress=false",
-    "dev-rv": "pnpm -filter 'examples-rust-vite*' run dev",
-    "preview-rv": "pnpm -filter 'examples-rust-vite*' run preview",
-    "dev-vv": "pnpm -filter 'examples-vite-vite*' run dev",
-    "dev-nv": "pnpm -filter 'examples-nuxt-vite-host' -filter 'examples-vite-vite-remote' run dev",
-    "preview-vv": "pnpm -filter 'examples-vite-vite*'  run preview",
-    "multi-example": "pnpm --filter \"multi-example-*\" --parallel run start",
-    "test": "vitest",
-    "e2e": "playwright test"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/module-federation/vite.git"
@@ -44,8 +28,11 @@
     "url": "https://github.com/module-federation/vite/issues"
   },
   "homepage": "https://github.com/module-federation/vite#readme",
-  "packageManager": "pnpm@9.1.3",
+  "peerDependencies": {
+    "vite": "<=6"
+  },
   "dependencies": {
+    "@module-federation/dts-plugin": "^0.21.6",
     "@module-federation/runtime": "^0.21.6",
     "@module-federation/sdk": "^0.21.6",
     "@rollup/pluginutils": "^5.1.0",
@@ -67,5 +54,20 @@
     "vite": "^5.4.3",
     "vitest": "^2.1.1",
     "wait-on": "^8.0.1"
+  },
+  "scripts": {
+    "fmt": "prettier --write src",
+    "fmt.check": "prettier --check src",
+    "format": "pretty-quick",
+    "dev": "microbundle watch --no-sourcemap --compress=false",
+    "build": "rimraf lib && microbundle --no-sourcemap --compress=false",
+    "dev-rv": "pnpm -filter 'examples-rust-vite*' run dev",
+    "preview-rv": "pnpm -filter 'examples-rust-vite*' run preview",
+    "dev-vv": "pnpm -filter 'examples-vite-vite*' run dev",
+    "dev-nv": "pnpm -filter 'examples-nuxt-vite-host' -filter 'examples-vite-vite-remote' run dev",
+    "preview-vv": "pnpm -filter 'examples-vite-vite*'  run preview",
+    "multi-example": "pnpm --filter \"multi-example-*\" --parallel run start",
+    "test": "vitest",
+    "e2e": "playwright test"
   }
-}
+}