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

package/dist/README.md

@@ -0,0 +1,347 @@
+# @module-federation/retry-plugin
+
+> A robust retry plugin for Module Federation that provides automatic retry mechanisms for failed module requests with domain rotation, cache-busting, and comprehensive error handling.
+
+## Features
+
+- 🔄 **Automatic Retry**: Automatically retries failed fetch and script requests
+- 🌐 **Domain Rotation**: Rotate through multiple domains for better reliability
+- ⚡ **Cache Busting**: Add query parameters to bypass cache issues
+- 📊 **Lifecycle Callbacks**: Comprehensive callbacks for retry events
+- 🎯 **Flexible Configuration**: Highly configurable retry strategies
+- 🔧 **TypeScript Support**: Full TypeScript support with type definitions
+
+## Installation
+
+```bash
+npm install @module-federation/retry-plugin
+# or
+yarn add @module-federation/retry-plugin
+# or
+pnpm add @module-federation/retry-plugin
+```
+
+## Basic Usage
+
+### Runtime Plugin Registration
+
+```ts
+import { createInstance } from '@module-federation/enhanced/runtime';
+import { RetryPlugin } from '@module-federation/retry-plugin';
+
+const mf = createInstance({
+  name: 'host',
+  remotes: [
+    {
+      name: 'remote1',
+      entry: 'http://localhost:2001/mf-manifest.json',
+    }
+  ],
+  plugins: [
+    RetryPlugin({
+      retryTimes: 3,
+      retryDelay: 1000,
+      domains: ['https://cdn1.example.com', 'https://cdn2.example.com'],
+      manifestDomains: ['https://domain1.example.com', 'https://domain2.example.com'],
+      addQuery: ({ times, originalQuery }) => `${originalQuery}&retry=${times}`,
+      onRetry: ({ times, url }) => console.log('Retrying...', times, url),
+      onSuccess: ({ url }) => console.log('Success!', url),
+      onError: ({ url }) => console.log('Failed!', url),
+    }),
+  ]
+});
+```
+
+### Build Plugin Registration
+
+```ts
+// webpack.config.js
+import { ModuleFederationPlugin } from '@module-federation/webpack';
+import { RetryPlugin } from '@module-federation/retry-plugin';
+
+export default {
+  plugins: [
+    new ModuleFederationPlugin({
+      name: 'host',
+      remotes: {
+        remote1: 'remote1@http://localhost:2001/mf-manifest.json',
+      },
+      runtimePlugins: [
+        path.join(__dirname, './src/runtime-plugin/retry.ts'),
+      ],
+    }),
+  ],
+};
+```
+
+```ts
+// src/runtime-plugin/retry.ts
+import { RetryPlugin } from '@module-federation/retry-plugin';
+
+export default () => RetryPlugin({
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: ['https://cdn1.example.com', 'https://cdn2.example.com'],
+  manifestDomains: ['https://domain1.example.com', 'https://domain2.example.com'],
+  addQuery: ({ times, originalQuery }) => `${originalQuery}&retry=${times}`,
+  onRetry: ({ times, url }) => console.log('Retrying...', times, url),
+  onSuccess: ({ url }) => console.log('Success!', url),
+  onError: ({ url }) => console.log('Failed!', url),
+});
+```
+
+## Configuration Options
+
+### CommonRetryOptions
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `retryTimes` | `number` | `3` | Number of retry attempts |
+| `retryDelay` | `number` | `1000` | Delay between retries in milliseconds |
+| `successTimes` | `number` | `0` | Number of successful requests required |
+| `domains` | `string[]` | `[]` | Alternative domains for script resources |
+| `manifestDomains` | `string[]` | `[]` | Alternative domains for manifest files |
+| `addQuery` | `boolean \| function` | `false` | Add query parameters for cache busting |
+| `fetchOptions` | `RequestInit` | `{}` | Additional fetch options |
+| `onRetry` | `function` | `undefined` | Callback when retry occurs |
+| `onSuccess` | `function` | `undefined` | Callback when request succeeds |
+| `onError` | `function` | `undefined` | Callback when all retries fail |
+
+### addQuery Function
+
+```ts
+addQuery: ({ times, originalQuery }) => {
+  // Add retry count and timestamp for cache busting
+  const separator = originalQuery ? '&' : '?';
+  return `${originalQuery}${separator}retry=${times}&t=${Date.now()}`;
+}
+```
+
+### Callback Functions
+
+```ts
+onRetry: ({ times, domains, url, tagName }) => {
+  console.log(`Retry attempt ${times} for ${url}`);
+  console.log(`Available domains: ${domains?.join(', ')}`);
+},
+
+onSuccess: ({ domains, url, tagName }) => {
+  console.log(`Successfully loaded ${url}`);
+  console.log(`Used domain: ${domains?.[0]}`);
+},
+
+onError: ({ domains, url, tagName }) => {
+  console.error(`Failed to load ${url} after all retries`);
+  console.error(`Tried domains: ${domains?.join(', ')}`);
+}
+```
+
+## Advanced Examples
+
+### Custom Retry Strategy
+
+```ts
+RetryPlugin({
+  retryTimes: 5,
+  retryDelay: (attempt) => Math.pow(2, attempt) * 1000, // Exponential backoff
+  domains: [
+    'https://cdn1.example.com',
+    'https://cdn2.example.com',
+    'https://cdn3.example.com',
+  ],
+  manifestDomains: [
+    'https://api1.example.com',
+    'https://api2.example.com',
+  ],
+  addQuery: ({ times, originalQuery }) => {
+    const params = new URLSearchParams(originalQuery);
+    params.set('retry', times.toString());
+    params.set('cache_bust', Date.now().toString());
+    return params.toString();
+  },
+  onRetry: ({ times, url, domains }) => {
+    console.log(`Retry ${times}/5 for ${url}`);
+    console.log(`Trying domain: ${domains?.[times % domains.length]}`);
+  },
+  onSuccess: ({ url, domains }) => {
+    console.log(`✅ Successfully loaded ${url}`);
+    console.log(`✅ Used domain: ${domains?.[0]}`);
+  },
+  onError: ({ url, domains }) => {
+    console.error(`❌ Failed to load ${url} after all retries`);
+    console.error(`❌ Tried all domains: ${domains?.join(', ')}`);
+  },
+})
+```
+
+### Error Handling with Fallback
+
+```ts
+RetryPlugin({
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: ['https://cdn1.example.com', 'https://cdn2.example.com'],
+  onError: ({ url, domains }) => {
+    // Log error for monitoring
+    console.error('Module loading failed:', { url, domains });
+    
+    // Send error to monitoring service
+    if (window.gtag) {
+      window.gtag('event', 'module_load_error', {
+        event_category: 'module_federation',
+        event_label: url,
+        value: domains?.length || 0,
+      });
+    }
+    
+    // Show user-friendly error message
+    const errorElement = document.createElement('div');
+    errorElement.className = 'module-load-error';
+    errorElement.innerHTML = `
+      <div style="padding: 16px; border: 1px solid #ffa39e; border-radius: 4px; background: #fff1f0; color: #cf1322;">
+        <h4>Module Loading Failed</h4>
+        <p>Unable to load module: ${url}</p>
+        <p>Please refresh the page to try again.</p>
+      </div>
+    `;
+    document.body.appendChild(errorElement);
+  },
+})
+```
+
+### Production Configuration
+
+```ts
+RetryPlugin({
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: [
+    'https://cdn1.prod.example.com',
+    'https://cdn2.prod.example.com',
+    'https://cdn3.prod.example.com',
+  ],
+  manifestDomains: [
+    'https://api1.prod.example.com',
+    'https://api2.prod.example.com',
+  ],
+  addQuery: ({ times, originalQuery }) => {
+    const params = new URLSearchParams(originalQuery);
+    params.set('retry', times.toString());
+    params.set('v', process.env.BUILD_VERSION || '1.0.0');
+    return params.toString();
+  },
+  fetchOptions: {
+    cache: 'no-cache',
+    headers: {
+      'X-Requested-With': 'ModuleFederation',
+    },
+  },
+  onRetry: ({ times, url }) => {
+    // Only log in development
+    if (process.env.NODE_ENV === 'development') {
+      console.log(`Retry ${times} for ${url}`);
+    }
+  },
+  onSuccess: ({ url }) => {
+    // Track successful loads
+    if (window.analytics) {
+      window.analytics.track('module_loaded', { url });
+    }
+  },
+  onError: ({ url, domains }) => {
+    // Send error to monitoring service
+    if (window.errorReporting) {
+      window.errorReporting.captureException(
+        new Error(`Module loading failed: ${url}`),
+        { extra: { domains, url } }
+      );
+    }
+  },
+})
+```
+
+## How It Works
+
+1. **Fetch Retry**: Intercepts failed fetch requests for manifest files and retries with domain rotation
+2. **Script Retry**: Intercepts failed script loading and retries with alternative domains
+3. **Domain Rotation**: Cycles through provided domains to find working alternatives
+4. **Cache Busting**: Adds query parameters to prevent cache-related issues
+5. **Lifecycle Hooks**: Provides callbacks for monitoring and debugging
+
+## Error Scenarios Handled
+
+- Network timeouts and connection errors
+- DNS resolution failures
+- Server errors (5xx status codes)
+- CDN failures and regional issues
+- Cache-related loading problems
+- CORS and security policy violations
+
+## Browser Support
+
+- Chrome 60+
+- Firefox 55+
+- Safari 12+
+- Edge 79+
+
+## TypeScript Support
+
+The plugin includes full TypeScript definitions:
+
+```ts
+import { RetryPlugin, type CommonRetryOptions } from '@module-federation/retry-plugin';
+
+const options: CommonRetryOptions = {
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: ['https://cdn1.example.com'],
+  onRetry: ({ times, url }) => {
+    console.log(`Retry ${times} for ${url}`);
+  },
+};
+
+const plugin = RetryPlugin(options);
+```
+
+## Migration Guide
+
+### From v0.18.x to v0.19.x
+
+The plugin configuration has been simplified. The old `fetch` and `script` configuration objects are deprecated:
+
+```ts
+// ❌ Old way (deprecated)
+RetryPlugin({
+  fetch: {
+    url: 'http://localhost:2008/not-exist-mf-manifest.json',
+    fallback: () => 'http://localhost:2001/mf-manifest.json',
+  },
+  script: {
+    url: 'http://localhost:2001/static/js/async/src_App_tsx.js',
+    customCreateScript: (url, attrs) => { /* ... */ },
+  }
+})
+
+// ✅ New way
+RetryPlugin({
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: ['http://localhost:2001'],
+  manifestDomains: ['http://localhost:2001'],
+  addQuery: ({ times, originalQuery }) => `${originalQuery}&retry=${times}`,
+})
+```
+
+## Contributing
+
+Contributions are welcome! Please read our [contributing guidelines](https://github.com/module-federation/core/blob/main/CONTRIBUTING.md) and submit pull requests to our [GitHub repository](https://github.com/module-federation/core).
+
+## License
+
+`@module-federation/retry-plugin` is [MIT licensed](https://github.com/module-federation/core/blob/main/packages/retry-plugin/LICENSE).
+
+## Related
+
+- [Module Federation Documentation](https://module-federation.io/)
+- [Module Federation Runtime](https://www.npmjs.com/package/@module-federation/runtime)
+- [Module Federation Enhanced](https://www.npmjs.com/package/@module-federation/enhanced)

package/dist/esm/index.js

@@ -0,0 +1,361 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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
+import { createLogger } from "@module-federation/sdk";
+var logger = 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");
+export {
+  RetryPlugin,
+  appendRetryCountQuery,
+  combineUrlDomainWithPathQuery,
+  getRetryUrl,
+  rewriteWithNextDomain
+};