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

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

@@ -1,296 +0,0 @@
-import { LRUCache } from 'lru-cache';
-import { getDataFetchCache } from '../utils';
-
-import type {
-  CacheConfig,
-  CacheItem,
-  DataFetch,
-  DataFetchParams,
-} from '../types';
-
-export const CacheSize = {
-  KB: 1024,
-  MB: 1024 * 1024,
-  GB: 1024 * 1024 * 1024,
-} as const;
-
-export const CacheTime = {
-  SECOND: 1000,
-  MINUTE: 60 * 1000,
-  HOUR: 60 * 60 * 1000,
-  DAY: 24 * 60 * 60 * 1000,
-  WEEK: 7 * 24 * 60 * 60 * 1000,
-  MONTH: 30 * 24 * 60 * 60 * 1000,
-} as const;
-
-export type CacheStatus = 'hit' | 'stale' | 'miss';
-
-export interface CacheStatsInfo {
-  status: CacheStatus;
-  key: string | symbol;
-  params: DataFetchParams;
-  result: any;
-}
-
-interface CacheOptions {
-  tag?: string | string[];
-  maxAge?: number;
-  revalidate?: number;
-  getKey?: <Args extends any[]>(...args: Args) => string;
-  customKey?: <Args extends any[]>(options: {
-    params: Args;
-    fn: (...args: Args) => any;
-    generatedKey: string;
-  }) => string | symbol;
-  onCache?: (info: CacheStatsInfo) => boolean;
-}
-
-function getTagKeyMap() {
-  const dataFetchCache = getDataFetchCache();
-  if (!dataFetchCache || !dataFetchCache.tagKeyMap) {
-    const tagKeyMap = new Map<string, Set<string>>();
-    globalThis.__MF_DATA_FETCH_CACHE__ ||= {};
-    globalThis.__MF_DATA_FETCH_CACHE__.tagKeyMap = tagKeyMap;
-    return tagKeyMap;
-  }
-  return dataFetchCache.tagKeyMap;
-}
-
-function addTagKeyRelation(tag: string, key: string) {
-  const tagKeyMap = getTagKeyMap();
-  let keys = tagKeyMap.get(tag);
-  if (!keys) {
-    keys = new Set();
-    tagKeyMap.set(tag, keys);
-  }
-  keys.add(key);
-}
-
-function getCacheConfig() {
-  const dataFetchCache = getDataFetchCache();
-  if (!dataFetchCache || !dataFetchCache.cacheConfig) {
-    const cacheConfig: CacheConfig = {
-      maxSize: CacheSize.GB,
-    };
-    globalThis.__MF_DATA_FETCH_CACHE__ ||= {};
-    globalThis.__MF_DATA_FETCH_CACHE__.cacheConfig = cacheConfig;
-    return cacheConfig;
-  }
-  return dataFetchCache.cacheConfig;
-}
-
-export function configureCache(config: CacheConfig): void {
-  const cacheConfig = getCacheConfig();
-  Object.assign(cacheConfig, config);
-}
-
-function getLRUCache() {
-  const dataFetchCache = getDataFetchCache();
-  const cacheConfig = getCacheConfig();
-
-  if (!dataFetchCache || !dataFetchCache.cacheStore) {
-    const cacheStore = new LRUCache<string, Map<string, CacheItem<any>>>({
-      maxSize: cacheConfig.maxSize ?? CacheSize.GB,
-      sizeCalculation: (value: Map<string, CacheItem<any>>): number => {
-        if (!value.size) {
-          return 1;
-        }
-
-        let size = 0;
-        for (const [k, item] of value.entries()) {
-          size += k.length * 2;
-          size += estimateObjectSize(item.data);
-          size += 8;
-        }
-        return size;
-      },
-      updateAgeOnGet: true,
-      updateAgeOnHas: true,
-    });
-    globalThis.__MF_DATA_FETCH_CACHE__ ||= {};
-    globalThis.__MF_DATA_FETCH_CACHE__.cacheStore = cacheStore;
-    return cacheStore;
-  }
-
-  return dataFetchCache.cacheStore;
-}
-
-function estimateObjectSize(data: unknown): number {
-  const type = typeof data;
-
-  if (type === 'number') return 8;
-  if (type === 'boolean') return 4;
-  if (type === 'string') return Math.max((data as string).length * 2, 1);
-  if (data === null || data === undefined) return 1;
-
-  if (ArrayBuffer.isView(data)) {
-    return Math.max(data.byteLength, 1);
-  }
-
-  if (Array.isArray(data)) {
-    return Math.max(
-      data.reduce((acc, item) => acc + estimateObjectSize(item), 0),
-      1,
-    );
-  }
-
-  if (data instanceof Map || data instanceof Set) {
-    return 1024;
-  }
-
-  if (data instanceof Date) {
-    return 8;
-  }
-
-  if (type === 'object') {
-    return Math.max(
-      Object.entries(data).reduce(
-        (acc, [key, value]) => acc + key.length * 2 + estimateObjectSize(value),
-        0,
-      ),
-      1,
-    );
-  }
-
-  return 1;
-}
-
-export function generateKey(dataFetchOptions: DataFetchParams): string {
-  return JSON.stringify(dataFetchOptions, (_, value) => {
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-      return Object.keys(value)
-        .sort()
-        .reduce((result: Record<string, unknown>, key) => {
-          result[key] = value[key];
-          return result;
-        }, {});
-    }
-    return value;
-  });
-}
-
-export function cache<T>(
-  fn: DataFetch<T>,
-  options?: CacheOptions,
-): DataFetch<T> {
-  const {
-    tag = 'default',
-    maxAge = CacheTime.MINUTE * 5,
-    revalidate = 0,
-    onCache,
-    getKey,
-  } = options || {};
-
-  const tags = Array.isArray(tag) ? tag : [tag];
-
-  return async (dataFetchOptions) => {
-    // if downgrade, skip cache
-    if (dataFetchOptions.isDowngrade || !dataFetchOptions._id) {
-      return fn(dataFetchOptions);
-    }
-    const store = getLRUCache();
-
-    const now = Date.now();
-    const storeKey = dataFetchOptions._id;
-    const cacheKey = getKey
-      ? getKey(dataFetchOptions)
-      : generateKey(dataFetchOptions);
-
-    tags.forEach((t) => addTagKeyRelation(t, cacheKey));
-
-    let cacheStore = store.get(cacheKey);
-    if (!cacheStore) {
-      cacheStore = new Map();
-    }
-
-    const cached = cacheStore.get(storeKey);
-    if (cached) {
-      const age = now - cached.timestamp;
-
-      if (age < maxAge) {
-        if (onCache) {
-          const useCache = onCache({
-            status: 'hit',
-            key: cacheKey,
-            params: dataFetchOptions,
-            result: cached.data,
-          });
-          if (!useCache) {
-            return fn(dataFetchOptions);
-          }
-        }
-        return cached.data;
-      }
-
-      if (revalidate > 0 && age < maxAge + revalidate) {
-        if (onCache) {
-          onCache({
-            status: 'stale',
-            key: cacheKey,
-            params: dataFetchOptions,
-            result: cached.data,
-          });
-        }
-
-        if (!cached.isRevalidating) {
-          cached.isRevalidating = true;
-          Promise.resolve().then(async () => {
-            try {
-              const newData = await fn(dataFetchOptions);
-              cacheStore!.set(storeKey, {
-                data: newData,
-                timestamp: Date.now(),
-                isRevalidating: false,
-              });
-
-              store.set(cacheKey, cacheStore!);
-            } catch (error) {
-              cached.isRevalidating = false;
-              console.error('Background revalidation failed:', error);
-            }
-          });
-        }
-        return cached.data;
-      }
-    }
-
-    const data = await fn(dataFetchOptions);
-    cacheStore.set(storeKey, {
-      data,
-      timestamp: now,
-      isRevalidating: false,
-    });
-    store.set(cacheKey, cacheStore);
-
-    if (onCache) {
-      onCache({
-        status: 'miss',
-        key: cacheKey,
-        params: dataFetchOptions,
-        result: data,
-      });
-    }
-
-    return data;
-  };
-}
-
-export function revalidateTag(tag: string): void {
-  const tagKeyMap = getTagKeyMap();
-  const keys = tagKeyMap.get(tag);
-  const lruCache = getLRUCache();
-  if (keys) {
-    keys.forEach((key) => {
-      lruCache?.delete(key);
-    });
-  }
-}
-
-export function clearStore(): void {
-  const lruCache = getLRUCache();
-  const tagKeyMap = getTagKeyMap();
-
-  lruCache?.clear();
-  delete globalThis.__MF_DATA_FETCH_CACHE__?.cacheStore;
-  tagKeyMap.clear();
-}

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

@@ -1,13 +0,0 @@
-import { DATA_FETCH_FUNCTION } from '../constant';
-import { dataFetchFunction } from './inject-data-fetch';
-
-export async function callDataFetch() {
-  const dataFetch = globalThis[DATA_FETCH_FUNCTION];
-  if (dataFetch) {
-    await Promise.all(
-      dataFetch.map(async (options) => {
-        await dataFetchFunction(options);
-      }),
-    );
-  }
-}

package/src/lazy/data-fetch/data-fetch-server-middleware.ts

@@ -1,196 +0,0 @@
-import { DATA_FETCH_QUERY, MF_DATA_FETCH_STATUS } from '../constant';
-import {
-  getDataFetchMap,
-  fetchData,
-  initDataFetchMap,
-  loadDataFetchModule,
-} from '../utils';
-import { SEPARATOR, MANIFEST_EXT } from '@module-federation/sdk';
-import logger from '../logger';
-
-import type { NoSSRRemoteInfo } from '../types';
-import type { MiddlewareHandler } from 'hono';
-
-function wrapSetTimeout(
-  targetPromise: Promise<unknown>,
-  delay = 20000,
-  id: string,
-) {
-  if (targetPromise && typeof targetPromise.then === 'function') {
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        logger.warn(`Data fetch for ID ${id} timed out after 20 seconds.`);
-        reject(new Error(`Data fetch for ID ${id} timed out after 20 seconds`));
-      }, delay);
-
-      targetPromise
-        .then((value: any) => {
-          clearTimeout(timeoutId);
-          resolve(value);
-        })
-        .catch((err: any) => {
-          clearTimeout(timeoutId);
-          reject(err);
-        });
-    });
-  }
-}
-
-function addProtocol(url: string) {
-  if (url.startsWith('//')) {
-    return 'https:' + url;
-  }
-  return url;
-}
-
-const getDecodeQuery = (url: URL, name: string) => {
-  const res = url.searchParams.get(name);
-  if (!res) {
-    return null;
-  }
-  return decodeURIComponent(res);
-};
-
-const dataFetchServerMiddleware: MiddlewareHandler = async (ctx, next) => {
-  let url: URL;
-  let dataFetchKey: string | null;
-  let params: Record<string, unknown>;
-  let remoteInfo: NoSSRRemoteInfo;
-  try {
-    url = new URL(ctx.req.url);
-    dataFetchKey = getDecodeQuery(url, DATA_FETCH_QUERY);
-    params = JSON.parse(getDecodeQuery(url, 'params') || '{}');
-    const remoteInfoQuery = getDecodeQuery(url, 'remoteInfo');
-    remoteInfo = remoteInfoQuery ? JSON.parse(remoteInfoQuery) : null;
-  } catch (e) {
-    logger.error('fetch data from server, error: ', e);
-    return next();
-  }
-
-  if (!dataFetchKey) {
-    return next();
-  }
-  logger.log('fetch data from server, dataFetchKey: ', dataFetchKey);
-  logger.debug(
-    'fetch data from server, moduleInfo: ',
-    globalThis.__FEDERATION__?.moduleInfo,
-  );
-  try {
-    const dataFetchMap = getDataFetchMap();
-    if (!dataFetchMap) {
-      initDataFetchMap();
-    }
-    const fetchDataPromise = dataFetchMap[dataFetchKey]?.[1];
-    logger.debug(
-      'fetch data from server, fetchDataPromise: ',
-      fetchDataPromise,
-    );
-    if (
-      fetchDataPromise &&
-      dataFetchMap[dataFetchKey]?.[2] !== MF_DATA_FETCH_STATUS.ERROR
-    ) {
-      const targetPromise = fetchDataPromise[0];
-      // Ensure targetPromise is thenable
-      const wrappedPromise = wrapSetTimeout(targetPromise, 20000, dataFetchKey);
-      if (wrappedPromise) {
-        const res = await wrappedPromise;
-        logger.log('fetch data from server, fetchDataPromise res: ', res);
-        return ctx.json(res);
-      }
-      logger.error(
-        `Expected a Promise from fetchDataPromise[0] for dataFetchKey ${dataFetchKey}, but received:`,
-        targetPromise,
-        'Will try call new dataFetch again...',
-      );
-    }
-
-    if (remoteInfo) {
-      try {
-        const hostInstance = globalThis.__FEDERATION__.__INSTANCES__[0];
-        const remoteEntry = `${addProtocol(remoteInfo.ssrPublicPath) + remoteInfo.ssrRemoteEntry}`;
-        if (!hostInstance) {
-          throw new Error('host instance not found!');
-        }
-        const remote = hostInstance.options.remotes.find(
-          (remote) => remote.name === remoteInfo.name,
-        );
-        logger.debug('find remote: ', JSON.stringify(remote));
-        if (!remote) {
-          hostInstance.registerRemotes([
-            {
-              name: remoteInfo.name,
-              entry: remoteEntry,
-              entryGlobalName: remoteInfo.globalName,
-            },
-          ]);
-        } else if (
-          !('entry' in remote) ||
-          !remote.entry.includes(MANIFEST_EXT)
-        ) {
-          const { hostGlobalSnapshot, remoteSnapshot } =
-            hostInstance.snapshotHandler.getGlobalRemoteInfo(remoteInfo);
-          logger.debug(
-            'find hostGlobalSnapshot: ',
-            JSON.stringify(hostGlobalSnapshot),
-          );
-          logger.debug('find remoteSnapshot: ', JSON.stringify(remoteSnapshot));
-
-          if (!hostGlobalSnapshot || !remoteSnapshot) {
-            if ('version' in remote) {
-              // @ts-ignore
-              delete remote.version;
-            }
-            // @ts-ignore
-            remote.entry = remoteEntry;
-            remote.entryGlobalName = remoteInfo.globalName;
-          }
-        }
-      } catch (e) {
-        ctx.status(500);
-        return ctx.text(
-          `failed to fetch ${remoteInfo.name} data, error:\n ${e}`,
-        );
-      }
-    }
-
-    const dataFetchItem = dataFetchMap[dataFetchKey];
-    logger.debug('fetch data from server, dataFetchItem: ', dataFetchItem);
-    if (dataFetchItem) {
-      const callFetchDataPromise = fetchData(dataFetchKey, {
-        ...params,
-        isDowngrade: !remoteInfo,
-        _id: dataFetchKey,
-      });
-      const wrappedPromise = wrapSetTimeout(
-        callFetchDataPromise,
-        20000,
-        dataFetchKey,
-      );
-      if (wrappedPromise) {
-        const res = await wrappedPromise;
-        logger.log('fetch data from server, dataFetchItem res: ', res);
-        return ctx.json(res);
-      }
-    }
-
-    const remoteId = dataFetchKey.split(SEPARATOR)[0];
-    const hostInstance = globalThis.__FEDERATION__.__INSTANCES__[0];
-    if (!hostInstance) {
-      throw new Error('host instance not found!');
-    }
-    const dataFetchFn = await loadDataFetchModule(hostInstance, remoteId);
-    const data = await dataFetchFn({
-      ...params,
-      isDowngrade: !remoteInfo,
-      _id: dataFetchKey,
-    });
-    logger.log('fetch data from server, loadDataFetchModule res: ', data);
-    return ctx.json(data);
-  } catch (e) {
-    logger.error('server plugin data fetch error: ', e);
-    ctx.status(500);
-    return ctx.text(`failed to fetch ${remoteInfo.name} data, error:\n ${e}`);
-  }
-};
-
-export default dataFetchServerMiddleware;

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

@@ -1,16 +0,0 @@
-export { callDataFetch } from './call-data-fetch';
-export { injectDataFetch } from './inject-data-fetch';
-export {
-  CacheSize,
-  CacheTime,
-  configureCache,
-  generateKey,
-  cache,
-  revalidateTag,
-  clearStore,
-} from './cache';
-
-export type { CacheStatus, CacheStatsInfo } from './cache';
-
-export type { PrefetchOptions } from './prefetch';
-export { prefetch } from './prefetch';

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

@@ -1,109 +0,0 @@
-import {
-  DATA_FETCH_FUNCTION,
-  DOWNGRADE_KEY,
-  FS_HREF,
-  MF_DATA_FETCH_STATUS,
-  MF_DATA_FETCH_TYPE,
-} from '../constant';
-import logger from '../logger';
-import {
-  dataFetchFunctionOptions,
-  MF_DATA_FETCH_MAP_VALUE_PROMISE_SET,
-} from '../types';
-import {
-  callAllDowngrade,
-  callDowngrade,
-  getDataFetchItem,
-  getDataFetchMap,
-  getDowngradeTag,
-  initDataFetchMap,
-} from '../utils';
-
-const dataFetchFunction = async function (options: dataFetchFunctionOptions) {
-  const [id, data, downgrade] = options;
-  logger.debug('==========call data fetch function!');
-  if (data) {
-    if (!id) {
-      throw new Error('id is required!');
-    }
-    if (!getDataFetchMap()) {
-      initDataFetchMap();
-    }
-    const dataFetchItem = getDataFetchItem(id);
-    if (dataFetchItem) {
-      dataFetchItem[1]?.[1]?.(data);
-      dataFetchItem[2] = MF_DATA_FETCH_STATUS.LOADED;
-      return;
-    }
-    if (!dataFetchItem) {
-      const dataFetchMap = getDataFetchMap();
-      let res: MF_DATA_FETCH_MAP_VALUE_PROMISE_SET[1];
-      let rej: MF_DATA_FETCH_MAP_VALUE_PROMISE_SET[2];
-      const p = new Promise((resolve, reject) => {
-        res = resolve;
-        rej = reject;
-      });
-
-      dataFetchMap[id] = [
-        [
-          async () => async () => {
-            return '';
-          },
-          MF_DATA_FETCH_TYPE.FETCH_SERVER,
-        ],
-        [p, res, rej],
-        MF_DATA_FETCH_STATUS.LOADED,
-      ];
-      res && res(data);
-      return;
-    }
-  }
-
-  if (downgrade) {
-    const mfDowngrade = getDowngradeTag();
-    if (!mfDowngrade) {
-      globalThis[DOWNGRADE_KEY] = id ? [id] : true;
-    } else if (Array.isArray(mfDowngrade) && id && !mfDowngrade.includes(id)) {
-      mfDowngrade.push(id);
-    }
-  }
-
-  const mfDowngrade = getDowngradeTag();
-
-  if (typeof mfDowngrade === 'boolean') {
-    return callAllDowngrade();
-  }
-  if (Array.isArray(mfDowngrade)) {
-    if (!id) {
-      globalThis[DOWNGRADE_KEY] = true;
-      return callAllDowngrade();
-    }
-
-    if (!mfDowngrade.includes(id)) {
-      mfDowngrade.push(id);
-    }
-
-    return callDowngrade(id);
-  }
-};
-
-export function injectDataFetch() {
-  globalThis[DATA_FETCH_FUNCTION] ||= [];
-  const dataFetch = globalThis[DATA_FETCH_FUNCTION];
-
-  //@ts-ignore
-  if (dataFetch.push === dataFetchFunction) {
-    return;
-  }
-
-  if (typeof window === 'undefined') {
-    return;
-  }
-
-  globalThis[FS_HREF] = window.location.href;
-
-  //@ts-ignore
-  dataFetch.push = dataFetchFunction;
-}
-
-export { dataFetchFunction };