@module-federation/vite 1.23.1 → 1.23.3

package/README.md

@@ -278,6 +278,21 @@ federation({
 
 The `"vm"` strategy requires Node.js to run with `--experimental-vm-modules`. When unavailable, the loader warns once and falls back to `"temp-file"`. Vite 8 development uses `ModuleRunner`; this option primarily affects build and preview SSR entry loading.
 
+`ssrEntryLoader` also accepts network and cache options:
+
+```ts
+federation({
+  // ...
+  ssrEntryLoader: {
+    maxAgeMs: 60_000, // re-check each remote's manifest after 60s; omit to cache until process exit
+    fetchTimeoutMs: 5_000, // per-request timeout, default 10s, 0 disables it
+    fetchMaxBytes: 5 * 1024 * 1024, // per-response size limit, default 10 MiB, 0 disables it
+  },
+});
+```
+
+With `maxAgeMs`, a remote redeployed at the same URL is picked up once its manifest version changes. Only manifest-resolved entries can be revalidated.
+
 The SSR remote entry is emitted as `<filename base>.ssr.js` next to the browser entry, or under the exact name given by `ssrFilename`, and is advertised as `metaData.ssrRemoteEntry` in `mf-manifest.json`. It keeps `@module-federation/runtime`, `@module-federation/runtime-core` and `@module-federation/sdk` external by default so Node resolves them from the host. Hosts that cannot resolve those packages, such as a plain `@module-federation/enhanced` host using the SDK's reference Node loader, need a self-contained entry: opt the packages back in with Vite's `ssr.noExternal` (for example `ssr: { noExternal: true }`) on the remote.
 
 ## Runtime capability optimization
@@ -402,6 +417,42 @@ federation({
 `provideExternalRuntime` injects a local runtime plugin that publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`. `externalRuntime` rewrites imports of `@module-federation/runtime-core` to read that global. A container that also `exposes` (e.g. a host consumed by its own remotes) may provide the runtime too, as long as exactly one container on the page does and it is loaded before any `externalRuntime` remote evaluates (a second provider is ignored with a `Detect multiple module federation runtime!` warning; a remote evaluated before the provider throws `_FEDERATION_RUNTIME_CORE is missing`).
 The `externalRuntime` rewrite applies to the browser remote graph; SSR remote entries continue to resolve `@module-federation/runtime-core` from Node so they do not depend on the browser global.
 
+## Host provides all shared (`experiments.hostProvidesAllShared`)
+
+For topologies where **one host provides every shared dependency** and remotes only consume them, shared dependencies can be resolved by a native browser [import map](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap) instead of the Module Federation runtime. No `loadShare` / prebuild glue is generated and `eager` is not needed: shared modules are ordinary static ES imports, so code that reads a shared value at module-evaluation time (`class X extends SharedBase`, decorator metadata) just works.
+
+**Remote** (a container with `exposes`):
+
+```ts
+federation({
+  name: "remote",
+  exposes: { "./Button": "./src/Button.tsx" },
+  shared: { react: {}, "react-dom": {}, "react/jsx-runtime": {} },
+  experiments: { hostProvidesAllShared: true },
+});
+```
+
+The remote build emits one fixed-name entry per expose (`./Button` → `Button.js`), keeps every shared key as a bare external import and writes a standard `mf-manifest.json` next to the entries, with no `remoteEntry` since there is no runtime container. `metaData.publicPath` comes from Vite's `base` (or `publicPath`); `auto` is inferred from the manifest URL by the host.
+
+**Host** (no `exposes`):
+
+```ts
+federation({
+  name: "host",
+  remotes: { remote: "https://cdn.example.com/remote/mf-manifest.json" },
+  shared: { react: {}, "react-dom": {}, "react/jsx-runtime": {} },
+  experiments: { hostProvidesAllShared: true },
+});
+```
+
+The host emits one re-export chunk per shared key, which the bundler dedupes with the host's own imports, and injects a `<script type="importmap">` into `index.html` mapping each shared key to that chunk and each remote expose (`remote/Button`) to the entry listed in the manifest. A manifest may also be a path relative to the host root (for example `../remote/dist/mf-manifest.json`). A manifest that has a `remoteEntry` belongs to a Module Federation runtime remote and is rejected. The dev server serves the same map, pointing shared keys at virtual modules that resolve to the host's pre-bundled dependencies, so host and remotes share one instance in dev too.
+
+A remote that imports an unshared subpath of a shared package (`rxjs/operators` with only `rxjs` shared) bundles a private copy of that package's internals; the remote build warns and names the key to add to `shared`.
+
+`dts` keeps working through the manifest's `metaData.types`: a remote emits its types archive next to `mf-manifest.json` and a host referencing the manifest by URL consumes it from there.
+
+Not supported in this mode, since the Module Federation runtime is not loaded: version negotiation and fallbacks, share aliasing (`request` / `shareKey`), `import: false`, runtime plugins, SSR, tree-shaking artifacts, `loadRemote` / runtime-registered remotes, and interop with webpack / rspack containers. Options that only the runtime or `remoteEntry.js` pipeline reads (for example `filename`, `shareStrategy`, `runtimePlugins`, `eager`, `requiredVersion`) are ignored; one warning names them. `singleton` needs no setting: every shared key has exactly one instance. The import map is fixed when the host is built, so a remote must keep its expose entry names stable across deploys. The inline import map changes with every host build; a strict CSP needs a nonce or hash for it.
+
 ## ⚠️ `codeSplitting` is managed by the plugin
 
 Do not set `build.rollupOptions.output.codeSplitting` or

package/lib/{dtsConstants-Bs4FukGL.js → dtsConstants-DSTzyKSG.js}

@@ -1,5 +1,5 @@
 import { d as getNodeModulesSuffix, r as getSharedRuntimeKey } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { r as mfWarn, t as createModuleFederationError } from "./logger--uKHOVjR.js";
+import { r as mfWarn, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
 import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
 import { createRequire } from "module";
 import * as path$1 from "node:path";
@@ -36,6 +36,7 @@ function getDependencyCacheKey(cwd, dependencyName) {
 }
 const installedPackageJsonCache = /* @__PURE__ */ new Map();
 const dependentsLookupCache = /* @__PURE__ */ new Map();
+const reachableDependencyNames = /* @__PURE__ */ new Map();
 function setPackageDetectionCwd(cwd) {
 	packageDetectionCwd = cwd;
 }
@@ -471,10 +472,17 @@ function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
 */
 function findPackageInDependents(packageName, cwd) {
 	const cacheKey = `${cwd}\0${packageName}`;
-	if (!dependentsLookupCache.has(cacheKey)) dependentsLookupCache.set(cacheKey, walkDependents(packageName, cwd));
+	if (!dependentsLookupCache.has(cacheKey)) {
+		if (!reachableDependencyNames.has(cwd)) {
+			const names = /* @__PURE__ */ new Set();
+			walkDependents("", cwd, names);
+			reachableDependencyNames.set(cwd, names);
+		}
+		dependentsLookupCache.set(cacheKey, reachableDependencyNames.get(cwd).has(packageName) ? walkDependents(packageName, cwd) : void 0);
+	}
 	return dependentsLookupCache.get(cacheKey);
 }
-function walkDependents(packageName, cwd) {
+function walkDependents(packageName, cwd, reachedNames) {
 	const root = tryReadPackageJson(path$1.join(cwd, "package.json"));
 	if (!root) return void 0;
 	const visited = /* @__PURE__ */ new Set();
@@ -492,6 +500,7 @@ function walkDependents(packageName, cwd) {
 				const dependent = findPackageFrom(name, fromDir);
 				if (!dependent || visited.has(dependent.dir)) continue;
 				visited.add(dependent.dir);
+				reachedNames?.add(name);
 				const dependencies = getDependencyNames(dependent.packageJson);
 				if (dependencies.includes(packageName)) {
 					const copy = findPackageFrom(packageName, dependent.dir);

package/lib/index.d.ts

@@ -1,263 +1,4 @@
-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.
-   */
-  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';
-}
-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.
-   * - `'vm'`: evaluate the graph with `vm.SourceTextModule`. Requires
-   *   `--experimental-vm-modules`; the loader emits a single warning and
-   *   falls back to `'temp-file'` when that API is unavailable.
-   */
-  strategy?: SsrEntryLoaderStrategy;
-};
-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
+import { a as SsrEntryLoaderStrategy, i as SsrEntryLoaderConfig, n as PluginExperimentsOptions, o as TreeShakingConfig, r as PluginManifestOptions, t as ModuleFederationOptions } from "./normalizeModuleFederationOptions-DNUlv-AL.js";
 //#region src/index.d.ts
 declare function federation(mfUserOptions: ModuleFederationOptions): any[];
 declare function createModuleFederationConfig<T extends ModuleFederationOptions>(options: T): T;