@rsbuild/plugin-assets-retry 1.0.2 → 1.0.4

package/{dist-types → dist}/AsyncChunkRetryPlugin.d.ts

@@ -1,5 +1,5 @@
 import { type Rspack } from '@rsbuild/core';
-import type { PluginAssetsRetryOptions, RuntimeRetryOptions } from './types';
+import type { PluginAssetsRetryOptions, RuntimeRetryOptions } from './types.js';
 declare class AsyncChunkRetryPlugin implements Rspack.RspackPluginInstance {
     readonly name = "ASYNC_CHUNK_RETRY_PLUGIN";
     readonly options: PluginAssetsRetryOptions & {

package/dist/index.cjs

@@ -1,234 +1,399 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-
-// src/AsyncChunkRetryPlugin.ts
-var AsyncChunkRetryPlugin_exports = {};
-__export(AsyncChunkRetryPlugin_exports, {
-  AsyncChunkRetryPlugin: () => AsyncChunkRetryPlugin
-});
-function appendWebpackScript(module2, appendSource) {
-  try {
-    const originSource = module2.getGeneratedCode();
-    module2.getGeneratedCode = () => `${originSource}
-${appendSource}`;
-  } catch (err) {
-    console.error("Failed to modify Webpack RuntimeModule");
-    throw err;
-  }
-}
-function appendRspackScript(module2, appendSource) {
-  try {
-    const source = module2.source.source.toString();
-    module2.source.source = Buffer.from(`${source}
-${appendSource}`, "utf-8");
-  } catch (err) {
-    console.error("Failed to modify Rspack RuntimeModule");
-    throw err;
-  }
-}
-function pick(obj, keys) {
-  return keys.reduce(
-    (ret, key) => {
-      if (obj[key] !== void 0) {
-        ret[key] = obj[key];
-      }
-      return ret;
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/randombytes@2.1.0/node_modules/randombytes/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        module1.exports = __webpack_require__("crypto")/* .randomBytes */ .randomBytes;
     },
-    {}
-  );
-}
-var import_node_fs, import_node_path, import_core, import_serialize_javascript, AsyncChunkRetryPlugin;
-var init_AsyncChunkRetryPlugin = __esm({
-  "src/AsyncChunkRetryPlugin.ts"() {
-    "use strict";
-    import_node_fs = __toESM(require("fs"));
-    import_node_path = __toESM(require("path"));
-    import_core = require("@rsbuild/core");
-    import_serialize_javascript = __toESM(require("serialize-javascript"));
-    AsyncChunkRetryPlugin = class {
-      constructor(options) {
-        __publicField(this, "name", "ASYNC_CHUNK_RETRY_PLUGIN");
-        __publicField(this, "options");
-        __publicField(this, "runtimeOptions");
-        this.options = options;
-        this.runtimeOptions = pick(options, [
-          "domain",
-          "max",
-          "onRetry",
-          "onSuccess",
-          "onFail",
-          "addQuery",
-          "test"
-        ]);
-      }
-      getRawRuntimeRetryCode() {
-        const { RuntimeGlobals } = import_core.rspack;
-        const filename = "asyncChunkRetry";
-        const runtimeFilePath = import_node_path.default.join(
-          __dirname,
-          "runtime",
-          this.options.minify ? `${filename}.min.js` : `${filename}.js`
-        );
-        const rawText = import_node_fs.default.readFileSync(runtimeFilePath, "utf-8");
-        return rawText.replaceAll("__RUNTIME_GLOBALS_REQUIRE__", RuntimeGlobals.require).replaceAll(
-          "__RUNTIME_GLOBALS_ENSURE_CHUNK__",
-          RuntimeGlobals.ensureChunk
-        ).replaceAll(
-          "__RUNTIME_GLOBALS_GET_CHUNK_SCRIPT_FILENAME__",
-          RuntimeGlobals.getChunkScriptFilename
-        ).replaceAll(
-          "__RUNTIME_GLOBALS_GET_CSS_FILENAME__",
-          RuntimeGlobals.getChunkCssFilename
-        ).replaceAll(
-          "__RUNTIME_GLOBALS_GET_MINI_CSS_EXTRACT_FILENAME__",
-          "__webpack_require__.miniCssF"
-        ).replaceAll("__RUNTIME_GLOBALS_PUBLIC_PATH__", RuntimeGlobals.publicPath).replaceAll("__RUNTIME_GLOBALS_LOAD_SCRIPT__", RuntimeGlobals.loadScript).replaceAll("__RETRY_OPTIONS__", (0, import_serialize_javascript.default)(this.runtimeOptions));
-      }
-      apply(compiler) {
-        compiler.hooks.thisCompilation.tap(this.name, (compilation) => {
-          compilation.hooks.runtimeModule.tap(this.name, (module2) => {
-            const { isRspack } = this.options;
-            const constructorName = isRspack ? module2.constructorName : module2.constructor?.name;
-            const isPublicPathModule = module2.name === "publicPath" || constructorName === "PublicPathRuntimeModule" || constructorName === "AutoPublicPathRuntimeModule";
-            if (!isPublicPathModule) {
-              return;
+    "../../node_modules/.pnpm/serialize-javascript@6.0.2/node_modules/serialize-javascript/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        /*
+Copyright (c) 2014, Yahoo! Inc. All rights reserved.
+Copyrights licensed under the New BSD License.
+See the accompanying LICENSE file for terms.
+*/ var randomBytes = __webpack_require__("../../node_modules/.pnpm/randombytes@2.1.0/node_modules/randombytes/index.js");
+        // Generate an internal UID to make the regexp pattern harder to guess.
+        var UID_LENGTH = 16;
+        var UID = generateUID();
+        var PLACE_HOLDER_REGEXP = new RegExp('(\\\\)?"@__(F|R|D|M|S|A|U|I|B|L)-' + UID + '-(\\d+)__@"', 'g');
+        var IS_NATIVE_CODE_REGEXP = /\{\s*\[native code\]\s*\}/g;
+        var IS_PURE_FUNCTION = /function.*?\(/;
+        var IS_ARROW_FUNCTION = /.*?=>.*?/;
+        var UNSAFE_CHARS_REGEXP = /[<>\/\u2028\u2029]/g;
+        var RESERVED_SYMBOLS = [
+            '*',
+            'async'
+        ];
+        // Mapping of unsafe HTML and invalid JavaScript line terminator chars to their
+        // Unicode char counterparts which are safe to use in JavaScript strings.
+        var ESCAPED_CHARS = {
+            '<': '\\u003C',
+            '>': '\\u003E',
+            '/': '\\u002F',
+            '\u2028': '\\u2028',
+            '\u2029': '\\u2029'
+        };
+        function escapeUnsafeChars(unsafeChar) {
+            return ESCAPED_CHARS[unsafeChar];
+        }
+        function generateUID() {
+            var bytes = randomBytes(UID_LENGTH);
+            var result = '';
+            for(var i = 0; i < UID_LENGTH; ++i)result += bytes[i].toString(16);
+            return result;
+        }
+        function deleteFunctions(obj) {
+            var functionKeys = [];
+            for(var key in obj)if ("function" == typeof obj[key]) functionKeys.push(key);
+            for(var i = 0; i < functionKeys.length; i++)delete obj[functionKeys[i]];
+        }
+        module1.exports = function serialize(obj, options) {
+            options || (options = {});
+            // Backwards-compatibility for `space` as the second argument.
+            if ('number' == typeof options || 'string' == typeof options) options = {
+                space: options
+            };
+            var functions = [];
+            var regexps = [];
+            var dates = [];
+            var maps = [];
+            var sets = [];
+            var arrays = [];
+            var undefs = [];
+            var infinities = [];
+            var bigInts = [];
+            var urls = [];
+            // Returns placeholders for functions and regexps (identified by index)
+            // which are later replaced by their string representation.
+            function replacer(key, value) {
+                // For nested function
+                if (options.ignoreFunction) deleteFunctions(value);
+                if (!value && void 0 !== value && value !== BigInt(0)) return value;
+                // If the value is an object w/ a toJSON method, toJSON is called before
+                // the replacer runs, so we use this[key] to get the non-toJSONed value.
+                var origValue = this[key];
+                var type = typeof origValue;
+                if ('object' === type) {
+                    if (origValue instanceof RegExp) return '@__R-' + UID + '-' + (regexps.push(origValue) - 1) + '__@';
+                    if (origValue instanceof Date) return '@__D-' + UID + '-' + (dates.push(origValue) - 1) + '__@';
+                    if (origValue instanceof Map) return '@__M-' + UID + '-' + (maps.push(origValue) - 1) + '__@';
+                    if (origValue instanceof Set) return '@__S-' + UID + '-' + (sets.push(origValue) - 1) + '__@';
+                    if (origValue instanceof Array) {
+                        var isSparse = origValue.filter(function() {
+                            return true;
+                        }).length !== origValue.length;
+                        if (isSparse) return '@__A-' + UID + '-' + (arrays.push(origValue) - 1) + '__@';
+                    }
+                    if (origValue instanceof URL) return '@__L-' + UID + '-' + (urls.push(origValue) - 1) + '__@';
+                }
+                if ('function' === type) return '@__F-' + UID + '-' + (functions.push(origValue) - 1) + '__@';
+                if ('undefined' === type) return '@__U-' + UID + '-' + (undefs.push(origValue) - 1) + '__@';
+                if ('number' === type && !isNaN(origValue) && !isFinite(origValue)) return '@__I-' + UID + '-' + (infinities.push(origValue) - 1) + '__@';
+                if ('bigint' === type) return '@__B-' + UID + '-' + (bigInts.push(origValue) - 1) + '__@';
+                return value;
             }
-            const runtimeCode = this.getRawRuntimeRetryCode();
-            if (isRspack) {
-              appendRspackScript(module2, runtimeCode);
-            } else {
-              appendWebpackScript(module2, runtimeCode);
+            function serializeFunc(fn) {
+                var serializedFn = fn.toString();
+                if (IS_NATIVE_CODE_REGEXP.test(serializedFn)) throw new TypeError('Serializing native function: ' + fn.name);
+                // pure functions, example: {key: function() {}}
+                if (IS_PURE_FUNCTION.test(serializedFn)) return serializedFn;
+                // arrow functions, example: arg1 => arg1+5
+                if (IS_ARROW_FUNCTION.test(serializedFn)) return serializedFn;
+                var argsStartsAt = serializedFn.indexOf('(');
+                var def = serializedFn.substr(0, argsStartsAt).trim().split(' ').filter(function(val) {
+                    return val.length > 0;
+                });
+                var nonReservedSymbols = def.filter(function(val) {
+                    return -1 === RESERVED_SYMBOLS.indexOf(val);
+                });
+                // enhanced literal objects, example: {key() {}}
+                if (nonReservedSymbols.length > 0) return (def.indexOf('async') > -1 ? 'async ' : '') + 'function' + (def.join('').indexOf('*') > -1 ? '*' : '') + serializedFn.substr(argsStartsAt);
+                // arrow functions
+                return serializedFn;
             }
-          });
-        });
-      }
+            // Check if the parameter is function
+            if (options.ignoreFunction && "function" == typeof obj) obj = void 0;
+            // Protects against `JSON.stringify()` returning `undefined`, by serializing
+            // to the literal string: "undefined".
+            if (void 0 === obj) return String(obj);
+            var str;
+            // Creates a JSON string representation of the value.
+            // NOTE: Node 0.12 goes into slow mode with extra JSON.stringify() args.
+            str = options.isJSON && !options.space ? JSON.stringify(obj) : JSON.stringify(obj, options.isJSON ? null : replacer, options.space);
+            // Protects against `JSON.stringify()` returning `undefined`, by serializing
+            // to the literal string: "undefined".
+            if ('string' != typeof str) return String(str);
+            // Replace unsafe HTML and invalid JavaScript line terminator chars with
+            // their safe Unicode char counterpart. This _must_ happen before the
+            // regexps and functions are serialized and added back to the string.
+            if (true !== options.unsafe) str = str.replace(UNSAFE_CHARS_REGEXP, escapeUnsafeChars);
+            if (0 === functions.length && 0 === regexps.length && 0 === dates.length && 0 === maps.length && 0 === sets.length && 0 === arrays.length && 0 === undefs.length && 0 === infinities.length && 0 === bigInts.length && 0 === urls.length) return str;
+            // Replaces all occurrences of function, regexp, date, map and set placeholders in the
+            // JSON string with their string representations. If the original value can
+            // not be found, then `undefined` is used.
+            return str.replace(PLACE_HOLDER_REGEXP, function(match, backSlash, type, valueIndex) {
+                // The placeholder may not be preceded by a backslash. This is to prevent
+                // replacing things like `"a\"@__R-<UID>-0__@"` and thus outputting
+                // invalid JS.
+                if (backSlash) return match;
+                if ('D' === type) return "new Date(\"" + dates[valueIndex].toISOString() + "\")";
+                if ('R' === type) return "new RegExp(" + serialize(regexps[valueIndex].source) + ", \"" + regexps[valueIndex].flags + "\")";
+                if ('M' === type) return "new Map(" + serialize(Array.from(maps[valueIndex].entries()), options) + ")";
+                if ('S' === type) return "new Set(" + serialize(Array.from(sets[valueIndex].values()), options) + ")";
+                if ('A' === type) return "Array.prototype.slice.call(" + serialize(Object.assign({
+                    length: arrays[valueIndex].length
+                }, arrays[valueIndex]), options) + ")";
+                if ('U' === type) return 'undefined';
+                if ('I' === type) return infinities[valueIndex];
+                if ('B' === type) return "BigInt(\"" + bigInts[valueIndex] + "\")";
+                if ('L' === type) return "new URL(" + serialize(urls[valueIndex].toString(), options) + ")";
+                var fn = functions[valueIndex];
+                return serializeFunc(fn);
+            });
+        };
+    },
+    crypto: function(module1) {
+        "use strict";
+        module1.exports = require("crypto");
+    }
+};
+/************************************************************************/ // The module cache
+var __webpack_module_cache__ = {};
+// The require function
+function __webpack_require__(moduleId) {
+    // Check if module is in cache
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    // Create a new module (and put it into the cache)
+    var module1 = __webpack_module_cache__[moduleId] = {
+        exports: {}
     };
-  }
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  PLUGIN_ASSETS_RETRY_NAME: () => PLUGIN_ASSETS_RETRY_NAME,
-  pluginAssetsRetry: () => pluginAssetsRetry
-});
-module.exports = __toCommonJS(src_exports);
-var import_node_fs2 = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
-var import_core2 = require("@rsbuild/core");
-var PLUGIN_ASSETS_RETRY_NAME = "rsbuild:assets-retry";
-async function getRetryCode(options) {
-  const { default: serialize2 } = await import("serialize-javascript");
-  const filename = "initialChunkRetry";
-  const { minify, inlineScript: _, ...restOptions } = options;
-  const runtimeFilePath = import_node_path2.default.join(
-    __dirname,
-    "runtime",
-    minify ? `${filename}.min.js` : `${filename}.js`
-  );
-  const runtimeCode = await import_node_fs2.default.promises.readFile(runtimeFilePath, "utf-8");
-  return `(function(){${runtimeCode};init(${serialize2(restOptions)});})()`;
+    // Execute the module function
+    __webpack_modules__[moduleId](module1, module1.exports, __webpack_require__);
+    // Return the exports of the module
+    return module1.exports;
 }
-var pluginAssetsRetry = (userOptions = {}) => ({
-  name: PLUGIN_ASSETS_RETRY_NAME,
-  setup(api) {
-    const { inlineScript = true } = userOptions;
-    const getScriptPath = (environment) => {
-      const distDir = environment.config.output.distPath.js;
-      return import_node_path2.default.posix.join(distDir, `assets-retry.${"1.0.14"}.js`);
+/************************************************************************/ // webpack/runtime/compat_get_default_export
+(()=>{
+    // getDefaultExport function for compatibility with non-ESM modules
+    __webpack_require__.n = function(module1) {
+        var getter = module1 && module1.__esModule ? function() {
+            return module1['default'];
+        } : function() {
+            return module1;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
     };
-    const formatOptions = (config) => {
-      const options = { ...userOptions };
-      if (options.crossOrigin === void 0) {
-        options.crossOrigin = config.html.crossorigin;
-      }
-      if (options.minify === void 0) {
-        const minify = typeof config.output.minify === "boolean" ? config.output.minify : config.output.minify?.js;
-        options.minify = minify && config.mode === "production";
-      }
-      return options;
+})();
+// webpack/runtime/define_property_getters
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
     };
-    if (inlineScript) {
-      api.modifyHTMLTags(async ({ headTags, bodyTags }, { environment }) => {
-        const code = await getRetryCode(formatOptions(environment.config));
-        headTags.unshift({
-          tag: "script",
-          attrs: {},
-          children: code
+})();
+// webpack/runtime/has_own_property
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+// webpack/runtime/make_namespace_object
+(()=>{
+    // define __esModule on exports
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
         });
-        return { headTags, bodyTags };
-      });
-    } else {
-      api.modifyHTMLTags(
-        async ({ headTags, bodyTags }, { assetPrefix, environment }) => {
-          const scriptPath = getScriptPath(environment);
-          const url = (0, import_core2.ensureAssetPrefix)(scriptPath, assetPrefix);
-          headTags.unshift({
-            tag: "script",
-            attrs: {
-              src: url
-            }
-          });
-          return { headTags, bodyTags };
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+/************************************************************************/ var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+(()=>{
+    "use strict";
+    // ESM COMPAT FLAG
+    __webpack_require__.r(__webpack_exports__);
+    // EXPORTS
+    __webpack_require__.d(__webpack_exports__, {
+        PLUGIN_ASSETS_RETRY_NAME: ()=>/* binding */ PLUGIN_ASSETS_RETRY_NAME,
+        pluginAssetsRetry: ()=>/* binding */ pluginAssetsRetry
+    });
+    const external_node_fs_namespaceObject = require("node:fs");
+    var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+    const external_node_path_namespaceObject = require("node:path");
+    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+    const external_node_url_namespaceObject = require("node:url");
+    const core_namespaceObject = require("@rsbuild/core");
+    // EXTERNAL MODULE: ../../node_modules/.pnpm/serialize-javascript@6.0.2/node_modules/serialize-javascript/index.js
+    var serialize_javascript = __webpack_require__("../../node_modules/.pnpm/serialize-javascript@6.0.2/node_modules/serialize-javascript/index.js");
+    var serialize_javascript_default = /*#__PURE__*/ __webpack_require__.n(serialize_javascript);
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    const AsyncChunkRetryPlugin_dirname = external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(/*#__PURE__*/ function() {
+        return 'undefined' == typeof document ? new (module.require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+    }()));
+    // https://github.com/web-infra-dev/rspack/pull/5370
+    function appendWebpackScript(module1, appendSource) {
+        try {
+            const originSource = module1.getGeneratedCode();
+            module1.getGeneratedCode = ()=>`${originSource}\n${appendSource}`;
+        } catch (err) {
+            console.error('Failed to modify Webpack RuntimeModule');
+            throw err;
         }
-      );
-      api.processAssets(
-        { stage: "additional" },
-        async ({ sources, compilation, environment }) => {
-          const scriptPath = getScriptPath(environment);
-          const code = await getRetryCode(formatOptions(environment.config));
-          compilation.emitAsset(scriptPath, new sources.RawSource(code));
+    }
+    function appendRspackScript(module1, appendSource) {
+        try {
+            const source = module1.source.source.toString();
+            module1.source.source = Buffer.from(`${source}\n${appendSource}`, 'utf-8');
+        } catch (err) {
+            console.error('Failed to modify Rspack RuntimeModule');
+            throw err;
         }
-      );
     }
-    api.modifyBundlerChain(async (chain, { environment }) => {
-      const { config, htmlPaths } = environment;
-      if (!userOptions || Object.keys(htmlPaths).length === 0) {
-        return;
-      }
-      const { AsyncChunkRetryPlugin: AsyncChunkRetryPlugin2 } = await Promise.resolve().then(() => (init_AsyncChunkRetryPlugin(), AsyncChunkRetryPlugin_exports));
-      const options = formatOptions(config);
-      const isRspack = api.context.bundlerType === "rspack";
-      chain.plugin("async-chunk-retry").use(AsyncChunkRetryPlugin2, [{ ...options, isRspack }]);
-    });
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PLUGIN_ASSETS_RETRY_NAME,
-  pluginAssetsRetry
+    function pick(obj, keys) {
+        return keys.reduce((ret, key)=>{
+            if (void 0 !== obj[key]) ret[key] = obj[key];
+            return ret;
+        }, {});
+    }
+    class AsyncChunkRetryPlugin {
+        getRawRuntimeRetryCode() {
+            const { RuntimeGlobals } = core_namespaceObject.rspack;
+            const filename = 'asyncChunkRetry';
+            const runtimeFilePath = external_node_path_default().join(AsyncChunkRetryPlugin_dirname, 'runtime', this.options.minify ? `${filename}.min.js` : `${filename}.js`);
+            const rawText = external_node_fs_default().readFileSync(runtimeFilePath, 'utf-8');
+            return rawText.replaceAll('__RUNTIME_GLOBALS_REQUIRE__', RuntimeGlobals.require).replaceAll('__RUNTIME_GLOBALS_ENSURE_CHUNK__', RuntimeGlobals.ensureChunk).replaceAll('__RUNTIME_GLOBALS_GET_CHUNK_SCRIPT_FILENAME__', RuntimeGlobals.getChunkScriptFilename).replaceAll('__RUNTIME_GLOBALS_GET_CSS_FILENAME__', RuntimeGlobals.getChunkCssFilename).replaceAll('__RUNTIME_GLOBALS_GET_MINI_CSS_EXTRACT_FILENAME__', '__webpack_require__.miniCssF').replaceAll('__RUNTIME_GLOBALS_PUBLIC_PATH__', RuntimeGlobals.publicPath).replaceAll('__RUNTIME_GLOBALS_LOAD_SCRIPT__', RuntimeGlobals.loadScript).replaceAll('__RETRY_OPTIONS__', serialize_javascript_default()(this.runtimeOptions));
+        }
+        apply(compiler) {
+            compiler.hooks.thisCompilation.tap(this.name, (compilation)=>{
+                compilation.hooks.runtimeModule.tap(this.name, (module1)=>{
+                    var _module_constructor;
+                    const { isRspack } = this.options;
+                    const constructorName = isRspack ? module1.constructorName : null === (_module_constructor = module1.constructor) || void 0 === _module_constructor ? void 0 : _module_constructor.name;
+                    const isPublicPathModule = 'publicPath' === module1.name || 'PublicPathRuntimeModule' === constructorName || 'AutoPublicPathRuntimeModule' === constructorName;
+                    if (!isPublicPathModule) return;
+                    const runtimeCode = this.getRawRuntimeRetryCode();
+                    // Rspack currently does not have module.addRuntimeModule on the js side,
+                    // so we insert our runtime code after PublicPathRuntimeModule or AutoPublicPathRuntimeModule.
+                    if (isRspack) appendRspackScript(module1, runtimeCode);
+                    else appendWebpackScript(module1, runtimeCode);
+                });
+            });
+        }
+        constructor(options){
+            _define_property(this, "name", 'ASYNC_CHUNK_RETRY_PLUGIN');
+            _define_property(this, "options", void 0);
+            _define_property(this, "runtimeOptions", void 0);
+            this.options = options;
+            this.runtimeOptions = pick(options, [
+                'domain',
+                'max',
+                'onRetry',
+                'onSuccess',
+                'onFail',
+                'addQuery',
+                'test'
+            ]);
+        }
+    }
+    const src_dirname = external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(/*#__PURE__*/ function() {
+        return 'undefined' == typeof document ? new (module.require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+    }()));
+    const PLUGIN_ASSETS_RETRY_NAME = 'rsbuild:assets-retry';
+    async function getRetryCode(options) {
+        const filename = 'initialChunkRetry';
+        const { minify, inlineScript: _, ...restOptions } = options;
+        const runtimeFilePath = external_node_path_default().join(src_dirname, 'runtime', minify ? `${filename}.min.js` : `${filename}.js`);
+        const runtimeCode = await external_node_fs_default().promises.readFile(runtimeFilePath, 'utf-8');
+        return `(function(){${runtimeCode};init(${serialize_javascript_default()(restOptions)});})()`;
+    }
+    const pluginAssetsRetry = (userOptions = {})=>({
+            name: PLUGIN_ASSETS_RETRY_NAME,
+            setup (api) {
+                const { inlineScript = true } = userOptions;
+                const getScriptPath = (environment)=>{
+                    const distDir = environment.config.output.distPath.js;
+                    return external_node_path_default().posix.join(distDir, "assets-retry.1-0-4.js");
+                };
+                const formatOptions = (config)=>{
+                    const options = {
+                        ...userOptions
+                    };
+                    // options.crossOrigin should be same as html.crossorigin by default
+                    if (void 0 === options.crossOrigin) options.crossOrigin = config.html.crossorigin;
+                    if (void 0 === options.minify) {
+                        var _config_output_minify;
+                        const minify = 'boolean' == typeof config.output.minify ? config.output.minify : null === (_config_output_minify = config.output.minify) || void 0 === _config_output_minify ? void 0 : _config_output_minify.js;
+                        options.minify = minify && 'production' === config.mode;
+                    }
+                    return options;
+                };
+                if (inlineScript) api.modifyHTMLTags(async ({ headTags, bodyTags }, { environment })=>{
+                    const code = await getRetryCode(formatOptions(environment.config));
+                    headTags.unshift({
+                        tag: 'script',
+                        attrs: {},
+                        children: code
+                    });
+                    return {
+                        headTags,
+                        bodyTags
+                    };
+                });
+                else {
+                    api.modifyHTMLTags(async ({ headTags, bodyTags }, { assetPrefix, environment })=>{
+                        const scriptPath = getScriptPath(environment);
+                        const url = (0, core_namespaceObject.ensureAssetPrefix)(scriptPath, assetPrefix);
+                        headTags.unshift({
+                            tag: 'script',
+                            attrs: {
+                                src: url
+                            }
+                        });
+                        return {
+                            headTags,
+                            bodyTags
+                        };
+                    });
+                    api.processAssets({
+                        stage: 'additional'
+                    }, async ({ sources, compilation, environment })=>{
+                        const scriptPath = getScriptPath(environment);
+                        const code = await getRetryCode(formatOptions(environment.config));
+                        compilation.emitAsset(scriptPath, new sources.RawSource(code));
+                    });
+                }
+                api.modifyBundlerChain(async (chain, { environment })=>{
+                    const { config, htmlPaths } = environment;
+                    if (!userOptions || 0 === Object.keys(htmlPaths).length) return;
+                    const options = formatOptions(config);
+                    const isRspack = 'rspack' === api.context.bundlerType;
+                    chain.plugin('async-chunk-retry').use(AsyncChunkRetryPlugin, [
+                        {
+                            ...options,
+                            isRspack
+                        }
+                    ]);
+                });
+            }
+        });
+})();
+var __webpack_export_target__ = exports;
+for(var i in __webpack_exports__)__webpack_export_target__[i] = __webpack_exports__[i];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
 });

package/{dist-types → dist}/index.d.ts

@@ -1,5 +1,5 @@
 import type { RsbuildPlugin } from '@rsbuild/core';
-import type { PluginAssetsRetryOptions } from './types';
+import type { PluginAssetsRetryOptions } from './types.js';
 export type { PluginAssetsRetryOptions };
 export declare const PLUGIN_ASSETS_RETRY_NAME = "rsbuild:assets-retry";
 export declare const pluginAssetsRetry: (userOptions?: PluginAssetsRetryOptions) => RsbuildPlugin;