@module-federation/retry-plugin 0.0.0-docs-remove-invalid-lark-link-20251205062649

package/dist/index.d.mts

@@ -0,0 +1,110 @@
+import { ModuleFederationRuntimePlugin } from '@module-federation/runtime/types';
+
+type CommonRetryOptions = {
+  /**
+   * retry request options
+   */
+  fetchOptions?: RequestInit;
+  /**
+   * retry times
+   */
+  retryTimes?: number;
+  /**
+   * retry success times
+   */
+  successTimes?: number;
+  /**
+   * retry delay
+   */
+  retryDelay?: number;
+  /**
+   * retry path
+   */
+  getRetryPath?: (url: string) => string;
+  /**
+   * add query parameter
+   */
+  addQuery?:
+    | boolean
+    | ((context: { times: number; originalQuery: string }) => string);
+  /**
+   * retry domains
+   */
+  domains?: string[];
+  /**
+   * retry manifest domains
+   */
+  manifestDomains?: string[];
+  /**
+   * retry callback
+   */
+  onRetry?: ({
+    times,
+    domains,
+    url,
+  }: {
+    times?: number;
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+  /**
+   * retry success callback
+   */
+  onSuccess?: ({
+    domains,
+    url,
+    tagName,
+  }: {
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+  /**
+   * retry failure callback
+   */
+  onError?: ({
+    domains,
+    url,
+    tagName,
+  }: {
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+};
+
+type FetchRetryOptions = {
+  url?: string;
+  fetchOptions?: RequestInit;
+} & CommonRetryOptions;
+
+type ScriptRetryOptions = {
+  retryOptions: CommonRetryOptions;
+  retryFn: (...args: any[]) => Promise<any> | (() => Promise<any>);
+  beforeExecuteRetry?: (...args: any[]) => void;
+};
+
+declare function rewriteWithNextDomain(currentUrl: string, domains?: string[]): string | null;
+declare function appendRetryCountQuery(url: string, retryIndex: number, key?: string): string;
+declare function getRetryUrl(baseUrl: string, opts?: {
+    domains?: string[];
+    addQuery?: boolean | ((context: {
+        times: number;
+        originalQuery: string;
+    }) => string);
+    retryIndex?: number;
+    queryKey?: string;
+}): string;
+/**
+ * Extract domain/host info from a URL and combine it with path/query from another URL
+ * This is useful for domain rotation while preserving original path and query parameters
+ * @param domainUrl - URL containing the target domain/host
+ * @param pathQueryUrl - URL containing the target path and query parameters
+ * @returns Combined URL with domain from domainUrl and path/query from pathQueryUrl
+ */
+declare function combineUrlDomainWithPathQuery(domainUrl: string, pathQueryUrl: string): string;
+
+declare const RetryPlugin: (params?: CommonRetryOptions) => ModuleFederationRuntimePlugin;
+
+export { type CommonRetryOptions, type FetchRetryOptions, RetryPlugin, type ScriptRetryOptions, appendRetryCountQuery, combineUrlDomainWithPathQuery, getRetryUrl, rewriteWithNextDomain };

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+import { ModuleFederationRuntimePlugin } from '@module-federation/runtime/types';
+
+type CommonRetryOptions = {
+  /**
+   * retry request options
+   */
+  fetchOptions?: RequestInit;
+  /**
+   * retry times
+   */
+  retryTimes?: number;
+  /**
+   * retry success times
+   */
+  successTimes?: number;
+  /**
+   * retry delay
+   */
+  retryDelay?: number;
+  /**
+   * retry path
+   */
+  getRetryPath?: (url: string) => string;
+  /**
+   * add query parameter
+   */
+  addQuery?:
+    | boolean
+    | ((context: { times: number; originalQuery: string }) => string);
+  /**
+   * retry domains
+   */
+  domains?: string[];
+  /**
+   * retry manifest domains
+   */
+  manifestDomains?: string[];
+  /**
+   * retry callback
+   */
+  onRetry?: ({
+    times,
+    domains,
+    url,
+  }: {
+    times?: number;
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+  /**
+   * retry success callback
+   */
+  onSuccess?: ({
+    domains,
+    url,
+    tagName,
+  }: {
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+  /**
+   * retry failure callback
+   */
+  onError?: ({
+    domains,
+    url,
+    tagName,
+  }: {
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+};
+
+type FetchRetryOptions = {
+  url?: string;
+  fetchOptions?: RequestInit;
+} & CommonRetryOptions;
+
+type ScriptRetryOptions = {
+  retryOptions: CommonRetryOptions;
+  retryFn: (...args: any[]) => Promise<any> | (() => Promise<any>);
+  beforeExecuteRetry?: (...args: any[]) => void;
+};
+
+declare function rewriteWithNextDomain(currentUrl: string, domains?: string[]): string | null;
+declare function appendRetryCountQuery(url: string, retryIndex: number, key?: string): string;
+declare function getRetryUrl(baseUrl: string, opts?: {
+    domains?: string[];
+    addQuery?: boolean | ((context: {
+        times: number;
+        originalQuery: string;
+    }) => string);
+    retryIndex?: number;
+    queryKey?: string;
+}): string;
+/**
+ * Extract domain/host info from a URL and combine it with path/query from another URL
+ * This is useful for domain rotation while preserving original path and query parameters
+ * @param domainUrl - URL containing the target domain/host
+ * @param pathQueryUrl - URL containing the target path and query parameters
+ * @returns Combined URL with domain from domainUrl and path/query from pathQueryUrl
+ */
+declare function combineUrlDomainWithPathQuery(domainUrl: string, pathQueryUrl: string): string;
+
+declare const RetryPlugin: (params?: CommonRetryOptions) => ModuleFederationRuntimePlugin;
+
+export { type CommonRetryOptions, type FetchRetryOptions, RetryPlugin, type ScriptRetryOptions, appendRetryCountQuery, combineUrlDomainWithPathQuery, getRetryUrl, rewriteWithNextDomain };

package/dist/index.js

@@ -0,0 +1,390 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+
+// packages/retry-plugin/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  RetryPlugin: () => RetryPlugin,
+  appendRetryCountQuery: () => appendRetryCountQuery,
+  combineUrlDomainWithPathQuery: () => combineUrlDomainWithPathQuery,
+  getRetryUrl: () => getRetryUrl,
+  rewriteWithNextDomain: () => rewriteWithNextDomain
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/retry-plugin/src/constant.ts
+var defaultRetries = 3;
+var defaultRetryDelay = 1e3;
+var PLUGIN_IDENTIFIER = "[ Module Federation RetryPlugin ]";
+var ERROR_ABANDONED = "The request failed and has now been abandoned";
+var RUNTIME_008 = "RUNTIME-008";
+
+// packages/retry-plugin/src/logger.ts
+var import_sdk = require("@module-federation/sdk");
+var logger = (0, import_sdk.createLogger)(PLUGIN_IDENTIFIER);
+var logger_default = logger;
+
+// packages/retry-plugin/src/utils.ts
+function rewriteWithNextDomain(currentUrl, domains) {
+  if (!domains || domains.length === 0)
+    return null;
+  try {
+    const u = new URL(currentUrl);
+    const currentHostname = u.hostname;
+    const currentPort = u.port;
+    const currentHost = `${currentHostname}${currentPort ? `:${currentPort}` : ""}`;
+    const normalized = domains.map((d) => {
+      try {
+        const du = new URL(d.startsWith("http") ? d : `https://${d}`);
+        return {
+          hostname: du.hostname,
+          port: du.port,
+          protocol: du.protocol
+        };
+      } catch {
+        return {
+          hostname: d,
+          port: "",
+          protocol: u.protocol
+        };
+      }
+    }).filter((d) => !!d.hostname);
+    if (normalized.length === 0)
+      return null;
+    let idx = -1;
+    for (let i = normalized.length - 1; i >= 0; i--) {
+      const candHost = `${normalized[i].hostname}${normalized[i].port ? `:${normalized[i].port}` : ""}`;
+      if (candHost === currentHost) {
+        idx = i;
+        break;
+      }
+    }
+    const total = normalized.length;
+    for (let step = 1; step <= total; step++) {
+      const nextIdx = ((idx >= 0 ? idx : -1) + step) % total;
+      const candidate = normalized[nextIdx];
+      const candidateHost = `${candidate.hostname}${candidate.port ? `:${candidate.port}` : ""}`;
+      if (candidateHost !== currentHost) {
+        u.hostname = candidate.hostname;
+        if (candidate.port !== void 0 && candidate.port !== null && candidate.port !== "") {
+          u.port = candidate.port;
+        } else {
+          u.port = "";
+        }
+        u.protocol = candidate.protocol || u.protocol;
+        return u.toString();
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+__name(rewriteWithNextDomain, "rewriteWithNextDomain");
+function appendRetryCountQuery(url, retryIndex, key = "retryCount") {
+  try {
+    const u = new URL(url);
+    u.searchParams.delete(key);
+    u.searchParams.set(key, String(retryIndex));
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+__name(appendRetryCountQuery, "appendRetryCountQuery");
+function getRetryUrl(baseUrl, opts = {}) {
+  const { domains, addQuery, retryIndex = 0, queryKey = "retryCount" } = opts;
+  let cleanBaseUrl = baseUrl;
+  try {
+    const urlObj = new URL(baseUrl);
+    urlObj.searchParams.delete(queryKey);
+    cleanBaseUrl = urlObj.toString();
+  } catch {
+  }
+  let nextUrl = rewriteWithNextDomain(cleanBaseUrl, domains) ?? cleanBaseUrl;
+  if (retryIndex > 0 && addQuery) {
+    try {
+      const u = new URL(nextUrl);
+      const originalUrl = new URL(baseUrl);
+      originalUrl.searchParams.delete(queryKey);
+      const originalQuery = originalUrl.search.startsWith("?") ? originalUrl.search.slice(1) : originalUrl.search;
+      if (typeof addQuery === "function") {
+        const newQuery = addQuery({
+          times: retryIndex,
+          originalQuery
+        });
+        u.search = newQuery ? `?${newQuery.replace(/^\?/, "")}` : "";
+        nextUrl = u.toString();
+      } else if (addQuery === true) {
+        u.searchParams.delete(queryKey);
+        u.searchParams.set(queryKey, String(retryIndex));
+        nextUrl = u.toString();
+      }
+    } catch {
+      if (addQuery === true) {
+        nextUrl = appendRetryCountQuery(nextUrl, retryIndex, queryKey);
+      }
+    }
+  }
+  return nextUrl;
+}
+__name(getRetryUrl, "getRetryUrl");
+function combineUrlDomainWithPathQuery(domainUrl, pathQueryUrl) {
+  try {
+    const domainUrlObj = new URL(domainUrl);
+    const pathQueryUrlObj = new URL(pathQueryUrl);
+    domainUrlObj.pathname = pathQueryUrlObj.pathname;
+    domainUrlObj.search = pathQueryUrlObj.search;
+    return domainUrlObj.toString();
+  } catch {
+    return pathQueryUrl;
+  }
+}
+__name(combineUrlDomainWithPathQuery, "combineUrlDomainWithPathQuery");
+
+// packages/retry-plugin/src/fetch-retry.ts
+function autoParseResponse(url, response) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.pathname.endsWith(".js") || parsed.pathname.endsWith(".cjs") || parsed.pathname.endsWith(".mjs")) {
+      return response.text();
+    }
+    return response.json();
+  } catch (error) {
+    return response.json();
+  }
+}
+__name(autoParseResponse, "autoParseResponse");
+async function fetchRetry(params, lastRequestUrl, originalTotal) {
+  const {
+    url,
+    fetchOptions = {},
+    retryTimes = defaultRetries,
+    retryDelay = defaultRetryDelay,
+    // List of retry domains when resource loading fails. In the domains array, the first item is the default domain for static resources, and the subsequent items are backup domains. When a request to a domain fails, the system will find that domain in the array and replace it with the next domain in the array.
+    domains,
+    // Whether to add query parameters during resource retry to avoid being affected by browser and CDN cache. When set to true, retry=${times} will be added to the query, requesting in the order of retry=1, retry=2, retry=3.
+    addQuery,
+    onRetry,
+    onSuccess,
+    onError
+  } = params;
+  if (!url) {
+    throw new Error(`${PLUGIN_IDENTIFIER}: url is required in fetchWithRetry`);
+  }
+  const total = originalTotal ?? params.retryTimes ?? defaultRetries;
+  const isFirstAttempt = !lastRequestUrl;
+  let baseUrl = url;
+  if (!isFirstAttempt && lastRequestUrl) {
+    baseUrl = combineUrlDomainWithPathQuery(lastRequestUrl, url);
+  }
+  let requestUrl = baseUrl;
+  if (!isFirstAttempt) {
+    requestUrl = getRetryUrl(baseUrl, {
+      domains,
+      addQuery,
+      retryIndex: total - retryTimes,
+      queryKey: "retryCount"
+    });
+  }
+  try {
+    if (!isFirstAttempt && retryDelay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+    }
+    const response = await fetch(requestUrl, fetchOptions);
+    const responseClone = response.clone();
+    if (!response.ok) {
+      throw new Error(`${PLUGIN_IDENTIFIER}: Request failed: ${response.status} ${response.statusText || ""} | url: ${requestUrl}`);
+    }
+    await autoParseResponse(requestUrl, responseClone).catch((error) => {
+      throw new Error(`${PLUGIN_IDENTIFIER}: JSON parse failed: ${error?.message || String(error)} | url: ${requestUrl}`);
+    });
+    if (!isFirstAttempt) {
+      onSuccess && requestUrl && onSuccess({
+        domains,
+        url: requestUrl,
+        tagName: "fetch"
+      });
+    }
+    return response;
+  } catch (error) {
+    if (retryTimes <= 0) {
+      const attemptedRetries = total - retryTimes;
+      if (!isFirstAttempt && attemptedRetries > 0) {
+        onError && onError({
+          domains,
+          url: requestUrl,
+          tagName: "fetch"
+        });
+        logger_default.log(`${PLUGIN_IDENTIFIER}: retry failed, no retries left for url: ${requestUrl}`);
+      }
+      throw new Error(`${RUNTIME_008}: ${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${requestUrl}`);
+    } else {
+      const nextIndex = total - retryTimes + 1;
+      const predictedBaseUrl = combineUrlDomainWithPathQuery(requestUrl, url);
+      const predictedNextUrl = getRetryUrl(predictedBaseUrl, {
+        domains,
+        addQuery,
+        retryIndex: nextIndex,
+        queryKey: "retryCount"
+      });
+      onRetry && onRetry({
+        times: nextIndex,
+        domains,
+        url: predictedNextUrl,
+        tagName: "fetch"
+      });
+      logger_default.log(`${PLUGIN_IDENTIFIER}: Trying again. Number of retries left: ${retryTimes - 1}`);
+      return await fetchRetry({
+        ...params,
+        retryTimes: retryTimes - 1
+      }, requestUrl, total);
+    }
+  }
+}
+__name(fetchRetry, "fetchRetry");
+
+// packages/retry-plugin/src/script-retry.ts
+function scriptRetry({ retryOptions, retryFn, beforeExecuteRetry = /* @__PURE__ */ __name(() => {
+}, "beforeExecuteRetry") }) {
+  return async function(params) {
+    let retryWrapper;
+    let lastError;
+    let lastRequestUrl;
+    let originalUrl;
+    const { retryTimes = defaultRetries, retryDelay = defaultRetryDelay, domains, addQuery, onRetry, onSuccess, onError } = retryOptions || {};
+    let attempts = 0;
+    const maxAttempts = retryTimes;
+    while (attempts < maxAttempts) {
+      try {
+        beforeExecuteRetry();
+        if (retryDelay > 0 && attempts > 0) {
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        const retryIndex = attempts + 1;
+        retryWrapper = await retryFn({
+          ...params,
+          getEntryUrl: (url) => {
+            if (!originalUrl) {
+              originalUrl = url;
+            }
+            let baseUrl = originalUrl;
+            if (lastRequestUrl) {
+              baseUrl = combineUrlDomainWithPathQuery(lastRequestUrl, originalUrl);
+            }
+            const next = getRetryUrl(baseUrl, {
+              domains,
+              addQuery,
+              retryIndex,
+              queryKey: "retryCount"
+            });
+            onRetry && onRetry({
+              times: retryIndex,
+              domains,
+              url: next,
+              tagName: "script"
+            });
+            lastRequestUrl = next;
+            return next;
+          }
+        });
+        onSuccess && lastRequestUrl && onSuccess({
+          domains,
+          url: lastRequestUrl,
+          tagName: "script"
+        });
+        break;
+      } catch (error) {
+        lastError = error;
+        attempts++;
+        if (attempts >= maxAttempts) {
+          onError && lastRequestUrl && onError({
+            domains,
+            url: lastRequestUrl,
+            tagName: "script"
+          });
+          throw new Error(`${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${lastRequestUrl || "unknown"}`);
+        }
+      }
+    }
+    return retryWrapper;
+  };
+}
+__name(scriptRetry, "scriptRetry");
+
+// packages/retry-plugin/src/index.ts
+var RetryPlugin = /* @__PURE__ */ __name((params) => {
+  if (params?.fetch || params?.script) {
+    logger_default.warn(`${PLUGIN_IDENTIFIER}: params is ${params}, fetch or script config is deprecated, please use the new config style. See docs: https://module-federation.io/plugin/plugins/retry-plugin.html`);
+  }
+  const { fetchOptions = {}, retryTimes = defaultRetries, successTimes = 0, retryDelay = defaultRetryDelay, domains = [], manifestDomains = [], addQuery, onRetry, onSuccess, onError } = params || {};
+  return {
+    name: "retry-plugin",
+    async fetch(manifestUrl, options) {
+      return fetchRetry({
+        url: manifestUrl,
+        fetchOptions: {
+          ...options,
+          ...fetchOptions
+        },
+        domains: manifestDomains || domains,
+        addQuery,
+        onRetry,
+        onSuccess,
+        onError,
+        retryTimes,
+        successTimes,
+        retryDelay
+      });
+    },
+    async loadEntryError({ getRemoteEntry, origin, remoteInfo, remoteEntryExports, globalLoading, uniqueKey }) {
+      const beforeExecuteRetry = /* @__PURE__ */ __name(() => {
+        delete globalLoading[uniqueKey];
+      }, "beforeExecuteRetry");
+      const getRemoteEntryRetry = scriptRetry({
+        retryOptions: {
+          retryTimes,
+          retryDelay,
+          domains,
+          addQuery,
+          onRetry,
+          onSuccess,
+          onError
+        },
+        retryFn: getRemoteEntry,
+        beforeExecuteRetry
+      });
+      const result = await getRemoteEntryRetry({
+        origin,
+        remoteInfo,
+        remoteEntryExports
+      });
+      return result;
+    }
+  };
+}, "RetryPlugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RetryPlugin,
+  appendRetryCountQuery,
+  combineUrlDomainWithPathQuery,
+  getRetryUrl,
+  rewriteWithNextDomain
+});

package/dist/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@module-federation/retry-plugin",
+  "version": "0.0.0-docs-remove-invalid-lark-link-20251205062649",
+  "author": "danpeen <dapeen.feng@gmail.com>",
+  "main": "./dist/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/retry-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@module-federation/runtime": "workspace:*"
+  },
+  "dependencies": {
+    "@module-federation/sdk": "workspace:*"
+  }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@module-federation/retry-plugin",
+  "version": "0.0.0-docs-remove-invalid-lark-link-20251205062649",
+  "author": "danpeen <dapeen.feng@gmail.com>",
+  "main": "./dist/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/retry-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@module-federation/runtime": "0.0.0-docs-remove-invalid-lark-link-20251205062649"
+  },
+  "dependencies": {
+    "@module-federation/sdk": "0.0.0-docs-remove-invalid-lark-link-20251205062649"
+  }
+}