@module-federation/bridge-react 0.0.0-perf-devtools-20260108034446 → 0.0.0-perf-website-code-usage-20260914033703

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;