@rspack/dev-server 2.0.0 → 2.0.2

package/client/modules/logger/Logger.js

@@ -1,121 +0,0 @@
-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('rspack logger raw log method');
-const TIMERS_SYMBOL = Symbol('rspack logger times');
-const TIMERS_AGGREGATES_SYMBOL = Symbol('rspack logger aggregated times');
-let _LOG_SYMBOL = LOG_SYMBOL, _TIMERS_SYMBOL = TIMERS_SYMBOL, _TIMERS_AGGREGATES_SYMBOL = TIMERS_AGGREGATES_SYMBOL;
-class RspackLogger {
-    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 RspackLogger.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 RspackLogger.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 RspackLogger.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){
-        _define_property(this, _LOG_SYMBOL, void 0);
-        _define_property(this, _TIMERS_SYMBOL, new Map());
-        _define_property(this, _TIMERS_AGGREGATES_SYMBOL, new Map());
-        this[LOG_SYMBOL] = log;
-    }
-}
-export { RspackLogger as Logger };

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

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1,119 +0,0 @@
-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 default createConsoleLogger;

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

@@ -1,26 +0,0 @@
-/**
- * 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';
-/**
- * Client stub for tapable SyncBailHook
- */
-declare class SyncBailHook {
-    constructor(_args?: string[]);
-    call(_origin?: string, _type?: string, _args?: unknown): undefined;
-}
-export declare const logger: {
-    getLogger: (name: string) => Logger;
-    configureDefaultLogger: (options: LoggerOptions) => void;
-    hooks: {
-        log: SyncBailHook;
-    };
-};
-export {};

package/client/modules/logger/index.js

@@ -1,32 +0,0 @@
-import { Logger } from "./Logger.js";
-import createConsoleLogger from "./createConsoleLogger.js";
-class SyncBailHook {
-    call(_origin, _type, _args) {}
-    constructor(_args){}
-}
-const currentDefaultLoggerOptions = {
-    level: 'info',
-    debug: false,
-    console
-};
-let currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
-const configureDefaultLogger = (options)=>{
-    Object.assign(currentDefaultLoggerOptions, options);
-    currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
-};
-const getLogger = (name)=>new Logger((type, args)=>{
-        if (void 0 === hooks.log.call(name, type, args)) currentDefaultLogger(name, type, args);
-    });
-const hooks = {
-    log: new SyncBailHook([
-        'origin',
-        'type',
-        'args'
-    ])
-};
-const logger = {
-    getLogger: getLogger,
-    configureDefaultLogger: configureDefaultLogger,
-    hooks: hooks
-};
-export { logger };

package/client/modules/types.d.ts

@@ -1,45 +0,0 @@
-import type { FilterTypes } from '@rspack/core';
-export type EXPECTED_ANY = any;
-export type FilterFunction = (item: string) => boolean;
-export type LoggingFunction = (value: string, type: LogTypeEnum, args?: Args) => void;
-export type LoggerConsole = {
-    clear: () => void;
-    trace: () => void;
-    info: (...args: Args) => void;
-    log: (...args: Args) => void;
-    warn: (...args: Args) => void;
-    error: (...args: Args) => void;
-    debug?: (...args: Args) => void;
-    group?: (...args: Args) => void;
-    groupCollapsed?: (...args: Args) => void;
-    groupEnd?: (...args: Args) => void;
-    status?: (...args: Args) => void;
-    profile?: (...args: Args) => void;
-    profileEnd?: (...args: Args) => void;
-    logTime?: (...args: Args) => void;
-};
-export type LoggerOptions = {
-    level: false | true | 'none' | 'error' | 'warn' | 'info' | 'log' | 'verbose';
-    debug: FilterTypes | boolean;
-    console: LoggerConsole;
-};
-export declare const LogType: Readonly<{
-    error: "error";
-    warn: "warn";
-    info: "info";
-    log: "log";
-    debug: "debug";
-    trace: "trace";
-    group: "group";
-    groupCollapsed: "groupCollapsed";
-    groupEnd: "groupEnd";
-    profile: "profile";
-    profileEnd: "profileEnd";
-    time: "time";
-    clear: "clear";
-    status: "status";
-}>;
-export type LogTypeEnum = (typeof LogType)[keyof typeof LogType];
-export type TimersMap = Map<string | undefined, [number, number]>;
-export type Args = EXPECTED_ANY[];
-export type { FilterItemTypes } from '@rspack/core';

package/client/modules/types.js

@@ -1,17 +0,0 @@
-const LogType = Object.freeze({
-    error: 'error',
-    warn: 'warn',
-    info: 'info',
-    log: 'log',
-    debug: 'debug',
-    trace: 'trace',
-    group: 'group',
-    groupCollapsed: 'groupCollapsed',
-    groupEnd: 'groupEnd',
-    profile: 'profile',
-    profileEnd: 'profileEnd',
-    time: 'time',
-    clear: 'clear',
-    status: 'status'
-});
-export { LogType };

package/client/overlay.d.ts

@@ -1,47 +0,0 @@
-/**
- * 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
- */
-type Message = Error & {
-    file?: string;
-    moduleName?: string;
-    moduleIdentifier?: string;
-    loc?: string;
-    message?: string;
-    stack?: string | string[];
-};
-type Event = {
-    type: string;
-} & Record<string, any>;
-type StateMachine = {
-    send: (event: Event) => void;
-};
-declare const formatProblem: (type: "warning" | "error", item: string | Message) => {
-    header: string;
-    body: string;
-};
-type CreateOverlayOptions = {
-    /** Trusted types policy name. If false, disables trusted types. */
-    trustedTypesPolicyName?: false | string;
-    /** Runtime error catcher. If boolean, enables/disables catching. If function, handles the error. */
-    catchRuntimeError?: boolean | ((error: Error) => void);
-};
-type OverlayTrustedTypePolicy = {
-    createHTML: (value: string) => string;
-};
-declare global {
-    interface Window {
-        trustedTypes?: {
-            createPolicy: (name: string, policy: {
-                createHTML: (value: string) => string;
-            }) => OverlayTrustedTypePolicy;
-        };
-    }
-}
-declare const createOverlay: (options: CreateOverlayOptions) => StateMachine;
-export { createOverlay, formatProblem };