@rsdoctor/core 1.5.9 → 1.5.11

package/dist/build-utils/build/chunks/assetsModules.d.cts

@@ -0,0 +1,17 @@
+import { SDK } from '@rsdoctor/types';
+/**
+ * Collects module size data from bundle assets, using source maps when available
+ * and falling back to AST parsing for assets without source maps.
+ *
+ * @param moduleGraph - The module graph instance
+ * @param chunkGraph - The chunk graph instance
+ * @param bundleDir - Directory containing the bundle assets
+ * @param sourceMapSets - Map of module paths to their source code (from source maps)
+ * @param hasParseBundle - Whether to enable AST parsing fallback
+ * @param assetsWithoutSourceMap - Optional set of asset paths that don't have source maps.
+ *   When provided, these assets will be parsed using AST parsing instead of source map data.
+ *   This is used as a fallback mechanism when source maps are unavailable for specific assets.
+ *   If not provided and no source maps exist (sourceMapSets is empty), all assets will be parsed via AST.
+ * @returns Promise that resolves when module data collection is complete
+ */
+export declare function getAssetsModulesData(moduleGraph: SDK.ModuleGraphInstance, chunkGraph: SDK.ChunkGraphInstance, bundleDir: string, sourceMapSets: Map<string, string>, hasParseBundle?: boolean, assetsWithoutSourceMap?: Set<string>): Promise<void>;

package/dist/build-utils/build/chunks/chunkTransform.d.cts

@@ -0,0 +1,4 @@
+import { Plugin } from '@rsdoctor/types';
+export declare function chunkTransform(assetMap: Map<string, {
+    content: string;
+}>, bundleStats: Plugin.StatsCompilation): import("@rsdoctor/graph").ChunkGraph;

package/dist/build-utils/build/chunks/index.d.cts

@@ -0,0 +1,3 @@
+export * from './assetsModules';
+export * from './chunkTransform';
+export * from './rspack/transform';

package/dist/build-utils/build/chunks/rspack/transform.cjs

@@ -24,8 +24,8 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    patchNativeChunkGraph: ()=>patchNativeChunkGraph,
-    patchNativeAssets: ()=>patchNativeAssets
+    patchNativeAssets: ()=>patchNativeAssets,
+    patchNativeChunkGraph: ()=>patchNativeChunkGraph
 });
 const graph_namespaceObject = require("@rsdoctor/graph");
 function patchNativeChunkGraph(cg, rawChunkGraph) {

package/dist/build-utils/build/chunks/rspack/transform.d.cts

@@ -0,0 +1,13 @@
+import { Plugin, SDK } from '@rsdoctor/types';
+/**
+ * Patch native chunk graph data from Rspack into ChunkGraph instance
+ * @param cg The ChunkGraph instance to be patched
+ * @param rawChunkGraph Raw chunk graph data from Rspack native plugin
+ */
+export declare function patchNativeChunkGraph(cg: SDK.ChunkGraphInstance, rawChunkGraph: Plugin.RspackNativeChunkGraph): void;
+/**
+ * Patch native assets data from Rspack into ChunkGraph instance
+ * @param cg The ChunkGraph instance to be patched
+ * @param rawAssetPatch Raw assets patch data from Rspack native plugin
+ */
+export declare function patchNativeAssets(cg: SDK.ChunkGraphInstance, rawAssetPatch: Plugin.RspackNativeAssetPatch): void;

package/dist/build-utils/build/index.cjs

@@ -25,10 +25,10 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Chunks: ()=>index_cjs_namespaceObject,
-    Types: ()=>external_types_index_cjs_namespaceObject,
-    Utils: ()=>external_utils_index_cjs_namespaceObject,
     Loader: ()=>external_loader_index_cjs_namespaceObject,
-    ModuleGraph: ()=>external_module_graph_index_cjs_namespaceObject
+    ModuleGraph: ()=>external_module_graph_index_cjs_namespaceObject,
+    Types: ()=>external_types_index_cjs_namespaceObject,
+    Utils: ()=>external_utils_index_cjs_namespaceObject
 });
 const index_cjs_namespaceObject = require("./chunks/index.cjs");
 const external_utils_index_cjs_namespaceObject = require("./utils/index.cjs");

package/dist/build-utils/build/index.d.cts

@@ -0,0 +1,5 @@
+export * as Chunks from './chunks';
+export * as Utils from './utils';
+export * as Loader from './loader';
+export * as Types from '../../types';
+export * as ModuleGraph from './module-graph';

package/dist/build-utils/build/loader/index.d.cts

@@ -0,0 +1,2 @@
+export * from './probeLoaderPlugin';
+export * from './probeLoader';

package/dist/build-utils/build/loader/probeLoader.cjs

@@ -33,8 +33,8 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    loaderModule: ()=>loaderModule,
-    default: ()=>probeLoader
+    default: ()=>probeLoader,
+    loaderModule: ()=>loaderModule
 });
 const external_index_cjs_namespaceObject = require("../../index.cjs");
 const index_cjs_namespaceObject = require("../../../inner-plugins/index.cjs");

package/dist/build-utils/build/loader/probeLoader.d.cts

@@ -0,0 +1,4 @@
+import { Plugin } from '@rsdoctor/types';
+import type { LoaderDefinitionFunction } from '@rspack/core';
+export declare const loaderModule: Plugin.LoaderDefinition<Parameters<LoaderDefinitionFunction>, {}>;
+export default loaderModule;

package/dist/build-utils/build/loader/probeLoaderPlugin.d.cts

@@ -0,0 +1,5 @@
+import { Plugin } from '@rsdoctor/types';
+export declare class ProbeLoaderPlugin {
+    apply(compiler: Plugin.BaseCompiler): void;
+    private addProbeLoader;
+}

package/dist/build-utils/build/module-graph/index.d.cts

@@ -0,0 +1,4 @@
+export * from './webpack/transform';
+export * from './transform';
+export * from './treeShaking';
+export * from './rspack/transform';

package/dist/build-utils/build/module-graph/parser.d.cts

@@ -0,0 +1,2 @@
+import { Node } from '@rsdoctor/utils/ruleUtils';
+export declare function hasSetEsModuleStatement(program: Node.Program): boolean;

package/dist/build-utils/build/module-graph/rspack/transform.cjs

@@ -25,9 +25,9 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     extractSideEffectCodes: ()=>extractSideEffectCodes,
-    patchNativeModuleSources: ()=>patchNativeModuleSources,
+    patchNativeModuleGraph: ()=>patchNativeModuleGraph,
     patchNativeModuleIds: ()=>patchNativeModuleIds,
-    patchNativeModuleGraph: ()=>patchNativeModuleGraph
+    patchNativeModuleSources: ()=>patchNativeModuleSources
 });
 const graph_namespaceObject = require("@rsdoctor/graph");
 const types_namespaceObject = require("@rsdoctor/types");

package/dist/build-utils/build/module-graph/rspack/transform.d.cts

@@ -0,0 +1,26 @@
+import { Plugin, SDK } from '@rsdoctor/types';
+/**
+ * Patch native module graph data from Rspack into ModuleGraph instance
+ * @param mg The ModuleGraph instance to be patched
+ * @param cg The ChunkGraph instance to be patched
+ * @param rawModuleGraph Raw module graph data from Rspack native plugin
+ */
+export declare function patchNativeModuleGraph(mg: SDK.ModuleGraphInstance, cg: SDK.ChunkGraphInstance, rawModuleGraph: Plugin.RspackNativeModuleGraph): void;
+/**
+ * Patch native ids data from Rspack into ModuleGraph instance
+ * @param mg The ModuleGraph instance to be patched
+ * @param rawModuleIdsPatch Raw ids patch data from Rspack native plugin
+ */
+export declare function patchNativeModuleIds(mg: SDK.ModuleGraphInstance, rawModuleIdsPatch: Plugin.RspackNativeModuleIdsPatch): void;
+/**
+ * Patch native sources data from Rspack into ModuleGraph instance
+ * @param mg The ModuleGraph instance to be patched
+ * @param rawModuleIdsPatch Raw sources patch data from Rspack native plugin
+ */
+export declare function patchNativeModuleSources(mg: SDK.ModuleGraphInstance, rawModuleSourcesPatch: Plugin.RspackNativeModuleSourcePatch): void;
+/**
+ * Extract and store code snippets for side effect locations
+ * This should be called after module sources have been set
+ * @param mg The ModuleGraph instance with modules and side effect locations
+ */
+export declare function extractSideEffectCodes(mg: SDK.ModuleGraphInstance): void;

package/dist/build-utils/build/module-graph/transform.d.cts

@@ -0,0 +1,4 @@
+import { Plugin } from '@rsdoctor/types';
+import { TransformContext } from '.';
+import { SDK } from '@rsdoctor/types';
+export declare function getModuleGraphByStats(compilation: Plugin.BaseCompilation, stats: Plugin.StatsCompilation, root: string, chunkGraph: SDK.ChunkGraphInstance, features?: Plugin.RsdoctorWebpackPluginFeatures, context?: TransformContext): Promise<SDK.ModuleGraphInstance>;

package/dist/build-utils/build/module-graph/treeShaking.d.cts

@@ -0,0 +1,2 @@
+import type { SDK, Plugin } from '@rsdoctor/types';
+export declare function appendTreeShaking(moduleGraph: SDK.ModuleGraphInstance, compilation: Plugin.BaseCompilation): SDK.ModuleGraphInstance;

package/dist/build-utils/build/module-graph/utils.cjs

@@ -24,8 +24,8 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    getExportIdentifierStatement: ()=>getExportIdentifierStatement,
-    getDeclarationIdentifier: ()=>getDeclarationIdentifier
+    getDeclarationIdentifier: ()=>getDeclarationIdentifier,
+    getExportIdentifierStatement: ()=>getExportIdentifierStatement
 });
 const compat_namespaceObject = require("es-toolkit/compat");
 const ruleUtils_namespaceObject = require("@rsdoctor/utils/ruleUtils");

package/dist/build-utils/build/module-graph/utils.d.cts

@@ -0,0 +1,3 @@
+import { SDK } from '@rsdoctor/types';
+export declare function getExportIdentifierStatement(name: string, module: SDK.ModuleInstance): SDK.StatementInstance | undefined;
+export declare function getDeclarationIdentifier(name: string, module: SDK.ModuleInstance): SDK.StatementInstance | undefined;

package/dist/build-utils/build/module-graph/webpack/transform.d.cts

@@ -0,0 +1,16 @@
+import type { SourceMapConsumer } from 'source-map';
+import * as Webpack from 'webpack';
+import * as Rspack from '@rspack/core';
+import { Node } from '@rsdoctor/utils/ruleUtils';
+import { Plugin, SDK } from '@rsdoctor/types';
+export interface TransformContext {
+    astCache?: Map<Webpack.NormalModule, Node.Program>;
+    packagePathMap?: Map<string, string>;
+    getSourceMap?(module: string): Promise<SourceMapConsumer | undefined>;
+}
+/**
+ * Get the type of dependencies between modules.
+ * This property can determine what runtime webpack has added to the modules.
+ */
+export declare function getModuleExportsType(module: Webpack.NormalModule | Rspack.NormalModule, moduleGraph?: Webpack.ModuleGraph, strict?: boolean): SDK.DependencyBuildMeta['exportsType'];
+export declare function appendModuleGraphByCompilation(compilation: Plugin.BaseCompilation, graph: SDK.ModuleGraphInstance, features?: Plugin.RsdoctorWebpackPluginFeatures, context?: TransformContext): Promise<SDK.ModuleGraphInstance>;

package/dist/build-utils/build/utils/index.d.cts

@@ -0,0 +1,3 @@
+export * from './loader';
+export * from './plugin';
+export * from './parseBundle';

package/dist/build-utils/build/utils/loader.cjs

@@ -51,15 +51,15 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
-        extractLoaderName: ()=>extractLoaderName,
-        mapEachRules: ()=>mapEachRules,
         addProbeLoader2Rules: ()=>addProbeLoader2Rules,
         createLoaderContextTrap: ()=>createLoaderContextTrap,
-        isESMLoader: ()=>isESMLoader,
-        parseQuery: ()=>parseQuery,
+        extractLoaderName: ()=>extractLoaderName,
         getLoaderNameMatch: ()=>getLoaderNameMatch,
+        isESMLoader: ()=>isESMLoader,
+        loadLoaderModule: ()=>loadLoaderModule,
+        mapEachRules: ()=>mapEachRules,
         parsePathQueryFragment: ()=>parsePathQueryFragment,
-        loadLoaderModule: ()=>loadLoaderModule
+        parseQuery: ()=>parseQuery
     });
     const external_node_path_namespaceObject = require("node:path");
     var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
@@ -139,7 +139,7 @@ var __webpack_exports__ = {};
                     const newRule = {
                         ...rule,
                         use: (...args)=>{
-                            const rules = funcUse.apply(null, args);
+                            const rules = funcUse(...args);
                             return mapEachRules(rules, callback);
                         }
                     };

package/dist/build-utils/build/utils/loader.d.cts

@@ -0,0 +1,20 @@
+import type { Common, Plugin } from '@rsdoctor/types';
+export declare function parsePathQueryFragment(str: string): {
+    path: string;
+    query: string;
+    fragment: string;
+};
+export declare function loadLoaderModule(loaderPath: string, cwd?: string): {
+    default: Plugin.LoaderDefinition<Common.PlainObject, {}>;
+    pitch: Plugin.PitchLoaderDefinitionFunction;
+    raw: boolean | void;
+};
+export declare function extractLoaderName(loaderPath: string, cwd?: string): string;
+export declare function mapEachRules<T extends Plugin.BuildRuleSetRule>(rules: T[], callback: (rule: T) => T): T[];
+export declare function isESMLoader(r: Plugin.BuildRuleSetRule): boolean;
+export declare function getLoaderNameMatch(r: Plugin.BuildRuleSetRule, loaderName: string, strict?: boolean): boolean;
+export declare function addProbeLoader2Rules<T extends Plugin.BuildRuleSetRule>(rules: T[], compiler: Plugin.BaseCompiler, fn: (r: Plugin.BuildRuleSetRule) => boolean): T[];
+export declare function createLoaderContextTrap(this: Plugin.LoaderContext<Common.PlainObject>, final: (err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Plugin.SourceMapInput) => void): Plugin.LoaderContext<Common.PlainObject<any>>;
+export declare function parseQuery(query: string): {
+    [k: string]: string;
+};

package/dist/build-utils/build/utils/loader.js

@@ -84,7 +84,7 @@ function mapEachRules(rules, callback) {
                 const newRule = {
                     ...rule,
                     use: (...args)=>{
-                        const rules = funcUse.apply(null, args);
+                        const rules = funcUse(...args);
                         return mapEachRules(rules, callback);
                     }
                 };

package/dist/build-utils/build/utils/parseBundle.d.cts

@@ -0,0 +1,12 @@
+import type { ParseBundle } from '@rsdoctor/graph';
+/**
+ * The following code is based on
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/src/parseUtils.js#L10
+ *
+ *
+ * MIT Licensed
+ * Author th0r
+ * Copyright JS Foundation and other contributors.
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/LICENSE
+ */
+export declare const parseBundle: ParseBundle;

package/dist/build-utils/build/utils/plugin.cjs

@@ -24,9 +24,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    interceptCompilationHooks: ()=>interceptCompilationHooks,
     interceptCompilerHooks: ()=>interceptCompilerHooks,
-    shouldInterceptPluginHook: ()=>shouldInterceptPluginHook,
-    interceptCompilationHooks: ()=>interceptCompilationHooks
+    shouldInterceptPluginHook: ()=>shouldInterceptPluginHook
 });
 const graph_namespaceObject = require("@rsdoctor/graph");
 function shouldInterceptPluginHook(hook) {

package/dist/build-utils/build/utils/plugin.d.cts

@@ -0,0 +1,5 @@
+import { Plugin } from '@rsdoctor/types';
+export type IHook = Plugin.BaseCompiler['hooks'][keyof Plugin.BaseCompiler['hooks']];
+export declare function shouldInterceptPluginHook<T extends IHook>(hook: T): boolean;
+export declare function interceptCompilerHooks(compiler: Plugin.BaseCompiler, interceptor: (name: string, hook: IHook, scope: 'compiler') => void): void;
+export declare function interceptCompilationHooks(compilation: Plugin.BaseCompilation, interceptor: (name: string, hook: IHook, scope: 'compilation') => void): void;

package/dist/build-utils/index.d.cts

@@ -0,0 +1 @@
+export * as Build from './build';

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+export * from './build-utils';
+export * as InnerPlugins from './inner-plugins';
+export * from './types';

package/dist/inner-plugins/constants.d.cts

@@ -0,0 +1,6 @@
+import type { Tap } from 'tapable';
+export declare const pluginTapName = "RsdoctorWebpackPlugin";
+export declare const pluginTapPostOptions: Tap;
+export declare const pluginTapPreOptions: Tap;
+export declare const internalPluginTapPreOptions: (namespace: string) => Tap;
+export declare const internalPluginTapPostOptions: (namespace: string) => Tap;

package/dist/inner-plugins/index.d.cts

@@ -0,0 +1,2 @@
+export * from './plugins';
+export * from './utils';

package/dist/inner-plugins/loaders/proxy.cjs

@@ -24,9 +24,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    raw: ()=>raw,
     default: ()=>proxy,
-    pitch: ()=>pitch
+    pitch: ()=>pitch,
+    raw: ()=>raw
 });
 const index_cjs_namespaceObject = require("../../build-utils/build/index.cjs");
 const external_utils_index_cjs_namespaceObject = require("../utils/index.cjs");

package/dist/inner-plugins/loaders/proxy.d.cts

@@ -0,0 +1,7 @@
+import type { Plugin as PluginType } from '@rsdoctor/types';
+import { Plugin } from '@rsdoctor/types';
+import type { ProxyLoaderOptions } from '../../types';
+declare const loaderModule: Plugin.LoaderDefinition<ProxyLoaderOptions, {}>;
+export declare const pitch: (this: PluginType.LoaderContext<ProxyLoaderOptions>) => string | void | Buffer<ArrayBufferLike> | Promise<string | Buffer<ArrayBufferLike>>;
+export declare const raw = true;
+export default loaderModule;

package/dist/inner-plugins/plugins/base.d.cts

@@ -0,0 +1,12 @@
+import type { Linter, Plugin, SDK } from '@rsdoctor/types';
+import type { InternalPlugin, RsdoctorPluginInstance } from '../../types';
+export declare abstract class InternalBasePlugin<T extends Plugin.BaseCompiler> implements InternalPlugin<T, Linter.ExtendRuleData[]> {
+    readonly scheduler: RsdoctorPluginInstance<T, Linter.ExtendRuleData[]>;
+    abstract name: string;
+    constructor(scheduler: RsdoctorPluginInstance<T, Linter.ExtendRuleData[]>);
+    abstract apply(compiler: T): void;
+    get options(): Plugin.RsdoctorPluginOptionsNormalized<Linter.ExtendRuleData<any, string>[]>;
+    get sdk(): SDK.RsdoctorBuilderSDKInstance;
+    get tapPostOptions(): import("tapable").Tap;
+    get tapPreOptions(): import("tapable").Tap;
+}

package/dist/inner-plugins/plugins/bundle.d.cts

@@ -0,0 +1,15 @@
+import { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalBundlePlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "bundle";
+    map: Map<string, {
+        content: string;
+    }>;
+    apply(compiler: T): void;
+    changeDevtoolModuleFilename(compiler: Plugin.BaseCompiler): void;
+    ensureAssetContent(name: string): {
+        content: string;
+    };
+    thisCompilation: (compilation: Plugin.BaseCompilation) => void;
+    done: () => Promise<void>;
+}

package/dist/inner-plugins/plugins/bundleTagPlugin.d.cts

@@ -0,0 +1,6 @@
+import { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalBundleTagPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "bundleTag";
+    apply(compiler: Plugin.BaseCompiler): void;
+}

package/dist/inner-plugins/plugins/ensureModulesChunkGraph.cjs

@@ -24,9 +24,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    ensureModulesChunksGraphFn: ()=>ensureModulesChunksGraphFn,
     calculateNamespaceAndRegex: ()=>calculateNamespaceAndRegex,
-    ensureDevtools: ()=>ensureDevtools
+    ensureDevtools: ()=>ensureDevtools,
+    ensureModulesChunksGraphFn: ()=>ensureModulesChunksGraphFn
 });
 const types_namespaceObject = require("@rsdoctor/types");
 const build_namespaceObject = require("@rsdoctor/utils/build");
@@ -111,7 +111,7 @@ async function doneHandler(_stats, _this, context, compiler) {
     await getModulesInfos(compiler, _this.modulesGraph, _this.chunkGraph, shouldParseBundle, _this.sourceMapSets, _this.assetsWithoutSourceMap);
     logger_namespaceObject.logger.debug(`${build_namespaceObject.Process.getMemoryUsageMessage()}, '[After Transform ModuleGraph]'`);
     logger_namespaceObject.logger.debug('reportModuleGraph start');
-    _this.modulesGraph && await _this.sdk.reportModuleGraph(_this.modulesGraph);
+    if (_this.modulesGraph) await _this.sdk.reportModuleGraph(_this.modulesGraph);
     logger_namespaceObject.logger.debug('reportModuleGraph done');
     logger_namespaceObject.logger.debug('reportChunkGraph start');
     await _this.sdk.reportChunkGraph(_this.chunkGraph);
@@ -122,7 +122,7 @@ async function doneHandler(_stats, _this, context, compiler) {
 const ensureDevtools = (compiler)=>{
     const devtool = compiler.options.devtool;
     if ('string' == typeof devtool && /eval/i.test(devtool)) {
-        hasConsole || logger_namespaceObject.logger.warn('SourceMap with eval is not supported. Please use other sourcemap options.');
+        if (!hasConsole) logger_namespaceObject.logger.warn('SourceMap with eval is not supported. Please use other sourcemap options.');
         hasConsole = true;
         return false;
     }

package/dist/inner-plugins/plugins/ensureModulesChunkGraph.d.cts

@@ -0,0 +1,36 @@
+import { RsdoctorPluginInstance } from '../../types';
+import { Linter, Plugin } from '@rsdoctor/types';
+/**
+ * Represents a mapping item from a source map.
+ */
+export interface MappingItem {
+    source: string | null;
+    generatedLine: number;
+    generatedColumn: number;
+    originalLine: number | null;
+    originalColumn: number | null;
+    name: string | null;
+}
+/**
+ * Main function to generate ModuleGraph and ChunkGraph from stats and Webpack module APIs.
+ * Sets up hooks to process stats, generate graphs, handle tree shaking, and collect source maps.
+ * @param compiler - The Webpack or Rspack compiler instance.
+ * @param _this - The Rsdoctor plugin instance.
+ */
+export declare const ensureModulesChunksGraphFn: (compiler: Plugin.BaseCompiler, _this: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>) => void;
+/**
+ * Checks if source map processing is enabled and supported by the current compiler configuration.
+ * Warns if eval-based source maps are used (unsupported).
+ * @param compiler - The Webpack or Rspack compiler instance.
+ * @returns true if source maps are enabled and supported, false otherwise.
+ */
+export declare const ensureDevtools: (compiler: Plugin.BaseCompiler) => boolean;
+/**
+ * Calculates namespace and source map filename regex for source map resolution.
+ * @param compiler - The Webpack or Rspack compiler instance.
+ * @returns An object containing namespace and sourceMapFilenameRegex.
+ */
+export declare function calculateNamespaceAndRegex(compiler: Plugin.BaseCompiler): {
+    namespace: string;
+    sourceMapFilenameRegex: RegExp;
+};

package/dist/inner-plugins/plugins/ensureModulesChunkGraph.js

@@ -82,7 +82,7 @@ async function doneHandler(_stats, _this, context, compiler) {
     await getModulesInfos(compiler, _this.modulesGraph, _this.chunkGraph, shouldParseBundle, _this.sourceMapSets, _this.assetsWithoutSourceMap);
     logger.debug(`${Process.getMemoryUsageMessage()}, '[After Transform ModuleGraph]'`);
     logger.debug('reportModuleGraph start');
-    _this.modulesGraph && await _this.sdk.reportModuleGraph(_this.modulesGraph);
+    if (_this.modulesGraph) await _this.sdk.reportModuleGraph(_this.modulesGraph);
     logger.debug('reportModuleGraph done');
     logger.debug('reportChunkGraph start');
     await _this.sdk.reportChunkGraph(_this.chunkGraph);
@@ -93,7 +93,7 @@ async function doneHandler(_stats, _this, context, compiler) {
 const ensureDevtools = (compiler)=>{
     const devtool = compiler.options.devtool;
     if ('string' == typeof devtool && /eval/i.test(devtool)) {
-        hasConsole || logger.warn('SourceMap with eval is not supported. Please use other sourcemap options.');
+        if (!hasConsole) logger.warn('SourceMap with eval is not supported. Please use other sourcemap options.');
         hasConsole = true;
         return false;
     }

package/dist/inner-plugins/plugins/errors.d.cts

@@ -0,0 +1,11 @@
+import { Rule, Err, Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+import { DevToolError } from '@rsdoctor/utils/error';
+export declare class InternalErrorReporterPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "error-reporter";
+    apply(compiler: T): void;
+    done: (stats: Plugin.BaseStats) => Promise<void>;
+    handleWebpackError(err: Plugin.BuildError, category: Rule.RuleMessageCategory, level: keyof typeof Err.ErrorLevel): DevToolError;
+    reportWarnings(warnings: Plugin.BuildError[]): Promise<void>;
+    reportErrors(errors: Plugin.BuildWarning[]): Promise<void>;
+}

package/dist/inner-plugins/plugins/index.d.cts

@@ -0,0 +1,11 @@
+export * from './loader';
+export * from './plugins';
+export * from './errors';
+export * from './progress';
+export * from './summary';
+export * from './base';
+export * from './bundle';
+export * from './ensureModulesChunkGraph';
+export * from './rules';
+export * from './bundleTagPlugin';
+export * from './resolver';

package/dist/inner-plugins/plugins/loader.d.cts

@@ -0,0 +1,10 @@
+import { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalLoaderPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "loader";
+    readonly internalLoaderPath: string;
+    apply(compiler: T): void;
+    afterPlugins: (compiler: T) => void;
+    compilation(compiler: T, compilation: Plugin.BaseCompilation): void;
+    getInterceptRules(compiler: T, rules: Plugin.BuildRuleSetRules): Plugin.BuildRuleSetRule[];
+}

package/dist/inner-plugins/plugins/plugins.d.cts

@@ -0,0 +1,8 @@
+import { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalPluginsPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "plugins";
+    apply(compiler: Plugin.BaseCompiler): void;
+    afterPlugins: (compiler: Plugin.BaseCompiler) => void;
+    compilation: (compilation: Plugin.BaseCompilation) => void;
+}

package/dist/inner-plugins/plugins/progress.d.cts

@@ -0,0 +1,8 @@
+import { SDK } from '@rsdoctor/types';
+import type { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalProgressPlugin<T extends Plugin.BaseCompilerType<'webpack'>> extends InternalBasePlugin<T> {
+    readonly name = "progress";
+    protected currentProgress: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.APIExtends.GetCompileProgress>;
+    apply(compiler: T): void;
+}

package/dist/inner-plugins/plugins/resolver.d.cts

@@ -0,0 +1,13 @@
+import { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+import type { Compiler as WebpackCompiler } from 'webpack';
+export declare class InternalResolverPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "resolver";
+    protected resolveDataMap: Map<string, {
+        startAt: number;
+        startHRTime: [number, number];
+        request: string;
+    }>;
+    apply(compiler: T): void;
+    protected handleNormalModuleFactory: (normalModuleFactory: Plugin.RspackNormalModuleFactory | ReturnType<WebpackCompiler["createNormalModuleFactory"]>) => void;
+}

package/dist/inner-plugins/plugins/rspack.d.cts

@@ -0,0 +1,4 @@
+import { Linter, Plugin } from '@rsdoctor/types';
+import type { experiments } from '@rspack/core';
+import { RsdoctorPluginInstance } from '../../types';
+export declare function applyRspackNativePlugin(compiler: Plugin.BaseCompiler, plugin: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>, RsdoctorRspackPlugin: typeof experiments.RsdoctorPlugin): void;

package/dist/inner-plugins/plugins/rules.d.cts

@@ -0,0 +1,8 @@
+import { InternalBasePlugin } from './base';
+import { Plugin } from '@rsdoctor/types';
+export declare class InternalRulesPlugin extends InternalBasePlugin<Plugin.BaseCompiler> {
+    readonly name = "rules";
+    apply(compiler: Plugin.BaseCompiler): void;
+    done: (stats: Plugin.BaseStats) => Promise<void>;
+    protected lint(compilation: Plugin.BaseCompilation): Promise<void>;
+}

package/dist/inner-plugins/plugins/sourcemapTool.cjs

@@ -26,9 +26,9 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     UNASSIGNED: ()=>UNASSIGNED,
     bindContextCache: ()=>bindContextCache,
+    collectSourceMaps: ()=>collectSourceMaps,
     handleAfterEmitAssets: ()=>handleAfterEmitAssets,
-    handleEmitAssets: ()=>handleEmitAssets,
-    collectSourceMaps: ()=>collectSourceMaps
+    handleEmitAssets: ()=>handleEmitAssets
 });
 const common_namespaceObject = require("@rsdoctor/utils/common");
 const logger_namespaceObject = require("@rsdoctor/utils/logger");