@rsdoctor/core 1.5.8 → 1.5.10

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

@@ -106,8 +106,8 @@ async function handleAfterEmitAssets(compilation, _this, sourceMapFilenameRegex,
                     sourceMapPath = 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) {

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

@@ -57,10 +57,10 @@ function interceptPluginHook(sdk, name, hook) {
     hook.intercept({
         register (tap) {
             const o = tap.fn;
-            if ('sync' === tap.type) tap.fn = function() {
+            if ('sync' === tap.type) tap.fn = function(...args) {
                 const start = Date.now();
                 try {
-                    const res = o.apply(this, arguments);
+                    const res = o.apply(this, args);
                     reportPluginData(sdk, name, tap.name, start, tap.type, res);
                     return res;
                 } catch (error) {
@@ -68,10 +68,10 @@ function interceptPluginHook(sdk, name, hook) {
                     throw error;
                 }
             };
-            else if ('async' === tap.type) tap.fn = async function() {
+            else if ('async' === tap.type) tap.fn = async function(...args) {
                 const start = Date.now();
                 try {
-                    const res = await o.apply(this, arguments);
+                    const res = await o.apply(this, args);
                     reportPluginData(sdk, name, tap.name, start, tap.type, res);
                     return res;
                 } catch (error) {
@@ -79,10 +79,10 @@ function interceptPluginHook(sdk, name, hook) {
                     throw error;
                 }
             };
-            else if ('promise' === tap.type) tap.fn = function() {
+            else if ('promise' === tap.type) tap.fn = function(...args) {
                 const start = Date.now();
-                const isChild = arguments?.[0]?.compiler?.isChild();
-                return o.apply(this, arguments).then((res)=>{
+                const isChild = args?.[0]?.compiler?.isChild();
+                return o.apply(this, args).then((res)=>{
                     if (isChild) return res;
                     reportPluginData(sdk, name, tap.name, start, tap.type, res);
                     return res;

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

@@ -29,10 +29,10 @@ function interceptPluginHook(sdk, name, hook) {
     hook.intercept({
         register (tap) {
             const o = tap.fn;
-            if ('sync' === tap.type) tap.fn = function() {
+            if ('sync' === tap.type) tap.fn = function(...args) {
                 const start = Date.now();
                 try {
-                    const res = o.apply(this, arguments);
+                    const res = o.apply(this, args);
                     reportPluginData(sdk, name, tap.name, start, tap.type, res);
                     return res;
                 } catch (error) {
@@ -40,10 +40,10 @@ function interceptPluginHook(sdk, name, hook) {
                     throw error;
                 }
             };
-            else if ('async' === tap.type) tap.fn = async function() {
+            else if ('async' === tap.type) tap.fn = async function(...args) {
                 const start = Date.now();
                 try {
-                    const res = await o.apply(this, arguments);
+                    const res = await o.apply(this, args);
                     reportPluginData(sdk, name, tap.name, start, tap.type, res);
                     return res;
                 } catch (error) {
@@ -51,10 +51,10 @@ function interceptPluginHook(sdk, name, hook) {
                     throw error;
                 }
             };
-            else if ('promise' === tap.type) tap.fn = function() {
+            else if ('promise' === tap.type) tap.fn = function(...args) {
                 const start = Date.now();
-                const isChild = arguments?.[0]?.compiler?.isChild();
-                return o.apply(this, arguments).then((res)=>{
+                const isChild = args?.[0]?.compiler?.isChild();
+                return o.apply(this, args).then((res)=>{
                     if (isChild) return res;
                     reportPluginData(sdk, name, tap.name, start, tap.type, res);
                     return res;

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

@@ -84,7 +84,7 @@ class Rule {
         const replace = [];
         const report = (data, remove)=>{
             if (remove) replace.push(remove);
-            let severity = data.severity ? (0, external_utils_cjs_namespaceObject.toSeverity)(data.severity, this.severity) : this.severity;
+            const severity = data.severity ? (0, external_utils_cjs_namespaceObject.toSeverity)(data.severity, this.severity) : this.severity;
             const error = {
                 ...data,
                 code: this.code,

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

@@ -56,7 +56,7 @@ class rule_Rule {
         const replace = [];
         const report = (data, remove)=>{
             if (remove) replace.push(remove);
-            let severity = data.severity ? toSeverity(data.severity, this.severity) : this.severity;
+            const severity = data.severity ? toSeverity(data.severity, this.severity) : this.severity;
             const error = {
                 ...data,
                 code: this.code,

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

@@ -42,6 +42,16 @@ var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_na
 const types_namespaceObject = require("@rsdoctor/types");
 const external_rule_cjs_namespaceObject = require("../../rule.cjs");
 const title = 'esm-resolved-to-cjs';
+function normalizePathForCompare(filePath) {
+    const queryIndex = filePath.indexOf('?');
+    const hashIndex = filePath.indexOf('#');
+    const splitIndex = [
+        queryIndex,
+        hashIndex
+    ].filter((index)=>index >= 0).reduce((min, index)=>Math.min(min, index), 1 / 0);
+    const cleanPath = splitIndex === 1 / 0 ? filePath : filePath.slice(0, splitIndex);
+    return external_path_default().normalize(cleanPath);
+}
 function extractEsmEntry(pkgJson, pkgRoot) {
     const { exports: exportsField, module: moduleField } = pkgJson;
     if (null !== exportsField && 'object' == typeof exportsField) {
@@ -78,6 +88,7 @@ const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
         },
         check ({ moduleGraph, packageGraph, report, ruleConfig }) {
             const pkgJsonCache = new Map();
+            const realPathCache = new Map();
             const readPkgJson = (pkgRoot)=>{
                 if (pkgJsonCache.has(pkgRoot)) return pkgJsonCache.get(pkgRoot);
                 try {
@@ -90,14 +101,31 @@ const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
                     return null;
                 }
             };
+            const toRealPath = (filePath)=>{
+                const normalized = normalizePathForCompare(filePath);
+                if (realPathCache.has(normalized)) return realPathCache.get(normalized);
+                try {
+                    const realPath = 'function' == typeof external_fs_default().realpathSync.native ? external_fs_default().realpathSync.native(normalized) : external_fs_default().realpathSync(normalized);
+                    const normalizedRealPath = external_path_default().normalize(realPath);
+                    realPathCache.set(normalized, normalizedRealPath);
+                    return normalizedRealPath;
+                } catch  {
+                    realPathCache.set(normalized, normalized);
+                    return normalized;
+                }
+            };
             const groups = new Map();
             const inNodeModules = /[/\\]node_modules[/\\]/;
             for (const dep of moduleGraph.getDependencies()){
                 if (dep.kind !== types_namespaceObject.SDK.DependencyKind.ImportStatement || inNodeModules.test(dep.module.path) || !inNodeModules.test(dep.dependency.path) || dep.dependency.meta.strictHarmonyModule || ruleConfig.ignore.some((p)=>dep.request.includes(p))) continue;
                 const pkg = packageGraph.getPackageByModule(dep.dependency);
-                const esmEntry = pkg?.root && !ruleConfig.ignore.some((p)=>pkg.name.includes(p)) && readPkgJson(pkg.root) && extractEsmEntry(readPkgJson(pkg.root), pkg.root);
+                if (!pkg?.root) continue;
+                const pkgJson = readPkgJson(pkg.root);
+                const esmEntry = !ruleConfig.ignore.some((p)=>pkg.name.includes(p)) && pkgJson && extractEsmEntry(pkgJson, pkg.root);
                 if (!esmEntry) continue;
-                const groupKey = `${pkg.name}::${dep.dependency.path}`;
+                const resolvedModuleRealPath = toRealPath(dep.dependency.path);
+                if (resolvedModuleRealPath === toRealPath(esmEntry)) continue;
+                const groupKey = `${pkg.name}::${resolvedModuleRealPath}`;
                 const issuer = {
                     id: dep.module.id,
                     path: dep.module.path,

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

@@ -4,6 +4,16 @@ import path from "path";
 import { Linter, SDK } from "@rsdoctor/types";
 import { defineRule } from "../../rule.js";
 const title = 'esm-resolved-to-cjs';
+function normalizePathForCompare(filePath) {
+    const queryIndex = filePath.indexOf('?');
+    const hashIndex = filePath.indexOf('#');
+    const splitIndex = [
+        queryIndex,
+        hashIndex
+    ].filter((index)=>index >= 0).reduce((min, index)=>Math.min(min, index), 1 / 0);
+    const cleanPath = splitIndex === 1 / 0 ? filePath : filePath.slice(0, splitIndex);
+    return path.normalize(cleanPath);
+}
 function extractEsmEntry(pkgJson, pkgRoot) {
     const { exports: exportsField, module: moduleField } = pkgJson;
     if (null !== exportsField && 'object' == typeof exportsField) {
@@ -40,6 +50,7 @@ const rule = defineRule(()=>({
         },
         check ({ moduleGraph, packageGraph, report, ruleConfig }) {
             const pkgJsonCache = new Map();
+            const realPathCache = new Map();
             const readPkgJson = (pkgRoot)=>{
                 if (pkgJsonCache.has(pkgRoot)) return pkgJsonCache.get(pkgRoot);
                 try {
@@ -52,14 +63,31 @@ const rule = defineRule(()=>({
                     return null;
                 }
             };
+            const toRealPath = (filePath)=>{
+                const normalized = normalizePathForCompare(filePath);
+                if (realPathCache.has(normalized)) return realPathCache.get(normalized);
+                try {
+                    const realPath = 'function' == typeof fs.realpathSync.native ? fs.realpathSync.native(normalized) : fs.realpathSync(normalized);
+                    const normalizedRealPath = path.normalize(realPath);
+                    realPathCache.set(normalized, normalizedRealPath);
+                    return normalizedRealPath;
+                } catch  {
+                    realPathCache.set(normalized, normalized);
+                    return normalized;
+                }
+            };
             const groups = new Map();
             const inNodeModules = /[/\\]node_modules[/\\]/;
             for (const dep of moduleGraph.getDependencies()){
                 if (dep.kind !== SDK.DependencyKind.ImportStatement || inNodeModules.test(dep.module.path) || !inNodeModules.test(dep.dependency.path) || dep.dependency.meta.strictHarmonyModule || ruleConfig.ignore.some((p)=>dep.request.includes(p))) continue;
                 const pkg = packageGraph.getPackageByModule(dep.dependency);
-                const esmEntry = pkg?.root && !ruleConfig.ignore.some((p)=>pkg.name.includes(p)) && readPkgJson(pkg.root) && extractEsmEntry(readPkgJson(pkg.root), pkg.root);
+                if (!pkg?.root) continue;
+                const pkgJson = readPkgJson(pkg.root);
+                const esmEntry = !ruleConfig.ignore.some((p)=>pkg.name.includes(p)) && pkgJson && extractEsmEntry(pkgJson, pkg.root);
                 if (!esmEntry) continue;
-                const groupKey = `${pkg.name}::${dep.dependency.path}`;
+                const resolvedModuleRealPath = toRealPath(dep.dependency.path);
+                if (resolvedModuleRealPath === toRealPath(esmEntry)) continue;
+                const groupKey = `${pkg.name}::${resolvedModuleRealPath}`;
                 const issuer = {
                     id: dep.module.id,
                     path: dep.module.path,

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