@module-federation/data-prefetch 1.0.16 → 2.0.0

package/dist/universal/index.d.ts

@@ -1,8 +0,0 @@
-import { p as prefetchOptions } from '../prefetch-4e9646e4.js';
-import '@module-federation/runtime';
-import '@module-federation/sdk';
-import '@module-federation/runtime/types';
-
-declare function prefetch(options: prefetchOptions): Promise<any>;
-
-export { prefetch };

package/dist/universal/index.js

@@ -1,204 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/universal/index.ts
-var universal_exports = {};
-__export(universal_exports, {
-  prefetch: () => prefetch
-});
-module.exports = __toCommonJS(universal_exports);
-
-// src/prefetch.ts
-var import_runtime2 = require("@module-federation/runtime");
-var import_sdk2 = require("@module-federation/sdk");
-
-// src/common/runtime-utils.ts
-var import_runtime = require("@module-federation/runtime");
-var import_sdk = require("@module-federation/sdk");
-var getScope = () => {
-  return (0, import_runtime.getInstance)().options.name;
-};
-var getPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/${import_sdk.MFPrefetchCommon.identifier}`);
-var compatGetPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/VmokPrefetch`);
-
-// src/prefetch.ts
-globalThis.__FEDERATION__ ?? (globalThis.__FEDERATION__ = {});
-var _a;
-(_a = globalThis.__FEDERATION__).__PREFETCH__ ?? (_a.__PREFETCH__ = {
-  entryLoading: {},
-  instance: /* @__PURE__ */ new Map(),
-  __PREFETCH_EXPORTS__: {}
-});
-var MFDataPrefetch = class {
-  constructor(options) {
-    this.prefetchMemory = /* @__PURE__ */ new Map();
-    this.recordOutdate = {};
-    this._exports = {};
-    this._options = options;
-    this.global.instance.set(options.name, this);
-  }
-  get global() {
-    return globalThis.__FEDERATION__.__PREFETCH__;
-  }
-  static getInstance(id) {
-    return globalThis.__FEDERATION__.__PREFETCH__.instance.get(id);
-  }
-  async loadEntry(entry) {
-    const { name, remoteSnapshot, remote, origin } = this._options;
-    if (entry) {
-      const { buildVersion, globalName } = remoteSnapshot;
-      const uniqueKey = globalName || `${name}:${buildVersion}`;
-      if (!this.global.entryLoading[uniqueKey]) {
-        this.global.entryLoading[uniqueKey] = (0, import_sdk2.loadScript)(entry, {});
-      }
-      return this.global.entryLoading[uniqueKey];
-    } else {
-      const remoteInfo = (0, import_runtime2.getRemoteInfo)(remote);
-      const module2 = origin.moduleCache.get(remoteInfo.name);
-      return (0, import_runtime2.getRemoteEntry)({
-        origin,
-        remoteInfo,
-        remoteEntryExports: module2 ? module2.remoteEntryExports : void 0
-      });
-    }
-  }
-  getProjectExports() {
-    var _a2;
-    if (Object.keys(this._exports).length > 0) {
-      return this._exports;
-    }
-    const { name } = this._options;
-    const exportsPromise = (_a2 = globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__) == null ? void 0 : _a2[name];
-    const resolve = exportsPromise.then(
-      (exports = {}) => {
-        const memory = {};
-        Object.keys(exports).forEach((key) => {
-          memory[key] = {};
-          const exportVal = exports[key];
-          Object.keys(exportVal).reduce(
-            (memo, current) => {
-              if (current.toLocaleLowerCase().endsWith("prefetch") || current.toLocaleLowerCase() === "default") {
-                memo[current] = exportVal[current];
-              }
-              return memo;
-            },
-            memory[key]
-          );
-        });
-        this.memorizeExports(memory);
-      }
-    );
-    return resolve;
-  }
-  memorizeExports(exports) {
-    this._exports = exports;
-  }
-  getExposeExports(id) {
-    const prefetchId = getPrefetchId(id);
-    const compatId = compatGetPrefetchId(id);
-    const prefetchExports = this._exports[prefetchId] || this._exports[compatId];
-    return prefetchExports || {};
-  }
-  prefetch(prefetchOptions) {
-    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];
-    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, value) {
-    this.prefetchMemory.set(id, value);
-  }
-  markOutdate(markOptions, isOutdate) {
-    const { id, functionId = "default" } = markOptions;
-    if (!this.recordOutdate[id]) {
-      this.recordOutdate[id] = {};
-    }
-    this.recordOutdate[id][functionId] = isOutdate;
-  }
-  checkOutdate(outdateOptions) {
-    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;
-    }
-  }
-};
-
-// src/universal/index.ts
-function prefetch(options) {
-  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;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  prefetch
-});

package/jest.config.js

@@ -1,29 +0,0 @@
-// For a detailed explanation regarding each configuration property, visit:
-// https://jestjs.io/docs/en/configuration.html
-
-module.exports = {
-  clearMocks: true,
-  cacheDirectory: './jest/cache',
-  coverageDirectory: './jest/coverage',
-  testEnvironment: 'jsdom',
-  coveragePathIgnorePatterns: ['__tests__', '/node_modules/'],
-  coverageProvider: 'v8',
-  coverageReporters: ['cobertura', 'clover', 'json', 'lcov', 'text'],
-  globals: {
-    __DEV__: true,
-    __TEST__: true,
-    __BROWSER__: false,
-    __VERSION__: '"unknow"',
-  },
-  preset: 'ts-jest',
-  transformIgnorePatterns: [
-    // Change MODULE_NAME_HERE to your module that isn't being compiled
-    '/node_modules/(?!((@byted/garfish-)|(byted-tea-sdk))).+\\.js$',
-  ],
-  transform: {
-    '^.+\\.(t|j)sx?$': ['@swc/jest', { swcrc: false }],
-  },
-  rootDir: __dirname,
-  testMatch: ['<rootDir>__tests__/**/**.spec.[jt]s?(x)'],
-  testPathIgnorePatterns: ['/node_modules/', '/dev/'],
-};

package/project.json

@@ -1,21 +0,0 @@
-{
-  "name": "module-federation/data-prefetch",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/data-prefetch/src",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "nx:run-commands",
-      "options": {
-        "commands": ["npm run build --prefix packages/data-prefetch"]
-      }
-    },
-    "test": {
-      "executor": "nx:run-commands",
-      "options": {
-        "commands": ["npm run test --prefix packages/data-prefetch"]
-      }
-    }
-  },
-  "tags": ["type:pkg"]
-}

package/src/cli/babel.ts

@@ -1,94 +0,0 @@
-// no used now
-import path from 'path';
-import type { moduleFederationPlugin } from '@module-federation/sdk';
-
-const attribute = 'id';
-const hookId = 'usePrefetch';
-const importPackage = '@module-federation/data-prefetch/react';
-
-interface BabelPluginOptions {
-  hook_id: string;
-  import_pkg: string;
-  attribute: string;
-  name: string;
-  exposes: moduleFederationPlugin.ModuleFederationPluginOptions['exposes'];
-}
-
-// biome-ignore lint/suspicious/noExplicitAny: <explanation>
-export default (babel: { types: any }, options: BabelPluginOptions) => {
-  const t = babel.types;
-  let shouldHandle = false;
-  let scope = '';
-  const { name, exposes } = options;
-  if (!exposes) {
-    return {};
-  }
-  const exposesKey = Object.keys(exposes);
-  const processedExposes = exposesKey.map((expose) => ({
-    key: expose.replace('.', ''),
-    value: path.resolve(
-      // @ts-ignore
-      typeof exposes[expose] === 'string'
-        ? // @ts-ignore
-          exposes[expose]
-        : // @ts-ignore
-          exposes[expose].import,
-    ),
-  }));
-
-  return {
-    visitor: {
-      ImportDeclaration(
-        nodePath: {
-          // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-          node: { source: { value: any }; specifiers: any };
-        },
-        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-        state: { file: { opts: { filename: any } } },
-      ) {
-        const source = nodePath.node.source.value;
-        const { specifiers } = nodePath.node;
-        const { filename } = state.file.opts;
-
-        if (source === importPackage) {
-          shouldHandle = specifiers.some(
-            (specifier: { imported: { name: string } }) =>
-              specifier.imported &&
-              specifier.imported.name === hookId &&
-              processedExposes.find(
-                // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
-                (expose) => expose.value === filename && (scope = expose.key),
-              ),
-          );
-        }
-      },
-
-      CallExpression(nodePath: {
-        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-        node: { callee: any; arguments: string | any[] };
-      }) {
-        if (
-          shouldHandle &&
-          t.isIdentifier(nodePath.node.callee, { name: hookId }) &&
-          nodePath.node.arguments.length > 0
-        ) {
-          const objectExpression = nodePath.node.arguments[0];
-          if (
-            objectExpression &&
-            t.isObjectExpression(objectExpression) &&
-            !objectExpression.properties.find(
-              (p: { key: { name: string } }) => p.key.name === attribute,
-            )
-          ) {
-            objectExpression.properties.push(
-              t.objectProperty(
-                t.identifier(attribute),
-                t.stringLiteral(name + scope),
-              ),
-            );
-          }
-        }
-      },
-    },
-  };
-};

package/src/cli/index.ts

@@ -1,171 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-
-import {
-  encodeName,
-  moduleFederationPlugin,
-  MFPrefetchCommon,
-} from '@module-federation/sdk';
-import { normalizeWebpackPath } from '@module-federation/sdk/normalize-webpack-path';
-import type { Compiler, WebpackPluginInstance } from 'webpack';
-
-import { TEMP_DIR } from '../common/constant';
-import { fileExistsWithCaseSync, fixPrefetchPath } from '../common/node-utils';
-import { getPrefetchId } from '../common/runtime-utils';
-
-const { RuntimeGlobals, Template } = require(
-  normalizeWebpackPath('webpack'),
-) as typeof import('webpack');
-
-export function getFederationGlobalScope(
-  runtimeGlobals: typeof RuntimeGlobals,
-): string {
-  return `${runtimeGlobals.require || '__webpack_require__'}.federation`;
-}
-
-export class PrefetchPlugin implements WebpackPluginInstance {
-  public options: moduleFederationPlugin.ModuleFederationPluginOptions;
-  private _reWriteExports: string;
-
-  constructor(options: moduleFederationPlugin.ModuleFederationPluginOptions) {
-    this.options = options;
-    this._reWriteExports = '';
-  }
-
-  // eslint-disable-next-line max-lines-per-function
-  apply(compiler: Compiler) {
-    const { name, exposes } = this.options;
-    if (!exposes) {
-      return;
-    }
-    if (!compiler.options.context) {
-      throw new Error('compiler.options.context is not defined');
-    }
-
-    const { runtimePlugins } = this.options;
-    if (!Array.isArray(runtimePlugins)) {
-      this.options.runtimePlugins = [];
-    }
-
-    const runtimePath = path.resolve(__dirname, '../esm/plugin.js');
-    const sharedPath = path.resolve(__dirname, '../esm/shared/index.js');
-    if (!this.options.runtimePlugins?.includes(runtimePath)) {
-      this.options.runtimePlugins!.push(runtimePath);
-    }
-    if (!this.options.runtimePlugins?.includes(sharedPath)) {
-      this.options.runtimePlugins!.push(sharedPath);
-    }
-
-    const encodedName = encodeName(name as string);
-    const asyncEntryPath = path.resolve(
-      compiler.options.context,
-      `node_modules/${TEMP_DIR}/${encodedName}/bootstrap.js`,
-    );
-    if (fs.existsSync(asyncEntryPath)) {
-      fs.unlinkSync(asyncEntryPath);
-    }
-    if (!this.options.dataPrefetch) {
-      return;
-    }
-
-    const prefetchs: Array<string> = [];
-    const exposeAlias = Object.keys(exposes);
-    exposeAlias.forEach((alias) => {
-      let exposePath;
-      // @ts-ignore
-      const exposeValue = exposes[alias];
-      if (typeof exposeValue === 'string') {
-        exposePath = exposeValue;
-      } else {
-        exposePath = exposeValue.import[0];
-      }
-      const targetPaths = fixPrefetchPath(exposePath);
-      for (const pathItem of targetPaths) {
-        const absolutePath = path.resolve(compiler.options.context!, pathItem);
-        if (fileExistsWithCaseSync(absolutePath)) {
-          prefetchs.push(pathItem);
-          const absoluteAlias = alias.replace('.', '');
-          this._reWriteExports += `export * as ${getPrefetchId(
-            `${name}${absoluteAlias}`,
-          )} from '${absolutePath}';\n`;
-          break;
-        }
-      }
-    });
-
-    if (!this._reWriteExports) {
-      return;
-    }
-    const tempDirRealPath = path.resolve(
-      compiler.options.context,
-      'node_modules',
-      TEMP_DIR,
-    );
-    if (!fs.existsSync(tempDirRealPath)) {
-      fs.mkdirSync(tempDirRealPath);
-    }
-    if (!fs.existsSync(`${tempDirRealPath}/${encodedName}`)) {
-      fs.mkdirSync(`${tempDirRealPath}/${encodedName}`);
-    }
-    fs.writeFileSync(asyncEntryPath, this._reWriteExports);
-    new compiler.webpack.DefinePlugin({
-      FederationDataPrefetch: JSON.stringify(asyncEntryPath),
-    }).apply(compiler);
-  }
-
-  static addRuntime(
-    compiler: Compiler,
-    options: {
-      name: string;
-    },
-  ) {
-    const encodedName = encodeName(options.name as string);
-    if (!compiler.options.context) {
-      throw new Error('compiler.options.context is not defined');
-    }
-    const prefetchEntry = path.resolve(
-      compiler.options.context,
-      `node_modules/.mf/${encodedName}/bootstrap.js`,
-    );
-    const federationGlobal = getFederationGlobalScope(
-      RuntimeGlobals || ({} as typeof RuntimeGlobals),
-    );
-
-    return Template.asString([
-      fs.existsSync(prefetchEntry)
-        ? Template.indent([
-            'function injectPrefetch() {',
-            `globalThis.__FEDERATION__ = globalThis.__FEDERATION__ || {};`,
-            `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}'] = globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}'] || {`,
-            `entryLoading: {},`,
-            `instance: new Map(),`,
-            `__PREFETCH_EXPORTS__: {},`,
-            `};`,
-            `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${MFPrefetchCommon.exportsKey}'] = globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${MFPrefetchCommon.exportsKey}'] || {};`,
-            `globalThis.__FEDERATION__['${MFPrefetchCommon.globalKey}']['${MFPrefetchCommon.exportsKey}']['${options.name}'] = import('${prefetchEntry}');`,
-            '}',
-            `${federationGlobal}.prefetch = injectPrefetch`,
-          ])
-        : '',
-      Template.indent([
-        `if(!${federationGlobal}.isMFRemote && ${federationGlobal}.prefetch){`,
-        `${federationGlobal}.prefetch()`,
-        '}',
-      ]),
-    ]);
-  }
-
-  static setRemoteIdentifier() {
-    const federationGlobal = getFederationGlobalScope(
-      RuntimeGlobals || ({} as typeof RuntimeGlobals),
-    );
-    return Template.indent([`${federationGlobal}.isMFRemote = true;`]);
-  }
-
-  static removeRemoteIdentifier() {
-    const federationGlobal = getFederationGlobalScope(
-      RuntimeGlobals || ({} as typeof RuntimeGlobals),
-    );
-    return Template.indent([`${federationGlobal}.isMFRemote = false;`]);
-  }
-}

package/src/common/constant.ts

@@ -1 +0,0 @@
-export const TEMP_DIR = '.mf';

package/src/common/node-utils.ts

@@ -1,24 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-
-export const fileExistsWithCaseSync = (filepath: string): boolean => {
-  const dir = path.dirname(filepath);
-  if (filepath === '/' || filepath === '.') {
-    return true;
-  }
-  const filenames = fs.readdirSync(dir);
-  if (filenames.indexOf(path.basename(filepath)) === -1) {
-    return false;
-  }
-  return fileExistsWithCaseSync(dir);
-};
-
-export const fixPrefetchPath = (exposePath: string): Array<string> => {
-  const pathExt = ['.js', '.ts'];
-  const extReg = /\.(ts|js|tsx|jsx)$/;
-  if (extReg.test(exposePath)) {
-    return pathExt.map((ext) => exposePath.replace(extReg, `.prefetch${ext}`));
-  } else {
-    return pathExt.map((ext) => exposePath + `.prefetch${ext}`);
-  }
-};

package/src/common/runtime-utils.ts

@@ -1,34 +0,0 @@
-import { getInstance } from '@module-federation/runtime';
-import {
-  encodeName,
-  ModuleInfo,
-  MFPrefetchCommon,
-} from '@module-federation/sdk';
-
-export const getScope = (): string => {
-  return getInstance()!.options.name;
-};
-
-export const getPrefetchId = (id: string): string =>
-  encodeName(`${id}/${MFPrefetchCommon.identifier}`);
-
-export const compatGetPrefetchId = (id: string): string =>
-  encodeName(`${id}/VmokPrefetch`);
-
-export const getSignalFromManifest = (remoteSnapshot: ModuleInfo): boolean => {
-  if (!remoteSnapshot) {
-    return false;
-  }
-
-  if (
-    !('prefetchEntry' in remoteSnapshot) &&
-    !('prefetchInterface' in remoteSnapshot)
-  ) {
-    return false;
-  }
-
-  if (!remoteSnapshot.prefetchEntry && !remoteSnapshot.prefetchInterface) {
-    return false;
-  }
-  return true;
-};

package/src/logger/index.ts

@@ -1,3 +0,0 @@
-import { Logger } from '@module-federation/sdk';
-
-export default new Logger('[Module Federation Data Prefetch]');