@module-federation/bridge-react 0.0.0-next-20250708121428 → 0.0.0-next-20250709032753

package/src/lazy/data-fetch/prefetch.ts

@@ -1,106 +0,0 @@
-import type { getInstance } from '@module-federation/runtime';
-import {
-  getDataFetchInfo,
-  getDataFetchMap,
-  getDataFetchMapKey,
-} from '../utils';
-import logger from '../logger';
-import helpers from '@module-federation/runtime/helpers';
-import { DataFetchParams } from '../types';
-
-export type PrefetchOptions = {
-  id: string;
-  instance: ReturnType<typeof getInstance>;
-  dataFetchParams?: DataFetchParams;
-  preloadComponentResource?: boolean;
-};
-
-export async function prefetch(options: PrefetchOptions) {
-  const { instance, id, dataFetchParams, preloadComponentResource } = options;
-  if (!id) {
-    logger.error('id is required for prefetch!');
-    return;
-  }
-  if (!instance) {
-    logger.error('instance is required for prefetch!');
-    return;
-  }
-  const matchedRemoteInfo = helpers.utils.matchRemoteWithNameAndExpose(
-    instance.options.remotes,
-    id,
-  );
-  if (!matchedRemoteInfo) {
-    logger.error(`Can not found '${id}' in instance.options.remotes!`);
-    return;
-  }
-  const { remote, expose } = matchedRemoteInfo;
-  const { remoteSnapshot, globalSnapshot } =
-    await instance.snapshotHandler.loadRemoteSnapshotInfo({
-      moduleInfo: remote,
-      id,
-      expose,
-    });
-
-  if (preloadComponentResource) {
-    const remoteInfo = helpers.utils.getRemoteInfo(remote);
-
-    instance.remoteHandler.hooks.lifecycle.generatePreloadAssets.emit({
-      origin: instance,
-      preloadOptions: {
-        remote,
-        preloadConfig: {
-          nameOrAlias: remote.name,
-          exposes: [expose],
-        },
-      },
-      remote,
-      remoteInfo,
-      globalSnapshot,
-      remoteSnapshot,
-    });
-  }
-
-  const dataFetchMap = getDataFetchMap();
-  if (!dataFetchMap) {
-    return;
-  }
-  const dataFetchInfo = getDataFetchInfo({
-    name: remote.name,
-    alias: remote.alias,
-    id,
-    remoteSnapshot,
-  });
-
-  const dataFetchMapKey = getDataFetchMapKey(dataFetchInfo, {
-    name: instance.name,
-    version: instance.options.version,
-  });
-
-  if (!dataFetchMapKey) {
-    return;
-  }
-
-  const dataFetchItem = dataFetchMap[dataFetchMapKey];
-  if (!dataFetchItem) {
-    return;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const [getDataFetchGetter, _type, getDataFetchPromise] = dataFetchItem[0];
-
-  let _getDataFetchPromise = getDataFetchPromise;
-  if (!getDataFetchPromise) {
-    if (!getDataFetchGetter) {
-      return;
-    }
-    _getDataFetchPromise = getDataFetchGetter();
-  }
-
-  _getDataFetchPromise!.then((dataFetchFn) => {
-    return dataFetchFn({
-      ...dataFetchParams,
-      _id: dataFetchMapKey,
-      isDowngrade: false,
-    });
-  });
-}

package/src/lazy/data-fetch/runtime-plugin.ts

@@ -1,115 +0,0 @@
-import { injectDataFetch } from './inject-data-fetch';
-import {
-  getDataFetchInfo,
-  initDataFetchMap,
-  getDataFetchItem,
-  getDataFetchMap,
-  isCSROnly,
-  getDataFetchMapKey,
-  isDataLoaderExpose,
-  loadDataFetchModule,
-  isServerEnv,
-} from '../utils';
-import logger from '../logger';
-import {
-  MF_DATA_FETCH_TYPE,
-  MF_DATA_FETCH_STATUS,
-  DATA_FETCH_CLIENT_SUFFIX,
-} from '../constant';
-
-import type { MF_DATA_FETCH_MAP_VALUE } from '../types';
-import type { FederationRuntimePlugin } from '@module-federation/runtime';
-
-const autoFetchData: () => FederationRuntimePlugin = () => {
-  initDataFetchMap();
-  injectDataFetch();
-  return {
-    name: 'auto-fetch-data-plugin',
-    afterLoadSnapshot(args) {
-      const { id, moduleInfo, remoteSnapshot, host } = args;
-      if (typeof id === 'string' && isDataLoaderExpose(id)) {
-        return args;
-      }
-      if (!remoteSnapshot || !id || !('modules' in remoteSnapshot)) {
-        return args;
-      }
-
-      const { name, alias } = moduleInfo;
-      const dataFetchInfo = getDataFetchInfo({
-        name,
-        alias,
-        id,
-        remoteSnapshot,
-      });
-      if (!dataFetchInfo) {
-        return args;
-      }
-      const { dataFetchId, dataFetchName } = dataFetchInfo;
-
-      const dataFetchMapKey = getDataFetchMapKey(dataFetchInfo, {
-        name: host.name,
-        version: host.options.version,
-      });
-      logger.debug(
-        '======= auto fetch plugin dataFetchMapKey: ',
-        dataFetchMapKey,
-      );
-
-      if (!dataFetchMapKey) {
-        return args;
-      }
-
-      const dataFetchItem = getDataFetchItem(dataFetchMapKey);
-      if (dataFetchItem) {
-        return args;
-      }
-
-      const dataFetchMap = getDataFetchMap();
-      const hasSSRAsset = Boolean(remoteSnapshot.ssrRemoteEntry);
-      const hasDataFetchClient = Boolean(
-        remoteSnapshot.modules.find(
-          (module) =>
-            module.moduleName === `${dataFetchName}${DATA_FETCH_CLIENT_SUFFIX}`,
-        ),
-      );
-      const downgradeType = hasDataFetchClient
-        ? MF_DATA_FETCH_TYPE.FETCH_CLIENT
-        : hasSSRAsset
-          ? MF_DATA_FETCH_TYPE.FETCH_SERVER
-          : MF_DATA_FETCH_TYPE.FETCH_CLIENT;
-      let finalDataFetchId = dataFetchId;
-
-      if (!isServerEnv()) {
-        finalDataFetchId =
-          downgradeType === MF_DATA_FETCH_TYPE.FETCH_CLIENT
-            ? hasDataFetchClient
-              ? `${dataFetchId}${DATA_FETCH_CLIENT_SUFFIX}`
-              : dataFetchId
-            : dataFetchId;
-      }
-
-      const getDataFetchGetter = () =>
-        loadDataFetchModule(host, finalDataFetchId);
-
-      const dataFetchFnItem: MF_DATA_FETCH_MAP_VALUE[0] = [
-        getDataFetchGetter,
-        downgradeType,
-      ];
-
-      // server client must execute
-      if (typeof window === 'undefined' || isCSROnly()) {
-        dataFetchFnItem.push(getDataFetchGetter());
-      }
-
-      dataFetchMap[dataFetchMapKey] = [
-        dataFetchFnItem,
-        undefined,
-        MF_DATA_FETCH_STATUS.AWAIT,
-      ];
-
-      return args;
-    },
-  };
-};
-
-export default autoFetchData;

package/src/lazy/index.ts

@@ -1,35 +0,0 @@
-import autoFetchDataPlugin from './data-fetch/runtime-plugin';
-
-export { ERROR_TYPE } from './constant';
-export type { DataFetchParams, NoSSRRemoteInfo } from './types';
-export type {
-  CreateLazyComponentOptions,
-  IProps as CollectSSRAssetsOptions,
-} from './createLazyComponent';
-
-export { createLazyComponent, collectSSRAssets } from './createLazyComponent';
-
-// export { wrapNoSSR } from './wrapNoSSR';
-
-export {
-  injectDataFetch,
-  callDataFetch,
-  CacheSize,
-  CacheTime,
-  configureCache,
-  generateKey,
-  cache,
-  revalidateTag,
-  clearStore,
-  prefetch,
-} from './data-fetch';
-
-export { setSSREnv } from './utils';
-
-export { autoFetchDataPlugin };
-
-export type {
-  CacheStatus,
-  CacheStatsInfo,
-  PrefetchOptions,
-} from './data-fetch';

package/src/lazy/logger.ts

@@ -1,6 +0,0 @@
-import { createLogger } from '@module-federation/sdk';
-import { PLUGIN_IDENTIFIER } from './constant';
-
-const logger = createLogger(PLUGIN_IDENTIFIER);
-
-export default logger;

package/src/lazy/types.ts

@@ -1,75 +0,0 @@
-import { MF_DATA_FETCH_TYPE, MF_DATA_FETCH_STATUS } from './constant';
-import type { LRUCache } from 'lru-cache';
-
-export type dataFetchFunctionOptions = [
-  id?: string,
-  data?: unknown,
-  downgrade?: boolean,
-];
-
-declare global {
-  var _mfSSRDowngrade: string[] | true | undefined;
-  var __MF_DATA_FETCH_MAP__: MF_DATA_FETCH_MAP | undefined;
-  var FEDERATION_SERVER_QUERY: Record<string, unknown> | undefined;
-  var FEDERATION_SSR: boolean | undefined;
-  var _mfFSHref: string | undefined;
-  var _mfDataFetch: Array<dataFetchFunctionOptions> | undefined;
-  var __MF_DATA_FETCH_CACHE__: MF_DATA_FETCH_CACHE | undefined;
-}
-
-export interface CacheItem<T> {
-  data: T;
-  timestamp: number;
-  isRevalidating?: boolean;
-}
-
-export type DataFetchParams = {
-  isDowngrade: boolean;
-  _id?: string;
-} & Record<string, unknown>;
-export type DataFetch<T> = (params: DataFetchParams) => Promise<T>;
-
-// loading, resolve, reject
-export type MF_DATA_FETCH_MAP_VALUE_PROMISE_SET = [
-  Promise<unknown>,
-  ((data: unknown) => void)?,
-  ((err: unknown) => void)?,
-];
-export type MF_DATA_FETCH_MAP_VALUE = [
-  [
-    // getDataFetchGetter
-    () => Promise<DataFetch<unknown>>,
-    // data fetch type
-    MF_DATA_FETCH_TYPE,
-    // getDataFetchPromise
-    Promise<DataFetch<unknown>>?,
-  ],
-  MF_DATA_FETCH_MAP_VALUE_PROMISE_SET?,
-  MF_DATA_FETCH_STATUS?,
-];
-export type MF_DATA_FETCH_MAP = Record<string, MF_DATA_FETCH_MAP_VALUE>;
-export type MF_SSR_DOWNGRADE = string[] | true | undefined;
-
-export type NoSSRRemoteInfo = {
-  name: string;
-  version: string;
-  ssrPublicPath: string;
-  ssrRemoteEntry: string;
-  globalName: string;
-};
-
-export interface CacheConfig {
-  maxSize?: number;
-  unstable_shouldDisable?: ({
-    request,
-  }: {
-    request: Request;
-  }) => boolean | Promise<boolean>;
-}
-
-// key is the id, default is the same with dataFetchMapId, but it can be custom by passing dataFetchParams.id
-export type MF_DATA_FETCH_CACHE = {
-  cacheStore?: LRUCache<string, Map<string, CacheItem<any>>>;
-  tagKeyMap?: Map<string, Set<string>>;
-  cacheConfig?: CacheConfig;
-};

package/src/lazy/utils.ts

@@ -1,372 +0,0 @@
-import { isBrowserEnv, composeKeyWithSeparator } from '@module-federation/sdk';
-import logger from './logger';
-import {
-  DOWNGRADE_KEY,
-  MF_DATA_FETCH_STATUS,
-  WRAP_DATA_FETCH_ID_IDENTIFIER,
-  DATA_FETCH_QUERY,
-  MF_DATA_FETCH_TYPE,
-  DATA_FETCH_IDENTIFIER,
-  DATA_FETCH_CLIENT_SUFFIX,
-} from './constant';
-
-import type { GlobalModuleInfo } from '@module-federation/sdk';
-import type {
-  DataFetchParams,
-  MF_DATA_FETCH_MAP,
-  NoSSRRemoteInfo,
-  MF_SSR_DOWNGRADE,
-  MF_DATA_FETCH_MAP_VALUE_PROMISE_SET,
-  MF_DATA_FETCH_CACHE,
-} from './types';
-import type { FederationHost } from '@module-federation/runtime';
-import { clearStore } from './data-fetch/cache';
-
-export const getDataFetchInfo = ({
-  name,
-  alias,
-  id,
-  remoteSnapshot,
-}: {
-  id: string;
-  name: string;
-  remoteSnapshot: GlobalModuleInfo[string];
-  alias?: string;
-}) => {
-  if (!remoteSnapshot) {
-    return;
-  }
-  if (!('modules' in remoteSnapshot)) {
-    return;
-  }
-  const regex = new RegExp(`^${name}(/[^/].*|)$`);
-  const nameOrAlias = regex.test(id) ? name : alias || name;
-
-  const expose = id.replace(nameOrAlias, '');
-  let dataFetchName = '';
-  let dataFetchId = '';
-  let dataFetchKey = '';
-  if (expose.startsWith('/')) {
-    dataFetchName = `${expose.slice(1)}.${DATA_FETCH_IDENTIFIER}`;
-    dataFetchId = `${id}.${DATA_FETCH_IDENTIFIER}`;
-    dataFetchKey = `${name}${expose}.${DATA_FETCH_IDENTIFIER}`;
-  } else if (expose === '') {
-    dataFetchName = DATA_FETCH_IDENTIFIER;
-    dataFetchId = `${id}/${DATA_FETCH_IDENTIFIER}`;
-    dataFetchKey = `${name}/${DATA_FETCH_IDENTIFIER}`;
-  } else {
-    return;
-  }
-
-  if (!dataFetchName || !dataFetchId || !dataFetchKey) {
-    return;
-  }
-
-  if (
-    !remoteSnapshot.modules.find(
-      (module) => module.moduleName === dataFetchName,
-    )
-  ) {
-    return;
-  }
-
-  return {
-    dataFetchName,
-    dataFetchId,
-    dataFetchKey,
-  };
-};
-
-export function initDataFetchMap() {
-  globalThis.__MF_DATA_FETCH_MAP__ ||= {};
-}
-
-export function getDataFetchItem(id: string) {
-  return (globalThis.__MF_DATA_FETCH_MAP__ as MF_DATA_FETCH_MAP)?.[id];
-}
-
-export function getDataFetchMap() {
-  return globalThis.__MF_DATA_FETCH_MAP__ as MF_DATA_FETCH_MAP;
-}
-
-export function getDataFetchCache() {
-  return globalThis.__MF_DATA_FETCH_CACHE__ as MF_DATA_FETCH_CACHE;
-}
-
-export const flushDataFetch = () => {
-  globalThis.__MF_DATA_FETCH_MAP__ = {};
-  globalThis[DOWNGRADE_KEY] = undefined;
-  clearStore();
-};
-
-export function setDataFetchItemLoadedStatus(id: string) {
-  const dataFetchItem = getDataFetchItem(id);
-  if (!dataFetchItem) {
-    return;
-  }
-  dataFetchItem[2] = MF_DATA_FETCH_STATUS.LOADED;
-}
-
-export const wrapDataFetchId = (id?: string) => {
-  return `${WRAP_DATA_FETCH_ID_IDENTIFIER}${id}${WRAP_DATA_FETCH_ID_IDENTIFIER}`;
-};
-
-export const getDataFetchIdWithErrorMsgs = (errMsgs: string) => {
-  const firstIdentifierIndex = errMsgs.indexOf(WRAP_DATA_FETCH_ID_IDENTIFIER);
-  if (firstIdentifierIndex === -1) {
-    return undefined;
-  }
-
-  const secondIdentifierIndex = errMsgs.indexOf(
-    WRAP_DATA_FETCH_ID_IDENTIFIER,
-    firstIdentifierIndex + WRAP_DATA_FETCH_ID_IDENTIFIER.length,
-  );
-
-  if (secondIdentifierIndex === -1) {
-    return undefined;
-  }
-
-  return errMsgs.substring(
-    firstIdentifierIndex + WRAP_DATA_FETCH_ID_IDENTIFIER.length,
-    secondIdentifierIndex,
-  );
-};
-
-export async function fetchData(
-  id: string,
-  params: DataFetchParams,
-  remoteInfo?: NoSSRRemoteInfo,
-): Promise<unknown | undefined> {
-  const callFetchData = async () => {
-    const item = getDataFetchItem(id);
-    if (!item) {
-      return;
-    }
-    const [fetchDataFnArr, ..._rest] = item;
-
-    const fetchDataFn = await fetchDataFnArr[2];
-    if (!fetchDataFn) {
-      return;
-    }
-    return fetchDataFn({
-      ...params,
-      _id: id,
-    });
-  };
-  if (isBrowserEnv()) {
-    const dataFetchItem = getDataFetchItem(id);
-    if (!dataFetchItem) {
-      throw new Error(`dataFetchItem not found, id: ${id}`);
-    }
-    if (dataFetchItem[1]?.[0]) {
-      return dataFetchItem[1][0];
-    }
-
-    if (isCSROnly()) {
-      logger.debug('==========csr only!');
-      return callFetchData();
-    }
-
-    if (remoteInfo) {
-      return callDowngrade(id, params, remoteInfo);
-    }
-
-    const mfDowngrade = getDowngradeTag();
-    if (
-      mfDowngrade &&
-      (typeof mfDowngrade === 'boolean' || mfDowngrade.includes(id))
-    ) {
-      return callDowngrade(id, { ...params, isDowngrade: true });
-    }
-
-    let res;
-    let rej;
-    const p = new Promise((resolve, reject) => {
-      res = resolve;
-      rej = reject;
-    });
-    dataFetchItem[1] = [p, res, rej];
-    dataFetchItem[2] = MF_DATA_FETCH_STATUS.AWAIT;
-    return dataFetchItem[1][0];
-  }
-
-  return callFetchData();
-}
-
-export function getDataFetchMapKey(
-  dataFetchInfo?: ReturnType<typeof getDataFetchInfo>,
-  hostInfo?: { name: string; version?: string },
-) {
-  if (!dataFetchInfo || !hostInfo) {
-    return;
-  }
-
-  const { dataFetchKey } = dataFetchInfo;
-
-  return composeKeyWithSeparator(dataFetchKey, hostInfo.name, hostInfo.version);
-}
-
-export async function loadDataFetchModule(
-  instance: FederationHost,
-  id: string,
-) {
-  return instance.loadRemote(id).then((m) => {
-    if (
-      m &&
-      typeof m === 'object' &&
-      'fetchData' in m &&
-      typeof m.fetchData === 'function'
-    ) {
-      return m.fetchData as (params: DataFetchParams) => Promise<unknown>;
-    }
-    throw new Error(
-      `fetchData not found in remote ${id}, ${JSON.stringify(m)}`,
-    );
-  });
-}
-
-export function isDataLoaderExpose(exposeKey: string) {
-  return (
-    exposeKey.endsWith(DATA_FETCH_IDENTIFIER) ||
-    exposeKey.endsWith(DATA_FETCH_CLIENT_SUFFIX)
-  );
-}
-
-export function getDowngradeTag() {
-  return globalThis[DOWNGRADE_KEY] as MF_SSR_DOWNGRADE;
-}
-
-export function callAllDowngrade() {
-  const dataFetchMap = getDataFetchMap();
-  if (!dataFetchMap) {
-    return;
-  }
-  Object.keys(dataFetchMap).forEach((key) => {
-    callDowngrade(key);
-  });
-}
-
-export async function callDowngrade(
-  id: string,
-  params?: DataFetchParams,
-  remoteInfo?: NoSSRRemoteInfo,
-) {
-  const dataFetchMap = getDataFetchMap();
-  if (!dataFetchMap) {
-    return;
-  }
-  const mfDataFetch = dataFetchMap[id];
-  if (mfDataFetch?.[2] === MF_DATA_FETCH_STATUS.AWAIT) {
-    mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADING;
-    let promise: MF_DATA_FETCH_MAP_VALUE_PROMISE_SET[0];
-    let res: MF_DATA_FETCH_MAP_VALUE_PROMISE_SET[1];
-    let rej: MF_DATA_FETCH_MAP_VALUE_PROMISE_SET[2];
-    if (mfDataFetch[1]) {
-      promise = mfDataFetch[1][0];
-      res = mfDataFetch[1][1];
-      rej = mfDataFetch[1][2];
-    } else {
-      promise = new Promise((resolve, reject) => {
-        res = resolve;
-        rej = reject;
-      });
-      mfDataFetch[1] = [promise, res, rej];
-    }
-    const dataFetchType = mfDataFetch[0][1];
-    if (dataFetchType === MF_DATA_FETCH_TYPE.FETCH_CLIENT) {
-      try {
-        mfDataFetch[0][0]().then(async (getDataFetchFn) => {
-          return getDataFetchFn({
-            ...params,
-            isDowngrade: true,
-            _id: id,
-          }).then((data) => {
-            mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
-            res && res(data);
-          });
-        });
-      } catch (e) {
-        mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
-        rej && rej(e);
-      }
-    } else if (dataFetchType === MF_DATA_FETCH_TYPE.FETCH_SERVER) {
-      try {
-        const currentUrl = new URL(window.location.href);
-        currentUrl.searchParams.set(DATA_FETCH_QUERY, encodeURIComponent(id));
-        if (params) {
-          currentUrl.searchParams.set(
-            'params',
-            encodeURIComponent(JSON.stringify(params)),
-          );
-        }
-        if (remoteInfo) {
-          currentUrl.searchParams.set(
-            'remoteInfo',
-            encodeURIComponent(JSON.stringify(remoteInfo)),
-          );
-        }
-        const fetchServerQuery = globalThis.FEDERATION_SERVER_QUERY;
-        if (fetchServerQuery && typeof fetchServerQuery === 'object') {
-          Object.keys(fetchServerQuery).forEach((key) => {
-            currentUrl.searchParams.set(
-              key,
-              JSON.stringify(fetchServerQuery[key]),
-            );
-          });
-        }
-        const fetchUrl = currentUrl.toString();
-        const data = await fetch(fetchUrl).then((res) => res.json());
-        mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
-        res && res(data);
-      } catch (e) {
-        mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
-        rej && rej(e);
-      }
-    }
-
-    return promise;
-  }
-}
-
-export function isCSROnly() {
-  // @ts-ignore  modern.js will inject window._SSR_DATA if enable ssr
-  return window._SSR_DATA === undefined;
-}
-
-export function isServerEnv() {
-  return typeof window === 'undefined';
-}
-
-export function setSSREnv({
-  fetchServerQuery,
-}: {
-  fetchServerQuery?: Record<string, unknown>;
-}) {
-  globalThis.FEDERATION_SSR = true;
-  globalThis.FEDERATION_SERVER_QUERY = fetchServerQuery;
-}
-
-export function getLoadedRemoteInfos(
-  id: string,
-  instance: FederationHost | null,
-) {
-  if (!instance) {
-    return;
-  }
-  const { name, expose } = instance.remoteHandler.idToRemoteMap[id] || {};
-  if (!name) {
-    return;
-  }
-  const module = instance.moduleCache.get(name);
-  if (!module) {
-    return;
-  }
-  const { remoteSnapshot } = instance.snapshotHandler.getGlobalRemoteInfo(
-    module.remoteInfo,
-  );
-  return {
-    ...module.remoteInfo,
-    snapshot: remoteSnapshot,
-    expose,
-  };
-}