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

package/dist/logging/runtime.js

@@ -11,40 +11,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hooks = exports.configureDefaultLogger = exports.getLogger = void 0;
 const SyncBailHook = require("tapable/lib/SyncBailHook");
-const { Logger } = require("./Logger");
-const createConsoleLogger = require("./createConsoleLogger");
-/** @type {createConsoleLogger.LoggerOptions} */
+const Logger_1 = require("./Logger");
+const createConsoleLogger_1 = require("./createConsoleLogger");
 const currentDefaultLoggerOptions = {
     level: "info",
     debug: false,
     console
 };
-let currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
-/**
- * @param {string} name name of the logger
- * @returns {Logger} a logger
- */
-// @ts-expect-error
-const getLogger = name => {
-    return new Logger(
-    // @ts-expect-error
-    (type, args) => {
+let currentDefaultLogger = (0, createConsoleLogger_1.createConsoleLogger)(currentDefaultLoggerOptions);
+const getLogger = (name) => {
+    return new Logger_1.Logger((type, args) => {
         if (exports.hooks.log.call(name, type, args) === undefined) {
             currentDefaultLogger(name, type, args);
         }
-    }, 
-    // @ts-expect-error
-    childName => exports.getLogger(`${name}/${childName}`));
+    }, childName => exports.getLogger(`${name}/${childName}`));
 };
 exports.getLogger = getLogger;
-/**
- * @param {createConsoleLogger.LoggerOptions} options new options, merge with old options
- * @returns {void}
- */
-// @ts-expect-error
-const configureDefaultLogger = options => {
+const configureDefaultLogger = (options) => {
     Object.assign(currentDefaultLoggerOptions, options);
-    currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
+    currentDefaultLogger = (0, createConsoleLogger_1.createConsoleLogger)(currentDefaultLoggerOptions);
 };
 exports.configureDefaultLogger = configureDefaultLogger;
 exports.hooks = {

package/dist/logging/truncateArgs.d.ts

@@ -8,9 +8,9 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 /**
- * @param {any[]} args items to be truncated
- * @param {number} maxLength maximum length of args including spaces between
- * @returns {string[]} truncated args
+ * @param args items to be truncated
+ * @param maxLength maximum length of args including spaces between
+ * @returns truncated args
  */
-declare const truncateArgs: (args: any, maxLength: any) => any;
+declare const truncateArgs: (args: any[], maxLength: number) => string[];
 export { truncateArgs };

package/dist/logging/truncateArgs.js

@@ -17,13 +17,11 @@ const arraySum = (array) => {
     return sum;
 };
 /**
- * @param {any[]} args items to be truncated
- * @param {number} maxLength maximum length of args including spaces between
- * @returns {string[]} truncated args
+ * @param args items to be truncated
+ * @param maxLength maximum length of args including spaces between
+ * @returns truncated args
  */
-// @ts-expect-error
 const truncateArgs = (args, maxLength) => {
-    // @ts-expect-error
     const lengths = args.map(a => `${a}`.length);
     const availableLength = maxLength - lengths.length + 1;
     if (availableLength > 0 && args.length === 1) {
@@ -31,12 +29,11 @@ const truncateArgs = (args, maxLength) => {
             return args;
         }
         if (availableLength > 3) {
-            return ["..." + args[0].slice(-availableLength + 3)];
+            return [`...${args[0].slice(-availableLength + 3)}`];
         }
         return [args[0].slice(-availableLength)];
     }
     // Check if there is space for at least 4 chars per arg
-    // @ts-expect-error
     if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
         // remove args
         if (args.length > 1)
@@ -50,7 +47,6 @@ const truncateArgs = (args, maxLength) => {
     // Try to remove chars from the longest items until it fits
     while (currentLength > availableLength) {
         const maxLength = Math.max(...lengths);
-        // @ts-expect-error
         const shorterItems = lengths.filter(l => l !== maxLength);
         const nextToMaxLength = shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
         const maxReduce = maxLength - nextToMaxLength;
@@ -67,7 +63,6 @@ const truncateArgs = (args, maxLength) => {
         }
     }
     // Return args reduced to length in lengths
-    // @ts-expect-error
     return args.map((a, i) => {
         const str = `${a}`;
         const length = lengths[i];
@@ -75,7 +70,7 @@ const truncateArgs = (args, maxLength) => {
             return str;
         }
         if (length > 5) {
-            return "..." + str.slice(-length + 3);
+            return `...${str.slice(-length + 3)}`;
         }
         if (length > 0) {
             return str.slice(-length);

package/dist/node/NodeEnvironmentPlugin.js

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-expect-error
 const CachedInputFileSystem_1 = __importDefault(require("../../compiled/enhanced-resolve/CachedInputFileSystem"));
 const graceful_fs_1 = __importDefault(require("../../compiled/graceful-fs"));
-const createConsoleLogger_1 = __importDefault(require("../logging/createConsoleLogger"));
+const createConsoleLogger_1 = require("../logging/createConsoleLogger");
 const NodeWatchFileSystem_1 = __importDefault(require("./NodeWatchFileSystem"));
 const nodeConsole_1 = __importDefault(require("./nodeConsole"));
 class NodeEnvironmentPlugin {
@@ -24,7 +24,7 @@ class NodeEnvironmentPlugin {
     }
     apply(compiler) {
         const { infrastructureLogging } = this.options;
-        compiler.infrastructureLogger = (0, createConsoleLogger_1.default)({
+        compiler.infrastructureLogger = (0, createConsoleLogger_1.createConsoleLogger)({
             level: infrastructureLogging.level || "info",
             debug: infrastructureLogging.debug || false,
             console: infrastructureLogging.console ||

package/dist/node/NodeWatchFileSystem.js

@@ -60,7 +60,7 @@ class NodeWatchFileSystem {
         this.watcher.once("aggregated", (changes, removals) => {
             // pause emitting events (avoids clearing aggregated changes and removals on timeout)
             this.watcher.pause();
-            if (this.inputFileSystem && this.inputFileSystem.purge) {
+            if (this.inputFileSystem?.purge) {
                 const fs = this.inputFileSystem;
                 for (const item of changes) {
                     fs.purge(item);
@@ -92,7 +92,7 @@ class NodeWatchFileSystem {
                 }
             },
             getAggregatedRemovals: node_util_1.default.deprecate(() => {
-                const items = this.watcher && this.watcher.aggregatedRemovals;
+                const items = this.watcher?.aggregatedRemovals;
                 if (items && this.inputFileSystem && this.inputFileSystem.purge) {
                     const fs = this.inputFileSystem;
                     for (const item of items) {
@@ -102,7 +102,7 @@ class NodeWatchFileSystem {
                 return items;
             }, "Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.", "DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS"),
             getAggregatedChanges: node_util_1.default.deprecate(() => {
-                const items = this.watcher && this.watcher.aggregatedChanges;
+                const items = this.watcher?.aggregatedChanges;
                 if (items && this.inputFileSystem && this.inputFileSystem.purge) {
                     const fs = this.inputFileSystem;
                     for (const item of items) {
@@ -118,9 +118,9 @@ class NodeWatchFileSystem {
                 return fetchTimeInfo().contextTimeInfoEntries;
             }, "Watcher.getContextTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.", "DEP_WEBPACK_WATCHER_CONTEXT_TIME_INFO_ENTRIES"),
             getInfo: () => {
-                const removals = this.watcher && this.watcher.aggregatedRemovals;
-                const changes = this.watcher && this.watcher.aggregatedChanges;
-                if (this.inputFileSystem && this.inputFileSystem.purge) {
+                const removals = this.watcher?.aggregatedRemovals;
+                const changes = this.watcher?.aggregatedChanges;
+                if (this.inputFileSystem?.purge) {
                     const fs = this.inputFileSystem;
                     if (removals) {
                         for (const item of removals) {

package/dist/node/nodeConsole.d.ts

@@ -7,24 +7,10 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-declare const _default: ({ colors, appendOnly, stream }: {
-    colors: any;
-    appendOnly: any;
-    stream: any;
-}) => {
-    log: (...args: any[]) => void;
-    debug: (...args: any[]) => void;
-    trace: (...args: any[]) => void;
-    info: (...args: any[]) => void;
-    warn: (...args: any[]) => void;
-    error: (...args: any[]) => void;
-    logTime: (...args: any[]) => void;
-    group: (...args: any[]) => void;
-    groupCollapsed: (...args: any[]) => void;
-    groupEnd: () => void;
-    profile: (name: any) => void;
-    profileEnd: (name: any) => void;
-    clear: false | (() => void);
-    status: (...args: any[]) => void;
-};
-export = _default;
+/// <reference types="node" />
+import type { LoggerConsole } from "../logging/createConsoleLogger";
+export default function ({ colors, appendOnly, stream }: {
+    colors?: boolean;
+    appendOnly?: boolean;
+    stream: NodeJS.WritableStream;
+}): LoggerConsole;

package/dist/node/nodeConsole.js

@@ -31,15 +31,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+Object.defineProperty(exports, "__esModule", { value: true });
 const util = __importStar(require("node:util"));
 const truncateArgs_1 = require("../logging/truncateArgs");
-module.exports = ({ colors, appendOnly, stream }) => {
-    // @ts-expect-error
+function default_1({ colors, appendOnly, stream }) {
     let currentStatusMessage = undefined;
     let hasStatusMessage = false;
     let currentIndent = "";
     let currentCollapsed = 0;
-    // @ts-expect-error
     const indent = (str, prefix, colorPrefix, colorSuffix) => {
         if (str === "")
             return str;
@@ -47,10 +46,10 @@ module.exports = ({ colors, appendOnly, stream }) => {
         if (colors) {
             return (prefix +
                 colorPrefix +
-                str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
+                str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) +
                 colorSuffix);
         }
-        return prefix + str.replace(/\n/g, "\n" + prefix);
+        return prefix + str.replace(/\n/g, `\n${prefix}`);
     };
     const clearStatusMessage = () => {
         if (hasStatusMessage) {
@@ -59,9 +58,9 @@ module.exports = ({ colors, appendOnly, stream }) => {
         }
     };
     const writeStatusMessage = () => {
-        // @ts-expect-error
         if (!currentStatusMessage)
             return;
+        //@ts-expect-error Property 'columns' does not exist on type 'WritableStream'.ts(2339)
         const l = stream.columns;
         const args = l
             ? (0, truncateArgs_1.truncateArgs)(currentStatusMessage, l - 1)
@@ -71,15 +70,13 @@ module.exports = ({ colors, appendOnly, stream }) => {
         stream.write(`\x1b[2K\r${coloredStr}`);
         hasStatusMessage = true;
     };
-    // @ts-expect-error
     const writeColored = (prefix, colorPrefix, colorSuffix) => {
-        // @ts-expect-error
         return (...args) => {
             if (currentCollapsed > 0)
                 return;
             clearStatusMessage();
             const str = indent(util.format(...args), prefix, colorPrefix, colorSuffix);
-            stream.write(str + "\n");
+            stream.write(`${str}\n`);
             writeStatusMessage();
         };
     };
@@ -93,7 +90,6 @@ module.exports = ({ colors, appendOnly, stream }) => {
         warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
         error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
         logTime: writeColored("<t> ", "\u001b[1m\u001b[35m", "\u001b[39m\u001b[22m"),
-        // @ts-expect-error
         group: (...args) => {
             writeGroupMessage(...args);
             if (currentCollapsed > 0) {
@@ -103,7 +99,6 @@ module.exports = ({ colors, appendOnly, stream }) => {
                 currentIndent += "  ";
             }
         },
-        // @ts-expect-error
         groupCollapsed: (...args) => {
             writeGroupCollapsedMessage(...args);
             currentCollapsed++;
@@ -114,39 +109,37 @@ module.exports = ({ colors, appendOnly, stream }) => {
             else if (currentIndent.length >= 2)
                 currentIndent = currentIndent.slice(0, currentIndent.length - 2);
         },
-        // @ts-expect-error
         profile: console.profile && (name => console.profile(name)),
-        // @ts-expect-error
         profileEnd: console.profileEnd && (name => console.profileEnd(name)),
-        clear: !appendOnly &&
+        clear: (!appendOnly &&
             console.clear &&
             (() => {
                 clearStatusMessage();
                 console.clear();
                 writeStatusMessage();
-            }),
+            })),
         status: appendOnly
             ? writeColored("<s> ", "", "")
-            : // @ts-expect-error
-                (name, ...args) => {
-                    args = args.filter(Boolean);
-                    if (name === undefined && args.length === 0) {
-                        clearStatusMessage();
-                        currentStatusMessage = undefined;
-                    }
-                    else if (typeof name === "string" &&
-                        name.startsWith("[webpack.Progress] ")) {
-                        currentStatusMessage = [name.slice(19), ...args];
-                        writeStatusMessage();
-                    }
-                    else if (name === "[webpack.Progress]") {
-                        currentStatusMessage = [...args];
-                        writeStatusMessage();
-                    }
-                    else {
-                        currentStatusMessage = [name, ...args];
-                        writeStatusMessage();
-                    }
+            : (name, ...args) => {
+                args = args.filter(Boolean);
+                if (name === undefined && args.length === 0) {
+                    clearStatusMessage();
+                    currentStatusMessage = undefined;
                 }
+                else if (typeof name === "string" &&
+                    name.startsWith("[webpack.Progress] ")) {
+                    currentStatusMessage = [name.slice(19), ...args];
+                    writeStatusMessage();
+                }
+                else if (name === "[webpack.Progress]") {
+                    currentStatusMessage = [...args];
+                    writeStatusMessage();
+                }
+                else {
+                    currentStatusMessage = [name, ...args];
+                    writeStatusMessage();
+                }
+            }
     };
-};
+}
+exports.default = default_1;

package/dist/rspackOptionsApply.d.ts

@@ -1,5 +1,4 @@
 import type { Compiler, RspackOptionsNormalized } from ".";
 export declare class RspackOptionsApply {
-    constructor();
     process(options: RspackOptionsNormalized, compiler: Compiler): void;
 }

package/dist/rspackOptionsApply.js

@@ -19,12 +19,12 @@ const Module_1 = require("./Module");
 const builtin_plugin_1 = require("./builtin-plugin");
 const EntryOptionPlugin_1 = __importDefault(require("./lib/EntryOptionPlugin"));
 const IgnoreWarningsPlugin_1 = __importDefault(require("./lib/IgnoreWarningsPlugin"));
+const MemoryCachePlugin_1 = __importDefault(require("./lib/cache/MemoryCachePlugin"));
 const DefaultStatsFactoryPlugin_1 = require("./stats/DefaultStatsFactoryPlugin");
 const DefaultStatsPresetPlugin_1 = require("./stats/DefaultStatsPresetPlugin");
 const DefaultStatsPrinterPlugin_1 = require("./stats/DefaultStatsPrinterPlugin");
 const assertNotNil_1 = require("./util/assertNotNil");
 class RspackOptionsApply {
-    constructor() { }
     process(options, compiler) {
         (0, node_assert_1.default)(options.output.path, "options.output.path should have value after `applyRspackOptionsDefaults`");
         compiler.outputPath = options.output.path;
@@ -76,7 +76,7 @@ class RspackOptionsApply {
                     break;
                 }
                 default:
-                    throw new Error("Unsupported chunk format '" + options.output.chunkFormat + "'.");
+                    throw new Error(`Unsupported chunk format '${options.output.chunkFormat}'.`);
             }
         }
         if (options.output.enabledChunkLoadingTypes &&
@@ -112,8 +112,8 @@ class RspackOptionsApply {
                     moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
                     fallbackModuleFilenameTemplate: options.output.devtoolFallbackModuleFilenameTemplate,
                     append: hidden ? false : undefined,
-                    module: moduleMaps ? true : cheap ? false : true,
-                    columns: cheap ? false : true,
+                    module: moduleMaps ? true : !cheap,
+                    columns: !cheap,
                     noSources: noSources,
                     namespace: options.output.devtoolNamespace
                 }).apply(compiler);
@@ -176,9 +176,7 @@ class RspackOptionsApply {
                         source: lazyOptions.test.source,
                         flags: lazyOptions.test.flags
                     }
-                    : undefined, 
-            // @ts-expect-error backend is hide
-            lazyOptions.backend).apply(compiler);
+                    : undefined, lazyOptions.backend).apply(compiler);
         }
         if (options.output.enabledLibraryTypes &&
             options.output.enabledLibraryTypes.length > 0) {
@@ -253,6 +251,9 @@ class RspackOptionsApply {
             new builtin_plugin_1.SizeLimitsPlugin(options.performance).apply(compiler);
         }
         new builtin_plugin_1.WarnCaseSensitiveModulesPlugin().apply(compiler);
+        if (options.cache) {
+            new MemoryCachePlugin_1.default().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);
         new DefaultStatsPresetPlugin_1.DefaultStatsPresetPlugin().apply(compiler);

package/dist/sharing/ProvideSharedPlugin.d.ts

@@ -1,33 +1,34 @@
-import { type BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
+import { type BuiltinPlugin, BuiltinPluginName, type RawProvideOptions } from "@rspack/binding";
 import type { Compiler } from "../Compiler";
 import { RspackBuiltinPlugin } from "../builtin-plugin/base";
-export type ProvideSharedPluginOptions = {
-    provides: Provides;
+export type ProvideSharedPluginOptions<Enhanced extends boolean = false> = {
+    provides: Provides<Enhanced>;
     shareScope?: string;
-    enhanced?: boolean;
+    enhanced?: Enhanced;
 };
-export type Provides = (ProvidesItem | ProvidesObject)[] | ProvidesObject;
+export type Provides<Enhanced extends boolean> = (ProvidesItem | ProvidesObject<Enhanced>)[] | ProvidesObject<Enhanced>;
 export type ProvidesItem = string;
-export type ProvidesObject = {
-    [k: string]: ProvidesConfig | ProvidesItem;
+export type ProvidesObject<Enhanced extends boolean> = {
+    [k: string]: ProvidesConfig<Enhanced> | ProvidesItem;
 };
-export type ProvidesConfig = {
+export type ProvidesConfig<Enhanced extends boolean> = Enhanced extends true ? ProvidesEnhancedConfig : ProvidesV1Config;
+type ProvidesV1Config = {
     eager?: boolean;
     shareKey: string;
     shareScope?: string;
     version?: false | string;
 };
-export declare class ProvideSharedPlugin extends RspackBuiltinPlugin {
+type ProvidesEnhancedConfig = ProvidesV1Config & ProvidesEnhancedExtraConfig;
+type ProvidesEnhancedExtraConfig = {
+    singleton?: boolean;
+    strictVersion?: boolean;
+    requiredVersion?: false | string;
+};
+export declare class ProvideSharedPlugin<Enhanced extends boolean = false> extends RspackBuiltinPlugin {
     name: BuiltinPluginName;
-    _options: {
-        provides: [string, {
-            shareKey: string;
-            version: string | false | undefined;
-            shareScope: string;
-            eager: boolean;
-        }][];
-        enhanced: boolean;
-    };
-    constructor(options: ProvideSharedPluginOptions);
+    _provides: [string, Omit<RawProvideOptions, "key">][];
+    _enhanced?: Enhanced;
+    constructor(options: ProvideSharedPluginOptions<Enhanced>);
     raw(compiler: Compiler): BuiltinPlugin;
 }
+export {};

package/dist/sharing/ProvideSharedPlugin.js

@@ -9,29 +9,38 @@ class ProvideSharedPlugin extends base_1.RspackBuiltinPlugin {
     constructor(options) {
         super();
         this.name = binding_1.BuiltinPluginName.ProvideSharedPlugin;
-        this._options = {
-            provides: (0, options_1.parseOptions)(options.provides, item => {
-                if (Array.isArray(item))
-                    throw new Error("Unexpected array of provides");
-                const result = {
-                    shareKey: item,
-                    version: undefined,
-                    shareScope: options.shareScope || "default",
-                    eager: false
-                };
-                return result;
-            }, item => ({
+        this._provides = (0, options_1.parseOptions)(options.provides, item => {
+            if (Array.isArray(item))
+                throw new Error("Unexpected array of provides");
+            return {
+                shareKey: item,
+                version: undefined,
+                shareScope: options.shareScope || "default",
+                eager: false
+            };
+        }, item => {
+            const raw = {
                 shareKey: item.shareKey,
                 version: item.version,
                 shareScope: item.shareScope || options.shareScope || "default",
                 eager: !!item.eager
-            })),
-            enhanced: options.enhanced ?? false
-        };
+            };
+            if (options.enhanced) {
+                const enhancedItem = item;
+                return {
+                    ...raw,
+                    singleton: enhancedItem.singleton,
+                    requiredVersion: enhancedItem.requiredVersion,
+                    strictVersion: enhancedItem.strictVersion
+                };
+            }
+            return raw;
+        });
+        this._enhanced = options.enhanced;
     }
     raw(compiler) {
-        new ShareRuntimePlugin_1.ShareRuntimePlugin(this._options.enhanced).apply(compiler);
-        const rawOptions = this._options.provides.map(([key, v]) => ({
+        new ShareRuntimePlugin_1.ShareRuntimePlugin(this._enhanced ?? false).apply(compiler);
+        const rawOptions = this._provides.map(([key, v]) => ({
             key,
             ...v
         }));

package/dist/sharing/SharePlugin.d.ts

@@ -40,6 +40,9 @@ export declare class SharePlugin {
             shareScope: string | undefined;
             version: string | false | undefined;
             eager: boolean | undefined;
+            singleton: boolean | undefined;
+            requiredVersion: string | false | undefined;
+            strictVersion: boolean | undefined;
         };
     }[];
     _enhanced: boolean;

package/dist/sharing/SharePlugin.js

@@ -39,7 +39,10 @@ class SharePlugin {
                 shareKey: options.shareKey || key,
                 shareScope: options.shareScope,
                 version: options.version,
-                eager: options.eager
+                eager: options.eager,
+                singleton: options.singleton,
+                requiredVersion: options.requiredVersion,
+                strictVersion: options.strictVersion
             }
         }));
         this._shareScope = options.shareScope;