@rspack/core 1.0.12 → 1.0.14

package/dist/container/ModuleFederationRuntimePlugin.d.ts

@@ -4,7 +4,7 @@ export declare const ModuleFederationRuntimePlugin: {
         name: BuiltinPluginName;
         _args: [];
         affectedHooks: "done" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
-        raw(compiler: import("../Compiler").Compiler): import("@rspack/binding").BuiltinPlugin;
-        apply(compiler: import("../Compiler").Compiler): void;
+        raw(compiler: import("..").Compiler): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
     };
 };

package/dist/exports.d.ts

@@ -10,7 +10,7 @@ import { RspackOptionsApply } from "./rspackOptionsApply";
 export { RspackOptionsApply, RspackOptionsApply as WebpackOptionsApply };
 export type { Chunk } from "./Chunk";
 export type { ChunkGroup } from "./ChunkGroup";
-export type { Module } from "./Module";
+export type { Module, ResolveData } from "./Module";
 export { MultiStats } from "./MultiStats";
 export { NormalModule } from "./NormalModule";
 export type { NormalModuleFactory } from "./NormalModuleFactory";
@@ -37,7 +37,7 @@ export type * from "./config";
 import { ValidationError } from "./util/validate";
 export { ValidationError };
 export declare const util: {
-    createHash: (algorithm: (string & {}) | "debug" | "xxhash64" | "md4" | "native-md4" | (new () => import("./util/hash").default)) => import("./util/hash").default;
+    createHash: (algorithm: "debug" | "xxhash64" | "md4" | "native-md4" | (string & {}) | (new () => import("./util/hash").default)) => import("./util/hash").default;
     cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
 };
 export { default as EntryOptionPlugin } from "./lib/EntryOptionPlugin";

package/dist/index.js

@@ -9121,7 +9121,7 @@ var RuntimeGlobals = {
    */
   compatGetDefaultExport: "__webpack_require__.n",
   /**
-   * harmony module decorator
+   * ES modules decorator
    */
   harmonyModuleDecorator: "__webpack_require__.hmd",
   /**
@@ -11587,9 +11587,10 @@ function getRawIncremental(incremental2) {
     emitAssets: incremental2.emitAssets,
     inferAsyncModules: incremental2.inferAsyncModules,
     providedExports: incremental2.providedExports,
-    moduleHashes: incremental2.moduleHashes,
-    moduleCodegen: incremental2.moduleCodegen,
-    moduleRuntimeRequirements: incremental2.moduleRuntimeRequirements
+    dependenciesDiagnostics: incremental2.dependenciesDiagnostics,
+    modulesHashes: incremental2.modulesHashes,
+    modulesCodegen: incremental2.modulesCodegen,
+    modulesRuntimeRequirements: incremental2.modulesRuntimeRequirements
   };
 }
 function getRawRspackFutureOptions(future) {
@@ -12796,9 +12797,10 @@ var applyExperimentsDefaults = (experiments3) => {
     D(experiments3.incremental, "emitAssets", true);
     D(experiments3.incremental, "inferAsyncModules", false);
     D(experiments3.incremental, "providedExports", false);
-    D(experiments3.incremental, "moduleHashes", false);
-    D(experiments3.incremental, "moduleCodegen", false);
-    D(experiments3.incremental, "moduleRuntimeRequirements", false);
+    D(experiments3.incremental, "dependenciesDiagnostics", false);
+    D(experiments3.incremental, "modulesHashes", false);
+    D(experiments3.incremental, "modulesCodegen", false);
+    D(experiments3.incremental, "modulesRuntimeRequirements", false);
   }
   D(experiments3, "rspackFuture", {});
 };
@@ -13746,7 +13748,16 @@ var getNormalizedRspackOptions = (config2) => {
       ),
       incremental: optionalNestedConfig(
         experiments3.incremental,
-        (options) => options === true ? {} : options
+        (options) => options === true ? {
+          make: true,
+          emitAssets: true,
+          dependenciesDiagnostics: true,
+          inferAsyncModules: true,
+          providedExports: true,
+          modulesHashes: true,
+          modulesCodegen: true,
+          modulesRuntimeRequirements: true
+        } : options
       )
     })),
     watch: config2.watch,
@@ -14126,7 +14137,9 @@ var ruleSetLoaderWithOptions = import_zod.z.strictObject({
   loader: ruleSetLoader,
   options: ruleSetLoaderOptions.optional()
 });
-var ruleSetUseItem = ruleSetLoader.or(ruleSetLoaderWithOptions);
+var ruleSetUseItem = ruleSetLoader.or(
+  ruleSetLoaderWithOptions
+);
 var ruleSetUse = ruleSetUseItem.or(ruleSetUseItem.array()).or(
   import_zod.z.function().args(import_zod.z.custom()).returns(ruleSetUseItem.array())
 );
@@ -14159,7 +14172,9 @@ var ruleSetRule = baseRuleSetRule.extend({
   oneOf: import_zod.z.lazy(() => ruleSetRule.array()).optional(),
   rules: import_zod.z.lazy(() => ruleSetRule.array()).optional()
 });
-var ruleSetRules = import_zod.z.array(import_zod.z.literal("...").or(ruleSetRule).or(falsy));
+var ruleSetRules = import_zod.z.array(
+  import_zod.z.literal("...").or(ruleSetRule).or(falsy)
+);
 var assetParserDataUrlOptions = import_zod.z.strictObject({
   maxSize: import_zod.z.number().optional()
 });
@@ -14226,7 +14241,9 @@ var parserOptionsByModuleTypeKnown = import_zod.z.strictObject({
   "javascript/dynamic": javascriptParserOptions.optional(),
   "javascript/esm": javascriptParserOptions.optional()
 });
-var parserOptionsByModuleTypeUnknown = import_zod.z.record(import_zod.z.record(import_zod.z.any()));
+var parserOptionsByModuleTypeUnknown = import_zod.z.record(
+  import_zod.z.record(import_zod.z.any())
+);
 var parserOptionsByModuleType = parserOptionsByModuleTypeKnown.or(
   parserOptionsByModuleTypeUnknown
 );
@@ -14288,12 +14305,16 @@ var generatorOptionsByModuleTypeKnown = import_zod.z.strictObject({
   "css/auto": cssAutoGeneratorOptions.optional(),
   "css/module": cssModuleGeneratorOptions.optional()
 });
-var generatorOptionsByModuleTypeUnknown = import_zod.z.record(import_zod.z.record(import_zod.z.any()));
+var generatorOptionsByModuleTypeUnknown = import_zod.z.record(
+  import_zod.z.record(import_zod.z.any())
+);
 var generatorOptionsByModuleType = generatorOptionsByModuleTypeKnown.or(
   generatorOptionsByModuleTypeUnknown
 );
 var noParseOptionSingle = import_zod.z.string().or(import_zod.z.instanceof(RegExp)).or(import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean()));
-var noParseOption = noParseOptionSingle.or(import_zod.z.array(noParseOptionSingle));
+var noParseOption = noParseOptionSingle.or(
+  import_zod.z.array(noParseOptionSingle)
+);
 var moduleOptions = import_zod.z.strictObject({
   defaultRules: ruleSetRules.optional(),
   rules: ruleSetRules.optional(),
@@ -14370,7 +14391,11 @@ var allowTarget = import_zod.z.union([
     (value) => typeof value === "string" && /^browserslist:(.+)$/.test(value)
   )
 ]);
-var target = import_zod.z.union([import_zod.z.literal(false), allowTarget, allowTarget.array()]);
+var target = import_zod.z.union([
+  import_zod.z.literal(false),
+  allowTarget,
+  allowTarget.array()
+]);
 var externalsType = import_zod.z.enum([
   "var",
   "module",
@@ -14432,7 +14457,9 @@ var externalsPresets = import_zod.z.strictObject({
   electronRenderer: import_zod.z.boolean().optional(),
   nwjs: import_zod.z.boolean().optional()
 });
-var filterItemTypes = import_zod.z.instanceof(RegExp).or(import_zod.z.string()).or(import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean()));
+var filterItemTypes = import_zod.z.instanceof(RegExp).or(import_zod.z.string()).or(
+  import_zod.z.function().args(import_zod.z.string()).returns(import_zod.z.boolean())
+);
 var filterTypes = filterItemTypes.array().or(filterItemTypes);
 var infrastructureLogging = import_zod.z.strictObject({
   appendOnly: import_zod.z.boolean().optional(),
@@ -14478,7 +14505,9 @@ var nodeOptions = import_zod.z.strictObject({
 });
 var node = import_zod.z.literal(false).or(nodeOptions);
 var loader = import_zod.z.record(import_zod.z.string(), import_zod.z.any());
-var snapshotOptions = import_zod.z.strictObject({});
+var snapshotOptions = import_zod.z.strictObject(
+  {}
+);
 var cacheOptions = import_zod.z.boolean();
 var statsPresets = import_zod.z.enum([
   "normal",
@@ -14690,9 +14719,10 @@ var incremental = import_zod.z.strictObject({
   emitAssets: import_zod.z.boolean().optional(),
   inferAsyncModules: import_zod.z.boolean().optional(),
   providedExports: import_zod.z.boolean().optional(),
-  moduleHashes: import_zod.z.boolean().optional(),
-  moduleCodegen: import_zod.z.boolean().optional(),
-  moduleRuntimeRequirements: import_zod.z.boolean().optional()
+  dependenciesDiagnostics: import_zod.z.boolean().optional(),
+  modulesHashes: import_zod.z.boolean().optional(),
+  modulesCodegen: import_zod.z.boolean().optional(),
+  modulesRuntimeRequirements: import_zod.z.boolean().optional()
 });
 var experiments = import_zod.z.strictObject({
   lazyCompilation: import_zod.z.boolean().optional().or(lazyCompilationOptions),
@@ -15462,7 +15492,7 @@ HtmlRspackPlugin.getCompilationOptions = (compilation) => {
   }
   return compilationOptionsMap.get(compilation);
 };
-HtmlRspackPlugin.getCompilationHooks = (compilation) => {
+HtmlRspackPlugin.getHooks = HtmlRspackPlugin.getCompilationHooks = (compilation) => {
   if (!(compilation instanceof Compilation)) {
     throw new TypeError(
       "The 'compilation' argument must be an instance of Compilation"
@@ -15486,6 +15516,7 @@ HtmlRspackPlugin.getCompilationHooks = (compilation) => {
   }
   return hooks;
 };
+HtmlRspackPlugin.version = 5;
 
 // src/builtin-plugin/HttpExternalsRspackPlugin.ts
 var import_binding39 = require("@rspack/binding");

package/dist/lib/HookWebpackError.d.ts

@@ -31,7 +31,7 @@ export declare const makeWebpackError: (error: Error, hook: string) => WebpackEr
  * @param hook name of hook
  * @returns generic callback
  */
-export declare const makeWebpackErrorCallback: <T>(callback: (error?: WebpackError | null, result?: T | undefined) => void, hook: string) => Callback<Error, T>;
+export declare const makeWebpackErrorCallback: <T>(callback: (error?: WebpackError | null, result?: T) => void, hook: string) => Callback<Error, T>;
 /**
  * @param fn function which will be wrapping in try catch
  * @param hook name of hook

package/dist/lib/WebpackError.d.ts

@@ -7,7 +7,6 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-/// <reference types="node" />
 import { inspect } from "node:util";
 import type { Chunk } from "../Chunk";
 import type { Module } from "../Module";

package/dist/node/nodeConsole.d.ts

@@ -7,7 +7,6 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-/// <reference types="node" />
 import type { LoggerConsole } from "../logging/createConsoleLogger";
 export default function ({ colors, appendOnly, stream }: {
     colors?: boolean;

package/dist/stats/statsFactoryUtils.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type * as binding from "@rspack/binding";
 import type { JsOriginRecord } from "@rspack/binding";
 import type { Compilation } from "../Compilation";
@@ -273,7 +272,7 @@ export declare const spaceLimited: (itemsAndGroups: ItemChildren, max: number, f
     filteredChildren: any;
 };
 export declare const countWithChildren: (compilation: Compilation, getItems: (compilation: Compilation, key: string) => any[]) => number;
-export declare const sortByField: (field: string) => (a1: Object, a2: Object) => number;
+export declare const sortByField: (field: string) => ((a1: Object, a2: Object) => number);
 export declare const assetGroup: (children: StatsAsset[]) => {
     size: number;
 };

package/dist/util/fs.d.ts

@@ -7,9 +7,6 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import type { Abortable } from "node:events";
 import type { WatchOptions } from "../config";
 export interface Watcher {

package/dist/util/hash/BatchedHash.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 /**
  * The following code is modified based on
  * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/hash/BatchedHash.js

package/dist/util/hash/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export default class Hash {
     /**
      * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}

package/dist/util/hash/wasm-hash.d.ts

@@ -7,7 +7,6 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-/// <reference types="node" />
 export declare const MAX_SHORT_STRING: number;
 type Exports = WebAssembly.Instance["exports"] & {
     init: () => void;

package/dist/util/identifier.d.ts

@@ -11,13 +11,13 @@ export declare const makePathsRelative: {
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string, string): string} cached function
      */
-    bindCache(associatedObjectForCache: object | undefined): (arg0: string, arg1: string) => string;
+    bindCache(associatedObjectForCache: object | undefined): ((arg0: string, arg1: string) => string);
     /**
      * @param {string} context context used to create relative path
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string): string} cached function
      */
-    bindContextCache(context: string, associatedObjectForCache: object | undefined): (arg0: string) => string;
+    bindContextCache(context: string, associatedObjectForCache: object | undefined): ((arg0: string) => string);
 };
 export declare const makePathsAbsolute: {
     (context: string, identifier: string, associatedObjectForCache: object | undefined): string;
@@ -25,13 +25,13 @@ export declare const makePathsAbsolute: {
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string, string): string} cached function
      */
-    bindCache(associatedObjectForCache: object | undefined): (arg0: string, arg1: string) => string;
+    bindCache(associatedObjectForCache: object | undefined): ((arg0: string, arg1: string) => string);
     /**
      * @param {string} context context used to create relative path
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string): string} cached function
      */
-    bindContextCache(context: string, associatedObjectForCache: object | undefined): (arg0: string) => string;
+    bindContextCache(context: string, associatedObjectForCache: object | undefined): ((arg0: string) => string);
 };
 export declare const contextify: {
     (context: string, identifier: string, associatedObjectForCache: object | undefined): string;
@@ -39,13 +39,13 @@ export declare const contextify: {
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string, string): string} cached function
      */
-    bindCache(associatedObjectForCache: object | undefined): (arg0: string, arg1: string) => string;
+    bindCache(associatedObjectForCache: object | undefined): ((arg0: string, arg1: string) => string);
     /**
      * @param {string} context context used to create relative path
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string): string} cached function
      */
-    bindContextCache(context: string, associatedObjectForCache: object | undefined): (arg0: string) => string;
+    bindContextCache(context: string, associatedObjectForCache: object | undefined): ((arg0: string) => string);
 };
 export declare const absolutify: {
     (context: string, identifier: string, associatedObjectForCache: object | undefined): string;
@@ -53,13 +53,13 @@ export declare const absolutify: {
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string, string): string} cached function
      */
-    bindCache(associatedObjectForCache: object | undefined): (arg0: string, arg1: string) => string;
+    bindCache(associatedObjectForCache: object | undefined): ((arg0: string, arg1: string) => string);
     /**
      * @param {string} context context used to create relative path
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string): string} cached function
      */
-    bindContextCache(context: string, associatedObjectForCache: object | undefined): (arg0: string) => string;
+    bindContextCache(context: string, associatedObjectForCache: object | undefined): ((arg0: string) => string);
 };
 export declare const parseResource: {
     (str: string, associatedObjectForCache?: object): ParsedResource;

package/dist/util/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { JsRspackError, JsStatsError } from "@rspack/binding";
 import type { LoaderObject } from "../loader-runner";
 export declare function mapValues(record: Record<string, string>, fn: (key: string) => string): {

package/dist/util/memoize.d.ts

@@ -1,3 +1,3 @@
-export declare const memoize: <T>(fn: () => T) => () => T;
+export declare const memoize: <T>(fn: () => T) => (() => T);
 export declare const memoizeFn: <const T extends readonly unknown[], const P>(fn: () => (...args: T) => P) => (...args: T) => P;
 export declare function memoizeValue<T>(fn: () => T): T;

package/dist/util/webpack.d.ts

@@ -1,4 +1,4 @@
 declare const _default: {
-    readonly createHash: (algorithm: (string & {}) | "debug" | "xxhash64" | "md4" | "native-md4" | (new () => import("./hash").default)) => import("./hash").default;
+    readonly createHash: (algorithm: "debug" | "xxhash64" | "md4" | "native-md4" | (string & {}) | (new () => import("./hash").default)) => import("./hash").default;
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -50,7 +50,7 @@
     "prebundle": "^1.1.0",
     "tsc-alias": "^1.8.8",
     "tsup": "^8.3.0",
-    "typescript": "5.0.2",
+    "typescript": "^5.6.3",
     "watchpack": "^2.4.0",
     "webpack-dev-server": "5.0.4",
     "webpack-sources": "3.2.3",
@@ -61,7 +61,7 @@
     "@module-federation/runtime-tools": "0.5.1",
     "@rspack/lite-tapable": "1.0.1",
     "caniuse-lite": "^1.0.30001616",
-    "@rspack/binding": "1.0.12"
+    "@rspack/binding": "1.0.14"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"