@module-federation/bridge-react 2.7.0 → 2.8.0

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 };

package/dist/router/v7.d.ts

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

package/dist/router-v5.d.ts

@@ -1,17 +1 @@
-import { default as default_2 } from 'react';
-
-export declare function BrowserRouter(props: Record<string, unknown>): default_2.JSX.Element;
-
-
-export * from "react-router-dom/";
-
-export { }
-
-
-declare module '@module-federation/runtime-core' {
-    interface ModuleFederation {
-        createLazyComponent<T, E extends keyof T>(options: Omit<CreateLazyComponentOptions<T, E>, 'instance'>): ReturnType<typeof createLazyComponent<T, E>>;
-        prefetch(options: Omit<PrefetchOptions, 'instance'>): ReturnType<typeof prefetch>;
-        collectSSRAssets(options: Omit<Parameters<typeof collectSSRAssets>[0], 'instance'>): ReturnType<typeof collectSSRAssets>;
-    }
-}
+export * from './router/v5';

package/dist/router-v6.d.ts

@@ -1,20 +1 @@
-import { default as default_2 } from 'react';
-import * as ReactRouterDom from 'react-router-dom/dist/index.js';
-
-export declare function BrowserRouter(props: Parameters<typeof ReactRouterDom.BrowserRouter>[0] | Parameters<typeof ReactRouterDom.MemoryRouter>[0]): default_2.JSX.Element;
-
-export declare function RouterProvider(props: Parameters<typeof ReactRouterDom.RouterProvider>[0]): default_2.JSX.Element;
-
-
-export * from "react-router-dom/";
-
-export { }
-
-
-declare module '@module-federation/runtime-core' {
-    interface ModuleFederation {
-        createLazyComponent<T, E extends keyof T>(options: Omit<CreateLazyComponentOptions<T, E>, 'instance'>): ReturnType<typeof createLazyComponent<T, E>>;
-        prefetch(options: Omit<PrefetchOptions, 'instance'>): ReturnType<typeof prefetch>;
-        collectSSRAssets(options: Omit<Parameters<typeof collectSSRAssets>[0], 'instance'>): ReturnType<typeof collectSSRAssets>;
-    }
-}
+export * from './router/v6';

package/dist/router-v7.d.ts

@@ -1,19 +1 @@
-import { default as default_2 } from 'react';
-
-export declare function BrowserRouter(props: Record<string, unknown>): default_2.JSX.Element;
-
-export declare function RouterProvider(props: Record<string, unknown>): default_2.JSX.Element;
-
-
-export * from "react-router";
-
-export { }
-
-
-declare module '@module-federation/runtime-core' {
-    interface ModuleFederation {
-        createLazyComponent<T, E extends keyof T>(options: Omit<CreateLazyComponentOptions<T, E>, 'instance'>): ReturnType<typeof createLazyComponent<T, E>>;
-        prefetch(options: Omit<PrefetchOptions, 'instance'>): ReturnType<typeof prefetch>;
-        collectSSRAssets(options: Omit<Parameters<typeof collectSSRAssets>[0], 'instance'>): ReturnType<typeof collectSSRAssets>;
-    }
-}
+export * from './router/v7';

package/dist/router.d.ts

@@ -1,20 +1 @@
-import { default as default_2 } from 'react';
-import * as ReactRouterDom from 'react-router-dom/';
-
-export declare function BrowserRouter(props: Parameters<typeof ReactRouterDom.BrowserRouter>[0] | Parameters<typeof ReactRouterDom.MemoryRouter>[0]): default_2.JSX.Element;
-
-export declare function RouterProvider(props: Parameters<typeof ReactRouterDom.RouterProvider>[0]): default_2.JSX.Element;
-
-
-export * from "react-router-dom/";
-
-export { }
-
-
-declare module '@module-federation/runtime-core' {
-    interface ModuleFederation {
-        createLazyComponent<T, E extends keyof T>(options: Omit<CreateLazyComponentOptions<T, E>, 'instance'>): ReturnType<typeof createLazyComponent<T, E>>;
-        prefetch(options: Omit<PrefetchOptions, 'instance'>): ReturnType<typeof prefetch>;
-        collectSSRAssets(options: Omit<Parameters<typeof collectSSRAssets>[0], 'instance'>): ReturnType<typeof collectSSRAssets>;
-    }
-}
+export * from './router/default';

package/dist/shared/size-limited-cache.d.ts

@@ -0,0 +1,29 @@
+export interface SizeLimitedCacheOptions<K, V> {
+    maxSize: number;
+    sizeCalculation?: (value: V, key: K) => number;
+}
+export interface SizeLimitedCacheSetOptions {
+    size?: number;
+}
+/**
+ * A small, size-aware least-recently-used cache.
+ *
+ * This intentionally implements only the operations used by federation
+ * packages. Reading or checking an entry refreshes its recency.
+ */
+export declare class SizeLimitedCache<K, V> {
+    readonly maxSize: number;
+    private readonly entries;
+    private readonly sizeCalculation?;
+    private currentSize;
+    constructor(options: SizeLimitedCacheOptions<K, V>);
+    get size(): number;
+    get calculatedSize(): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V, options?: SizeLimitedCacheSetOptions): this;
+    delete(key: K): boolean;
+    clear(): void;
+    private refresh;
+    private evictUntilWithinLimit;
+}

package/dist/shared/size-limited-cache.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/size-limited-cache.cjs.js

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class SizeLimitedCache {
+  constructor(options) {
+    __publicField(this, "maxSize");
+    __publicField(this, "entries", /* @__PURE__ */ new Map());
+    __publicField(this, "sizeCalculation");
+    __publicField(this, "currentSize", 0);
+    if (!Number.isInteger(options.maxSize) || options.maxSize <= 0) {
+      throw new TypeError("maxSize must be a positive integer");
+    }
+    this.maxSize = options.maxSize;
+    this.sizeCalculation = options.sizeCalculation;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get calculatedSize() {
+    return this.currentSize;
+  }
+  get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    this.refresh(key, entry);
+    return entry.value;
+  }
+  has(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return false;
+    }
+    this.refresh(key, entry);
+    return true;
+  }
+  set(key, value, options = {}) {
+    var _a;
+    const entrySize = options.size ?? ((_a = this.sizeCalculation) == null ? void 0 : _a.call(this, value, key)) ?? 1;
+    if (!Number.isInteger(entrySize) || entrySize <= 0) {
+      throw new TypeError("entry size must be a positive integer");
+    }
+    this.delete(key);
+    if (entrySize > this.maxSize) {
+      return this;
+    }
+    this.entries.set(key, { value, size: entrySize });
+    this.currentSize += entrySize;
+    this.evictUntilWithinLimit();
+    return this;
+  }
+  delete(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return false;
+    }
+    this.currentSize -= entry.size;
+    return this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+    this.currentSize = 0;
+  }
+  refresh(key, entry) {
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+  }
+  evictUntilWithinLimit() {
+    while (this.currentSize > this.maxSize) {
+      const oldest = this.entries.keys().next();
+      if (oldest.done) {
+        this.currentSize = 0;
+        return;
+      }
+      this.delete(oldest.value);
+    }
+  }
+}
+exports.SizeLimitedCache = SizeLimitedCache;

package/dist/size-limited-cache.d.ts

@@ -0,0 +1 @@
+export * from './shared/size-limited-cache';

package/dist/size-limited-cache.es.js

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class SizeLimitedCache {
+  constructor(options) {
+    __publicField(this, "maxSize");
+    __publicField(this, "entries", /* @__PURE__ */ new Map());
+    __publicField(this, "sizeCalculation");
+    __publicField(this, "currentSize", 0);
+    if (!Number.isInteger(options.maxSize) || options.maxSize <= 0) {
+      throw new TypeError("maxSize must be a positive integer");
+    }
+    this.maxSize = options.maxSize;
+    this.sizeCalculation = options.sizeCalculation;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get calculatedSize() {
+    return this.currentSize;
+  }
+  get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    this.refresh(key, entry);
+    return entry.value;
+  }
+  has(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return false;
+    }
+    this.refresh(key, entry);
+    return true;
+  }
+  set(key, value, options = {}) {
+    var _a;
+    const entrySize = options.size ?? ((_a = this.sizeCalculation) == null ? void 0 : _a.call(this, value, key)) ?? 1;
+    if (!Number.isInteger(entrySize) || entrySize <= 0) {
+      throw new TypeError("entry size must be a positive integer");
+    }
+    this.delete(key);
+    if (entrySize > this.maxSize) {
+      return this;
+    }
+    this.entries.set(key, { value, size: entrySize });
+    this.currentSize += entrySize;
+    this.evictUntilWithinLimit();
+    return this;
+  }
+  delete(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return false;
+    }
+    this.currentSize -= entry.size;
+    return this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+    this.currentSize = 0;
+  }
+  refresh(key, entry) {
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+  }
+  evictUntilWithinLimit() {
+    while (this.currentSize > this.maxSize) {
+      const oldest = this.entries.keys().next();
+      if (oldest.done) {
+        this.currentSize = 0;
+        return;
+      }
+      this.delete(oldest.value);
+    }
+  }
+}
+export {
+  SizeLimitedCache
+};

package/dist/types.d.ts

@@ -0,0 +1,137 @@
+import * as React from 'react';
+export type ErrorFallbackProps = {
+    error: unknown;
+    resetErrorBoundary: (...args: unknown[]) => void;
+};
+/**
+ * Options for creating a React root
+ */
+export interface CreateRootOptions {
+    identifierPrefix?: string;
+    onRecoverableError?: (error: unknown) => void;
+    transitionCallbacks?: unknown;
+}
+/**
+ * Interface for a React root object
+ */
+export interface Root {
+    render(children: React.ReactNode): void;
+    unmount(): void;
+}
+/**
+ * Type for a root element, which can be either an HTMLElement or a React root
+ */
+export type RootType = HTMLElement | Root;
+/**
+ * Parameters for the render function
+ */
+export interface RenderParams {
+    moduleName?: string;
+    basename?: string;
+    memoryRoute?: {
+        entryPath: string;
+        initialState?: Record<string, unknown>;
+    };
+    dom: HTMLElement;
+    /**
+     * Options to pass to createRoot for React 18 and 19
+     * @example
+     * {
+     *   identifierPrefix: 'app-',
+     *   onRecoverableError: (err) => console.error(err)
+     * }
+     */
+    rootOptions?: CreateRootOptions;
+    [key: string]: unknown;
+}
+/**
+ * Parameters for the destroy function
+ */
+export interface DestroyParams {
+    moduleName: string;
+    dom: HTMLElement;
+}
+/**
+ * Parameters for the provider function
+ */
+export interface ProviderParams {
+    moduleName?: string;
+    basename?: string;
+    memoryRoute?: {
+        entryPath: string;
+        initialState?: Record<string, unknown>;
+    };
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Parameters for the render function, extending ProviderParams
+ */
+export interface RenderFnParams extends ProviderParams {
+    dom: HTMLElement;
+    fallback?: React.ComponentType<{
+        error: Error;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * Parameters for the provider function
+ */
+export interface ProviderFnParams<T> {
+    rootComponent: React.ComponentType<T>;
+    render?: (App: React.ReactElement, id?: HTMLElement | string) => RootType | Promise<RootType>;
+    createRoot?: (container: Element | DocumentFragment, options?: CreateRootOptions) => Root;
+    /**
+     * Default options to pass to createRoot for React 18 and 19
+     * These options will be used when creating a root unless overridden by rootOptions in render params
+     * @example
+     * {
+     *   identifierPrefix: 'app-',
+     *   onRecoverableError: (err) => console.error(err)
+     * }
+     */
+    defaultRootOptions?: CreateRootOptions;
+}
+/**
+ * Parameters for the remote component
+ */
+export interface RemoteComponentProps<T = Record<string, unknown>> {
+    props?: T;
+    fallback?: React.ComponentType<{
+        error: Error;
+    }>;
+    loading?: React.ReactNode;
+    [key: string]: unknown;
+}
+/**
+ * Parameters for the remote component loader
+ */
+export interface RemoteComponentParams<T = Record<string, unknown>, E extends keyof T = keyof T> {
+    loader: () => Promise<T>;
+    loading: React.ReactNode;
+    fallback: React.ComponentType<{
+        error: Error;
+    }>;
+    export?: E;
+    props?: T;
+}
+/**
+ * Interface for a remote module provider
+ */
+export interface RemoteModule {
+    provider: () => {
+        render: (info: RenderFnParams) => void;
+        destroy: (info: {
+            dom: any;
+        }) => void;
+    };
+}
+/**
+ * Parameters for a remote app component
+ */
+export interface RemoteAppParams extends ProviderParams {
+    moduleName: string;
+    providerInfo: NonNullable<RemoteModule['provider']>;
+    exportName: string | number | symbol;
+    fallback: React.ComponentType<ErrorFallbackProps>;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export declare const LoggerInstance: import("@module-federation/sdk").Logger;
+export declare function pathJoin(...args: string[]): string;
+export declare const getModuleName: (id: string) => string;
+export declare const getRootDomDefaultClassName: (moduleName: string) => string;