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

package/dist/Compilation.d.ts

@@ -8,7 +8,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import type * as binding from "@rspack/binding";
-import { type ExternalObject, type JsCompilation, type JsModule, type JsPathData, type JsRuntimeModule } from "@rspack/binding";
+import { type ExternalObject, type JsCompilation, type JsPathData, type JsRuntimeModule } from "@rspack/binding";
 import * as liteTapable from "@rspack/lite-tapable";
 import type { Source } from "../compiled/webpack-sources";
 import { Chunk } from "./Chunk";
@@ -167,6 +167,7 @@ export declare class Compilation {
             Set<string>
         ], void>;
         runtimeModule: RuntimeModule;
+        seal: liteTapable.SyncHook<[], void>;
         afterSeal: liteTapable.AsyncSeriesHook<[], void>;
     }>;
     name?: string;
@@ -210,6 +211,7 @@ export declare class Compilation {
      * Note: This is a proxy for webpack internal API, only method `get` and `keys` is supported now.
      */
     get namedChunks(): ReadonlyMap<string, Readonly<Chunk>>;
+    get entries(): Map<string, EntryData>;
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
@@ -220,7 +222,7 @@ export declare class Compilation {
         buildMeta: Record<string, unknown>;
     };
     getCache(name: string): import("./lib/CacheFacade").CacheFacade;
-    createStatsOptions(optionsOrPreset: StatsValue | undefined, context?: CreateStatsOptionsContext): NormalizedStatsOptions;
+    createStatsOptions(statsValue: StatsValue | undefined, context?: CreateStatsOptionsContext): NormalizedStatsOptions;
     createStatsFactory(options: StatsOptions): StatsFactory;
     createStatsPrinter(options: StatsOptions): StatsPrinter;
     /**
@@ -336,12 +338,6 @@ export declare class Compilation {
      * @internal
      */
     __internal__hasAsset(name: string): boolean;
-    /**
-     * Note: This is not a webpack public API, maybe removed in future.
-     *
-     * @internal
-     */
-    __internal__getModules(): JsModule[];
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
@@ -373,3 +369,20 @@ export declare class Compilation {
     static PROCESS_ASSETS_STAGE_ANALYSE: number;
     static PROCESS_ASSETS_STAGE_REPORT: number;
 }
+export type EntryData = binding.JsEntryData;
+export declare class Entries implements Map<string, EntryData> {
+    #private;
+    constructor(data: binding.JsEntries);
+    clear(): void;
+    forEach(callback: (value: binding.JsEntryData, key: string, map: Map<string, binding.JsEntryData>) => void, thisArg?: any): void;
+    get size(): number;
+    entries(): IterableIterator<[string, binding.JsEntryData]>;
+    values(): IterableIterator<binding.JsEntryData>;
+    [Symbol.iterator](): IterableIterator<[string, binding.JsEntryData]>;
+    get [Symbol.toStringTag](): string;
+    has(key: string): boolean;
+    set(key: string, value: EntryData): this;
+    delete(key: string): boolean;
+    get(key: string): EntryData | undefined;
+    keys(): IterableIterator<string>;
+}

package/dist/Compilation.js

@@ -36,9 +36,9 @@ 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_customModules, _Compilation_createCachedAssets, _Compilation_rebuildModuleCaller;
+var _Compilation_instances, _Compilation_inner, _Compilation_customModules, _Compilation_createCachedAssets, _Compilation_rebuildModuleCaller, _Entries_data;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compilation = void 0;
+exports.Entries = exports.Compilation = void 0;
 const binding_1 = require("@rspack/binding");
 const liteTapable = __importStar(require("@rspack/lite-tapable"));
 const Chunk_1 = require("./Chunk");
@@ -72,10 +72,10 @@ class Compilation {
          * These fields are generally used within a plugin, so they do not need to be passed back to the Rust side.
          */
         _Compilation_customModules.set(this, void 0);
-        this.fileDependencies = (0, fake_1.createFakeCompilationDependencies)(() => __classPrivateFieldGet(this, _Compilation_inner, "f").getFileDependencies(), d => __classPrivateFieldGet(this, _Compilation_inner, "f").addFileDependencies(d));
-        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));
+        this.fileDependencies = (0, fake_1.createFakeCompilationDependencies)(() => __classPrivateFieldGet(this, _Compilation_inner, "f").dependencies().fileDependencies, d => __classPrivateFieldGet(this, _Compilation_inner, "f").addFileDependencies(d));
+        this.contextDependencies = (0, fake_1.createFakeCompilationDependencies)(() => __classPrivateFieldGet(this, _Compilation_inner, "f").dependencies().contextDependencies, d => __classPrivateFieldGet(this, _Compilation_inner, "f").addContextDependencies(d));
+        this.missingDependencies = (0, fake_1.createFakeCompilationDependencies)(() => __classPrivateFieldGet(this, _Compilation_inner, "f").dependencies().missingDependencies, d => __classPrivateFieldGet(this, _Compilation_inner, "f").addMissingDependencies(d));
+        this.buildDependencies = (0, fake_1.createFakeCompilationDependencies)(() => __classPrivateFieldGet(this, _Compilation_inner, "f").dependencies().buildDependencies, d => __classPrivateFieldGet(this, _Compilation_inner, "f").addBuildDependencies(d));
         _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) {
@@ -98,12 +98,14 @@ class Compilation {
             const errorMessage = (reason) => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
             const getOptions = (options) => {
-                if (typeof options === "string")
-                    options = { name: options };
-                if (options.stage) {
+                const isString = typeof options === "string";
+                if (!isString && options.stage) {
                     throw new Error(errorMessage("it's using the 'stage' option"));
                 }
-                return { ...options, stage: stage };
+                return {
+                    ...(isString ? { name: options } : options),
+                    stage: stage
+                };
             };
             return Object.freeze({
                 name,
@@ -157,6 +159,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 "runtimeRequirements"
             ]),
             runtimeModule: new liteTapable.SyncHook(["module", "chunk"]),
+            seal: new liteTapable.SyncHook([]),
             afterSeal: new liteTapable.AsyncSeriesHook([])
         };
         this.compiler = compiler;
@@ -213,7 +216,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         };
     }
     get modules() {
-        return (0, memoize_1.memoizeValue)(() => new Set(this.__internal__getModules().map(item => Module_1.Module.__from_binding(item, this))));
+        return new Set(__classPrivateFieldGet(this, _Compilation_inner, "f").modules.map(module => Module_1.Module.__from_binding(module, this)));
     }
     get chunks() {
         return (0, memoize_1.memoizeValue)(() => new Set(this.__internal__getChunks()));
@@ -237,6 +240,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             }
         };
     }
+    get entries() {
+        return new Entries(__classPrivateFieldGet(this, _Compilation_inner, "f").entries);
+    }
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
@@ -255,7 +261,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     getCache(name) {
         return this.compiler.getCache(name);
     }
-    createStatsOptions(optionsOrPreset, context = {}) {
+    createStatsOptions(statsValue, context = {}) {
+        let optionsOrPreset = statsValue;
         if (typeof optionsOrPreset === "boolean" ||
             typeof optionsOrPreset === "string") {
             optionsOrPreset = { preset: optionsOrPreset };
@@ -448,12 +455,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             {
                 method: "push",
                 handler(target, thisArg, warns) {
-                    warns = processWarningsHook.call(warns);
-                    for (let i = 0; i < warns.length; i++) {
-                        const warn = warns[i];
+                    return Reflect.apply(target, thisArg, processWarningsHook.call(warns).map(warn => {
                         inner.pushDiagnostic(RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn));
-                    }
-                    return Reflect.apply(target, thisArg, warns);
+                        return warn;
+                    }));
                 }
             },
             {
@@ -473,12 +478,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             {
                 method: "unshift",
                 handler(target, thisArg, warns) {
-                    warns = processWarningsHook.call(warns);
-                    const warnList = warns.map(warn => {
+                    const warnings = processWarningsHook.call(warns);
+                    inner.spliceDiagnostic(0, 0, warnings.map(warn => {
                         return RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn);
-                    });
-                    inner.spliceDiagnostic(0, 0, warnList);
-                    return Reflect.apply(target, thisArg, warns);
+                    }));
+                    return Reflect.apply(target, thisArg, warnings);
                 }
             },
             {
@@ -521,11 +525,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         if (!name) {
             throw new TypeError("Compilation.getLogger(name) called without a name");
         }
+        let logName = name;
         let logEntries;
         return new Logger_1.Logger((type, args) => {
-            if (typeof name === "function") {
-                name = name();
-                if (!name) {
+            if (typeof logName === "function") {
+                logName = logName();
+                if (!logName) {
                     throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                 }
             }
@@ -545,67 +550,68 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 args,
                 trace
             };
-            if (this.hooks.log.call(name, logEntry) === undefined) {
+            if (this.hooks.log.call(logName, logEntry) === undefined) {
                 if (logEntry.type === Logger_1.LogType.profileEnd) {
                     if (typeof console.profileEnd === "function") {
-                        console.profileEnd(`[${name}] ${logEntry.args[0]}`);
+                        console.profileEnd(`[${logName}] ${logEntry.args[0]}`);
                     }
                 }
                 if (logEntries === undefined) {
-                    logEntries = this.logging.get(name);
+                    logEntries = this.logging.get(logName);
                     if (logEntries === undefined) {
                         logEntries = [];
-                        this.logging.set(name, logEntries);
+                        this.logging.set(logName, logEntries);
                     }
                 }
                 logEntries.push(logEntry);
                 if (logEntry.type === Logger_1.LogType.profile) {
                     if (typeof console.profile === "function") {
-                        console.profile(`[${name}] ${logEntry.args[0]}`);
+                        console.profile(`[${logName}] ${logEntry.args[0]}`);
                     }
                 }
             }
         }, (childName) => {
-            if (typeof name === "function") {
-                if (typeof childName === "function") {
+            let normalizedChildName = childName;
+            if (typeof logName === "function") {
+                if (typeof normalizedChildName === "function") {
                     return this.getLogger(() => {
-                        if (typeof name === "function") {
-                            name = name();
-                            if (!name) {
+                        if (typeof logName === "function") {
+                            logName = logName();
+                            if (!logName) {
                                 throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                             }
                         }
-                        if (typeof childName === "function") {
-                            childName = childName();
-                            if (!childName) {
+                        if (typeof normalizedChildName === "function") {
+                            normalizedChildName = normalizedChildName();
+                            if (!normalizedChildName) {
                                 throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                             }
                         }
-                        return `${name}/${childName}`;
+                        return `${logName}/${normalizedChildName}`;
                     });
                 }
                 return this.getLogger(() => {
-                    if (typeof name === "function") {
-                        name = name();
-                        if (!name) {
+                    if (typeof logName === "function") {
+                        logName = logName();
+                        if (!logName) {
                             throw new TypeError("Compilation.getLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${logName}/${normalizedChildName}`;
                 });
             }
-            if (typeof childName === "function") {
+            if (typeof normalizedChildName === "function") {
                 return this.getLogger(() => {
-                    if (typeof childName === "function") {
-                        childName = childName();
-                        if (!childName) {
+                    if (typeof normalizedChildName === "function") {
+                        normalizedChildName = normalizedChildName();
+                        if (!normalizedChildName) {
                             throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${logName}/${normalizedChildName}`;
                 });
             }
-            return this.getLogger(`${name}/${childName}`);
+            return this.getLogger(`${logName}/${normalizedChildName}`);
         });
     }
     getStats() {
@@ -673,14 +679,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     __internal__hasAsset(name) {
         return __classPrivateFieldGet(this, _Compilation_inner, "f").hasAsset(name);
     }
-    /**
-     * Note: This is not a webpack public API, maybe removed in future.
-     *
-     * @internal
-     */
-    __internal__getModules() {
-        return __classPrivateFieldGet(this, _Compilation_inner, "f").getModules();
-    }
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
@@ -759,3 +757,62 @@ Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
 Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000;
 Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000;
 exports.Compilation = Compilation;
+class Entries {
+    constructor(data) {
+        _Entries_data.set(this, void 0);
+        __classPrivateFieldSet(this, _Entries_data, data, "f");
+    }
+    clear() {
+        __classPrivateFieldGet(this, _Entries_data, "f").clear();
+    }
+    forEach(callback, thisArg) {
+        for (const [key, value] of this) {
+            callback.call(thisArg, value, key, this);
+        }
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").size;
+    }
+    entries() {
+        const self = this;
+        const keys = this.keys();
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                const { done, value } = keys.next();
+                return {
+                    done,
+                    value: done ? undefined : [value, self.get(value)]
+                };
+            }
+        };
+    }
+    values() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").values()[Symbol.iterator]();
+    }
+    [(_Entries_data = new WeakMap(), Symbol.iterator)]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return "Map";
+    }
+    has(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").has(key);
+    }
+    set(key, value) {
+        __classPrivateFieldGet(this, _Entries_data, "f").set(key, value);
+        return this;
+    }
+    delete(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").delete(key);
+    }
+    get(key) {
+        return __classPrivateFieldGet(this, _Entries_data, "f").get(key);
+    }
+    keys() {
+        return __classPrivateFieldGet(this, _Entries_data, "f").keys()[Symbol.iterator]();
+    }
+}
+exports.Entries = Entries;

package/dist/Compiler.d.ts

@@ -69,6 +69,7 @@ declare class Compiler {
         entryOption: liteTapable.SyncBailHook<[string, EntryNormalized], any>;
     };
     webpack: typeof rspack;
+    rspack: typeof rspack;
     name?: string;
     parentCompilation?: Compilation;
     root: Compiler;

package/dist/Compiler.js

@@ -137,6 +137,7 @@ class Compiler {
             entryOption: new liteTapable.SyncBailHook(["context", "entry"])
         };
         this.webpack = index_1.rspack;
+        this.rspack = index_1.rspack;
         this.root = this;
         this.outputPath = "";
         this.inputFileSystem = null;
@@ -199,62 +200,65 @@ class Compiler {
         if (!name) {
             throw new TypeError("Compiler.getInfrastructureLogger(name) called without a name");
         }
+        let normalizedName = name;
         return new Logger_1.Logger((type, args) => {
-            if (typeof name === "function") {
-                name = name();
-                if (!name) {
+            if (typeof normalizedName === "function") {
+                normalizedName = normalizedName();
+                if (!normalizedName) {
                     throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                 }
             }
             else {
-                if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+                if (this.hooks.infrastructureLog.call(normalizedName, type, args) ===
+                    undefined) {
                     if (this.infrastructureLogger !== undefined) {
-                        this.infrastructureLogger(name, type, args);
+                        this.infrastructureLogger(normalizedName, type, args);
                     }
                 }
             }
         }, (childName) => {
-            if (typeof name === "function") {
-                if (typeof childName === "function") {
+            let normalizedChildName = childName;
+            if (typeof normalizedName === "function") {
+                if (typeof normalizedChildName === "function") {
                     // @ts-expect-error
                     return this.getInfrastructureLogger(_ => {
-                        if (typeof name === "function") {
-                            name = name();
-                            if (!name) {
+                        if (typeof normalizedName === "function") {
+                            normalizedName = normalizedName();
+                            if (!normalizedName) {
                                 throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                             }
                         }
-                        if (typeof childName === "function") {
-                            childName = childName();
-                            if (!childName) {
+                        if (typeof normalizedChildName === "function") {
+                            normalizedChildName = normalizedChildName();
+                            if (!normalizedChildName) {
                                 throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                             }
                         }
-                        return `${name}/${childName}`;
+                        return `${normalizedName}/${normalizedChildName}`;
                     });
                 }
                 return this.getInfrastructureLogger(() => {
-                    if (typeof name === "function") {
-                        name = name();
-                        if (!name) {
+                    if (typeof normalizedName === "function") {
+                        normalizedName = normalizedName();
+                        if (!normalizedName) {
                             throw new TypeError("Compiler.getInfrastructureLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${normalizedName}/${normalizedChildName}`;
                 });
             }
-            if (typeof childName === "function") {
+            if (typeof normalizedChildName === "function") {
                 return this.getInfrastructureLogger(() => {
-                    if (typeof childName === "function") {
-                        childName = childName();
-                        if (!childName) {
+                    if (typeof normalizedChildName === "function") {
+                        normalizedChildName = normalizedChildName();
+                        if (!normalizedChildName) {
                             throw new TypeError("Logger.getChildLogger(name) called with a function not returning a name");
                         }
                     }
-                    return `${name}/${childName}`;
+                    return `${normalizedName}/${normalizedChildName}`;
                 });
             }
-            return this.getInfrastructureLogger(`${name}/${childName}`);
+            return this.getInfrastructureLogger(`${normalizedName}/${normalizedChildName}`);
         });
     }
     /**
@@ -665,6 +669,7 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
         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)),
+        registerCompilationSealTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationSeal, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.seal, queried => () => queried.call()),
         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 = {

package/dist/DependenciesBlock.d.ts

@@ -0,0 +1,8 @@
+import type { DependenciesBlockDTO } from "@rspack/binding";
+import { Dependency } from "./Dependency";
+export declare class DependenciesBlock {
+    #private;
+    constructor(binding: DependenciesBlockDTO);
+    get dependencies(): Dependency[];
+    get blocks(): DependenciesBlock[];
+}

package/dist/DependenciesBlock.js

@@ -0,0 +1,30 @@
+"use strict";
+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 __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 _DependenciesBlock_binding;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependenciesBlock = void 0;
+const Dependency_1 = require("./Dependency");
+class DependenciesBlock {
+    constructor(binding) {
+        _DependenciesBlock_binding.set(this, void 0);
+        __classPrivateFieldSet(this, _DependenciesBlock_binding, binding, "f");
+    }
+    get dependencies() {
+        return __classPrivateFieldGet(this, _DependenciesBlock_binding, "f").dependencies.map(d => new Dependency_1.Dependency(d));
+    }
+    get blocks() {
+        return __classPrivateFieldGet(this, _DependenciesBlock_binding, "f").blocks.map(b => new DependenciesBlock(b));
+    }
+}
+exports.DependenciesBlock = DependenciesBlock;
+_DependenciesBlock_binding = new WeakMap();

package/dist/Dependency.d.ts

@@ -0,0 +1,8 @@
+import type { DependencyDTO } from "@rspack/binding";
+export declare class Dependency {
+    #private;
+    constructor(binding: DependencyDTO);
+    get type(): string;
+    get category(): string;
+    get request(): string | undefined;
+}

package/dist/Dependency.js

@@ -0,0 +1,32 @@
+"use strict";
+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 __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 _Dependency_binding;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dependency = void 0;
+class Dependency {
+    constructor(binding) {
+        _Dependency_binding.set(this, void 0);
+        __classPrivateFieldSet(this, _Dependency_binding, binding, "f");
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _Dependency_binding, "f").type;
+    }
+    get category() {
+        return __classPrivateFieldGet(this, _Dependency_binding, "f").category;
+    }
+    get request() {
+        return __classPrivateFieldGet(this, _Dependency_binding, "f").request;
+    }
+}
+exports.Dependency = Dependency;
+_Dependency_binding = new WeakMap();

package/dist/Module.d.ts

@@ -1,6 +1,7 @@
-import type { JsCodegenerationResult, JsCreateData, JsFactoryMeta, JsModule } from "@rspack/binding";
+import type { JsCodegenerationResult, JsCreateData, JsFactoryMeta, JsModule, ModuleDTO } from "@rspack/binding";
 import type { Source } from "../compiled/webpack-sources";
 import type { Compilation } from "./Compilation";
+import { DependenciesBlock } from "./DependenciesBlock";
 export type ResourceData = {
     resource: string;
     path: string;
@@ -56,11 +57,13 @@ export declare class Module {
      * @see {@link Compilation#customModules}
      */
     buildMeta: Record<string, any>;
-    static __from_binding(module: JsModule, compilation?: Compilation): Module;
-    constructor(module: JsModule, compilation?: Compilation);
+    static __from_binding(module: JsModule | ModuleDTO, compilation?: Compilation): Module;
+    constructor(module: JsModule | ModuleDTO, compilation?: Compilation);
     originalSource(): Source | null;
     identifier(): string;
     nameForCondition(): string | null;
+    get blocks(): DependenciesBlock[];
+    size(type?: string): number;
 }
 export declare class CodeGenerationResult {
     #private;

package/dist/Module.js

@@ -13,6 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Module_inner, _Module_originalSource, _CodeGenerationResult_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodeGenerationResults = exports.CodeGenerationResult = exports.Module = void 0;
+const DependenciesBlock_1 = require("./DependenciesBlock");
 const source_1 = require("./util/source");
 class Module {
     static __from_binding(module, compilation) {
@@ -52,6 +53,18 @@ class Module {
         }
         return null;
     }
+    get blocks() {
+        if ("blocks" in __classPrivateFieldGet(this, _Module_inner, "f")) {
+            return __classPrivateFieldGet(this, _Module_inner, "f").blocks.map(b => new DependenciesBlock_1.DependenciesBlock(b));
+        }
+        return [];
+    }
+    size(type) {
+        if ("size" in __classPrivateFieldGet(this, _Module_inner, "f")) {
+            return __classPrivateFieldGet(this, _Module_inner, "f").size(type);
+        }
+        return 0;
+    }
 }
 exports.Module = Module;
 _Module_inner = new WeakMap(), _Module_originalSource = new WeakMap();