@rspack/dev-server 2.0.0-beta.1 → 2.0.0-beta.2

package/client/modules/logger/Logger.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+import { type Args, type EXPECTED_ANY, type LogTypeEnum } from '../types.js';
+declare const LOG_SYMBOL: unique symbol;
+declare const TIMERS_SYMBOL: unique symbol;
+declare const TIMERS_AGGREGATES_SYMBOL: unique symbol;
+declare class WebpackLogger {
+    private [LOG_SYMBOL];
+    private [TIMERS_SYMBOL];
+    private [TIMERS_AGGREGATES_SYMBOL];
+    private getChildLogger;
+    constructor(log: (type: LogTypeEnum, args?: Args) => void, getChildLogger: (name: string | (() => string)) => WebpackLogger);
+    error(...args: Args): void;
+    warn(...args: Args): void;
+    info(...args: Args): void;
+    log(...args: Args): void;
+    debug(...args: Args): void;
+    assert(assertion: EXPECTED_ANY, ...args: Args): void;
+    trace(): void;
+    clear(): void;
+    status(...args: Args): void;
+    group(...args: Args): void;
+    groupCollapsed(...args: Args): void;
+    groupEnd(): void;
+    profile(label?: string): void;
+    profileEnd(label?: string): void;
+    time(label: string): void;
+    timeLog(label?: string): void;
+    timeEnd(label?: string): void;
+    timeAggregate(label?: string): void;
+    timeAggregateEnd(label?: string): void;
+}
+export { WebpackLogger as Logger };

package/client/modules/logger/Logger.js

@@ -0,0 +1,123 @@
+import { LogType } from "../types.js";
+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 LOG_SYMBOL = Symbol('webpack logger raw log method');
+const TIMERS_SYMBOL = Symbol('webpack logger times');
+const TIMERS_AGGREGATES_SYMBOL = Symbol('webpack logger aggregated times');
+let _LOG_SYMBOL = LOG_SYMBOL, _TIMERS_SYMBOL = TIMERS_SYMBOL, _TIMERS_AGGREGATES_SYMBOL = TIMERS_AGGREGATES_SYMBOL;
+class WebpackLogger {
+    error(...args) {
+        this[LOG_SYMBOL](LogType.error, args);
+    }
+    warn(...args) {
+        this[LOG_SYMBOL](LogType.warn, args);
+    }
+    info(...args) {
+        this[LOG_SYMBOL](LogType.info, args);
+    }
+    log(...args) {
+        this[LOG_SYMBOL](LogType.log, args);
+    }
+    debug(...args) {
+        this[LOG_SYMBOL](LogType.debug, args);
+    }
+    assert(assertion, ...args) {
+        if (!assertion) this[LOG_SYMBOL](LogType.error, args);
+    }
+    trace() {
+        this[LOG_SYMBOL](LogType.trace, [
+            'Trace'
+        ]);
+    }
+    clear() {
+        this[LOG_SYMBOL](LogType.clear);
+    }
+    status(...args) {
+        this[LOG_SYMBOL](LogType.status, args);
+    }
+    group(...args) {
+        this[LOG_SYMBOL](LogType.group, args);
+    }
+    groupCollapsed(...args) {
+        this[LOG_SYMBOL](LogType.groupCollapsed, args);
+    }
+    groupEnd() {
+        this[LOG_SYMBOL](LogType.groupEnd);
+    }
+    profile(label) {
+        this[LOG_SYMBOL](LogType.profile, [
+            label
+        ]);
+    }
+    profileEnd(label) {
+        this[LOG_SYMBOL](LogType.profileEnd, [
+            label
+        ]);
+    }
+    time(label) {
+        this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
+        this[TIMERS_SYMBOL].set(label, process.hrtime());
+    }
+    timeLog(label) {
+        const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+        if (!prev) throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
+        const time = process.hrtime(prev);
+        this[LOG_SYMBOL](LogType.time, [
+            label,
+            ...time
+        ]);
+    }
+    timeEnd(label) {
+        const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+        if (!prev) throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
+        const time = process.hrtime(prev);
+        this[TIMERS_SYMBOL].delete(label);
+        this[LOG_SYMBOL](LogType.time, [
+            label,
+            ...time
+        ]);
+    }
+    timeAggregate(label) {
+        const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+        if (!prev) throw new Error(`No such label '${label}' for WebpackLogger.timeAggregate()`);
+        const time = process.hrtime(prev);
+        this[TIMERS_SYMBOL].delete(label);
+        this[TIMERS_AGGREGATES_SYMBOL] = this[TIMERS_AGGREGATES_SYMBOL] || new Map();
+        const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+        if (void 0 !== current) if (time[1] + current[1] > 1e9) {
+            time[0] += current[0] + 1;
+            time[1] = time[1] - 1e9 + current[1];
+        } else {
+            time[0] += current[0];
+            time[1] += current[1];
+        }
+        this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
+    }
+    timeAggregateEnd(label) {
+        if (void 0 === this[TIMERS_AGGREGATES_SYMBOL]) return;
+        const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+        if (void 0 === time) return;
+        this[TIMERS_AGGREGATES_SYMBOL].delete(label);
+        this[LOG_SYMBOL](LogType.time, [
+            label,
+            ...time
+        ]);
+    }
+    constructor(log, getChildLogger){
+        _define_property(this, _LOG_SYMBOL, void 0);
+        _define_property(this, _TIMERS_SYMBOL, new Map());
+        _define_property(this, _TIMERS_AGGREGATES_SYMBOL, new Map());
+        _define_property(this, "getChildLogger", void 0);
+        this[LOG_SYMBOL] = log;
+        this.getChildLogger = getChildLogger;
+    }
+}
+export { WebpackLogger as Logger };

package/client/modules/logger/createConsoleLogger.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+import { type LoggerOptions, type LoggingFunction } from '../types.js';
+declare const _default: ({ level, debug, console, }: LoggerOptions) => LoggingFunction;
+export default _default;

package/client/modules/logger/createConsoleLogger.js

@@ -0,0 +1,119 @@
+import { LogType } from "../types.js";
+const filterToFunction = (item)=>{
+    if ('string' == typeof item) {
+        const regExp = new RegExp(`[\\\\/]${item.replace(/[-[\]{}()*+?.\\^$|]/g, '\\$&')}([\\\\/]|$|!|\\?)`);
+        return (ident)=>regExp.test(ident);
+    }
+    if (item && 'object' == typeof item && 'function' == typeof item.test) return (ident)=>item.test(ident);
+    if ('function' == typeof item) return item;
+    if ('boolean' == typeof item) return ()=>item;
+};
+const LogLevel = {
+    none: 6,
+    false: 6,
+    error: 5,
+    warn: 4,
+    info: 3,
+    log: 2,
+    true: 2,
+    verbose: 1
+};
+const createConsoleLogger = ({ level = 'info', debug = false, console })=>{
+    const debugFilters = 'boolean' == typeof debug ? [
+        ()=>debug
+    ] : [
+        ...Array.isArray(debug) ? debug : [
+            debug
+        ]
+    ].map(filterToFunction);
+    const loglevel = LogLevel[`${level}`] || 0;
+    const logger = (name, type, args)=>{
+        const labeledArgs = ()=>{
+            if (Array.isArray(args)) {
+                if (args.length > 0 && 'string' == typeof args[0]) return [
+                    `[${name}] ${args[0]}`,
+                    ...args.slice(1)
+                ];
+                return [
+                    `[${name}]`,
+                    ...args
+                ];
+            }
+            return [];
+        };
+        const debug = debugFilters.some((f)=>f(name));
+        switch(type){
+            case LogType.debug:
+                if (!debug) return;
+                if ('function' == typeof console.debug) console.debug(...labeledArgs());
+                else console.log(...labeledArgs());
+                break;
+            case LogType.log:
+                if (!debug && loglevel > LogLevel.log) return;
+                console.log(...labeledArgs());
+                break;
+            case LogType.info:
+                if (!debug && loglevel > LogLevel.info) return;
+                console.info(...labeledArgs());
+                break;
+            case LogType.warn:
+                if (!debug && loglevel > LogLevel.warn) return;
+                console.warn(...labeledArgs());
+                break;
+            case LogType.error:
+                if (!debug && loglevel > LogLevel.error) return;
+                console.error(...labeledArgs());
+                break;
+            case LogType.trace:
+                if (!debug) return;
+                console.trace();
+                break;
+            case LogType.groupCollapsed:
+                if (!debug && loglevel > LogLevel.log) return;
+                if (!debug && loglevel > LogLevel.verbose) {
+                    if ('function' == typeof console.groupCollapsed) console.groupCollapsed(...labeledArgs());
+                    else console.log(...labeledArgs());
+                    break;
+                }
+            case LogType.group:
+                if (!debug && loglevel > LogLevel.log) return;
+                if ('function' == typeof console.group) console.group(...labeledArgs());
+                else console.log(...labeledArgs());
+                break;
+            case LogType.groupEnd:
+                if (!debug && loglevel > LogLevel.log) return;
+                if ('function' == typeof console.groupEnd) console.groupEnd();
+                break;
+            case LogType.time:
+                {
+                    if (!debug && loglevel > LogLevel.log) return;
+                    const [label, start, end] = args;
+                    const ms = 1000 * start + end / 1000000;
+                    const msg = `[${name}] ${label}: ${ms} ms`;
+                    if ('function' == typeof console.logTime) console.logTime(msg);
+                    else console.log(msg);
+                    break;
+                }
+            case LogType.profile:
+                if ('function' == typeof console.profile) console.profile(...labeledArgs());
+                break;
+            case LogType.profileEnd:
+                if ('function' == typeof console.profileEnd) console.profileEnd(...labeledArgs());
+                break;
+            case LogType.clear:
+                if (!debug && loglevel > LogLevel.log) return;
+                if ('function' == typeof console.clear) console.clear();
+                break;
+            case LogType.status:
+                if (!debug && loglevel > LogLevel.info) return;
+                if ('function' == typeof console.status) if (args && 0 !== args.length) console.status(...labeledArgs());
+                else console.status();
+                else if (args && 0 !== args.length) console.info(...labeledArgs());
+                break;
+            default:
+                throw new Error(`Unexpected LogType ${type}`);
+        }
+    };
+    return logger;
+};
+export { createConsoleLogger as default };

package/client/modules/logger/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+import { Logger } from './Logger.js';
+import type { LoggerOptions } from '../types.js';
+export declare const logger: {
+    getLogger: (name: string) => Logger;
+    configureDefaultLogger: (options: LoggerOptions) => void;
+    hooks: {
+        log: any;
+    };
+};