@rspack/core 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/stats/DefaultStatsFactoryPlugin.js

@@ -57,22 +57,14 @@ const ITEM_NAMES = {
     "module.issuerPath[]": "moduleIssuer",
     "module.reasons[]": "moduleReason",
     "module.modules[]": "module",
-    "module.children[]": "module"
-    // "moduleTrace[]": "moduleTraceItem",
+    "module.children[]": "module",
+    "moduleTrace[]": "moduleTraceItem"
     // "moduleTraceItem.dependencies[]": "moduleTraceDependency"
 };
-// const MERGER: Record<
-// 	string,
-// 	(
-// 		items: {
-// 			[key: string]: any;
-// 			name: string;
-// 		}[]
-// 	) => any
-// > = {
-// 	"compilation.entrypoints": mergeToObject,
-// 	"compilation.namedChunkGroups": mergeToObject
-// };
+const MERGER = {
+    "compilation.entrypoints": statsFactoryUtils_1.mergeToObject,
+    "compilation.namedChunkGroups": statsFactoryUtils_1.mergeToObject
+};
 const ASSETS_GROUPERS = {
     _: (groupConfigs, context, options) => {
         const groupByFlag = (name, exclude) => {
@@ -149,10 +141,74 @@ const ASSETS_GROUPERS = {
                 }
             });
         }
+    },
+    groupAssetsByInfo: groupConfigs => {
+        const groupByAssetInfoFlag = (name) => {
+            groupConfigs.push({
+                getKeys: asset => {
+                    return asset.info && asset.info[name] ? ["1"] : undefined;
+                },
+                // @ts-expect-error
+                createGroup: (key, children) => {
+                    return {
+                        type: "assets by info",
+                        info: {
+                            [name]: !!key
+                        },
+                        children,
+                        ...(0, statsFactoryUtils_1.assetGroup)(children)
+                    };
+                }
+            });
+        };
+        groupByAssetInfoFlag("immutable");
+        groupByAssetInfoFlag("development");
+        groupByAssetInfoFlag("hotModuleReplacement");
+    },
+    groupAssetsByChunk: groupConfigs => {
+        const groupByNames = (name) => {
+            groupConfigs.push({
+                getKeys: asset => {
+                    return asset[name];
+                },
+                // @ts-expect-error
+                createGroup: (key, children) => {
+                    return {
+                        type: "assets by chunk",
+                        [name]: [key],
+                        children,
+                        ...(0, statsFactoryUtils_1.assetGroup)(children)
+                    };
+                }
+            });
+        };
+        groupByNames("chunkNames");
+        groupByNames("auxiliaryChunkNames");
+        groupByNames("chunkIdHints");
+        groupByNames("auxiliaryChunkIdHints");
+    },
+    excludeAssets: (groupConfigs, context, { excludeAssets }) => {
+        groupConfigs.push({
+            getKeys: asset => {
+                const ident = asset.name;
+                const excluded = excludeAssets.some(fn => fn(ident, asset));
+                if (excluded)
+                    return ["excluded"];
+            },
+            getOptions: () => ({
+                groupChildren: false,
+                force: true
+            }),
+            // @ts-expect-error
+            createGroup: (key, children, assets) => ({
+                type: "hidden assets",
+                filteredChildren: assets.length,
+                ...(0, statsFactoryUtils_1.assetGroup)(children)
+            })
+        });
     }
-    // not support groupAssetsByInfo / groupAssetsByChunk / excludeAssets
 };
-const MODULES_GROUPERS = (_type) => ({
+const MODULES_GROUPERS = (type) => ({
     _: (groupConfigs, context, options) => {
         const groupByFlag = (name, type, exclude) => {
             groupConfigs.push({
@@ -176,7 +232,7 @@ const MODULES_GROUPERS = (_type) => ({
                 }
             });
         };
-        const { groupModulesByCacheStatus, groupModulesByAttributes, groupModulesByType } = options;
+        const { groupModulesByCacheStatus, groupModulesByAttributes, groupModulesByType, groupModulesByPath, groupModulesByExtension } = options;
         if (groupModulesByAttributes) {
             groupByFlag("errors", "modules with errors");
             groupByFlag("warnings", "modules with warnings");
@@ -228,9 +284,76 @@ const MODULES_GROUPERS = (_type) => ({
                 }
             });
         }
-        // not support groupModulesByLayer / groupModulesByPath / groupModulesByExtension
+        // not support groupModulesByLayer
+        if (groupModulesByPath || groupModulesByExtension) {
+            groupConfigs.push({
+                getKeys: module => {
+                    if (!module.name)
+                        return;
+                    const resource = (0, identifier_1.parseResource)(module.name.split("!").pop()).path;
+                    const dataUrl = /^data:[^,;]+/.exec(resource);
+                    if (dataUrl)
+                        return [dataUrl[0]];
+                    const extensionMatch = groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
+                    const extension = extensionMatch ? extensionMatch[1] : "";
+                    const pathMatch = groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
+                    const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+                    const keys = [];
+                    if (groupModulesByPath) {
+                        if (extension)
+                            keys.push(path.length
+                                ? `${path.join("/")}/*${extension}`
+                                : `*${extension}`);
+                        while (path.length > 0) {
+                            keys.push(path.join("/") + "/");
+                            path.pop();
+                        }
+                    }
+                    else {
+                        if (extension)
+                            keys.push(`*${extension}`);
+                    }
+                    return keys;
+                },
+                // @ts-expect-error
+                createGroup: (key, children, modules) => {
+                    const isDataUrl = key.startsWith("data:");
+                    return {
+                        type: isDataUrl
+                            ? "modules by mime type"
+                            : groupModulesByPath
+                                ? "modules by path"
+                                : "modules by extension",
+                        name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
+                        children,
+                        ...(0, statsFactoryUtils_1.moduleGroup)(children)
+                    };
+                }
+            });
+        }
+    },
+    excludeModules: (groupConfigs, context, { excludeModules }) => {
+        groupConfigs.push({
+            getKeys: module => {
+                const name = module.name;
+                if (name) {
+                    const excluded = excludeModules.some(fn => fn(name, module, type));
+                    if (excluded)
+                        return ["1"];
+                }
+            },
+            getOptions: () => ({
+                groupChildren: false,
+                force: true
+            }),
+            // @ts-expect-error
+            createGroup: (key, children, modules) => ({
+                type: "hidden modules",
+                filteredChildren: children.length,
+                ...(0, statsFactoryUtils_1.moduleGroup)(children)
+            })
+        });
     }
-    // not support excludeModules
 });
 const RESULT_GROUPERS = {
     "compilation.assets": ASSETS_GROUPERS,
@@ -295,6 +418,31 @@ const SORTERS = {
         }
     }
 };
+const EXTRACT_ERROR = {
+    _: (object, error) => {
+        object.message = error.message;
+        object.chunkName = error.chunkName;
+        object.chunkEntry = error.chunkEntry;
+        object.chunkInitial = error.chunkInitial;
+        object.file = error.file;
+        object.moduleIdentifier = error.moduleIdentifier;
+        object.moduleName = error.moduleName;
+    },
+    ids: (object, error) => {
+        object.chunkId = error.chunkId;
+        object.moduleId = error.moduleId;
+    },
+    moduleTrace: (object, error, context, _, factory) => {
+        const { type } = context;
+        object.moduleTrace = factory.create(`${type}.moduleTrace`, error.moduleTrace, context);
+    },
+    errorDetails: (object, error) => {
+        object.details = error.details;
+    },
+    errorStack: (object, error) => {
+        object.stack = error.stack;
+    }
+};
 const SIMPLE_EXTRACTORS = {
     compilation: {
         _: (object, compilation, context, options) => {
@@ -475,22 +623,51 @@ const SIMPLE_EXTRACTORS = {
             object.outputPath = compilation.outputOptions.path;
         },
         assets: (object, compilation, context, options, factory) => {
-            const { assets, assetsByChunkName } = context
+            const { assets: compilationAssets, assetsByChunkName } = context
                 .getInner(compilation)
                 .getAssets();
+            const assetMap = new Map();
+            const assets = new Set();
+            for (const asset of compilationAssets) {
+                const item = {
+                    ...asset,
+                    type: "asset",
+                    related: []
+                };
+                assets.add(item);
+                assetMap.set(asset.name, item);
+            }
+            for (const item of assetMap.values()) {
+                const related = item.info.related;
+                if (!related)
+                    continue;
+                for (const { name: type, value: relatedEntry } of related) {
+                    const deps = Array.isArray(relatedEntry)
+                        ? relatedEntry
+                        : [relatedEntry];
+                    for (const dep of deps) {
+                        const depItem = assetMap.get(dep);
+                        if (!depItem)
+                            continue;
+                        assets.delete(depItem);
+                        depItem.type = type;
+                        item.related = item.related || [];
+                        item.related.push(depItem);
+                    }
+                }
+            }
             object.assetsByChunkName = assetsByChunkName.reduce((acc, cur) => {
                 acc[cur.name] = cur.files;
                 return acc;
             }, {});
-            const groupedAssets = factory.create(`${context.type}.assets`, assets, {
+            const groupedAssets = factory.create(`${context.type}.assets`, Array.from(assets), {
                 ...context
                 // compilationFileToChunks
                 // compilationAuxiliaryFileToChunks
             });
-            const limited = (0, statsFactoryUtils_1.spaceLimited)(groupedAssets, options.assetsSpace || Infinity);
-            // object.filteredAssets = limited.filteredChildren;
-            // const limited = spaceLimited(groupedAssets, options.assetsSpace);
+            const limited = (0, statsFactoryUtils_1.spaceLimited)(groupedAssets, options.assetsSpace || Number.POSITIVE_INFINITY);
             object.assets = limited.children;
+            object.filteredAssets = limited.filteredChildren;
         },
         chunks: (object, compilation, context, options, factory) => {
             const { type } = context;
@@ -509,35 +686,46 @@ const SIMPLE_EXTRACTORS = {
             object.modules = limited.children;
             object.filteredModules = limited.filteredChildren;
         },
-        entrypoints: (object, compilation, context, { chunkGroupAuxiliary, chunkGroupChildren }, _factory) => {
-            // const { type } = context;
+        entrypoints: (object, compilation, context, { entrypoints, chunkGroups, chunkGroupAuxiliary, chunkGroupChildren }, factory) => {
+            const { type } = context;
             const array = context
                 .getInner(compilation)
-                .getEntrypoints(chunkGroupAuxiliary, chunkGroupChildren);
-            // object.entrypoints = factory.create(
-            // 	`${type}.entrypoints`,
-            // 	array,
-            // 	context
-            // );
-            object.entrypoints = array.reduce((acc, cur) => {
-                acc[cur.name] = cur;
-                return acc;
+                .getEntrypoints(chunkGroupAuxiliary, chunkGroupChildren)
+                .map(entrypoint => ({
+                name: entrypoint.name,
+                chunkGroup: entrypoint
+            }));
+            const chunks = Array.from(compilation.chunks).reduce((res, chunk) => {
+                res[chunk.id] = chunk;
+                return res;
             }, {});
+            if (entrypoints === "auto" && !chunkGroups) {
+                if (array.length > 5)
+                    return;
+                if (!chunkGroupChildren &&
+                    array.every(({ chunkGroup }) => {
+                        if (chunkGroup.chunks.length !== 1)
+                            return false;
+                        const chunk = chunks[chunkGroup.chunks[0]];
+                        return (chunk &&
+                            chunk.files.size === 1 &&
+                            (!chunkGroupAuxiliary || chunk.auxiliaryFiles.size === 0));
+                    })) {
+                    return;
+                }
+            }
+            object.entrypoints = factory.create(`${type}.entrypoints`, array, context);
         },
         chunkGroups: (object, compilation, context, { chunkGroupAuxiliary, chunkGroupChildren }, factory) => {
-            // const { type } = context;
+            const { type } = context;
             const namedChunkGroups = context
                 .getInner(compilation)
-                .getNamedChunkGroups(chunkGroupAuxiliary, chunkGroupChildren);
-            // object.namedChunkGroups = factory.create(
-            // 	`${type}.namedChunkGroups`,
-            // 	namedChunkGroups,
-            // 	context
-            // );
-            object.namedChunkGroups = namedChunkGroups.reduce((acc, cur) => {
-                acc[cur.name] = cur;
-                return acc;
-            }, {});
+                .getNamedChunkGroups(chunkGroupAuxiliary, chunkGroupChildren)
+                .map(cg => ({
+                name: cg.name,
+                chunkGroup: cg
+            }));
+            object.namedChunkGroups = factory.create(`${type}.namedChunkGroups`, namedChunkGroups, context);
         },
         errors: (object, compilation, context, _options, _factory) => {
             const { cachedGetErrors } = context;
@@ -571,15 +759,45 @@ const SIMPLE_EXTRACTORS = {
                 ...asset.info,
                 related: Object.fromEntries(asset.info.related.map(i => [i.name, i.value]))
             };
+            // - comparedForEmit
+            // - cached
             Object.assign(object, factory.create(`${context.type}$visible`, asset, context));
         }
     },
     asset$visible: {
         _: (object, asset) => {
             object.chunkNames = asset.chunkNames;
+            object.chunkIdHints = asset.chunkIdHints.filter(Boolean);
+            object.auxiliaryChunkNames = asset.auxiliaryChunkNames;
+            object.auxiliaryChunkIdHints =
+                asset.auxiliaryChunkIdHints.filter(Boolean);
+        },
+        relatedAssets: (object, asset, context, options, factory) => {
+            const { type } = context;
+            object.related = factory.create(`${type.slice(0, -8)}.related`, asset.related, context);
+            object.filteredRelated = asset.related
+                ? asset.related.length - object.related.length
+                : undefined;
         },
         ids: (object, asset) => {
             object.chunks = asset.chunks;
+            object.auxiliaryChunks = asset.auxiliaryChunks;
+        }
+    },
+    chunkGroup: {
+        _: (object, { name, chunkGroup }, _context, { chunkGroupMaxAssets }) => {
+            object.name = name;
+            object.chunks = chunkGroup.chunks;
+            object.assets = chunkGroup.assets;
+            object.filteredAssets =
+                chunkGroup.assets.length <= chunkGroupMaxAssets
+                    ? 0
+                    : chunkGroup.assets.length;
+            object.assetsSize = chunkGroup.assetsSize;
+            object.auxiliaryAssets = chunkGroup.auxiliaryAssets;
+            object.auxiliaryAssetsSize = chunkGroup.auxiliaryAssetsSize;
+            object.children = chunkGroup.children;
+            // - childAssets
         }
     },
     module: {
@@ -635,6 +853,7 @@ const SIMPLE_EXTRACTORS = {
         reasons: (object, module, context, options, factory) => {
             const { type } = context;
             object.reasons = factory.create(`${type.slice(0, -8)}.reasons`, module.reasons, context);
+            // object.filteredReasons
         },
         source: (object, module) => {
             object.source = module.source;
@@ -745,7 +964,23 @@ const SIMPLE_EXTRACTORS = {
         chunkOrigins: (object, chunk, context, options, factory) => {
             object.origins = chunk.origins;
         }
+    },
+    // chunkOrigin
+    error: EXTRACT_ERROR,
+    warning: EXTRACT_ERROR,
+    moduleTraceItem: {
+        _: (object, { origin, module }, context, { requestShortener }, factory) => {
+            object.originIdentifier = origin.identifier;
+            object.originName = origin.name;
+            object.moduleIdentifier = module.identifier;
+            object.moduleName = module.name;
+        },
+        ids: (object, { origin, module }) => {
+            object.originId = origin.id;
+            object.moduleId = module.id;
+        }
     }
+    // moduleTraceDependency
 };
 /**
  * only support below factories:
@@ -797,10 +1032,10 @@ class DefaultStatsFactoryPlugin {
                         .for(key)
                         .tap("DefaultStatsFactoryPlugin", () => itemName);
                 }
-                // for (const key of Object.keys(MERGER)) {
-                // 	const merger = MERGER[key];
-                // 	stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
-                // }
+                for (const key of Object.keys(MERGER)) {
+                    const merger = MERGER[key];
+                    stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
+                }
             });
         });
     }

package/dist/stats/DefaultStatsPresetPlugin.js

@@ -16,7 +16,7 @@ const NAMED_PRESETS = {
     verbose: {
         hash: true,
         builtAt: true,
-        // relatedAssets: true,
+        relatedAssets: true,
         entrypoints: true,
         chunkGroups: true,
         ids: true,
@@ -24,16 +24,16 @@ const NAMED_PRESETS = {
         chunks: true,
         chunkRelations: true,
         chunkModules: true,
-        // dependentModules: true,
-        // chunkOrigins: true,
+        dependentModules: true,
+        chunkOrigins: true,
         depth: true,
-        // env: true,
+        env: true,
         reasons: true,
         usedExports: true,
         providedExports: true,
         optimizationBailout: true,
-        // errorDetails: true,
-        // errorStack: true,
+        errorDetails: true,
+        errorStack: true,
         publicPath: true,
         logging: "verbose",
         orphanModules: true,
@@ -41,7 +41,7 @@ const NAMED_PRESETS = {
         // exclude: false,
         // errorsSpace: Infinity,
         // warningsSpace: Infinity,
-        modulesSpace: Infinity,
+        modulesSpace: Number.POSITIVE_INFINITY,
         // chunkModulesSpace: Infinity,
         // assetsSpace: Infinity,
         // reasonsSpace: Infinity,
@@ -50,19 +50,19 @@ const NAMED_PRESETS = {
     detailed: {
         hash: true,
         builtAt: true,
-        // relatedAssets: true,
+        relatedAssets: true,
         entrypoints: true,
         chunkGroups: true,
         ids: true,
         chunks: true,
         chunkRelations: true,
         chunkModules: false,
-        // chunkOrigins: true,
+        chunkOrigins: true,
         depth: true,
         usedExports: true,
         providedExports: true,
         optimizationBailout: true,
-        // errorDetails: true,
+        errorDetails: true,
         publicPath: true,
         logging: true,
         runtimeModules: true,
@@ -94,7 +94,7 @@ const NAMED_PRESETS = {
         errors: true,
         errorsCount: true,
         // errorsSpace: Infinity,
-        // moduleTrace: true,
+        moduleTrace: true,
         logging: "error"
     },
     "errors-warnings": {
@@ -147,7 +147,7 @@ const DEFAULTS = {
     chunkGroups: OFF_FOR_TO_STRING,
     chunkGroupAuxiliary: OFF_FOR_TO_STRING,
     chunkGroupChildren: OFF_FOR_TO_STRING,
-    chunkGroupMaxAssets: (o, { forToString }) => (forToString ? 5 : Infinity),
+    chunkGroupMaxAssets: (o, { forToString }) => forToString ? 5 : Number.POSITIVE_INFINITY,
     chunks: OFF_FOR_TO_STRING,
     chunkRelations: OFF_FOR_TO_STRING,
     chunkModules: ({ all, modules }) => {
@@ -178,16 +178,16 @@ const DEFAULTS = {
     groupModulesByAttributes: ON_FOR_TO_STRING,
     groupModulesByPath: ON_FOR_TO_STRING,
     groupModulesByExtension: ON_FOR_TO_STRING,
-    modulesSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
-    chunkModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
-    nestedModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
+    modulesSpace: (o, { forToString }) => forToString ? 15 : Number.POSITIVE_INFINITY,
+    chunkModulesSpace: (o, { forToString }) => forToString ? 10 : Number.POSITIVE_INFINITY,
+    nestedModulesSpace: (o, { forToString }) => forToString ? 10 : Number.POSITIVE_INFINITY,
     relatedAssets: OFF_FOR_TO_STRING,
     groupAssetsByEmitStatus: ON_FOR_TO_STRING,
     groupAssetsByInfo: ON_FOR_TO_STRING,
     groupAssetsByPath: ON_FOR_TO_STRING,
     groupAssetsByExtension: ON_FOR_TO_STRING,
     groupAssetsByChunk: ON_FOR_TO_STRING,
-    assetsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+    assetsSpace: (o, { forToString }) => forToString ? 15 : Number.POSITIVE_INFINITY,
     orphanModules: OFF_FOR_TO_STRING,
     runtimeModules: ({ all, runtime }, { forToString }) => runtime !== undefined
         ? runtime
@@ -200,7 +200,7 @@ const DEFAULTS = {
     depth: OFF_FOR_TO_STRING,
     // cachedAssets: OFF_FOR_TO_STRING,
     reasons: OFF_FOR_TO_STRING,
-    reasonsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+    reasonsSpace: (o, { forToString }) => forToString ? 15 : Number.POSITIVE_INFINITY,
     groupReasonsByOrigin: ON_FOR_TO_STRING,
     usedExports: OFF_FOR_TO_STRING,
     providedExports: OFF_FOR_TO_STRING,

package/dist/stats/DefaultStatsPrinterPlugin.js

@@ -81,7 +81,7 @@ const SIMPLE_PRINTERS = {
             statusMessage = `compiled ${green("successfully")}`;
         }
         else {
-            statusMessage = `compiled`;
+            statusMessage = "compiled";
         }
         if (builtAtMessage ||
             versionMessage ||
@@ -367,7 +367,7 @@ const SIMPLE_PRINTERS = {
     "error.message": (message, { bold, formatError }) => message.includes("\u001b[") ? message : bold(formatError(message)),
     // "error.details": (details, { formatError }) => formatError(details),
     // "error.stack": stack => stack,
-    // "error.moduleTrace": moduleTrace => undefined,
+    "error.moduleTrace": moduleTrace => undefined,
     "error.separator!": () => "\n",
     "loggingEntry(error).loggingEntry.message": (message, { red }) => mapLines(message, x => `<e> ${red(x)}`),
     "loggingEntry(warn).loggingEntry.message": (message, { yellow }) => mapLines(message, x => `<w> ${yellow(x)}`),

package/dist/stats/statsFactoryUtils.d.ts

@@ -2,20 +2,19 @@ import type * as binding from "@rspack/binding";
 import type { Compilation, NormalizedStatsOptions } from "../Compilation";
 import { type Comparator } from "../util/comparators";
 import type { StatsFactory, StatsFactoryContext } from "./StatsFactory";
+type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
 export type KnownStatsChunkGroup = binding.JsStatsChunkGroup;
-export type KnownStatsChunk = Omit<binding.JsStatsChunk, "sizes"> & {
+export type KnownStatsChunk = Omit<Writable<binding.JsStatsChunk>, "sizes"> & {
     sizes: Record<string, number>;
 };
-export type KnownStatsAssetInfo = Omit<binding.JsStatsAssetInfo, "related"> & {
-    related: Record<string, string[]>;
-};
+export type KnownStatsAssetInfo = Omit<binding.JsStatsAssetInfo, "related">;
 export type StatsChunkGroup = binding.JsStatsChunkGroup & Record<string, any>;
-export type KnownStatsAsset = Omit<binding.JsStatsAsset, "info"> & {
-    info: KnownStatsAssetInfo;
-};
+export type KnownStatsAsset = Omit<binding.JsStatsAsset, "info">;
 export type StatsAsset = KnownStatsAsset & Record<string, any>;
 export type StatsChunk = KnownStatsChunk & Record<string, any>;
-export type KnownStatsModule = Omit<binding.JsStatsModule, "usedExports" | "providedExports" | "optimizationBailout" | "sizes"> & {
+export type KnownStatsModule = Omit<Writable<binding.JsStatsModule>, "usedExports" | "providedExports" | "optimizationBailout" | "sizes"> & {
     profile?: StatsProfile;
     usedExports?: null | string[] | boolean;
     providedExports?: null | string[];
@@ -34,7 +33,15 @@ export type StatsModule = KnownStatsModule & Record<string, any>;
 export type StatsModuleIssuer = binding.JsStatsModuleIssuer & Record<string, any>;
 export type StatsError = binding.JsStatsError & Record<string, any>;
 export type StatsWarnings = binding.JsStatsWarning & Record<string, any>;
-export type StatsModuleReason = binding.JsStatsModuleReason & Record<string, any>;
+export type StatsModuleTraceItem = {
+    originIdentifier?: string;
+    originName?: string;
+    moduleIdentifier?: string;
+    moduleName?: string;
+    originId?: string;
+    moduleId?: string;
+};
+export type StatsModuleReason = Writable<binding.JsStatsModuleReason> & Record<string, any>;
 export type KnownStatsCompilation = {
     /**
      * webpack version.
@@ -90,7 +97,7 @@ export type KnownStatsChunkOrigin = {
 type ExtractorsByOption<T, O> = {
     [x: string]: (object: O, data: T, context: StatsFactoryContext, options: any, factory: StatsFactory) => void;
 };
-type PreprocessedAsset = StatsAsset & {
+export type PreprocessedAsset = StatsAsset & {
     type: string;
     related: PreprocessedAsset[];
     info: binding.JsStatsAssetInfo;
@@ -99,12 +106,19 @@ export type SimpleExtractors = {
     compilation: ExtractorsByOption<Compilation, StatsCompilation>;
     asset$visible: ExtractorsByOption<PreprocessedAsset, StatsAsset>;
     asset: ExtractorsByOption<PreprocessedAsset, StatsAsset>;
+    chunkGroup: ExtractorsByOption<{
+        name: string;
+        chunkGroup: binding.JsStatsChunkGroup;
+    }, StatsChunkGroup>;
     module: ExtractorsByOption<binding.JsStatsModule, StatsModule>;
     module$visible: ExtractorsByOption<binding.JsStatsModule, StatsModule>;
     moduleIssuer: ExtractorsByOption<binding.JsStatsModuleIssuer, StatsModuleIssuer>;
     profile: ExtractorsByOption<binding.JsStatsModuleProfile, StatsProfile>;
     moduleReason: ExtractorsByOption<binding.JsStatsModuleReason, StatsModuleReason>;
     chunk: ExtractorsByOption<binding.JsStatsChunk, KnownStatsChunk>;
+    error: ExtractorsByOption<binding.JsStatsError, StatsError>;
+    warning: ExtractorsByOption<binding.JsStatsWarning, StatsError>;
+    moduleTraceItem: ExtractorsByOption<binding.JsStatsModuleTrace, StatsModuleTraceItem>;
 };
 export declare const uniqueArray: <T, I>(items: Iterable<T>, selector: (arg: T) => Iterable<I>) => I[];
 export declare const uniqueOrderedArray: <T, I>(items: Iterable<T>, selector: (arg: T) => Iterable<I>, comparator: Comparator) => I[];

package/dist/util/bindingVersionCheck.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkVersion = void 0;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 const NodePlatformArchToAbi = {
     android: {
         arm64: "",
@@ -39,11 +39,11 @@ function isMusl() {
     // For Node 10
     if (!process.report || typeof process.report.getReport !== "function") {
         try {
-            const lddPath = require("child_process")
+            const lddPath = require("node:child_process")
                 .execSync("which ldd")
                 .toString()
                 .trim();
-            return (0, fs_1.readFileSync)(lddPath, "utf8").includes("musl");
+            return (0, node_fs_1.readFileSync)(lddPath, "utf8").includes("musl");
         }
         catch (e) {
             return true;
@@ -96,8 +96,8 @@ const checkVersion = () => {
     }
     let ADDON_VERSION;
     try {
-        const BINDING_PKG_DIR = path_1.default.dirname(require.resolve("@rspack/binding/package.json"));
-        const isLocal = (0, fs_1.readdirSync)(BINDING_PKG_DIR).some(item => item === `rspack.${platformArchAbi}.node`);
+        const BINDING_PKG_DIR = node_path_1.default.dirname(require.resolve("@rspack/binding/package.json"));
+        const isLocal = (0, node_fs_1.readdirSync)(BINDING_PKG_DIR).some(item => item === `rspack.${platformArchAbi}.node`);
         if (isLocal) {
             // Treat addon version the same as binding version if running locally
             ADDON_VERSION = BINDING_VERSION;