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

package/dist/lazy-load-component-plugin.es.js

@@ -1,5 +1,5 @@
-import { l, l as l2 } from "./lazy-load-component-plugin-CVcFMRce.mjs";
-import "./prefetch-CK3EZdY4.mjs";
+import { l, l as l2 } from "./lazy-load-component-plugin-NZphPG7_.mjs";
+import "./prefetch-TKq_EK_q.mjs";
 export {
   l as default,
   l2 as lazyLoadComponentPlugin

package/dist/lazy-utils.cjs.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./index.esm-BWaKho-8.js");
-const lazyUtils = require("./utils-tM9yE73c.js");
+require("./logger-Dxblx6P-.js");
+const lazyUtils = require("./utils-5dGErM3C.js");
 exports.callAllDowngrade = lazyUtils.callAllDowngrade;
 exports.callDowngrade = lazyUtils.callDowngrade;
 exports.fetchData = lazyUtils.fetchData;

package/dist/lazy-utils.d.ts

@@ -1,149 +1 @@
-import { GlobalModuleInfo } from '@module-federation/sdk';
-import { LRUCache } from 'lru-cache';
-import { ManifestProvider } from '@module-federation/sdk';
-import { ModuleFederation } from '@module-federation/runtime';
-import { ModuleInfo } from '@module-federation/sdk';
-import { PureEntryProvider } from '@module-federation/sdk';
-import { RemoteEntryType } from '@module-federation/sdk';
-
-declare interface CacheConfig {
-    maxSize?: number;
-    unstable_shouldDisable?: ({ request, }: {
-        request: Request;
-    }) => boolean | Promise<boolean>;
-}
-
-declare interface CacheItem<T> {
-    data: T;
-    timestamp: number;
-    isRevalidating?: boolean;
-}
-
-export declare function callAllDowngrade(): void;
-
-export declare function callDowngrade(id: string, params?: DataFetchParams, remoteInfo?: NoSSRRemoteInfo): Promise<unknown>;
-
-declare type DataFetch<T> = (params: DataFetchParams) => Promise<T>;
-
-declare type DataFetchParams = {
-    isDowngrade: boolean;
-    _id?: string;
-} & Record<string, unknown>;
-
-export declare function fetchData(id: string, params: DataFetchParams, remoteInfo?: NoSSRRemoteInfo): Promise<unknown | undefined>;
-
-export declare const flushDataFetch: () => void;
-
-export declare function getDataFetchCache(): MF_DATA_FETCH_CACHE;
-
-export declare const getDataFetchIdWithErrorMsgs: (errMsgs: string) => string | undefined;
-
-export declare const getDataFetchInfo: ({ name, alias, id, remoteSnapshot, }: {
-    id: string;
-    name: string;
-    remoteSnapshot: GlobalModuleInfo[string];
-    alias?: string;
-}) => {
-    dataFetchName: string;
-    dataFetchId: string;
-    dataFetchKey: string;
-} | undefined;
-
-export declare function getDataFetchItem(id: string): MF_DATA_FETCH_MAP_VALUE;
-
-export declare function getDataFetchMap(): MF_DATA_FETCH_MAP;
-
-export declare function getDataFetchMapKey(dataFetchInfo?: ReturnType<typeof getDataFetchInfo>, hostInfo?: {
-    name: string;
-    version?: string;
-}): string | undefined;
-
-export declare function getDowngradeTag(): MF_SSR_DOWNGRADE;
-
-export declare function getLoadedRemoteInfos(id: string, instance: ModuleFederation | null): {
-    snapshot: ModuleInfo | ManifestProvider | PureEntryProvider | undefined;
-    expose: string;
-    alias?: string;
-    name: string;
-    version?: string;
-    buildVersion?: string;
-    entry: string;
-    type: RemoteEntryType;
-    entryGlobalName: string;
-    shareScope: string | string[];
-} | undefined;
-
-export declare function initDataFetchMap(): void;
-
-export declare function isCSROnly(): boolean;
-
-export declare function isDataLoaderExpose(exposeKey: string): boolean;
-
-export declare function isServerEnv(): boolean;
-
-export declare function loadDataFetchModule(instance: ModuleFederation, id: string): Promise<(params: DataFetchParams) => Promise<unknown>>;
-
-declare type MF_DATA_FETCH_CACHE = {
-    cacheStore?: LRUCache<string, Map<string, CacheItem<any>>>;
-    tagKeyMap?: Map<string, Set<string>>;
-    cacheConfig?: CacheConfig;
-};
-
-declare type MF_DATA_FETCH_MAP = Record<string, MF_DATA_FETCH_MAP_VALUE>;
-
-declare type MF_DATA_FETCH_MAP_VALUE = [
-[
-() => Promise<DataFetch<unknown>>,
-MF_DATA_FETCH_TYPE,
-Promise<DataFetch<unknown>>?
-],
-MF_DATA_FETCH_MAP_VALUE_PROMISE_SET?,
-MF_DATA_FETCH_STATUS?
-];
-
-declare type MF_DATA_FETCH_MAP_VALUE_PROMISE_SET = [
-Promise<unknown>,
-((data: unknown) => void)?,
-((err: unknown) => void)?
-];
-
-declare const enum MF_DATA_FETCH_STATUS {
-    LOADED = 1,
-    LOADING = 2,
-    AWAIT = 0,
-    ERROR = 3
-}
-
-declare const enum MF_DATA_FETCH_TYPE {
-    FETCH_SERVER = 1,
-    FETCH_CLIENT = 2
-}
-
-declare type MF_SSR_DOWNGRADE = string[] | true | undefined;
-
-declare type NoSSRRemoteInfo = {
-    name: string;
-    version: string;
-    ssrPublicPath: string;
-    ssrRemoteEntry: string;
-    globalName: string;
-};
-
-export declare function setDataFetchItemLoadedStatus(id: string): void;
-
-export declare function setSSREnv({ fetchServerQuery, }: {
-    fetchServerQuery?: Record<string, unknown>;
-}): void;
-
-export declare const wrapDataFetchId: (id?: string) => string;
-
-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 './lazy/utils';

package/dist/lazy-utils.es.js

@@ -1,24 +1,24 @@
-import "./index.esm-CPwSeCvw.mjs";
-import { G, H, f, J, I, u, k, n, e, m, B, y, i, q, j, t, h, z, s, w } from "./utils-dUgb9Jkm.mjs";
+import "./logger-DwWkXsWl.mjs";
+import { H, I, h, f, O, v, m, o, e, n, J, z, i, t, k, u, j, A, s, x } from "./utils-BBP3hEeV.mjs";
 export {
-  G as callAllDowngrade,
-  H as callDowngrade,
-  f as fetchData,
-  J as flushDataFetch,
-  I as getDataFetchCache,
-  u as getDataFetchIdWithErrorMsgs,
-  k as getDataFetchInfo,
-  n as getDataFetchItem,
+  H as callAllDowngrade,
+  I as callDowngrade,
+  h as fetchData,
+  f as flushDataFetch,
+  O as getDataFetchCache,
+  v as getDataFetchIdWithErrorMsgs,
+  m as getDataFetchInfo,
+  o as getDataFetchItem,
   e as getDataFetchMap,
-  m as getDataFetchMapKey,
-  B as getDowngradeTag,
-  y as getLoadedRemoteInfos,
+  n as getDataFetchMapKey,
+  J as getDowngradeTag,
+  z as getLoadedRemoteInfos,
   i as initDataFetchMap,
-  q as isCSROnly,
-  j as isDataLoaderExpose,
-  t as isServerEnv,
-  h as loadDataFetchModule,
-  z as setDataFetchItemLoadedStatus,
+  t as isCSROnly,
+  k as isDataLoaderExpose,
+  u as isServerEnv,
+  j as loadDataFetchModule,
+  A as setDataFetchItemLoadedStatus,
   s as setSSREnv,
-  w as wrapDataFetchId
+  x as wrapDataFetchId
 };

package/dist/logger-DwWkXsWl.mjs

@@ -0,0 +1,139 @@
+const MANIFEST_EXT = ".json";
+const BROWSER_LOG_KEY = "FEDERATION_DEBUG";
+const SEPARATOR = ":";
+const isBrowserEnvValue = typeof ENV_TARGET !== "undefined" ? ENV_TARGET === "web" : typeof window !== "undefined" && typeof window.document !== "undefined";
+function isBrowserEnv() {
+  return isBrowserEnvValue;
+}
+function isBrowserDebug() {
+  try {
+    if (isBrowserEnv() && window.localStorage) return Boolean(localStorage.getItem(BROWSER_LOG_KEY));
+  } catch (error) {
+    return false;
+  }
+  return false;
+}
+function isDebugMode() {
+  if (typeof process !== "undefined" && process.env && process.env["FEDERATION_DEBUG"]) return Boolean(process.env["FEDERATION_DEBUG"]);
+  if (typeof FEDERATION_DEBUG !== "undefined" && Boolean(FEDERATION_DEBUG)) return true;
+  return isBrowserDebug();
+}
+const PREFIX = "[ Module Federation ]";
+const DEFAULT_DELEGATE = console;
+const LOGGER_STACK_SKIP_TOKENS = [
+  "logger.ts",
+  "logger.js",
+  "captureStackTrace",
+  "Logger.emit",
+  "Logger.log",
+  "Logger.info",
+  "Logger.warn",
+  "Logger.error",
+  "Logger.debug"
+];
+function captureStackTrace() {
+  try {
+    const stack = (/* @__PURE__ */ new Error()).stack;
+    if (!stack) return;
+    const [, ...rawLines] = stack.split("\n");
+    const filtered = rawLines.filter((line) => !LOGGER_STACK_SKIP_TOKENS.some((token) => line.includes(token)));
+    if (!filtered.length) return;
+    return `Stack trace:
+${filtered.slice(0, 5).join("\n")}`;
+  } catch {
+    return;
+  }
+}
+var Logger = class {
+  constructor(prefix, delegate = DEFAULT_DELEGATE) {
+    this.prefix = prefix;
+    this.delegate = delegate ?? DEFAULT_DELEGATE;
+  }
+  setPrefix(prefix) {
+    this.prefix = prefix;
+  }
+  setDelegate(delegate) {
+    this.delegate = delegate ?? DEFAULT_DELEGATE;
+  }
+  emit(method, args) {
+    const delegate = this.delegate;
+    const stackTrace = isDebugMode() ? captureStackTrace() : void 0;
+    const enrichedArgs = stackTrace ? [...args, stackTrace] : args;
+    const order = (() => {
+      switch (method) {
+        case "log":
+          return ["log", "info"];
+        case "info":
+          return ["info", "log"];
+        case "warn":
+          return [
+            "warn",
+            "info",
+            "log"
+          ];
+        case "error":
+          return [
+            "error",
+            "warn",
+            "log"
+          ];
+        default:
+          return ["debug", "log"];
+      }
+    })();
+    for (const candidate of order) {
+      const handler = delegate[candidate];
+      if (typeof handler === "function") {
+        handler.call(delegate, this.prefix, ...enrichedArgs);
+        return;
+      }
+    }
+    for (const candidate of order) {
+      const handler = DEFAULT_DELEGATE[candidate];
+      if (typeof handler === "function") {
+        handler.call(DEFAULT_DELEGATE, this.prefix, ...enrichedArgs);
+        return;
+      }
+    }
+  }
+  log(...args) {
+    this.emit("log", args);
+  }
+  warn(...args) {
+    this.emit("warn", args);
+  }
+  error(...args) {
+    this.emit("error", args);
+  }
+  success(...args) {
+    this.emit("info", args);
+  }
+  info(...args) {
+    this.emit("info", args);
+  }
+  ready(...args) {
+    this.emit("info", args);
+  }
+  debug(...args) {
+    if (isDebugMode()) this.emit("debug", args);
+  }
+};
+function createLogger(prefix) {
+  return new Logger(prefix);
+}
+function createInfrastructureLogger(prefix) {
+  const infrastructureLogger = new Logger(prefix);
+  Object.defineProperty(infrastructureLogger, "__mf_infrastructure_logger__", {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  return infrastructureLogger;
+}
+createInfrastructureLogger(PREFIX);
+export {
+  MANIFEST_EXT as M,
+  SEPARATOR as S,
+  createLogger as c,
+  isBrowserEnvValue as i
+};

package/dist/logger-Dxblx6P-.js

@@ -0,0 +1,138 @@
+"use strict";
+const MANIFEST_EXT = ".json";
+const BROWSER_LOG_KEY = "FEDERATION_DEBUG";
+const SEPARATOR = ":";
+const isBrowserEnvValue = typeof ENV_TARGET !== "undefined" ? ENV_TARGET === "web" : typeof window !== "undefined" && typeof window.document !== "undefined";
+function isBrowserEnv() {
+  return isBrowserEnvValue;
+}
+function isBrowserDebug() {
+  try {
+    if (isBrowserEnv() && window.localStorage) return Boolean(localStorage.getItem(BROWSER_LOG_KEY));
+  } catch (error) {
+    return false;
+  }
+  return false;
+}
+function isDebugMode() {
+  if (typeof process !== "undefined" && process.env && process.env["FEDERATION_DEBUG"]) return Boolean(process.env["FEDERATION_DEBUG"]);
+  if (typeof FEDERATION_DEBUG !== "undefined" && Boolean(FEDERATION_DEBUG)) return true;
+  return isBrowserDebug();
+}
+const PREFIX = "[ Module Federation ]";
+const DEFAULT_DELEGATE = console;
+const LOGGER_STACK_SKIP_TOKENS = [
+  "logger.ts",
+  "logger.js",
+  "captureStackTrace",
+  "Logger.emit",
+  "Logger.log",
+  "Logger.info",
+  "Logger.warn",
+  "Logger.error",
+  "Logger.debug"
+];
+function captureStackTrace() {
+  try {
+    const stack = (/* @__PURE__ */ new Error()).stack;
+    if (!stack) return;
+    const [, ...rawLines] = stack.split("\n");
+    const filtered = rawLines.filter((line) => !LOGGER_STACK_SKIP_TOKENS.some((token) => line.includes(token)));
+    if (!filtered.length) return;
+    return `Stack trace:
+${filtered.slice(0, 5).join("\n")}`;
+  } catch {
+    return;
+  }
+}
+var Logger = class {
+  constructor(prefix, delegate = DEFAULT_DELEGATE) {
+    this.prefix = prefix;
+    this.delegate = delegate ?? DEFAULT_DELEGATE;
+  }
+  setPrefix(prefix) {
+    this.prefix = prefix;
+  }
+  setDelegate(delegate) {
+    this.delegate = delegate ?? DEFAULT_DELEGATE;
+  }
+  emit(method, args) {
+    const delegate = this.delegate;
+    const stackTrace = isDebugMode() ? captureStackTrace() : void 0;
+    const enrichedArgs = stackTrace ? [...args, stackTrace] : args;
+    const order = (() => {
+      switch (method) {
+        case "log":
+          return ["log", "info"];
+        case "info":
+          return ["info", "log"];
+        case "warn":
+          return [
+            "warn",
+            "info",
+            "log"
+          ];
+        case "error":
+          return [
+            "error",
+            "warn",
+            "log"
+          ];
+        default:
+          return ["debug", "log"];
+      }
+    })();
+    for (const candidate of order) {
+      const handler = delegate[candidate];
+      if (typeof handler === "function") {
+        handler.call(delegate, this.prefix, ...enrichedArgs);
+        return;
+      }
+    }
+    for (const candidate of order) {
+      const handler = DEFAULT_DELEGATE[candidate];
+      if (typeof handler === "function") {
+        handler.call(DEFAULT_DELEGATE, this.prefix, ...enrichedArgs);
+        return;
+      }
+    }
+  }
+  log(...args) {
+    this.emit("log", args);
+  }
+  warn(...args) {
+    this.emit("warn", args);
+  }
+  error(...args) {
+    this.emit("error", args);
+  }
+  success(...args) {
+    this.emit("info", args);
+  }
+  info(...args) {
+    this.emit("info", args);
+  }
+  ready(...args) {
+    this.emit("info", args);
+  }
+  debug(...args) {
+    if (isDebugMode()) this.emit("debug", args);
+  }
+};
+function createLogger(prefix) {
+  return new Logger(prefix);
+}
+function createInfrastructureLogger(prefix) {
+  const infrastructureLogger = new Logger(prefix);
+  Object.defineProperty(infrastructureLogger, "__mf_infrastructure_logger__", {
+    value: true,
+    enumerable: false,
+    configurable: false
+  });
+  return infrastructureLogger;
+}
+createInfrastructureLogger(PREFIX);
+exports.MANIFEST_EXT = MANIFEST_EXT;
+exports.SEPARATOR = SEPARATOR;
+exports.createLogger = createLogger;
+exports.isBrowserEnvValue = isBrowserEnvValue;

package/dist/plugin.d.ts

@@ -1,22 +1,2 @@
-import { ModuleFederation } from '@module-federation/runtime';
-import { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-
-declare function BridgeReactPlugin(): ModuleFederationRuntimePlugin;
-export default BridgeReactPlugin;
-
-export declare const federationRuntime: FederationRuntimeType;
-
-export declare type FederationRuntimeType = {
-    instance: ModuleFederation | null;
-};
-
-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 { default } from './provider/plugin';
+export * from './provider/plugin';

package/dist/plugins/lazy-load-component-plugin.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import { createLazyComponent, prefetch, collectSSRAssets } from '../lazy';
+import type { CreateLazyComponentOptions, PrefetchOptions } from '../lazy';
+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 declare function lazyLoadComponentPlugin(): ModuleFederationRuntimePlugin;
+export default lazyLoadComponentPlugin;

package/dist/plugins/lazy-load-component-plugin.spec.d.ts

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