@module-federation/vite 1.23.2 → 1.23.4

package/lib/normalizeModuleFederationOptions-DNUlv-AL.d.ts

@@ -0,0 +1,303 @@
+import { moduleFederationPlugin } from "@module-federation/sdk";
+import { ShareStrategy } from "@module-federation/runtime/types";
+//#region src/utils/normalizeModuleFederationOptions.d.ts
+interface RemoteObjectConfig {
+  type?: string;
+  name: string;
+  internalName?: string;
+  entry: string;
+  entryGlobalName?: string;
+  shareScope?: string | string[];
+}
+interface TreeShakingConfig {
+  mode: 'server-calc' | 'runtime-infer';
+  usedExports?: string[];
+}
+interface PluginManifestOptions {
+  filePath?: string;
+  disableAssetsAnalyze?: boolean;
+  fileName?: string;
+  additionalData?: (options: {
+    stats: Record<string, unknown>;
+    manifest?: Record<string, unknown>;
+    pluginOptions: Record<string, unknown>;
+    compiler?: unknown;
+    compilation?: unknown;
+    bundler: 'vite';
+  }) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void;
+}
+type ModuleFederationOptions = {
+  exposes?: Record<string, string | {
+    import: string;
+  }> | undefined;
+  filename?: string;
+  /**
+   * Exact file name of the SSR remote entry emitted next to `filename`.
+   * Defaults to `<filename base>.ssr<ext>` so it never clobbers the browser
+   * entry when both builds share an output directory. `[hash]` is not supported.
+   */
+  ssrFilename?: string;
+  library?: any;
+  name: string;
+  remotes?: Record<string, string | RemoteObjectConfig> | undefined;
+  runtime?: any;
+  shareScope?: string | string[];
+  /**
+   * Override the public path used for remote entries
+   * Defaults to Vite's base config or "auto" if base is empty
+   */
+  publicPath?: string;
+  /**
+   * Controls whether all CSS assets from the bundle should be added to every exposed module.
+   * When false (default), the plugin will not process any CSS assets.
+   * When true, all CSS assets are bundled into every exposed module.
+   */
+  bundleAllCSS?: boolean;
+  /** Directory reserved for deploy-service generated secondary shared artifacts. */
+  treeShakingDir?: string;
+  /** Whether inferred usedExports metadata is injected into generated runtime records. */
+  injectTreeShakingUsedExports?: boolean;
+  treeShakingSharedPlugins?: string[];
+  treeShakingSharedExcludePlugins?: string[];
+  shared?: string[] | Record<string, string | {
+    name?: string;
+    version?: string;
+    shareScope?: string;
+    request?: moduleFederationPlugin.SharedConfig['request'];
+    shareKey?: moduleFederationPlugin.SharedConfig['shareKey'];
+    singleton?: boolean;
+    eager?: boolean;
+    requiredVersion?: moduleFederationPlugin.SharedConfig['requiredVersion'];
+    strictVersion?: boolean;
+    allowNodeModulesSuffixMatch?: boolean;
+    /** Suppress the missing local dependency warning for `import: false` shares. */
+    suppressMissingImportWarning?: boolean;
+    treeShaking?: TreeShakingConfig;
+    import?: moduleFederationPlugin.SharedConfig['import'];
+  }> | undefined;
+  runtimePlugins?: Array<string | [string, Record<string, unknown>]>;
+  getPublicPath?: string;
+  implementation?: string;
+  manifest?: PluginManifestOptions | boolean;
+  dev?: boolean | PluginDevOptions;
+  dts?: boolean | PluginDtsOptions;
+  shareStrategy?: ShareStrategy;
+  ignoreOrigin?: boolean;
+  virtualModuleDir?: string;
+  hostInitInjectLocation?: HostInitInjectLocationOptions;
+  /**
+   * Timeout for parsing modules in seconds.
+   * Defaults to 10 seconds.
+   */
+  moduleParseTimeout?: number;
+  /**
+   * Idle timeout for parsing modules in seconds. When set, the timeout resets
+   * on every parsed module and only fires when there has been no module activity
+   * for the configured duration. Prefer this over `moduleParseTimeout` for large
+   * codebases where the total build time may exceed the fixed timeout.
+   */
+  moduleParseIdleTimeout?: number;
+  /**
+   * Allows generate additional remoteEntry file for "var" host environment
+   */
+  varFilename?: string;
+  /**
+   * Target environment for the build to enable effective tree-shaking.
+   *
+   * @see https://module-federation.io/configure/experiments#target
+   * @default 'web' (or 'node' if build.ssr is enabled)
+   */
+  target?: 'web' | 'node';
+  /**
+   * Removes remote-consumption support from the federation runtime.
+   * Only enable this for builds that never load remotes.
+   *
+   * @default false
+   */
+  disableRemote?: boolean;
+  /**
+   * Removes shared-dependency support from the federation runtime.
+   * Only enable this when the build has no shared dependencies.
+   *
+   * @default false
+   */
+  disableShared?: boolean;
+  /**
+   * Removes snapshot support, including manifest-based remotes, preload,
+   * dynamic type hints, HMR, and devtools integration.
+   *
+   * @default false (true for Node/SSR builds)
+   */
+  disableSnapshot?: boolean;
+  /**
+   * Additional packages to mark as external in the SSR remote entry build.
+   * Shared packages and MF runtime packages are external by default. Use this to
+   * add any other Node-only packages that should not be bundled into the SSR entry.
+   * To emit a self-contained SSR entry (loadable by hosts that cannot resolve the
+   * MF runtime from Node, such as the `@module-federation/sdk` reference loader),
+   * opt the MF runtime packages back in through Vite's `ssr.noExternal`.
+   */
+  ssrExternals?: string[];
+  /**
+   * Options for the auto-injected `@module-federation/vite/ssrEntryLoader`.
+   * When omitted, the loader uses the `'temp-file'` strategy. Set
+   * `strategy: 'vm'` to opt into `vm.SourceTextModule` evaluation while keeping
+   * the computed `resolvedShared` map. Optional `maxAgeMs`, `fetchTimeoutMs`,
+   * and `fetchMaxBytes` are forwarded to the loader when set.
+   */
+  ssrEntryLoader?: SsrEntryLoaderConfig;
+  /**
+   * Experimental Module Federation capabilities.
+   *
+   * @see https://module-federation.io/configure/experiments
+   */
+  experiments?: PluginExperimentsOptions;
+};
+interface PluginExperimentsOptions {
+  /**
+   * Treat `@module-federation/runtime-core` as an external that reads
+   * `globalThis._FEDERATION_RUNTIME_CORE` at runtime. Pair with a host that
+   * sets `provideExternalRuntime: true`.
+   */
+  externalRuntime?: boolean;
+  /**
+   * Injects a local runtime plugin that publishes `runtime-core` on
+   * `globalThis._FEDERATION_RUNTIME_CORE`. Set it on exactly one container
+   * per page; that container may also `exposes`.
+   */
+  provideExternalRuntime?: boolean;
+  /** Generate the React SSR/hydration island capability for eligible exposes. */
+  ssrMode?: 'ISLAND';
+  /**
+   * The host provides every shared dependency; remotes bring none. Shared keys
+   * are resolved by a native browser import map instead of the Module
+   * Federation runtime: the host emits one entry chunk per shared key and
+   * injects `<script type="importmap">`, remotes keep shared imports as bare
+   * specifiers and emit one fixed-name entry per expose plus a standard
+   * `mf-manifest.json` (without `remoteEntry`) the host maps from.
+   *
+   * Shared modules become ordinary static ES imports, so there is no
+   * `loadShare` glue and no `eager` is needed for code that reads a shared
+   * value at module-evaluation time. There is no version negotiation and no
+   * runtime API: `requiredVersion`, `strictVersion`, `shareStrategy`,
+   * `runtimePlugins` and `manifest` are ignored.
+   *
+   * @see https://github.com/module-federation/vite/issues/1381
+   */
+  hostProvidesAllShared?: boolean;
+}
+type SsrEntryLoaderStrategy = 'temp-file' | 'vm';
+type SsrEntryLoaderConfig = {
+  /**
+   * How the auto-injected `@module-federation/vite/ssrEntryLoader` evaluates
+   * remote SSR entries.
+   *
+   * - `'temp-file'` (default when omitted): fetch the ESM graph, rewrite
+   *   specifiers, write temp files and `import()` them. Works on stock Node;
+   *   shared packages are pinned to the host's copies via `resolvedShared`
+   *   (no version negotiation).
+   * - `'vm'`: evaluate the graph with `vm.SourceTextModule` and link bare
+   *   shared imports through the host's federation share scope (`loadShare`),
+   *   restoring version negotiation. Requires `--experimental-vm-modules`; the
+   *   loader emits a single warning and falls back to `'temp-file'` when that
+   *   API is unavailable.
+   */
+  strategy?: SsrEntryLoaderStrategy;
+  /**
+   * Re-check each remote's manifest when the cached SSR entry resolution is
+   * older than this many milliseconds. When the manifest's version changes
+   * (remote redeployed at the same URL), the loader drops its caches for that
+   * remote so subsequent loads use the new build. Omit to cache until process
+   * exit or an explicit `revalidate()` call. Only manifest-resolved entries
+   * can be revalidated this way — convention-resolved entries have no version
+   * source.
+   */
+  maxAgeMs?: number;
+  /**
+   * Maximum time in milliseconds for each SSR network request. Defaults to
+   * 10 seconds. Set to `0` to disable the timeout.
+   */
+  fetchTimeoutMs?: number;
+  /**
+   * Maximum response body size in bytes for each SSR network request. Defaults
+   * to 10 MiB. Set to `0` to disable the limit.
+   */
+  fetchMaxBytes?: number;
+};
+type HostInitInjectLocationOptions = 'entry' | 'html';
+interface PluginDevOptions {
+  disableLiveReload?: boolean;
+  disableHotTypesReload?: boolean;
+  disableDynamicRemoteTypeHints?: boolean;
+  /**
+   * Controls cross-federation HMR for remote modules.
+   *
+   * - `false` / `undefined` — HMR disabled (default).
+   * - `true` — HMR enabled with auto-detected strategy. When a framework
+   *   plugin with cross-federation HMR support is detected, broadcast/relay
+   *   is suppressed and the framework's native HMR handles updates:
+   *     - React (`@vitejs/plugin-react` / `@vitejs/plugin-react-swc`) — the
+   *       plugin serves a `/@react-refresh` proxy on remotes that delegates
+   *       to the host's `RefreshRuntime`, unifying the component registry.
+   *     - Vue (`@vitejs/plugin-vue` / `@vitejs/plugin-vue-jsx`) — the plugin
+   *       injects a `__VUE_HMR_RUNTIME__` guard into the host page so the
+   *       first-loaded (host) Vue runtime is pinned and remote-loaded Vue
+   *       copies cannot overwrite it.
+   *   For any host, the plugin also injects a script that clears the
+   *   federation `moduleCache` on `vite:beforeUpdate` so subsequent
+   *   `loadRemote()` calls return the freshly patched module.
+   *   Other frameworks fall back to full page reloads.
+   * - `'full-reload'` — HMR enabled, always use full page reloads even when
+   *   a framework with native cross-federation HMR is detected.
+   */
+  remoteHmr?: boolean | 'full-reload';
+}
+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' | 'tspc' | string;
+  compileInChildProcess?: boolean;
+  generateAPITypes?: boolean;
+  extractThirdParty?: boolean | {
+    exclude?: Array<string | RegExp>;
+  };
+  extractRemoteTypes?: boolean;
+  abortOnError?: boolean;
+  deleteTsConfig?: boolean;
+  afterGenerate?: (options: moduleFederationPlugin.DtsGenerateTypesHookOptions) => Promise<void> | void;
+}
+interface DtsHostOptions {
+  typesFolder?: string;
+  abortOnError?: boolean;
+  remoteTypesFolder?: string;
+  deleteTypesFolder?: boolean;
+  maxRetries?: number;
+  consumeAPITypes?: boolean;
+  runtimePkgs?: string[];
+  remoteTypeUrls?: (() => Promise<RemoteTypeUrls>) | RemoteTypeUrls;
+  timeout?: number;
+  family?: 0 | 4 | 6;
+  typesOnBuild?: boolean;
+}
+//#endregion
+export { SsrEntryLoaderStrategy as a, SsrEntryLoaderConfig as i, PluginExperimentsOptions as n, TreeShakingConfig as o, PluginManifestOptions as r, ModuleFederationOptions as t };

package/lib/{pluginDts-DnEX3cp_.js → pluginDts-CVyHPAEq.js}

@@ -1,5 +1,5 @@
 import { l as normalizePathForImport, n as mfError, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
-import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-r5OfegUr.js";
+import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-DSTzyKSG.js";
 import fs from "fs";
 import * as path$1 from "node:path";
 import { normalizeOptions } from "@module-federation/sdk";

package/lib/{ssrEntryLoader-DEH3eV1e.js → ssrEntryLoader-DjZj-5Lw.js}

@@ -1,4 +1,5 @@
 import { a as CodeRewriter, i as createCodePositionMap, r as mfWarn, s as EXTERNAL_URL_RE } from "./logger-DOwfTlw5.js";
+import { simpleJoinRemoteEntry } from "@module-federation/sdk";
 //#region src/utils/fetchWithTimeout.ts
 const DEFAULT_SSR_FETCH_TIMEOUT_MS = 1e4;
 const DEFAULT_SSR_FETCH_MAX_BYTES = 10 * 1024 * 1024;
@@ -361,15 +362,14 @@ function getEntryFilename(entryUrl) {
 }
 function resolveEntryAssetUrl(entry, manifestUrl) {
 	const base = manifestUrl.replace(/\/[^/]+$/, "/");
-	return new URL(`${entry.path || ""}${entry.name}`, base).href;
+	return new URL(simpleJoinRemoteEntry(entry.path || "", entry.name), base).href;
 }
 function resolveSSREntryUrl(manifest, manifestUrl) {
 	const entry = parseManifestEntry(manifest.metaData?.ssrRemoteEntry);
 	if (!entry) return null;
 	const base = manifestUrl.replace(/\/[^/]+$/, "/");
-	const entryPath = entry.path + entry.name;
 	return {
-		url: new URL(entryPath, base).href,
+		url: new URL(simpleJoinRemoteEntry(entry.path, entry.name), base).href,
 		type: entry.type,
 		versionKey: computeManifestVersionKey(manifest)
 	};
@@ -834,7 +834,7 @@ async function importTempModule(filePath, versionKey) {
 let warnedVmUnavailable = false;
 let vmStrategyModulePromise;
 function getVmStrategyModule() {
-	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-COMHOCN2.js");
+	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-Dk5xXVvR.js");
 	return vmStrategyModulePromise;
 }
 /**
@@ -902,9 +902,12 @@ async function loadSSRRemoteEntry(ssrEntry, options, rootEntryUrl) {
 		const cacheDir = await getSSRCacheDir();
 		mkdirSync(cacheDir, { recursive: true });
 		const sharedPkgMap = new Map(Object.entries(resolvedShared));
-		const extension = type === "commonjs-module" || type === "commonjs" ? ".js" : ".mjs";
+		const isCommonJs = type === "commonjs-module" || type === "commonjs";
+		const extension = isCommonJs ? ".cjs" : ".mjs";
 		try {
-			return await importTempModule(await fetchEsmGraphToTempFile(url, cacheDir, sharedPkgMap, versionKey, options.fetchTimeoutMs, getSsrTransformContextKey(resolvedShared, options.shareScopeName), options.fetchMaxBytes, extension, rootEntryUrl), versionKey);
+			const tmpFile = await fetchEsmGraphToTempFile(url, cacheDir, sharedPkgMap, versionKey, options.fetchTimeoutMs, getSsrTransformContextKey(resolvedShared, options.shareScopeName), options.fetchMaxBytes, extension, rootEntryUrl);
+			if (isCommonJs) return (await _module()).createRequire(import.meta.url)(tmpFile);
+			return await importTempModule(tmpFile, versionKey);
 		} catch (error) {
 			if (isSsrEntryHttpError(error) || isSsrFetchBodyTooLargeError(error)) throw error;
 			warnStrategyFallback("temp-file", url, "the federation runtime's loader", error);
@@ -941,7 +944,10 @@ function ssrEntryLoaderPlugin(options = {}) {
 			} : resolved;
 			const ssrEntry = await getSSREntry(remoteInfo.entry, loadOptions.maxAgeMs, loadOptions.fetchTimeoutMs, loadOptions.fetchMaxBytes);
 			if (!ssrEntry) return;
-			const mod = await loadSSRRemoteEntry(ssrEntry, loadOptions, remoteInfo.entry);
+			const mod = await loadSSRRemoteEntry(ssrEntry.url === remoteInfo.entry && remoteInfo.type ? {
+				...ssrEntry,
+				type: remoteInfo.type
+			} : ssrEntry, loadOptions, remoteInfo.entry);
 			if (!mod) return;
 			return mod;
 		}

package/lib/{ssrVmStrategy-COMHOCN2.js → ssrVmStrategy-Dk5xXVvR.js}

@@ -1,5 +1,5 @@
 import { t as findSharedKey } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-DEH3eV1e.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-DjZj-5Lw.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.

package/lib/utils/ssrEntryLoader.d.ts

@@ -1,30 +1,5 @@
+import { i as SsrEntryLoaderConfig } from "../normalizeModuleFederationOptions-DNUlv-AL.js";
 //#region src/utils/ssrEntryLoader.d.ts
-/**
- * MF runtime plugin that intercepts the `loadEntry` lifecycle hook on the
- * server and loads the SSR-compatible remote entry instead of the browser one.
- *
- * This completely replaces the need for any `@module-federation/sdk` patches.
- * The `loadEntry` hook is emitted by `runtime-core` before it falls through to
- * `loadScriptNode` — if the hook returns a value, the runtime uses it directly.
- *
- * Strategy:
- *  - In Node (detected through process.versions.node), fetch the remote's mf-manifest.json
- *    to discover the ssrRemoteEntry URL and its type.
- *  - ESM entry: use a dynamic `import()` — the SSR entry has no browser
- *    globals and all shared packages are external.
- *  - Dev mode (Vite 8+ only): use `ModuleRunner` with an HTTP transport backed
- *    by the remote's `/__mf_runner__` endpoint. This fetches fully-transformed
- *    module source through Vite's plugin pipeline, avoiding serialisation which
- *    cannot faithfully represent React components or closures.
- *
- *    Dev mode on Vite < 8 is NOT supported by this integration because the
- *    cross-process `fetchModule` proxy uses Vite 8's environment APIs.
- *    `ModuleRunner` itself is available in earlier Vite versions, but an older
- *    remote needs a different transport and server endpoint.
- *
- * Exported as a plain factory function so it can be serialised into the
- * generated runtimePlugins list in virtualRemotes.ts.
- */
 interface RemoteInfo {
   name: string;
   entry: string;
@@ -63,7 +38,7 @@ declare function neutralizeBrowserPreloadHelpers(code: string): string;
  *
  * The plugin is also injected automatically for SSR contexts by the vite plugin.
  */
-interface SsrEntryLoaderOptions {
+interface SsrEntryLoaderOptions extends SsrEntryLoaderConfig {
   /**
    * Pre-resolved absolute file paths for common shared packages, keyed by
    * bare specifier. Populated at build time by the Vite plugin from the MF
@@ -72,43 +47,11 @@ interface SsrEntryLoaderOptions {
    * in remote SSR entry temp files — no runtime createRequire walk-up needed.
    */
   resolvedShared?: Record<string, string>;
-  /**
-   * How to evaluate remote SSR entries on the server.
-   *
-   * - `'temp-file'` (default): fetch the ESM graph, rewrite specifiers, write
-   *   temp files and `import()` them. Works on stock Node; shared packages are
-   *   pinned to the host's copies via `resolvedShared` (no version negotiation).
-   * - `'vm'`: evaluate the graph with `vm.SourceTextModule` and link bare
-   *   shared imports through the host's federation share scope (`loadShare`),
-   *   restoring version negotiation. Requires `--experimental-vm-modules`;
-   *   falls back to `'temp-file'` when unavailable.
-   */
-  strategy?: 'temp-file' | 'vm';
   /**
    * Share scope consulted by the `'vm'` strategy when linking bare imports.
    * Defaults to `'default'`.
    */
   shareScopeName?: string;
-  /**
-   * Re-check each remote's manifest when the cached SSR entry resolution is
-   * older than this many milliseconds. When the manifest's version changes
-   * (remote redeployed at the same URL), the loader drops its caches for that
-   * remote so subsequent loads use the new build. Omit to cache until process
-   * exit or an explicit `revalidate()` call. Only manifest-resolved entries
-   * can be revalidated this way — convention-resolved entries have no version
-   * source.
-   */
-  maxAgeMs?: number;
-  /**
-   * Maximum time in milliseconds for each SSR network request. Defaults to
-   * 10 seconds. Set to `0` to disable the timeout.
-   */
-  fetchTimeoutMs?: number;
-  /**
-   * Maximum response body size in bytes for each SSR network request. Defaults
-   * to 10 MiB. Set to `0` to disable the limit.
-   */
-  fetchMaxBytes?: number;
 }
 declare function ssrEntryLoaderPlugin(options?: SsrEntryLoaderOptions): {
   name: string;

package/lib/utils/ssrEntryLoader.js

@@ -1,2 +1,2 @@
-import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-DEH3eV1e.js";
+import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-DjZj-5Lw.js";
 export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.23.2",
+  "version": "1.23.4",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",