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

package/dist/config/zod.js

@@ -345,6 +345,7 @@ const reexportExportsPresence = zod_1.z
     .or(zod_1.z.literal(false));
 const strictExportPresence = zod_1.z.boolean();
 const worker = zod_1.z.array(zod_1.z.string()).or(zod_1.z.boolean());
+const overrideStrict = zod_1.z.enum(["strict", "non-strict"]);
 const javascriptParserOptions = zod_1.z.strictObject({
     dynamicImportMode: dynamicImportMode.optional(),
     dynamicImportPreload: dynamicImportPreload.optional(),
@@ -357,7 +358,8 @@ const javascriptParserOptions = zod_1.z.strictObject({
     importExportsPresence: importExportsPresence.optional(),
     reexportExportsPresence: reexportExportsPresence.optional(),
     strictExportPresence: strictExportPresence.optional(),
-    worker: worker.optional()
+    worker: worker.optional(),
+    overrideStrict: overrideStrict.optional()
 });
 const parserOptionsByModuleTypeKnown = zod_1.z.strictObject({
     asset: assetParserOptions.optional(),
@@ -442,44 +444,45 @@ const moduleOptions = zod_1.z.strictObject({
 });
 //#endregion
 //#region Target
-const allowTarget = zod_1.z
-    .enum([
-    "web",
-    "webworker",
-    "es3",
-    "es5",
-    "es2015",
-    "es2016",
-    "es2017",
-    "es2018",
-    "es2019",
-    "es2020",
-    "es2021",
-    "es2022",
-    "browserslist"
-])
-    .or(zod_1.z.literal("node"))
-    .or(zod_1.z.literal("async-node"))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^node\d+$/.test(value)))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^async-node\d+$/.test(value)))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^node\d+\.\d+$/.test(value)))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^async-node\d+\.\d+$/.test(value)))
-    .or(zod_1.z.literal("electron-main"))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^electron\d+-main$/.test(value)))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^electron\d+\.\d+-main$/.test(value)))
-    .or(zod_1.z.literal("electron-renderer"))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^electron\d+-renderer$/.test(value)))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^electron\d+\.\d+-renderer$/.test(value)))
-    .or(zod_1.z.literal("electron-preload"))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^electron\d+-preload$/.test(value)))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^electron\d+\.\d+-preload$/.test(value)))
-    .or(zod_1.z.literal("nwjs"))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^nwjs\d+$/.test(value)))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^nwjs\d+\.\d+$/.test(value)))
-    .or(zod_1.z.literal("node-webkit"))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^node-webkit\d+$/.test(value)))
-    .or(zod_1.z.custom(value => typeof value === "string" && /^node-webkit\d+\.\d+$/.test(value)));
-const target = zod_1.z.literal(false).or(allowTarget).or(allowTarget.array());
+const allowTarget = zod_1.z.union([
+    zod_1.z.enum([
+        "web",
+        "webworker",
+        "es3",
+        "es5",
+        "es2015",
+        "es2016",
+        "es2017",
+        "es2018",
+        "es2019",
+        "es2020",
+        "es2021",
+        "es2022",
+        "browserslist"
+    ]),
+    zod_1.z.literal("node"),
+    zod_1.z.literal("async-node"),
+    zod_1.z.custom(value => typeof value === "string" && /^node\d+$/.test(value)),
+    zod_1.z.custom(value => typeof value === "string" && /^async-node\d+$/.test(value)),
+    zod_1.z.custom(value => typeof value === "string" && /^node\d+\.\d+$/.test(value)),
+    zod_1.z.custom(value => typeof value === "string" && /^async-node\d+\.\d+$/.test(value)),
+    zod_1.z.literal("electron-main"),
+    zod_1.z.custom(value => typeof value === "string" && /^electron\d+-main$/.test(value)),
+    zod_1.z.custom(value => typeof value === "string" && /^electron\d+\.\d+-main$/.test(value)),
+    zod_1.z.literal("electron-renderer"),
+    zod_1.z.custom(value => typeof value === "string" && /^electron\d+-renderer$/.test(value)),
+    zod_1.z.custom(value => typeof value === "string" && /^electron\d+\.\d+-renderer$/.test(value)),
+    zod_1.z.literal("electron-preload"),
+    zod_1.z.custom(value => typeof value === "string" && /^electron\d+-preload$/.test(value)),
+    zod_1.z.custom(value => typeof value === "string" && /^electron\d+\.\d+-preload$/.test(value)),
+    zod_1.z.literal("nwjs"),
+    zod_1.z.custom(value => typeof value === "string" && /^nwjs\d+$/.test(value)),
+    zod_1.z.custom(value => typeof value === "string" && /^nwjs\d+\.\d+$/.test(value)),
+    zod_1.z.literal("node-webkit"),
+    zod_1.z.custom(value => typeof value === "string" && /^node-webkit\d+$/.test(value)),
+    zod_1.z.custom(value => typeof value === "string" && /^node-webkit\d+\.\d+$/.test(value))
+]);
+const target = zod_1.z.union([zod_1.z.literal(false), allowTarget, allowTarget.array()]);
 //#endregion
 //#region ExternalsType
 exports.externalsType = zod_1.z.enum([

package/dist/container/ModuleFederationPlugin.js

@@ -71,8 +71,8 @@ function getRemoteInfos(options) {
         shareScope: item.shareScope || options.shareScope || "default"
     }));
     const remoteInfos = {};
-    for (let [key, config] of remotes) {
-        for (let external of config.external) {
+    for (const [key, config] of remotes) {
+        for (const external of config.external) {
             const [externalType, externalRequest] = getExternal(external);
             remoteInfos[key] ??= [];
             if (externalType === "script") {

package/dist/loader-runner/index.js

@@ -59,10 +59,10 @@ function createLoaderObject(loader, compiler) {
             obj.query.replace(/#/g, "\u200b#") +
             obj.fragment,
         set: value => {
-            var splittedRequest = (0, identifier_1.parseResourceWithoutFragment)(value.request);
+            const splittedRequest = (0, identifier_1.parseResourceWithoutFragment)(value.request);
             obj.path = splittedRequest.path;
             obj.query = splittedRequest.query;
-            obj.fragment = splittedRequest.fragment || "";
+            obj.fragment = "";
             obj.options =
                 obj.options === null
                     ? splittedRequest.query
@@ -231,7 +231,7 @@ const runSyncOrAsync = (0, util_1.promisify)(function runSyncOrAsync(fn, context
     }
     catch (e) {
         // use string for napi getter
-        let err = e;
+        const err = e;
         if ("hideStack" in err && err.hideStack) {
             err.hideStack = "true";
         }
@@ -514,7 +514,7 @@ async function runLoaders(compiler, context) {
         if (!(error instanceof Error)) {
             error = new RspackError_1.NonErrorEmittedError(error);
         }
-        let hasStack = !!error.stack;
+        const hasStack = !!error.stack;
         error.name = "ModuleError";
         error.message = `${error.message} (from: ${(0, util_2.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`;
         !hasStack && Error.captureStackTrace(error);
@@ -529,7 +529,7 @@ async function runLoaders(compiler, context) {
         if (!(warning instanceof Error)) {
             warning = new RspackError_1.NonErrorEmittedError(warning);
         }
-        let hasStack = !!warning.stack;
+        const hasStack = !!warning.stack;
         warning.name = "ModuleWarning";
         warning.message = `${warning.message} (from: ${(0, util_2.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`;
         hasStack && Error.captureStackTrace(warning);
@@ -686,7 +686,7 @@ async function runLoaders(compiler, context) {
                 currentLoaderObject.normalExecuted = true;
                 if (!fn)
                     continue;
-                let args = [content, sourceMap, additionalData];
+                const args = [content, sourceMap, additionalData];
                 convertArgs(args, !!currentLoaderObject.raw);
                 [content, sourceMap, additionalData] =
                     (await runSyncOrAsync(fn, loaderContext, args)) || [];

package/dist/logging/runtime.js

@@ -14,7 +14,7 @@ const SyncBailHook = require("tapable/lib/SyncBailHook");
 const { Logger } = require("./Logger");
 const createConsoleLogger = require("./createConsoleLogger");
 /** @type {createConsoleLogger.LoggerOptions} */
-let currentDefaultLoggerOptions = {
+const currentDefaultLoggerOptions = {
     level: "info",
     debug: false,
     console

package/dist/rspack.js

@@ -68,7 +68,7 @@ function isMultiRspackOptions(o) {
 }
 function rspack(options, callback) {
     try {
-        for (let o of (0, util_2.asArray)(options)) {
+        for (const o of (0, util_2.asArray)(options)) {
             (0, validate_1.validate)(o, config_1.rspackOptions);
         }
     }

package/dist/sharing/ConsumeSharedPlugin.js

@@ -14,7 +14,7 @@ class ConsumeSharedPlugin extends base_1.RspackBuiltinPlugin {
             consumes: (0, options_1.parseOptions)(options.consumes, (item, key) => {
                 if (Array.isArray(item))
                     throw new Error("Unexpected array in options");
-                let result = item === key || !(0, utils_1.isRequiredVersion)(item)
+                const result = item === key || !(0, utils_1.isRequiredVersion)(item)
                     ? // item is a request/key
                         {
                             import: key,

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) => {
@@ -487,7 +635,7 @@ const SIMPLE_EXTRACTORS = {
                 // compilationFileToChunks
                 // compilationAuxiliaryFileToChunks
             });
-            const limited = (0, statsFactoryUtils_1.spaceLimited)(groupedAssets, options.assetsSpace || Infinity);
+            const limited = (0, statsFactoryUtils_1.spaceLimited)(groupedAssets, options.assetsSpace || Number.POSITIVE_INFINITY);
             // object.filteredAssets = limited.filteredChildren;
             // const limited = spaceLimited(groupedAssets, options.assetsSpace);
             object.assets = limited.children;
@@ -509,35 +657,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 +730,39 @@ 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;
+            // - chunkIdHints
+            // - auxiliaryChunkNames
+            // - auxiliaryChunkIdHints
+            // - filteredRelated
         },
+        // relatedAssets
         ids: (object, asset) => {
             object.chunks = asset.chunks;
+            // - 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 +818,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 +929,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 +997,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);
+                }
             });
         });
     }