@rspack/core 1.3.0 → 1.3.2

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

@@ -10,7 +10,6 @@
 import { type JsLoaderContext, type JsLoaderItem } from "@rspack/binding";
 import type { Compiler } from "../Compiler";
 export declare class LoaderObject {
-    #private;
     request: string;
     path: string;
     query: string;
@@ -21,13 +20,16 @@ export declare class LoaderObject {
     pitch?: Function;
     raw?: boolean;
     type?: "module" | "commonjs";
+    parallel?: boolean;
+    /**
+     * @internal This field is rspack internal. Do not edit.
+     */
+    loaderItem: JsLoaderItem;
     constructor(loaderItem: JsLoaderItem, compiler: Compiler);
     get pitchExecuted(): boolean;
     set pitchExecuted(value: boolean);
     get normalExecuted(): boolean;
     set normalExecuted(value: boolean);
-    get data(): any;
-    set data(data: any);
     shouldYield(): boolean;
     static __from_binding(loaderItem: JsLoaderItem, compiler: Compiler): LoaderObject;
     static __to_binding(loader: LoaderObject): JsLoaderItem;

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

@@ -0,0 +1,71 @@
+import type { Tinypool } from "tinypool" with { "resolution-mode": "import" };
+type RunOptions = Parameters<Tinypool["run"]>[1];
+export interface WorkerResponseMessage {
+    type: "response";
+    id: number;
+    data: any;
+}
+export interface WorkerResponseErrorMessage {
+    type: "response-error";
+    id: number;
+    error: WorkerError;
+}
+interface WorkerDoneMessage {
+    type: "done";
+    data: WorkerArgs;
+}
+interface WorkerDoneErrorMessage {
+    type: "done-error";
+    error: WorkerError;
+}
+export interface WorkerRequestMessage {
+    type: "request";
+    id: number;
+    requestType: RequestType;
+    data: WorkerArgs;
+}
+export interface WorkerRequestSyncMessage {
+    type: "request-sync";
+    id: number;
+    requestType: RequestSyncType;
+    data: WorkerArgs;
+    sharedBuffer: SharedArrayBuffer;
+}
+export type WorkerMessage = WorkerResponseMessage | WorkerDoneMessage | WorkerRequestMessage | WorkerResponseErrorMessage | WorkerDoneErrorMessage | WorkerRequestSyncMessage;
+export declare function isWorkerResponseMessage(message: WorkerMessage): message is WorkerResponseMessage;
+export declare function isWorkerResponseErrorMessage(message: WorkerMessage): message is WorkerResponseErrorMessage;
+export declare enum RequestType {
+    AddDependency = "AddDependency",
+    AddContextDependency = "AddContextDependency",
+    AddMissingDependency = "AddMissingDependency",
+    AddBuildDependency = "AddBuildDependency",
+    GetDependencies = "GetDependencies",
+    GetContextDependencies = "GetContextDependencies",
+    GetMissingDependencies = "GetMissingDependencies",
+    ClearDependencies = "ClearDependencies",
+    Resolve = "Resolve",
+    GetResolve = "GetResolve",
+    GetLogger = "GetLogger",
+    EmitError = "EmitError",
+    EmitWarning = "EmitWarning",
+    EmitFile = "EmitFile",
+    EmitDiagnostic = "EmitDiagnostic",
+    SetCacheable = "SetCacheable",
+    ImportModule = "ImportModule",
+    UpdateLoaderObjects = "UpdateLoaderObjects",
+    CompilationGetPath = "CompilationGetPath",
+    CompilationGetPathWithInfo = "CompilationGetPathWithInfo",
+    CompilationGetAssetPath = "CompilationGetAssetPath",
+    CompilationGetAssetPathWithInfo = "CompilationGetAssetPathWithInfo"
+}
+export declare enum RequestSyncType {
+    WaitForPendingRequest = "WaitForPendingRequest"
+}
+export type HandleIncomingRequest = (requestType: RequestType, ...args: any[]) => Promise<any> | any;
+type WorkerArgs = any[];
+export type WorkerError = Error;
+export declare function serializeError(error: unknown): WorkerError;
+export declare const run: (task: any, options: RunOptions & {
+    handleIncomingRequest: HandleIncomingRequest;
+}) => Promise<WorkerArgs>;
+export {};

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

@@ -0,0 +1,5 @@
+import type { LoaderObject } from ".";
+import type { LoaderContext } from "../config/adapterRuleUse";
+export declare function convertArgs(args: any[], raw: boolean): void;
+export declare const loadLoader: (loaderObject: LoaderObject) => Promise<void>;
+export declare const runSyncOrAsync: (arg1: Function, arg2: LoaderContext<{}>, arg3: any[]) => Promise<any[]>;

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

@@ -0,0 +1,14 @@
+import { type MessagePort } from "node:worker_threads";
+import { JsLoaderState } from "@rspack/binding";
+import type { LoaderContext } from "../config";
+interface WorkerOptions {
+    loaderContext: LoaderContext;
+    loaderState: JsLoaderState;
+    args: any[];
+    workerData?: {
+        workerPort: MessagePort;
+        workerSyncPort: MessagePort;
+    };
+}
+declare function worker(workerOptions: WorkerOptions): void;
+export = worker;

package/dist/util/index.d.ts

@@ -4,7 +4,7 @@ export declare function mapValues(record: Record<string, string>, fn: (key: stri
     [k: string]: string;
 };
 export declare function isNil(value: unknown): value is null | undefined;
-export declare const toBuffer: (bufLike: string | Buffer) => Buffer;
+export declare const toBuffer: (bufLike: string | Buffer | Uint8Array) => Buffer;
 export declare const toObject: (input: string | Buffer | object) => object;
 export declare function serializeObject(map: string | object | undefined | null): Buffer | undefined;
 export declare function isPromiseLike(value: unknown): value is Promise<any>;