@rspack/core 0.5.7 → 0.5.8

package/dist/config/zod.js

@@ -329,7 +329,14 @@ const assetGeneratorDataUrlOptions = zod_1.z.strictObject({
     encoding: zod_1.z.literal(false).or(zod_1.z.literal("base64")).optional(),
     mimetype: zod_1.z.string().optional()
 });
-const assetGeneratorDataUrl = assetGeneratorDataUrlOptions;
+const assetGeneratorDataUrlFunction = zod_1.z
+    .function()
+    .args(zod_1.z.strictObject({
+    content: zod_1.z.string(),
+    filename: zod_1.z.string()
+}))
+    .returns(zod_1.z.string());
+const assetGeneratorDataUrl = assetGeneratorDataUrlOptions.or(assetGeneratorDataUrlFunction);
 const assetInlineGeneratorOptions = zod_1.z.strictObject({
     dataUrl: assetGeneratorDataUrl.optional()
 });

package/dist/exports.d.ts

@@ -329,7 +329,10 @@ export declare const config: {
                     dataUrl?: {
                         encoding?: false | "base64" | undefined;
                         mimetype?: string | undefined;
-                    } | undefined;
+                    } | ((args_0: {
+                        filename: string;
+                        content: string;
+                    }, ...args_1: unknown[]) => string) | undefined;
                     filename?: string | undefined;
                     publicPath?: string | undefined;
                 } | undefined;
@@ -337,7 +340,10 @@ export declare const config: {
                     dataUrl?: {
                         encoding?: false | "base64" | undefined;
                         mimetype?: string | undefined;
-                    } | undefined;
+                    } | ((args_0: {
+                        filename: string;
+                        content: string;
+                    }, ...args_1: unknown[]) => string) | undefined;
                 } | undefined;
                 "asset/resource"?: {
                     filename?: string | undefined;
@@ -657,7 +663,10 @@ export declare const config: {
                     dataUrl?: {
                         encoding?: false | "base64" | undefined;
                         mimetype?: string | undefined;
-                    } | undefined;
+                    } | ((args_0: {
+                        filename: string;
+                        content: string;
+                    }, ...args_1: unknown[]) => string) | undefined;
                     filename?: string | undefined;
                     publicPath?: string | undefined;
                 } | undefined;
@@ -665,7 +674,10 @@ export declare const config: {
                     dataUrl?: {
                         encoding?: false | "base64" | undefined;
                         mimetype?: string | undefined;
-                    } | undefined;
+                    } | ((args_0: {
+                        filename: string;
+                        content: string;
+                    }, ...args_1: unknown[]) => string) | undefined;
                 } | undefined;
                 "asset/resource"?: {
                     filename?: string | undefined;

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

@@ -46,7 +46,7 @@ export interface HookInterceptor<T, R, AdditionalOptions = UnsetAdditionalOption
     register?: (tap: FullTap & IfSet<AdditionalOptions>) => FullTap & IfSet<AdditionalOptions>;
 }
 type ArgumentNames<T extends any[]> = FixedSizeArray<T["length"], string>;
-declare class Hook<T, R, AdditionalOptions = UnsetAdditionalOptions> {
+export declare class Hook<T, R, AdditionalOptions = UnsetAdditionalOptions> {
     args?: ArgumentNames<AsArray<T>>;
     name?: string;
     taps: (FullTap & IfSet<AdditionalOptions>)[];
@@ -58,6 +58,7 @@ declare class Hook<T, R, AdditionalOptions = UnsetAdditionalOptions> {
     _runErrorInterceptors(e: Error): void;
     _runTapInterceptors(tap: FullTap & IfSet<AdditionalOptions>): void;
     _runDoneInterceptors(): void;
+    _runResultInterceptors(r: R): void;
     isUsed(): boolean;
     queryStageRange(stageRange: StageRange): QueriedHook<T, R, AdditionalOptions>;
     callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
@@ -89,6 +90,13 @@ export declare class SyncHook<T, R = void, AdditionalOptions = UnsetAdditionalOp
     tapAsync(): never;
     tapPromise(): never;
 }
+export declare class SyncBailHook<T, R, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, R, AdditionalOptions> {
+    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    call(...args: AsArray<T>): R;
+    callStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): R;
+    tapAsync(): never;
+    tapPromise(): never;
+}
 export declare class AsyncParallelHook<T, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, void, AdditionalOptions> {
     callAsyncStageRange(queried: QueriedHook<T, void, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, void>>): void;
     tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
@@ -99,4 +107,9 @@ export declare class AsyncSeriesHook<T, AdditionalOptions = UnsetAdditionalOptio
     tapAsync(options: Options<AdditionalOptions>, fn: FnWithCallback<T, void>): void;
     tapPromise(options: Options<AdditionalOptions>, fn: Fn<T, void>): void;
 }
+export declare class AsyncSeriesBailHook<T, R, AdditionalOptions = UnsetAdditionalOptions> extends Hook<T, R, AdditionalOptions> {
+    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 {};

package/dist/lite-tapable/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncSeriesHook = exports.AsyncParallelHook = exports.SyncHook = exports.QueriedHook = exports.safeStage = exports.maxStage = exports.minStage = void 0;
+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;
@@ -55,6 +55,13 @@ class Hook {
             }
         }
     }
+    _runResultInterceptors(r) {
+        for (const interceptor of this.interceptors) {
+            if (interceptor.result) {
+                interceptor.result(r);
+            }
+        }
+    }
     isUsed() {
         return this.taps.length > 0 || this.interceptors.length > 0;
     }
@@ -136,6 +143,7 @@ class Hook {
         this.taps[i] = item;
     }
 }
+exports.Hook = Hook;
 exports.minStage = -Infinity;
 exports.maxStage = Infinity;
 const allStageRange = [exports.minStage, exports.maxStage];
@@ -241,6 +249,59 @@ class SyncHook extends Hook {
     }
 }
 exports.SyncHook = SyncHook;
+class SyncBailHook extends Hook {
+    callAsyncStageRange(queried, ...args) {
+        const { stageRange: [from, to], tapsInRange } = queried;
+        const args2 = [...args];
+        const cb = args2.pop();
+        if (from === exports.minStage) {
+            this._runCallInterceptors(...args2);
+        }
+        for (let tap of tapsInRange) {
+            this._runTapInterceptors(tap);
+            let r = undefined;
+            try {
+                r = tap.fn(...args2);
+            }
+            catch (e) {
+                const err = e;
+                this._runErrorInterceptors(err);
+                return cb(err);
+            }
+            if (r !== undefined) {
+                this._runResultInterceptors(r);
+                return cb(null, r);
+            }
+        }
+        if (to === exports.maxStage) {
+            this._runDoneInterceptors();
+            cb(null);
+        }
+    }
+    call(...args) {
+        return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    callStageRange(queried, ...args) {
+        let result, error;
+        this.callAsyncStageRange(queried, 
+        // @ts-expect-error
+        ...args, (e, r) => {
+            error = e;
+            result = r;
+        });
+        if (error) {
+            throw error;
+        }
+        return result;
+    }
+    tapAsync() {
+        throw new Error("tapAsync is not supported on a SyncBailHook");
+    }
+    tapPromise() {
+        throw new Error("tapPromise is not supported on a SyncBailHook");
+    }
+}
+exports.SyncBailHook = SyncBailHook;
 class AsyncParallelHook extends Hook {
     callAsyncStageRange(queried, ...args) {
         const { stageRange: [from, to], tapsInRange } = queried;
@@ -411,3 +472,109 @@ class AsyncSeriesHook extends Hook {
     }
 }
 exports.AsyncSeriesHook = AsyncSeriesHook;
+class AsyncSeriesBailHook extends Hook {
+    callAsyncStageRange(queried, ...args) {
+        const { stageRange: [from, to], tapsInRange } = queried;
+        const args2 = [...args];
+        const cb = args2.pop();
+        if (from === exports.minStage) {
+            this._runCallInterceptors(...args2);
+        }
+        const done = () => {
+            this._runDoneInterceptors();
+            cb(null);
+        };
+        const error = (e) => {
+            this._runErrorInterceptors(e);
+            cb(e);
+        };
+        const result = (r) => {
+            this._runResultInterceptors(r);
+            cb(null, r);
+        };
+        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(...args2);
+                if (!promise || !promise.then) {
+                    throw new Error("Tap function (tapPromise) did not return promise (returned " +
+                        promise +
+                        ")");
+                }
+                promise.then((r) => {
+                    index += 1;
+                    if (r !== undefined) {
+                        result(r);
+                    }
+                    else if (index === tapsInRange.length) {
+                        done();
+                    }
+                    else {
+                        next();
+                    }
+                }, (e) => {
+                    index = tapsInRange.length;
+                    error(e);
+                });
+            }
+            else if (tap.type === "async") {
+                tap.fn(...args2, (e, r) => {
+                    if (e) {
+                        index = tapsInRange.length;
+                        error(e);
+                    }
+                    else {
+                        index += 1;
+                        if (r !== undefined) {
+                            result(r);
+                        }
+                        else if (index === tapsInRange.length) {
+                            done();
+                        }
+                        else {
+                            next();
+                        }
+                    }
+                });
+            }
+            else {
+                let hasError = false;
+                let r = undefined;
+                try {
+                    r = tap.fn(...args2);
+                }
+                catch (e) {
+                    hasError = true;
+                    index = tapsInRange.length;
+                    error(e);
+                }
+                if (!hasError) {
+                    index += 1;
+                    if (r !== undefined) {
+                        result(r);
+                    }
+                    else 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.AsyncSeriesBailHook = AsyncSeriesBailHook;

package/dist/loader-runner/index.d.ts

@@ -7,11 +7,11 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/loader-runner/blob/main/LICENSE
  */
-import type { JsLoaderContext } from "@rspack/binding";
+import type { JsLoaderContext, JsLoaderResult } from "@rspack/binding";
 import { Compiler } from "../Compiler";
 export declare function parsePathQueryFragment(str: string): {
     path: string;
     query: string;
     fragment: string;
 };
-export declare function runLoaders(compiler: Compiler, rawContext: JsLoaderContext): Promise<unknown>;
+export declare function runLoaders(compiler: Compiler, rawContext: JsLoaderContext): Promise<JsLoaderResult>;

package/dist/loader-runner/index.js

@@ -200,8 +200,8 @@ async function runLoaders(compiler, rawContext) {
     loaderContext.importModule = function importModule(request, options, callback) {
         if (!callback) {
             return new Promise((resolve, reject) => {
-                compiler.compilation
-                    .__internal_getInner()
+                compiler
+                    .compilation.__internal_getInner()
                     .importModule(request, options.publicPath, options.baseUri, rawContext._moduleIdentifier, loaderContext.context, (err, res) => {
                     if (err)
                         reject(err);
@@ -224,8 +224,8 @@ async function runLoaders(compiler, rawContext) {
                 });
             });
         }
-        return compiler.compilation
-            .__internal_getInner()
+        return compiler
+            .compilation.__internal_getInner()
             .importModule(request, options.publicPath, options.baseUri, rawContext._moduleIdentifier, loaderContext.context, (err, res) => {
             if (err) {
                 callback(err, undefined);

package/dist/rspackOptionsApply.js

@@ -137,6 +137,7 @@ class RspackOptionsApply {
         if (options.experiments.asyncWebAssembly) {
             new builtin_plugin_1.AsyncWebAssemblyModulesPlugin().apply(compiler);
         }
+        new builtin_plugin_1.JsLoaderRspackPlugin(compiler).apply(compiler);
         if (options.experiments.rspackFuture.disableApplyEntryLazily) {
             applyEntryOptions(compiler, options);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "A Fast Rust-based Web Bundler",
@@ -55,9 +55,9 @@
     "styled-components": "^6.0.8",
     "terser": "5.27.2",
     "wast-loader": "^1.11.4",
-    "@rspack/plugin-minify": "^0.5.7",
-    "@rspack/core": "0.5.7",
-    "@rspack/plugin-node-polyfill": "^0.5.7"
+    "@rspack/plugin-minify": "^0.5.8",
+    "@rspack/plugin-node-polyfill": "^0.5.8",
+    "@rspack/core": "0.5.8"
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.0.8",
@@ -72,7 +72,7 @@
     "webpack-sources": "3.2.3",
     "zod": "^3.21.4",
     "zod-validation-error": "1.3.1",
-    "@rspack/binding": "0.5.7"
+    "@rspack/binding": "0.5.8"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"