@rspack-canary/browser 1.4.12-canary-c9012b88-20250801081627 → 1.4.12-canary-4f117639-20250801093856

package/dist/ContextModuleFactory.d.ts

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

package/dist/Diagnostics.d.ts

@@ -0,0 +1,7 @@
+import type { Diagnostics } from "@rspack/binding";
+import type { RspackError } from "./RspackError";
+declare const $proxy: unique symbol;
+export declare function createDiagnosticArray(adm: Diagnostics & {
+    [$proxy]?: RspackError[];
+}): RspackError[];
+export {};

package/dist/Entrypoint.d.ts

@@ -0,0 +1,2 @@
+import type { ChunkGroup } from "@rspack/binding";
+export type Entrypoint = ChunkGroup;

package/dist/ErrorHelpers.d.ts

@@ -0,0 +1,3 @@
+export declare const cutOffLoaderExecution: (stack: string) => string;
+export declare const cleanUp: (stack: string, name: string, message: string) => string;
+export declare const cutOffMessage: (stack: string, name: string, message: string) => string;

package/dist/ExecuteModulePlugin.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler } from "./Compiler";
+export default class ExecuteModulePlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/ExportsInfo.d.ts

@@ -0,0 +1,20 @@
+import type { JsExportsInfo } from "@rspack/binding";
+import type { RuntimeSpec } from "./util/runtime";
+/**
+ * Unused: 0
+ * OnlyPropertiesUsed: 1
+ * NoInfo: 2
+ * Unknown: 3
+ * Used: 4
+ */
+type UsageStateType = 0 | 1 | 2 | 3 | 4;
+export declare class ExportsInfo {
+    #private;
+    static __from_binding(binding: JsExportsInfo): ExportsInfo;
+    private constructor();
+    isUsed(runtime: RuntimeSpec): boolean;
+    isModuleUsed(runtime: RuntimeSpec): boolean;
+    setUsedInUnknownWay(runtime: RuntimeSpec): boolean;
+    getUsed(name: string | string[], runtime: RuntimeSpec): UsageStateType;
+}
+export {};

package/dist/ExternalModule.d.ts

@@ -0,0 +1 @@
+export { ExternalModule } from "@rspack/binding";

package/dist/FileSystem.d.ts

@@ -0,0 +1,54 @@
+import type { NodeFsStats, ThreadsafeNodeFS } from "@rspack/binding";
+import { type InputFileSystem, type IntermediateFileSystem, type OutputFileSystem } from "./util/fs";
+declare class ThreadsafeInputNodeFS implements ThreadsafeNodeFS {
+    writeFile: (name: string, content: Buffer) => Promise<void>;
+    removeFile: (name: string) => Promise<void>;
+    mkdir: (name: string) => Promise<void>;
+    mkdirp: (name: string) => Promise<string | void>;
+    removeDirAll: (name: string) => Promise<string | void>;
+    readDir: (name: string) => Promise<string[] | void>;
+    readFile: (name: string) => Promise<Buffer | string | void>;
+    stat: (name: string) => Promise<NodeFsStats | void>;
+    lstat: (name: string) => Promise<NodeFsStats | void>;
+    chmod?: (name: string, mode: number) => Promise<void>;
+    realpath: (name: string) => Promise<string | void>;
+    open: (name: string, flags: string) => Promise<number | void>;
+    rename: (from: string, to: string) => Promise<void>;
+    close: (fd: number) => Promise<void>;
+    write: (fd: number, content: Buffer, position: number) => Promise<number | void>;
+    writeAll: (fd: number, content: Buffer) => Promise<number | void>;
+    read: (fd: number, length: number, position: number) => Promise<Buffer | void>;
+    readUntil: (fd: number, code: number, position: number) => Promise<Buffer | void>;
+    readToEnd: (fd: number, position: number) => Promise<Buffer | void>;
+    constructor(fs?: InputFileSystem);
+    static __to_binding(fs?: InputFileSystem): ThreadsafeInputNodeFS;
+    static needsBinding(ifs?: false | RegExp[]): boolean;
+}
+declare class ThreadsafeOutputNodeFS implements ThreadsafeNodeFS {
+    writeFile: (name: string, content: Buffer) => Promise<void>;
+    removeFile: (name: string) => Promise<void>;
+    mkdir: (name: string) => Promise<void>;
+    mkdirp: (name: string) => Promise<string | void>;
+    removeDirAll: (name: string) => Promise<string | void>;
+    readDir: (name: string) => Promise<string[] | void>;
+    readFile: (name: string) => Promise<Buffer | string | void>;
+    stat: (name: string) => Promise<NodeFsStats | void>;
+    lstat: (name: string) => Promise<NodeFsStats | void>;
+    chmod?: (name: string, mode: number) => Promise<void>;
+    realpath: (name: string) => Promise<string | void>;
+    open: (name: string, flags: string) => Promise<number | void>;
+    rename: (from: string, to: string) => Promise<void>;
+    close: (fd: number) => Promise<void>;
+    write: (fd: number, content: Buffer, position: number) => Promise<number | void>;
+    writeAll: (fd: number, content: Buffer) => Promise<number | void>;
+    read: (fd: number, length: number, position: number) => Promise<Buffer | void>;
+    readUntil: (fd: number, code: number, position: number) => Promise<Buffer | void>;
+    readToEnd: (fd: number, position: number) => Promise<Buffer | void>;
+    constructor(fs?: OutputFileSystem);
+    static __to_binding(fs?: OutputFileSystem): ThreadsafeOutputNodeFS;
+}
+declare class ThreadsafeIntermediateNodeFS extends ThreadsafeOutputNodeFS {
+    constructor(fs?: IntermediateFileSystem);
+    static __to_binding(fs?: IntermediateFileSystem): ThreadsafeIntermediateNodeFS;
+}
+export { ThreadsafeInputNodeFS, ThreadsafeOutputNodeFS, ThreadsafeIntermediateNodeFS };

package/dist/FileSystemInfo.d.ts

@@ -0,0 +1,5 @@
+interface FileSystemInfoEntry {
+    safeTime: number;
+    timestamp?: number;
+}
+export type { FileSystemInfoEntry };

package/dist/Module.d.ts

@@ -0,0 +1,53 @@
+import binding, { type AssetInfo } from "@rspack/binding";
+import type { Source } from "webpack-sources";
+import type { ResourceData } from "./Resolver";
+import "./BuildInfo";
+export type ResourceDataWithData = ResourceData & {
+    data?: Record<string, any>;
+};
+export type CreateData = Partial<binding.JsCreateData>;
+export type ContextInfo = {
+    issuer: string;
+    issuerLayer?: string | null;
+};
+export type ResolveData = {
+    contextInfo: ContextInfo;
+    context: string;
+    request: string;
+    fileDependencies: string[];
+    missingDependencies: string[];
+    contextDependencies: string[];
+    createData?: CreateData;
+};
+export declare class ContextModuleFactoryBeforeResolveData {
+    #private;
+    context: string;
+    request: string;
+    regExp: RegExp | undefined;
+    recursive: boolean;
+    static __from_binding(binding: binding.JsContextModuleFactoryBeforeResolveData): ContextModuleFactoryBeforeResolveData;
+    static __to_binding(data: ContextModuleFactoryBeforeResolveData): binding.JsContextModuleFactoryBeforeResolveData;
+    private constructor();
+}
+export type ContextModuleFactoryBeforeResolveResult = false | ContextModuleFactoryBeforeResolveData;
+export declare class ContextModuleFactoryAfterResolveData {
+    #private;
+    resource: number;
+    context: string;
+    request: string;
+    regExp: RegExp | undefined;
+    recursive: boolean;
+    readonly dependencies: binding.Dependency[];
+    static __from_binding(binding: binding.JsContextModuleFactoryAfterResolveData): ContextModuleFactoryAfterResolveData;
+    static __to_binding(data: ContextModuleFactoryAfterResolveData): binding.JsContextModuleFactoryAfterResolveData;
+    private constructor();
+}
+export type ContextModuleFactoryAfterResolveResult = false | ContextModuleFactoryAfterResolveData;
+declare module "@rspack/binding" {
+    interface Module {
+        identifier(): string;
+        originalSource(): Source | null;
+        emitFile(filename: string, source: Source, assetInfo?: AssetInfo): void;
+    }
+}
+export { Module } from "@rspack/binding";

package/dist/ModuleGraph.d.ts

@@ -0,0 +1,19 @@
+import type { Dependency, JsModuleGraph, ModuleGraphConnection } from "@rspack/binding";
+import { ExportsInfo } from "./ExportsInfo";
+import type { Module } from "./Module";
+export default class ModuleGraph {
+    #private;
+    static __from_binding(binding: JsModuleGraph): ModuleGraph;
+    constructor(binding: JsModuleGraph);
+    getModule(dependency: Dependency): Module | null;
+    getResolvedModule(dependency: Dependency): Module | null;
+    getParentModule(dependency: Dependency): Module | null;
+    getIssuer(module: Module): Module | null;
+    getExportsInfo(module: Module): ExportsInfo;
+    getConnection(dependency: Dependency): ModuleGraphConnection | null;
+    getOutgoingConnections(module: Module): ModuleGraphConnection[];
+    getIncomingConnections(module: Module): ModuleGraphConnection[];
+    getParentBlockIndex(dependency: Dependency): number;
+    isAsync(module: Module): boolean;
+    getOutgoingConnectionsInOrder(module: Module): ModuleGraphConnection[];
+}

package/dist/ModuleTypeConstants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This is the module type used for JSON files. JSON files are always parsed as ES Module.
+ */
+export declare const JSON_MODULE_TYPE = "json";
+/**
+ * This is the module type used for automatically choosing between `asset/inline`, `asset/resource` based on asset size limit (8096).
+ */
+export declare const ASSET_MODULE_TYPE = "asset";

package/dist/MultiCompiler.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/MultiCompiler.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import * as liteTapable from "@rspack/lite-tapable";
+import type { CompilationParams, Compiler, RspackOptions } from ".";
+import type { WatchOptions } from "./config";
+import MultiStats from "./MultiStats";
+import MultiWatching from "./MultiWatching";
+import type { InputFileSystem, IntermediateFileSystem, WatchFileSystem } from "./util/fs";
+export interface MultiCompilerOptions {
+    /**
+     * how many Compilers are allows to run at the same time in parallel
+     */
+    parallelism?: number;
+}
+export type MultiRspackOptions = ReadonlyArray<RspackOptions> & MultiCompilerOptions;
+export declare class MultiCompiler {
+    #private;
+    compilers: Compiler[];
+    dependencies: WeakMap<Compiler, string[]>;
+    hooks: {
+        done: liteTapable.SyncHook<MultiStats>;
+        invalid: liteTapable.MultiHook<liteTapable.SyncHook<[string | null, number]>>;
+        beforeCompile: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[CompilationParams]>>;
+        shutdown: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[]>>;
+        run: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
+        watchClose: liteTapable.SyncHook<[]>;
+        watchRun: liteTapable.MultiHook<liteTapable.AsyncSeriesHook<[Compiler]>>;
+        infrastructureLog: liteTapable.MultiHook<liteTapable.SyncBailHook<[string, string, any[]], true>>;
+    };
+    _options: MultiCompilerOptions;
+    running: boolean;
+    watching?: MultiWatching;
+    constructor(compilers: Compiler[] | Record<string, Compiler>, options?: MultiCompilerOptions);
+    get options(): import(".").RspackOptionsNormalized[] & MultiCompilerOptions;
+    get outputPath(): string;
+    get inputFileSystem(): InputFileSystem;
+    get outputFileSystem(): typeof import("fs");
+    get watchFileSystem(): WatchFileSystem;
+    get intermediateFileSystem(): IntermediateFileSystem;
+    set inputFileSystem(value: InputFileSystem);
+    set outputFileSystem(value: typeof import("fs"));
+    set watchFileSystem(value: WatchFileSystem);
+    set intermediateFileSystem(value: IntermediateFileSystem);
+    getInfrastructureLogger(name: string): import("./logging/Logger").Logger;
+    /**
+     * @param compiler - the child compiler
+     * @param dependencies - its dependencies
+     */
+    setDependencies(compiler: Compiler, dependencies: string[]): void;
+    /**
+     * @param callback - signals when the validation is complete
+     * @returns true if the dependencies are valid
+     */
+    validateDependencies(callback: liteTapable.Callback<Error, MultiStats>): boolean;
+    /**
+     * @param watchOptions - the watcher's options
+     * @param handler - signals when the call finishes
+     * @returns a compiler watcher
+     */
+    watch(watchOptions: WatchOptions | WatchOptions[], handler: liteTapable.Callback<Error, MultiStats>): MultiWatching;
+    /**
+     * @param callback - signals when the call finishes
+     * @param options - additional data like modifiedFiles, removedFiles
+     */
+    run(callback: liteTapable.Callback<Error, MultiStats>, options?: {
+        modifiedFiles?: ReadonlySet<string>;
+        removedFiles?: ReadonlySet<string>;
+    }): void;
+    purgeInputFileSystem(): void;
+    close(callback: liteTapable.Callback<Error, void>): void;
+}

package/dist/MultiStats.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/MultiStats.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Stats } from "./Stats";
+import type { StatsCompilation } from "./stats/statsFactoryUtils";
+export default class MultiStats {
+    #private;
+    stats: Stats[];
+    constructor(stats: Stats[]);
+    get hash(): string;
+    hasErrors(): boolean;
+    hasWarnings(): boolean;
+    toJson(options: any): StatsCompilation;
+    toString(options: any): string;
+}
+export { MultiStats };

package/dist/MultiWatching.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/MultiWatching.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Callback } from "@rspack/lite-tapable";
+import type { MultiCompiler } from "./MultiCompiler";
+import type { Watching } from "./Watching";
+declare class MultiWatching {
+    watchings: Watching[];
+    compiler: MultiCompiler;
+    /**
+     * @param watchings - child compilers' watchers
+     * @param compiler - the compiler
+     */
+    constructor(watchings: Watching[], compiler: MultiCompiler);
+    invalidate(callback: Callback<Error, void>): void;
+    invalidateWithChangesAndRemovals(changedFiles?: Set<string>, removedFiles?: Set<string>, callback?: Callback<Error, void>): void;
+    close(callback: Callback<Error, void>): void;
+    suspend(): void;
+    resume(): void;
+}
+export default MultiWatching;

package/dist/NativeWatchFileSystem.d.ts

@@ -0,0 +1,17 @@
+import binding from "@rspack/binding";
+import type Watchpack from "watchpack";
+import type { FileSystemInfoEntry, Watcher, WatchFileSystem } from "./util/fs";
+export default class NativeWatchFileSystem implements WatchFileSystem {
+    #private;
+    watch(files: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, directories: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, missing: Iterable<string> & {
+        added?: Iterable<string>;
+        removed?: Iterable<string>;
+    }, _startTime: number, options: Watchpack.WatchOptions, callback: (error: Error | null, fileTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, contextTimeInfoEntries: Map<string, FileSystemInfoEntry | "ignore">, changedFiles: Set<string>, removedFiles: Set<string>) => void, callbackUndelayed: (fileName: string, changeTime: number) => void): Watcher;
+    getNativeWatcher(options: Watchpack.WatchOptions): binding.NativeWatcher;
+}

package/dist/NormalModule.d.ts

@@ -0,0 +1,15 @@
+import * as liteTapable from "@rspack/lite-tapable";
+import type { Compilation } from "./Compilation";
+import type { LoaderContext } from "./config";
+import type { Module } from "./Module";
+export interface NormalModuleCompilationHooks {
+    loader: liteTapable.SyncHook<[LoaderContext, Module]>;
+    readResourceForScheme: any;
+    readResource: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[LoaderContext], string | Buffer>>;
+}
+declare module "@rspack/binding" {
+    interface NormalModuleConstructor {
+        getCompilationHooks(compilation: Compilation): NormalModuleCompilationHooks;
+    }
+}
+export { NormalModule } from "@rspack/binding";

package/dist/NormalModuleFactory.d.ts

@@ -0,0 +1,23 @@
+import type binding from "@rspack/binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import type { ResolveData, ResourceDataWithData } from "./Module";
+import type { ResolverFactory } from "./ResolverFactory";
+export type NormalModuleCreateData = binding.JsNormalModuleFactoryCreateModuleArgs & {
+    settings: {};
+};
+export declare class NormalModuleFactory {
+    hooks: {
+        resolveForScheme: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[ResourceDataWithData], true | void>>;
+        beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        factorize: liteTapable.AsyncSeriesBailHook<[ResolveData], void>;
+        resolve: liteTapable.AsyncSeriesBailHook<[ResolveData], void>;
+        afterResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        createModule: liteTapable.AsyncSeriesBailHook<[
+            NormalModuleCreateData,
+            {}
+        ], void>;
+    };
+    resolverFactory: ResolverFactory;
+    constructor(resolverFactory: ResolverFactory);
+    getResolver(type: string, resolveOptions: Parameters<ResolverFactory["get"]>[1]): import("./Resolver").Resolver;
+}

package/dist/Resolver.d.ts

@@ -0,0 +1,24 @@
+import type binding from "@rspack/binding";
+import { type Resolve } from "./config";
+import type { ResolveCallback } from "./config/adapterRuleUse";
+type ResolveContext = {};
+type ResolveOptionsWithDependencyType = Resolve & {
+    dependencyCategory?: string;
+    resolveToContext?: boolean;
+};
+export type ResourceData = binding.JsResourceData;
+export interface ResolveRequest {
+    path: string;
+    query: string;
+    fragment: string;
+    descriptionFileData?: string;
+    descriptionFilePath?: string;
+}
+export declare class Resolver {
+    #private;
+    constructor(binding: binding.JsResolver);
+    resolveSync(context: object, path: string, request: string): string | false;
+    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void;
+    withOptions(options: ResolveOptionsWithDependencyType): Resolver;
+}
+export {};

package/dist/ResolverFactory.d.ts

@@ -0,0 +1,14 @@
+import binding from "@rspack/binding";
+import { type Resolve } from "./config";
+import { Resolver } from "./Resolver";
+type ResolveOptionsWithDependencyType = Resolve & {
+    dependencyCategory?: string;
+    resolveToContext?: boolean;
+};
+export declare class ResolverFactory {
+    #private;
+    static __to_binding(resolver_factory: ResolverFactory): binding.JsResolverFactory;
+    constructor(pnp: boolean);
+    get(type: string, resolveOptions?: ResolveOptionsWithDependencyType): Resolver;
+}
+export {};

package/dist/RspackError.d.ts

@@ -0,0 +1,9 @@
+import type binding from "@rspack/binding";
+export type { RspackError } from "@rspack/binding";
+export type RspackSeverity = binding.JsRspackSeverity;
+export declare class NonErrorEmittedError extends Error {
+    constructor(error: Error);
+}
+export declare class DeadlockRiskError extends Error {
+    constructor(message: string);
+}

package/dist/RuleSetCompiler.d.ts

@@ -0,0 +1,9 @@
+declare class RuleSetCompiler {
+    references: Map<string, any>;
+    /**
+     * builtin references that should be serializable and passed to Rust.
+     */
+    builtinReferences: Map<string, any>;
+    constructor();
+}
+export { RuleSetCompiler };