@rspack/core 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/Compilation.d.ts

@@ -167,6 +167,7 @@ export declare class Compilation {
             Set<string>
         ], void>;
         runtimeModule: RuntimeModule;
+        seal: liteTapable.SyncHook<[], void>;
         afterSeal: liteTapable.AsyncSeriesHook<[], void>;
     }>;
     name?: string;
@@ -210,6 +211,7 @@ export declare class Compilation {
      * Note: This is a proxy for webpack internal API, only method `get` and `keys` is supported now.
      */
     get namedChunks(): ReadonlyMap<string, Readonly<Chunk>>;
+    get entries(): Map<string, EntryData>;
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
@@ -220,7 +222,7 @@ export declare class Compilation {
         buildMeta: Record<string, unknown>;
     };
     getCache(name: string): import("./lib/CacheFacade").CacheFacade;
-    createStatsOptions(optionsOrPreset: StatsValue | undefined, context?: CreateStatsOptionsContext): NormalizedStatsOptions;
+    createStatsOptions(statsValue: StatsValue | undefined, context?: CreateStatsOptionsContext): NormalizedStatsOptions;
     createStatsFactory(options: StatsOptions): StatsFactory;
     createStatsPrinter(options: StatsOptions): StatsPrinter;
     /**
@@ -373,3 +375,20 @@ export declare class Compilation {
     static PROCESS_ASSETS_STAGE_ANALYSE: number;
     static PROCESS_ASSETS_STAGE_REPORT: number;
 }
+export type EntryData = binding.JsEntryData;
+export declare class Entries implements Map<string, EntryData> {
+    #private;
+    constructor(data: binding.JsEntries);
+    clear(): void;
+    forEach(callback: (value: binding.JsEntryData, key: string, map: Map<string, binding.JsEntryData>) => void, thisArg?: any): void;
+    get size(): number;
+    entries(): IterableIterator<[string, binding.JsEntryData]>;
+    values(): IterableIterator<binding.JsEntryData>;
+    [Symbol.iterator](): IterableIterator<[string, binding.JsEntryData]>;
+    get [Symbol.toStringTag](): string;
+    has(key: string): boolean;
+    set(key: string, value: EntryData): this;
+    delete(key: string): boolean;
+    get(key: string): EntryData | undefined;
+    keys(): IterableIterator<string>;
+}

package/dist/Compilation.js

@@ -36,9 +36,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Compilation_instances, _Compilation_inner, _Compilation_customModules, _Compilation_createCachedAssets, _Compilation_rebuildModuleCaller;
+var _Compilation_instances, _Compilation_inner, _Compilation_customModules, _Compilation_createCachedAssets, _Compilation_rebuildModuleCaller, _Entries_data;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compilation = void 0;
+exports.Entries = exports.Compilation = void 0;
 const binding_1 = require("@rspack/binding");
 const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const Chunk_1 = require("./Chunk");
@@ -98,12 +98,14 @@ class Compilation {
             const errorMessage = (reason) => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
             const getOptions = (options) => {
-                if (typeof options === "string")
-                    options = { name: options };
-                if (options.stage) {
+                const isString = typeof options === "string";
+                if (!isString && options.stage) {
                     throw new Error(errorMessage("it's using the 'stage' option"));
                 }
-                return { ...options, stage: stage };
+                return {
+                    ...(isString ? { name: options } : options),
+                    stage: stage
+                };
             };
             return Object.freeze({
                 name,
@@ -157,6 +159,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 "runtimeRequirements"
             ]),
             runtimeModule: new liteTapable.SyncHook(["module", "chunk"]),
+            seal: new liteTapable.SyncHook([]),
             afterSeal: new liteTapable.AsyncSeriesHook([])
         };
         this.compiler = compiler;
@@ -237,6 +240,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             }
         };
     }
+    get entries() {
+        return new Entries(__classPrivateFieldGet(this, _Compilation_inner, "f").entries);
+    }
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
@@ -255,7 +261,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     getCache(name) {
         return this.compiler.getCache(name);
     }
-    createStatsOptions(optionsOrPreset, context = {}) {
+    createStatsOptions(statsValue, context = {}) {
+        let optionsOrPreset = statsValue;
         if (typeof optionsOrPreset === "boolean" ||
             typeof optionsOrPreset === "string") {
             optionsOrPreset = { preset: optionsOrPreset };
@@ -448,12 +455,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             {
                 method: "push",
                 handler(target, thisArg, warns) {
-                    warns = processWarningsHook.call(warns);
-                    for (let i = 0; i < warns.length; i++) {
-                        const warn = warns[i];
+                    return Reflect.apply(target, thisArg, processWarningsHook.call(warns).map(warn => {
                         inner.pushDiagnostic(RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn));
-                    }
-                    return Reflect.apply(target, thisArg, warns);
+                        return warn;
+                    }));
                 }
             },
             {
@@ -473,12 +478,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             {
                 method: "unshift",
                 handler(target, thisArg, warns) {
-                    warns = processWarningsHook.call(warns);
-                    const warnList = warns.map(warn => {
+                    const warnings = processWarningsHook.call(warns);
+                    inner.spliceDiagnostic(0, 0, warnings.map(warn => {
                         return RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn);
-                    });
-                    inner.spliceDiagnostic(0, 0, warnList);
-                    return Reflect.apply(target, thisArg, warns);
+                    }));
+                    return Reflect.apply(target, thisArg, warnings);
                 }
             },
             {
@@ -521,11 +525,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         if (!name) {
             throw new TypeError("Compilation.getLogger(name) called without a name");
         }
+        let logName = name;
         let logEntries;
         return new Logger_1.Logger((type, args) => {
-            if (typeof name === "function") {
-                name = name();
-                if (!name) {
+            if (typeof logName === "function") {
+                logName = logName();
+                if (!logName) {
                     throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                 }
             }
@@ -545,67 +550,68 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 args,
                 trace
             };
-            if (this.hooks.log.call(name, logEntry) === undefined) {
+            if (this.hooks.log.call(logName, logEntry) === undefined) {
                 if (logEntry.type === Logger_1.LogType.profileEnd) {
                     if (typeof console.profileEnd === "function") {
-                        console.profileEnd(`[${name}] ${logEntry.args[0]}`);
+                        console.profileEnd(`[${logName}] ${logEntry.args[0]}`);
                     }
                 }
                 if (logEntries === undefined) {
-                    logEntries = this.logging.get(name);
+                    logEntries = this.logging.get(logName);
                     if (logEntries === undefined) {
                         logEntries = [];
-                        this.logging.set(name, logEntries);
+                        this.logging.set(logName, logEntries);
                     }
                 }
                 logEntries.push(logEntry);
                 if (logEntry.type === Logger_1.LogType.profile) {
                     if (typeof console.profile === "function") {
-                        console.profile(`[${name}] ${logEntry.args[0]}`);
+                        console.profile(`[${logName}] ${logEntry.args[0]}`);
                     }
                 }
             }
         }, (childName) => {
-            if (typeof name === "function") {
-                if (typeof childName === "function") {
+            let normalizedChildName = childName;
+            if (typeof logName === "function") {
+                if (typeof normalizedChildName === "function") {
                     return this.getLogger(() => {
-                        if (typeof name === "function") {
-                            name = name();
-                            if (!name) {
+                        if (typeof logName === "function") {
+                            logName = logName();
+                            if (!logName) {
                                 throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                             }
                         }
-                        if (typeof childName === "function") {
-                            childName = childName();
-                            if (!childName) {
+                        if (typeof normalizedChildName === "function") {
+                            normalizedChildName = normalizedChildName();
+                            if (!normalizedChildName) {
                                 throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                             }
                         }
-                        return `${name}/${childName}`;
+                        return `${logName}/${normalizedChildName}`;
                     });
                 }
                 return this.getLogger(() => {
-                    if (typeof name === "function") {
-                        name = name();
-                        if (!name) {
+                    if (typeof logName === "function") {
+                        logName = logName();
+                        if (!logName) {
                             throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${logName}/${normalizedChildName}`;
                 });
             }
-            if (typeof childName === "function") {
+            if (typeof normalizedChildName === "function") {
                 return this.getLogger(() => {
-                    if (typeof childName === "function") {
-                        childName = childName();
-                        if (!childName) {
+                    if (typeof normalizedChildName === "function") {
+                        normalizedChildName = normalizedChildName();
+                        if (!normalizedChildName) {
                             throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${logName}/${normalizedChildName}`;
                 });
             }
-            return this.getLogger(`${name}/${childName}`);
+            return this.getLogger(`${logName}/${normalizedChildName}`);
         });
     }
     getStats() {
@@ -759,3 +765,62 @@ Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
 Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000;
 Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000;
 exports.Compilation = Compilation;
+class Entries {
+    constructor(data) {
+        _Entries_data.set(this, void 0);
+        __classPrivateFieldSet(this, _Entries_data, data, "f");
+    }
+    clear() {
+        __classPrivateFieldGet(this, _Entries_data, "f").clear();
+    }
+    forEach(callback, thisArg) {
+        for (const [key, value] of this) {
+            callback.call(thisArg, value, key, this);
+        }
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").size;
+    }
+    entries() {
+        const self = this;
+        const keys = this.keys();
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                const { done, value } = keys.next();
+                return {
+                    done,
+                    value: done ? undefined : [value, self.get(value)]
+                };
+            }
+        };
+    }
+    values() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").values()[Symbol.iterator]();
+    }
+    [(_Entries_data = new WeakMap(), Symbol.iterator)]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return "Map";
+    }
+    has(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").has(key);
+    }
+    set(key, value) {
+        __classPrivateFieldGet(this, _Entries_data, "f").set(key, value);
+        return this;
+    }
+    delete(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").delete(key);
+    }
+    get(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").get(key);
+    }
+    keys() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").keys()[Symbol.iterator]();
+    }
+}
+exports.Entries = Entries;

package/dist/Compiler.d.ts

@@ -69,6 +69,7 @@ declare class Compiler {
         entryOption: liteTapable.SyncBailHook<[string, EntryNormalized], any>;
     };
     webpack: typeof rspack;
+    rspack: typeof rspack;
     name?: string;
     parentCompilation?: Compilation;
     root: Compiler;

package/dist/Compiler.js

@@ -137,6 +137,7 @@ class Compiler {
             entryOption: new liteTapable.SyncBailHook(["context", "entry"])
         };
         this.webpack = index_1.rspack;
+        this.rspack = index_1.rspack;
         this.root = this;
         this.outputPath = "";
         this.inputFileSystem = null;
@@ -199,62 +200,65 @@ class Compiler {
         if (!name) {
             throw new TypeError("Compiler.getInfrastructureLogger(name) called without a name");
         }
+        let normalizedName = name;
         return new Logger_1.Logger((type, args) => {
-            if (typeof name === "function") {
-                name = name();
-                if (!name) {
+            if (typeof normalizedName === "function") {
+                normalizedName = normalizedName();
+                if (!normalizedName) {
                     throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                 }
             }
             else {
-                if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+                if (this.hooks.infrastructureLog.call(normalizedName, type, args) ===
+                    undefined) {
                     if (this.infrastructureLogger !== undefined) {
-                        this.infrastructureLogger(name, type, args);
+                        this.infrastructureLogger(normalizedName, type, args);
                     }
                 }
             }
         }, (childName) => {
-            if (typeof name === "function") {
-                if (typeof childName === "function") {
+            let normalizedChildName = childName;
+            if (typeof normalizedName === "function") {
+                if (typeof normalizedChildName === "function") {
                     // @ts-expect-error
                     return this.getInfrastructureLogger(_ => {
-                        if (typeof name === "function") {
-                            name = name();
-                            if (!name) {
+                        if (typeof normalizedName === "function") {
+                            normalizedName = normalizedName();
+                            if (!normalizedName) {
                                 throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                             }
                         }
-                        if (typeof childName === "function") {
-                            childName = childName();
-                            if (!childName) {
+                        if (typeof normalizedChildName === "function") {
+                            normalizedChildName = normalizedChildName();
+                            if (!normalizedChildName) {
                                 throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                             }
                         }
-                        return `${name}/${childName}`;
+                        return `${normalizedName}/${normalizedChildName}`;
                     });
                 }
                 return this.getInfrastructureLogger(() => {
-                    if (typeof name === "function") {
-                        name = name();
-                        if (!name) {
+                    if (typeof normalizedName === "function") {
+                        normalizedName = normalizedName();
+                        if (!normalizedName) {
                             throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${normalizedName}/${normalizedChildName}`;
                 });
             }
-            if (typeof childName === "function") {
+            if (typeof normalizedChildName === "function") {
                 return this.getInfrastructureLogger(() => {
-                    if (typeof childName === "function") {
-                        childName = childName();
-                        if (!childName) {
+                    if (typeof normalizedChildName === "function") {
+                        normalizedChildName = normalizedChildName();
+                        if (!normalizedChildName) {
                             throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${normalizedName}/${normalizedChildName}`;
                 });
             }
-            return this.getInfrastructureLogger(`${name}/${childName}`);
+            return this.getInfrastructureLogger(`${normalizedName}/${normalizedChildName}`);
         });
     }
     /**
@@ -665,6 +669,7 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
         registerCompilationChunkAssetTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationChunkAsset, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.chunkAsset, queried => ({ chunk, filename }) => queried.call(Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")), filename)),
         registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationProcessAssets, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.processAssets, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").assets)),
         registerCompilationAfterProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterProcessAssets, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterProcessAssets, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").assets)),
+        registerCompilationSealTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationSeal, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.seal, queried => () => queried.call()),
         registerCompilationAfterSealTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterSeal, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterSeal, queried => async () => await queried.promise()),
         registerNormalModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryBeforeResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.beforeResolve, queried => async (resolveData) => {
             const normalizedResolveData = {

package/dist/MultiCompiler.js

@@ -51,21 +51,25 @@ const ArrayQueue_1 = __importDefault(require("./util/ArrayQueue"));
 class MultiCompiler {
     constructor(compilers, options) {
         _MultiCompiler_instances.add(this);
+        let normalizedCompilers;
         if (!Array.isArray(compilers)) {
-            compilers = Object.entries(compilers).map(([name, compiler]) => {
+            normalizedCompilers = Object.entries(compilers).map(([name, compiler]) => {
                 compiler.name = name;
                 return compiler;
             });
         }
+        else {
+            normalizedCompilers = compilers;
+        }
         this.hooks = {
             done: new liteTapable.SyncHook(["stats"]),
-            invalid: new liteTapable.MultiHook(compilers.map(c => c.hooks.invalid)),
-            run: new liteTapable.MultiHook(compilers.map(c => c.hooks.run)),
+            invalid: new liteTapable.MultiHook(normalizedCompilers.map(c => c.hooks.invalid)),
+            run: new liteTapable.MultiHook(normalizedCompilers.map(c => c.hooks.run)),
             watchClose: new liteTapable.SyncHook([]),
-            watchRun: new liteTapable.MultiHook(compilers.map(c => c.hooks.watchRun)),
-            infrastructureLog: new liteTapable.MultiHook(compilers.map(c => c.hooks.infrastructureLog))
+            watchRun: new liteTapable.MultiHook(normalizedCompilers.map(c => c.hooks.watchRun)),
+            infrastructureLog: new liteTapable.MultiHook(normalizedCompilers.map(c => c.hooks.infrastructureLog))
         };
-        this.compilers = compilers;
+        this.compilers = normalizedCompilers;
         this._options = {
             parallelism: options?.parallelism || Number.POSITIVE_INFINITY
         };

package/dist/MultiStats.d.ts

@@ -16,7 +16,7 @@ export default class MultiStats {
     get hash(): string;
     hasErrors(): boolean;
     hasWarnings(): boolean;
-    toJson(options?: any): StatsCompilation;
+    toJson(options: any): StatsCompilation;
     toString(options: any): string;
 }
 export { MultiStats };

package/dist/MultiStats.js

@@ -56,21 +56,23 @@ class MultiStats {
         return this.stats.some(stat => stat.hasWarnings());
     }
     toJson(options) {
-        options = __classPrivateFieldGet(this, _MultiStats_instances, "m", _MultiStats_createChildOptions).call(this, options, { forToString: false });
+        const childOptions = __classPrivateFieldGet(this, _MultiStats_instances, "m", _MultiStats_createChildOptions).call(this, options || {}, {
+            forToString: false
+        });
         const obj = {};
         obj.children = this.stats.map((stat, idx) => {
-            const obj = stat.toJson(options.children[idx]);
+            const obj = stat.toJson(childOptions.children[idx]);
             const compilationName = stat.compilation.name;
             const name = compilationName &&
-                identifierUtils.makePathsRelative(options.context, compilationName, stat.compilation.compiler.root);
+                identifierUtils.makePathsRelative(childOptions.context, compilationName, stat.compilation.compiler.root);
             obj.name = name;
             return obj;
         });
-        if (options.version) {
+        if (childOptions.version) {
             obj.rspackVersion = require("../package.json").version;
             obj.version = require("../package.json").webpackVersion;
         }
-        if (options.hash) {
+        if (childOptions.hash) {
             obj.hash = obj.children.map(j => j.hash).join("");
         }
         const mapError = (j, obj) => {
@@ -81,7 +83,7 @@ class MultiStats {
                     : j.name
             };
         };
-        if (options.errors) {
+        if (childOptions.errors) {
             obj.errors = [];
             for (const j of obj.children) {
                 for (const i of j.errors || []) {
@@ -89,7 +91,7 @@ class MultiStats {
                 }
             }
         }
-        if (options.warnings) {
+        if (childOptions.warnings) {
             obj.warnings = [];
             for (const j of obj.children) {
                 for (const i of j.warnings || []) {
@@ -97,13 +99,13 @@ class MultiStats {
                 }
             }
         }
-        if (options.errorsCount) {
+        if (childOptions.errorsCount) {
             obj.errorsCount = 0;
             for (const j of obj.children) {
                 obj.errorsCount += j.errorsCount || 0;
             }
         }
-        if (options.warningsCount) {
+        if (childOptions.warningsCount) {
             obj.warningsCount = 0;
             for (const j of obj.children) {
                 obj.warningsCount += j.warningsCount || 0;
@@ -112,13 +114,15 @@ class MultiStats {
         return obj;
     }
     toString(options) {
-        options = __classPrivateFieldGet(this, _MultiStats_instances, "m", _MultiStats_createChildOptions).call(this, options, { forToString: true });
+        const childOptions = __classPrivateFieldGet(this, _MultiStats_instances, "m", _MultiStats_createChildOptions).call(this, options || {}, {
+            forToString: true
+        });
         const results = this.stats.map((stat, idx) => {
-            const str = stat.toString(options.children[idx]);
+            const str = stat.toString(childOptions.children[idx]);
             const compilationName = stat.compilation.name;
             const name = compilationName &&
                 identifierUtils
-                    .makePathsRelative(options.context, compilationName, stat.compilation.compiler.root)
+                    .makePathsRelative(childOptions.context, compilationName, stat.compilation.compiler.root)
                     .replace(/\|/g, " ");
             if (!str)
                 return str;
@@ -130,9 +134,6 @@ class MultiStats {
 exports.default = MultiStats;
 exports.MultiStats = MultiStats;
 _MultiStats_instances = new WeakSet(), _MultiStats_createChildOptions = function _MultiStats_createChildOptions(options, context) {
-    if (!options) {
-        options = {};
-    }
     const { children: childrenOptions = undefined, ...baseOptions } = typeof options === "string" ? { preset: options } : options;
     const children = this.stats.map((stat, idx) => {
         const childOptions = Array.isArray(childrenOptions)
@@ -153,6 +154,8 @@ _MultiStats_instances = new WeakSet(), _MultiStats_createChildOptions = function
         warningsCount: children.every(o => o.warningsCount),
         errors: children.every(o => o.errors),
         warnings: children.every(o => o.warnings),
-        children
+        children,
+        context: "",
+        version: ""
     };
 };

package/dist/NormalModule.js

@@ -32,10 +32,9 @@ const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const Compilation_1 = require("./Compilation");
 const compilationHooksMap = new WeakMap();
 const createFakeHook = (fakeHook, message, code) => {
-    if (message && code) {
-        fakeHook = deprecateAllProperties(fakeHook, message, code);
-    }
-    return Object.freeze(Object.assign(fakeHook, { _fakeHook: true }));
+    return Object.freeze(Object.assign(message && code
+        ? deprecateAllProperties(fakeHook, message, code)
+        : fakeHook, { _fakeHook: true }));
 };
 const deprecateAllProperties = (obj, message, code) => {
     const newObj = {};

package/dist/Stats.d.ts

@@ -1,7 +1,7 @@
 import type { Compilation } from "./Compilation";
 import type { StatsOptions, StatsValue } from "./config";
 import type { StatsCompilation } from "./stats/statsFactoryUtils";
-export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule, StatsWarnings } from "./stats/statsFactoryUtils";
+export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule } from "./stats/statsFactoryUtils";
 export declare class Stats {
     #private;
     compilation: Compilation;

package/dist/Template.d.ts

@@ -37,15 +37,15 @@ declare class Template {
      */
     static toPath(str: string): string;
     /**
-     * @param n number to convert to ident
+     * @param num number to convert to ident
      * @returns returns single character ident
      */
-    static numberToIdentifier(n: number): string;
+    static numberToIdentifier(num: number): string;
     /**
-     * @param n number to convert to ident
+     * @param num number to convert to ident
      * @returns returns single character ident
      */
-    static numberToIdentifierContinuation(n: number): string;
+    static numberToIdentifierContinuation(num: number): string;
     /**
      *
      * @param s string to convert to identity

package/dist/Template.js

@@ -80,10 +80,11 @@ class Template {
     }
     // map number to a single character a-z, A-Z or multiple characters if number is too big
     /**
-     * @param n number to convert to ident
+     * @param num number to convert to ident
      * @returns returns single character ident
      */
-    static numberToIdentifier(n) {
+    static numberToIdentifier(num) {
+        let n = num;
         if (n >= NUMBER_OF_IDENTIFIER_START_CHARS) {
             // use multiple letters
             return (Template.numberToIdentifier(n % NUMBER_OF_IDENTIFIER_START_CHARS) +
@@ -103,10 +104,11 @@ class Template {
         return "$";
     }
     /**
-     * @param n number to convert to ident
+     * @param num number to convert to ident
      * @returns returns single character ident
      */
-    static numberToIdentifierContinuation(n) {
+    static numberToIdentifierContinuation(num) {
+        let n = num;
         if (n >= NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) {
             // use multiple letters
             return (Template.numberToIdentifierContinuation(n % NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) +