@rspack/core 1.0.10 → 1.0.12

package/dist/loader-runner/loadLoader.js

@@ -1,64 +0,0 @@
-"use strict";
-/**
- * The following code is from
- * https://github.com/webpack/loader-runner
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/loader-runner/blob/main/LICENSE
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const LoaderLoadingError_1 = __importDefault(require("./LoaderLoadingError"));
-let url = undefined;
-function loadLoader(loader, callback) {
-    if (loader.type === "module") {
-        try {
-            if (url === undefined)
-                url = require("node:url");
-            const loaderUrl = url.pathToFileURL(loader.path);
-            const modulePromise = import(loaderUrl.toString());
-            modulePromise.then((module) => {
-                handleResult(loader, module, callback);
-            }, callback);
-            return;
-        }
-        catch (e) {
-            callback(e);
-        }
-    }
-    else {
-        let module;
-        try {
-            module = require(loader.path);
-        }
-        catch (e) {
-            // it is possible for node to choke on a require if the FD descriptor
-            // limit has been reached. give it a chance to recover.
-            if (e instanceof Error &&
-                e.code === "EMFILE") {
-                const retry = loadLoader.bind(null, loader, callback);
-                return void setImmediate(retry);
-            }
-            return callback(e);
-        }
-        return handleResult(loader, module, callback);
-    }
-}
-exports.default = loadLoader;
-function handleResult(loader, module, callback) {
-    if (typeof module !== "function" && typeof module !== "object") {
-        return callback(new LoaderLoadingError_1.default(`Module '${loader.path}' is not a loader (export function or es6 module)`));
-    }
-    loader.normal = typeof module === "function" ? module : module.default;
-    loader.pitch = module.pitch;
-    loader.raw = module.raw;
-    if (typeof loader.normal !== "function" &&
-        typeof loader.pitch !== "function") {
-        return callback(new LoaderLoadingError_1.default(`Module '${loader.path}' is not a loader (must have normal or pitch function)`));
-    }
-    callback();
-}

package/dist/logging/Logger.js

@@ -1,143 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/logging/Logger.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.getLogTypesBitFlag = exports.getLogTypeBitFlag = exports.LogType = void 0;
-exports.LogType = Object.freeze({
-    error: /** @type {"error"} */ "error",
-    warn: /** @type {"warn"} */ "warn",
-    info: /** @type {"info"} */ "info",
-    log: /** @type {"log"} */ "log",
-    debug: /** @type {"debug"} */ "debug",
-    trace: /** @type {"trace"} */ "trace",
-    group: /** @type {"group"} */ "group",
-    groupCollapsed: /** @type {"groupCollapsed"} */ "groupCollapsed",
-    groupEnd: /** @type {"groupEnd"} */ "groupEnd",
-    profile: /** @type {"profile"} */ "profile",
-    profileEnd: /** @type {"profileEnd"} */ "profileEnd",
-    time: /** @type {"time"} */ "time",
-    clear: /** @type {"clear"} */ "clear",
-    status: /** @type {"status"} */ "status",
-    cache: /** @type {"cache"} */ "cache" // [hit, total]
-});
-function getLogTypeBitFlag(type) {
-    return 1 << Object.values(exports.LogType).findIndex(i => i === type);
-}
-exports.getLogTypeBitFlag = getLogTypeBitFlag;
-function getLogTypesBitFlag(types) {
-    return types.reduce((acc, cur) => acc | getLogTypeBitFlag(cur), 0);
-}
-exports.getLogTypesBitFlag = getLogTypesBitFlag;
-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");
-class Logger {
-    constructor(log, getChildLogger) {
-        this[LOG_SYMBOL] = log;
-        this.getChildLogger = getChildLogger;
-    }
-    error(...args) {
-        this[LOG_SYMBOL](exports.LogType.error, args);
-    }
-    warn(...args) {
-        this[LOG_SYMBOL](exports.LogType.warn, args);
-    }
-    info(...args) {
-        this[LOG_SYMBOL](exports.LogType.info, args);
-    }
-    log(...args) {
-        this[LOG_SYMBOL](exports.LogType.log, args);
-    }
-    debug(...args) {
-        this[LOG_SYMBOL](exports.LogType.debug, args);
-    }
-    assert(assertion, ...args) {
-        if (!assertion) {
-            this[LOG_SYMBOL](exports.LogType.error, args);
-        }
-    }
-    trace() {
-        this[LOG_SYMBOL](exports.LogType.trace, ["Trace"]);
-    }
-    clear() {
-        this[LOG_SYMBOL](exports.LogType.clear);
-    }
-    status(...args) {
-        this[LOG_SYMBOL](exports.LogType.status, args);
-    }
-    group(...args) {
-        this[LOG_SYMBOL](exports.LogType.group, args);
-    }
-    groupCollapsed(...args) {
-        this[LOG_SYMBOL](exports.LogType.groupCollapsed, args);
-    }
-    groupEnd(...args) {
-        this[LOG_SYMBOL](exports.LogType.groupEnd, args);
-    }
-    profile(label) {
-        this[LOG_SYMBOL](exports.LogType.profile, [label]);
-    }
-    profileEnd(label) {
-        this[LOG_SYMBOL](exports.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]?.get(label);
-        if (!prev) {
-            throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
-        }
-        const time = process.hrtime(prev);
-        this[LOG_SYMBOL](exports.LogType.time, [label, ...time]);
-    }
-    timeEnd(label) {
-        const prev = 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](exports.LogType.time, [label, ...time]);
-    }
-    timeAggregate(label) {
-        const prev = 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 (current !== undefined) {
-            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 (this[TIMERS_AGGREGATES_SYMBOL] === undefined)
-            return;
-        const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
-        if (time === undefined)
-            return;
-        this[TIMERS_AGGREGATES_SYMBOL].delete(label);
-        this[LOG_SYMBOL](exports.LogType.time, [label, ...time]);
-    }
-}
-exports.Logger = Logger;

package/dist/logging/createConsoleLogger.js

@@ -1,176 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/logging/createConsoleLogger.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConsoleLogger = void 0;
-const Logger_1 = require("./Logger");
-const filterToFunction = (item) => {
-    if (typeof item === "string") {
-        const regExp = new RegExp(`[\\\\/]${item.replace(
-        // eslint-disable-next-line no-useless-escape
-        /[-[\]{}()*+?.\\^$|]/g, "\\$&")}([\\\\/]|$|!|\\?)`);
-        return ident => regExp.test(ident);
-    }
-    if (item && typeof item === "object" && typeof item.test === "function") {
-        return ident => item.test(ident);
-    }
-    if (typeof item === "function") {
-        return item;
-    }
-    if (typeof item === "boolean") {
-        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 = typeof debug === "boolean"
-        ? [() => debug]
-        : [].concat(debug).map(filterToFunction);
-    const loglevel = LogLevel[`${level}`] || 0;
-    const logger = (name, type, args) => {
-        const labeledArgs = () => {
-            if (Array.isArray(args)) {
-                if (args.length > 0 && typeof args[0] === "string") {
-                    return [`[${name}] ${args[0]}`, ...args.slice(1)];
-                }
-                return [`[${name}]`, ...args];
-            }
-            return [];
-        };
-        const debug = debugFilters.some(f => f(name));
-        switch (type) {
-            case Logger_1.LogType.debug:
-                if (!debug)
-                    return;
-                if (typeof console.debug === "function") {
-                    console.debug(...labeledArgs());
-                }
-                else {
-                    console.log(...labeledArgs());
-                }
-                break;
-            case Logger_1.LogType.log:
-                if (!debug && loglevel > LogLevel.log)
-                    return;
-                console.log(...labeledArgs());
-                break;
-            case Logger_1.LogType.info:
-                if (!debug && loglevel > LogLevel.info)
-                    return;
-                console.info(...labeledArgs());
-                break;
-            case Logger_1.LogType.warn:
-                if (!debug && loglevel > LogLevel.warn)
-                    return;
-                console.warn(...labeledArgs());
-                break;
-            case Logger_1.LogType.error:
-                if (!debug && loglevel > LogLevel.error)
-                    return;
-                console.error(...labeledArgs());
-                break;
-            case Logger_1.LogType.trace:
-                if (!debug)
-                    return;
-                console.trace();
-                break;
-            case Logger_1.LogType.groupCollapsed:
-                if (!debug && loglevel > LogLevel.log)
-                    return;
-                if (!debug && loglevel > LogLevel.verbose) {
-                    if (typeof console.groupCollapsed === "function") {
-                        console.groupCollapsed(...labeledArgs());
-                    }
-                    else {
-                        console.log(...labeledArgs());
-                    }
-                    break;
-                }
-            // falls through
-            case Logger_1.LogType.group:
-                if (!debug && loglevel > LogLevel.log)
-                    return;
-                if (typeof console.group === "function") {
-                    console.group(...labeledArgs());
-                }
-                else {
-                    console.log(...labeledArgs());
-                }
-                break;
-            case Logger_1.LogType.groupEnd:
-                if (!debug && loglevel > LogLevel.log)
-                    return;
-                if (typeof console.groupEnd === "function") {
-                    console.groupEnd();
-                }
-                break;
-            case Logger_1.LogType.time: {
-                if (!debug && loglevel > LogLevel.log)
-                    return;
-                const ms = args[1] * 1000 + args[2] / 1000000;
-                const msg = `[${name}] ${args[0]}: ${ms} ms`;
-                if (typeof console.logTime === "function") {
-                    console.logTime(msg);
-                }
-                else {
-                    console.log(msg);
-                }
-                break;
-            }
-            case Logger_1.LogType.profile:
-                if (typeof console.profile === "function") {
-                    console.profile(...labeledArgs());
-                }
-                break;
-            case Logger_1.LogType.profileEnd:
-                if (typeof console.profileEnd === "function") {
-                    console.profileEnd(...labeledArgs());
-                }
-                break;
-            case Logger_1.LogType.clear:
-                if (!debug && loglevel > LogLevel.log)
-                    return;
-                if (typeof console.clear === "function") {
-                    console.clear();
-                }
-                break;
-            case Logger_1.LogType.status:
-                if (!debug && loglevel > LogLevel.info)
-                    return;
-                if (typeof console.status === "function") {
-                    if (args.length === 0) {
-                        console.status();
-                    }
-                    else {
-                        console.status(...labeledArgs());
-                    }
-                }
-                else {
-                    if (args.length !== 0) {
-                        console.info(...labeledArgs());
-                    }
-                }
-                break;
-            default:
-                throw new Error(`Unexpected LogType ${type}`);
-        }
-    };
-    return logger;
-};
-exports.createConsoleLogger = createConsoleLogger;

package/dist/logging/runtime.js

@@ -1,37 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/logging/runtime.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hooks = exports.configureDefaultLogger = exports.getLogger = void 0;
-const SyncBailHook = require("tapable/lib/SyncBailHook");
-const Logger_1 = require("./Logger");
-const createConsoleLogger_1 = require("./createConsoleLogger");
-const currentDefaultLoggerOptions = {
-    level: "info",
-    debug: false,
-    console
-};
-let currentDefaultLogger = (0, createConsoleLogger_1.createConsoleLogger)(currentDefaultLoggerOptions);
-const getLogger = (name) => {
-    return new Logger_1.Logger((type, args) => {
-        if (exports.hooks.log.call(name, type, args) === undefined) {
-            currentDefaultLogger(name, type, args);
-        }
-    }, childName => exports.getLogger(`${name}/${childName}`));
-};
-exports.getLogger = getLogger;
-const configureDefaultLogger = (options) => {
-    Object.assign(currentDefaultLoggerOptions, options);
-    currentDefaultLogger = (0, createConsoleLogger_1.createConsoleLogger)(currentDefaultLoggerOptions);
-};
-exports.configureDefaultLogger = configureDefaultLogger;
-exports.hooks = {
-    log: new SyncBailHook(["origin", "type", "args"])
-};

package/dist/logging/truncateArgs.js

@@ -1,81 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/logging/truncateArgs.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.truncateArgs = void 0;
-const arraySum = (array) => {
-    let sum = 0;
-    for (const item of array)
-        sum += item;
-    return sum;
-};
-/**
- * @param args items to be truncated
- * @param maxLength maximum length of args including spaces between
- * @returns truncated args
- */
-const truncateArgs = (args, maxLength) => {
-    const lengths = args.map(a => `${a}`.length);
-    const availableLength = maxLength - lengths.length + 1;
-    if (availableLength > 0 && args.length === 1) {
-        if (availableLength >= args[0].length) {
-            return args;
-        }
-        if (availableLength > 3) {
-            return [`...${args[0].slice(-availableLength + 3)}`];
-        }
-        return [args[0].slice(-availableLength)];
-    }
-    // Check if there is space for at least 4 chars per arg
-    if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
-        // remove args
-        if (args.length > 1)
-            return truncateArgs(args.slice(0, args.length - 1), maxLength);
-        return [];
-    }
-    let currentLength = arraySum(lengths);
-    // Check if all fits into maxLength
-    if (currentLength <= availableLength)
-        return args;
-    // Try to remove chars from the longest items until it fits
-    while (currentLength > availableLength) {
-        const maxLength = Math.max(...lengths);
-        const shorterItems = lengths.filter(l => l !== maxLength);
-        const nextToMaxLength = shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
-        const maxReduce = maxLength - nextToMaxLength;
-        let maxItems = lengths.length - shorterItems.length;
-        let overrun = currentLength - availableLength;
-        for (let i = 0; i < lengths.length; i++) {
-            if (lengths[i] === maxLength) {
-                const reduce = Math.min(Math.floor(overrun / maxItems), maxReduce);
-                lengths[i] -= reduce;
-                currentLength -= reduce;
-                overrun -= reduce;
-                maxItems--;
-            }
-        }
-    }
-    // Return args reduced to length in lengths
-    return args.map((a, i) => {
-        const str = `${a}`;
-        const length = lengths[i];
-        if (str.length === length) {
-            return str;
-        }
-        if (length > 5) {
-            return `...${str.slice(-length + 3)}`;
-        }
-        if (length > 0) {
-            return str.slice(-length);
-        }
-        return "";
-    });
-};
-exports.truncateArgs = truncateArgs;

package/dist/node/NodeEnvironmentPlugin.js

@@ -1,50 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/node/NodeEnvironmentPlugin.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-// @ts-expect-error we directly import from enhanced-resolve inner js file to improve performance
-const CachedInputFileSystem_1 = __importDefault(require("../../compiled/enhanced-resolve/CachedInputFileSystem"));
-const graceful_fs_1 = __importDefault(require("../../compiled/graceful-fs"));
-const createConsoleLogger_1 = require("../logging/createConsoleLogger");
-const NodeWatchFileSystem_1 = __importDefault(require("./NodeWatchFileSystem"));
-const nodeConsole_1 = __importDefault(require("./nodeConsole"));
-class NodeEnvironmentPlugin {
-    constructor(options) {
-        this.options = options;
-    }
-    apply(compiler) {
-        const { infrastructureLogging } = this.options;
-        compiler.infrastructureLogger = (0, createConsoleLogger_1.createConsoleLogger)({
-            level: infrastructureLogging.level || "info",
-            debug: infrastructureLogging.debug || false,
-            console: infrastructureLogging.console ||
-                (0, nodeConsole_1.default)({
-                    colors: infrastructureLogging.colors,
-                    appendOnly: infrastructureLogging.appendOnly,
-                    stream: infrastructureLogging.stream
-                })
-        });
-        const inputFileSystem = new CachedInputFileSystem_1.default(graceful_fs_1.default, 60000);
-        compiler.inputFileSystem = inputFileSystem;
-        compiler.outputFileSystem = graceful_fs_1.default;
-        compiler.intermediateFileSystem = graceful_fs_1.default;
-        compiler.watchFileSystem = new NodeWatchFileSystem_1.default(inputFileSystem);
-        compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
-            if (compiler.inputFileSystem === inputFileSystem) {
-                compiler.fsStartTime = Date.now();
-                inputFileSystem.purge?.();
-            }
-        });
-    }
-}
-exports.default = NodeEnvironmentPlugin;

package/dist/node/NodeTemplatePlugin.js

@@ -1,26 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/node/NodeTemplatePlugin.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const builtin_plugin_1 = require("../builtin-plugin");
-class NodeTemplatePlugin {
-    constructor(_options = {}) {
-        this._options = _options;
-    }
-    apply(compiler) {
-        const chunkLoading = this._options.asyncChunkLoading
-            ? "async-node"
-            : "require";
-        compiler.options.output.chunkLoading = chunkLoading;
-        new builtin_plugin_1.CommonJsChunkFormatPlugin().apply(compiler);
-        new builtin_plugin_1.EnableChunkLoadingPlugin(chunkLoading).apply(compiler);
-    }
-}
-exports.default = NodeTemplatePlugin;