@rspack/core 1.2.2 → 1.2.4

package/dist/ExportsInfo.d.ts

@@ -1,5 +1,5 @@
 import type { JsExportsInfo } from "@rspack/binding";
-type RuntimeSpec = string | string[] | undefined;
+import type { RuntimeSpec } from "./util/runtime";
 /**
  * Unused: 0
  * OnlyPropertiesUsed: 1

package/dist/Module.d.ts

@@ -1,8 +1,9 @@
-import type { JsCodegenerationResult, JsContextModuleFactoryAfterResolveData, JsContextModuleFactoryBeforeResolveData, JsCreateData, JsFactoryMeta } from "@rspack/binding";
+import type { 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;
@@ -74,6 +75,8 @@ export declare class Module {
     readonly blocks: DependenciesBlock[];
     readonly dependencies: Dependency[];
     readonly useSourceMap: boolean;
+    readonly resourceResolveData: Record<string, any> | undefined;
+    readonly matchResource: string | undefined;
     static __from_binding(binding: JsModule): Module;
     static __to_binding(module: Module): JsModule;
     constructor(module: JsModule);
@@ -81,6 +84,8 @@ export declare class Module {
     identifier(): string;
     nameForCondition(): string | null;
     size(type?: string): number;
+    libIdent(options: JsLibIdentOptions): string | null;
+    emitFile(filename: string, source: Source, assetInfo: AssetInfo): void;
 }
 export declare class CodeGenerationResult {
     #private;

package/dist/ModuleGraph.d.ts

@@ -6,11 +6,15 @@ import { ModuleGraphConnection } from "./ModuleGraphConnection";
 export default class ModuleGraph {
     #private;
     static __from_binding(binding: JsModuleGraph): ModuleGraph;
-    private constructor();
+    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;
 }

package/dist/ModuleGraphConnection.d.ts

@@ -5,6 +5,8 @@ export declare class ModuleGraphConnection {
     #private;
     readonly module: Module | null;
     readonly dependency: Dependency;
+    readonly resolvedModule: Module | null;
+    readonly originModule: Module | null;
     static __from_binding(binding: JsModuleGraphConnection): ModuleGraphConnection;
     static __to_binding(data: ModuleGraphConnection): JsModuleGraphConnection;
     private constructor();

package/dist/NormalModuleFactory.d.ts

@@ -1,6 +1,7 @@
 import type * as 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: {};
 };
@@ -16,5 +17,7 @@ export declare class NormalModuleFactory {
             {}
         ], void>;
     };
-    constructor();
+    resolverFactory: ResolverFactory;
+    constructor(resolverFactory: ResolverFactory);
+    getResolver(type: string, resolveOptions: Parameters<ResolverFactory["get"]>[1]): import("./Resolver").Resolver;
 }

package/dist/builtin-plugin/EnableChunkLoadingPlugin.d.ts

@@ -1,10 +1,26 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/3919c84/lib/javascript/EnableChunkLoadingPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
 import { BuiltinPluginName } from "@rspack/binding";
-export declare const EnableChunkLoadingPlugin: {
+import type { ChunkLoadingType, Compiler } from "../exports";
+declare const EnableChunkLoadingPluginInner: {
     new (type: string): {
         name: BuiltinPluginName;
         _args: [type: string];
         affectedHooks: "done" | "environment" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
-        raw(compiler: import("..").Compiler): import("@rspack/binding").BuiltinPlugin;
-        apply(compiler: import("..").Compiler): void;
+        raw(compiler: Compiler): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: Compiler): void;
     };
 };
+export declare class EnableChunkLoadingPlugin extends EnableChunkLoadingPluginInner {
+    static setEnabled(compiler: Compiler, type: ChunkLoadingType): void;
+    static checkEnabled(compiler: Compiler, type: ChunkLoadingType): void;
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/builtin-plugin/RsdoctorPlugin.d.ts

@@ -0,0 +1,45 @@
+import { BuiltinPluginName, type JsRsdoctorAsset, type JsRsdoctorAssetPatch, type JsRsdoctorChunk, type JsRsdoctorChunkAssets, type JsRsdoctorChunkGraph, type JsRsdoctorChunkModules, type JsRsdoctorDependency, type JsRsdoctorEntrypoint, type JsRsdoctorEntrypointAssets, type JsRsdoctorExportInfo, type JsRsdoctorModule, type JsRsdoctorModuleGraph, type JsRsdoctorModuleGraphModule, type JsRsdoctorModuleIdsPatch, type JsRsdoctorModuleOriginalSource, type JsRsdoctorModuleSourcesPatch, type JsRsdoctorSideEffect, type JsRsdoctorSourcePosition, type JsRsdoctorSourceRange, type JsRsdoctorStatement, type JsRsdoctorVariable } from "@rspack/binding";
+import * as liteTapable from "@rspack/lite-tapable";
+import { Compilation } from "../Compilation";
+import type { Compiler } from "../Compiler";
+import type { CreatePartialRegisters } from "../taps/types";
+export declare namespace RsdoctorPluginData {
+    export type { JsRsdoctorAsset as RsdoctorAsset, JsRsdoctorChunkGraph as RsdoctorChunkGraph, JsRsdoctorModuleGraph as RsdoctorModuleGraph, JsRsdoctorChunk as RsdoctorChunk, JsRsdoctorModule as RsdoctorModule, JsRsdoctorSideEffect as RsdoctorSideEffect, JsRsdoctorExportInfo as RsdoctorExportInfo, JsRsdoctorVariable as RsdoctorVariable, JsRsdoctorDependency as RsdoctorDependency, JsRsdoctorEntrypoint as RsdoctorEntrypoint, JsRsdoctorStatement as RsdoctorStatement, JsRsdoctorSourceRange as RsdoctorSourceRange, JsRsdoctorSourcePosition as RsdoctorSourcePosition, JsRsdoctorModuleGraphModule as RsdoctorModuleGraphModule, JsRsdoctorModuleIdsPatch as RsdoctorModuleIdsPatch, JsRsdoctorModuleOriginalSource as RsdoctorModuleOriginalSource, JsRsdoctorAssetPatch as RsdoctorAssetPatch, JsRsdoctorChunkAssets as RsdoctorChunkAssets, JsRsdoctorEntrypointAssets as RsdoctorEntrypointAssets, JsRsdoctorChunkModules as RsdoctorChunkModules, JsRsdoctorModuleSourcesPatch as RsdoctorModuleSourcesPatch };
+}
+export type RsdoctorPluginOptions = {
+    moduleGraphFeatures?: boolean | Array<"graph" | "ids" | "sources">;
+    chunkGraphFeatures?: boolean | Array<"graph" | "assets">;
+};
+declare const RsdoctorPluginImpl: {
+    new (c?: RsdoctorPluginOptions | undefined): {
+        name: BuiltinPluginName;
+        _args: [c?: RsdoctorPluginOptions | undefined];
+        affectedHooks: "done" | "environment" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
+        raw(compiler: Compiler): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: Compiler): void;
+    };
+};
+export type RsdoctorPluginHooks = {
+    moduleGraph: liteTapable.AsyncSeriesBailHook<[
+        JsRsdoctorModuleGraph
+    ], false | void>;
+    chunkGraph: liteTapable.AsyncSeriesBailHook<[
+        JsRsdoctorChunkGraph
+    ], false | void>;
+    moduleIds: liteTapable.AsyncSeriesBailHook<[
+        JsRsdoctorModuleIdsPatch
+    ], false | void>;
+    moduleSources: liteTapable.AsyncSeriesBailHook<[
+        JsRsdoctorModuleSourcesPatch
+    ], false | void>;
+    assets: liteTapable.AsyncSeriesBailHook<[JsRsdoctorAssetPatch], false | void>;
+};
+declare const RsdoctorPlugin: typeof RsdoctorPluginImpl & {
+    /**
+     * @deprecated Use `getCompilationHooks` instead.
+     */
+    getHooks: (compilation: Compilation) => RsdoctorPluginHooks;
+    getCompilationHooks: (compilation: Compilation) => RsdoctorPluginHooks;
+};
+export declare const createRsdoctorPluginHooksRegisters: CreatePartialRegisters<`RsdoctorPlugin`>;
+export { RsdoctorPlugin };

package/dist/builtin-plugin/SubresourceIntegrityPlugin.d.ts

@@ -0,0 +1,40 @@
+import { BuiltinPluginName, type RawSubresourceIntegrityPluginOptions } from "@rspack/binding";
+import type { Compiler } from "../Compiler";
+export type SubresourceIntegrityHashFunction = "sha256" | "sha384" | "sha512";
+export type SubresourceIntegrityPluginOptions = {
+    hashFuncNames?: [
+        SubresourceIntegrityHashFunction,
+        ...SubresourceIntegrityHashFunction[]
+    ];
+    htmlPlugin?: string | false;
+    enabled?: "auto" | boolean;
+};
+export type NativeSubresourceIntegrityPluginOptions = Omit<RawSubresourceIntegrityPluginOptions, "htmlPlugin"> & {
+    htmlPlugin: string | false;
+};
+/**
+ * Note: This is not a webpack public API, maybe removed in future.
+ * @internal
+ */
+declare const NativeSubresourceIntegrityPlugin: {
+    new (options: NativeSubresourceIntegrityPluginOptions): {
+        name: BuiltinPluginName;
+        _args: [options: NativeSubresourceIntegrityPluginOptions];
+        affectedHooks: "done" | "environment" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
+        raw(compiler: Compiler): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: Compiler): void;
+    };
+};
+export declare class SubresourceIntegrityPlugin extends NativeSubresourceIntegrityPlugin {
+    private integrities;
+    private options;
+    private validateError;
+    constructor(options: SubresourceIntegrityPluginOptions);
+    private isEnabled;
+    private getIntegrityChecksumForAsset;
+    private handleHwpPluginArgs;
+    private handleHwpBodyTags;
+    private processTag;
+    apply(compiler: Compiler): void;
+}
+export {};

package/dist/builtin-plugin/html-plugin/options.d.ts

@@ -5,63 +5,69 @@ export type HtmlRspackPluginOptions = {
     /** The title to use for the generated HTML document. */
     title?: string;
     /**
-     * The file to write the HTML to. You can specify a subdirectory here too (eg: pages/index.html).
-     * @default 'index.html'
+     * The file to write the HTML to. You can specify a subdirectory here too (e.g.: `"pages/index.html"`).
+     * @default "index.html"
      */
     filename?: string | ((entry: string) => string);
     /** The template file path. */
     template?: string;
     /**
-     * The template file content, priority is greater than template.
+     * The template file content, priority is greater than `template` option.
+     *
      * When using a function, pass in the template parameters and use the returned string as the template content.
      */
     templateContent?: string | TemplateRenderFunction;
     /**
      * Allows to overwrite the parameters used in the template.
+     *
      * When using a function, pass in the original template parameters and use the returned object as the final template parameters.
      */
     templateParameters?: Record<string, string> | boolean | TemplateParamFunction;
     /**
-     * The script and link tag inject position in template. Use false to not inject.
-     * If not specified, it will be automatically determined based on scriptLoading.
+     * The script and link tag inject position in template. Use `false` to not inject.
+     * If not specified, it will be automatically determined based on `scriptLoading` value.
+     * @default true
      */
     inject?: boolean | "head" | "body";
-    /** The publicPath used for script and link tags. */
+    /** The public path used for script and link tags. */
     publicPath?: string;
-    /** Inject a [base](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base) tag */
+    /** Inject a [`base`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base) tag. */
     base?: string | {
         href?: string;
         target?: "_self" | "_blank" | "_parent" | "_top";
     };
     /**
-     * Modern browsers support non blocking javascript loading ('defer') to improve the page startup performance.
-     * Setting to 'module' adds attribute type='module'.
-     * This also implies 'defer', since modules are automatically deferred.
-     * @default 'defer'
+     * Modern browsers support non-blocking JavaScript loading ([`defer` attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#defer)) to improve the page startup performance.
+     *
+     * Setting this option to `'module'` adds attribute `type="module"` to the `script`. This also implies `defer` attribute on the `script`, since modules are automatically deferred.
+     * @default "defer"
      * */
     scriptLoading?: "blocking" | "defer" | "module" | "systemjs-module";
     /** Allows you to add only some chunks. */
     chunks?: string[];
     /** Allows you to skip some chunks. */
     excludeChunks?: string[];
-    /** Allows to control how chunks should be sorted before they are included to the HTML. */
+    /**
+     * Allows to control how chunks should be sorted before they are included to the HTML.
+     * @default "auto"
+     */
     chunksSortMode?: "auto" | "manual";
-    /** The sri hash algorithm, disabled by default. */
+    /** The SRI hash algorithm, disabled by default. */
     sri?: "sha256" | "sha384" | "sha512";
     /**
-     * Controls whether to minify the output.
-     * @default false
+     * Controls whether to minify the output, disabled by default.
      */
     minify?: boolean;
     /** Adds the given favicon path to the output HTML. */
     favicon?: string;
     /**
-     * If true then append a unique rspack compilation hash to all included scripts and CSS files.
-     * This is useful for cache busting
-     * @default false
-     * */
+     * Allows to inject meta-tags.
+     * @default {}
+     */
     meta?: Record<string, string | Record<string, string>>;
-    /** Inject a base tag */
+    /**
+     * If `true` then append a unique Rspack compilation hash to all included scripts and CSS files. This is useful for cache busting.
+     */
     hash?: boolean;
 };
 export declare function validateHtmlPluginOptions(options: HtmlRspackPluginOptions): void;

package/dist/builtin-plugin/index.d.ts

@@ -70,3 +70,5 @@ export * from "./ContextReplacementPlugin";
 export * from "./LibManifestPlugin";
 export * from "./DllEntryPlugin";
 export * from "./DllReferenceAgencyPlugin";
+export * from "./RsdoctorPlugin";
+export * from "./SubresourceIntegrityPlugin";

package/dist/builtin-plugin/lazy-compilation/backend.d.ts

@@ -1,7 +1,16 @@
 import type { IncomingMessage, ServerOptions as ServerOptionsImport, ServerResponse } from "node:http";
-import type { ListenOptions, Server } from "node:net";
+import type { AddressInfo, ListenOptions, Socket } from "node:net";
 import type { SecureContextOptions, TlsOptions } from "node:tls";
 import type { Compiler } from "../..";
+interface Server {
+    on(event: "request", callback: (req: IncomingMessage, res: ServerResponse) => void): void;
+    on(event: "connection", callback: (socket: Socket) => void): void;
+    on(event: "listening", callback: (err?: Error) => void): void;
+    off(event: "request", callback: (req: IncomingMessage, res: ServerResponse) => void): void;
+    address(): AddressInfo;
+    close(callback: (err?: any) => void): void;
+    listen(listenOptions?: number | ListenOptions): void;
+}
 export interface LazyCompilationDefaultBackendOptions {
     /**
      * A custom client script path.
@@ -23,7 +32,7 @@ export interface LazyCompilationDefaultBackendOptions {
 export type ServerOptionsHttps<Request extends typeof IncomingMessage = typeof IncomingMessage, Response extends typeof ServerResponse = typeof ServerResponse> = SecureContextOptions & TlsOptions & ServerOptionsImport<Request, Response>;
 declare const getBackend: (options: Omit<LazyCompilationDefaultBackendOptions, "client"> & {
     client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>;
-}) => (compiler: Compiler, callback: (err: any, obj?: {
+}) => (compiler: Compiler, callback: (err: Error | null, obj?: {
     dispose: (callback: (err: any) => void) => void;
     module: (args: {
         module: string;

package/dist/config/defaults.d.ts

@@ -10,3 +10,4 @@
 import type { RspackOptionsNormalized } from "./normalization";
 export declare const applyRspackOptionsDefaults: (options: RspackOptionsNormalized) => void;
 export declare const applyRspackOptionsBaseDefaults: (options: RspackOptionsNormalized) => void;
+export declare const getPnpDefault: () => boolean;

package/dist/config/types.d.ts

@@ -1,8 +1,10 @@
 import type { JsAssetInfo, RawFuncUseCtx } from "@rspack/binding";
 import type * as webpackDevServer from "webpack-dev-server";
+import type { ChunkGraph } from "../ChunkGraph";
 import type { Compilation, PathData } from "../Compilation";
 import type { Compiler } from "../Compiler";
 import type { Module } from "../Module";
+import type ModuleGraph from "../ModuleGraph";
 import type { LazyCompilationDefaultBackendOptions } from "../builtin-plugin/lazy-compilation/backend";
 import type { Chunk } from "../exports";
 export type FilenameTemplate = string;
@@ -1545,6 +1547,8 @@ type SharedOptimizationSplitChunksCacheGroup = {
      * @default false
      * */
     name?: false | OptimizationSplitChunksName;
+    /** Allows to override the filename when and only when it's an initial chunk. */
+    filename?: Filename;
     /**
      * Minimum size, in bytes, for a chunk to be generated.
      *
@@ -1575,10 +1579,14 @@ type SharedOptimizationSplitChunksCacheGroup = {
      */
     automaticNameDelimiter?: string;
 };
+export type OptimizationSplitChunksCacheGroupTestFn = (module: Module, ctx: {
+    chunkGraph: ChunkGraph;
+    moduleGraph: ModuleGraph;
+}) => boolean;
 /** How to splitting chunks. */
 export type OptimizationSplitChunksCacheGroup = {
     /** Controls which modules are selected by this cache group. */
-    test?: string | RegExp | ((module: Module) => unknown);
+    test?: string | RegExp | OptimizationSplitChunksCacheGroupTestFn;
     /**
      * A module can belong to multiple cache groups.
      * @default -20
@@ -1588,8 +1596,6 @@ export type OptimizationSplitChunksCacheGroup = {
      * Tells Rspack to ignore `splitChunks.minSize`, `splitChunks.minChunks`, `splitChunks.maxAsyncRequests` and `splitChunks.maxInitialRequests` options and always create chunks for this cache group.
      */
     enforce?: boolean;
-    /** Allows to override the filename when and only when it's an initial chunk. */
-    filename?: Filename;
     /**
      * Whether to reuse existing chunks when possible.
      * @default false
@@ -1599,6 +1605,10 @@ export type OptimizationSplitChunksCacheGroup = {
     type?: string | RegExp;
     /** Sets the hint for chunk id. It will be added to chunk's filename. */
     idHint?: string;
+    /**
+     * Assign modules to a cache group by module layer.
+     */
+    layer?: string | ((layer?: string) => boolean) | RegExp;
 } & SharedOptimizationSplitChunksCacheGroup;
 /** Tell Rspack how to splitting chunks. */
 export type OptimizationSplitChunksOptions = {