@module-federation/vite 1.23.0 → 1.23.2

package/README.md

@@ -402,6 +402,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-DEMpRfBz.js → dtsConstants-r5OfegUr.js}

@@ -1,40 +1,10 @@
 import { d as getNodeModulesSuffix, r as getSharedRuntimeKey } from "./sharedKeyMatcher-Od_nYxJA.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";
 import { fileURLToPath, pathToFileURL } from "url";
 import { createHash } from "node:crypto";
-//#region src/utils/logger.ts
-const MODULE_FEDERATION_LOG_PREFIX = "[Module Federation]";
-function formatModuleFederationMessage(message) {
-	return `${MODULE_FEDERATION_LOG_PREFIX} ${message}`;
-}
-function createModuleFederationError(message) {
-	return new Error(formatModuleFederationMessage(message));
-}
-function toConsoleArgs(message, rest = []) {
-	if (typeof message === "string") return [formatModuleFederationMessage(message), ...rest];
-	if (message === void 0) return [MODULE_FEDERATION_LOG_PREFIX, ...rest];
-	return [
-		MODULE_FEDERATION_LOG_PREFIX,
-		message,
-		...rest
-	];
-}
-const moduleFederationConsole = {
-	log(message, ...rest) {
-		console.log(...toConsoleArgs(message, rest));
-	},
-	warn(message, ...rest) {
-		console.warn(...toConsoleArgs(message, rest));
-	},
-	error(message, ...rest) {
-		console.error(...toConsoleArgs(message, rest));
-	}
-};
-const mfWarn = moduleFederationConsole.warn;
-const mfError = moduleFederationConsole.error;
-//#endregion
 //#region src/utils/reactShares.ts
 /** Property under which React 19 exposes its internals object. */
 const REACT_CLIENT_INTERNALS_KEY = "__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE";
@@ -685,4 +655,4 @@ function hasPackageDependency(dependencyName, cwd = packageDetectionCwd || proce
 //#region src/utils/dtsConstants.ts
 const DEFAULT_PUBLIC_TYPES_FOLDER = "@mf-types";
 //#endregion
-export { isReactCoreShare as C, mfWarn as E, REACT_DOM_CLIENT_SHARE as S, mfError as T, resolveModulePath as _, getIsRolldown as a, supportsCodeSplittingGroupDebugName as b, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, isPackageExportAvailable as f, resolveImportPath as g, packageNameEncode as h, getInstalledPackageJson as i, getSharedCacheDescriptor as l, packageNameDecode as m, getDependencyNames as n, getPackageDetectionCwd as o, isPackageInstalled as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, setPackageDetectionCwd as v, createModuleFederationError as w, REACT_CLIENT_INTERNALS_KEY as x, sharedCacheHelperCode as y };
+export { isReactCoreShare as C, REACT_DOM_CLIENT_SHARE as S, resolveModulePath as _, getIsRolldown as a, supportsCodeSplittingGroupDebugName as b, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, isPackageExportAvailable as f, resolveImportPath as g, packageNameEncode as h, getInstalledPackageJson as i, getSharedCacheDescriptor as l, packageNameDecode as m, getDependencyNames as n, getPackageDetectionCwd as o, isPackageInstalled as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, setPackageDetectionCwd as v, REACT_CLIENT_INTERNALS_KEY as x, sharedCacheHelperCode as y };

package/lib/index.d.ts

@@ -167,6 +167,23 @@ interface PluginExperimentsOptions {
   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 = {