@rspack/core 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/ChunkGraph.d.ts

@@ -1,5 +1,5 @@
 import { Chunk } from "./Chunk";
-import { Compilation } from "./Compilation";
+import type { Compilation } from "./Compilation";
 import { Module } from "./Module";
 export declare class ChunkGraph {
     private compilation;

package/dist/Compilation.d.ts

@@ -10,23 +10,23 @@
 import type * as binding from "@rspack/binding";
 import { type ExternalObject, type JsCompilation, type JsModule, type JsPathData, type JsRuntimeModule } from "@rspack/binding";
 import * as liteTapable from "@rspack/lite-tapable";
-import { Source } from "../compiled/webpack-sources";
-import { ContextModuleFactory } from "./ContextModuleFactory";
-import { Filename, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance, StatsOptions, StatsValue } from "./config";
-import ResolverFactory = require("./ResolverFactory");
+import type { Source } from "../compiled/webpack-sources";
 import { Chunk } from "./Chunk";
 import { ChunkGraph } from "./ChunkGraph";
-import { Compiler } from "./Compiler";
+import type { Compiler } from "./Compiler";
+import type { ContextModuleFactory } from "./ContextModuleFactory";
 import { Entrypoint } from "./Entrypoint";
-import { CodeGenerationResult, Module } from "./Module";
-import { NormalModuleFactory } from "./NormalModuleFactory";
-import { Stats, StatsAsset, StatsError, StatsModule } from "./Stats";
+import { type CodeGenerationResult, Module } from "./Module";
+import type { NormalModuleFactory } from "./NormalModuleFactory";
+import type { ResolverFactory } from "./ResolverFactory";
+import { Stats, type StatsAsset, type StatsError, type StatsModule } from "./Stats";
+import type { Filename, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance, StatsOptions, StatsValue } from "./config";
 import { Logger } from "./logging/Logger";
 import { StatsFactory } from "./stats/StatsFactory";
 import { StatsPrinter } from "./stats/StatsPrinter";
 import { type AssetInfo } from "./util/AssetInfo";
 import Hash = require("./util/hash");
-import { RspackError } from "./RspackError";
+import { type RspackError } from "./RspackError";
 export { type AssetInfo } from "./util/AssetInfo";
 export type Assets = Record<string, Source>;
 export interface Asset {

package/dist/Compilation.js

@@ -36,7 +36,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Compilation_instances, _Compilation_inner, _Compilation_cachedAssets, _Compilation_customModules, _Compilation_createCachedAssets, _Compilation_rebuildModuleCaller;
+var _Compilation_instances, _Compilation_inner, _Compilation_cachedAssets, _Compilation_cachedEntrypoints, _Compilation_customModules, _Compilation_createCachedAssets, _Compilation_rebuildModuleCaller;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compilation = void 0;
 const binding_1 = require("@rspack/binding");
@@ -61,6 +61,7 @@ class Compilation {
         _Compilation_instances.add(this);
         _Compilation_inner.set(this, void 0);
         _Compilation_cachedAssets.set(this, void 0);
+        _Compilation_cachedEntrypoints.set(this, void 0);
         this.fileSystemInfo = {
             createSnapshot() {
                 // fake implement to support html-webpack-plugin
@@ -76,23 +77,20 @@ class Compilation {
         this.contextDependencies = (0, fake_1.createFakeCompilationDependencies)(() => __classPrivateFieldGet(this, _Compilation_inner, "f").getContextDependencies(), d => __classPrivateFieldGet(this, _Compilation_inner, "f").addContextDependencies(d));
         this.missingDependencies = (0, fake_1.createFakeCompilationDependencies)(() => __classPrivateFieldGet(this, _Compilation_inner, "f").getMissingDependencies(), d => __classPrivateFieldGet(this, _Compilation_inner, "f").addMissingDependencies(d));
         this.buildDependencies = (0, fake_1.createFakeCompilationDependencies)(() => __classPrivateFieldGet(this, _Compilation_inner, "f").getBuildDependencies(), d => __classPrivateFieldGet(this, _Compilation_inner, "f").addBuildDependencies(d));
-        _Compilation_rebuildModuleCaller.set(this, (function (compilation) {
-            return new MergeCaller_1.default((args) => {
-                __classPrivateFieldGet(compilation, _Compilation_inner, "f").rebuildModule(args.map(item => item[0]), function (err, modules) {
-                    for (const [id, callback] of args) {
-                        const m = modules.find(item => item.moduleIdentifier === id);
-                        if (m) {
-                            callback(err, Module_1.Module.__from_binding(m, compilation));
-                        }
-                        else {
-                            callback(err || new Error("module no found"), null);
-                        }
+        _Compilation_rebuildModuleCaller.set(this, ((compilation) => new MergeCaller_1.default((args) => {
+            __classPrivateFieldGet(compilation, _Compilation_inner, "f").rebuildModule(args.map(item => item[0]), (err, modules) => {
+                for (const [id, callback] of args) {
+                    const m = modules.find(item => item.moduleIdentifier === id);
+                    if (m) {
+                        callback(err, Module_1.Module.__from_binding(m, compilation));
                     }
-                });
-            }, 10);
-        })(this));
+                    else {
+                        callback(err || new Error("module no found"), null);
+                    }
+                }
+            });
+        }, 10))(this));
         __classPrivateFieldSet(this, _Compilation_inner, inner, "f");
-        __classPrivateFieldSet(this, _Compilation_cachedAssets, __classPrivateFieldGet(this, _Compilation_instances, "m", _Compilation_createCachedAssets).call(this), "f");
         __classPrivateFieldSet(this, _Compilation_customModules, {}, "f");
         const processAssetsHook = new liteTapable.AsyncSeriesHook([
             "assets"
@@ -182,16 +180,22 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
      * Get a map of all assets.
      */
     get assets() {
+        if (!__classPrivateFieldGet(this, _Compilation_cachedAssets, "f")) {
+            __classPrivateFieldSet(this, _Compilation_cachedAssets, __classPrivateFieldGet(this, _Compilation_instances, "m", _Compilation_createCachedAssets).call(this), "f");
+        }
         return __classPrivateFieldGet(this, _Compilation_cachedAssets, "f");
     }
     /**
      * Get a map of all entrypoints.
      */
     get entrypoints() {
-        return new Map(Object.entries(__classPrivateFieldGet(this, _Compilation_inner, "f").entrypoints).map(([n, e]) => [
-            n,
-            Entrypoint_1.Entrypoint.__from_binding(e, __classPrivateFieldGet(this, _Compilation_inner, "f"))
-        ]));
+        if (!__classPrivateFieldGet(this, _Compilation_cachedEntrypoints, "f")) {
+            __classPrivateFieldSet(this, _Compilation_cachedEntrypoints, new Map(Object.entries(__classPrivateFieldGet(this, _Compilation_inner, "f").entrypoints).map(([n, e]) => [
+                n,
+                Entrypoint_1.Entrypoint.__from_binding(e, __classPrivateFieldGet(this, _Compilation_inner, "f"))
+            ])), "f");
+        }
+        return __classPrivateFieldGet(this, _Compilation_cachedEntrypoints, "f");
     }
     get modules() {
         return (0, memoize_1.memoizeValue)(() => new Set(this.__internal__getModules().map(item => Module_1.Module.__from_binding(item, this))));
@@ -684,7 +688,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     seal() { }
     unseal() { }
 }
-_Compilation_inner = new WeakMap(), _Compilation_cachedAssets = new WeakMap(), _Compilation_customModules = new WeakMap(), _Compilation_rebuildModuleCaller = new WeakMap(), _Compilation_instances = new WeakSet(), _Compilation_createCachedAssets = function _Compilation_createCachedAssets() {
+_Compilation_inner = new WeakMap(), _Compilation_cachedAssets = new WeakMap(), _Compilation_cachedEntrypoints = new WeakMap(), _Compilation_customModules = new WeakMap(), _Compilation_rebuildModuleCaller = new WeakMap(), _Compilation_instances = new WeakSet(), _Compilation_createCachedAssets = function _Compilation_createCachedAssets() {
     return new Proxy({}, {
         get: (_, property) => {
             if (typeof property === "string") {

package/dist/Compiler.d.ts

@@ -11,22 +11,22 @@
 import * as binding from "@rspack/binding";
 import * as liteTapable from "@rspack/lite-tapable";
 import type Watchpack from "../compiled/watchpack";
-import { Compilation, CompilationParams } from "./Compilation";
+import { Compilation, type CompilationParams } from "./Compilation";
 import { ContextModuleFactory } from "./ContextModuleFactory";
 import { RuleSetCompiler } from "./RuleSetCompiler";
 import { Stats } from "./Stats";
-import { EntryNormalized, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance } from "./config";
+import { type EntryNormalized, type OutputNormalized, type RspackOptionsNormalized, type RspackPluginInstance } from "./config";
 import { rspack } from "./index";
-import ResolverFactory = require("./ResolverFactory");
 import Cache = require("./lib/Cache");
 import CacheFacade = require("./lib/CacheFacade");
-import { Source } from "../compiled/webpack-sources";
+import type { Source } from "../compiled/webpack-sources";
 import { Chunk } from "./Chunk";
-import { FileSystemInfoEntry } from "./FileSystemInfo";
+import type { FileSystemInfoEntry } from "./FileSystemInfo";
 import { NormalModuleFactory } from "./NormalModuleFactory";
+import { ResolverFactory } from "./ResolverFactory";
 import { Watching } from "./Watching";
 import { Logger } from "./logging/Logger";
-import { OutputFileSystem, WatchFileSystem } from "./util/fs";
+import type { OutputFileSystem, WatchFileSystem } from "./util/fs";
 export interface AssetEmittedInfo {
     content: Buffer;
     source: Source;

package/dist/Compiler.js

@@ -52,19 +52,19 @@ const binding = __importStar(require("@rspack/binding"));
 const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const Compilation_1 = require("./Compilation");
 const ContextModuleFactory_1 = require("./ContextModuleFactory");
+const FileSystem_1 = require("./FileSystem");
 const RuleSetCompiler_1 = require("./RuleSetCompiler");
 const Stats_1 = require("./Stats");
 const config_1 = require("./config");
-const index_1 = require("./index");
-const ResolverFactory = require("./ResolverFactory");
-const FileSystem_1 = require("./FileSystem");
 const ConcurrentCompilationError_1 = __importDefault(require("./error/ConcurrentCompilationError"));
+const index_1 = require("./index");
 const Cache = require("./lib/Cache");
 const CacheFacade = require("./lib/CacheFacade");
 const Chunk_1 = require("./Chunk");
 const ExecuteModulePlugin_1 = __importDefault(require("./ExecuteModulePlugin"));
 const Module_1 = require("./Module");
 const NormalModuleFactory_1 = require("./NormalModuleFactory");
+const ResolverFactory_1 = require("./ResolverFactory");
 const RuntimeGlobals_1 = require("./RuntimeGlobals");
 const Watching_1 = require("./Watching");
 const builtin_plugin_1 = require("./builtin-plugin");
@@ -144,8 +144,8 @@ class Compiler {
         this.outputFileSystem = null;
         this.watchFileSystem = null;
         this.records = {};
-        this.resolverFactory = new ResolverFactory();
         this.options = options;
+        this.resolverFactory = new ResolverFactory_1.ResolverFactory();
         this.context = context;
         this.cache = new Cache();
         this.compilerPath = "";
@@ -402,7 +402,6 @@ class Compiler {
         childCompiler.outputPath = this.outputPath;
         childCompiler.inputFileSystem = this.inputFileSystem;
         childCompiler.outputFileSystem = null;
-        childCompiler.resolverFactory = this.resolverFactory;
         childCompiler.modifiedFiles = this.modifiedFiles;
         childCompiler.removedFiles = this.removedFiles;
         childCompiler.fileTimestamps = this.fileTimestamps;
@@ -786,7 +785,7 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
             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");
+    __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), ResolverFactory_1.ResolverFactory.__to_binding(this.resolverFactory)), "f");
     callback(null, __classPrivateFieldGet(this, _Compiler_instance, "f"));
 }, _Compiler_updateNonSkippableRegisters = function _Compiler_updateNonSkippableRegisters() {
     const kinds = [];

package/dist/ContextModuleFactory.d.ts

@@ -1,5 +1,5 @@
 import * as liteTapable from "@rspack/lite-tapable";
-import { ContextModuleFactoryAfterResolveResult, ContextModuleFactoryBeforeResolveResult } from "./Module";
+import type { ContextModuleFactoryAfterResolveResult, ContextModuleFactoryBeforeResolveResult } from "./Module";
 export declare class ContextModuleFactory {
     hooks: {
         beforeResolve: liteTapable.AsyncSeriesWaterfallHook<[

package/dist/FileSystem.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { ThreadsafeNodeFS } from "@rspack/binding";
-import { OutputFileSystem } from "./util/fs";
+import type { ThreadsafeNodeFS } from "@rspack/binding";
+import { type OutputFileSystem } from "./util/fs";
 declare class ThreadsafeWritableNodeFS implements ThreadsafeNodeFS {
     writeFile: (name: string, content: Buffer) => Promise<void> | void;
     removeFile: (name: string) => Promise<void> | void;

package/dist/Module.d.ts

@@ -1,6 +1,6 @@
-import { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsFactoryMeta, JsModule } from "@rspack/binding";
-import { Source } from "../compiled/webpack-sources";
-import { Compilation } from "./Compilation";
+import type { JsCodegenerationResult, JsCodegenerationResults, JsCreateData, JsFactoryMeta, JsModule } from "@rspack/binding";
+import type { Source } from "../compiled/webpack-sources";
+import type { Compilation } from "./Compilation";
 export type ResourceData = {
     resource: string;
     path: string;
@@ -41,6 +41,7 @@ export declare class Module {
     request?: Readonly<string>;
     userRequest?: Readonly<string>;
     rawRequest?: Readonly<string>;
+    type: string;
     factoryMeta?: Readonly<JsFactoryMeta>;
     /**
      * Records the dynamically added fields for Module on the JavaScript side.

package/dist/Module.js

@@ -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;

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/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,10 @@
-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;
+import * as binding from "@rspack/binding";
+import { Resolver } from "./Resolver";
+type ResolveOptionsWithDependencyType = binding.RawResolveOptionsWithDependencyType;
+export declare class ResolverFactory {
+    #private;
+    static __to_binding(resolver_factory: ResolverFactory): binding.JsResolverFactory;
+    constructor();
+    get(type: string, resolveOptions?: ResolveOptionsWithDependencyType): Resolver;
 }
-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;
-    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 {};

package/dist/ResolverFactory.js

@@ -1,126 +1,55 @@
-/**
- * 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");
+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 binding = __classPrivateFieldGet(this, _ResolverFactory_binding, "f").get(type, resolveOptions);
+        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: {