@rspack/core 0.7.6-canary-f272bd8-20240625122346 → 1.0.0-alpha.0

package/dist/Compiler.js

@@ -77,6 +77,7 @@ const Logger_1 = require("./logging/Logger");
 const util_1 = require("./util");
 const assertNotNil_1 = require("./util/assertNotNil");
 const bindingVersionCheck_1 = require("./util/bindingVersionCheck");
+const createHash_1 = require("./util/createHash");
 const identifier_1 = require("./util/identifier");
 class Compiler {
     constructor(context, options) {
@@ -651,16 +652,27 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
             __classPrivateFieldGet(this, _Compiler_moduleExecutionResultsMap, "f").set(id, executeResult);
         }),
         registerCompilationFinishModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationFinishModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.finishModules, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
-        registerCompilationOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.optimizeModules, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
-        registerCompilationAfterOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterOptimizeModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterOptimizeModules, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
+        registerCompilationOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.optimizeModules, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules.values())),
+        registerCompilationAfterOptimizeModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterOptimizeModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterOptimizeModules, queried => () => {
+            queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").modules.values());
+        }),
         registerCompilationOptimizeTreeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeTree, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.optimizeTree, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").chunks, __classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
         registerCompilationOptimizeChunkModulesTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationOptimizeChunkModules, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.optimizeChunkModules, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").chunks, __classPrivateFieldGet(this, _Compiler_compilation, "f").modules)),
+        registerCompilationChunkHashTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationChunkHash, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.chunkHash, queried => (chunk) => {
+            const hash = (0, createHash_1.createHash)(this.options.output.hashFunction);
+            queried.call(Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")), hash);
+            const digestResult = hash.digest(this.options.output.hashDigest);
+            return Buffer.from(digestResult);
+        }),
         registerCompilationChunkAssetTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationChunkAsset, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.chunkAsset, queried => ({ chunk, filename }) => queried.call(Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")), filename)),
         registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationProcessAssets, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.processAssets, queried => async () => await queried.promise(__classPrivateFieldGet(this, _Compiler_compilation, "f").assets)),
         registerCompilationAfterProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterProcessAssets, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterProcessAssets, queried => () => queried.call(__classPrivateFieldGet(this, _Compiler_compilation, "f").assets)),
         registerCompilationAfterSealTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationAfterSeal, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.afterSeal, queried => async () => await queried.promise()),
         registerNormalModuleFactoryBeforeResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryBeforeResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.beforeResolve, queried => async (resolveData) => {
             const normalizedResolveData = {
+                contextInfo: {
+                    issuer: resolveData.issuer
+                },
                 request: resolveData.request,
                 context: resolveData.context,
                 fileDependencies: [],
@@ -672,6 +684,22 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
             resolveData.context = normalizedResolveData.context;
             return [ret, resolveData];
         }),
+        registerNormalModuleFactoryFactorizeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryFactorize, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.factorize, queried => async (resolveData) => {
+            const normalizedResolveData = {
+                contextInfo: {
+                    issuer: resolveData.issuer
+                },
+                request: resolveData.request,
+                context: resolveData.context,
+                fileDependencies: [],
+                missingDependencies: [],
+                contextDependencies: []
+            };
+            await queried.promise(normalizedResolveData);
+            resolveData.request = normalizedResolveData.request;
+            resolveData.context = normalizedResolveData.context;
+            return resolveData;
+        }),
         registerNormalModuleFactoryResolveForSchemeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookMapRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryResolveForScheme, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.resolveForScheme, queried => async (args) => {
             const ret = await queried
                 .for(args.scheme)
@@ -680,6 +708,9 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
         }),
         registerNormalModuleFactoryAfterResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.NormalModuleFactoryAfterResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").normalModuleFactory.hooks.afterResolve, queried => async (arg) => {
             const data = {
+                contextInfo: {
+                    issuer: arg.issuer
+                },
                 request: arg.request,
                 context: arg.context,
                 fileDependencies: arg.fileDependencies,
@@ -728,6 +759,13 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
                 })
                 : false;
             return result;
+        }),
+        registerJavascriptModulesChunkHashTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.JavascriptModulesChunkHash, () => builtin_plugin_1.JavascriptModulesPlugin.getCompilationHooks(__classPrivateFieldGet(this, _Compiler_compilation, "f"))
+            .chunkHash, queried => (chunk) => {
+            const hash = (0, createHash_1.createHash)(this.options.output.hashFunction);
+            queried.call(Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")), hash);
+            const digestResult = hash.digest(this.options.output.hashDigest);
+            return Buffer.from(digestResult);
         })
     }, "f");
     __classPrivateFieldSet(this, _Compiler_instance, new instanceBinding.Rspack(rawOptions, __classPrivateFieldGet(this, _Compiler_builtinPlugins, "f"), __classPrivateFieldGet(this, _Compiler_registers, "f"), FileSystem_1.ThreadsafeWritableNodeFS.__to_binding(this.outputFileSystem)), "f");

package/dist/Entrypoint.d.ts

@@ -4,5 +4,5 @@ import { ChunkGroup } from "./ChunkGroup";
 export declare class Entrypoint extends ChunkGroup {
     static __from_binding(chunk: JsChunkGroup, compilation: JsCompilation): Entrypoint;
     protected constructor(inner: JsChunkGroup, compilation: JsCompilation);
-    getRuntimeChunk(): Chunk | null;
+    getRuntimeChunk(): Readonly<Chunk | null>;
 }

package/dist/Entrypoint.js

@@ -12,9 +12,9 @@ class Entrypoint extends ChunkGroup_1.ChunkGroup {
         super(inner, compilation);
     }
     getRuntimeChunk() {
-        const c = (0, binding_1.__entrypoint_inner_get_runtime_chunk)(this.__internal_innerUkey(), this.__internal_innerCompilation());
+        const c = (0, binding_1.__entrypoint_inner_get_runtime_chunk)(this.__internal__innerUkey(), this.__internal__innerCompilation());
         if (c)
-            return Chunk_1.Chunk.__from_binding(c, this.__internal_innerCompilation());
+            return Chunk_1.Chunk.__from_binding(c, this.__internal__innerCompilation());
         return null;
     }
 }

package/dist/Module.d.ts

@@ -1,5 +1,5 @@
-import { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsModule } from "@rspack/binding";
-import { Source } from "webpack-sources";
+import { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsFactoryMeta, JsModule } from "@rspack/binding";
+import { Source } from "../compiled/webpack-sources";
 import { Compilation } from "./Compilation";
 export type ResourceData = {
     resource: string;
@@ -11,7 +11,11 @@ export type ResourceDataWithData = ResourceData & {
     data?: Record<string, any>;
 };
 export type CreateData = Partial<JsCreateData>;
+export type ContextInfo = {
+    issuer: string;
+};
 export type ResolveData = {
+    contextInfo: ContextInfo;
     context: string;
     request: string;
     fileDependencies: string[];
@@ -32,11 +36,12 @@ export type ContextModuleFactoryAfterResolveResult = false | {
 };
 export declare class Module {
     #private;
-    context?: string;
-    resource?: string;
-    request?: string;
-    userRequest?: string;
-    rawRequest?: string;
+    context?: Readonly<string>;
+    resource?: Readonly<string>;
+    request?: Readonly<string>;
+    userRequest?: Readonly<string>;
+    rawRequest?: Readonly<string>;
+    factoryMeta?: Readonly<JsFactoryMeta>;
     /**
      * Records the dynamically added fields for Module on the JavaScript side.
      * These fields are generally used within a plugin, so they do not need to be passed back to the Rust side.

package/dist/Module.js

@@ -27,6 +27,7 @@ class Module {
         this.request = module.request;
         this.userRequest = module.userRequest;
         this.rawRequest = module.rawRequest;
+        this.factoryMeta = module.factoryMeta;
         const customModule = compilation?.__internal__getCustomModule(module.moduleIdentifier);
         this.buildInfo = customModule?.buildInfo || {};
         this.buildMeta = customModule?.buildMeta || {};

package/dist/NormalModule.d.ts

@@ -3,7 +3,6 @@ import { AsyncSeriesBailHook, HookMap, SyncHook } from "tapable";
 import { Compilation } from "./Compilation";
 import { LoaderContext } from "./config";
 export declare class NormalModule {
-    constructor();
     static getCompilationHooks(compilation: Compilation): {
         loader: SyncHook<[LoaderContext<{}>], void, import("tapable").UnsetAdditionalOptions>;
         readResourceForScheme: any;

package/dist/NormalModule.js

@@ -46,10 +46,7 @@ const deprecateAllProperties = (obj, message, code) => {
     }
     return newObj;
 };
-// Actually it is just a NormalModule proxy, used for hooks api alignment
-// Maybe we can 1:1 align to webpack NormalModule once we found a better way to reduce communicate overhead between rust and js
 class NormalModule {
-    constructor() { }
     static getCompilationHooks(compilation) {
         if (!(compilation instanceof Compilation_1.Compilation)) {
             throw new TypeError("The 'compilation' argument must be an instance of Compilation");
@@ -58,9 +55,6 @@ class NormalModule {
         if (hooks === undefined) {
             hooks = {
                 loader: new tapable_1.SyncHook(["loaderContext"]),
-                // beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-                // beforeParse: new SyncHook(["module"]),
-                // beforeSnapshot: new SyncHook(["module"]),
                 // TODO webpack 6 deprecate
                 readResourceForScheme: new tapable_1.HookMap(scheme => {
                     const hook = hooks.readResource.for(scheme);
@@ -71,7 +65,6 @@ class NormalModule {
                     });
                 }),
                 readResource: new tapable_1.HookMap(() => new tapable_1.AsyncSeriesBailHook(["loaderContext"]))
-                // needBuild: new AsyncSeriesBailHook(["module", "context"])
             };
             compilationHooksMap.set(compilation, hooks);
         }

package/dist/NormalModuleFactory.d.ts

@@ -8,6 +8,7 @@ export declare class NormalModuleFactory {
     hooks: {
         resolveForScheme: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[ResourceDataWithData], true | void>>;
         beforeResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
+        factorize: liteTapable.AsyncSeriesBailHook<[ResolveData], void>;
         afterResolve: liteTapable.AsyncSeriesBailHook<[ResolveData], false | void>;
         createModule: liteTapable.AsyncSeriesBailHook<[
             NormalModuleCreateData,

package/dist/NormalModuleFactory.js

@@ -28,35 +28,14 @@ const liteTapable = __importStar(require("./lite-tapable"));
 class NormalModuleFactory {
     constructor() {
         this.hooks = {
-            // /** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */
-            // resolve: new AsyncSeriesBailHook(["resolveData"]),
-            // /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
             resolveForScheme: new liteTapable.HookMap(() => new liteTapable.AsyncSeriesBailHook(["resourceData"])),
-            // /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
-            // resolveInScheme: new HookMap(
-            // 	() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
-            // ),
-            // /** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
-            // factorize: new AsyncSeriesBailHook(["resolveData"]),
-            // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
             beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
-            // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
+            factorize: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
             afterResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
-            // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
             createModule: new liteTapable.AsyncSeriesBailHook([
                 "createData",
                 "resolveData"
             ])
-            // /** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
-            // module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
-            // createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
-            // parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
-            // createGenerator: new HookMap(
-            // 	() => new SyncBailHook(["generatorOptions"])
-            // ),
-            // generator: new HookMap(
-            // 	() => new SyncHook(["generator", "generatorOptions"])
-            // )
         };
     }
 }

package/dist/RspackError.d.ts

@@ -0,0 +1,8 @@
+import * as binding from "@rspack/binding";
+export type RspackError = binding.JsRspackError;
+export declare class JsDiagnostic {
+    static __to_binding(error: Error | RspackError, severity: binding.JsRspackSeverity): binding.JsDiagnostic;
+}
+export declare class NonErrorEmittedError extends Error {
+    constructor(error: Error);
+}

package/dist/RspackError.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonErrorEmittedError = exports.JsDiagnostic = void 0;
+const util_1 = require("./util");
+class JsDiagnostic {
+    static __to_binding(error, severity) {
+        return {
+            error: (0, util_1.concatErrorMsgAndStack)(error),
+            severity
+        };
+    }
+}
+exports.JsDiagnostic = JsDiagnostic;
+class NonErrorEmittedError extends Error {
+    constructor(error) {
+        super();
+        this.name = "NonErrorEmittedError";
+        this.message = "(Emitted value instead of an instance of Error) " + error;
+    }
+}
+exports.NonErrorEmittedError = NonErrorEmittedError;

package/dist/Stats.d.ts

@@ -1,4 +1,4 @@
-import { Compilation } from ".";
+import { Compilation } from "./Compilation";
 import { StatsOptions, StatsValue } from "./config";
 import type { StatsCompilation } from "./stats/statsFactoryUtils";
 export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule, StatsWarnings } from "./stats/statsFactoryUtils";
@@ -6,7 +6,7 @@ export declare class Stats {
     #private;
     compilation: Compilation;
     constructor(compilation: Compilation);
-    get hash(): string | null;
+    get hash(): Readonly<string | null>;
     hasErrors(): boolean;
     hasWarnings(): boolean;
     toJson(opts?: StatsValue, forToString?: boolean): StatsCompilation;

package/dist/Template.d.ts

@@ -137,7 +137,7 @@ declare namespace Template {
 }
 type ChunkRenderContext = any;
 type Module = any;
-type Source = import("webpack-sources").Source;
+type Source = import("../compiled/webpack-sources").Source;
 type RuntimeModule = any;
 type RenderContext = any;
 type CodeGenerationResults = any;

package/dist/Template.js

@@ -3,10 +3,10 @@
     Author Tobias Koppers @sokra
 */
 "use strict";
-const { ConcatSource, PrefixSource } = require("webpack-sources");
+const { ConcatSource, PrefixSource } = require("../compiled/webpack-sources");
 const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
-/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../compiled/webpack-sources").Source} Source */
 // /** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {any} OutputOptions */
 // /** @typedef {import("./Chunk")} Chunk */

package/dist/builtin-loader/swc/index.d.ts

@@ -1,11 +1,7 @@
-export type { EmotionOptions } from "./emotion";
-export { resolveEmotion } from "./emotion";
 export { resolvePluginImport } from "./pluginImport";
 export type { PluginImportOptions } from "./pluginImport";
 export type { ReactOptions } from "./react";
 export { resolveReact } from "./react";
 export { resolvePreact } from "./preact";
 export type { PreactOptions } from "./preact";
-export type { RelayOptions } from "./relay";
-export { resolveRelay } from "./relay";
 export type { SwcLoaderEnvConfig, SwcLoaderEsParserConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderOptions, SwcLoaderParserConfig, SwcLoaderTransformConfig, SwcLoaderTsParserConfig } from "./types";

package/dist/builtin-loader/swc/index.js

@@ -1,13 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveRelay = exports.resolvePreact = exports.resolveReact = exports.resolvePluginImport = exports.resolveEmotion = void 0;
-var emotion_1 = require("./emotion");
-Object.defineProperty(exports, "resolveEmotion", { enumerable: true, get: function () { return emotion_1.resolveEmotion; } });
+exports.resolvePreact = exports.resolveReact = exports.resolvePluginImport = void 0;
 var pluginImport_1 = require("./pluginImport");
 Object.defineProperty(exports, "resolvePluginImport", { enumerable: true, get: function () { return pluginImport_1.resolvePluginImport; } });
 var react_1 = require("./react");
 Object.defineProperty(exports, "resolveReact", { enumerable: true, get: function () { return react_1.resolveReact; } });
 var preact_1 = require("./preact");
 Object.defineProperty(exports, "resolvePreact", { enumerable: true, get: function () { return preact_1.resolvePreact; } });
-var relay_1 = require("./relay");
-Object.defineProperty(exports, "resolveRelay", { enumerable: true, get: function () { return relay_1.resolveRelay; } });

package/dist/builtin-loader/swc/preact.d.ts

@@ -1,7 +1,6 @@
 type RawPreactOptions = {
     library?: string;
 };
-type PreactOptions = RawPreactOptions | boolean | undefined;
-declare function resolvePreact(preact: PreactOptions): RawPreactOptions | undefined;
-export { resolvePreact };
-export type { PreactOptions };
+export type PreactOptions = RawPreactOptions | boolean | undefined;
+export declare function resolvePreact(preact: PreactOptions): RawPreactOptions | undefined;
+export {};

package/dist/builtin-loader/swc/types.d.ts

@@ -2,22 +2,9 @@
  * Some types are modified from https://github.com/swc-project/swc/blob/16a38851/packages/types/index.ts#L647
  * license at https://github.com/swc-project/swc/blob/main/LICENSE
  */
-import type { EmotionOptions } from "./emotion";
 import type { PluginImportOptions } from "./pluginImport";
+import type { PreactOptions } from "./preact";
 import type { ReactOptions } from "./react";
-import type { RelayOptions } from "./relay";
-export type StyledComponentsOptions = {
-    displayName?: boolean;
-    ssr?: boolean;
-    fileName?: boolean;
-    meaninglessFileNames?: string[];
-    namespace?: string;
-    topLevelImportPaths?: string[];
-    transpileTemplateLiterals?: boolean;
-    minify?: boolean;
-    pure?: boolean;
-    cssProps?: boolean;
-};
 export type JscTarget = "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "esnext";
 export type SwcLoaderParserConfig = SwcLoaderTsParserConfig | SwcLoaderEsParserConfig;
 export interface SwcLoaderTsParserConfig {
@@ -454,9 +441,7 @@ export type SwcLoaderOptions = {
      * @experimental
      */
     rspackExperiments?: {
-        relay?: RelayOptions;
-        emotion?: EmotionOptions;
         import?: PluginImportOptions;
-        styledComponents?: StyledComponentsOptions;
+        preact?: PreactOptions;
     };
 };

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

@@ -1,6 +1,7 @@
 import { BuiltinPluginName, RawBundlerInfoPluginOptions } from "@rspack/binding";
 export type BundleInfoOptions = {
     version?: string;
+    bundler?: string;
     force?: boolean | string[];
 };
 export declare const BundlerInfoRspackPlugin: {

package/dist/builtin-plugin/BundlerInfoRspackPlugin.js

@@ -6,6 +6,7 @@ const base_1 = require("./base");
 exports.BundlerInfoRspackPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.BundlerInfoRspackPlugin, (options) => {
     return {
         version: options.version || "unknown",
+        bundler: options.bundler || "rspack",
         force: options.force ?? true
     };
 });

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

@@ -1,10 +1,16 @@
-import { BuiltinPluginName } from "@rspack/binding";
-export declare const JavascriptModulesPlugin: {
-    new (): {
-        name: BuiltinPluginName;
-        _options: void;
-        affectedHooks: "make" | "compile" | "emit" | "afterEmit" | "invalid" | "done" | "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(): import("@rspack/binding").BuiltinPlugin;
-        apply(compiler: import("../Compiler").Compiler): void;
-    };
+import { BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
+import { Compilation } from "../Compilation";
+import * as liteTapable from "../lite-tapable";
+import { RspackBuiltinPlugin } from "./base";
+import Hash = require("../util/hash");
+import { Chunk } from "../Chunk";
+export type CompilationHooks = {
+    chunkHash: liteTapable.SyncHook<[Chunk, Hash]>;
 };
+export declare class JavascriptModulesPlugin extends RspackBuiltinPlugin {
+    name: BuiltinPluginName;
+    affectedHooks: "compilation";
+    constructor();
+    raw(): BuiltinPlugin;
+    static getCompilationHooks(compilation: Compilation): CompilationHooks;
+}

package/dist/builtin-plugin/JavascriptModulesPlugin.js

@@ -1,6 +1,55 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavascriptModulesPlugin = void 0;
 const binding_1 = require("@rspack/binding");
+const Compilation_1 = require("../Compilation");
+const liteTapable = __importStar(require("../lite-tapable"));
 const base_1 = require("./base");
-exports.JavascriptModulesPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.JavascriptModulesPlugin, () => { }, "compilation");
+const compilationHooksMap = new WeakMap();
+class JavascriptModulesPlugin extends base_1.RspackBuiltinPlugin {
+    constructor() {
+        super();
+        this.name = binding_1.BuiltinPluginName.JavascriptModulesPlugin;
+        this.affectedHooks = "compilation";
+    }
+    raw() {
+        return (0, base_1.createBuiltinPlugin)(this.name, undefined);
+    }
+    static getCompilationHooks(compilation) {
+        if (!(compilation instanceof Compilation_1.Compilation)) {
+            throw new TypeError("The 'compilation' argument must be an instance of Compilation");
+        }
+        let hooks = compilationHooksMap.get(compilation);
+        if (hooks === undefined) {
+            hooks = {
+                chunkHash: new liteTapable.SyncHook(["chunk", "hash"])
+            };
+            compilationHooksMap.set(compilation, hooks);
+        }
+        return hooks;
+    }
+}
+exports.JavascriptModulesPlugin = JavascriptModulesPlugin;

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

@@ -9,34 +9,6 @@ type ExtractCommentsObject = {
 };
 type ExtractCommentsOptions = ExtractCommentsCondition | ExtractCommentsObject;
 export type SwcJsMinimizerRspackPluginOptions = {
-    /**
-     * @deprecated Deprecated, move to `compress.passes`
-     */
-    passes?: number;
-    /**
-     * @deprecated Deprecated, move to `compress.drop_console`
-     */
-    dropConsole?: boolean;
-    /**
-     * @deprecated Deprecated, move to `compress.pure_funcs`
-     */
-    pureFuncs?: Array<string>;
-    /**
-     * @deprecated Deprecated, move to `mangle.keep_classnames`
-     */
-    keepClassNames?: boolean;
-    /**
-     * @deprecated Deprecated, move to `mangle.keep_fnames`
-     */
-    keepFnNames?: boolean;
-    /**
-     * @deprecated Deprecated, move to `format.comments`
-     */
-    comments?: false | "all" | "some";
-    /**
-     * @deprecated Deprecated, move to `format.ascii_only`
-     */
-    asciiOnly?: boolean;
     extractComments?: ExtractCommentsOptions | undefined;
     compress?: TerserCompressOptions | boolean;
     mangle?: TerserMangleOptions | boolean;

package/dist/builtin-plugin/SwcJsMinimizerPlugin.js

@@ -3,72 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwcJsMinimizerRspackPlugin = void 0;
 const binding_1 = require("@rspack/binding");
 const base_1 = require("./base");
-function getRawCompressOptions(options) {
-    function _inner() {
-        const _default = {
-            passes: options?.passes ?? 1,
-            pure_funcs: options?.pureFuncs ?? [],
-            drop_console: options?.dropConsole ?? false
-        };
-        if (options?.compress === true) {
-            return _default;
-        }
-        if (options?.compress === false) {
-            return false;
-        }
-        if (options?.compress && typeof options.compress === "object") {
-            return {
-                // TODO: deprecate default merging in 0.4
-                ..._default,
-                ...options.compress
-            };
-        }
-        return _default;
-    }
-    let inner = _inner();
-    return typeof inner === "boolean" ? inner : JSON.stringify(inner);
-}
-function getRawMangleOptions(options) {
-    function _inner() {
-        const _default = {
-            keep_classnames: options?.keepClassNames ?? false,
-            keep_fnames: options?.keepFnNames ?? false
-        };
-        if (options?.mangle === true) {
-            return _default;
-        }
-        if (options?.mangle === false) {
-            return false;
-        }
-        if (options?.mangle && typeof options.mangle === "object") {
-            return {
-                // TODO: deprecate default merging in 0.4
-                ..._default,
-                ...options.mangle
-            };
-        }
-        return _default;
-    }
-    let inner = _inner();
-    return typeof inner === "boolean" ? inner : JSON.stringify(inner);
-}
-function getRawFormatOptions(options) {
-    function _inner() {
-        const _default = {
-            comments: options?.comments ? options?.comments : false,
-            asciiOnly: options?.asciiOnly ?? false
-        };
-        if (options?.format && typeof options.format === "object") {
-            // TODO: deprecate default merging in 0.4
-            return {
-                ..._default,
-                ...options.format
-            };
-        }
-        return _default;
-    }
-    return JSON.stringify(_inner());
-}
 function isObject(value) {
     const type = typeof value;
     return value != null && (type === "object" || type === "function");
@@ -121,11 +55,28 @@ function getRawExtractCommentsOptions(extractComments) {
     }
 }
 exports.SwcJsMinimizerRspackPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.SwcJsMinimizerRspackPlugin, (options) => {
+    let compress = options?.compress ?? true;
+    let mangle = options?.mangle ?? true;
+    let format = {
+        comments: false,
+        ...options?.format
+    };
+    if (compress && typeof compress === "object") {
+        compress = {
+            passes: 1,
+            ...compress
+        };
+    }
+    else if (compress) {
+        compress = {
+            passes: 1
+        };
+    }
     return {
         extractComments: getRawExtractCommentsOptions(options?.extractComments),
-        compress: getRawCompressOptions(options),
-        mangle: getRawMangleOptions(options),
-        format: getRawFormatOptions(options),
+        compress,
+        mangle,
+        format,
         module: options?.module,
         test: options?.test,
         include: options?.include,