@rsdoctor/core 1.5.9 → 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.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

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

@@ -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.d.cts

@@ -0,0 +1,52 @@
+import { RsdoctorPluginInstance } from '../../types';
+import { Linter, Plugin } from '@rsdoctor/types';
+export declare const UNASSIGNED = "[unassigned]";
+/**
+ * Options for handling source map assets.
+ * @param compilation - The current compilation object.
+ * @param pluginInstance - The Rsdoctor plugin instance.
+ * @param sourceMapFilenameRegex - Regex to extract file paths from source map sources.
+ * @param namespace - Optional namespace for resolving sources.
+ */
+interface SourceMapAssetOptions {
+    compilation: Plugin.BaseCompilation;
+    pluginInstance: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData<any, string>[]>;
+    sourceMapFilenameRegex: RegExp;
+    namespace?: string;
+}
+/**
+ * Binds a context cache to a source path resolver.
+ * @param context - The base context directory.
+ * @param namespace - Optional namespace for resolving sources.
+ * @param cache - The cache map to store resolved paths.
+ * @param sourceMapDir - The directory containing source maps.
+ * @param sourceRoot - The source root directory.
+ * @returns A function that resolves source paths based on the given context.
+ */
+export declare function bindContextCache(context: string, namespace?: string, cache?: Map<string, string>, sourceMapDir?: string, sourceRoot?: string): (source: string, sourceMapFilenameRegex?: RegExp) => string;
+/**
+ * Collects and processes source map information for a given asset.
+ * Groups mappings by line, sorts them, and reconstructs the original source code segments.
+ * @param map - The raw source map object.
+ * @param assetLinesCodeList - The code lines of the asset.
+ * @param _compilation - The current compilation object.
+ * @param _this - The Rsdoctor plugin instance.
+ * @param sourceMapFilenameRegex - Regex to extract file paths from source map sources.
+ * @param namespace - Optional namespace for resolving sources.
+ */
+export declare function collectSourceMaps(map: any, assetLinesCodeList: string[], _compilation: Plugin.BaseCompilation, _this: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData[]>, sourceMapFilenameRegex?: RegExp, namespace?: string, skipSources?: Set<string>, sourceMapPath?: string): Promise<void>;
+/**
+ * Handles the afterEmit event for assets to collect source map information.
+ * @param compilation - The current compilation object.
+ * @param _this - The Rsdoctor plugin instance.
+ * @param sourceMapFilenameRegex - Regex to extract file paths from source map sources.
+ * @param namespace - Optional namespace for resolving sources.
+ */
+export declare function handleAfterEmitAssets(compilation: Plugin.BaseCompilation, _this: RsdoctorPluginInstance<Plugin.BaseCompiler, Linter.ExtendRuleData<any, string>[]>, sourceMapFilenameRegex?: RegExp, namespace?: string): Promise<void>;
+/**
+ * Handles the emit event for assets to collect source map information.
+ * @param options - The options for handling source map assets.
+ * @returns A promise that resolves when the source map information is collected.
+ */
+export declare function handleEmitAssets(options: SourceMapAssetOptions): Promise<void>;
+export {};

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

@@ -100,7 +100,7 @@ class InternalSummaryPlugin extends external_base_cjs_namespaceObject.InternalBa
                     const minifyHookData = [
                         ...pluginData.processAssets || []
                     ];
-                    minifyHookData.length && this.sdk.reportSummaryData({
+                    if (minifyHookData.length) this.sdk.reportSummaryData({
                         costs: [
                             {
                                 name: common_namespaceObject.Summary.SummaryCostsDataName.Minify,

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

@@ -0,0 +1,14 @@
+import type { Plugin } from '@rsdoctor/types';
+import { InternalBasePlugin } from './base';
+export declare class InternalSummaryPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
+    readonly name = "summary";
+    private times;
+    private preTimes;
+    private postTimes;
+    apply(compiler: T): void;
+    private mark;
+    beforeCompile: () => Promise<void>;
+    afterCompile: (compilation: Plugin.BaseCompilation) => Promise<void>;
+    done: (compiler: T) => Promise<void>;
+    private report;
+}

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

@@ -73,7 +73,7 @@ class InternalSummaryPlugin extends InternalBasePlugin {
                     const minifyHookData = [
                         ...pluginData.processAssets || []
                     ];
-                    minifyHookData.length && this.sdk.reportSummaryData({
+                    if (minifyHookData.length) this.sdk.reportSummaryData({
                         costs: [
                             {
                                 name: Summary.SummaryCostsDataName.Minify,

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

@@ -0,0 +1,4 @@
+export declare const checkCirclePath: (obj: any, record: {
+    prop: string;
+    ref: unknown;
+}[], res: string[][], level: number, maxLevel?: number) => void;

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

@@ -0,0 +1,5 @@
+import { RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../../types';
+import { Linter, Plugin, SDK } from '@rsdoctor/types';
+export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorWebpackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
+export declare const normalizeReportType: (reportCodeType: Plugin.IReportCodeType | Plugin.NewReportCodeType, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
+export declare function normalizeRspackUserOptions<Rules extends Linter.ExtendRuleData[]>(options: RsdoctorRspackPluginOptions<Rules>): RsdoctorRspackPluginOptionsNormalized<Rules>;

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

@@ -0,0 +1,9 @@
+export * from './loader';
+export * from './plugin';
+export * from './sdk';
+export * from './config';
+export * from './circleDetect';
+export * from './plugin-common';
+export * from './normalize-config';
+export * from './plugin-common';
+export * from './normalize-config';

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

@@ -0,0 +1,13 @@
+import { Loader } from '@rsdoctor/utils/common';
+import { SDK, Plugin } from '@rsdoctor/types';
+import { ProxyLoaderInternalOptions, ProxyLoaderOptions } from '../../types';
+import { Utils as BuildUtils } from '../../build-utils/build';
+export declare function getInternalLoaderOptions(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ProxyLoaderInternalOptions;
+export declare function getLoaderOptionsWithoutInternalKeys(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): Omit<ProxyLoaderOptions, typeof Loader.LoaderInternalPropertyName>;
+export declare function getOriginLoaderModule(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ReturnType<typeof BuildUtils.loadLoaderModule>;
+export declare function shouldSkipLoader(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): boolean;
+export type CompatibleResolve = Omit<Plugin.Configuration['resolve'], 'mainFields'> & {
+    mainFields?: string[];
+};
+export declare function interceptLoader<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderPath: string, options: Omit<ProxyLoaderInternalOptions, 'loader' | 'hasOptions'>, cwd?: string, resolveLoader?: CompatibleResolve): T[];
+export declare function reportLoader(ctx: Plugin.LoaderContext<ProxyLoaderOptions>, start: number, startHRTime: [number, number], isPitch: boolean, sync: boolean, code: string, err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Plugin.SourceMapInput): Promise<SDK.LoaderData>;

package/dist/inner-plugins/utils/normalize-config.d.cts

@@ -0,0 +1,40 @@
+import { Config, Plugin, SDK } from '@rsdoctor/types';
+import type { RuleSetCondition as RspackRuleSetCondition, RuleSetRule as RspackRuleSetRule } from '@rspack/core';
+import { RuleSetCondition as WebpackRuleSetCondition, RuleSetConditionAbsolute as WebpackRuleSetConditionAbsolute, RuleSetRule as WebpackRuleSetRule } from 'webpack';
+/**
+ * Process mode-specific configurations with priority logic
+ */
+export declare function processModeConfigurations(finalMode: keyof typeof SDK.IMode, output: Config.IOutput<'brief' | 'normal'>, brief: Config.BriefConfig | undefined): {
+    finalBrief: {};
+    finalNormalOptions: Config.NormalModeOptions;
+};
+/**
+ * Process brief mode configuration with priority logic
+ * Priority: output.options.briefOptions > output.brief > default
+ */
+export declare function processBriefHtmlModeConfig(output: Config.BriefModeConfig, brief: Config.BriefConfig | undefined): Config.BriefModeOptions;
+/**
+ * Convert reportCodeType object to NewReportCodeType enum value
+ */
+export declare function convertReportCodeTypeObject(reportCodeType: any): Config.NewReportCodeType | undefined;
+/**
+ * This function recursively processes rule set conditions to ensure they can be
+ * properly serialized to JSON.
+ *
+ * @param item - The rule set condition to make serializable. Can be:
+ *   - RspackRuleSetCondition: Rspack-specific rule conditions
+ *   - WebpackRuleSetConditionAbsolute: Webpack absolute rule conditions
+ *   - WebpackRuleSetCondition: Webpack rule conditions
+ *   - void: Undefined or null values
+ *
+ * @example
+ * ```typescript
+ * const condition = /\.js$/;
+ * JSON.stringify(condition); // Error: Converting circular structure to JSON
+ *
+ * makeRuleSetSerializable(condition);
+ * JSON.stringify(condition); // '"/\\.js$/"'
+ * ```
+ */
+export declare function makeRuleSetSerializable(item: RspackRuleSetCondition | WebpackRuleSetConditionAbsolute | WebpackRuleSetCondition | void): void;
+export declare function makeRulesSerializable(rules: Plugin.RuleSetRule[] | RspackRuleSetRule['oneOf'] | WebpackRuleSetRule['oneOf']): void;

package/dist/inner-plugins/utils/plugin-common.d.cts

@@ -0,0 +1,11 @@
+import type { Configuration } from '@rspack/core';
+/**
+ * Safe cloneDeep implementation that skips read-only properties (getters without setters)
+ * to avoid errors when cloning objects like AppContext that have read-only properties
+ */
+export declare function safeCloneDeep<T>(value: T, visited?: WeakMap<WeakKey, any>): T;
+/**
+ * Process compiler configuration to make it serializable
+ */
+export declare function processCompilerConfig(config: any): Configuration;
+export declare function handleBriefModeReport(sdk: any, options: any, disableClientServer: boolean): Promise<void>;

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

@@ -0,0 +1,4 @@
+import type { SDK } from '@rsdoctor/types';
+import { IHook } from '../../build-utils/build/utils';
+export declare function reportPluginData(sdk: SDK.RsdoctorBuilderSDKInstance, hook: string, tapName: string, start: number, type: SDK.PluginHookData['type'], _res: unknown, err?: Error): void;
+export declare function interceptPluginHook(sdk: SDK.RsdoctorBuilderSDKInstance, name: string, hook: IHook): void;

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

@@ -0,0 +1,8 @@
+import { RsdoctorPrimarySDK } from '@rsdoctor/sdk';
+import { SDK } from '@rsdoctor/types';
+declare global {
+    var __rsdoctor_sdks__: SDK.RsdoctorBuilderSDKInstance[] | undefined;
+    var __rsdoctor_sdk__: SDK.RsdoctorBuilderSDKInstance | undefined;
+}
+export declare function setSDK(t: SDK.RsdoctorBuilderSDKInstance): void;
+export declare function getSDK(builderName?: string): RsdoctorPrimarySDK | SDK.RsdoctorBuilderSDKInstance | undefined;

package/dist/rules/index.d.cts

@@ -0,0 +1,3 @@
+export * from './linter';
+export * from './rule';
+export { rules } from './rules';

package/dist/rules/linter.d.cts

@@ -0,0 +1,9 @@
+import { Linter as LinterType, SDK } from '@rsdoctor/types';
+export { LinterType };
+export declare class Linter<Rules extends LinterType.ExtendRuleData[]> {
+    private rules;
+    constructor({ rules, extends: extendRules, level, }?: LinterType.Options<Rules>);
+    private getRules;
+    validate(context: SDK.RuntimeContext): Promise<LinterType.ValidateResult>;
+    afterValidate(context: LinterType.InternalRuleCheckerContextForCheckEnd): Promise<void>;
+}

package/dist/rules/rule.d.cts

@@ -0,0 +1,27 @@
+import { Linter, SDK, Rule as RuleTypes } from '@rsdoctor/types';
+import { LinterType } from './linter';
+type DefaultRuleConfig = Linter.DefaultRuleConfig;
+export declare class Rule<Config = DefaultRuleConfig> implements Linter.RuleMeta<Config> {
+    static from<C>(data: Linter.ExtendRuleData<C>): Rule<C>;
+    readonly meta: Linter.RuleMeta<Config>;
+    private check;
+    /**
+     * execute when check end
+     */
+    private onCheckEnd;
+    private _severity;
+    private _config?;
+    constructor(data: Linter.RuleData<Config>);
+    get code(): RuleTypes.RuleMessageCode;
+    get title(): string;
+    get severity(): Linter.Severity;
+    get config(): Config | undefined;
+    get category(): "compile" | "bundle" | RuleTypes.RuleMessageCategory | "emo";
+    setOption(opt: Linter.RuleConfigItem): void;
+    match(level: Linter.Severity): boolean;
+    validate(context: SDK.RuntimeContext): Promise<Linter.ValidateResult>;
+    afterValidate({ hooks, validateResult, data, }: LinterType.InternalRuleCheckerContextForCheckEnd<Config>): Promise<void>;
+}
+export declare function defineRule<Title extends Linter.DefaultRuleTitle, T = Linter.DefaultRuleConfig>(ruleCreator: Linter.ExtendRuleConstructor<Title, T>): Linter.ExtendRuleData<T, Title>;
+export declare function defineRule<Title extends Linter.DefaultRuleTitle, T = Linter.DefaultRuleConfig>(ruleCreator: Linter.RuleConstructor<Title, T>): Linter.RuleData<T, Title>;
+export {};

package/dist/rules/rules/cjs-require/index.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import type { Config } from './types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "cjs-require">;

package/dist/rules/rules/cjs-require/types.d.cts

@@ -0,0 +1,7 @@
+export interface Config {
+    /**
+     * Module path patterns to ignore (applied to both issuer and required module paths).
+     * Defaults to [].
+     */
+    ignore: string[];
+}

package/dist/rules/rules/cross-chunks-package/index.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import { Config } from './types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "cross-chunks-package">;

package/dist/rules/rules/cross-chunks-package/types.d.cts

@@ -0,0 +1,3 @@
+export interface Config {
+    ignore: string[];
+}

package/dist/rules/rules/cross-chunks-package/utils.d.cts

@@ -0,0 +1 @@
+export declare function getErrorMsgForDupPckChunks(chunks: string[], pkgName: string): string;

package/dist/rules/rules/default-import-check/index.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import type { Config } from './types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "default-import-check">;

package/dist/rules/rules/default-import-check/types.d.cts

@@ -0,0 +1,4 @@
+export interface Config {
+    /** Packages that need to be ignored */
+    ignore: string[];
+}

package/dist/rules/rules/default-import-check/utils.d.cts

@@ -0,0 +1,10 @@
+import { Node, Range } from '@rsdoctor/utils/ruleUtils';
+import type { SDK, Linter } from '@rsdoctor/types';
+export declare function getDefaultImportByRequest(node: Node.Program, request: string): Node.ImportDeclaration | undefined;
+/**
+ * Determine that it contains the same left value assignment expression in the enumeration.
+ */
+export declare function hasSameLeftInAssignStatement(node: Node.Program, compare: Node.SyntaxNode[]): Node.Pattern | undefined;
+export declare function importDeclarationToString(node: Node.ImportDeclaration): string;
+export declare function getFixData(module: SDK.ModuleInstance, node: Node.ImportDeclaration, originalRange: Range): Linter.FixData;
+export declare function getSourceRangeFromTransformedOffset(module: SDK.ModuleInstance, node: Node.SyntaxNode): Linter.ReportDocument | undefined;

package/dist/rules/rules/duplicate-package/index.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import * as duplicatePackageTypes from './types';
+export type { Config, CheckVersion } from './types';
+export declare const rule: Linter.RuleData<duplicatePackageTypes.Config, "duplicate-package">;

package/dist/rules/rules/duplicate-package/types.d.cts

@@ -0,0 +1,24 @@
+export declare enum CheckVersion {
+    null = 0,
+    prerelease = 1,
+    prepatch = 16,
+    patch = 256,
+    preminor = 4096,
+    minor = 65536,
+    premajor = 1048576,
+    major = 16777216
+}
+export declare enum CheckVersionMap {
+    null = 0,
+    prerelease = 1,
+    prepatch = 17,
+    patch = 273,
+    preminor = 4369,
+    minor = 69905,
+    premajor = 1118481,
+    major = 17895697
+}
+export interface Config {
+    checkVersion: keyof typeof CheckVersion;
+    ignore: string[];
+}

package/dist/rules/rules/duplicate-package/utils.d.cts

@@ -0,0 +1,3 @@
+import type { SDK, Rule } from '@rsdoctor/types';
+export declare function getErrorMsg(packages: SDK.PackageInstance[], root: string): string;
+export declare function getErrorDetail(pkg: SDK.PackageInstance, pkgGraph: SDK.PackageGraphInstance): Rule.PackageRelationData;

package/dist/rules/rules/ecma-version-check/index.d.cts

@@ -0,0 +1,4 @@
+import { Config } from './types';
+import { Linter } from '@rsdoctor/types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "ecma-version-check">;

package/dist/rules/rules/ecma-version-check/types.d.cts

@@ -0,0 +1,3 @@
+import type { PluginCheckSyntaxOptions } from '@rsbuild/plugin-check-syntax';
+export interface Config extends PluginCheckSyntaxOptions {
+}

package/dist/rules/rules/ecma-version-check/utils.d.cts

@@ -0,0 +1,2 @@
+import type { ECMAVersion } from '@rsdoctor/utils/ruleUtils';
+export declare function getVersionNumber(ECMAString: ECMAVersion): number | undefined;

package/dist/rules/rules/esm-resolved-to-cjs/index.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import type { Config } from './types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "esm-resolved-to-cjs">;

package/dist/rules/rules/esm-resolved-to-cjs/types.d.cts

@@ -0,0 +1,8 @@
+export interface Config {
+    /**
+     * Package name patterns to ignore (substring match against the import request).
+     * @example ['my-legacy-pkg', '@internal/']
+     * @default []
+     */
+    ignore: string[];
+}

package/dist/rules/rules/index.d.cts

@@ -0,0 +1 @@
+export declare const rules: (import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./duplicate-package").Config, "duplicate-package"> | import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./default-import-check").Config, "default-import-check"> | import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./loader-performance-optimization").Config, "loader-performance-optimization"> | import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./ecma-version-check").Config, "ecma-version-check"> | import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./cross-chunks-package").Config, "cross-chunks-package"> | import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./module-mixed-chunks").Config, "module-mixed-chunks"> | import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./side-effects-only-imports").Config, "tree-shaking-side-effects-only"> | import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./cjs-require").Config, "cjs-require"> | import("node_modules/@rsdoctor/types/dist/linter").RuleData<import("./esm-resolved-to-cjs").Config, "esm-resolved-to-cjs">)[];

package/dist/rules/rules/loader-performance-optimization/index.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import { Config } from './types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "loader-performance-optimization">;

package/dist/rules/rules/loader-performance-optimization/types.d.cts

@@ -0,0 +1,22 @@
+import type { SDK } from '@rsdoctor/types';
+export interface Config {
+    /**
+     * loaders which should be ignore.
+     */
+    ignore?: (string | RegExp)[];
+    /**
+     * threshold which the loader total costs.
+     * @unit millisecond
+     * @default 5000
+     */
+    threshold?: number;
+    /**
+     * the file extensions which will be match in rule check.
+     * @default ["js", "css", "jpg", "jpeg", "png", "gif", "webp", "svg"]
+     */
+    extensions?: (string | RegExp)[];
+}
+export interface LoaderMapValue extends SDK.LoaderTransformData {
+    __resource__: SDK.ResourceData;
+    __costs__: number;
+}

package/dist/rules/rules/loader-performance-optimization/utils.d.cts

@@ -0,0 +1 @@
+export declare function match(str: string, patterns: (string | RegExp)[]): boolean;

package/dist/rules/rules/module-mixed-chunks/index.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import { Config } from './types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "module-mixed-chunks">;

package/dist/rules/rules/module-mixed-chunks/types.d.cts

@@ -0,0 +1,3 @@
+export interface Config {
+    ignore: string[];
+}

package/dist/rules/rules/side-effects-only-imports/index.d.cts

@@ -0,0 +1,4 @@
+import { Linter } from '@rsdoctor/types';
+import type { Config } from './types';
+export type { Config } from './types';
+export declare const rule: Linter.RuleData<Config, "tree-shaking-side-effects-only">;

package/dist/rules/rules/side-effects-only-imports/types.d.cts

@@ -0,0 +1,9 @@
+export interface Config {
+    /** Module path patterns to ignore */
+    ignore: string[];
+    /**
+     * Module path patterns to include when the module is under node_modules.
+     * Example: ['react', '@babel/runtime']
+     */
+    include: string[];
+}

package/dist/rules/utils.d.cts

@@ -0,0 +1,3 @@
+import { Linter } from '@rsdoctor/types';
+export declare function toSeverity(input: Linter.SeverityInput, defaultLevel: Linter.Severity): Linter.Severity;
+export declare function noop(): void;

package/dist/types/chunks.d.cts

@@ -0,0 +1,6 @@
+import { Plugin } from '@rsdoctor/types';
+export type AssetsModules = {
+    label?: string;
+    isAsset?: boolean;
+    modules?: Plugin.StatsModule[];
+};

package/dist/types/index.d.cts

@@ -0,0 +1,4 @@
+export * from './chunks';
+export * from './rules';
+export * from './loader';
+export * from './plugin';

package/dist/types/loader.d.cts

@@ -0,0 +1,19 @@
+import { Loader } from '@rsdoctor/utils/common';
+export interface ProxyLoaderInternalOptions {
+    cwd: string;
+    /**
+     * the url host of http server(which used to collect data).
+     */
+    host: string;
+    /**
+     * correct loader path.
+     */
+    loader: string;
+    /** include the loader option */
+    hasOptions: boolean;
+    skipLoaders: string[];
+}
+export interface ProxyLoaderOptions {
+    [key: string]: any;
+    [Loader.LoaderInternalPropertyName]: ProxyLoaderInternalOptions;
+}

package/dist/types/plugin.d.cts

@@ -0,0 +1,51 @@
+import type { RsdoctorPrimarySDK } from '@rsdoctor/sdk';
+import type { Linter, Linter as LinterType, Plugin, SDK } from '@rsdoctor/types';
+export interface RsdoctorMultiplePluginOptions<Rules extends LinterType.ExtendRuleData[] = LinterType.ExtendRuleData[]> extends Omit<Plugin.RsdoctorWebpackPluginOptions<Rules>, 'sdkInstance'>, Pick<ConstructorParameters<typeof RsdoctorPrimarySDK>[0], 'stage'> {
+    /**
+     * name of builder
+     */
+    name?: string;
+}
+export interface BasePluginInstance<T extends Plugin.BaseCompiler> {
+    apply: (compiler: T) => void;
+    [k: string]: any;
+}
+export interface InternalPlugin<T extends Plugin.BaseCompiler, Rules extends LinterType.ExtendRuleData[] = []> extends BasePluginInstance<T> {
+    readonly name: string;
+    readonly scheduler: RsdoctorPluginInstance<T, Rules>;
+}
+export interface RsdoctorPluginInstance<T extends Plugin.BaseCompiler, Rules extends LinterType.ExtendRuleData[] = []> extends BasePluginInstance<T> {
+    readonly name: string;
+    readonly options: Plugin.RsdoctorPluginOptionsNormalized<Rules>;
+    readonly sdk: SDK.RsdoctorBuilderSDKInstance;
+    readonly isRsdoctorPlugin: boolean;
+    _modulesGraphApplied?: boolean;
+    chunkGraph?: SDK.ChunkGraphInstance;
+    modulesGraph: SDK.ModuleGraphInstance;
+    ensureModulesChunksGraphApplied(compiler: T): void;
+}
+export interface RsdoctorRspackPluginInstance<Rules extends LinterType.ExtendRuleData[] = []> extends RsdoctorPluginInstance<Plugin.BaseCompilerType<'rspack'>, Rules> {
+}
+export interface NativePluginConfig {
+    moduleGraph?: boolean;
+    chunkGraph?: boolean;
+}
+export interface RsdoctorRspackPluginExperiments {
+    /**
+     * Whether to enable the native plugin to improve the performance.
+     * @default true
+     */
+    enableNativePlugin?: boolean;
+}
+export interface RsdoctorRspackPluginExperimentsNormalized {
+    enableNativePlugin?: NativePluginConfig;
+}
+export interface RsdoctorRspackPluginOptions<Rules extends LinterType.ExtendRuleData[]> extends Plugin.RsdoctorWebpackPluginOptions<Rules> {
+    /**
+     * The experiments of the Rsdoctor Rspack plugin.
+     */
+    experiments?: RsdoctorRspackPluginExperiments;
+}
+export type RsdoctorRspackPluginOptionsNormalized<Rules extends Linter.ExtendRuleData[]> = Plugin.RsdoctorPluginOptionsNormalized<Rules> & {
+    experiments?: RsdoctorRspackPluginExperimentsNormalized;
+};

package/dist/types/rules.d.cts

@@ -0,0 +1,7 @@
+import { RuleSetRule } from 'webpack';
+export interface Rule extends RuleSetRule {
+    /**
+     * https://webpack.js.org/configuration/module/#ruleloaders
+     */
+    loaders: RuleSetRule['use'];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/core",
-  "version": "1.5.9",
+  "version": "1.5.10",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
@@ -16,29 +16,54 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./build-utils": {
-      "types": "./dist/build-utils/build/index.d.ts",
-      "import": "./dist/build-utils/build/index.js",
-      "default": "./dist/build-utils/build/index.cjs"
+      "import": {
+        "types": "./dist/build-utils/build/index.d.ts",
+        "default": "./dist/build-utils/build/index.js"
+      },
+      "require": {
+        "types": "./dist/build-utils/build/index.d.cts",
+        "default": "./dist/build-utils/build/index.cjs"
+      }
     },
     "./plugins": {
-      "types": "./dist/inner-plugins/index.d.ts",
-      "import": "./dist/inner-plugins/index.js",
-      "default": "./dist/inner-plugins/index.cjs"
+      "import": {
+        "types": "./dist/inner-plugins/index.d.ts",
+        "default": "./dist/inner-plugins/index.js"
+      },
+      "require": {
+        "types": "./dist/inner-plugins/index.d.cts",
+        "default": "./dist/inner-plugins/index.cjs"
+      }
     },
     "./rules": {
-      "types": "./dist/rules/index.d.ts",
-      "import": "./dist/rules/index.js",
-      "default": "./dist/rules/index.cjs"
+      "import": {
+        "types": "./dist/rules/index.d.ts",
+        "default": "./dist/rules/index.js"
+      },
+      "require": {
+        "types": "./dist/rules/index.d.cts",
+        "default": "./dist/rules/index.cjs"
+      }
     },
     "./types": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/types/index.js",
-      "default": "./dist/types/index.cjs"
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/types/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.cts",
+        "default": "./dist/types/index.cjs"
+      }
     }
   },
   "typesVersions": {
@@ -69,13 +94,13 @@
     "fs-extra": "^11.1.1",
     "semver": "^7.7.4",
     "source-map": "^0.7.6",
-    "@rsdoctor/graph": "1.5.9",
-    "@rsdoctor/sdk": "1.5.9",
-    "@rsdoctor/types": "1.5.9",
-    "@rsdoctor/utils": "1.5.9"
+    "@rsdoctor/graph": "1.5.10",
+    "@rsdoctor/utils": "1.5.10",
+    "@rsdoctor/sdk": "1.5.10",
+    "@rsdoctor/types": "1.5.10"
   },
   "devDependencies": {
-    "@rspack/core": "2.0.0-rc.1",
+    "@rspack/core": "2.0.0",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.8.1",
     "@types/node-fetch": "^2.6.13",