@rspack/core 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/Module.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Module_inner, _Module_originalSource, _CodeGenerationResult_inner, _CodeGenerationResults_inner;
+var _Module_inner, _Module_originalSource, _CodeGenerationResult_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodeGenerationResults = exports.CodeGenerationResult = exports.Module = void 0;
 const source_1 = require("./util/source");
@@ -22,6 +22,7 @@ class Module {
         _Module_inner.set(this, void 0);
         _Module_originalSource.set(this, void 0);
         __classPrivateFieldSet(this, _Module_inner, module, "f");
+        this.type = module.type;
         this.context = module.context;
         this.resource = module.resource;
         this.request = module.request;
@@ -69,10 +70,6 @@ class CodeGenerationResult {
 exports.CodeGenerationResult = CodeGenerationResult;
 _CodeGenerationResult_inner = new WeakMap();
 class CodeGenerationResults {
-    constructor(result) {
-        _CodeGenerationResults_inner.set(this, void 0);
-        __classPrivateFieldSet(this, _CodeGenerationResults_inner, result, "f");
-    }
+    constructor(_result) { }
 }
 exports.CodeGenerationResults = CodeGenerationResults;
-_CodeGenerationResults_inner = new WeakMap();

package/dist/MultiCompiler.d.ts

@@ -8,11 +8,11 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import * as liteTapable from "@rspack/lite-tapable";
-import { Compiler, RspackOptions } from ".";
+import type { Compiler, RspackOptions } from ".";
 import MultiStats from "./MultiStats";
 import MultiWatching from "./MultiWatching";
-import { WatchOptions } from "./config";
-import { WatchFileSystem } from "./util/fs";
+import type { WatchOptions } from "./config";
+import type { WatchFileSystem } from "./util/fs";
 export interface MultiCompilerOptions {
     /**
      * how many Compilers are allows to run at the same time in parallel

package/dist/MultiCompiler.js

@@ -67,7 +67,7 @@ class MultiCompiler {
         };
         this.compilers = compilers;
         this._options = {
-            parallelism: options?.parallelism || Infinity
+            parallelism: options?.parallelism || Number.POSITIVE_INFINITY
         };
         this.dependencies = new WeakMap();
         this.running = false;

package/dist/MultiStats.d.ts

@@ -7,8 +7,8 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-import { Stats } from "./Stats";
-import { StatsCompilation } from "./stats/statsFactoryUtils";
+import type { Stats } from "./Stats";
+import type { StatsCompilation } from "./stats/statsFactoryUtils";
 export default class MultiStats {
     #private;
     stats: Stats[];

package/dist/MultiWatching.d.ts

@@ -7,8 +7,8 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-import { MultiCompiler } from "./MultiCompiler";
-import { Watching } from "./Watching";
+import type { MultiCompiler } from "./MultiCompiler";
+import type { Watching } from "./Watching";
 declare class MultiWatching {
     watchings: Watching[];
     compiler: MultiCompiler;

package/dist/NormalModule.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import * as liteTapable from "@rspack/lite-tapable";
 import { Compilation } from "./Compilation";
-import { LoaderContext } from "./config";
+import type { LoaderContext } from "./config";
 export declare class NormalModule {
     static getCompilationHooks(compilation: Compilation): {
         loader: liteTapable.SyncHook<[LoaderContext<{}>], void, {

package/dist/NormalModuleFactory.d.ts

@@ -1,6 +1,6 @@
 import type * as binding from "@rspack/binding";
 import * as liteTapable from "@rspack/lite-tapable";
-import { ResolveData, ResourceDataWithData } from "./Module";
+import type { ResolveData, ResourceDataWithData } from "./Module";
 export type NormalModuleCreateData = binding.JsNormalModuleFactoryCreateModuleArgs & {
     settings: {};
 };

package/dist/Resolver.d.ts

@@ -0,0 +1,19 @@
+import type * as binding from "@rspack/binding";
+import { type Resolve } from "./config";
+interface ResolveContext {
+}
+type ErrorWithDetail = Error & {
+    details?: string;
+};
+type ResolveOptionsWithDependencyType = Resolve & {
+    dependencyCategory?: string;
+    resolveToContext?: boolean;
+};
+export declare class Resolver {
+    binding: binding.JsResolver;
+    constructor(binding: binding.JsResolver);
+    resolveSync(context: object, path: string, request: string): string | false;
+    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: (err: null | ErrorWithDetail, res?: string | false) => void): void;
+    withOptions({ dependencyCategory, resolveToContext, ...resolve }: ResolveOptionsWithDependencyType): Resolver;
+}
+export {};

package/dist/Resolver.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resolver = void 0;
+const config_1 = require("./config");
+function isString(value) {
+    return typeof value === "string";
+}
+class Resolver {
+    constructor(binding) {
+        this.binding = binding;
+    }
+    resolveSync(context, path, request) {
+        return this.binding.resolveSync(path, request);
+    }
+    resolve(context, path, request, resolveContext, callback) {
+        try {
+            const res = this.binding.resolveSync(path, request);
+            callback(null, res);
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    withOptions({ dependencyCategory, resolveToContext, ...resolve }) {
+        const rawResolve = (0, config_1.getRawResolve)(resolve);
+        // TODO: rspack_resolver is unimplemented regex
+        if (Array.isArray(rawResolve.restrictions)) {
+            rawResolve.restrictions =
+                rawResolve.restrictions.filter(isString);
+        }
+        const binding = this.binding.withOptions({
+            dependencyCategory,
+            resolveToContext,
+            ...rawResolve
+        });
+        return new Resolver(binding);
+    }
+}
+exports.Resolver = Resolver;

package/dist/ResolverFactory.d.ts

@@ -1,48 +1,14 @@
-export = ResolverFactory;
-declare class ResolverFactory {
-    hooks: Readonly<{
-        /** @type {HookMap<SyncWaterfallHook<[ResolveOptionsWithDependencyType]>>} */
-        resolveOptions: HookMap<SyncWaterfallHook<[ResolveOptionsWithDependencyType]>>;
-        /** @type {HookMap<SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>>} */
-        resolver: HookMap<SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>>;
-    }>;
-    /** @type {Map<string, ResolverCache>} */
-    cache: Map<string, ResolverCache>;
-    /**
-     * @param {string} type type of resolver
-     * @param {ResolveOptionsWithDependencyType=} resolveOptions options
-     * @returns {ResolverWithOptions} the resolver
-     */
-    get(type: string, resolveOptions?: ResolveOptionsWithDependencyType | undefined): ResolverWithOptions;
-    /**
-     * @param {string} type type of resolver
-     * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType options
-     * @returns {ResolverWithOptions} the resolver
-     */
-    _create(type: string, resolveOptionsWithDepType: ResolveOptionsWithDependencyType): ResolverWithOptions;
-}
-declare namespace ResolverFactory {
-    export { ResolveOptions, Resolver, WebpackResolveOptions, ResolvePluginInstance, ResolveOptionsWithDependencyType, WithOptions, ResolverWithOptions, ResolverCache };
-}
-import { HookMap } from "@rspack/lite-tapable";
-import { SyncWaterfallHook } from "@rspack/lite-tapable";
-type ResolveOptionsWithDependencyType = WebpackResolveOptions & {
-    dependencyType?: string;
+import * as binding from "@rspack/binding";
+import { Resolver } from "./Resolver";
+import { type Resolve } from "./config";
+type ResolveOptionsWithDependencyType = Resolve & {
+    dependencyCategory?: string;
     resolveToContext?: boolean;
 };
-import { SyncHook } from "@rspack/lite-tapable";
-type Resolver = import("../compiled/enhanced-resolve").Resolver;
-type ResolveOptions = import("../compiled/enhanced-resolve").ResolveOptions;
-type ResolverCache = {
-    direct: WeakMap<Object, ResolverWithOptions>;
-    stringified: Map<string, ResolverWithOptions>;
-};
-type ResolverWithOptions = Resolver & WithOptions;
-type WebpackResolveOptions = any;
-type ResolvePluginInstance = any;
-type WithOptions = {
-    /**
-     * create a resolver with additional/different options
-     */
-    withOptions: (arg0: Partial<ResolveOptionsWithDependencyType>) => ResolverWithOptions;
-};
+export declare class ResolverFactory {
+    #private;
+    static __to_binding(resolver_factory: ResolverFactory): binding.JsResolverFactory;
+    constructor();
+    get(type: string, resolveOptions?: ResolveOptionsWithDependencyType): Resolver;
+}
+export {};

package/dist/ResolverFactory.js

@@ -1,126 +1,61 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/ResolverFactory.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
 "use strict";
-const Factory = require("../compiled/enhanced-resolve").ResolverFactory;
-const { HookMap, SyncHook, SyncWaterfallHook } = require("@rspack/lite-tapable");
-const { cachedCleverMerge, removeOperations, resolveByProperty } = require("./util/cleverMerge");
-/** @typedef {import("../compiled/enhanced-resolve").ResolveOptions} ResolveOptions */
-/** @typedef {import("../compiled/enhanced-resolve").Resolver} Resolver */
-// /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} WebpackResolveOptions */
-// /** @typedef {import("../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
-/** @typedef {any} WebpackResolveOptions */
-/** @typedef {any} ResolvePluginInstance */
-/** @typedef {WebpackResolveOptions & {dependencyType?: string, resolveToContext?: boolean }} ResolveOptionsWithDependencyType */
-/**
- * @typedef {Object} WithOptions
- * @property {function(Partial<ResolveOptionsWithDependencyType>): ResolverWithOptions} withOptions create a resolver with additional/different options
- */
-/** @typedef {Resolver & WithOptions} ResolverWithOptions */
-// need to be hoisted on module level for caching identity
-const EMPTY_RESOLVE_OPTIONS = {};
-/**
- * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType enhanced options
- * @returns {ResolveOptions} merged options
- */
-const convertToResolveOptions = resolveOptionsWithDepType => {
-    const { dependencyType, plugins, ...remaining } = resolveOptionsWithDepType;
-    // check type compat
-    /** @type {Partial<ResolveOptions>} */
-    const partialOptions = {
-        ...remaining,
-        plugins: plugins &&
-            /** @type {ResolvePluginInstance[]} */ (
-            // @ts-expect-error
-            plugins.filter(item => item !== "..."))
-    };
-    if (!partialOptions.fileSystem) {
-        throw new Error("fileSystem is missing in resolveOptions, but it's required for enhanced-resolve");
+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]; } };
     }
-    // These weird types validate that we checked all non-optional properties
-    const options = 
-    /** @type {Partial<ResolveOptions> & Pick<ResolveOptions, "fileSystem">} */ (partialOptions);
-    // @ts-expect-error
-    return removeOperations(resolveByProperty(options, "byDependency", dependencyType));
+    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;
 };
-/**
- * @typedef {Object} ResolverCache
- * @property {WeakMap<Object, ResolverWithOptions>} direct
- * @property {Map<string, ResolverWithOptions>} stringified
- */
-module.exports = class ResolverFactory {
-    constructor() {
-        this.hooks = Object.freeze({
-            /** @type {HookMap<SyncWaterfallHook<[ResolveOptionsWithDependencyType]>>} */
-            resolveOptions: new HookMap(() => new SyncWaterfallHook(["resolveOptions"])),
-            /** @type {HookMap<SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>>} */
-            resolver: new HookMap(() => new SyncHook(["resolver", "resolveOptions", "userResolveOptions"]))
-        });
-        /** @type {Map<string, ResolverCache>} */
-        this.cache = new Map();
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ResolverFactory_binding;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolverFactory = void 0;
+const binding = __importStar(require("@rspack/binding"));
+const Resolver_1 = require("./Resolver");
+const config_1 = require("./config");
+class ResolverFactory {
+    static __to_binding(resolver_factory) {
+        return __classPrivateFieldGet(resolver_factory, _ResolverFactory_binding, "f");
     }
-    /**
-     * @param {string} type type of resolver
-     * @param {ResolveOptionsWithDependencyType=} resolveOptions options
-     * @returns {ResolverWithOptions} the resolver
-     */
-    get(type, resolveOptions = EMPTY_RESOLVE_OPTIONS) {
-        let typedCaches = this.cache.get(type);
-        if (!typedCaches) {
-            typedCaches = {
-                direct: new WeakMap(),
-                stringified: new Map()
-            };
-            this.cache.set(type, typedCaches);
-        }
-        const cachedResolver = typedCaches.direct.get(resolveOptions);
-        if (cachedResolver) {
-            return cachedResolver;
-        }
-        const ident = JSON.stringify(resolveOptions);
-        const resolver = typedCaches.stringified.get(ident);
-        if (resolver) {
-            typedCaches.direct.set(resolveOptions, resolver);
-            return resolver;
-        }
-        const newResolver = this._create(type, resolveOptions);
-        typedCaches.direct.set(resolveOptions, newResolver);
-        typedCaches.stringified.set(ident, newResolver);
-        return newResolver;
+    constructor() {
+        _ResolverFactory_binding.set(this, void 0);
+        __classPrivateFieldSet(this, _ResolverFactory_binding, new binding.JsResolverFactory(), "f");
     }
-    /**
-     * @param {string} type type of resolver
-     * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType options
-     * @returns {ResolverWithOptions} the resolver
-     */
-    _create(type, resolveOptionsWithDepType) {
-        /** @type {ResolveOptionsWithDependencyType} */
-        const originalResolveOptions = { ...resolveOptionsWithDepType };
-        const resolveOptions = convertToResolveOptions(this.hooks.resolveOptions.for(type).call(resolveOptionsWithDepType));
-        const resolver = /** @type {ResolverWithOptions} */ (Factory.createResolver(resolveOptions));
-        if (!resolver) {
-            throw new Error("No resolver created");
-        }
-        /** @type {WeakMap<Partial<ResolveOptionsWithDependencyType>, ResolverWithOptions>} */
-        const childCache = new WeakMap();
-        resolver.withOptions = options => {
-            const cacheEntry = childCache.get(options);
-            if (cacheEntry !== undefined)
-                return cacheEntry;
-            const mergedOptions = cachedCleverMerge(originalResolveOptions, options);
-            const resolver = this.get(type, mergedOptions);
-            childCache.set(options, resolver);
-            return resolver;
-        };
-        this.hooks.resolver
-            .for(type)
-            .call(resolver, resolveOptions, originalResolveOptions);
-        return resolver;
+    get(type, resolveOptions) {
+        const { dependencyCategory, resolveToContext, ...resolve } = resolveOptions || {};
+        const binding = __classPrivateFieldGet(this, _ResolverFactory_binding, "f").get(type, {
+            ...(0, config_1.getRawResolve)(resolve),
+            dependencyCategory,
+            resolveToContext
+        });
+        return new Resolver_1.Resolver(binding);
     }
-};
+}
+exports.ResolverFactory = ResolverFactory;
+_ResolverFactory_binding = new WeakMap();

package/dist/RspackError.d.ts

@@ -1,4 +1,4 @@
-import * as binding from "@rspack/binding";
+import type * 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;

package/dist/RuntimeGlobals.d.ts

@@ -7,7 +7,7 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-import { JsRuntimeGlobals } from "@rspack/binding";
+import type { JsRuntimeGlobals } from "@rspack/binding";
 export declare function __from_binding_runtime_globals(runtimeRequirements: JsRuntimeGlobals): Set<string>;
 export declare function __to_binding_runtime_globals(runtimeRequirements: Set<string>): JsRuntimeGlobals;
 export declare const RuntimeGlobals: {

package/dist/RuntimeGlobals.js

@@ -13,7 +13,7 @@ exports.RuntimeGlobals = exports.__to_binding_runtime_globals = exports.__from_b
 const REVERSE_RUNTIME_GLOBALS = new Map();
 function __from_binding_runtime_globals(runtimeRequirements) {
     const res = new Set();
-    for (let flag of runtimeRequirements.value) {
+    for (const flag of runtimeRequirements.value) {
         if (flag in exports.RuntimeGlobals) {
             res.add(exports.RuntimeGlobals[flag]);
         }
@@ -28,7 +28,7 @@ function __to_binding_runtime_globals(runtimeRequirements) {
     const res = {
         value: []
     };
-    for (let flag of Array.from(runtimeRequirements)) {
+    for (const flag of Array.from(runtimeRequirements)) {
         const item = REVERSE_RUNTIME_GLOBALS.get(flag);
         if (typeof item === "string") {
             res.value.push(item);
@@ -352,6 +352,6 @@ exports.RuntimeGlobals = {
      */
     asyncModule: "__webpack_require__.a"
 };
-for (let entry of Object.entries(exports.RuntimeGlobals)) {
+for (const entry of Object.entries(exports.RuntimeGlobals)) {
     REVERSE_RUNTIME_GLOBALS.set(entry[1], entry[0]);
 }

package/dist/Stats.d.ts

@@ -1,5 +1,5 @@
-import { Compilation } from "./Compilation";
-import { StatsOptions, StatsValue } from "./config";
+import type { Compilation } from "./Compilation";
+import type { StatsOptions, StatsValue } from "./config";
 import type { StatsCompilation } from "./stats/statsFactoryUtils";
 export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule, StatsWarnings } from "./stats/statsFactoryUtils";
 export declare class Stats {

package/dist/Stats.js

@@ -102,7 +102,7 @@ function normalizeStatsPreset(options) {
     else if (!options)
         return {};
     else {
-        let obj = { ...presetToOptions(options.preset), ...options };
+        const obj = { ...presetToOptions(options.preset), ...options };
         delete obj.preset;
         return obj;
     }
@@ -118,15 +118,15 @@ function presetToOptions(name) {
         case "verbose":
             return {
                 all: true,
-                modulesSpace: Infinity
+                modulesSpace: Number.POSITIVE_INFINITY
             };
         case "errors-only":
             return {
                 all: false,
                 errors: true,
                 errorsCount: true,
-                logging: "error"
-                // TODO: moduleTrace: true,
+                logging: "error",
+                moduleTrace: true
             };
         case "errors-warnings":
             return {

package/dist/Template.js

@@ -246,8 +246,8 @@ class Template {
      * or false if not every module has a number based id
      */
     static getModulesArrayBounds(modules) {
-        let maxId = -Infinity;
-        let minId = Infinity;
+        let maxId = Number.NEGATIVE_INFINITY;
+        let minId = Number.POSITIVE_INFINITY;
         for (const module of modules) {
             const moduleId = module.id;
             if (typeof moduleId !== "number")

package/dist/Watching.d.ts

@@ -1,8 +1,8 @@
-import { Callback } from "@rspack/lite-tapable";
+import type { Callback } from "@rspack/lite-tapable";
 import type { Compiler } from ".";
 import { Stats } from ".";
-import { WatchOptions } from "./config";
-import { Watcher } from "./util/fs";
+import type { WatchOptions } from "./config";
+import type { Watcher } from "./util/fs";
 export declare class Watching {
     #private;
     watcher?: Watcher;

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

@@ -1,5 +1,3 @@
 export { resolvePluginImport } from "./pluginImport";
 export type { PluginImportOptions } from "./pluginImport";
-export type { ReactOptions } from "./react";
-export { resolveReact } from "./react";
 export type { SwcLoaderEnvConfig, SwcLoaderEsParserConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderOptions, SwcLoaderParserConfig, SwcLoaderTransformConfig, SwcLoaderTsParserConfig } from "./types";

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

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveReact = exports.resolvePluginImport = void 0;
+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; } });

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

@@ -1,4 +1,20 @@
-import type { RawPluginImportConfig } from "@rspack/binding";
+type RawStyleConfig = {
+    styleLibraryDirectory?: string;
+    custom?: string;
+    css?: string;
+    bool?: boolean;
+};
+type RawPluginImportConfig = {
+    libraryName: string;
+    libraryDirectory?: string;
+    customName?: string;
+    customStyleName?: string;
+    style?: RawStyleConfig;
+    camelToDashComponentName?: boolean;
+    transformToDefaultImport?: boolean;
+    ignoreEsComponent?: Array<string>;
+    ignoreStyleComponent?: Array<string>;
+};
 type PluginImportConfig = {
     libraryName: string;
     libraryDirectory?: string;

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

@@ -1,4 +1,14 @@
-import type { RawReactOptions } from "@rspack/binding";
+type RawReactOptions = {
+    runtime?: "automatic" | "classic";
+    importSource?: string;
+    pragma?: string;
+    pragmaFrag?: string;
+    throwIfNamespace?: boolean;
+    development?: boolean;
+    useBuiltins?: boolean;
+    useSpread?: boolean;
+    refresh?: boolean;
+};
 declare function resolveReact(react: ReactOptions): RawReactOptions;
 type ReactOptions = RawReactOptions | undefined;
 export { resolveReact };

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

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

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

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

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

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

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

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