@rsdoctor/core 1.5.8 → 1.5.10

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.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.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.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.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.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.cjs

@@ -155,7 +155,7 @@ async function appendModuleGraphByCompilation(compilation, graph, features, cont
         await Promise.all(allModules.map((module)=>appendModuleData(module, webpackGraph, graph, fileSystemInfo, features, context)));
         graph_namespaceObject.ModuleGraphTrans.removeNoImportStyle(graph);
         return graph;
-    } catch (e) {
+    } catch  {
         return graph;
     }
 }

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/module-graph/webpack/transform.js

@@ -117,7 +117,7 @@ async function appendModuleGraphByCompilation(compilation, graph, features, cont
         await Promise.all(allModules.map((module)=>appendModuleData(module, webpackGraph, graph, fileSystemInfo, features, context)));
         ModuleGraphTrans.removeNoImportStyle(graph);
         return graph;
-    } catch (e) {
+    } catch  {
         return graph;
     }
 }

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

@@ -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);
                         }
                     };
@@ -168,7 +168,7 @@ var __webpack_exports__ = {};
         });
     }
     function isESMLoader(r) {
-        let _loaderName = 'object' == typeof r && 'string' == typeof r?.loader ? r.loader : 'string' == typeof r ? r : '';
+        const _loaderName = 'object' == typeof r && 'string' == typeof r?.loader ? r.loader : 'string' == typeof r ? r : '';
         if (!_loaderName) return false;
         const isPath = external_node_path_default().isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../');
         if (isPath) {
@@ -302,8 +302,7 @@ var __webpack_exports__ = {};
                                 common_namespaceObject.Loader.LoaderInternalPropertyName
                             ]) : Reflect.get(target, key, receiver);
                     default:
-                        const _target = target;
-                        return _target[key];
+                        return target[key];
                 }
             },
             set (target, key, value, receiver) {

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);
                     }
                 };
@@ -113,7 +113,7 @@ function mapEachRules(rules, callback) {
     });
 }
 function isESMLoader(r) {
-    let _loaderName = 'object' == typeof r && 'string' == typeof r?.loader ? r.loader : 'string' == typeof r ? r : '';
+    const _loaderName = 'object' == typeof r && 'string' == typeof r?.loader ? r.loader : 'string' == typeof r ? r : '';
     if (!_loaderName) return false;
     const isPath = node_path.isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../');
     if (isPath) {
@@ -247,8 +247,7 @@ function createLoaderContextTrap(final) {
                             Loader.LoaderInternalPropertyName
                         ]) : Reflect.get(target, key, receiver);
                 default:
-                    const _target = target;
-                    return _target[key];
+                    return target[key];
             }
         },
         set (target, key, value, receiver) {

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.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

@@ -36,8 +36,11 @@ const loaderModule = function(...args) {
     const mod = (0, external_utils_index_cjs_namespaceObject.getOriginLoaderModule)(this);
     if (mod.default) {
         if (false === mod.raw && Buffer.isBuffer(args[0])) args[0] = args[0].toString();
-        let start;
-        let startHRTime;
+        let start = 0;
+        let startHRTime = [
+            0,
+            0
+        ];
         const trap = index_cjs_namespaceObject.Utils.createLoaderContextTrap.call(this, (err, res, sourceMap)=>{
             (0, external_utils_index_cjs_namespaceObject.reportLoader)(this, start, startHRTime, false, false, args[0].toString(), err, res, sourceMap);
         });
@@ -61,8 +64,11 @@ const pitch = function() {
     this.cacheable(false);
     const mod = (0, external_utils_index_cjs_namespaceObject.getOriginLoaderModule)(this);
     if (mod.pitch && 'function' == typeof mod.pitch) {
-        let start;
-        let startHRTime;
+        let start = 0;
+        let startHRTime = [
+            0,
+            0
+        ];
         const trap = index_cjs_namespaceObject.Utils.createLoaderContextTrap.call(this, (err, res)=>{
             (0, external_utils_index_cjs_namespaceObject.reportLoader)(this, start, startHRTime, true, false, err ? 'Loader Pitch Async Error' : '', err, res);
         });

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/loaders/proxy.js

@@ -7,8 +7,11 @@ const loaderModule = function(...args) {
     const mod = getOriginLoaderModule(this);
     if (mod.default) {
         if (false === mod.raw && Buffer.isBuffer(args[0])) args[0] = args[0].toString();
-        let start;
-        let startHRTime;
+        let start = 0;
+        let startHRTime = [
+            0,
+            0
+        ];
         const trap = Utils.createLoaderContextTrap.call(this, (err, res, sourceMap)=>{
             reportLoader(this, start, startHRTime, false, false, args[0].toString(), err, res, sourceMap);
         });
@@ -32,8 +35,11 @@ const pitch = function() {
     this.cacheable(false);
     const mod = getOriginLoaderModule(this);
     if (mod.pitch && 'function' == typeof mod.pitch) {
-        let start;
-        let startHRTime;
+        let start = 0;
+        let startHRTime = [
+            0,
+            0
+        ];
         const trap = Utils.createLoaderContextTrap.call(this, (err, res)=>{
             reportLoader(this, start, startHRTime, true, false, err ? 'Loader Pitch Async Error' : '', err, res);
         });

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.cjs

@@ -52,13 +52,13 @@ class InternalBundleTagPlugin extends external_base_cjs_namespaceObject.Internal
                         if (true === terserDropConsole || true === swcDropConsole) logger_namespaceObject.logger.warn(logger_namespaceObject.chalk.yellow('Warning: BannerPlugin detected in project. Please disable drop_console option in TerserPlugin or SwcJsMinimizerRspackPlugin to enable Rsdoctor analysis for BannerPlugin.'));
                     }
                     const chunks = compilation.chunks;
-                    for (let chunk of chunks)for (const file of chunk.files){
+                    for (const chunk of chunks)for (const file of chunk.files){
                         if (!file || '.js' !== (0, external_path_namespaceObject.extname)(file)) continue;
                         const { ConcatSource } = compiler.webpack.sources;
                         compilation.updateAsset(file, (old)=>{
                             const concatSource = new ConcatSource();
-                            let header = "\n console.log('RSDOCTOR_START::');\n";
-                            let footer = "\n console.log('RSDOCTOR_END::');\n";
+                            const header = "\n console.log('RSDOCTOR_START::');\n";
+                            const footer = "\n console.log('RSDOCTOR_END::');\n";
                             concatSource.add(header);
                             concatSource.add(old);
                             concatSource.add(footer);

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/bundleTagPlugin.js

@@ -25,13 +25,13 @@ class InternalBundleTagPlugin extends InternalBasePlugin {
                         if (true === terserDropConsole || true === swcDropConsole) logger.warn(chalk.yellow('Warning: BannerPlugin detected in project. Please disable drop_console option in TerserPlugin or SwcJsMinimizerRspackPlugin to enable Rsdoctor analysis for BannerPlugin.'));
                     }
                     const chunks = compilation.chunks;
-                    for (let chunk of chunks)for (const file of chunk.files){
+                    for (const chunk of chunks)for (const file of chunk.files){
                         if (!file || '.js' !== extname(file)) continue;
                         const { ConcatSource } = compiler.webpack.sources;
                         compilation.updateAsset(file, (old)=>{
                             const concatSource = new ConcatSource();
-                            let header = "\n console.log('RSDOCTOR_START::');\n";
-                            let footer = "\n console.log('RSDOCTOR_END::');\n";
+                            const header = "\n console.log('RSDOCTOR_START::');\n";
+                            const footer = "\n console.log('RSDOCTOR_END::');\n";
                             concatSource.add(header);
                             concatSource.add(old);
                             concatSource.add(footer);

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

@@ -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;
     }
@@ -138,7 +138,7 @@ async function getModulesInfos(compiler, moduleGraph, chunkGraph, parseBundle, s
     if (!moduleGraph) return;
     try {
         await index_cjs_namespaceObject.Chunks.getAssetsModulesData(moduleGraph, chunkGraph, compiler.outputPath, sourceMapSets, parseBundle, assetsWithoutSourceMap);
-    } catch (e) {}
+    } catch  {}
 }
 function escapeRegExp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

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;
     }
@@ -109,7 +109,7 @@ async function getModulesInfos(compiler, moduleGraph, chunkGraph, parseBundle, s
     if (!moduleGraph) return;
     try {
         await Chunks.getAssetsModulesData(moduleGraph, chunkGraph, compiler.outputPath, sourceMapSets, parseBundle, assetsWithoutSourceMap);
-    } catch (e) {}
+    } catch  {}
 }
 function escapeRegExp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

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

@@ -137,8 +137,8 @@ async function handleAfterEmitAssets(compilation, _this, sourceMapFilenameRegex,
                     sourceMapPath = (0, external_path_namespaceObject.resolve)(outputPath, mapFileName);
                 }
             } else {
-                let sourceMapFile = asset.info.related?.sourceMap;
-                let sourceMapFileAssetName = sourceMapFile?.replace(/(\.[^.]+)(\.[^.]+)?$/, '$1');
+                const sourceMapFile = asset.info.related?.sourceMap;
+                const sourceMapFileAssetName = sourceMapFile?.replace(/(\.[^.]+)(\.[^.]+)?$/, '$1');
                 if (sourceMapFile) {
                     let sourceMapAsset = assets.find((asset)=>asset.name === sourceMapFile);
                     if (!sourceMapAsset && sourceMapFileAssetName) {