@rspack/core 0.6.5 → 0.7.0-beta.0

package/dist/lite-tapable/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueriedHookMap = exports.HookMap = exports.AsyncSeriesBailHook = exports.AsyncSeriesHook = exports.AsyncParallelHook = exports.SyncBailHook = exports.SyncHook = exports.QueriedHook = exports.safeStage = exports.maxStage = exports.minStage = exports.Hook = void 0;
+exports.QueriedHookMap = exports.HookMap = exports.AsyncSeriesWaterfallHook = exports.AsyncSeriesBailHook = exports.AsyncSeriesHook = exports.AsyncParallelHook = exports.SyncBailHook = exports.SyncHook = exports.QueriedHook = exports.safeStage = exports.maxStage = exports.minStage = exports.Hook = void 0;
 class Hook {
     constructor(args, name) {
         this.args = args;
@@ -578,6 +578,112 @@ class AsyncSeriesBailHook extends Hook {
     }
 }
 exports.AsyncSeriesBailHook = AsyncSeriesBailHook;
+class AsyncSeriesWaterfallHook extends Hook {
+    constructor(args, name) {
+        if (!(args === null || args === void 0 ? void 0 : args.length))
+            throw new Error("Waterfall hooks must have at least one argument");
+        super(args, name);
+    }
+    callAsyncStageRange(queried, ...args) {
+        const { stageRange: [from, to], tapsInRange } = queried;
+        let data = args[0];
+        const cb = args[1];
+        if (from === exports.minStage) {
+            this._runCallInterceptors(data);
+        }
+        const done = () => {
+            this._runDoneInterceptors();
+            cb(null, data);
+        };
+        const error = (e) => {
+            this._runErrorInterceptors(e);
+            cb(e);
+        };
+        if (tapsInRange.length === 0)
+            return done();
+        let index = 0;
+        const next = () => {
+            const tap = tapsInRange[index];
+            this._runTapInterceptors(tap);
+            if (tap.type === "promise") {
+                const promise = tap.fn(data);
+                if (!promise || !promise.then) {
+                    throw new Error("Tap function (tapPromise) did not return promise (returned " +
+                        promise +
+                        ")");
+                }
+                promise.then((r) => {
+                    index += 1;
+                    if (r !== undefined) {
+                        data = r;
+                    }
+                    if (index === tapsInRange.length) {
+                        done();
+                    }
+                    else {
+                        next();
+                    }
+                }, (e) => {
+                    index = tapsInRange.length;
+                    error(e);
+                });
+            }
+            else if (tap.type === "async") {
+                tap.fn(data, (e, r) => {
+                    if (e) {
+                        index = tapsInRange.length;
+                        error(e);
+                    }
+                    else {
+                        index += 1;
+                        if (r !== undefined) {
+                            data = r;
+                        }
+                        if (index === tapsInRange.length) {
+                            done();
+                        }
+                        else {
+                            next();
+                        }
+                    }
+                });
+            }
+            else {
+                let hasError = false;
+                try {
+                    const r = tap.fn(data);
+                    if (r !== undefined) {
+                        data = r;
+                    }
+                }
+                catch (e) {
+                    hasError = true;
+                    index = tapsInRange.length;
+                    error(e);
+                }
+                if (!hasError) {
+                    index += 1;
+                    if (index === tapsInRange.length) {
+                        done();
+                    }
+                    else {
+                        next();
+                    }
+                }
+            }
+            if (index === tapsInRange.length)
+                return;
+        };
+        next();
+    }
+    tapAsync(options, fn) {
+        this._tap("async", options, fn);
+    }
+    tapPromise(options, fn) {
+        this._tap("promise", options, fn);
+    }
+}
+exports.AsyncSeriesWaterfallHook = AsyncSeriesWaterfallHook;
 const defaultFactory = (key, hook) => hook;
 class HookMap {
     constructor(factory, name) {

package/dist/loader-runner/index.js

@@ -11,12 +11,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runLoaders = exports.parsePathQueryFragment = void 0;
 const webpack_sources_1 = require("webpack-sources");
-const NormalModule_1 = require("../NormalModule");
 const adapterRuleUse_1 = require("../config/adapterRuleUse");
+const NormalModule_1 = require("../NormalModule");
 const util_1 = require("../util");
+const createHash_1 = require("../util/createHash");
 const identifier_1 = require("../util/identifier");
 const memoize_1 = require("../util/memoize");
-const createHash_1 = require("../util/createHash");
 const loadLoader = require("./loadLoader");
 const querystring = require("node:querystring");
 const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
@@ -151,7 +151,7 @@ async function runLoaders(compiler, rawContext) {
                     "When using a function for Rule.use in config you need to " +
                     "provide an 'ident' property for referenced loader options.");
             }
-            obj.options = compiler.ruleSet.references.get(ident);
+            obj.options = compiler.__internal__ruleSet.references.get(ident);
             if (obj.options === undefined) {
                 throw new Error(`Invalid ident("${ident}") is provided by referenced loader`);
             }
@@ -201,7 +201,7 @@ async function runLoaders(compiler, rawContext) {
         if (!callback) {
             return new Promise((resolve, reject) => {
                 compiler
-                    .compilation.__internal_getInner()
+                    ._lastCompilation.__internal_getInner()
                     .importModule(request, options.publicPath, options.baseUri, rawContext._moduleIdentifier, loaderContext.context, (err, res) => {
                     if (err)
                         reject(err);
@@ -225,7 +225,7 @@ async function runLoaders(compiler, rawContext) {
             });
         }
         return compiler
-            .compilation.__internal_getInner()
+            ._lastCompilation.__internal_getInner()
             .importModule(request, options.publicPath, options.baseUri, rawContext._moduleIdentifier, loaderContext.context, (err, res) => {
             if (err) {
                 callback(err, undefined);
@@ -386,22 +386,22 @@ async function runLoaders(compiler, rawContext) {
         };
     };
     loaderContext.getLogger = function getLogger(name) {
-        return compiler.compilation.getLogger([name, resource].filter(Boolean).join("|"));
+        return compiler._lastCompilation.getLogger([name, resource].filter(Boolean).join("|"));
     };
     loaderContext.rootContext = compiler.context;
     loaderContext.emitError = function emitError(error) {
         const title = "Module Error";
         const message = error instanceof Error ? (0, util_1.concatErrorMsgAndStack)(error) : error;
-        compiler.compilation.pushDiagnostic("error", title, `${message}\n(from: ${(0, util_1.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`);
+        compiler._lastCompilation.__internal__pushDiagnostic("error", title, `${message}\n(from: ${(0, util_1.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`);
     };
     loaderContext.emitWarning = function emitWarning(warning) {
         const title = "Module Warning";
         const message = warning instanceof Error ? (0, util_1.concatErrorMsgAndStack)(warning) : warning;
-        compiler.compilation.pushDiagnostic("warning", title, `${message}\n(from: ${(0, util_1.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`);
+        compiler._lastCompilation.__internal__pushDiagnostic("warning", title, `${message}\n(from: ${(0, util_1.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`);
     };
     loaderContext.__internal__pushNativeDiagnostics =
         function __internal__pushNativeDiagnostics(diagnostics) {
-            compiler.compilation.__internal__pushNativeDiagnostics(diagnostics);
+            compiler._lastCompilation.__internal__pushNativeDiagnostics(diagnostics);
         };
     loaderContext.emitFile = function emitFile(name, content, sourceMap, assetInfo) {
         let source;
@@ -425,7 +425,7 @@ async function runLoaders(compiler, rawContext) {
         }
         assetFilenames.push(name),
             // @ts-expect-error
-            compiler.compilation.emitAsset(name, source, assetInfo);
+            compiler._lastCompilation.emitAsset(name, source, assetInfo);
     };
     loaderContext.fs = compiler.inputFileSystem;
     const getAbsolutify = (0, memoize_1.memoize)(() => identifier_1.absolutify.bindCache(compiler.root));
@@ -444,7 +444,7 @@ async function runLoaders(compiler, rawContext) {
                 : getContextify()(context, request);
         },
         createHash: type => {
-            return (0, createHash_1.createHash)(type || compiler.compilation.outputOptions.hashFunction);
+            return (0, createHash_1.createHash)(type || compiler._lastCompilation.outputOptions.hashFunction);
         }
     };
     loaderContext.addBuildDependency = function addBuildDependency(file) {
@@ -477,7 +477,7 @@ async function runLoaders(compiler, rawContext) {
         return missingDependencies.slice();
     };
     loaderContext._compiler = compiler;
-    loaderContext._compilation = compiler.compilation;
+    loaderContext._compilation = compiler._lastCompilation;
     loaderContext.getOptions = function () {
         const loader = getCurrentLoader(loaderContext);
         let options = loader === null || loader === void 0 ? void 0 : loader.options;
@@ -500,7 +500,7 @@ async function runLoaders(compiler, rawContext) {
         }
         return options;
     };
-    let compilation = compiler.compilation;
+    let compilation = compiler._lastCompilation;
     let step = 0;
     while (compilation) {
         NormalModule_1.NormalModule.getCompilationHooks(compilation).loader.call(loaderContext);

package/dist/logging/Logger.d.ts

@@ -30,7 +30,7 @@ export type LogTypeEnum = (typeof LogType)[keyof typeof LogType];
 declare const LOG_SYMBOL: unique symbol;
 declare const TIMERS_SYMBOL: unique symbol;
 declare const TIMERS_AGGREGATES_SYMBOL: unique symbol;
-export type LogFunction = (type: LogTypeEnum, args?: any[]) => void;
+export type LogFunction = (type: LogTypeEnum, args: any[]) => void;
 export type GetChildLogger = (name: string | (() => string)) => Logger;
 export declare class Logger {
     getChildLogger: GetChildLogger;

package/dist/logging/createConsoleLogger.js

@@ -100,9 +100,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
             case LogType.debug:
                 if (!debug)
                     return;
-                // eslint-disable-next-line node/no-unsupported-features/node-builtins
                 if (typeof console.debug === "function") {
-                    // eslint-disable-next-line node/no-unsupported-features/node-builtins
                     console.debug(...labeledArgs());
                 }
                 else {
@@ -138,9 +136,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
                 if (!debug && loglevel > LogLevel.log)
                     return;
                 if (!debug && loglevel > LogLevel.verbose) {
-                    // eslint-disable-next-line node/no-unsupported-features/node-builtins
                     if (typeof console.groupCollapsed === "function") {
-                        // eslint-disable-next-line node/no-unsupported-features/node-builtins
                         console.groupCollapsed(...labeledArgs());
                     }
                     else {
@@ -152,9 +148,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
             case LogType.group:
                 if (!debug && loglevel > LogLevel.log)
                     return;
-                // eslint-disable-next-line node/no-unsupported-features/node-builtins
                 if (typeof console.group === "function") {
-                    // eslint-disable-next-line node/no-unsupported-features/node-builtins
                     console.group(...labeledArgs());
                 }
                 else {
@@ -164,9 +158,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
             case LogType.groupEnd:
                 if (!debug && loglevel > LogLevel.log)
                     return;
-                // eslint-disable-next-line node/no-unsupported-features/node-builtins
                 if (typeof console.groupEnd === "function") {
-                    // eslint-disable-next-line node/no-unsupported-features/node-builtins
                     console.groupEnd();
                 }
                 break;
@@ -184,25 +176,19 @@ module.exports = ({ level = "info", debug = false, console }) => {
                 break;
             }
             case LogType.profile:
-                // eslint-disable-next-line node/no-unsupported-features/node-builtins
                 if (typeof console.profile === "function") {
-                    // eslint-disable-next-line node/no-unsupported-features/node-builtins
                     console.profile(...labeledArgs());
                 }
                 break;
             case LogType.profileEnd:
-                // eslint-disable-next-line node/no-unsupported-features/node-builtins
                 if (typeof console.profileEnd === "function") {
-                    // eslint-disable-next-line node/no-unsupported-features/node-builtins
                     console.profileEnd(...labeledArgs());
                 }
                 break;
             case LogType.clear:
                 if (!debug && loglevel > LogLevel.log)
                     return;
-                // eslint-disable-next-line node/no-unsupported-features/node-builtins
                 if (typeof console.clear === "function") {
-                    // eslint-disable-next-line node/no-unsupported-features/node-builtins
                     console.clear();
                 }
                 break;

package/dist/node/NodeEnvironmentPlugin.d.ts

@@ -1,5 +1,5 @@
-import type { InfrastructureLogging } from "../config";
 import type { Compiler } from "..";
+import type { InfrastructureLogging } from "../config";
 export interface NodeEnvironmentPluginOptions {
     infrastructureLogging: InfrastructureLogging;
 }

package/dist/node/NodeEnvironmentPlugin.js

@@ -16,8 +16,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const CachedInputFileSystem_1 = __importDefault(require("enhanced-resolve/lib/CachedInputFileSystem"));
 const graceful_fs_1 = __importDefault(require("../../compiled/graceful-fs"));
 const createConsoleLogger_1 = __importDefault(require("../logging/createConsoleLogger"));
-const NodeWatchFileSystem_1 = __importDefault(require("./NodeWatchFileSystem"));
 const nodeConsole_1 = __importDefault(require("./nodeConsole"));
+const NodeWatchFileSystem_1 = __importDefault(require("./NodeWatchFileSystem"));
 class NodeEnvironmentPlugin {
     constructor(options) {
         this.options = options;

package/dist/node/nodeConsole.js

@@ -93,18 +93,14 @@ module.exports = ({ colors, appendOnly, stream }) => {
             else if (currentIndent.length >= 2)
                 currentIndent = currentIndent.slice(0, currentIndent.length - 2);
         },
-        // eslint-disable-next-line node/no-unsupported-features/node-builtins
         // @ts-expect-error
         profile: console.profile && (name => console.profile(name)),
-        // eslint-disable-next-line node/no-unsupported-features/node-builtins
         // @ts-expect-error
         profileEnd: console.profileEnd && (name => console.profileEnd(name)),
         clear: !appendOnly &&
-            // eslint-disable-next-line node/no-unsupported-features/node-builtins
             console.clear &&
             (() => {
                 clearStatusMessage();
-                // eslint-disable-next-line node/no-unsupported-features/node-builtins
                 console.clear();
                 writeStatusMessage();
             }),

package/dist/rspack.d.ts

@@ -1,18 +1,9 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-import { RspackOptions } from "./config";
+import { Callback } from "tapable";
 import { Compiler } from "./Compiler";
-import { Stats } from "./Stats";
+import { RspackOptions } from "./config";
 import { MultiCompiler, MultiRspackOptions } from "./MultiCompiler";
-import { Callback } from "tapable";
 import MultiStats from "./MultiStats";
+import { Stats } from "./Stats";
 declare function createMultiCompiler(options: MultiRspackOptions): MultiCompiler;
 declare function createCompiler(userOptions: RspackOptions): Compiler;
 declare function rspack(options: MultiRspackOptions): MultiCompiler;
@@ -21,5 +12,5 @@ declare function rspack(options: MultiRspackOptions | RspackOptions): MultiCompi
 declare function rspack(options: MultiRspackOptions, callback?: Callback<Error, MultiStats>): null | MultiCompiler;
 declare function rspack(options: RspackOptions, callback?: Callback<Error, Stats>): null | Compiler;
 declare function rspack(options: MultiRspackOptions | RspackOptions, callback?: Callback<Error, MultiStats | Stats>): null | MultiCompiler | Compiler;
-export { rspack, createCompiler, createMultiCompiler, Stats, MultiStats };
+export { createCompiler, createMultiCompiler, MultiStats, rspack, Stats };
 export default rspack;

package/dist/rspack.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiStats = exports.Stats = exports.createMultiCompiler = exports.createCompiler = exports.rspack = void 0;
+exports.Stats = exports.rspack = exports.MultiStats = exports.createMultiCompiler = exports.createCompiler = void 0;
 /**
  * The following code is modified based on
  * https://github.com/webpack/webpack/blob/4b4ca3b/lib
@@ -13,17 +13,17 @@ exports.MultiStats = exports.Stats = exports.createMultiCompiler = exports.creat
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-const config_1 = require("./config");
-const Compiler_1 = require("./Compiler");
-const Stats_1 = require("./Stats");
-Object.defineProperty(exports, "Stats", { enumerable: true, get: function () { return Stats_1.Stats; } });
+const assert_1 = __importDefault(require("assert"));
 const util_1 = __importDefault(require("util"));
-const rspackOptionsApply_1 = require("./rspackOptionsApply");
-const NodeEnvironmentPlugin_1 = __importDefault(require("./node/NodeEnvironmentPlugin"));
+const Compiler_1 = require("./Compiler");
+const config_1 = require("./config");
 const MultiCompiler_1 = require("./MultiCompiler");
 const MultiStats_1 = __importDefault(require("./MultiStats"));
 exports.MultiStats = MultiStats_1.default;
-const assert_1 = __importDefault(require("assert"));
+const NodeEnvironmentPlugin_1 = __importDefault(require("./node/NodeEnvironmentPlugin"));
+const rspackOptionsApply_1 = require("./rspackOptionsApply");
+const Stats_1 = require("./Stats");
+Object.defineProperty(exports, "Stats", { enumerable: true, get: function () { return Stats_1.Stats; } });
 const util_2 = require("./util");
 const validate_1 = require("./util/validate");
 function createMultiCompiler(options) {

package/dist/rspackOptionsApply.d.ts

@@ -1,13 +1,4 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/OptionsApply.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-import { RspackOptionsNormalized, Compiler } from ".";
+import { Compiler, RspackOptionsNormalized } from ".";
 export declare class RspackOptionsApply {
     constructor();
     process(options: RspackOptionsNormalized, compiler: Compiler): void;

package/dist/rspackOptionsApply.js

@@ -4,15 +4,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RspackOptionsApply = void 0;
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/OptionsApply.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+const assert_1 = __importDefault(require("assert"));
 const graceful_fs_1 = __importDefault(require("../compiled/graceful-fs"));
+const builtin_plugin_1 = require("./builtin-plugin");
+const EntryOptionPlugin_1 = __importDefault(require("./lib/EntryOptionPlugin"));
+const ignoreWarningsPlugin_1 = __importDefault(require("./lib/ignoreWarningsPlugin"));
 const DefaultStatsFactoryPlugin_1 = require("./stats/DefaultStatsFactoryPlugin");
 const DefaultStatsPrinterPlugin_1 = require("./stats/DefaultStatsPrinterPlugin");
-const cleverMerge_1 = require("./util/cleverMerge");
-const assert_1 = __importDefault(require("assert"));
-const ignoreWarningsPlugin_1 = __importDefault(require("./lib/ignoreWarningsPlugin"));
-const EntryOptionPlugin_1 = __importDefault(require("./lib/EntryOptionPlugin"));
-const builtin_plugin_1 = require("./builtin-plugin");
 const assertNotNil_1 = require("./util/assertNotNil");
+const cleverMerge_1 = require("./util/cleverMerge");
 class RspackOptionsApply {
     constructor() { }
     process(options, compiler) {
@@ -216,6 +225,9 @@ class RspackOptionsApply {
                 }
             }
         }
+        if (options.performance) {
+            new builtin_plugin_1.SizeLimitsPlugin(options.performance).apply(compiler);
+        }
         new builtin_plugin_1.WarnCaseSensitiveModulesPlugin().apply(compiler);
         new builtin_plugin_1.WorkerPlugin(options.output.workerChunkLoading, options.output.workerWasmLoading, options.output.module, options.output.workerPublicPath).apply(compiler);
         new DefaultStatsFactoryPlugin_1.DefaultStatsFactoryPlugin().apply(compiler);

package/dist/sharing/ConsumeSharedPlugin.d.ts

@@ -1,6 +1,6 @@
 import { BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
-import { Compiler } from "../Compiler";
 import { RspackBuiltinPlugin } from "../builtin-plugin/base";
+import { Compiler } from "../Compiler";
 export type ConsumeSharedPluginOptions = {
     consumes: Consumes;
     shareScope?: string;

package/dist/sharing/ConsumeSharedPlugin.js

@@ -4,8 +4,8 @@ exports.ConsumeSharedPlugin = void 0;
 const binding_1 = require("@rspack/binding");
 const base_1 = require("../builtin-plugin/base");
 const options_1 = require("../container/options");
-const utils_1 = require("./utils");
 const ShareRuntimePlugin_1 = require("./ShareRuntimePlugin");
+const utils_1 = require("./utils");
 class ConsumeSharedPlugin extends base_1.RspackBuiltinPlugin {
     constructor(options) {
         var _a;

package/dist/stats/DefaultStatsFactoryPlugin.js

@@ -33,11 +33,11 @@ exports.DefaultStatsFactoryPlugin = void 0;
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
+const util = __importStar(require("node:util"));
+const Logger_1 = require("../logging/Logger");
 const comparators_1 = require("../util/comparators");
 const identifier_1 = require("../util/identifier");
-const util = __importStar(require("node:util"));
 const statsFactoryUtils_1 = require("./statsFactoryUtils");
-const Logger_1 = require("../logging/Logger");
 const compareIds = comparators_1.compareIds;
 const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
 const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;

package/dist/stats/StatsFactory.d.ts

@@ -7,10 +7,10 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
+import { JsStats, JsStatsError, JsStatsWarning } from "@rspack/binding";
 import { HookMap, SyncBailHook, SyncWaterfallHook } from "tapable";
-import { GroupConfig } from "../util/smartGrouping";
 import type { Compilation } from "../Compilation";
-import { JsStats, JsStatsError, JsStatsWarning } from "@rspack/binding";
+import { GroupConfig } from "../util/smartGrouping";
 export type KnownStatsFactoryContext = {
     type: string;
     makePathsRelative?: ((arg0: string) => string) | undefined;

package/dist/stats/StatsFactory.js

@@ -1,15 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatsFactory = void 0;
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/tree/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/stats
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
 const tapable_1 = require("tapable");
 const comparators_1 = require("../util/comparators");
 const smartGrouping_1 = require("../util/smartGrouping");

package/dist/stats/StatsPrinter.d.ts

@@ -1,5 +1,5 @@
 import { HookMap, SyncBailHook, SyncWaterfallHook } from "tapable";
-import type { StatsAsset, StatsChunk, StatsChunkGroup, StatsModule, StatsModuleReason, StatsCompilation } from "./statsFactoryUtils";
+import type { StatsAsset, StatsChunk, StatsChunkGroup, StatsCompilation, StatsModule, StatsModuleReason } from "./statsFactoryUtils";
 type PrintedElement = {
     element: string;
     content: string;

package/dist/stats/statsFactoryUtils.d.ts

@@ -1,7 +1,7 @@
 import * as binding from "@rspack/binding";
-import { type Comparator } from "../util/comparators";
 import type { Compilation } from "../Compilation";
 import type { StatsOptions } from "../config";
+import { type Comparator } from "../util/comparators";
 import type { StatsFactory, StatsFactoryContext } from "./StatsFactory";
 export type KnownStatsChunkGroup = binding.JsStatsChunkGroup;
 export type KnownStatsChunk = binding.JsStatsChunk;

package/dist/util/comparators.d.ts

@@ -16,5 +16,5 @@ export declare const compareIds: (a: string | number, b: string | number) => -1
 export declare const compareChunksById: (a: Chunk, b: Chunk) => -1 | 0 | 1;
 export declare const compareChunkGroupsByIndex: (a: ChunkGroup, b: ChunkGroup) => -1 | 0 | 1;
 export declare const compareSelect: <T, R>(getter: Selector<T, R>, comparator: Comparator) => Comparator;
-export declare const compareNumbers: (a: number, b: number) => 1 | -1 | 0;
+export declare const compareNumbers: (a: number, b: number) => 0 | 1 | -1;
 export {};

package/dist/util/fs.d.ts

@@ -1,3 +1,14 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/fs.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+/// <reference types="node" />
+/// <reference types="node" />
 import { WatchOptions } from "../config";
 export interface Watcher {
     close(): void;
@@ -14,6 +25,58 @@ export interface WatcherInfo {
     fileTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">;
     contextTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">;
 }
+interface IDirent {
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+    isBlockDevice: () => boolean;
+    isCharacterDevice: () => boolean;
+    isSymbolicLink: () => boolean;
+    isFIFO: () => boolean;
+    isSocket: () => boolean;
+    name: string | Buffer;
+}
+interface IStats {
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+    isBlockDevice: () => boolean;
+    isCharacterDevice: () => boolean;
+    isSymbolicLink: () => boolean;
+    isFIFO: () => boolean;
+    isSocket: () => boolean;
+    dev: number | bigint;
+    ino: number | bigint;
+    mode: number | bigint;
+    nlink: number | bigint;
+    uid: number | bigint;
+    gid: number | bigint;
+    rdev: number | bigint;
+    size: number | bigint;
+    blksize: number | bigint;
+    blocks: number | bigint;
+    atimeMs: number | bigint;
+    mtimeMs: number | bigint;
+    ctimeMs: number | bigint;
+    birthtimeMs: number | bigint;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+}
+export interface OutputFileSystem {
+    writeFile: (arg0: string, arg1: string | Buffer, arg2: (arg0?: null | NodeJS.ErrnoException) => void) => void;
+    mkdir: (arg0: string, arg1: (arg0?: null | NodeJS.ErrnoException) => void) => void;
+    readdir: (arg0: string, arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: (string | Buffer)[] | IDirent[]) => void) => void;
+    rmdir: (arg0: string, arg1: (arg0?: null | NodeJS.ErrnoException) => void) => void;
+    unlink: (arg0: string, arg1: (arg0?: null | NodeJS.ErrnoException) => void) => void;
+    stat: (arg0: string, arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: IStats) => void) => void;
+    lstat?: (arg0: string, arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: IStats) => void) => void;
+    readFile: (arg0: string, arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: string | Buffer) => void) => void;
+    join?: (arg0: string, arg1: string) => string;
+    relative?: (arg0: string, arg1: string) => string;
+    dirname?: (arg0: string) => string;
+}
+export declare function rmrf(fs: OutputFileSystem, p: string, callback: (err?: Error | null) => void): void;
+export declare const mkdirp: (fs: OutputFileSystem, p: string, callback: (error?: Error) => void) => void;
 export interface FileSystemInfoEntry {
     safeTime: number;
     timestamp?: number;
@@ -21,3 +84,4 @@ export interface FileSystemInfoEntry {
 export interface WatchFileSystem {
     watch(files: Iterable<string>, directories: Iterable<string>, missing: Iterable<string>, startTime: number, options: WatchOptions, callback: (error: Error | null, fileTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, contextTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, changedFiles: Set<string>, removedFiles: Set<string>) => void, callbackUndelayed: (fileName: string, changeTime: number) => void): Watcher;
 }
+export {};