@rsbuild/webpack 1.0.11 → 1.1.0-beta.1

package/dist/238.js

@@ -0,0 +1,332 @@
+export const ids = [
+    '238'
+];
+export const modules = {
+    "./src/progress/ProgressPlugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        // EXPORTS
+        __webpack_require__.d(__webpack_exports__, {
+            ProgressPlugin: ()=>/* binding */ ProgressPlugin
+        });
+        // EXTERNAL MODULE: external "@rsbuild/core"
+        var core_ = __webpack_require__("@rsbuild/core");
+        // EXTERNAL MODULE: external "picocolors"
+        var external_picocolors_ = __webpack_require__("picocolors");
+        // EXTERNAL MODULE: external "webpack"
+        var external_webpack_ = __webpack_require__("webpack");
+        // EXTERNAL MODULE: ./src/shared.ts
+        var shared = __webpack_require__("./src/shared.ts");
+        // EXTERNAL MODULE: external "node:console"
+        var external_node_console_ = __webpack_require__("node:console");
+        // EXTERNAL MODULE: ../../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js
+        var cli_truncate = __webpack_require__("../../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js");
+        var cli_truncate_default = /*#__PURE__*/ __webpack_require__.n(cli_truncate);
+        // EXTERNAL MODULE: ../../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js
+        var build = __webpack_require__("../../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js");
+        var build_default = /*#__PURE__*/ __webpack_require__.n(build);
+        const clamp = (x, min, max)=>Math.min(max, Math.max(min, x));
+        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: 'gray',
+            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; // display all info
+        const MIDDLE_WIDTH = 40; // remove message info
+        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 = clamp(Math.floor(current / total * 100), 0, 100);
+            // @ts-expect-error
+            const barColor = external_picocolors_["default"][color];
+            // @ts-expect-error
+            const backgroundColor = external_picocolors_["default"][bgColor];
+            const doneColor = hasErrors ? external_picocolors_["default"].red : barColor;
+            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 message = external_picocolors_["default"].bold(doneColor(errorInfo));
+                    if (terminalWidth >= MIDDLE_WIDTH) return [
+                        idColor(errorIcon),
+                        id,
+                        doneColor(`${space}${message}`)
+                    ].join('');
+                    return [
+                        id,
+                        doneColor(`${message}`)
+                    ].join('');
+                }
+                return '';
+            }
+            // @ts-expect-error
+            const msgStr = external_picocolors_["default"][messageColor](cli_truncate_default()(message, messageWidth, {
+                position: 'start'
+            }));
+            const left = clamp(Math.floor(percent * width / 100), 0, width);
+            const right = 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('');
+        };
+        // EXTERNAL MODULE: ../../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js
+        var ansi_escapes = __webpack_require__("../../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js");
+        var ansi_escapes_default = /*#__PURE__*/ __webpack_require__.n(ansi_escapes);
+        const create = (stream)=>{
+            let previousLineCount = 0;
+            let previousOutput = '';
+            const render = (str)=>{
+                const output = `${str}\n`;
+                if (output === previousOutput) return;
+                previousOutput = output;
+                stream.write(ansi_escapes_default().eraseLines(previousLineCount) + output);
+                previousLineCount = output.split('\n').length;
+            };
+            render.clear = ()=>{
+                stream.write(ansi_escapes_default().eraseLines(previousLineCount));
+                previousOutput = '';
+                previousLineCount = 0;
+            };
+            render.done = ()=>{
+                previousOutput = '';
+                previousLineCount = 0;
+            };
+            return render;
+        };
+        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 colorList = [
+            'green',
+            'cyan',
+            'yellow',
+            'blue',
+            'magenta'
+        ];
+        const getProgressColor = (index)=>colorList[index % colorList.length];
+        class Bus {
+            update(state) {
+                const index = this.states.findIndex((i)=>i.id === state.id);
+                if (-1 === index) {
+                    this.states.push(state);
+                    return;
+                }
+                this.states[index] = state;
+            }
+            writeToStd(type = 'stdout', data) {
+                this.log.clear();
+                if (data) {
+                    if ('stdout' === type) process.stdout.write(data);
+                    else if ('stderr' === type) process.stderr.write(data);
+                }
+                this.log(this.prevOutput);
+            }
+            render() {
+                const maxIdLen = Math.max(...this.states.map((i)=>{
+                    var _i_id;
+                    return (null === (_i_id = i.id) || void 0 === _i_id ? void 0 : _i_id.length) ?? 0;
+                })) + 2;
+                const { columns = FULL_WIDTH } = process.stdout;
+                this.prevOutput = this.states.map((i, k)=>{
+                    const bar = renderBar({
+                        maxIdLen,
+                        color: i.color ?? getProgressColor(k),
+                        ...i
+                    });
+                    if (bar) return cli_truncate_default()(bar, columns, {
+                        position: 'end'
+                    });
+                    return null;
+                }).filter((item)=>null !== item).join('\n');
+                this.writeToStd();
+            }
+            destroy() {
+                if (!this.destroyed) this.restore();
+                this.destroyed = true;
+            }
+            clear() {
+                this.log.clear();
+                this.log.done();
+            }
+            constructor(){
+                _define_property(this, "states", []);
+                _define_property(this, "log", void 0);
+                _define_property(this, "restore", void 0);
+                _define_property(this, "prevOutput", void 0);
+                _define_property(this, "destroyed", false);
+                this.prevOutput = '';
+                this.log = create(process.stdout);
+                console.Console = external_node_console_.Console;
+                this.restore = build_default()((type, data)=>{
+                    this.writeToStd(type, data);
+                });
+            }
+        }
+        const bus = new Bus();
+        /**
+ * 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.
+ */ const createFriendlyPercentage = ()=>{
+            let prevPercentage = 0;
+            return (percentage)=>{
+                if (0 === percentage || 1 === percentage) {
+                    prevPercentage = 0;
+                    return percentage;
+                }
+                if (percentage <= prevPercentage) {
+                    let step = 0;
+                    if (prevPercentage < 0.3) step = 0.001;
+                    else if (prevPercentage < 0.6) step = 0.002;
+                    else if (prevPercentage < 0.8) step = 0.004;
+                    else if (prevPercentage < 0.99) step = 0.002;
+                    prevPercentage += step;
+                    return prevPercentage;
+                }
+                prevPercentage = percentage;
+                return percentage;
+            };
+        };
+        function createNonTTYLogger() {
+            let prevPercentage = 0;
+            const log = ({ id, done, current, hasErrors, compileTime })=>{
+                const suffix = external_picocolors_["default"].gray(`(${id})`);
+                if (done) {
+                    // avoid printing done twice
+                    if (100 === prevPercentage) return;
+                    prevPercentage = 100;
+                    if (hasErrors) core_.logger.error(`Built failed in ${compileTime} ${suffix}`);
+                    else core_.logger.ready(`Built in ${compileTime} ${suffix}`);
+                } else if (current - prevPercentage > 10) {
+                    prevPercentage = current;
+                    core_.logger.info(`Build progress: ${current.toFixed(0)}% ${suffix}`);
+                }
+            };
+            return {
+                log
+            };
+        }
+        function ProgressPlugin_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;
+        }
+        class ProgressPlugin extends external_webpack_["default"].ProgressPlugin {
+            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();
+                        const hrtime = process.hrtime(startTime);
+                        const seconds = hrtime[0] + hrtime[1] / 1e9;
+                        this.compileTime = (0, shared /* prettyTime */ .AS)(seconds);
+                        startTime = null;
+                        if (!this.hasCompileErrors) {
+                            const suffix = this.id ? external_picocolors_["default"].gray(` (${this.id})`) : '';
+                            core_.logger.ready(`Built in ${this.compileTime} ${suffix}`);
+                        }
+                    }
+                });
+            }
+            constructor(options){
+                const { id = 'Rsbuild' } = options;
+                const nonTTYLogger = createNonTTYLogger();
+                const friendlyPercentage = createFriendlyPercentage();
+                super({
+                    activeModules: false,
+                    entries: true,
+                    modules: true,
+                    modulesCount: 5000,
+                    profile: false,
+                    dependencies: true,
+                    dependenciesCount: 10000,
+                    percentBy: null,
+                    handler: (originalPercentage, message)=>{
+                        const percentage = friendlyPercentage(originalPercentage);
+                        const done = 1 === percentage;
+                        if (process.stdout.isTTY) {
+                            bus.update({
+                                id,
+                                current: 100 * percentage,
+                                message,
+                                done,
+                                hasErrors: this.hasCompileErrors
+                            });
+                            bus.render();
+                        } else nonTTYLogger.log({
+                            id,
+                            done,
+                            current: 100 * percentage,
+                            hasErrors: this.hasCompileErrors,
+                            compileTime: this.compileTime
+                        });
+                    }
+                }), ProgressPlugin_define_property(this, "name", 'ProgressPlugin'), ProgressPlugin_define_property(this, "id", void 0), ProgressPlugin_define_property(this, "hasCompileErrors", false), ProgressPlugin_define_property(this, "compileTime", null);
+                this.id = id;
+            }
+        }
+    }
+};