@rsbuild/webpack 0.0.0-next-20231103091827

package/dist/webpackPlugins/ProgressPlugin/ProgressPlugin.d.ts

@@ -0,0 +1,13 @@
+import webpack from 'webpack';
+import type { Props } from './helpers/type';
+export interface ProgressOptions extends Omit<Partial<Props>, 'message' | 'total' | 'current' | 'done'> {
+  id?: string;
+}
+export declare class ProgressPlugin extends webpack.ProgressPlugin {
+  readonly name: string;
+  id: string;
+  hasCompileErrors: boolean;
+  compileTime: string | null;
+  constructor(options: ProgressOptions);
+  apply(compiler: webpack.Compiler): void;
+}

package/dist/webpackPlugins/ProgressPlugin/ProgressPlugin.js

@@ -0,0 +1,102 @@
+"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 __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 ProgressPlugin_exports = {};
+__export(ProgressPlugin_exports, {
+  ProgressPlugin: () => ProgressPlugin
+});
+module.exports = __toCommonJS(ProgressPlugin_exports);
+var import_webpack = __toESM(require("webpack"));
+var import_shared = require("@rsbuild/shared");
+var import_helpers = require("./helpers");
+var import_nonTty = require("./helpers/nonTty");
+class ProgressPlugin extends import_webpack.default.ProgressPlugin {
+  constructor(options) {
+    const { id = "Rsbuild" } = options;
+    const nonTTYLogger = (0, import_nonTty.createNonTTYLogger)();
+    const friendlyPercentage = (0, import_helpers.createFriendlyPercentage)();
+    super({
+      activeModules: false,
+      entries: true,
+      modules: true,
+      modulesCount: 5e3,
+      profile: false,
+      dependencies: true,
+      dependenciesCount: 1e4,
+      percentBy: null,
+      handler: (percentage, message) => {
+        percentage = friendlyPercentage(percentage);
+        const done = percentage === 1;
+        if (process.stdout.isTTY) {
+          import_helpers.bus.update({
+            id,
+            current: percentage * 100,
+            message,
+            done,
+            hasErrors: this.hasCompileErrors
+          });
+          import_helpers.bus.render();
+        } else {
+          nonTTYLogger.log({
+            id,
+            done,
+            current: percentage * 100,
+            hasErrors: this.hasCompileErrors,
+            compileTime: this.compileTime
+          });
+        }
+      }
+    });
+    this.name = "ProgressPlugin";
+    this.hasCompileErrors = false;
+    this.compileTime = null;
+    this.id = id;
+  }
+  apply(compiler) {
+    super.apply(compiler);
+    let startTime = null;
+    compiler.hooks.compile.tap(this.name, () => {
+      this.compileTime = null;
+      startTime = process.hrtime();
+    });
+    compiler.hooks.done.tap(this.name, (stat) => {
+      if (startTime) {
+        this.hasCompileErrors = stat.hasErrors();
+        this.compileTime = (0, import_shared.prettyTime)(process.hrtime(startTime));
+        startTime = null;
+        if (!this.hasCompileErrors) {
+          import_shared.logger.ready(`${this.id} compiled in ${this.compileTime}`);
+        }
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProgressPlugin
+});

package/dist/webpackPlugins/ProgressPlugin/helpers/bar.d.ts

@@ -0,0 +1,5 @@
+import type { Props } from './type';
+export declare const FULL_WIDTH = 70;
+export declare const MIDDLE_WIDTH = 40;
+export declare const SMALL_WIDTH = 15;
+export declare const renderBar: (option: Partial<Props>) => string;

package/dist/webpackPlugins/ProgressPlugin/helpers/bar.js

@@ -0,0 +1,143 @@
+"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 __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 bar_exports = {};
+__export(bar_exports, {
+  FULL_WIDTH: () => FULL_WIDTH,
+  MIDDLE_WIDTH: () => MIDDLE_WIDTH,
+  SMALL_WIDTH: () => SMALL_WIDTH,
+  renderBar: () => renderBar
+});
+module.exports = __toCommonJS(bar_exports);
+var import_cli_truncate = __toESM(require("../../../../compiled/cli-truncate"));
+var import_utils = require("./utils");
+var import_chalk = require("@rsbuild/shared/chalk");
+const defaultOption = {
+  total: 100,
+  current: 0,
+  color: "green",
+  bgColor: "gray",
+  char: "━",
+  width: 25,
+  buildIcon: "◯",
+  errorIcon: "✖",
+  errorInfo: "compile failed",
+  message: "",
+  done: false,
+  spaceWidth: 1,
+  messageWidth: 25,
+  messageColor: "grey",
+  id: "",
+  maxIdLen: 16,
+  hasErrors: false
+};
+const padding = (id, maxLen) => {
+  const left = Math.floor((maxLen - id.length) / 2);
+  const right = maxLen - left - id.length;
+  return " ".repeat(left) + id + " ".repeat(right);
+};
+const FULL_WIDTH = 70;
+const MIDDLE_WIDTH = 40;
+const SMALL_WIDTH = 15;
+const renderBar = (option) => {
+  const mergedOptions = {
+    ...defaultOption,
+    ...option
+  };
+  const {
+    total,
+    done,
+    buildIcon,
+    errorIcon,
+    errorInfo,
+    width,
+    current,
+    color,
+    bgColor,
+    char,
+    message,
+    messageWidth,
+    spaceWidth,
+    messageColor,
+    maxIdLen,
+    hasErrors
+  } = mergedOptions;
+  const space = " ".repeat(spaceWidth);
+  const percent = (0, import_utils.clamp)(Math.floor(current / total * 100), 0, 100);
+  const barColor = Reflect.get(import_chalk.chalk, color);
+  const backgroundColor = Reflect.get(import_chalk.chalk, bgColor);
+  const doneColor = hasErrors ? import_chalk.chalk.bold.red : Reflect.get(import_chalk.chalk, color);
+  const idColor = done ? doneColor : barColor;
+  const id = mergedOptions.id ? idColor(padding(mergedOptions.id, maxIdLen)) : "";
+  const { columns: terminalWidth = FULL_WIDTH } = process.stdout;
+  if (done) {
+    if (hasErrors) {
+      const message2 = doneColor(errorInfo);
+      if (terminalWidth >= MIDDLE_WIDTH) {
+        return [idColor(errorIcon), id, doneColor(`${space}${message2}`)].join(
+          ""
+        );
+      }
+      return [id, doneColor(`${message2}`)].join("");
+    }
+    return "";
+  }
+  const msgStr = Reflect.get(
+    import_chalk.chalk,
+    messageColor
+  )((0, import_cli_truncate.default)(message, messageWidth, { position: "start" }));
+  const left = (0, import_utils.clamp)(Math.floor(percent * width / 100), 0, width);
+  const right = (0, import_utils.clamp)(width - left, 0, width);
+  const barStr = `${barColor(char.repeat(left))}${backgroundColor(
+    char.repeat(right)
+  )}`;
+  const percentStr = `${percent.toString().padStart(3)}%`;
+  if (terminalWidth >= FULL_WIDTH) {
+    return [
+      idColor(buildIcon),
+      id,
+      space,
+      barStr,
+      space,
+      percentStr,
+      space,
+      msgStr
+    ].join("");
+  }
+  if (terminalWidth >= MIDDLE_WIDTH) {
+    return [idColor(buildIcon), id, space, barStr, space, percentStr].join("");
+  }
+  return [idColor(buildIcon), id, space, percentStr].join("");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FULL_WIDTH,
+  MIDDLE_WIDTH,
+  SMALL_WIDTH,
+  renderBar
+});

package/dist/webpackPlugins/ProgressPlugin/helpers/bus.d.ts

@@ -0,0 +1,17 @@
+import type { Props } from './type';
+import type { LogUpdate } from './log';
+declare class Bus {
+  states: Partial<Props>[];
+  log: LogUpdate;
+  restore: () => void;
+  prevOutput: string;
+  destroyed: boolean;
+  constructor();
+  update(state: Partial<Props>): void;
+  writeToStd(type?: 'stdout' | 'stderr', data?: string): void;
+  render(): void;
+  destroy(): void;
+  clear(): void;
+}
+declare const bus: Bus;
+export { bus };

package/dist/webpackPlugins/ProgressPlugin/helpers/bus.js

@@ -0,0 +1,105 @@
+"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 __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 bus_exports = {};
+__export(bus_exports, {
+  bus: () => bus
+});
+module.exports = __toCommonJS(bus_exports);
+var import_console = require("console");
+var import_patch_console = __toESM(require("../../../../compiled/patch-console"));
+var import_cli_truncate = __toESM(require("../../../../compiled/cli-truncate"));
+var import_bar = require("./bar");
+var import_log = require("./log");
+var import_shared = require("@rsbuild/shared");
+class Bus {
+  constructor() {
+    this.states = [];
+    this.destroyed = false;
+    this.prevOutput = "";
+    this.log = (0, import_log.create)(process.stdout);
+    console.Console = import_console.Console;
+    this.restore = (0, import_patch_console.default)((type, data) => {
+      this.writeToStd(type, data);
+    });
+  }
+  update(state) {
+    const index = this.states.findIndex((i) => i.id === state.id);
+    if (index === -1) {
+      this.states.push(state);
+      return;
+    }
+    this.states[index] = state;
+  }
+  writeToStd(type = "stdout", data) {
+    this.log.clear();
+    if (data) {
+      if (type === "stdout") {
+        process.stdout.write(data);
+      } else if (type === "stderr") {
+        process.stderr.write(data);
+      }
+    }
+    this.log(this.prevOutput);
+  }
+  render() {
+    const maxIdLen = Math.max(...this.states.map((i) => {
+      var _a, _b;
+      return (_b = (_a = i.id) == null ? void 0 : _a.length) != null ? _b : 0;
+    })) + 2;
+    const { columns = import_bar.FULL_WIDTH } = process.stdout;
+    this.prevOutput = this.states.map((i, k) => {
+      var _a;
+      const bar = (0, import_bar.renderBar)({
+        maxIdLen,
+        color: (_a = i.color) != null ? _a : (0, import_shared.getProgressColor)(k),
+        ...i
+      });
+      if (bar) {
+        return (0, import_cli_truncate.default)(bar, columns, { position: "end" });
+      }
+      return null;
+    }).filter((item) => item !== null).join("\n");
+    this.writeToStd();
+  }
+  destroy() {
+    if (!this.destroyed) {
+      this.restore();
+    }
+    this.destroyed = true;
+  }
+  clear() {
+    this.log.clear();
+    this.log.done();
+  }
+}
+const bus = new Bus();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bus
+});

package/dist/webpackPlugins/ProgressPlugin/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bus';
+export * from './bar';
+export * from './type';
+export * from './percentage';

package/dist/webpackPlugins/ProgressPlugin/helpers/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helpers_exports = {};
+module.exports = __toCommonJS(helpers_exports);
+__reExport(helpers_exports, require("./bus"), module.exports);
+__reExport(helpers_exports, require("./bar"), module.exports);
+__reExport(helpers_exports, require("./type"), module.exports);
+__reExport(helpers_exports, require("./percentage"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./bus"),
+  ...require("./bar"),
+  ...require("./type"),
+  ...require("./percentage")
+});

package/dist/webpackPlugins/ProgressPlugin/helpers/log.d.ts

@@ -0,0 +1,8 @@
+import { Writable } from 'stream';
+export interface LogUpdate {
+  clear: () => void;
+  done: () => void;
+  (str: string): void;
+}
+declare const create: (stream: Writable) => LogUpdate;
+export { create };

package/dist/webpackPlugins/ProgressPlugin/helpers/log.js

@@ -0,0 +1,62 @@
+"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 __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 log_exports = {};
+__export(log_exports, {
+  create: () => create
+});
+module.exports = __toCommonJS(log_exports);
+var import_ansi_escapes = __toESM(require("../../../../compiled/ansi-escapes"));
+const create = (stream) => {
+  let previousLineCount = 0;
+  let previousOutput = "";
+  const render = (str) => {
+    const output = `${str}
+`;
+    if (output === previousOutput) {
+      return;
+    }
+    previousOutput = output;
+    stream.write(import_ansi_escapes.default.eraseLines(previousLineCount) + output);
+    previousLineCount = output.split("\n").length;
+  };
+  render.clear = () => {
+    stream.write(import_ansi_escapes.default.eraseLines(previousLineCount));
+    previousOutput = "";
+    previousLineCount = 0;
+  };
+  render.done = () => {
+    previousOutput = "";
+    previousLineCount = 0;
+  };
+  return render;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create
+});

package/dist/webpackPlugins/ProgressPlugin/helpers/nonTty.d.ts

@@ -0,0 +1,15 @@
+export declare function createNonTTYLogger(): {
+  log: ({
+    id,
+    done,
+    current,
+    hasErrors,
+    compileTime
+  }: {
+    id: string;
+    done: boolean;
+    current: number;
+    hasErrors: boolean;
+    compileTime: string | null;
+  }) => void;
+};

package/dist/webpackPlugins/ProgressPlugin/helpers/nonTty.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var nonTty_exports = {};
+__export(nonTty_exports, {
+  createNonTTYLogger: () => createNonTTYLogger
+});
+module.exports = __toCommonJS(nonTty_exports);
+var import_shared = require("@rsbuild/shared");
+function createNonTTYLogger() {
+  let prevPercentage = 0;
+  const log = ({
+    id,
+    done,
+    current,
+    hasErrors,
+    compileTime
+  }) => {
+    if (done) {
+      if (prevPercentage === 100) {
+        return;
+      }
+      prevPercentage = 100;
+      if (hasErrors) {
+        import_shared.logger.error(`${id} compile failed in ${compileTime}`);
+      } else {
+        import_shared.logger.ready(`${id} compiled in ${compileTime}`);
+      }
+    } else if (current - prevPercentage > 10) {
+      prevPercentage = current;
+      import_shared.logger.info(`${id} compile progress: ${current.toFixed(0)}%`);
+    }
+  };
+  return {
+    log
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNonTTYLogger
+});

package/dist/webpackPlugins/ProgressPlugin/helpers/percentage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Make the progress percentage more user friendly.
+ * The original percentage may pause at certain number for a long time,
+ * or decrease in some cases, which will confuse the user.
+ * So we format the percentage number and display a more smooth percentage.
+ */
+export declare const createFriendlyPercentage: () => (percentage: number) => number;

package/dist/webpackPlugins/ProgressPlugin/helpers/percentage.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var percentage_exports = {};
+__export(percentage_exports, {
+  createFriendlyPercentage: () => createFriendlyPercentage
+});
+module.exports = __toCommonJS(percentage_exports);
+const createFriendlyPercentage = () => {
+  let prevPercentage = 0;
+  return (percentage) => {
+    if (percentage === 0 || percentage === 1) {
+      prevPercentage = 0;
+      return percentage;
+    }
+    if (percentage <= prevPercentage) {
+      let step = 0;
+      if (prevPercentage < 0.3) {
+        step = 1e-3;
+      } else if (prevPercentage < 0.6) {
+        step = 2e-3;
+      } else if (prevPercentage < 0.8) {
+        step = 4e-3;
+      } else if (prevPercentage < 0.99) {
+        step = 2e-3;
+      }
+      prevPercentage += step;
+      return prevPercentage;
+    }
+    prevPercentage = percentage;
+    return percentage;
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFriendlyPercentage
+});

package/dist/webpackPlugins/ProgressPlugin/helpers/type.d.ts

@@ -0,0 +1,25 @@
+import type { chalk } from '@rsbuild/shared/chalk';
+type Color = (typeof chalk)['ForegroundColor'];
+export type Props = {
+  total: number;
+  current: number;
+  color: Color;
+  bgColor: Color;
+  char: string;
+  width: number;
+  buildIcon: string;
+  errorIcon: string;
+  errorInfo: string;
+  message: string;
+  done: boolean;
+  messageWidth: number;
+  spaceWidth: number;
+  messageColor: Color;
+  id: string;
+  maxIdLen: number;
+  hasErrors: boolean;
+};
+export type BusOption = {
+  state: Props[];
+};
+export {};

package/dist/webpackPlugins/ProgressPlugin/helpers/type.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);

package/dist/webpackPlugins/ProgressPlugin/helpers/utils.d.ts

@@ -0,0 +1 @@
+export declare const clamp: (x: number, min: number, max: number) => number;