@rspack/core 1.2.6 → 1.2.7

package/dist/Compilation.d.ts

@@ -8,7 +8,8 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import type * as binding from "@rspack/binding";
-import { type ExternalObject, type JsCompilation, type JsRuntimeModule } from "@rspack/binding";
+import { type AssetInfo, type Dependency, type ExternalObject, type JsCompilation, type JsRuntimeModule } from "@rspack/binding";
+export type { AssetInfo } from "@rspack/binding";
 import * as liteTapable from "@rspack/lite-tapable";
 import type { Source } from "../compiled/webpack-sources";
 import { Chunk } from "./Chunk";
@@ -16,7 +17,6 @@ import { ChunkGraph } from "./ChunkGraph";
 import { ChunkGroup } from "./ChunkGroup";
 import type { Compiler } from "./Compiler";
 import type { ContextModuleFactory } from "./ContextModuleFactory";
-import { Dependency } from "./Dependency";
 import { Entrypoint } from "./Entrypoint";
 import { type CodeGenerationResult, Module } from "./Module";
 import ModuleGraph from "./ModuleGraph";
@@ -31,10 +31,8 @@ import WebpackError from "./lib/WebpackError";
 import { Logger } from "./logging/Logger";
 import { StatsFactory } from "./stats/StatsFactory";
 import { StatsPrinter } from "./stats/StatsPrinter";
-import { type AssetInfo } from "./util/AssetInfo";
 import type { InputFileSystem } from "./util/fs";
 import type Hash from "./util/hash";
-export type { AssetInfo } from "./util/AssetInfo";
 export type Assets = Record<string, Source>;
 export interface Asset {
     name: string;
@@ -241,7 +239,7 @@ export declare class Compilation {
     /**
      * Update an existing asset. Trying to update an asset that doesn't exist will throw an error.
      */
-    updateAsset(filename: string, newSourceOrFunction: Source | ((source: Source) => Source), assetInfoUpdateOrFunction?: AssetInfo | ((assetInfo: AssetInfo) => AssetInfo)): void;
+    updateAsset(filename: string, newSourceOrFunction: Source | ((source: Source) => Source), assetInfoUpdateOrFunction?: AssetInfo | ((assetInfo: AssetInfo) => AssetInfo | undefined)): void;
     /**
      * Emit an not existing asset. Trying to emit an asset that already exists will throw an error.
      *

package/dist/Compiler.d.ts

@@ -128,8 +128,12 @@ declare class Compiler {
     watch(watchOptions: Watchpack.WatchOptions, handler: liteTapable.Callback<Error, Stats>): Watching;
     /**
      * @param callback - signals when the call finishes
+     * @param options - additional data like modifiedFiles, removedFiles
      */
-    run(callback: liteTapable.Callback<Error, Stats>): void;
+    run(callback: liteTapable.Callback<Error, Stats>, options?: {
+        modifiedFiles?: ReadonlySet<string>;
+        removedFiles?: ReadonlySet<string>;
+    }): void;
     runAsChild(callback: (err?: null | Error, entries?: Chunk[], compilation?: Compilation) => any): void;
     purgeInputFileSystem(): void;
     /**
@@ -142,6 +146,11 @@ declare class Compiler {
      */
     createChildCompiler(compilation: Compilation, compilerName: string, compilerIndex: number, outputOptions: OutputNormalized, plugins: RspackPluginInstance[]): Compiler;
     isChild(): boolean;
+    /**
+     * Create a compilation and run it, which is the basic method that `compiler.run` and `compiler.watch` depend on.
+     * TODO: make this method private in the next major release
+     * @private this method is only used in Rspack core
+     */
     compile(callback: liteTapable.Callback<Error, Compilation>): void;
     close(callback: (error?: Error | null) => void): void;
     /**

package/dist/DependenciesBlock.d.ts

@@ -1,5 +1,4 @@
-import type { JsDependenciesBlock } from "@rspack/binding";
-import { Dependency } from "./Dependency";
+import type { Dependency, JsDependenciesBlock } from "@rspack/binding";
 export declare class DependenciesBlock {
     #private;
     readonly dependencies: Dependency[];

package/dist/Module.d.ts

@@ -1,9 +1,7 @@
-import type { JsCodegenerationResult, JsContextModuleFactoryAfterResolveData, JsContextModuleFactoryBeforeResolveData, JsCreateData, JsFactoryMeta, JsLibIdentOptions } from "@rspack/binding";
+import type { AssetInfo, Dependency, JsCodegenerationResult, JsContextModuleFactoryAfterResolveData, JsContextModuleFactoryBeforeResolveData, JsCreateData, JsFactoryMeta, JsLibIdentOptions } from "@rspack/binding";
 import type { JsModule } from "@rspack/binding";
 import type { Source } from "../compiled/webpack-sources";
 import { DependenciesBlock } from "./DependenciesBlock";
-import { Dependency } from "./Dependency";
-import { type AssetInfo } from "./util/AssetInfo";
 export type ResourceData = {
     resource: string;
     path: string;
@@ -16,7 +14,7 @@ export type ResourceDataWithData = ResourceData & {
 export type CreateData = Partial<JsCreateData>;
 export type ContextInfo = {
     issuer: string;
-    issuerLayer?: string;
+    issuerLayer?: string | null;
 };
 export type ResolveData = {
     contextInfo: ContextInfo;
@@ -85,7 +83,7 @@ export declare class Module {
     nameForCondition(): string | null;
     size(type?: string): number;
     libIdent(options: JsLibIdentOptions): string | null;
-    emitFile(filename: string, source: Source, assetInfo: AssetInfo): void;
+    emitFile(filename: string, source: Source, assetInfo?: AssetInfo): void;
 }
 export declare class CodeGenerationResult {
     #private;

package/dist/ModuleGraph.d.ts

@@ -1,5 +1,4 @@
-import type { JsModuleGraph } from "@rspack/binding";
-import { Dependency } from "./Dependency";
+import type { Dependency, JsModuleGraph } from "@rspack/binding";
 import { ExportsInfo } from "./ExportsInfo";
 import { Module } from "./Module";
 import { ModuleGraphConnection } from "./ModuleGraphConnection";
@@ -17,4 +16,5 @@ export default class ModuleGraph {
     getIncomingConnections(module: Module): ModuleGraphConnection[];
     getParentBlockIndex(dependency: Dependency): number;
     isAsync(module: Module): boolean;
+    getOutgoingConnectionsInOrder(module: Module): ModuleGraphConnection[];
 }

package/dist/ModuleGraphConnection.d.ts

@@ -1,5 +1,4 @@
-import type { JsModuleGraphConnection } from "@rspack/binding";
-import { Dependency } from "./Dependency";
+import type { Dependency, JsModuleGraphConnection } from "@rspack/binding";
 import { Module } from "./Module";
 export declare class ModuleGraphConnection {
     #private;

package/dist/MultiCompiler.d.ts

@@ -62,7 +62,14 @@ export declare class MultiCompiler {
      * @returns a compiler watcher
      */
     watch(watchOptions: WatchOptions, handler: liteTapable.Callback<Error, MultiStats>): MultiWatching;
-    run(callback: liteTapable.Callback<Error, MultiStats>): void;
+    /**
+     * @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/builtin-plugin/EntryPlugin.d.ts

@@ -1,4 +1,4 @@
-import { BuiltinPluginName, type JsEntryOptions } from "@rspack/binding";
+import { BuiltinPluginName, EntryDependency, type JsEntryOptions } from "@rspack/binding";
 import type { EntryDescriptionNormalized } from "../config";
 /**
  * Options for the `EntryPlugin`.
@@ -24,9 +24,6 @@ declare const OriginEntryPlugin: {
         apply(compiler: import("..").Compiler): void;
     };
 };
-interface EntryDependency {
-    request: string;
-}
 type EntryPluginType = typeof OriginEntryPlugin & {
     createDependency(entry: string): EntryDependency;
 };

package/dist/config/adapterRuleUse.d.ts

@@ -1,4 +1,4 @@
-import type { JsAssetInfo, RawModuleRuleUse, RawOptions } from "@rspack/binding";
+import type { AssetInfo, RawModuleRuleUse, RawOptions } from "@rspack/binding";
 import type { ResolveRequest } from "../../compiled/enhanced-resolve";
 import type { Compilation } from "../Compilation";
 import type { Compiler } from "../Compiler";
@@ -73,21 +73,83 @@ export interface ImportModuleOptions {
     baseUri?: string;
 }
 export interface LoaderContext<OptionsType = {}> {
+    /**
+     * The version number of the loader API. Currently 2.
+     * This is useful for providing backwards compatibility. Using the version you can specify
+     * custom logic or fallbacks for breaking changes.
+     */
     version: 2;
+    /**
+     * The path string of the current module.
+     * @example `'/abc/resource.js?query#hash'`.
+     */
     resource: string;
+    /**
+     * The path string of the current module, excluding the query and fragment parameters.
+     * @example `'/abc/resource.js?query#hash'` in `'/abc/resource.js'`.
+     */
     resourcePath: string;
+    /**
+     * The query parameter for the path string of the current module.
+     * @example `'?query'` in `'/abc/resource.js?query#hash'`.
+     */
     resourceQuery: string;
+    /**
+     * The fragment parameter of the current module's path string.
+     * @example `'#hash'` in `'/abc/resource.js?query#hash'`.
+     */
     resourceFragment: string;
+    /**
+     * Tells Rspack that this loader will be called asynchronously. Returns `this.callback`.
+     */
     async(): LoaderContextCallback;
+    /**
+     * A function that can be called synchronously or asynchronously in order to return multiple
+     * results. The expected arguments are:
+     *
+     * 1. The first parameter must be `Error` or `null`, which marks the current module as a
+     * compilation failure.
+     * 2. The second argument is a `string` or `Buffer`, which indicates the contents of the file
+     * after the module has been processed by the loader.
+     * 3. The third parameter is a source map that can be processed by the loader.
+     * 4. The fourth parameter is ignored by Rspack and can be anything (e.g. some metadata).
+     */
     callback: LoaderContextCallback;
+    /**
+     * A function that sets the cacheable flag.
+     * By default, the processing results of the loader are marked as cacheable.
+     * Calling this method and passing `false` turns off the loader's ability to
+     * cache processing results.
+     */
     cacheable(cacheable?: boolean): void;
+    /**
+     * Tells if source map should be generated. Since generating source maps can be an expensive task,
+     * you should check if source maps are actually requested.
+     */
     sourceMap: boolean;
+    /**
+     * The base path configured in Rspack config via `context`.
+     */
     rootContext: string;
+    /**
+     * The directory path of the currently processed module, which changes with the
+     * location of each processed module.
+     * For example, if the loader is processing `/project/src/components/Button.js`,
+     * then the value of `this.context` would be `/project/src/components`.
+     */
     context: string | null;
+    /**
+     * The index in the loaders array of the current loader.
+     */
     loaderIndex: number;
     remainingRequest: string;
     currentRequest: string;
     previousRequest: string;
+    /**
+     * The module specifier string after being resolved.
+     * For example, if a `resource.js` is processed by `loader1.js` and `loader2.js`, the value of
+     * `this.request` will be `/path/to/loader1.js!/path/to/loader2.js!/path/to/resource.js`.
+     */
     request: string;
     /**
      * An array of all the loaders. It is writeable in the pitch phase.
@@ -108,23 +170,80 @@ export interface LoaderContext<OptionsType = {}> {
      * ]
      */
     loaders: LoaderObject[];
+    /**
+     * The value of `mode` is read when Rspack is run.
+     * The possible values are: `'production'`, `'development'`, `'none'`
+     */
     mode?: Mode;
+    /**
+     * The current compilation target. Passed from `target` configuration options.
+     */
     target?: Target;
+    /**
+     * Whether HMR is enabled.
+     */
     hot?: boolean;
     /**
-     * @param schema To provide the best performance, Rspack does not perform the schema validation. If your loader requires schema validation, please call scheme-utils or zod on your own.
+     * Get the options passed in by the loader's user.
+     * @param schema To provide the best performance, Rspack does not perform the schema
+     * validation. If your loader requires schema validation, please call scheme-utils or
+     * zod on your own.
      */
     getOptions(schema?: any): OptionsType;
+    /**
+     * Resolve a module specifier.
+     * @param context The absolute path to a directory. This directory is used as the starting
+     * location for resolving.
+     * @param request The module specifier to be resolved.
+     * @param callback A callback function that gives the resolved path.
+     */
     resolve(context: string, request: string, callback: (arg0: null | Error, arg1?: string | false, arg2?: ResolveRequest) => void): void;
+    /**
+     * Create a resolver like `this.resolve`.
+     */
     getResolve(options: Resolve): ((context: string, request: string, callback: ResolveCallback) => void) | ((context: string, request: string) => Promise<string | false | undefined>);
+    /**
+     * Get the logger of this compilation, through which messages can be logged.
+     */
     getLogger(name: string): Logger;
+    /**
+     * Emit an error. Unlike `throw` and `this.callback(err)` in the loader, it does not
+     * mark the current module as a compilation failure, it just adds an error to Rspack's
+     * Compilation and displays it on the command line at the end of this compilation.
+     */
     emitError(error: Error): void;
+    /**
+     * Emit a warning.
+     */
     emitWarning(warning: Error): void;
-    emitFile(name: string, content: string | Buffer, sourceMap?: string, assetInfo?: JsAssetInfo): void;
+    /**
+     * Emit a new file. This method allows you to create new files during the loader execution.
+     */
+    emitFile(name: string, content: string | Buffer, sourceMap?: string, assetInfo?: AssetInfo): void;
+    /**
+     * Add a file as a dependency on the loader results so that any changes to them can be listened to.
+     * For example, `sass-loader`, `less-loader` use this trick to recompile when the imported style
+     * files change.
+     */
     addDependency(file: string): void;
+    /**
+     * Alias of `this.addDependency()`.
+     */
     dependency(file: string): void;
+    /**
+     * Add the directory as a dependency for the loader results so that any changes to the
+     * files in the directory can be listened to.
+     */
     addContextDependency(context: string): void;
+    /**
+     * Add a currently non-existent file as a dependency of the loader result, so that its
+     * creation and any changes can be listened. For example, when a new file is created at
+     * that path, it will trigger a rebuild.
+     */
     addMissingDependency(missing: string): void;
+    /**
+     * Removes all dependencies of the loader result.
+     */
     clearDependencies(): void;
     getDependencies(): string[];
     getContextDependencies(): string[];
@@ -145,24 +264,58 @@ export interface LoaderContext<OptionsType = {}> {
      */
     importModule<T = any>(request: string, options: ImportModuleOptions | undefined, callback: (err?: null | Error, exports?: T) => any): void;
     importModule<T = any>(request: string, options?: ImportModuleOptions): Promise<T>;
+    /**
+     * Access to the `compilation` object's `inputFileSystem` property.
+     */
     fs: any;
     /**
      * This is an experimental API and maybe subject to change.
      * @experimental
      */
     experiments: LoaderExperiments;
+    /**
+     * Access to some utilities.
+     */
     utils: {
+        /**
+         * Return a new request string using absolute paths when possible.
+         */
         absolutify: (context: string, request: string) => string;
+        /**
+         * Return a new request string avoiding absolute paths when possible.
+         */
         contextify: (context: string, request: string) => string;
+        /**
+         * Return a new Hash object from provided hash function.
+         */
         createHash: (algorithm?: string) => Hash;
     };
+    /**
+     * The value depends on the loader configuration:
+     * - If the current loader was configured with an options object, `this.query` will
+     * point to that object.
+     * - If the current loader has no options, but was invoked with a query string, this
+     * will be a string starting with `?`.
+     */
     query: string | OptionsType;
+    /**
+     * A data object shared between the pitch and the normal phase.
+     */
     data: unknown;
+    /**
+     * Access to the current Compiler object of Rspack.
+     */
     _compiler: Compiler;
+    /**
+     * Access to the current Compilation object of Rspack.
+     */
     _compilation: Compilation;
+    /**
+     * @deprecated Hacky access to the Module object being loaded.
+     */
     _module: Module;
     /**
-     * Note: This is not a webpack public API, maybe removed in future.
+     * Note: This is not a Rspack public API, maybe removed in future.
      * Store some data from loader, and consume it from parser, it may be removed in the future
      *
      * @internal

package/dist/config/types.d.ts

@@ -1,4 +1,4 @@
-import type { JsAssetInfo, RawFuncUseCtx } from "@rspack/binding";
+import type { AssetInfo, RawFuncUseCtx } from "@rspack/binding";
 import type * as webpackDevServer from "webpack-dev-server";
 import type { ChunkGraph } from "../ChunkGraph";
 import type { Compilation, PathData } from "../Compilation";
@@ -8,7 +8,7 @@ import type ModuleGraph from "../ModuleGraph";
 import type { LazyCompilationDefaultBackendOptions } from "../builtin-plugin/lazy-compilation/backend";
 import type { Chunk } from "../exports";
 export type FilenameTemplate = string;
-export type Filename = FilenameTemplate | ((pathData: PathData, assetInfo?: JsAssetInfo) => string);
+export type Filename = FilenameTemplate | ((pathData: PathData, assetInfo?: AssetInfo) => string);
 /** Name of the configuration. Used when loading multiple configurations. */
 export type Name = string;
 /** A list of name defining all sibling configurations it depends on. Dependent configurations need to be compiled first. */