@module-federation/data-prefetch 0.0.0-next-20240617071542

package/dist/universal/index.js

@@ -0,0 +1,213 @@
+"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_runtime = require("@module-federation/runtime");
+var import_sdk2 = require("@module-federation/sdk");
+
+// src/common/runtime-utils.ts
+var import_sdk = require("@module-federation/sdk");
+var getScope = (id) => {
+  const idArray = id.split("/");
+  if (idArray.length >= 2) {
+    idArray.pop();
+  }
+  const name = idArray.join("/");
+  return name;
+};
+var getPrefetchId = (id) => (0, import_sdk.encodeName)(`${id}/${import_sdk.MFPrefetchCommon.identifier}`);
+
+// 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_runtime.getRemoteInfo)(remote);
+      const module2 = origin.moduleCache.get(remoteInfo.name);
+      return (0, import_runtime.getRemoteEntry)({
+        remoteInfo,
+        remoteEntryExports: module2 ? module2.remoteEntryExports : void 0,
+        createScriptHook: (url) => {
+          const res = origin.loaderHook.lifecycle.createScript.emit({
+            url
+          });
+          if (res instanceof HTMLScriptElement) {
+            return res;
+          }
+          return;
+        }
+      });
+    }
+  }
+  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 prefetchExports = this._exports[prefetchId];
+    return prefetchExports || {};
+  }
+  prefetch(prefetchOptions) {
+    const { id, functionId = "default", refetchParams } = prefetchOptions;
+    let prefetchResult;
+    const prefetchId = getPrefetchId(id);
+    const memorizeId = id + functionId;
+    const memory = this.prefetchMemory.get(memorizeId);
+    if (!this.checkOutdate(prefetchOptions) && memory) {
+      return memory;
+    }
+    const prefetchExports = this._exports[prefetchId];
+    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 } = options;
+  const mfScope = getScope(id);
+  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

@@ -0,0 +1,29 @@
+// 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'],
+  },
+  rootDir: __dirname,
+  testMatch: ['<rootDir>__tests__/**/**.spec.[jt]s?(x)'],
+  testPathIgnorePatterns: ['/node_modules/', '/dev/'],
+};

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@module-federation/data-prefetch",
+  "description": "Module Federation Data Prefetch",
+  "version": "0.0.0-next-20240617071542",
+  "author": "nieyan <nyqykk@foxmail.com>",
+  "homepage": "https://github.com/module-federation/core",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./react": {
+      "import": "./dist/esm/react/index.js",
+      "require": "./dist/react/index.js",
+      "types": "./dist/react/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/esm/cli/index.js",
+      "require": "./dist/cli/index.js",
+      "types": "./dist/cli/index.d.ts"
+    },
+    "./babel-plugin": {
+      "import": "./dist/esm/cli/babel.js",
+      "require": "./dist/cli/babel.js",
+      "types": "./dist/cli/babel.d.ts"
+    },
+    "./universal": {
+      "import": "./dist/esm/universal/index.js",
+      "require": "./dist/universal/index.js",
+      "types": "./dist/universal/index.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "react": [
+        "./dist/react/index.d.ts"
+      ],
+      "cli": [
+        "./dist/cli/index.d.ts"
+      ],
+      "universal": [
+        "./dist/universal/index.d.ts"
+      ]
+    }
+  },
+  "main": "dist/index.js",
+  "module": "dist/esm/index.js",
+  "peerDependencies": {
+    "react": ">=16.9.0",
+    "react-dom": ">=16.9.0"
+  },
+  "devDependencies": {
+    "@testing-library/react-hooks": "^8.0.1",
+    "@types/fs-extra": "9.0.6",
+    "@types/jest": "^29.5.11",
+    "@types/node": "^17.0.45",
+    "@types/react": "~18.0.38",
+    "esbuild-plugin-replace": "^1.4.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "minimist": "^1.2.8",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router": "^6.21.3",
+    "react-test-renderer": "^18.2.0",
+    "ts-jest": "29.0.1",
+    "tsup": "6.2.0",
+    "webpack": "5.75.0"
+  },
+  "dependencies": {
+    "fs-extra": "9.1.0",
+    "@module-federation/sdk": "0.0.0-next-20240617071542",
+    "@module-federation/runtime": "0.0.0-next-20240617071542"
+  },
+  "scripts": {
+    "dev": "cross-env WATCH=true tsup",
+    "build": "rm -rf dist && tsup",
+    "test": "jest"
+  }
+}

package/project.json

@@ -0,0 +1,21 @@
+{
+  "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/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "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__/**/*", "tsup.config.ts"],
+  "exclude": ["node_modules/**/*", "../node_modules"]
+}