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

package/dist/config/zod.js

@@ -93,6 +93,7 @@ const libraryOptions = zod_1.z.strictObject({
     umdNamedDefine: umdNamedDefine.optional()
 });
 const library = libraryName.or(libraryOptions).optional();
+const layer = zod_1.z.string().or(zod_1.z.null());
 const entryFilename = filename;
 const entryRuntime = zod_1.z.literal(false).or(zod_1.z.string());
 const entryItem = zod_1.z.string().or(zod_1.z.array(zod_1.z.string()));
@@ -107,7 +108,8 @@ const entryDescription = zod_1.z.strictObject({
     wasmLoading: wasmLoading.optional(),
     filename: entryFilename.optional(),
     library: libraryOptions.optional(),
-    dependOn: entryDependOn.optional()
+    dependOn: entryDependOn.optional(),
+    layer: layer.optional()
 });
 const entryUnnamed = entryItem;
 const entryObject = zod_1.z.record(entryItem.or(entryDescription));
@@ -138,6 +140,7 @@ const strictModuleErrorHandling = zod_1.z.boolean();
 const globalObject = zod_1.z.string();
 const enabledWasmLoadingTypes = zod_1.z.array(wasmLoadingType);
 const importFunctionName = zod_1.z.string();
+const importMetaName = zod_1.z.string();
 const iife = zod_1.z.boolean();
 const enabledChunkLoadingTypes = zod_1.z.array(chunkLoadingType);
 const chunkFormat = zod_1.z.literal(false).or(zod_1.z.string());
@@ -199,6 +202,7 @@ const output = zod_1.z.strictObject({
     strictModuleErrorHandling: strictModuleErrorHandling.optional(),
     globalObject: globalObject.optional(),
     importFunctionName: importFunctionName.optional(),
+    importMetaName: importMetaName.optional(),
     iife: iife.optional(),
     wasmLoading: wasmLoading.optional(),
     enabledWasmLoadingTypes: enabledWasmLoadingTypes.optional(),
@@ -291,6 +295,7 @@ const baseRuleSetRule = zod_1.z.strictObject({
     exclude: ruleSetCondition.optional(),
     include: ruleSetCondition.optional(),
     issuer: ruleSetCondition.optional(),
+    issuerLayer: ruleSetCondition.optional(),
     dependency: ruleSetCondition.optional(),
     resource: ruleSetCondition.optional(),
     resourceFragment: ruleSetCondition.optional(),
@@ -298,7 +303,9 @@ const baseRuleSetRule = zod_1.z.strictObject({
     scheme: ruleSetCondition.optional(),
     mimetype: ruleSetCondition.optional(),
     descriptionData: zod_1.z.record(ruleSetCondition).optional(),
+    with: zod_1.z.record(ruleSetCondition).optional(),
     type: zod_1.z.string().optional(),
+    layer: zod_1.z.string().optional(),
     loader: ruleSetLoader.optional(),
     options: ruleSetLoaderOptions.optional(),
     use: ruleSetUse.optional(),
@@ -352,6 +359,7 @@ const javascriptParserOptions = zod_1.z.strictObject({
     dynamicImportPreload: dynamicImportPreload.optional(),
     dynamicImportPrefetch: dynamicImportPrefetch.optional(),
     dynamicImportFetchPriority: dynamicImportFetchPriority.optional(),
+    importMeta: zod_1.z.boolean().optional(),
     url: javascriptParserUrl.optional(),
     exprContextCritical: exprContextCritical.optional(),
     wrappedContextCritical: wrappedContextCritical.optional(),
@@ -857,6 +865,7 @@ const experiments = zod_1.z.strictObject({
     outputModule: zod_1.z.boolean().optional(),
     topLevelAwait: zod_1.z.boolean().optional(),
     css: zod_1.z.boolean().optional(),
+    layers: zod_1.z.boolean().optional(),
     futureDefaults: zod_1.z.boolean().optional(),
     rspackFuture: rspackFutureOptions.optional()
 });

package/dist/container/ContainerReferencePlugin.d.ts

@@ -21,7 +21,7 @@ export type RemotesConfig = {
 export declare class ContainerReferencePlugin extends RspackBuiltinPlugin {
     name: BuiltinPluginName;
     _options: {
-        remoteType: "promise" | "module" | "commonjs" | "umd" | "amd" | "jsonp" | "import" | "commonjs2" | "var" | "assign" | "this" | "window" | "self" | "global" | "commonjs-module" | "commonjs-static" | "amd-require" | "umd2" | "system" | "script" | "node-commonjs";
+        remoteType: "module" | "global" | "system" | "promise" | "commonjs" | "umd" | "amd" | "jsonp" | "import" | "commonjs2" | "var" | "assign" | "this" | "window" | "self" | "commonjs-module" | "commonjs-static" | "amd-require" | "umd2" | "script" | "node-commonjs";
         remotes: [string, {
             external: string[];
             shareScope: string;

package/dist/container/ModuleFederationRuntimePlugin.d.ts

@@ -3,7 +3,7 @@ export declare const ModuleFederationRuntimePlugin: {
     new (): {
         name: BuiltinPluginName;
         _args: [];
-        affectedHooks: "done" | "compilation" | "failed" | "environment" | "emit" | "make" | "compile" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "shutdown" | "watchRun" | "watchClose" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
+        affectedHooks: "done" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
         raw(compiler: import("../Compiler").Compiler): import("@rspack/binding").BuiltinPlugin;
         apply(compiler: import("../Compiler").Compiler): void;
     };

package/dist/exports.d.ts

@@ -33,7 +33,7 @@ type Config = {
 export declare const config: Config;
 export type * from "./config";
 export declare const util: {
-    createHash: (algorithm: "debug" | "md4" | "xxhash64" | (string & {}) | "native-md4" | (new () => import("./util/hash").default)) => import("./util/hash").default;
+    createHash: (algorithm: (string & {}) | "debug" | "xxhash64" | "md4" | "native-md4" | (new () => import("./util/hash").default)) => import("./util/hash").default;
     cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
 };
 export { default as EntryOptionPlugin } from "./lib/EntryOptionPlugin";

package/dist/lib/AbstractMethodError.d.ts

@@ -1,4 +1,13 @@
-export = AbstractMethodError;
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/AbstractMethodError.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import WebpackError from "./WebpackError";
 /**
  * Error for abstract method
  * @example
@@ -9,7 +18,7 @@ export = AbstractMethodError;
  * }
  *
  */
-declare class AbstractMethodError extends WebpackError {
+export declare class AbstractMethodError extends WebpackError {
     constructor();
 }
-import WebpackError = require("./WebpackError");
+export default AbstractMethodError;

package/dist/lib/AbstractMethodError.js

@@ -1,29 +1,36 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Ivan Kopeykin @vankop
-*/
 "use strict";
-const WebpackError = require("./WebpackError");
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/AbstractMethodError.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractMethodError = void 0;
+const WebpackError_1 = __importDefault(require("./WebpackError"));
 const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
 /**
- * @param {string=} method method name
- * @returns {string} message
+ * @param method method name
+ * @returns message
  */
 function createMessage(method) {
     return `Abstract method${method ? " " + method : ""}. Must be overridden.`;
 }
-/**
- * @constructor
- */
-function Message() {
-    /** @type {string} */
-    // @ts-expect-error
-    this.stack = undefined;
-    Error.captureStackTrace(this);
-    /** @type {RegExpMatchArray} */
-    // @ts-expect-error
-    const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
-    this.message = match && match[1] ? createMessage(match[1]) : createMessage();
+class Message extends Error {
+    constructor() {
+        super();
+        this.stack = undefined;
+        Error.captureStackTrace(this);
+        const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
+        this.message =
+            match && match[1] ? createMessage(match[1]) : createMessage();
+    }
 }
 /**
  * Error for abstract method
@@ -35,10 +42,11 @@ function Message() {
  * }
  *
  */
-class AbstractMethodError extends WebpackError {
+class AbstractMethodError extends WebpackError_1.default {
     constructor() {
         super(new Message().message);
         this.name = "AbstractMethodError";
     }
 }
-module.exports = AbstractMethodError;
+exports.AbstractMethodError = AbstractMethodError;
+exports.default = AbstractMethodError;

package/dist/lib/Cache.d.ts

@@ -1,71 +1,65 @@
-export = Cache;
-declare class Cache {
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Cache.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } from "@rspack/lite-tapable";
+import type { WebpackError } from "./WebpackError";
+export interface Etag {
+    toString(): string;
+}
+export type CallbackCache<T> = (err?: WebpackError | null, result?: T) => void;
+type GotHandler<T = any> = (result: any | null, callback: (error: Error) => void) => void;
+export declare class Cache {
+    static STAGE_DISK: number;
+    static STAGE_MEMORY: number;
+    static STAGE_DEFAULT: number;
+    static STAGE_NETWORK: number;
     hooks: {
-        /** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
         get: AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>;
-        /** @type {AsyncParallelHook<[string, Etag | null, any]>} */
         store: AsyncParallelHook<[string, Etag | null, any]>;
-        /** @type {AsyncParallelHook<[Iterable<string>]>} */
         storeBuildDependencies: AsyncParallelHook<[Iterable<string>]>;
-        /** @type {SyncHook<[]>} */
         beginIdle: SyncHook<[]>;
-        /** @type {AsyncParallelHook<[]>} */
         endIdle: AsyncParallelHook<[]>;
-        /** @type {AsyncParallelHook<[]>} */
         shutdown: AsyncParallelHook<[]>;
     };
+    constructor();
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     get<T>(identifier: string, etag: Etag | null, callback: CallbackCache<T>): void;
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
-    store<T_1>(identifier: string, etag: Etag | null, data: T_1, callback: CallbackCache<void>): void;
+    store<T>(identifier: string, etag: Etag | null, data: T, callback: CallbackCache<void>): void;
     /**
      * After this method has succeeded the cache can only be restored when build dependencies are
-     * @param {Iterable<string>} dependencies list of all build dependencies
-     * @param {CallbackCache<void>} callback signals when the dependencies are stored
-     * @returns {void}
+     * @param dependencies list of all build dependencies
+     * @param callback signals when the dependencies are stored
+     * @returns
      */
     storeBuildDependencies(dependencies: Iterable<string>, callback: CallbackCache<void>): void;
-    /**
-     * @returns {void}
-     */
     beginIdle(): void;
     /**
-     * @param {CallbackCache<void>} callback signals when the call finishes
-     * @returns {void}
+     * @param callback signals when the call finishes
+     * @returns
      */
     endIdle(callback: CallbackCache<void>): void;
     /**
-     * @param {CallbackCache<void>} callback signals when the call finishes
-     * @returns {void}
+     * @param callback signals when the call finishes
+     * @returns
      */
     shutdown(callback: CallbackCache<void>): void;
 }
-declare namespace Cache {
-    export { STAGE_MEMORY, STAGE_DEFAULT, STAGE_DISK, STAGE_NETWORK, WebpackError, Etag, CallbackCache, GotHandler };
-}
-import { AsyncSeriesBailHook } from "@rspack/lite-tapable";
-type Etag = {
-    toString: () => string;
-};
-type GotHandler = (result: any, callback: (arg0: Error | undefined) => void) => void;
-import { AsyncParallelHook } from "@rspack/lite-tapable";
-import { SyncHook } from "@rspack/lite-tapable";
-type CallbackCache<T> = (err?: (WebpackError | null) | undefined, result?: T | undefined) => void;
-declare var STAGE_MEMORY: number;
-declare var STAGE_DEFAULT: number;
-declare var STAGE_DISK: number;
-declare var STAGE_NETWORK: number;
-type WebpackError = import("./WebpackError");
+export default Cache;

package/dist/lib/Cache.js

@@ -1,72 +1,50 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
-const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = require("@rspack/lite-tapable");
-const { makeWebpackError, makeWebpackErrorCallback } = require("./HookWebpackError.js");
-/** @typedef {import("./WebpackError")} WebpackError */
 /**
- * @typedef {Object} Etag
- * @property {function(): string} toString
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Cache.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-/**
- * @template T
- * @callback CallbackCache
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- * @returns {void}
- */
-/**
- * @callback GotHandler
- * @param {any} result
- * @param {function(Error=): void} callback
- * @returns {void}
- */
-// @ts-expect-error
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const lite_tapable_1 = require("@rspack/lite-tapable");
+const HookWebpackError_1 = require("./HookWebpackError");
 const needCalls = (times, callback) => {
-    // @ts-expect-error
     return err => {
         if (--times === 0) {
-            return callback(err);
+            return callback();
         }
         if (err && times > 0) {
             times = 0;
-            return callback(err);
+            return callback();
         }
     };
 };
 class Cache {
     constructor() {
         this.hooks = {
-            /** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
-            get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
-            /** @type {AsyncParallelHook<[string, Etag | null, any]>} */
-            store: new AsyncParallelHook(["identifier", "etag", "data"]),
-            /** @type {AsyncParallelHook<[Iterable<string>]>} */
-            storeBuildDependencies: new AsyncParallelHook(["dependencies"]),
-            /** @type {SyncHook<[]>} */
-            beginIdle: new SyncHook([]),
-            /** @type {AsyncParallelHook<[]>} */
-            endIdle: new AsyncParallelHook([]),
-            /** @type {AsyncParallelHook<[]>} */
-            shutdown: new AsyncParallelHook([])
+            get: new lite_tapable_1.AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
+            store: new lite_tapable_1.AsyncParallelHook(["identifier", "etag", "data"]),
+            storeBuildDependencies: new lite_tapable_1.AsyncParallelHook(["dependencies"]),
+            beginIdle: new lite_tapable_1.SyncHook([]),
+            endIdle: new lite_tapable_1.AsyncParallelHook([]),
+            shutdown: new lite_tapable_1.AsyncParallelHook([])
         };
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     get(identifier, etag, callback) {
-        // @ts-expect-error
         const gotHandlers = [];
-        // @ts-expect-error
         this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
             if (err) {
-                callback(makeWebpackError(err, "Cache.hooks.get"));
+                callback((0, HookWebpackError_1.makeWebpackError)(err, "Cache.hooks.get"));
                 return;
             }
             if (result === null) {
@@ -74,13 +52,11 @@ class Cache {
             }
             if (gotHandlers.length > 1) {
                 const innerCallback = needCalls(gotHandlers.length, () => callback(null, result));
-                // @ts-expect-error
                 for (const gotHandler of gotHandlers) {
                     gotHandler(result, innerCallback);
                 }
             }
             else if (gotHandlers.length === 1) {
-                // @ts-expect-error
                 gotHandlers[0](result, () => callback(null, result));
             }
             else {
@@ -89,56 +65,45 @@ class Cache {
         });
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
     store(identifier, etag, data, callback) {
-        this.hooks.store.callAsync(identifier, etag, data, 
-        // @ts-expect-error
-        makeWebpackErrorCallback(callback, "Cache.hooks.store"));
+        this.hooks.store.callAsync(identifier, etag, data, (0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.store"));
     }
     /**
      * After this method has succeeded the cache can only be restored when build dependencies are
-     * @param {Iterable<string>} dependencies list of all build dependencies
-     * @param {CallbackCache<void>} callback signals when the dependencies are stored
-     * @returns {void}
+     * @param dependencies list of all build dependencies
+     * @param callback signals when the dependencies are stored
+     * @returns
      */
     storeBuildDependencies(dependencies, callback) {
-        this.hooks.storeBuildDependencies.callAsync(dependencies, 
-        // @ts-expect-error
-        makeWebpackErrorCallback(callback, "Cache.hooks.storeBuildDependencies"));
+        this.hooks.storeBuildDependencies.callAsync(dependencies, (0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.storeBuildDependencies"));
     }
-    /**
-     * @returns {void}
-     */
     beginIdle() {
         this.hooks.beginIdle.call();
     }
     /**
-     * @param {CallbackCache<void>} callback signals when the call finishes
-     * @returns {void}
+     * @param callback signals when the call finishes
+     * @returns
      */
     endIdle(callback) {
-        this.hooks.endIdle.callAsync(
-        // @ts-expect-error
-        makeWebpackErrorCallback(callback, "Cache.hooks.endIdle"));
+        this.hooks.endIdle.callAsync((0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.endIdle"));
     }
     /**
-     * @param {CallbackCache<void>} callback signals when the call finishes
-     * @returns {void}
+     * @param callback signals when the call finishes
+     * @returns
      */
     shutdown(callback) {
-        this.hooks.shutdown.callAsync(
-        // @ts-expect-error
-        makeWebpackErrorCallback(callback, "Cache.hooks.shutdown"));
+        this.hooks.shutdown.callAsync((0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.shutdown"));
     }
 }
+Cache.STAGE_DISK = 10;
 Cache.STAGE_MEMORY = -10;
 Cache.STAGE_DEFAULT = 0;
-Cache.STAGE_DISK = 10;
 Cache.STAGE_NETWORK = 20;
-module.exports = Cache;
+exports.Cache = Cache;
+exports.default = Cache;