@module-federation/bridge-react 2.6.0 → 2.8.0

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;