@rspack/dev-server 2.0.1 → 2.0.2

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 };