Project Init

node_modules/@rspack/core/dist/loader-runner/LoaderLoadingError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The following code is from
+ * https://github.com/webpack/loader-runner
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/loader-runner/blob/main/LICENSE
+ */
+declare class LoadingLoaderError extends Error {
+    constructor(message: string);
+}
+export default LoadingLoaderError;

node_modules/@rspack/core/dist/loader-runner/ModuleError.d.ts

@@ -0,0 +1,13 @@
+import WebpackError from "../lib/WebpackError";
+export declare class ModuleError extends WebpackError {
+    error?: Error;
+    constructor(err: Error, { from }?: {
+        from?: string;
+    });
+}
+export declare class ModuleWarning extends WebpackError {
+    error?: Error;
+    constructor(err: Error, { from }?: {
+        from?: string;
+    });
+}

node_modules/@rspack/core/dist/loader-runner/index.d.ts

@@ -0,0 +1,36 @@
+import { type JsLoaderContext, type JsLoaderItem } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
+export declare class LoaderObject {
+    request: string;
+    path: string;
+    query: string;
+    fragment: string;
+    options?: string | object;
+    ident: string;
+    normal?: Function;
+    pitch?: Function;
+    raw?: boolean;
+    type?: "module" | "commonjs";
+    parallel?: boolean | {
+        maxWorkers?: number;
+    };
+    /**
+     * @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);
+    set noPitch(value: boolean);
+    shouldYield(): boolean;
+    static __from_binding(loaderItem: JsLoaderItem, compiler: Compiler): LoaderObject;
+    static __to_binding(loader: LoaderObject): JsLoaderItem;
+}
+export declare function runLoaders(compiler: Compiler, context: JsLoaderContext): Promise<JsLoaderContext>;
+export declare function parsePathQueryFragment(str: string): {
+    path: string;
+    query: string;
+    fragment: string;
+};

node_modules/@rspack/core/dist/loader-runner/loadLoader.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The following code is from
+ * https://github.com/webpack/loader-runner
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/loader-runner/blob/main/LICENSE
+ */
+import type { Compiler } from "../exports";
+import type { LoaderObject } from ".";
+export default function loadLoader(loader: LoaderObject, compiler: Compiler, callback: (err: unknown) => void): void;

node_modules/@rspack/core/dist/loader-runner/service.d.ts

@@ -0,0 +1,73 @@
+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[]) => any;
+type WorkerArgs = any[];
+export type WorkerError = Error;
+export declare function serializeError(error: unknown): WorkerError;
+export declare const run: (loaderName: string, task: any, options: RunOptions & {
+    handleIncomingRequest: HandleIncomingRequest;
+}, workerOptions?: {
+    maxWorkers?: number;
+}) => Promise<WorkerArgs>;
+export {};

node_modules/@rspack/core/dist/loader-runner/utils.d.ts

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

node_modules/@rspack/core/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 default worker;