@module-federation/data-prefetch 0.0.0-next-20241231075249 → 0.0.0-next-20250106035038

package/src/prefetch.ts

@@ -1,216 +0,0 @@
-import {
-  FederationHost,
-  getRemoteEntry,
-  getRemoteInfo,
-} from '@module-federation/runtime';
-import {
-  loadScript,
-  ModuleInfo,
-  ProviderModuleInfo,
-} from '@module-federation/sdk';
-import { Remote } from '@module-federation/runtime/types';
-import type { Federation } from '@module-federation/runtime';
-import { getPrefetchId, compatGetPrefetchId } from './common/runtime-utils';
-
-// Define an interface that extends Federation to include __PREFETCH__
-interface FederationWithPrefetch extends Federation {
-  __PREFETCH__: {
-    entryLoading: Record<string, undefined | Promise<void>>;
-    instance: Map<string, MFDataPrefetch>;
-    __PREFETCH_EXPORTS__: Record<string, () => Promise<Record<string, any>>>;
-  };
-}
-
-type PrefetchExports = Record<string, any>;
-
-export interface DataPrefetchOptions {
-  name: string;
-  remote?: Remote;
-  origin?: FederationHost;
-  remoteSnapshot?: ModuleInfo;
-}
-
-export interface prefetchOptions {
-  id: string;
-  functionId?: string;
-  cacheStrategy?: () => boolean;
-  refetchParams?: any;
-}
-
-// @ts-ignore init global variable for test
-globalThis.__FEDERATION__ ??= {};
-(
-  globalThis.__FEDERATION__ as unknown as FederationWithPrefetch
-).__PREFETCH__ ??= {
-  entryLoading: {},
-  instance: new Map(),
-  __PREFETCH_EXPORTS__: {},
-} as FederationWithPrefetch['__PREFETCH__'];
-export class MFDataPrefetch {
-  public prefetchMemory: Map<string, Promise<any>>;
-  public recordOutdate: Record<string, Record<string, boolean>>;
-  private _exports: Record<string, any>;
-  private _options: DataPrefetchOptions;
-
-  constructor(options: DataPrefetchOptions) {
-    this.prefetchMemory = new Map();
-    this.recordOutdate = {};
-    this._exports = {};
-    this._options = options;
-    this.global.instance.set(options.name, this);
-  }
-
-  get global(): FederationWithPrefetch['__PREFETCH__'] {
-    return (globalThis.__FEDERATION__ as unknown as FederationWithPrefetch)
-      .__PREFETCH__;
-  }
-
-  static getInstance(id: string): MFDataPrefetch | undefined {
-    return (
-      globalThis.__FEDERATION__ as unknown as FederationWithPrefetch
-    ).__PREFETCH__.instance.get(id);
-  }
-
-  async loadEntry(entry: string | undefined): Promise<any> {
-    const { name, remoteSnapshot, remote, origin } = this._options;
-
-    if (entry) {
-      const { buildVersion, globalName } = remoteSnapshot as ProviderModuleInfo;
-      const uniqueKey = globalName || `${name}:${buildVersion}`;
-
-      if (!this.global.entryLoading[uniqueKey]) {
-        this.global.entryLoading[uniqueKey] = loadScript(entry, {});
-      }
-      return this.global.entryLoading[uniqueKey];
-    } else {
-      const remoteInfo = getRemoteInfo(remote as Remote);
-      const module = origin!.moduleCache.get(remoteInfo.name);
-      return getRemoteEntry({
-        origin: origin!,
-        remoteInfo,
-        remoteEntryExports: module ? module.remoteEntryExports : undefined,
-      });
-    }
-  }
-
-  getProjectExports() {
-    if (Object.keys(this._exports).length > 0) {
-      return this._exports;
-    }
-    const { name } = this._options;
-    const exportsPromiseFn = (
-      globalThis.__FEDERATION__ as unknown as FederationWithPrefetch
-    ).__PREFETCH__.__PREFETCH_EXPORTS__?.[name];
-    const exportsPromise =
-      typeof exportsPromiseFn === 'function'
-        ? exportsPromiseFn()
-        : exportsPromiseFn;
-    const resolve = exportsPromise.then(
-      (exports: Record<string, Record<string, any>> = {}) => {
-        // Match prefetch based on the function name suffix so that other capabilities can be expanded later.
-        // Not all functions should be directly identified as prefetch functions
-        const memory: Record<string, Record<string, any>> = {};
-        Object.keys(exports).forEach((key) => {
-          memory[key] = {};
-          const exportVal = exports[key];
-          Object.keys(exportVal).reduce(
-            (memo: Record<string, any>, current: string) => {
-              if (
-                current.toLocaleLowerCase().endsWith('prefetch') ||
-                current.toLocaleLowerCase() === 'default'
-              ) {
-                memo[current] = exportVal[current];
-              }
-              return memo;
-            },
-            memory[key],
-          );
-        });
-        this.memorizeExports(memory);
-      },
-    );
-    return resolve;
-  }
-
-  memorizeExports(exports: Record<string, any>): void {
-    this._exports = exports;
-  }
-
-  getExposeExports(id: string): PrefetchExports {
-    const prefetchId = getPrefetchId(id);
-    const compatId = compatGetPrefetchId(id);
-    const prefetchExports =
-      this._exports[prefetchId] || (this._exports[compatId] as PrefetchExports);
-    return prefetchExports || {};
-  }
-
-  prefetch(prefetchOptions: prefetchOptions): any {
-    const { id, functionId = 'default', refetchParams } = prefetchOptions;
-    let prefetchResult;
-    const prefetchId = getPrefetchId(id);
-    const compatId = compatGetPrefetchId(id);
-    const memorizeId = id + functionId;
-    const memory = this.prefetchMemory.get(memorizeId);
-    if (!this.checkOutdate(prefetchOptions) && memory) {
-      return memory;
-    }
-
-    const prefetchExports =
-      this._exports[prefetchId] || (this._exports[compatId] as PrefetchExports);
-    if (!prefetchExports) {
-      return;
-    }
-    const executePrefetch = prefetchExports[functionId];
-    if (typeof executePrefetch === 'function') {
-      if (refetchParams) {
-        prefetchResult = executePrefetch(refetchParams);
-      } else {
-        prefetchResult = executePrefetch();
-      }
-    } else {
-      throw new Error(
-        `[Module Federation Data Prefetch]: No prefetch function called ${functionId} export in prefetch file`,
-      );
-    }
-    this.memorize(memorizeId, prefetchResult);
-    return prefetchResult;
-  }
-
-  memorize(id: string, value: any): void {
-    this.prefetchMemory.set(id, value);
-  }
-
-  markOutdate(
-    markOptions: Omit<prefetchOptions, 'cacheStrategy'>,
-    isOutdate: boolean,
-  ): void {
-    const { id, functionId = 'default' } = markOptions;
-    if (!this.recordOutdate[id]) {
-      this.recordOutdate[id] = {};
-    }
-    this.recordOutdate[id][functionId] = isOutdate;
-  }
-
-  checkOutdate(outdateOptions: prefetchOptions): boolean {
-    const { id, functionId = 'default', cacheStrategy } = outdateOptions;
-    if (typeof cacheStrategy === 'function') {
-      return cacheStrategy();
-    }
-
-    if (!this.recordOutdate[id]) {
-      this.recordOutdate[id] = {};
-    }
-    if (this.recordOutdate[id][functionId]) {
-      this.markOutdate(
-        {
-          id,
-          functionId,
-        },
-        false,
-      );
-      return true;
-    } else {
-      return false;
-    }
-  }
-}

package/src/react/hooks.ts

@@ -1,95 +0,0 @@
-import { useEffect, useState } from 'react';
-import type { defer } from 'react-router';
-
-import logger from '../logger';
-import { MFDataPrefetch, type prefetchOptions } from '../prefetch';
-import { prefetch } from '../universal';
-import { getScope } from '../common/runtime-utils';
-import { useFirstMounted } from './utils';
-
-type refetchParams = any;
-type DeferredData = ReturnType<typeof defer>;
-type prefetchReturnType<T> = [
-  Promise<T>,
-  (refetchParams?: refetchParams) => void,
-];
-
-type UsePrefetchOptions = prefetchOptions & {
-  deferId?: string;
-};
-
-export const usePrefetch = <T>(
-  options: UsePrefetchOptions,
-): prefetchReturnType<T> => {
-  const isFirstMounted = useFirstMounted();
-  if (isFirstMounted) {
-    const startTiming = performance.now();
-    logger.info(
-      `2. Start Get Prefetch Data: ${options.id} - ${
-        options.functionId || 'default'
-      } - ${startTiming}`,
-    );
-  }
-  const { id, functionId, deferId } = options;
-  const prefetchInfo = {
-    id,
-    functionId,
-  };
-  const mfScope = getScope();
-
-  let state;
-  const prefetchResult = prefetch(options);
-  if (deferId) {
-    if (prefetchResult instanceof Promise) {
-      state = (prefetchResult as Promise<DeferredData>).then(
-        (deferredData) => deferredData.data[deferId],
-      );
-    } else {
-      state = (prefetchResult as DeferredData).data[deferId];
-    }
-  } else {
-    state = prefetchResult;
-  }
-  const [prefetchState, setPrefetchState] = useState<Promise<T>>(
-    state as Promise<T>,
-  );
-  const prefetchInstance = MFDataPrefetch.getInstance(mfScope);
-
-  useEffect(() => {
-    const useEffectTiming = performance.now();
-    logger.info(
-      `3. Start Execute UseEffect: ${options.id} - ${
-        options.functionId || 'default'
-      } - ${useEffectTiming}`,
-    );
-
-    return () => {
-      prefetchInstance?.markOutdate(prefetchInfo, true);
-    };
-  }, []);
-
-  const refreshExecutor = (refetchParams?: refetchParams) => {
-    const refetchOptions = {
-      ...options,
-    };
-    if (refetchParams) {
-      refetchOptions.refetchParams = refetchParams;
-    }
-    prefetchInstance?.markOutdate(prefetchInfo, true);
-    const newVal = prefetch(refetchOptions) as Promise<DeferredData>;
-    let newState;
-    if (deferId) {
-      if (newVal instanceof Promise) {
-        newState = newVal.then((deferredData) => deferredData.data[deferId]);
-      } else {
-        newState = (newVal as DeferredData).data[deferId];
-      }
-    } else {
-      newState = newVal;
-    }
-
-    setPrefetchState(newState as Promise<T>);
-  };
-
-  return [prefetchState, refreshExecutor];
-};

package/src/react/index.ts

@@ -1 +0,0 @@
-export * from './hooks';

package/src/react/utils.ts

@@ -1,11 +0,0 @@
-import { useEffect, useRef } from 'react';
-
-export const useFirstMounted = (): boolean => {
-  const ref = useRef(true);
-
-  useEffect(() => {
-    ref.current = false;
-  }, []);
-
-  return ref.current;
-};

package/src/universal/index.ts

@@ -1,27 +0,0 @@
-import { MFDataPrefetch, type prefetchOptions } from '../prefetch';
-import { getScope } from '../common/runtime-utils';
-
-export function prefetch(options: prefetchOptions): Promise<any> {
-  const { id, functionId = 'default' } = options;
-  const mfScope = getScope();
-
-  const prefetchInstance =
-    MFDataPrefetch.getInstance(mfScope) ||
-    new MFDataPrefetch({
-      name: mfScope,
-    });
-
-  const res = prefetchInstance.getProjectExports();
-  if (res instanceof Promise) {
-    const promise = res.then(() => {
-      const result = prefetchInstance!.prefetch(options);
-      prefetchInstance.memorize(id + functionId, result);
-      return result;
-    });
-    return promise;
-  } else {
-    const result = prefetchInstance!.prefetch(options);
-    prefetchInstance.memorize(id + functionId, result);
-    return result;
-  }
-}

package/tsconfig.json

@@ -1,27 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "rootDir": "./",
-    "outDir": "dist",
-    "sourceMap": false,
-    "module": "commonjs",
-    "target": "ES2015",
-    "skipLibCheck": true,
-    "moduleResolution": "node",
-    "allowJs": false,
-    "strict": true,
-    "types": ["jest", "node"],
-    "experimentalDecorators": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "removeComments": true,
-    "declaration": true,
-    "paths": {
-      "@/*": ["./*"],
-      "@src/*": ["./src/*"]
-    }
-  },
-  "include": ["src", "../../global.d.ts", "__tests__/**/*"],
-  "exclude": ["node_modules/**/*", "../node_modules"]
-}

package/tsconfig.lib.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
-}