@rsbuild/core 0.4.14 → 0.5.0

package/dist/client/hmr.mjs

@@ -1,286 +1,505 @@
 // src/client/formatStats.ts
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self1 = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self1, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 var friendlySyntaxErrorLabel = "SyntaxError:";
 function isLikelyASyntaxError(message) {
-  return message.includes(friendlySyntaxErrorLabel);
+    return message.includes(friendlySyntaxErrorLabel);
 }
 function formatMessage(stats) {
-  let lines = [];
-  let message;
-  if (typeof stats === "object") {
-    const fileName = stats.moduleName ? `File: ${stats.moduleName}
-` : "";
-    const mainMessage = typeof stats.formatted === "string" ? stats.formatted : stats.message;
-    const details = stats.details ? `
-Details: ${stats.details}
-` : "";
-    const stack = stats.stack ? `
-${stats.stack}` : "";
-    message = `${fileName}${mainMessage}${details}${stack}`;
-  } else {
-    message = stats;
-  }
-  lines = message.split("\n");
-  lines = lines.map((line) => {
-    const parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(
-      line
-    );
-    if (!parsingError) {
-      return line;
+    var lines = [];
+    var message;
+    if (typeof stats === "object") {
+        var fileName = stats.moduleName ? "File: ".concat(stats.moduleName, "\n") : "";
+        var mainMessage = typeof stats.formatted === "string" ? stats.formatted : stats.message;
+        var details = stats.details ? "\nDetails: ".concat(stats.details, "\n") : "";
+        var stack = stats.stack ? "\n".concat(stats.stack) : "";
+        message = "".concat(fileName).concat(mainMessage).concat(details).concat(stack);
+    } else {
+        message = stats;
+    }
+    lines = message.split("\n");
+    lines = lines.map(function(line) {
+        var parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(line);
+        if (!parsingError) {
+            return line;
+        }
+        var _parsingError = _sliced_to_array(parsingError, 4), errorLine = _parsingError[1], errorColumn = _parsingError[2], errorMessage = _parsingError[3];
+        return "".concat(friendlySyntaxErrorLabel, " ").concat(errorMessage, " (").concat(errorLine, ":").concat(errorColumn, ")");
+    });
+    message = lines.join("\n");
+    message = message.replace(/SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g, "".concat(friendlySyntaxErrorLabel, " $3 ($1:$2)\n"));
+    lines = message.split("\n");
+    if (lines.length > 2 && lines[1].trim() === "") {
+        lines.splice(1, 1);
+    }
+    lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, "$1");
+    if (lines[1] && lines[1].indexOf("Module not found:") !== -1) {
+        lines[1] = lines[1].replace("Error: ", "");
     }
-    const [, errorLine, errorColumn, errorMessage] = parsingError;
-    return `${friendlySyntaxErrorLabel} ${errorMessage} (${errorLine}:${errorColumn})`;
-  });
-  message = lines.join("\n");
-  message = message.replace(
-    /SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g,
-    `${friendlySyntaxErrorLabel} $3 ($1:$2)
-`
-  );
-  lines = message.split("\n");
-  if (lines.length > 2 && lines[1].trim() === "") {
-    lines.splice(1, 1);
-  }
-  lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, "$1");
-  if (lines[1] && lines[1].indexOf("Module not found:") !== -1) {
-    lines[1] = lines[1].replace("Error: ", "");
-  }
-  lines = lines.filter(
-    (line, index, arr) => index === 0 || line.trim() !== "" || line.trim() !== arr[index - 1].trim()
-  );
-  message = lines.join("\n");
-  return message.trim();
+    lines = lines.filter(function(line, index, arr) {
+        return index === 0 || line.trim() !== "" || line.trim() !== arr[index - 1].trim();
+    });
+    message = lines.join("\n");
+    return message.trim();
 }
 function formatStatsMessages(json) {
-  const formattedErrors = json?.errors?.map(formatMessage);
-  const formattedWarnings = json?.warnings?.map(formatMessage);
-  const result = {
-    errors: formattedErrors || [],
-    warnings: formattedWarnings || [],
-    errorTips: []
-  };
-  if (result.errors?.some(isLikelyASyntaxError)) {
-    result.errors = result.errors.filter(isLikelyASyntaxError);
-  }
-  if (result.errors.length > 1) {
-    result.errors.length = 1;
-  }
-  return result;
-}
-
+    var _json_errors, _json_warnings, _result_errors;
+    var formattedErrors = json === null || json === void 0 ? void 0 : (_json_errors = json.errors) === null || _json_errors === void 0 ? void 0 : _json_errors.map(formatMessage);
+    var formattedWarnings = json === null || json === void 0 ? void 0 : (_json_warnings = json.warnings) === null || _json_warnings === void 0 ? void 0 : _json_warnings.map(formatMessage);
+    var result = {
+        errors: formattedErrors || [],
+        warnings: formattedWarnings || [],
+        errorTips: []
+    };
+    if ((_result_errors = result.errors) === null || _result_errors === void 0 ? void 0 : _result_errors.some(isLikelyASyntaxError)) {
+        result.errors = result.errors.filter(isLikelyASyntaxError);
+    }
+    if (result.errors.length > 1) {
+        result.errors.length = 1;
+    }
+    return result;
+}
 // src/client/hmr/createSocketUrl.ts
 var HMR_SOCK_PATH = "/rsbuild-hmr";
 function createSocketUrl(resourceQuery) {
-  const searchParams = resourceQuery.substr(1).split("&");
-  const options = {};
-  for (const pair of searchParams) {
-    const ary = pair.split("=");
-    options[ary[0]] = decodeURIComponent(ary[1]);
-  }
-  const currentLocation = self.location;
-  return getSocketUrl(options, currentLocation);
-}
-function formatURL({
-  port,
-  protocol,
-  hostname,
-  pathname
-}) {
-  if (typeof URL !== "undefined") {
-    const url = new URL("http://localhost");
-    url.port = port;
-    url.hostname = hostname;
-    url.protocol = protocol;
-    url.pathname = pathname;
-    return url.toString();
-  }
-  const colon = protocol.indexOf(":") === -1 ? ":" : "";
-  return `${protocol}${colon}//${hostname}:${port}${pathname}`;
+    var searchParams = resourceQuery.substr(1).split("&");
+    var options = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = searchParams[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var pair = _step.value;
+            var ary = pair.split("=");
+            options[ary[0]] = decodeURIComponent(ary[1]);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var currentLocation = self.location;
+    return getSocketUrl(options, currentLocation);
+}
+function formatURL(param) {
+    var port = param.port, protocol = param.protocol, hostname = param.hostname, pathname = param.pathname;
+    if (typeof URL !== "undefined") {
+        var url = new URL("http://localhost");
+        url.port = port;
+        url.hostname = hostname;
+        url.protocol = protocol;
+        url.pathname = pathname;
+        return url.toString();
+    }
+    var colon = protocol.indexOf(":") === -1 ? ":" : "";
+    return "".concat(protocol).concat(colon, "//").concat(hostname, ":").concat(port).concat(pathname);
 }
 function getSocketUrl(urlParts, location) {
-  const { host, port, path, protocol } = urlParts;
-  return formatURL({
-    protocol: protocol || (location.protocol === "https:" ? "wss" : "ws"),
-    hostname: host || location.hostname,
-    port: port || location.port,
-    pathname: path || HMR_SOCK_PATH
-  });
-}
-
+    var host = urlParts.host, port = urlParts.port, path = urlParts.path, protocol = urlParts.protocol;
+    return formatURL({
+        protocol: protocol || (location.protocol === "https:" ? "wss" : "ws"),
+        hostname: host || location.hostname,
+        port: port || location.port,
+        pathname: path || HMR_SOCK_PATH
+    });
+}
 // src/client/hmr/index.ts
 var socketUrl = createSocketUrl(__resourceQuery);
 var isFirstCompilation = true;
 var mostRecentCompilationHash = null;
 var hasCompileErrors = false;
 function clearOutdatedErrors() {
-  if (typeof console !== "undefined" && typeof console.clear === "function") {
-    if (hasCompileErrors) {
-      console.clear();
+    if (typeof console !== "undefined" && typeof console.clear === "function") {
+        if (hasCompileErrors) {
+            console.clear();
+        }
     }
-  }
 }
 function handleSuccess() {
-  clearOutdatedErrors();
-  const isHotUpdate = !isFirstCompilation;
-  isFirstCompilation = false;
-  hasCompileErrors = false;
-  if (isHotUpdate) {
-    tryApplyUpdates();
-  }
+    clearOutdatedErrors();
+    var isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    if (isHotUpdate) {
+        tryApplyUpdates();
+    }
 }
 function handleWarnings(warnings) {
-  clearOutdatedErrors();
-  const isHotUpdate = !isFirstCompilation;
-  isFirstCompilation = false;
-  hasCompileErrors = false;
-  function printWarnings() {
-    const formatted = formatStatsMessages({
-      warnings,
-      errors: []
-    });
-    if (typeof console !== "undefined" && typeof console.warn === "function") {
-      for (let i = 0; i < formatted.warnings.length; i++) {
-        if (i === 5) {
-          console.warn(
-            "There were more warnings in other files.\nYou can find a complete log in the terminal."
-          );
-          break;
+    clearOutdatedErrors();
+    var isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    function printWarnings() {
+        var formatted = formatStatsMessages({
+            warnings: warnings,
+            errors: []
+        });
+        if (typeof console !== "undefined" && typeof console.warn === "function") {
+            for(var i = 0; i < formatted.warnings.length; i++){
+                if (i === 5) {
+                    console.warn("There were more warnings in other files.\nYou can find a complete log in the terminal.");
+                    break;
+                }
+                console.warn(formatted.warnings[i]);
+            }
         }
-        console.warn(formatted.warnings[i]);
-      }
     }
-  }
-  printWarnings();
-  if (isHotUpdate) {
-    tryApplyUpdates();
-  }
+    printWarnings();
+    if (isHotUpdate) {
+        tryApplyUpdates();
+    }
 }
 function handleErrors(errors) {
-  clearOutdatedErrors();
-  isFirstCompilation = false;
-  hasCompileErrors = true;
-  const formatted = formatStatsMessages({
-    errors,
-    warnings: []
-  });
-  if (typeof console !== "undefined" && typeof console.error === "function") {
-    for (const error of formatted.errors) {
-      console.error(error);
+    clearOutdatedErrors();
+    isFirstCompilation = false;
+    hasCompileErrors = true;
+    var formatted = formatStatsMessages({
+        errors: errors,
+        warnings: []
+    });
+    if (typeof console !== "undefined" && typeof console.error === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = formatted.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var error = _step.value;
+                console.error(error);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
     }
-  }
 }
 function handleAvailableHash(hash) {
-  mostRecentCompilationHash = hash;
+    mostRecentCompilationHash = hash;
 }
 function isUpdateAvailable() {
-  return mostRecentCompilationHash !== __webpack_hash__;
+    return mostRecentCompilationHash !== __webpack_hash__;
 }
 function canApplyUpdates() {
-  return import.meta.webpackHot.status() === "idle";
+    return import.meta.webpackHot.status() === "idle";
 }
 function tryApplyUpdates() {
-  if (!isUpdateAvailable()) {
-    return;
-  }
-  if (!import.meta.webpackHot) {
-    window.location.reload();
-    return;
-  }
-  if (!canApplyUpdates()) {
-    return;
-  }
-  function handleApplyUpdates(err, updatedModules) {
-    const wantsForcedReload = err || !updatedModules;
-    if (wantsForcedReload) {
-      window.location.reload();
-      return;
+    if (!isUpdateAvailable()) {
+        return;
+    }
+    if (!import.meta.webpackHot) {
+        window.location.reload();
+        return;
     }
-    if (isUpdateAvailable()) {
-      tryApplyUpdates();
+    if (!canApplyUpdates()) {
+        return;
     }
-  }
-  import.meta.webpackHot.check(true).then(
-    (updatedModules) => {
-      handleApplyUpdates(null, updatedModules);
-    },
-    (err) => {
-      handleApplyUpdates(err, null);
+    function handleApplyUpdates(err, updatedModules) {
+        var wantsForcedReload = err || !updatedModules;
+        if (wantsForcedReload) {
+            window.location.reload();
+            return;
+        }
+        if (isUpdateAvailable()) {
+            tryApplyUpdates();
+        }
     }
-  );
+    import.meta.webpackHot.check(true).then(function(updatedModules) {
+        handleApplyUpdates(null, updatedModules);
+    }, function(err) {
+        handleApplyUpdates(err, null);
+    });
 }
 var MAX_RETRIES = 100;
 var connection = null;
 var retry_counter = 0;
 function onOpen() {
-  if (typeof console !== "undefined" && typeof console.info === "function") {
-    console.info("[HMR] connected.");
-  }
+    if (typeof console !== "undefined" && typeof console.info === "function") {
+        console.info("[HMR] connected.");
+    }
 }
 function onMessage(e) {
-  const message = JSON.parse(e.data);
-  switch (message.type) {
-    case "hash":
-      handleAvailableHash(message.data);
-      break;
-    case "still-ok":
-    case "ok":
-      handleSuccess();
-      break;
-    case "content-changed":
-      window.location.reload();
-      break;
-    case "warnings":
-      handleWarnings(message.data);
-      break;
-    case "errors":
-      handleErrors(message.data);
-      break;
-    default:
-  }
-}
-async function sleep(msec = 1e3) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, msec);
-  });
-}
-async function onClose() {
-  if (typeof console !== "undefined" && typeof console.info === "function") {
-    console.info("[HMR] disconnected. Attempting to reconnect.");
-  }
-  removeListeners();
-  await sleep(1e3);
-  retry_counter++;
-  if (connection && (connection.readyState === connection.CONNECTING || connection.readyState === connection.OPEN)) {
-    retry_counter = 0;
-    return;
-  }
-  if (retry_counter > MAX_RETRIES) {
-    if (typeof console !== "undefined" && typeof console.info === "function") {
-      console.info(
-        "[HMR] Unable to establish a connection after exceeding the maximum retry attempts."
-      );
+    var message = JSON.parse(e.data);
+    switch(message.type){
+        case "hash":
+            handleAvailableHash(message.data);
+            break;
+        case "still-ok":
+        case "ok":
+            handleSuccess();
+            break;
+        case "content-changed":
+            window.location.reload();
+            break;
+        case "warnings":
+            handleWarnings(message.data);
+            break;
+        case "errors":
+            handleErrors(message.data);
+            break;
+        default:
     }
-    retry_counter = 0;
-    return;
-  }
-  reconnect();
+}
+function sleep() {
+    return _sleep.apply(this, arguments);
+}
+function _sleep() {
+    _sleep = _async_to_generator(function() {
+        var msec;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            msec = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : 1e3;
+            return [
+                2,
+                new Promise(function(resolve) {
+                    setTimeout(resolve, msec);
+                })
+            ];
+        });
+    });
+    return _sleep.apply(this, arguments);
+}
+function onClose() {
+    return _onClose.apply(this, arguments);
+}
+function _onClose() {
+    _onClose = _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (typeof console !== "undefined" && typeof console.info === "function") {
+                        console.info("[HMR] disconnected. Attempting to reconnect.");
+                    }
+                    removeListeners();
+                    return [
+                        4,
+                        sleep(1e3)
+                    ];
+                case 1:
+                    _state.sent();
+                    retry_counter++;
+                    if (connection && (connection.readyState === connection.CONNECTING || connection.readyState === connection.OPEN)) {
+                        retry_counter = 0;
+                        return [
+                            2
+                        ];
+                    }
+                    if (retry_counter > MAX_RETRIES) {
+                        if (typeof console !== "undefined" && typeof console.info === "function") {
+                            console.info("[HMR] Unable to establish a connection after exceeding the maximum retry attempts.");
+                        }
+                        retry_counter = 0;
+                        return [
+                            2
+                        ];
+                    }
+                    reconnect();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _onClose.apply(this, arguments);
 }
 function connect() {
-  connection = new WebSocket(socketUrl);
-  connection.addEventListener("open", onOpen);
-  connection.addEventListener("close", onClose);
-  connection.addEventListener("message", onMessage);
+    connection = new WebSocket(socketUrl);
+    connection.addEventListener("open", onOpen);
+    connection.addEventListener("close", onClose);
+    connection.addEventListener("message", onMessage);
 }
 function removeListeners() {
-  if (connection) {
-    connection.removeEventListener("open", onOpen);
-    connection.removeEventListener("close", onClose);
-    connection.removeEventListener("message", onMessage);
-  }
+    if (connection) {
+        connection.removeEventListener("open", onOpen);
+        connection.removeEventListener("close", onClose);
+        connection.removeEventListener("message", onMessage);
+    }
 }
 function reconnect() {
-  if (connection) {
-    connection = null;
-  }
-  connect();
+    if (connection) {
+        connection = null;
+    }
+    connect();
 }
 connect();