@rsdoctor/core 1.5.9 → 1.5.11

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

@@ -33,9 +33,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    normalizeUserConfig: ()=>normalizeUserConfig,
     normalizeReportType: ()=>normalizeReportType,
-    normalizeRspackUserOptions: ()=>normalizeRspackUserOptions
+    normalizeRspackUserOptions: ()=>normalizeRspackUserOptions,
+    normalizeUserConfig: ()=>normalizeUserConfig
 });
 const types_namespaceObject = require("@rsdoctor/types");
 const logger_namespaceObject = require("@rsdoctor/utils/logger");
@@ -65,6 +65,9 @@ function getDefaultSupports() {
         gzip: true
     };
 }
+function isJsonOutputEnv(value) {
+    return 'json' === value;
+}
 function normalizeFeatures(features, mode) {
     if (Array.isArray(features)) return {
         loader: features.includes('loader'),
@@ -99,9 +102,25 @@ function isValidMode(mode) {
     ].includes(mode);
 }
 function normalizeUserConfig(config = {}) {
-    const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer: userDisableClientServer = false, sdkInstance, innerClientPath = '', output = getDefaultOutput(), supports = getDefaultSupports(), port, printLog = {
+    const userOutput = config.output;
+    const defaultOutput = getDefaultOutput();
+    const outputConfig = isJsonOutputEnv(process.env.RSDOCTOR_OUTPUT) ? {
+        reportDir: userOutput?.reportDir,
+        compressData: userOutput?.compressData,
+        mode: 'brief',
+        options: {
+            type: [
+                'json'
+            ]
+        }
+    } : userOutput ?? defaultOutput;
+    const normalizedConfig = {
+        ...config,
+        output: outputConfig
+    };
+    const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer: userDisableClientServer = false, sdkInstance, innerClientPath = '', output = outputConfig, supports = getDefaultSupports(), port, printLog = {
         serverUrls: true
-    }, mode, brief } = config;
+    }, mode, brief } = normalizedConfig;
     const disableClientServer = 'true' === process.env.RSTEST ? false : process.env.CI ? true : userDisableClientServer;
     external_assert_default()('object' == typeof linter);
     external_assert_default()('object' == typeof features || Array.isArray(features));

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

@@ -26,6 +26,9 @@ function getDefaultSupports() {
         gzip: true
     };
 }
+function isJsonOutputEnv(value) {
+    return 'json' === value;
+}
 function normalizeFeatures(features, mode) {
     if (Array.isArray(features)) return {
         loader: features.includes('loader'),
@@ -60,9 +63,25 @@ function isValidMode(mode) {
     ].includes(mode);
 }
 function normalizeUserConfig(config = {}) {
-    const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer: userDisableClientServer = false, sdkInstance, innerClientPath = '', output = getDefaultOutput(), supports = getDefaultSupports(), port, printLog = {
+    const userOutput = config.output;
+    const defaultOutput = getDefaultOutput();
+    const outputConfig = isJsonOutputEnv(process.env.RSDOCTOR_OUTPUT) ? {
+        reportDir: userOutput?.reportDir,
+        compressData: userOutput?.compressData,
+        mode: 'brief',
+        options: {
+            type: [
+                'json'
+            ]
+        }
+    } : userOutput ?? defaultOutput;
+    const normalizedConfig = {
+        ...config,
+        output: outputConfig
+    };
+    const { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer: userDisableClientServer = false, sdkInstance, innerClientPath = '', output = outputConfig, supports = getDefaultSupports(), port, printLog = {
         serverUrls: true
-    }, mode, brief } = config;
+    }, mode, brief } = normalizedConfig;
     const disableClientServer = 'true' === process.env.RSTEST ? false : process.env.CI ? true : userDisableClientServer;
     assert('object' == typeof linter);
     assert('object' == typeof features || Array.isArray(features));

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

@@ -33,12 +33,12 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    interceptLoader: ()=>interceptLoader,
+    getInternalLoaderOptions: ()=>getInternalLoaderOptions,
     getLoaderOptionsWithoutInternalKeys: ()=>getLoaderOptionsWithoutInternalKeys,
-    shouldSkipLoader: ()=>shouldSkipLoader,
+    getOriginLoaderModule: ()=>getOriginLoaderModule,
+    interceptLoader: ()=>interceptLoader,
     reportLoader: ()=>reportLoader,
-    getInternalLoaderOptions: ()=>getInternalLoaderOptions,
-    getOriginLoaderModule: ()=>getOriginLoaderModule
+    shouldSkipLoader: ()=>shouldSkipLoader
 });
 const resolver_namespaceObject = require("@rspack/resolver");
 const compat_namespaceObject = require("es-toolkit/compat");

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

@@ -33,9 +33,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    handleBriefModeReport: ()=>handleBriefModeReport,
     processCompilerConfig: ()=>processCompilerConfig,
-    safeCloneDeep: ()=>safeCloneDeep,
-    handleBriefModeReport: ()=>handleBriefModeReport
+    safeCloneDeep: ()=>safeCloneDeep
 });
 const sdk_namespaceObject = require("@rsdoctor/sdk");
 const plugins_namespaceObject = require("@rsdoctor/core/plugins");

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

@@ -24,8 +24,8 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    defineRule: ()=>defineRule,
-    Rule: ()=>Rule
+    Rule: ()=>Rule,
+    defineRule: ()=>defineRule
 });
 const types_namespaceObject = require("@rsdoctor/types");
 const common_namespaceObject = require("@rsdoctor/utils/common");

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

@@ -24,11 +24,11 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    hasSameLeftInAssignStatement: ()=>hasSameLeftInAssignStatement,
-    getSourceRangeFromTransformedOffset: ()=>getSourceRangeFromTransformedOffset,
     getDefaultImportByRequest: ()=>getDefaultImportByRequest,
-    importDeclarationToString: ()=>importDeclarationToString,
-    getFixData: ()=>getFixData
+    getFixData: ()=>getFixData,
+    getSourceRangeFromTransformedOffset: ()=>getSourceRangeFromTransformedOffset,
+    hasSameLeftInAssignStatement: ()=>hasSameLeftInAssignStatement,
+    importDeclarationToString: ()=>importDeclarationToString
 });
 const ruleUtils_namespaceObject = require("@rsdoctor/utils/ruleUtils");
 const common_namespaceObject = require("@rsdoctor/utils/common");

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

@@ -24,8 +24,8 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    toSeverity: ()=>toSeverity,
-    noop: ()=>noop
+    noop: ()=>noop,
+    toSeverity: ()=>toSeverity
 });
 const types_namespaceObject = require("@rsdoctor/types");
 function toSeverity(input, defaultLevel) {

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