@module-federation/bridge-react 2.6.0 → 2.8.0

package/dist/{prefetch-CG2l-06N.js → prefetch-D66kL1aM.js}

@@ -1,5 +1,5 @@
 "use strict";
-const lazyUtils = require("./utils-CFTy4LVE.js");
+const lazyUtils = require("./utils-5dGErM3C.js");
 const logger = require("./logger-Dxblx6P-.js");
 async function safeWrapper(callback, disableWarn) {
   try {
@@ -216,16 +216,12 @@ function importNodeModule(name) {
   sdkImportCache.set(name, promise);
   return promise;
 }
-const loadNodeFetch = async () => {
-  const fetchModule = await importNodeModule("node-fetch");
-  return fetchModule.default || fetchModule;
-};
 const lazyLoaderHookFetch = async (input, init, loaderHook) => {
   const hook = (url, init2) => {
     return loaderHook.lifecycle.fetch.emit(url, init2);
   };
   const res = await hook(input, init || {});
-  if (!res || !(res instanceof Response)) return (typeof fetch === "undefined" ? await loadNodeFetch() : fetch)(input, init || {});
+  if (!res || !(res instanceof Response)) return fetch(input, init || {});
   return res;
 };
 const createScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "web" ? (url, cb, attrs, loaderHook) => {
@@ -243,7 +239,7 @@ const createScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "we
   }
   const getFetch = async () => {
     if (loaderHook == null ? void 0 : loaderHook.fetch) return (input, init) => lazyLoaderHookFetch(input, init, loaderHook);
-    return typeof fetch === "undefined" ? loadNodeFetch() : fetch;
+    return fetch;
   };
   const handleScriptFetch = async (f, urlObj2) => {
     var _a;
@@ -307,20 +303,82 @@ const loadScriptNode = typeof ENV_TARGET === "undefined" || ENV_TARGET !== "web"
   throw new Error("loadScriptNode is disabled in non-Node.js environment");
 };
 const esmModuleCache = /* @__PURE__ */ new Map();
+const isFetchableRemoteModuleUrl = (url) => url.startsWith("http:") || url.startsWith("https:");
+const isBareModuleSpecifier = (specifier) => !specifier.startsWith("./") && !specifier.startsWith("../") && !specifier.startsWith("/") && !specifier.includes(":");
+function encodeRemoteModulePath(url) {
+  const remoteUrl = new URL(url);
+  const encodedProtocol = encodeURIComponent(remoteUrl.protocol.slice(0, -1));
+  const encodedHost = encodeURIComponent(remoteUrl.host);
+  const encodedPathname = remoteUrl.pathname.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  const encodedSearchHash = encodeURIComponent(`${remoteUrl.search}${remoteUrl.hash}`);
+  return `/${encodedProtocol}/${encodedHost}${encodedPathname}${encodedSearchHash ? `/${encodedSearchHash}` : ""}`;
+}
+function createImportMetaUrl(url, baseFileUrl) {
+  const baseUrl = baseFileUrl.endsWith("/") ? baseFileUrl : `${baseFileUrl}/`;
+  return new URL(`__module_federation_remote__${encodeRemoteModulePath(url)}`, baseUrl).href;
+}
+async function isNodeBuiltinSpecifier(specifier) {
+  if (specifier.startsWith("node:")) return true;
+  if (!isBareModuleSpecifier(specifier)) return false;
+  return (await importNodeModule("node:module")).builtinModules.includes(specifier);
+}
+function getSyntheticModuleExports(moduleExports) {
+  const namespaceObject = moduleExports && (typeof moduleExports === "object" || typeof moduleExports === "function") ? moduleExports : { default: moduleExports };
+  const effectiveExports = { ...namespaceObject };
+  if (!Object.prototype.hasOwnProperty.call(effectiveExports, "default")) effectiveExports.default = namespaceObject;
+  return effectiveExports;
+}
+async function createSyntheticModuleFromExports(identifier, moduleExports, vm) {
+  if (typeof vm.SyntheticModule !== "function") throw new Error("vm.SyntheticModule is required to load Node.js built-in modules in ESM remote entries.");
+  const effectiveExports = getSyntheticModuleExports(moduleExports);
+  const exportNames = Object.keys(effectiveExports);
+  const syntheticModule = new vm.SyntheticModule(exportNames, function setSyntheticModuleExports() {
+    for (const name of exportNames) this.setExport(name, effectiveExports[name]);
+  }, { identifier });
+  esmModuleCache.set(identifier, syntheticModule);
+  await syntheticModule.link(async () => {
+    throw new Error(`Node.js built-in module "${identifier}" should not request child modules.`);
+  });
+  await syntheticModule.evaluate();
+  return syntheticModule;
+}
+async function loadNodeBuiltinModule(specifier, vm) {
+  const cacheKey = `node-builtin:${specifier}`;
+  if (esmModuleCache.has(cacheKey)) return esmModuleCache.get(cacheKey);
+  return createSyntheticModuleFromExports(cacheKey, await importNodeModule(specifier), vm);
+}
+async function loadResolvedModule(specifier, parentUrl, options) {
+  if (await isNodeBuiltinSpecifier(specifier)) return loadNodeBuiltinModule(specifier, options.vm);
+  if (isBareModuleSpecifier(specifier)) throw new Error(`Unsupported ESM module specifier "${specifier}". Only relative or absolute http(s) remote modules and Node.js built-in modules are supported.`);
+  const resolvedUrl = new URL(specifier, parentUrl).href;
+  if (!isFetchableRemoteModuleUrl(resolvedUrl)) throw new Error(`Unsupported ESM module specifier "${specifier}" resolved to "${resolvedUrl}". Only http(s) remote modules and Node.js built-in modules are supported.`);
+  return loadModule(resolvedUrl, options);
+}
+async function evaluateDynamicModule(module2) {
+  if (module2.status === "linked") await module2.evaluate();
+  if (module2.status === "errored") throw module2.error;
+  return module2;
+}
 async function loadModule(url, options) {
   if (esmModuleCache.has(url)) return esmModuleCache.get(url);
   const { fetch: fetch2, vm } = options;
+  if (!isFetchableRemoteModuleUrl(url)) throw new Error(`Unsupported ESM module URL "${url}". Only http(s) remote modules and Node.js built-in modules are supported.`);
   const code = await (await fetch2(url)).text();
-  const module2 = new vm.SourceTextModule(code, { importModuleDynamically: async (specifier, script) => {
-    const resolvedUrl = new URL(specifier, url).href;
-    return loadModule(resolvedUrl, options);
-  } });
-  esmModuleCache.set(url, module2);
-  await module2.link(async (specifier) => {
-    const resolvedUrl = new URL(specifier, url).href;
-    return await loadModule(resolvedUrl, options);
+  const cwdFileUrl = (await importNodeModule("node:url")).pathToFileURL(process.cwd()).href;
+  const sourceTextModule = new vm.SourceTextModule(code, {
+    identifier: url,
+    initializeImportMeta: (meta) => {
+      meta.url = createImportMetaUrl(url, cwdFileUrl);
+    },
+    importModuleDynamically: async (specifier) => {
+      return evaluateDynamicModule(await loadResolvedModule(specifier, url, options));
+    }
   });
-  return module2;
+  esmModuleCache.set(url, sourceTextModule);
+  await sourceTextModule.link(async (specifier) => {
+    return loadResolvedModule(specifier, url, options);
+  });
+  return sourceTextModule;
 }
 const dataFetchFunction = async function(options) {
   var _a, _b;
@@ -412,6 +470,9 @@ function logAndReport(code, descMap, args, logger2, originalErrorMsg, context) {
   return logger2(getShortErrorMsg(code, descMap, args, originalErrorMsg));
 }
 const LOG_CATEGORY = "[ Federation Runtime ]";
+function assert(condition, msgOrCode, descMap, args, context) {
+  if (!condition) error(msgOrCode);
+}
 function error(msgOrCode, descMap, args, originalErrorMsg, context) {
   if (descMap !== void 0) return logAndReport(msgOrCode, descMap, args ?? {}, (msg2) => {
     throw new Error(`${LOG_CATEGORY}: ${msg2}`);
@@ -423,6 +484,14 @@ function error(msgOrCode, descMap, args, originalErrorMsg, context) {
   }
   throw new Error(`${LOG_CATEGORY}: ${msg}`);
 }
+const processModuleAlias = (name, subPath) => {
+  let moduleName;
+  if (name.endsWith("/")) moduleName = name.slice(0, -1);
+  else moduleName = name;
+  if (subPath.startsWith(".")) subPath = subPath.slice(1);
+  moduleName = moduleName + subPath;
+  return moduleName;
+};
 const CurrentGlobal = typeof globalThis === "object" ? globalThis : window;
 const nativeGlobal = (() => {
   try {
@@ -475,6 +544,10 @@ const getRemoteEntryExports = (name, globalName) => {
 };
 const DEFAULT_SCOPE = "default";
 const DEFAULT_REMOTE_TYPE = "global";
+function composeRemoteRequestId(remoteName, expose) {
+  if (!expose || expose === ".") return remoteName;
+  return `${remoteName}/${expose.replace(/^\.\//, "")}`;
+}
 function matchRemoteWithNameAndExpose(remotes, id) {
   for (const remote of remotes) {
     const isNameMatched = id.startsWith(remote.name);
@@ -752,6 +825,42 @@ function getRemoteInfo(remote) {
     shareScope: remote.shareScope || DEFAULT_SCOPE
   };
 }
+function remoteToEntry(r) {
+  return {
+    name: r.name,
+    alias: r.alias,
+    entry: "entry" in r ? r.entry : void 0,
+    version: "version" in r ? r.version : void 0,
+    type: r.type,
+    entryGlobalName: r.entryGlobalName,
+    shareScope: r.shareScope
+  };
+}
+function optionsToMFContext(options) {
+  var _a, _b, _c, _d, _e, _f;
+  const shared = {};
+  for (const [pkgName, versions] of Object.entries(options.shared)) {
+    const first = versions[0];
+    if (first) shared[pkgName] = {
+      version: first.version,
+      singleton: (_a = first.shareConfig) == null ? void 0 : _a.singleton,
+      requiredVersion: ((_b = first.shareConfig) == null ? void 0 : _b.requiredVersion) === false ? false : (_c = first.shareConfig) == null ? void 0 : _c.requiredVersion,
+      eager: first.eager,
+      strictVersion: (_d = first.shareConfig) == null ? void 0 : _d.strictVersion
+    };
+  }
+  return {
+    project: {
+      name: options.name,
+      mfRole: ((_e = options.remotes) == null ? void 0 : _e.length) > 0 ? "host" : "unknown"
+    },
+    mfConfig: {
+      name: options.name,
+      remotes: ((_f = options.remotes) == null ? void 0 : _f.map(remoteToEntry)) ?? [],
+      shared
+    }
+  };
+}
 function isTimeoutError(error2) {
   if (!(error2 instanceof Error)) return false;
   return error2.message.includes("timed out") || error2.name.includes("Timeout");
@@ -929,8 +1038,270 @@ var helpers_default = {
     getRemoteInfo
   }
 };
+function getAvailableExposeNames(remoteSnapshot) {
+  if (!remoteSnapshot || !("modules" in remoteSnapshot) || !Array.isArray(remoteSnapshot.modules)) return;
+  const exposes = remoteSnapshot.modules.map((module2) => module2.moduleName).filter(Boolean);
+  return exposes.length ? exposes.join(",") : void 0;
+}
+function createRemoteEntryInitOptions(remoteInfo, hostShareScopeMap, rawInitScope) {
+  const localShareScopeMap = hostShareScopeMap;
+  const shareScopeKeys = Array.isArray(remoteInfo.shareScope) ? remoteInfo.shareScope : [remoteInfo.shareScope];
+  if (!shareScopeKeys.length) shareScopeKeys.push("default");
+  shareScopeKeys.forEach((shareScopeKey) => {
+    if (!localShareScopeMap[shareScopeKey]) localShareScopeMap[shareScopeKey] = {};
+  });
+  const remoteEntryInitOptions = {
+    version: remoteInfo.version || "",
+    shareScopeKeys: Array.isArray(remoteInfo.shareScope) ? shareScopeKeys : remoteInfo.shareScope || "default"
+  };
+  Object.defineProperty(remoteEntryInitOptions, "shareScopeMap", {
+    value: localShareScopeMap,
+    enumerable: false
+  });
+  return {
+    remoteEntryInitOptions,
+    shareScope: localShareScopeMap[shareScopeKeys[0]],
+    initScope: rawInitScope ?? []
+  };
+}
+var Module$1 = class {
+  constructor({ remoteInfo, host }) {
+    this.inited = false;
+    this.initing = false;
+    this.lib = void 0;
+    this.remoteInfo = remoteInfo;
+    this.host = host;
+  }
+  async getEntry(expose) {
+    if (this.remoteEntryExports) return this.remoteEntryExports;
+    const remoteEntryExports = await getRemoteEntry({
+      origin: this.host,
+      remoteInfo: this.remoteInfo,
+      remoteEntryExports: this.remoteEntryExports,
+      resourceContext: {
+        initiator: "loadRemote",
+        id: composeRemoteRequestId(this.remoteInfo.name, expose),
+        resourceType: "remoteEntry"
+      }
+    });
+    assert(remoteEntryExports, `remoteEntryExports is undefined 
+ ${lazyUtils.safeToString(this.remoteInfo)}`);
+    this.remoteEntryExports = remoteEntryExports;
+    return this.remoteEntryExports;
+  }
+  async init(id, remoteSnapshot, rawInitScope, expose) {
+    const remoteEntryExports = await this.getEntry(expose);
+    if (this.inited) {
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        cached: true,
+        origin: this.host
+      });
+      return remoteEntryExports;
+    }
+    if (this.initPromise) {
+      try {
+        await this.initPromise;
+        await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+          id,
+          remoteInfo: this.remoteInfo,
+          remoteSnapshot,
+          remoteEntryExports,
+          cached: true,
+          origin: this.host
+        });
+      } catch (initError) {
+        await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+          id,
+          remoteInfo: this.remoteInfo,
+          remoteSnapshot,
+          remoteEntryExports,
+          error: initError,
+          cached: true,
+          origin: this.host
+        });
+        throw initError;
+      }
+      return remoteEntryExports;
+    }
+    this.initing = true;
+    this.initPromise = (async () => {
+      await this.host.loaderHook.lifecycle.beforeInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        origin: this.host
+      });
+      const { remoteEntryInitOptions, shareScope, initScope } = createRemoteEntryInitOptions(this.remoteInfo, this.host.shareScopeMap, rawInitScope);
+      const initContainerOptions = await this.host.hooks.lifecycle.beforeInitContainer.emit({
+        shareScope,
+        remoteEntryInitOptions,
+        initScope,
+        remoteInfo: this.remoteInfo,
+        origin: this.host
+      });
+      if (typeof (remoteEntryExports == null ? void 0 : remoteEntryExports.init) === "undefined") error(RUNTIME_002, runtimeDescMap, {
+        hostName: this.host.name,
+        remoteName: this.remoteInfo.name,
+        remoteEntryUrl: this.remoteInfo.entry,
+        remoteEntryKey: this.remoteInfo.entryGlobalName
+      }, void 0, optionsToMFContext(this.host.options));
+      try {
+        await remoteEntryExports.init(initContainerOptions.shareScope, initContainerOptions.initScope, initContainerOptions.remoteEntryInitOptions);
+      } catch (initError) {
+        error(RUNTIME_015, runtimeDescMap, {
+          hostName: this.host.name,
+          remoteName: this.remoteInfo.name,
+          remoteEntryUrl: this.remoteInfo.entry,
+          remoteEntryKey: this.remoteInfo.entryGlobalName,
+          shareScope: this.remoteInfo.shareScope
+        }, `${initError}`, optionsToMFContext(this.host.options));
+      }
+      await this.host.hooks.lifecycle.initContainer.emit({
+        ...initContainerOptions,
+        id,
+        remoteSnapshot,
+        remoteEntryExports
+      });
+      this.inited = true;
+    })();
+    try {
+      await this.initPromise;
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        origin: this.host
+      });
+    } catch (initError) {
+      await this.host.loaderHook.lifecycle.afterInitRemote.emit({
+        id,
+        remoteInfo: this.remoteInfo,
+        remoteSnapshot,
+        remoteEntryExports,
+        error: initError,
+        origin: this.host
+      });
+      throw initError;
+    } finally {
+      this.initing = false;
+      this.initPromise = void 0;
+    }
+    return remoteEntryExports;
+  }
+  async get(id, expose, options, remoteSnapshot) {
+    const { loadFactory = true } = options || { loadFactory: true };
+    const remoteEntryExports = await this.init(id, remoteSnapshot, void 0, expose);
+    this.lib = remoteEntryExports;
+    await this.host.loaderHook.lifecycle.beforeGetExpose.emit({
+      id,
+      expose,
+      moduleInfo: this.remoteInfo,
+      remoteEntryExports,
+      origin: this.host
+    });
+    let moduleFactory;
+    try {
+      const hookModuleFactory = await this.host.loaderHook.lifecycle.getModuleFactory.emit({
+        remoteEntryExports,
+        expose,
+        moduleInfo: this.remoteInfo
+      });
+      moduleFactory = typeof hookModuleFactory === "function" ? hookModuleFactory : void 0;
+      if (!moduleFactory) moduleFactory = await remoteEntryExports.get(expose);
+      if (!moduleFactory) error(RUNTIME_014, runtimeDescMap, {
+        hostName: this.host.name,
+        remoteName: this.remoteInfo.name,
+        remoteEntryUrl: this.remoteInfo.entry,
+        expose,
+        requestId: id,
+        availableExposes: getAvailableExposeNames(remoteSnapshot)
+      }, void 0, optionsToMFContext(this.host.options));
+      await this.host.loaderHook.lifecycle.afterGetExpose.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        remoteEntryExports,
+        moduleFactory,
+        origin: this.host
+      });
+    } catch (getExposeError) {
+      await this.host.loaderHook.lifecycle.afterGetExpose.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        remoteEntryExports,
+        error: getExposeError,
+        origin: this.host
+      });
+      throw getExposeError;
+    }
+    const symbolName = processModuleAlias(this.remoteInfo.name, expose);
+    const wrapModuleFactory = this.wraperFactory(moduleFactory, symbolName);
+    if (!loadFactory) return wrapModuleFactory;
+    await this.host.loaderHook.lifecycle.beforeExecuteFactory.emit({
+      id,
+      expose,
+      moduleInfo: this.remoteInfo,
+      loadFactory,
+      origin: this.host
+    });
+    try {
+      const exposeContent = await wrapModuleFactory();
+      await this.host.loaderHook.lifecycle.afterExecuteFactory.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        loadFactory,
+        exposeModule: exposeContent,
+        origin: this.host
+      });
+      return exposeContent;
+    } catch (executeFactoryError) {
+      await this.host.loaderHook.lifecycle.afterExecuteFactory.emit({
+        id,
+        expose,
+        moduleInfo: this.remoteInfo,
+        loadFactory,
+        error: executeFactoryError,
+        origin: this.host
+      });
+      throw executeFactoryError;
+    }
+  }
+  wraperFactory(moduleFactory, id) {
+    function defineModuleId(res, id2) {
+      if (res && typeof res === "object" && Object.isExtensible(res) && !Object.getOwnPropertyDescriptor(res, Symbol.for("mf_module_id"))) Object.defineProperty(res, Symbol.for("mf_module_id"), {
+        value: id2,
+        enumerable: false
+      });
+    }
+    return () => {
+      const res = moduleFactory();
+      if (res instanceof Promise) return res.then((asyncRes) => {
+        defineModuleId(asyncRes, id);
+        return asyncRes;
+      });
+      defineModuleId(res, id);
+      return res;
+    };
+  }
+};
+const REMOTE_DISABLED_MESSAGE = "Remote loading is disabled by experiments.optimization.disableRemote.";
+var UnavailableRemoteModule = class {
+  constructor() {
+    throw new Error(REMOTE_DISABLED_MESSAGE);
+  }
+};
 typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === "boolean" ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true;
+typeof FEDERATION_OPTIMIZE_NO_REMOTE === "boolean" ? !FEDERATION_OPTIMIZE_NO_REMOTE : true;
+typeof FEDERATION_OPTIMIZE_NO_SHARED === "boolean" ? !FEDERATION_OPTIMIZE_NO_SHARED : true;
 const helpers = helpers_default;
+typeof FEDERATION_OPTIMIZE_NO_REMOTE === "boolean" && FEDERATION_OPTIMIZE_NO_REMOTE ? UnavailableRemoteModule : Module$1;
 const utils = helpers.utils;
 const runtimeHelpers = {
   utils

package/dist/provider/context.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { ProviderParams } from '../types';
+export declare const RouterContext: React.Context<ProviderParams | null>;

package/dist/provider/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { ModuleFederationRuntimePlugin, ModuleFederation } from '@module-federation/runtime';
+export type FederationRuntimeType = {
+    instance: ModuleFederation | null;
+};
+export declare const federationRuntime: FederationRuntimeType;
+declare function BridgeReactPlugin(): ModuleFederationRuntimePlugin;
+export default BridgeReactPlugin;

package/dist/provider/versions/bridge-base.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderFnParams, DestroyParams, RenderParams } from '../../types';
+export declare function createBaseBridgeComponent<T>({ createRoot, defaultRootOptions, ...bridgeInfo }: ProviderFnParams<T>): () => {
+    render(info: RenderParams): Promise<void>;
+    destroy(info: DestroyParams): void;
+};

package/dist/provider/versions/legacy.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Entry point for React 16/17 (legacy) specific bridge components
+ * This file provides support for React 16 and 17 versions, using the traditional ReactDOM.render API
+ */
+import type { ProviderFnParams } from '../../types';
+export interface CreateRootOptions {
+    identifierPrefix?: string;
+    onRecoverableError?: (error: unknown, errorInfo: unknown) => void;
+}
+export interface Root {
+    render(children: React.ReactNode): void;
+    unmount(): void;
+}
+/**
+ * Default createRoot function that automatically detects React version and uses the appropriate API(only support React 16/17, 18)
+ *
+ * Note: Users can also directly import version-specific bridge components:
+ * - import { createBridgeComponent } from '@module-federation/bridge-react'
+ * - import { createBridgeComponent } from '@module-federation/bridge-react/v18'
+ * - import { createBridgeComponent } from '@module-federation/bridge-react/v19'
+ */
+export declare function createReact16Or17Root(container: Element | DocumentFragment): Root;
+export declare function createBridgeComponent<T = any>(bridgeInfo: Omit<ProviderFnParams<T>, 'createRoot'>): () => {
+    render(info: import("../..").RenderParams): Promise<void>;
+    destroy(info: import("../..").DestroyParams): void;
+};

package/dist/provider/versions/v18.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Entry point for React 18 specific bridge components
+ */
+import React from 'react';
+import type { ProviderFnParams } from '../../types';
+export interface CreateRootOptions {
+    identifierPrefix?: string;
+    onRecoverableError?: (error: unknown, errorInfo: unknown) => void;
+}
+export interface Root {
+    render(children: React.ReactNode): void;
+    unmount(): void;
+}
+export declare function createReact18Root(container: Element | DocumentFragment, options?: CreateRootOptions): Root;
+export declare function hydrateReact18Root(container: Element | DocumentFragment, initialChildren: React.ReactNode, options?: CreateRootOptions): import("node_modules/@types/react-dom/client").Root;
+export declare function createBridgeComponent<T = any>(bridgeInfo: Omit<ProviderFnParams<T>, 'createRoot'>): () => {
+    render(info: import("../..").RenderParams): Promise<void>;
+    destroy(info: import("../..").DestroyParams): void;
+};

package/dist/provider/versions/v19.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Entry point for React 19 specific bridge components
+ * This file provides support for React 19 version, using the new ReactDOM.createRoot API
+ */
+import React from 'react';
+import type { ProviderFnParams } from '../../types';
+export interface CreateRootOptions {
+    identifierPrefix?: string;
+    onRecoverableError?: (error: unknown, errorInfo: unknown) => void;
+    transitionCallbacks?: unknown;
+}
+export interface Root {
+    render(children: React.ReactNode): void;
+    unmount(): void;
+}
+export declare function createReact19Root(container: Element | DocumentFragment, options?: CreateRootOptions): Root;
+export declare function hydrateReact19Root(container: Element | DocumentFragment, initialChildren: React.ReactNode, options?: CreateRootOptions): Root;
+export declare function createBridgeComponent<T = any>(bridgeInfo: Omit<ProviderFnParams<T>, 'createRoot'>): () => {
+    render(info: import("../..").RenderParams): Promise<void>;
+    destroy(info: import("../..").DestroyParams): void;
+};

package/dist/remote/RemoteAppWrapper.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared RemoteAppWrapper component used by both base and router versions
+ * This component handles the lifecycle of remote Module Federation apps
+ */
+import React from 'react';
+import { RemoteComponentProps, RemoteAppParams } from '../types';
+export declare const RemoteAppWrapper: React.ForwardRefExoticComponent<Omit<RemoteAppParams & RemoteComponentProps<Record<string, unknown>>, "ref"> & React.RefAttributes<unknown>>;

package/dist/remote/base-component/component.d.ts

@@ -0,0 +1,2 @@
+import { RemoteAppWrapper } from '../RemoteAppWrapper';
+export default RemoteAppWrapper;

package/dist/remote/base-component/create.d.ts

@@ -0,0 +1,9 @@
+import { type LazyRemoteComponentInfo } from '../createHelpers';
+export type { LazyRemoteComponentInfo };
+declare const createLazyRemoteComponent: <T = Record<string, unknown>, E extends keyof T = keyof T>(info: LazyRemoteComponentInfo<T, E>) => import("node_modules/@types/react").LazyExoticComponent<import("node_modules/@types/react").ForwardRefExoticComponent<Omit<import("../..").RemoteComponentProps<Record<string, unknown>>, "ref"> & import("node_modules/@types/react").RefAttributes<HTMLDivElement>>>;
+export declare const createRemoteAppComponent: <T = Record<string, unknown>, E extends keyof T = keyof T>(info: LazyRemoteComponentInfo<T, E>) => import("node_modules/@types/react").ForwardRefExoticComponent<Omit<import("../..").RemoteComponentProps<Record<string, unknown>>, "ref"> & import("node_modules/@types/react").RefAttributes<HTMLDivElement>>;
+/**
+ * @deprecated createRemoteComponent is deprecated, please use createRemoteAppComponent instead!
+ */
+export declare const createRemoteComponent: <T = Record<string, unknown>, E extends keyof T = keyof T>(info: LazyRemoteComponentInfo<T, E>) => any;
+export { createLazyRemoteComponent };

package/dist/remote/base-component/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Base entry point without React Router dependencies
+ * Re-exports from base/create.tsx
+ */
+export { createRemoteAppComponent, createRemoteComponent, createLazyRemoteComponent, type LazyRemoteComponentInfo, } from './create';

package/dist/remote/createHelpers.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { RemoteComponentParams, RemoteComponentProps } from '../types';
+export type LazyRemoteComponentInfo<T, _E extends keyof T> = RemoteComponentParams<T>;
+/**
+ * Creates a factory function for creating lazy remote components
+ * @param RemoteApp The RemoteAppWrapper component to use (with or without router)
+ */
+export declare function createLazyRemoteComponentFactory(RemoteApp: React.ComponentType<any>): <T = Record<string, unknown>, E extends keyof T = keyof T>(info: LazyRemoteComponentInfo<T, E>) => React.LazyExoticComponent<React.ForwardRefExoticComponent<Omit<RemoteComponentProps<Record<string, unknown>>, "ref"> & React.RefAttributes<HTMLDivElement>>>;
+/**
+ * Creates a factory function for creating remote app components
+ * @param RemoteApp The RemoteAppWrapper component to use (with or without router)
+ */
+export declare function createRemoteAppComponentFactory(RemoteApp: React.ComponentType<any>): <T = Record<string, unknown>, E extends keyof T = keyof T>(info: LazyRemoteComponentInfo<T, E>) => React.ForwardRefExoticComponent<Omit<RemoteComponentProps<Record<string, unknown>>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Creates the deprecated createRemoteComponent function
+ */
+export declare function createDeprecatedRemoteComponentFactory<T = Record<string, unknown>, E extends keyof T = keyof T>(createFn: (info: LazyRemoteComponentInfo<T, E>) => any): (info: LazyRemoteComponentInfo<T, E>) => any;

package/dist/remote/router-component/component.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { RemoteAppWrapper } from '../RemoteAppWrapper';
+interface ExtraDataProps {
+    basename?: string;
+}
+export declare function withRouterData<P extends Parameters<typeof RemoteAppWrapper>[0]>(WrappedComponent: React.ComponentType<P & ExtraDataProps>): React.FC<Omit<P, keyof ExtraDataProps>>;
+declare const _default: React.FC<Omit<Omit<import("../../types").RemoteAppParams & import("../..").RemoteComponentProps<Record<string, unknown>>, "ref"> & React.RefAttributes<unknown>, "basename">>;
+export default _default;

package/dist/remote/router-component/create.d.ts

@@ -0,0 +1,9 @@
+import { type LazyRemoteComponentInfo } from '../createHelpers';
+export type { LazyRemoteComponentInfo };
+declare const createLazyRemoteComponent: <T = Record<string, unknown>, E extends keyof T = keyof T>(info: LazyRemoteComponentInfo<T, E>) => import("node_modules/@types/react").LazyExoticComponent<import("node_modules/@types/react").ForwardRefExoticComponent<Omit<import("../..").RemoteComponentProps<Record<string, unknown>>, "ref"> & import("node_modules/@types/react").RefAttributes<HTMLDivElement>>>;
+export declare const createRemoteAppComponent: <T = Record<string, unknown>, E extends keyof T = keyof T>(info: LazyRemoteComponentInfo<T, E>) => import("node_modules/@types/react").ForwardRefExoticComponent<Omit<import("../..").RemoteComponentProps<Record<string, unknown>>, "ref"> & import("node_modules/@types/react").RefAttributes<HTMLDivElement>>;
+/**
+ * @deprecated createRemoteComponent is deprecated, please use createRemoteAppComponent instead!
+ */
+export declare const createRemoteComponent: <T = Record<string, unknown>, E extends keyof T = keyof T>(info: LazyRemoteComponentInfo<T, E>) => any;
+export { createLazyRemoteComponent };

package/dist/remote/router-component/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Default entry point with React Router support
+ * Re-exports from router/create.tsx
+ */
+export { createRemoteAppComponent, createRemoteComponent, createLazyRemoteComponent, type LazyRemoteComponentInfo, } from './create';

package/dist/router/default.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import * as ReactRouterDom from 'react-router-dom/';
+declare function WrapperRouter(props: Parameters<typeof ReactRouterDom.BrowserRouter>[0] | Parameters<typeof ReactRouterDom.MemoryRouter>[0]): React.JSX.Element;
+declare function WrapperRouterProvider(props: Parameters<typeof ReactRouterDom.RouterProvider>[0]): React.JSX.Element;
+export * from 'react-router-dom/';
+export { WrapperRouter as BrowserRouter };
+export { WrapperRouterProvider as RouterProvider };

package/dist/router/v5.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare function WraperRouter(props: Record<string, unknown>): React.JSX.Element;
+export * from 'react-router-dom/';
+export { WraperRouter as BrowserRouter };

package/dist/router/v6.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import * as ReactRouterDom from 'react-router-dom/dist/index.js';
+declare function WraperRouter(props: Parameters<typeof ReactRouterDom.BrowserRouter>[0] | Parameters<typeof ReactRouterDom.MemoryRouter>[0]): React.JSX.Element;
+declare function WraperRouterProvider(props: Parameters<typeof ReactRouterDom.RouterProvider>[0]): React.JSX.Element;
+export * from 'react-router-dom/';
+export { WraperRouter as BrowserRouter };
+export { WraperRouterProvider as RouterProvider };