@rspack/core 0.6.5-canary-00f90f0-20240510072319 → 0.6.5-canary-d1f53fd-20240511004704

package/dist/Compiler.js

@@ -609,27 +609,33 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
             };
             await queried.promise(data, {});
         }),
-        registerContextModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.ContextModuleFactoryBeforeResolve, () => this.compilationParams.contextModuleFactory.hooks.beforeResolve, queried => async (arg) => {
-            const data = {
-                request: arg.request,
-                context: arg.context,
-                fileDependencies: [],
-                missingDependencies: [],
-                contextDependencies: []
-            };
-            const ret = await queried.promise(data);
-            return [ret, data];
+        registerContextModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.ContextModuleFactoryBeforeResolve, () => this.compilationParams.contextModuleFactory.hooks.beforeResolve, queried => async (bindingData) => {
+            return queried.promise(bindingData);
         }),
-        registerContextModuleFactoryAfterResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.ContextModuleFactoryAfterResolve, () => this.compilationParams.contextModuleFactory.hooks.afterResolve, queried => async (arg) => {
-            const data = {
-                request: arg.request,
-                context: arg.context,
-                fileDependencies: arg.fileDependencies,
-                missingDependencies: arg.missingDependencies,
-                contextDependencies: arg.contextDependencies,
-                createData: arg.createData
-            };
-            return await queried.promise(data);
+        registerContextModuleFactoryAfterResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.ContextModuleFactoryAfterResolve, () => this.compilationParams.contextModuleFactory.hooks.afterResolve, queried => async (bindingData) => {
+            var _a;
+            const data = bindingData
+                ? ({
+                    resource: bindingData.resource,
+                    regExp: bindingData.regExp
+                        ? new RegExp(bindingData.regExp)
+                        : undefined,
+                    request: bindingData.request,
+                    context: bindingData.context,
+                    // TODO: Dependencies are not fully supported yet; this is a placeholder to prevent errors in moment-locales-webpack-plugin.
+                    dependencies: []
+                })
+                : false;
+            const ret = await queried.promise(data);
+            const result = ret
+                ? ({
+                    resource: ret.resource,
+                    context: ret.context,
+                    request: ret.request,
+                    regExp: (_a = ret.regExp) === null || _a === void 0 ? void 0 : _a.toString()
+                })
+                : false;
+            return result;
         })
     }, "f");
     __classPrivateFieldSet(this, _Compiler_instance, new instanceBinding.Rspack(rawOptions, this.builtinPlugins, __classPrivateFieldGet(this, _Compiler_registers, "f"), (0, fileSystem_1.createThreadsafeNodeFSFromRaw)(this.outputFileSystem)), "f");

package/dist/ContextModuleFactory.d.ts

@@ -1,9 +1,13 @@
 import * as liteTapable from "./lite-tapable";
-import { ResolveData } from "./Module";
+import { ContextModuleFactoryAfterResolveResult, ContextModuleFactoryBeforeResolveResult } from "./Module";
 export declare class ContextModuleFactory {
     hooks: {
-        beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
-        afterResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        beforeResolve: liteTapable.AsyncSeriesWaterfallHook<[
+            ContextModuleFactoryBeforeResolveResult
+        ], ContextModuleFactoryBeforeResolveResult | void>;
+        afterResolve: liteTapable.AsyncSeriesWaterfallHook<[
+            ContextModuleFactoryAfterResolveResult
+        ], ContextModuleFactoryAfterResolveResult | void>;
     };
     constructor();
 }

package/dist/ContextModuleFactory.js

@@ -41,8 +41,8 @@ class ContextModuleFactory {
             // /** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
             // factorize: new AsyncSeriesBailHook(["resolveData"]),
             // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
-            beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
-            afterResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"])
+            beforeResolve: new liteTapable.AsyncSeriesWaterfallHook(["resolveData"]),
+            afterResolve: new liteTapable.AsyncSeriesWaterfallHook(["resolveData"])
             // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
             // createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
             // /** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */

package/dist/Module.d.ts

@@ -18,6 +18,17 @@ export type ResolveData = {
     contextDependencies: string[];
     createData?: CreateData;
 };
+export type ContextModuleFactoryBeforeResolveResult = false | {
+    context: string;
+    request?: string;
+};
+export type ContextModuleFactoryAfterResolveResult = false | {
+    resource: string;
+    context: string;
+    request: string;
+    regExp?: RegExp;
+    dependencies: Array<any>;
+};
 export declare class Module {
     #private;
     _originalSource?: Source;

package/dist/exports.d.ts

@@ -59,9 +59,11 @@ export { EnvironmentPlugin } from "./lib/EnvironmentPlugin";
 export { NormalModuleReplacementPlugin } from "./lib/NormalModuleReplacementPlugin";
 import NodeTemplatePlugin from "./node/NodeTemplatePlugin";
 import { NodeTargetPlugin } from "./builtin-plugin";
+import NodeEnvironmentPlugin from "./node/NodeEnvironmentPlugin";
 interface Node {
     NodeTargetPlugin: typeof NodeTargetPlugin;
     NodeTemplatePlugin: typeof NodeTemplatePlugin;
+    NodeEnvironmentPlugin: typeof NodeEnvironmentPlugin;
 }
 export declare const node: Node;
 import { ElectronTargetPlugin } from "./builtin-plugin";

package/dist/exports.js

@@ -100,7 +100,12 @@ var NormalModuleReplacementPlugin_1 = require("./lib/NormalModuleReplacementPlug
 Object.defineProperty(exports, "NormalModuleReplacementPlugin", { enumerable: true, get: function () { return NormalModuleReplacementPlugin_1.NormalModuleReplacementPlugin; } });
 const NodeTemplatePlugin_1 = __importDefault(require("./node/NodeTemplatePlugin"));
 const builtin_plugin_10 = require("./builtin-plugin");
-exports.node = { NodeTargetPlugin: builtin_plugin_10.NodeTargetPlugin, NodeTemplatePlugin: NodeTemplatePlugin_1.default };
+const NodeEnvironmentPlugin_1 = __importDefault(require("./node/NodeEnvironmentPlugin"));
+exports.node = {
+    NodeTargetPlugin: builtin_plugin_10.NodeTargetPlugin,
+    NodeTemplatePlugin: NodeTemplatePlugin_1.default,
+    NodeEnvironmentPlugin: NodeEnvironmentPlugin_1.default
+};
 const builtin_plugin_11 = require("./builtin-plugin");
 exports.electron = { ElectronTargetPlugin: builtin_plugin_11.ElectronTargetPlugin };
 const builtin_plugin_12 = require("./builtin-plugin");

package/dist/lite-tapable/index.d.ts

@@ -112,6 +112,12 @@ export declare class AsyncSeriesBailHook<T, R, AdditionalOptions = UnsetAddition
     tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
     tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
 }
+export declare class AsyncSeriesWaterfallHook<T, R, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, R, AdditionalOptions> {
+    constructor(args?: ArgumentNames<AsArray<T>>, name?: string);
+    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
+    tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
+}
 export type HookMapKey = any;
 export type HookFactory<H> = (key: HookMapKey, hook?: H) => H;
 export interface HookMapInterceptor<H> {

package/dist/lite-tapable/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueriedHookMap = exports.HookMap = exports.AsyncSeriesBailHook = exports.AsyncSeriesHook = exports.AsyncParallelHook = exports.SyncBailHook = exports.SyncHook = exports.QueriedHook = exports.safeStage = exports.maxStage = exports.minStage = exports.Hook = void 0;
+exports.QueriedHookMap = exports.HookMap = exports.AsyncSeriesWaterfallHook = exports.AsyncSeriesBailHook = exports.AsyncSeriesHook = exports.AsyncParallelHook = exports.SyncBailHook = exports.SyncHook = exports.QueriedHook = exports.safeStage = exports.maxStage = exports.minStage = exports.Hook = void 0;
 class Hook {
     constructor(args, name) {
         this.args = args;
@@ -578,6 +578,112 @@ class AsyncSeriesBailHook extends Hook {
     }
 }
 exports.AsyncSeriesBailHook = AsyncSeriesBailHook;
+class AsyncSeriesWaterfallHook extends Hook {
+    constructor(args, name) {
+        if (!(args === null || args === void 0 ? void 0 : args.length))
+            throw new Error("Waterfall hooks must have at least one argument");
+        super(args, name);
+    }
+    callAsyncStageRange(queried, ...args) {
+        const { stageRange: [from, to], tapsInRange } = queried;
+        let data = args[0];
+        const cb = args[1];
+        if (from === exports.minStage) {
+            this._runCallInterceptors(data);
+        }
+        const done = () => {
+            this._runDoneInterceptors();
+            cb(null, data);
+        };
+        const error = (e) => {
+            this._runErrorInterceptors(e);
+            cb(e);
+        };
+        if (tapsInRange.length === 0)
+            return done();
+        let index = 0;
+        const next = () => {
+            const tap = tapsInRange[index];
+            this._runTapInterceptors(tap);
+            if (tap.type === "promise") {
+                const promise = tap.fn(data);
+                if (!promise || !promise.then) {
+                    throw new Error("Tap function (tapPromise) did not return promise (returned " +
+                        promise +
+                        ")");
+                }
+                promise.then((r) => {
+                    index += 1;
+                    if (r !== undefined) {
+                        data = r;
+                    }
+                    if (index === tapsInRange.length) {
+                        done();
+                    }
+                    else {
+                        next();
+                    }
+                }, (e) => {
+                    index = tapsInRange.length;
+                    error(e);
+                });
+            }
+            else if (tap.type === "async") {
+                tap.fn(data, (e, r) => {
+                    if (e) {
+                        index = tapsInRange.length;
+                        error(e);
+                    }
+                    else {
+                        index += 1;
+                        if (r !== undefined) {
+                            data = r;
+                        }
+                        if (index === tapsInRange.length) {
+                            done();
+                        }
+                        else {
+                            next();
+                        }
+                    }
+                });
+            }
+            else {
+                let hasError = false;
+                try {
+                    const r = tap.fn(data);
+                    if (r !== undefined) {
+                        data = r;
+                    }
+                }
+                catch (e) {
+                    hasError = true;
+                    index = tapsInRange.length;
+                    error(e);
+                }
+                if (!hasError) {
+                    index += 1;
+                    if (index === tapsInRange.length) {
+                        done();
+                    }
+                    else {
+                        next();
+                    }
+                }
+            }
+            if (index === tapsInRange.length)
+                return;
+        };
+        next();
+    }
+    tapAsync(options, fn) {
+        this._tap("async", options, fn);
+    }
+    tapPromise(options, fn) {
+        this._tap("promise", options, fn);
+    }
+}
+exports.AsyncSeriesWaterfallHook = AsyncSeriesWaterfallHook;
 const defaultFactory = (key, hook) => hook;
 class HookMap {
     constructor(factory, name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "0.6.5-canary-00f90f0-20240510072319",
+  "version": "0.6.5-canary-d1f53fd-20240511004704",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "A Fast Rust-based Web Bundler",
@@ -71,8 +71,8 @@
     "watchpack": "^2.4.0",
     "zod": "^3.21.4",
     "zod-validation-error": "1.3.1",
-    "@rspack/core": "0.6.5-canary-00f90f0-20240510072319",
-    "@rspack/plugin-minify": "^0.6.5-canary-00f90f0-20240510072319"
+    "@rspack/core": "0.6.5-canary-d1f53fd-20240511004704",
+    "@rspack/plugin-minify": "^0.6.5-canary-d1f53fd-20240511004704"
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.1.6",
@@ -80,7 +80,7 @@
     "enhanced-resolve": "5.12.0",
     "tapable": "2.2.1",
     "webpack-sources": "3.2.3",
-    "@rspack/binding": "0.6.5-canary-00f90f0-20240510072319"
+    "@rspack/binding": "0.6.5-canary-d1f53fd-20240511004704"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"