@module-federation/data-prefetch 0.6.6 → 0.6.8

package/dist/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@module-federation/data-prefetch",
+  "description": "Module Federation Data Prefetch",
+  "version": "0.6.8",
+  "author": "nieyan <nyqykk@foxmail.com>",
+  "homepage": "https://github.com/module-federation/core",
+  "license": "MIT",
+  "scripts": {
+    "dev": "cross-env WATCH=true tsup",
+    "build": "rm -rf dist && tsup",
+    "test": "jest"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.cjs.d.ts"
+    },
+    "./react": {
+      "import": "./dist/react.esm.js",
+      "require": "./dist/react.cjs.js",
+      "types": "./dist/react.cjs.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli.esm.js",
+      "require": "./dist/cli.cjs.js",
+      "types": "./dist/cli.cjs.d.ts"
+    },
+    "./babel-plugin": {
+      "import": "./dist/babel.esm.js",
+      "require": "./dist/babel.cjs.js",
+      "types": "./dist/babel.cjs.d.ts"
+    },
+    "./universal": {
+      "import": "./dist/universal.esm.js",
+      "require": "./dist/universal.cjs.js",
+      "types": "./dist/universal.cjs.d.ts"
+    },
+    "./shared": {
+      "import": "./dist/shared.esm.js",
+      "require": "./dist/shared.cjs.js",
+      "types": "./dist/shared/.cjs.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.cjs.d.ts"
+      ],
+      "react": [
+        "./dist/react.cjs.d.ts"
+      ],
+      "cli": [
+        "./dist/cli.cjs.d.ts"
+      ],
+      "universal": [
+        "./dist/universal.cjs.d.ts"
+      ],
+      "shared": [
+        "./dist/shared.cjs.d.ts"
+      ],
+      "babel-plugin": [
+        "./dist/babel.cjs.d.ts"
+      ]
+    }
+  },
+  "main": "./index.cjs.js",
+  "module": "./index.esm.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.3.1",
+    "react-dom": "^18.3.1",
+    "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": {
+    "@module-federation/runtime": "workspace:*",
+    "@module-federation/sdk": "workspace:*",
+    "fs-extra": "9.1.0"
+  },
+  "types": "./index.esm.d.ts"
+}

package/dist/plugin.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/plugin";
+export { default } from "./src/plugin";

package/dist/plugin.cjs.js

@@ -0,0 +1,159 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdk = require('@module-federation/sdk');
+var runtimeUtils = require('./runtime-utils.cjs.js');
+var prefetch = require('./prefetch.cjs.js');
+var index = require('./index.cjs2.js');
+require('@module-federation/runtime');
+
+const loadingArray = [];
+const strategy = 'loaded-first';
+let sharedFlag = strategy;
+// eslint-disable-next-line max-lines-per-function
+const prefetchPlugin = ()=>({
+        name: 'data-prefetch-runtime-plugin',
+        initContainer (options) {
+            const { remoteSnapshot, remoteInfo, id, origin } = options;
+            const snapshot = remoteSnapshot;
+            const { name } = remoteInfo;
+            const prefetchOptions = {
+                name,
+                remote: remoteInfo,
+                origin,
+                remoteSnapshot: snapshot
+            };
+            const signal = runtimeUtils.getSignalFromManifest(snapshot);
+            if (!signal) {
+                return options;
+            }
+            if (sharedFlag !== strategy) {
+                throw new Error(`[Module Federation Data Prefetch]: If you want to use data prefetch, the shared strategy must be 'loaded-first'`);
+            }
+            const instance = prefetch.MFDataPrefetch.getInstance(name) || new prefetch.MFDataPrefetch(prefetchOptions);
+            let prefetchUrl;
+            // @ts-expect-error
+            if (snapshot.prefetchEntry) {
+                // @ts-expect-error
+                prefetchUrl = sdk.getResourceUrl(snapshot, snapshot.prefetchEntry);
+            }
+            const exist = loadingArray.find((loading)=>loading.id === id);
+            if (exist) {
+                return options;
+            }
+            const promise = instance.loadEntry(prefetchUrl).then(async ()=>{
+                const projectExports = instance.getProjectExports();
+                if (projectExports instanceof Promise) {
+                    await projectExports;
+                }
+                return Promise.resolve().then(()=>{
+                    const exports = instance.getExposeExports(id);
+                    index.logger.info(`1. Start Prefetch initContainer: ${id} - ${performance.now()}`);
+                    const result = Object.keys(exports).map((k)=>{
+                        const value = instance.prefetch({
+                            id,
+                            functionId: k
+                        });
+                        const functionId = k;
+                        return {
+                            value,
+                            functionId
+                        };
+                    });
+                    return result;
+                });
+            });
+            loadingArray.push({
+                id,
+                promise
+            });
+            return options;
+        },
+        afterResolve (options) {
+            const { remoteSnapshot, remoteInfo, id, origin } = options;
+            const snapshot = remoteSnapshot;
+            const { name } = remoteInfo;
+            const prefetchOptions = {
+                name,
+                remote: remoteInfo,
+                origin,
+                remoteSnapshot: snapshot
+            };
+            const signal = runtimeUtils.getSignalFromManifest(snapshot);
+            if (!signal) {
+                return options;
+            }
+            const inited = loadingArray.some((info)=>info.id === id);
+            if (!inited) {
+                return options;
+            }
+            if (sharedFlag !== strategy) {
+                throw new Error(`[Module Federation Data Prefetch]: If you want to use data prefetch, the shared strategy must be 'loaded-first'`);
+            }
+            const instance = prefetch.MFDataPrefetch.getInstance(name) || new prefetch.MFDataPrefetch(prefetchOptions);
+            let prefetchUrl;
+            // @ts-expect-error
+            if (snapshot.prefetchEntry) {
+                // @ts-expect-error
+                prefetchUrl = sdk.getResourceUrl(snapshot, snapshot.prefetchEntry);
+            }
+            const index$1 = loadingArray.findIndex((loading)=>loading.id === id);
+            // clear cache
+            if (index$1 !== -1) {
+                loadingArray.splice(index$1, 1);
+            }
+            const promise = instance.loadEntry(prefetchUrl).then(async ()=>{
+                const projectExports = instance.getProjectExports();
+                if (projectExports instanceof Promise) {
+                    await projectExports;
+                }
+                return Promise.resolve().then(()=>{
+                    const exports = instance.getExposeExports(id);
+                    index.logger.info(`1. Start Prefetch afterResolve: ${id} - ${performance.now()}`);
+                    const result = Object.keys(exports).map((k)=>{
+                        const value = instance.prefetch({
+                            id,
+                            functionId: k
+                        });
+                        const functionId = k;
+                        return {
+                            value,
+                            functionId
+                        };
+                    });
+                    return result;
+                });
+            });
+            loadingArray.push({
+                id,
+                promise
+            });
+            return options;
+        },
+        async onLoad (options) {
+            var _loadingArray_find;
+            const { remote, id } = options;
+            const { name } = remote;
+            const promise = (_loadingArray_find = loadingArray.find((loading)=>loading.id === id)) == null ? void 0 : _loadingArray_find.promise;
+            if (promise) {
+                const prefetch$1 = await promise;
+                const prefetchValue = prefetch$1.map((result)=>result.value);
+                await Promise.all(prefetchValue);
+                const instance = prefetch.MFDataPrefetch.getInstance(name);
+                prefetch$1.forEach((result)=>{
+                    const { value, functionId } = result;
+                    instance.memorize(id + functionId, value);
+                });
+            }
+            return options;
+        },
+        beforeLoadShare (options) {
+            const shareInfo = options.shareInfo;
+            sharedFlag = (shareInfo == null ? void 0 : shareInfo.strategy) || sharedFlag;
+            return options;
+        }
+    });
+
+exports.default = prefetchPlugin;
+exports.prefetchPlugin = prefetchPlugin;

package/dist/plugin.esm.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/plugin";
+export { default } from "./src/plugin";

package/dist/plugin.esm.js

@@ -0,0 +1,154 @@
+import { getResourceUrl } from '@module-federation/sdk';
+import { a as getSignalFromManifest } from './runtime-utils.esm.js';
+import { M as MFDataPrefetch } from './prefetch.esm.js';
+import { l as logger } from './index.esm2.js';
+import '@module-federation/runtime';
+
+const loadingArray = [];
+const strategy = 'loaded-first';
+let sharedFlag = strategy;
+// eslint-disable-next-line max-lines-per-function
+const prefetchPlugin = ()=>({
+        name: 'data-prefetch-runtime-plugin',
+        initContainer (options) {
+            const { remoteSnapshot, remoteInfo, id, origin } = options;
+            const snapshot = remoteSnapshot;
+            const { name } = remoteInfo;
+            const prefetchOptions = {
+                name,
+                remote: remoteInfo,
+                origin,
+                remoteSnapshot: snapshot
+            };
+            const signal = getSignalFromManifest(snapshot);
+            if (!signal) {
+                return options;
+            }
+            if (sharedFlag !== strategy) {
+                throw new Error(`[Module Federation Data Prefetch]: If you want to use data prefetch, the shared strategy must be 'loaded-first'`);
+            }
+            const instance = MFDataPrefetch.getInstance(name) || new MFDataPrefetch(prefetchOptions);
+            let prefetchUrl;
+            // @ts-expect-error
+            if (snapshot.prefetchEntry) {
+                // @ts-expect-error
+                prefetchUrl = getResourceUrl(snapshot, snapshot.prefetchEntry);
+            }
+            const exist = loadingArray.find((loading)=>loading.id === id);
+            if (exist) {
+                return options;
+            }
+            const promise = instance.loadEntry(prefetchUrl).then(async ()=>{
+                const projectExports = instance.getProjectExports();
+                if (projectExports instanceof Promise) {
+                    await projectExports;
+                }
+                return Promise.resolve().then(()=>{
+                    const exports = instance.getExposeExports(id);
+                    logger.info(`1. Start Prefetch initContainer: ${id} - ${performance.now()}`);
+                    const result = Object.keys(exports).map((k)=>{
+                        const value = instance.prefetch({
+                            id,
+                            functionId: k
+                        });
+                        const functionId = k;
+                        return {
+                            value,
+                            functionId
+                        };
+                    });
+                    return result;
+                });
+            });
+            loadingArray.push({
+                id,
+                promise
+            });
+            return options;
+        },
+        afterResolve (options) {
+            const { remoteSnapshot, remoteInfo, id, origin } = options;
+            const snapshot = remoteSnapshot;
+            const { name } = remoteInfo;
+            const prefetchOptions = {
+                name,
+                remote: remoteInfo,
+                origin,
+                remoteSnapshot: snapshot
+            };
+            const signal = getSignalFromManifest(snapshot);
+            if (!signal) {
+                return options;
+            }
+            const inited = loadingArray.some((info)=>info.id === id);
+            if (!inited) {
+                return options;
+            }
+            if (sharedFlag !== strategy) {
+                throw new Error(`[Module Federation Data Prefetch]: If you want to use data prefetch, the shared strategy must be 'loaded-first'`);
+            }
+            const instance = MFDataPrefetch.getInstance(name) || new MFDataPrefetch(prefetchOptions);
+            let prefetchUrl;
+            // @ts-expect-error
+            if (snapshot.prefetchEntry) {
+                // @ts-expect-error
+                prefetchUrl = getResourceUrl(snapshot, snapshot.prefetchEntry);
+            }
+            const index = loadingArray.findIndex((loading)=>loading.id === id);
+            // clear cache
+            if (index !== -1) {
+                loadingArray.splice(index, 1);
+            }
+            const promise = instance.loadEntry(prefetchUrl).then(async ()=>{
+                const projectExports = instance.getProjectExports();
+                if (projectExports instanceof Promise) {
+                    await projectExports;
+                }
+                return Promise.resolve().then(()=>{
+                    const exports = instance.getExposeExports(id);
+                    logger.info(`1. Start Prefetch afterResolve: ${id} - ${performance.now()}`);
+                    const result = Object.keys(exports).map((k)=>{
+                        const value = instance.prefetch({
+                            id,
+                            functionId: k
+                        });
+                        const functionId = k;
+                        return {
+                            value,
+                            functionId
+                        };
+                    });
+                    return result;
+                });
+            });
+            loadingArray.push({
+                id,
+                promise
+            });
+            return options;
+        },
+        async onLoad (options) {
+            var _loadingArray_find;
+            const { remote, id } = options;
+            const { name } = remote;
+            const promise = (_loadingArray_find = loadingArray.find((loading)=>loading.id === id)) == null ? void 0 : _loadingArray_find.promise;
+            if (promise) {
+                const prefetch = await promise;
+                const prefetchValue = prefetch.map((result)=>result.value);
+                await Promise.all(prefetchValue);
+                const instance = MFDataPrefetch.getInstance(name);
+                prefetch.forEach((result)=>{
+                    const { value, functionId } = result;
+                    instance.memorize(id + functionId, value);
+                });
+            }
+            return options;
+        },
+        beforeLoadShare (options) {
+            const shareInfo = options.shareInfo;
+            sharedFlag = (shareInfo == null ? void 0 : shareInfo.strategy) || sharedFlag;
+            return options;
+        }
+    });
+
+export { prefetchPlugin as default, prefetchPlugin };

package/dist/polyfills.cjs.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+exports._extends = _extends;

package/dist/polyfills.esm.js

@@ -0,0 +1,12 @@
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+export { _extends as _ };

package/dist/prefetch.cjs.js

@@ -0,0 +1,142 @@
+'use strict';
+
+var runtime = require('@module-federation/runtime');
+var sdk = require('@module-federation/sdk');
+var runtimeUtils = require('./runtime-utils.cjs.js');
+
+var // @ts-ignore init global variable for test
+_globalThis, _globalThis___FEDERATION__;
+var ___FEDERATION__;
+(___FEDERATION__ = (_globalThis = globalThis).__FEDERATION__) != null ? ___FEDERATION__ : _globalThis.__FEDERATION__ = {};
+var ___PREFETCH__;
+(___PREFETCH__ = (_globalThis___FEDERATION__ = globalThis.__FEDERATION__).__PREFETCH__) != null ? ___PREFETCH__ : _globalThis___FEDERATION__.__PREFETCH__ = {
+    entryLoading: {},
+    instance: new Map(),
+    __PREFETCH_EXPORTS__: {}
+};
+class MFDataPrefetch {
+    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] = sdk.loadScript(entry, {});
+            }
+            return this.global.entryLoading[uniqueKey];
+        } else {
+            const remoteInfo = runtime.getRemoteInfo(remote);
+            const module = origin.moduleCache.get(remoteInfo.name);
+            return runtime.getRemoteEntry({
+                origin: origin,
+                remoteInfo,
+                remoteEntryExports: module ? module.remoteEntryExports : undefined
+            });
+        }
+    }
+    getProjectExports() {
+        var _globalThis___FEDERATION_____PREFETCH_____PREFETCH_EXPORTS__;
+        if (Object.keys(this._exports).length > 0) {
+            return this._exports;
+        }
+        const { name } = this._options;
+        const exportsPromiseFn = (_globalThis___FEDERATION_____PREFETCH_____PREFETCH_EXPORTS__ = globalThis.__FEDERATION__.__PREFETCH__.__PREFETCH_EXPORTS__) == null ? void 0 : _globalThis___FEDERATION_____PREFETCH_____PREFETCH_EXPORTS__[name];
+        const exportsPromise = typeof exportsPromiseFn === 'function' ? exportsPromiseFn() : Promise.resolve({});
+        const resolve = exportsPromise.then((exports = {})=>{
+            // 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 = {};
+            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 = runtimeUtils.getPrefetchId(id);
+        const compatId = runtimeUtils.compatGetPrefetchId(id);
+        const prefetchExports = this._exports[prefetchId] || this._exports[compatId];
+        return prefetchExports || {};
+    }
+    prefetch(prefetchOptions) {
+        const { id, functionId = 'default', refetchParams } = prefetchOptions;
+        let prefetchResult;
+        const prefetchId = runtimeUtils.getPrefetchId(id);
+        const compatId = runtimeUtils.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;
+        }
+    }
+    constructor(options){
+        this.prefetchMemory = new Map();
+        this.recordOutdate = {};
+        this._exports = {};
+        this._options = options;
+        this.global.instance.set(options.name, this);
+    }
+}
+
+exports.MFDataPrefetch = MFDataPrefetch;