@module-federation/bridge-react 0.0.0-chore-bump-node-22-20260710161714

package/dist/lazy-utils.d.ts

@@ -0,0 +1,149 @@
+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>;
+    }
+}

package/dist/lazy-utils.es.js

@@ -0,0 +1,24 @@
+import "./logger-DwWkXsWl.mjs";
+import { H, I, h, f, N, v, m, o, e, n, J, z, i, t, k, u, j, A, s, x } from "./utils-DGS4pYp8.mjs";
+export {
+  H as callAllDowngrade,
+  I as callDowngrade,
+  h as fetchData,
+  f as flushDataFetch,
+  N as getDataFetchCache,
+  v as getDataFetchIdWithErrorMsgs,
+  m as getDataFetchInfo,
+  o as getDataFetchItem,
+  e as getDataFetchMap,
+  n as getDataFetchMapKey,
+  J as getDowngradeTag,
+  z as getLoadedRemoteInfos,
+  i as initDataFetchMap,
+  t as isCSROnly,
+  k as isDataLoaderExpose,
+  u as isServerEnv,
+  j as loadDataFetchModule,
+  A as setDataFetchItemLoadedStatus,
+  s as setSSREnv,
+  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.cjs.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const federationRuntime = { instance: null };
+function BridgeReactPlugin() {
+  return {
+    name: "bridge-react-plugin",
+    beforeInit(args) {
+      federationRuntime.instance = args.origin;
+      return args;
+    }
+  };
+}
+exports.default = BridgeReactPlugin;
+exports.federationRuntime = federationRuntime;

package/dist/plugin.d.ts

@@ -0,0 +1,22 @@
+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>;
+    }
+}

package/dist/plugin.es.js

@@ -0,0 +1,14 @@
+const federationRuntime = { instance: null };
+function BridgeReactPlugin() {
+  return {
+    name: "bridge-react-plugin",
+    beforeInit(args) {
+      federationRuntime.instance = args.origin;
+      return args;
+    }
+  };
+}
+export {
+  BridgeReactPlugin as default,
+  federationRuntime
+};