@module-federation/bridge-react 2.7.0 → 2.8.1

package/dist/{prefetch-DLhPTofn.js → prefetch-QJLnti7A.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 {
@@ -470,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}`);
@@ -481,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 {
@@ -533,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);
@@ -607,6 +622,9 @@ const runtimeDescMap = {
   ...runtimeDescMap
 });
 const importCallback = ".then(callbacks[0]).catch(callbacks[1])";
+function isEsmRemoteType(type) {
+  return type === "esm" || type === "module";
+}
 async function loadEsmEntry({ entry, remoteEntryExports }) {
   return new Promise((resolve, reject) => {
     try {
@@ -674,29 +692,23 @@ async function loadEntryScript({ name, globalName, entry, remoteInfo, loaderHook
 }
 async function loadEntryDom({ remoteInfo, remoteEntryExports, loaderHook, getEntryUrl, resourceContext }) {
   const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
-  switch (type) {
-    case "esm":
-    case "module":
-      return loadEsmEntry({
-        entry,
-        remoteEntryExports
-      });
-    case "system":
-      return loadSystemJsEntry({
-        entry,
-        remoteEntryExports
-      });
-    default:
-      return loadEntryScript({
-        entry,
-        globalName,
-        name,
-        remoteInfo,
-        loaderHook,
-        getEntryUrl,
-        resourceContext
-      });
-  }
+  if (isEsmRemoteType(type)) return loadEsmEntry({
+    entry,
+    remoteEntryExports
+  });
+  if (type === "system") return loadSystemJsEntry({
+    entry,
+    remoteEntryExports
+  });
+  return loadEntryScript({
+    entry,
+    globalName,
+    name,
+    remoteInfo,
+    loaderHook,
+    getEntryUrl,
+    resourceContext
+  });
 }
 async function loadEntryNode({ remoteInfo, loaderHook, resourceContext }) {
   const { entry, entryGlobalName: globalName, name, type } = remoteInfo;
@@ -810,6 +822,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");
@@ -919,7 +967,7 @@ function preloadAssets(remoteInfo, host, assets, useLinkPreload = true, baseCont
       results.push(waitForRemoteEntryPreload(host, remoteInfo, entryRemoteInfo, createResourceContext(baseContext, "remoteEntry")));
     });
     if (useLinkPreload) {
-      const defaultAttrs = {
+      const defaultAttrs2 = {
         rel: "preload",
         as: "style"
       };
@@ -928,12 +976,12 @@ function preloadAssets(remoteInfo, host, assets, useLinkPreload = true, baseCont
           host,
           remoteInfo,
           url: cssUrl,
-          attrs: defaultAttrs,
+          attrs: defaultAttrs2,
           context: createResourceContext(baseContext, "css")
         }));
       });
     } else {
-      const defaultAttrs = {
+      const defaultAttrs2 = {
         rel: "stylesheet",
         type: "text/css"
       };
@@ -942,41 +990,39 @@ function preloadAssets(remoteInfo, host, assets, useLinkPreload = true, baseCont
           host,
           remoteInfo,
           url: cssUrl,
-          attrs: defaultAttrs,
+          attrs: defaultAttrs2,
           needDeleteLink: false,
           context: createResourceContext(baseContext, "css")
         }));
       });
     }
+    let preloadJsAsset = waitForScriptPreload;
+    let defaultAttrs = {
+      fetchpriority: "high",
+      type: "text/javascript"
+    };
     if (useLinkPreload) {
-      const defaultAttrs = {
+      preloadJsAsset = waitForLinkPreload;
+      defaultAttrs = {
         rel: "preload",
         as: "script"
       };
-      jsAssetsWithoutEntry.forEach((jsUrl) => {
-        results.push(waitForLinkPreload({
-          host,
-          remoteInfo,
-          url: jsUrl,
-          attrs: defaultAttrs,
-          context: createResourceContext(baseContext, "js")
-        }));
-      });
-    } else {
-      const defaultAttrs = {
-        fetchpriority: "high",
-        type: (remoteInfo == null ? void 0 : remoteInfo.type) === "module" ? "module" : "text/javascript"
+    } else if (isEsmRemoteType(remoteInfo.type)) {
+      preloadJsAsset = waitForLinkPreload;
+      defaultAttrs = {
+        rel: "modulepreload",
+        fetchpriority: "high"
       };
-      jsAssetsWithoutEntry.forEach((jsUrl) => {
-        results.push(waitForScriptPreload({
-          host,
-          remoteInfo,
-          url: jsUrl,
-          attrs: defaultAttrs,
-          context: createResourceContext(baseContext, "js")
-        }));
-      });
     }
+    jsAssetsWithoutEntry.forEach((jsUrl) => {
+      results.push(preloadJsAsset({
+        host,
+        remoteInfo,
+        url: jsUrl,
+        attrs: defaultAttrs,
+        context: createResourceContext(baseContext, "js")
+      }));
+    });
   }
   return Promise.all(results);
 }
@@ -987,8 +1033,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 };