@rsdoctor/core 1.5.3 → 1.5.5

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

@@ -0,0 +1,82 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    rule: ()=>rule
+});
+const types_namespaceObject = require("@rsdoctor/types");
+const external_rule_cjs_namespaceObject = require("../../rule.cjs");
+const title = 'cjs-require';
+const CJS_REQUIRE_TYPE = 'cjs require';
+function isNodeModulesPath(modulePath) {
+    return modulePath.includes('/node_modules/');
+}
+const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
+        meta: {
+            code: 'E1008',
+            title,
+            category: 'bundle',
+            severity: types_namespaceObject.Linter.Severity.Warn,
+            defaultConfig: {
+                ignore: []
+            }
+        },
+        check ({ moduleGraph, report, ruleConfig }) {
+            const dependencies = moduleGraph.getDependencies();
+            for (const dep of dependencies){
+                if (dep.typeString !== CJS_REQUIRE_TYPE) continue;
+                const issuerPath = dep.module.path;
+                if (isNodeModulesPath(issuerPath)) continue;
+                const requiredModule = dep.dependency;
+                if (ruleConfig.ignore.some((pattern)=>issuerPath.includes(pattern) || requiredModule.path.includes(pattern))) continue;
+                const detail = {
+                    type: title,
+                    issuerModule: {
+                        id: dep.module.id,
+                        path: dep.module.path,
+                        webpackId: dep.module.webpackId
+                    },
+                    requiredModule: {
+                        id: requiredModule.id,
+                        path: requiredModule.path,
+                        webpackId: requiredModule.webpackId
+                    },
+                    request: dep.request
+                };
+                const message = `"${issuerPath}" uses \`require('${dep.request}')\` (CJS require) which prevents tree-shaking of the entire module "${requiredModule.path}". Consider using \`require('${dep.request}').property\` or ESM \`import\` instead.`;
+                report({
+                    message,
+                    detail
+                });
+            }
+        }
+    }));
+exports.rule = __webpack_exports__.rule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "rule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/rules/rules/cjs-require/index.js

@@ -0,0 +1,49 @@
+import "node:module";
+import { Linter } from "@rsdoctor/types";
+import { defineRule } from "../../rule.js";
+const title = 'cjs-require';
+const CJS_REQUIRE_TYPE = 'cjs require';
+function isNodeModulesPath(modulePath) {
+    return modulePath.includes('/node_modules/');
+}
+const rule = defineRule(()=>({
+        meta: {
+            code: 'E1008',
+            title: title,
+            category: 'bundle',
+            severity: Linter.Severity.Warn,
+            defaultConfig: {
+                ignore: []
+            }
+        },
+        check ({ moduleGraph, report, ruleConfig }) {
+            const dependencies = moduleGraph.getDependencies();
+            for (const dep of dependencies){
+                if (dep.typeString !== CJS_REQUIRE_TYPE) continue;
+                const issuerPath = dep.module.path;
+                if (isNodeModulesPath(issuerPath)) continue;
+                const requiredModule = dep.dependency;
+                if (ruleConfig.ignore.some((pattern)=>issuerPath.includes(pattern) || requiredModule.path.includes(pattern))) continue;
+                const detail = {
+                    type: title,
+                    issuerModule: {
+                        id: dep.module.id,
+                        path: dep.module.path,
+                        webpackId: dep.module.webpackId
+                    },
+                    requiredModule: {
+                        id: requiredModule.id,
+                        path: requiredModule.path,
+                        webpackId: requiredModule.webpackId
+                    },
+                    request: dep.request
+                };
+                const message = `"${issuerPath}" uses \`require('${dep.request}')\` (CJS require) which prevents tree-shaking of the entire module "${requiredModule.path}". Consider using \`require('${dep.request}').property\` or ESM \`import\` instead.`;
+                report({
+                    message,
+                    detail
+                });
+            }
+        }
+    }));
+export { rule };

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/rules/rules/cjs-require/types.js

@@ -0,0 +1 @@
+import "node:module";

package/dist/rules/rules/cross-chunks-package/index.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { Linter } from "@rsdoctor/types";
 import { defineRule } from "../../rule.js";
 import { getErrorMsgForDupPckChunks } from "./utils.js";
@@ -8,7 +7,7 @@ const title = 'cross-chunks-package';
 const rule = defineRule(()=>({
         meta: {
             code: 'E1002',
-            title,
+            title: title,
             category: 'bundle',
             severity: Linter.Severity.Warn,
             defaultConfig: {

package/dist/rules/rules/cross-chunks-package/types.js

@@ -1,2 +1 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";

package/dist/rules/rules/cross-chunks-package/utils.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 function getErrorMsgForDupPckChunks(chunks, pkgName) {
     let message = `The same package ${pkgName} was bundled into different chunks:\n`;
     for (const chunkName of chunks)message += ` ${chunkName}\n`;

package/dist/rules/rules/default-import-check/index.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { builtinModules } from "module";
 import { Linter } from "@rsdoctor/types";
 import { getDocument, parser } from "@rsdoctor/utils/ruleUtils";
@@ -15,7 +14,7 @@ const rule = defineRule(()=>{
     return {
         meta: {
             code: 'E1005',
-            title,
+            title: title,
             category: 'compile',
             severity: Linter.Severity.Warn,
             defaultConfig: {

package/dist/rules/rules/default-import-check/types.js

@@ -1,2 +1 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";

package/dist/rules/rules/default-import-check/utils.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { getDocument, parser } from "@rsdoctor/utils/ruleUtils";
 import { Lodash } from "@rsdoctor/utils/common";
 function getDefaultImportByRequest(node, request) {

package/dist/rules/rules/duplicate-package/index.cjs

@@ -32,6 +32,7 @@ const external_types_cjs_namespaceObject = require("./types.cjs");
 const external_utils_cjs_namespaceObject = require("./utils.cjs");
 const external_rule_cjs_namespaceObject = require("../../rule.cjs");
 const title = 'duplicate-package';
+const { CheckVersionMap } = external_types_cjs_namespaceObject;
 const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
         meta: {
             code: 'E1001',
@@ -44,9 +45,9 @@ const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
             }
         },
         check ({ packageGraph, report, root, ruleConfig }) {
-            const checkVersion = external_types_cjs_namespaceObject.CheckVersionMap[ruleConfig.checkVersion];
+            const checkVersion = CheckVersionMap[ruleConfig.checkVersion];
             const packages = packageGraph.getDuplicatePackages().filter((pkg)=>!ruleConfig.ignore.includes(pkg[0].name)).map((pkgs)=>pkgs.filter((current)=>{
-                    const check = pkgs.reduce((ans, pkg)=>ans | external_types_cjs_namespaceObject.CheckVersionMap[(0, external_semver_namespaceObject.diff)(current.version, pkg.version) ?? 'null'], 0);
+                    const check = pkgs.reduce((ans, pkg)=>ans | CheckVersionMap[(0, external_semver_namespaceObject.diff)(current.version, pkg.version) ?? 'null'], 0);
                     return check <= checkVersion;
                 }).sort((_packA, _packB)=>(0, external_semver_namespaceObject.gt)(_packA.version, _packB.version) ? 1 : -1)).filter((pkgs)=>pkgs.length > 1 && pkgs.filter((pkg)=>pkg.getSize().parsedSize > 0).length > 1);
             for (const pkg of packages){

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

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

package/dist/rules/rules/duplicate-package/index.js

@@ -1,15 +1,21 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
+import { __webpack_require__ } from "../../../rslib-runtime.js";
 import { Linter } from "@rsdoctor/types";
 import { diff, gt } from "semver";
 import { CheckVersionMap } from "./types.js";
 import { getErrorDetail, getErrorMsg } from "./utils.js";
 import { defineRule } from "../../rule.js";
+var external_types_js_namespaceObject = {};
+__webpack_require__.r(external_types_js_namespaceObject);
+__webpack_require__.d(external_types_js_namespaceObject, {
+    CheckVersionMap: ()=>CheckVersionMap
+});
 const title = 'duplicate-package';
+const { CheckVersionMap: duplicate_package_CheckVersionMap } = external_types_js_namespaceObject;
 const rule = defineRule(()=>({
         meta: {
             code: 'E1001',
-            title,
+            title: title,
             category: 'bundle',
             severity: Linter.Severity.Warn,
             defaultConfig: {
@@ -18,9 +24,9 @@ const rule = defineRule(()=>({
             }
         },
         check ({ packageGraph, report, root, ruleConfig }) {
-            const checkVersion = CheckVersionMap[ruleConfig.checkVersion];
+            const checkVersion = duplicate_package_CheckVersionMap[ruleConfig.checkVersion];
             const packages = packageGraph.getDuplicatePackages().filter((pkg)=>!ruleConfig.ignore.includes(pkg[0].name)).map((pkgs)=>pkgs.filter((current)=>{
-                    const check = pkgs.reduce((ans, pkg)=>ans | CheckVersionMap[diff(current.version, pkg.version) ?? 'null'], 0);
+                    const check = pkgs.reduce((ans, pkg)=>ans | duplicate_package_CheckVersionMap[diff(current.version, pkg.version) ?? 'null'], 0);
                     return check <= checkVersion;
                 }).sort((_packA, _packB)=>gt(_packA.version, _packB.version) ? 1 : -1)).filter((pkgs)=>pkgs.length > 1 && pkgs.filter((pkg)=>pkg.getSize().parsedSize > 0).length > 1);
             for (const pkg of packages){

package/dist/rules/rules/duplicate-package/types.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 var types_CheckVersion = /*#__PURE__*/ function(CheckVersion) {
     CheckVersion[CheckVersion["null"] = 0] = "null";
     CheckVersion[CheckVersion["prerelease"] = 1] = "prerelease";

package/dist/rules/rules/duplicate-package/utils.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import path from "path";
 import { filesize } from "filesize";
 function getErrorMsg(packages, root) {

package/dist/rules/rules/ecma-version-check/index.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import path from "path";
 import { CheckSyntax } from "@rsbuild/plugin-check-syntax";
 import { loadConfig } from "browserslist-load-config";
@@ -9,7 +8,7 @@ const title = 'ecma-version-check';
 const rule = defineRule(()=>({
         meta: {
             code: 'E1004',
-            title,
+            title: title,
             category: 'bundle',
             severity: Linter.Severity.Warn,
             defaultConfig: {

package/dist/rules/rules/ecma-version-check/types.js

@@ -1,2 +1 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";

package/dist/rules/rules/ecma-version-check/utils.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 function getVersionNumber(ECMAString) {
     const version = ECMAString.match(/\d/);
     return version?.length ? Number(version[0]) : void 0;

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

@@ -0,0 +1,144 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    rule: ()=>rule
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const types_namespaceObject = require("@rsdoctor/types");
+const external_rule_cjs_namespaceObject = require("../../rule.cjs");
+const title = 'esm-resolved-to-cjs';
+function extractEsmEntry(pkgJson, pkgRoot) {
+    const { exports: exportsField, module: moduleField } = pkgJson;
+    if (null !== exportsField && 'object' == typeof exportsField) {
+        const exports1 = exportsField;
+        const dotEntry = exports1['.'];
+        if (null !== dotEntry && 'object' == typeof dotEntry) {
+            const dot = dotEntry;
+            const importEntry = dot['import'];
+            if ('string' == typeof importEntry) return external_path_default().resolve(pkgRoot, importEntry);
+            if (null !== importEntry && 'object' == typeof importEntry) {
+                const nested = importEntry['default'];
+                if ('string' == typeof nested) return external_path_default().resolve(pkgRoot, nested);
+            }
+        }
+        const topImport = exports1['import'];
+        if ('string' == typeof topImport) return external_path_default().resolve(pkgRoot, topImport);
+        if (null !== topImport && 'object' == typeof topImport) {
+            const nested = topImport['default'];
+            if ('string' == typeof nested) return external_path_default().resolve(pkgRoot, nested);
+        }
+    }
+    if ('string' == typeof moduleField) return external_path_default().resolve(pkgRoot, moduleField);
+    return null;
+}
+const rule = (0, external_rule_cjs_namespaceObject.defineRule)(()=>({
+        meta: {
+            code: 'E1009',
+            title,
+            category: 'bundle',
+            severity: types_namespaceObject.Linter.Severity.Warn,
+            defaultConfig: {
+                ignore: []
+            }
+        },
+        check ({ moduleGraph, packageGraph, report, ruleConfig }) {
+            const pkgJsonCache = new Map();
+            const readPkgJson = (pkgRoot)=>{
+                if (pkgJsonCache.has(pkgRoot)) return pkgJsonCache.get(pkgRoot);
+                try {
+                    const raw = external_fs_default().readFileSync(external_path_default().join(pkgRoot, 'package.json'), 'utf-8');
+                    const parsed = JSON.parse(raw);
+                    pkgJsonCache.set(pkgRoot, parsed);
+                    return parsed;
+                } catch  {
+                    pkgJsonCache.set(pkgRoot, null);
+                    return null;
+                }
+            };
+            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 (!esmEntry) continue;
+                const groupKey = `${pkg.name}::${dep.dependency.path}`;
+                const issuer = {
+                    id: dep.module.id,
+                    path: dep.module.path,
+                    request: dep.request
+                };
+                if (groups.has(groupKey)) groups.get(groupKey).issuers.push(issuer);
+                else groups.set(groupKey, {
+                    packageName: pkg.name,
+                    packageVersion: pkg.version,
+                    esmEntry,
+                    resolvedModule: {
+                        id: dep.dependency.id,
+                        path: dep.dependency.path,
+                        webpackId: dep.dependency.webpackId
+                    },
+                    issuers: [
+                        issuer
+                    ]
+                });
+            }
+            for (const group of groups.values()){
+                const detail = {
+                    type: title,
+                    packageName: group.packageName,
+                    packageVersion: group.packageVersion,
+                    esmEntry: group.esmEntry,
+                    resolvedModule: group.resolvedModule,
+                    issuers: group.issuers
+                };
+                const message = `"${group.packageName}" declares an ESM entry ("${group.esmEntry}") but was resolved to CJS by ${group.issuers.length} ESM import(s). Check your bundler's \`resolve.mainFields\` or \`resolve.conditionNames\` config.`;
+                report({
+                    message,
+                    detail
+                });
+            }
+        }
+    }));
+exports.rule = __webpack_exports__.rule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "rule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/rules/rules/esm-resolved-to-cjs/index.js

@@ -0,0 +1,100 @@
+import "node:module";
+import fs from "fs";
+import path from "path";
+import { Linter, SDK } from "@rsdoctor/types";
+import { defineRule } from "../../rule.js";
+const title = 'esm-resolved-to-cjs';
+function extractEsmEntry(pkgJson, pkgRoot) {
+    const { exports: exportsField, module: moduleField } = pkgJson;
+    if (null !== exportsField && 'object' == typeof exportsField) {
+        const exports = exportsField;
+        const dotEntry = exports['.'];
+        if (null !== dotEntry && 'object' == typeof dotEntry) {
+            const dot = dotEntry;
+            const importEntry = dot['import'];
+            if ('string' == typeof importEntry) return path.resolve(pkgRoot, importEntry);
+            if (null !== importEntry && 'object' == typeof importEntry) {
+                const nested = importEntry['default'];
+                if ('string' == typeof nested) return path.resolve(pkgRoot, nested);
+            }
+        }
+        const topImport = exports['import'];
+        if ('string' == typeof topImport) return path.resolve(pkgRoot, topImport);
+        if (null !== topImport && 'object' == typeof topImport) {
+            const nested = topImport['default'];
+            if ('string' == typeof nested) return path.resolve(pkgRoot, nested);
+        }
+    }
+    if ('string' == typeof moduleField) return path.resolve(pkgRoot, moduleField);
+    return null;
+}
+const rule = defineRule(()=>({
+        meta: {
+            code: 'E1009',
+            title: title,
+            category: 'bundle',
+            severity: Linter.Severity.Warn,
+            defaultConfig: {
+                ignore: []
+            }
+        },
+        check ({ moduleGraph, packageGraph, report, ruleConfig }) {
+            const pkgJsonCache = new Map();
+            const readPkgJson = (pkgRoot)=>{
+                if (pkgJsonCache.has(pkgRoot)) return pkgJsonCache.get(pkgRoot);
+                try {
+                    const raw = fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf-8');
+                    const parsed = JSON.parse(raw);
+                    pkgJsonCache.set(pkgRoot, parsed);
+                    return parsed;
+                } catch  {
+                    pkgJsonCache.set(pkgRoot, null);
+                    return null;
+                }
+            };
+            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 (!esmEntry) continue;
+                const groupKey = `${pkg.name}::${dep.dependency.path}`;
+                const issuer = {
+                    id: dep.module.id,
+                    path: dep.module.path,
+                    request: dep.request
+                };
+                if (groups.has(groupKey)) groups.get(groupKey).issuers.push(issuer);
+                else groups.set(groupKey, {
+                    packageName: pkg.name,
+                    packageVersion: pkg.version,
+                    esmEntry,
+                    resolvedModule: {
+                        id: dep.dependency.id,
+                        path: dep.dependency.path,
+                        webpackId: dep.dependency.webpackId
+                    },
+                    issuers: [
+                        issuer
+                    ]
+                });
+            }
+            for (const group of groups.values()){
+                const detail = {
+                    type: title,
+                    packageName: group.packageName,
+                    packageVersion: group.packageVersion,
+                    esmEntry: group.esmEntry,
+                    resolvedModule: group.resolvedModule,
+                    issuers: group.issuers
+                };
+                const message = `"${group.packageName}" declares an ESM entry ("${group.esmEntry}") but was resolved to CJS by ${group.issuers.length} ESM import(s). Check your bundler's \`resolve.mainFields\` or \`resolve.conditionNames\` config.`;
+                report({
+                    message,
+                    detail
+                });
+            }
+        }
+    }));
+export { rule };

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -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/esm-resolved-to-cjs/types.js

@@ -0,0 +1 @@
+import "node:module";

package/dist/rules/rules/index.cjs

@@ -32,13 +32,19 @@ const external_loader_performance_optimization_index_cjs_namespaceObject = requi
 const external_ecma_version_check_index_cjs_namespaceObject = require("./ecma-version-check/index.cjs");
 const external_cross_chunks_package_index_cjs_namespaceObject = require("./cross-chunks-package/index.cjs");
 const external_module_mixed_chunks_index_cjs_namespaceObject = require("./module-mixed-chunks/index.cjs");
+const external_side_effects_only_imports_index_cjs_namespaceObject = require("./side-effects-only-imports/index.cjs");
+const external_cjs_require_index_cjs_namespaceObject = require("./cjs-require/index.cjs");
+const external_esm_resolved_to_cjs_index_cjs_namespaceObject = require("./esm-resolved-to-cjs/index.cjs");
 const rules = [
     index_cjs_namespaceObject.rule,
     external_default_import_check_index_cjs_namespaceObject.rule,
     external_loader_performance_optimization_index_cjs_namespaceObject.rule,
     external_ecma_version_check_index_cjs_namespaceObject.rule,
     external_cross_chunks_package_index_cjs_namespaceObject.rule,
-    external_module_mixed_chunks_index_cjs_namespaceObject.rule
+    external_module_mixed_chunks_index_cjs_namespaceObject.rule,
+    external_side_effects_only_imports_index_cjs_namespaceObject.rule,
+    external_cjs_require_index_cjs_namespaceObject.rule,
+    external_esm_resolved_to_cjs_index_cjs_namespaceObject.rule
 ];
 exports.rules = __webpack_exports__.rules;
 for(var __rspack_i in __webpack_exports__)if (-1 === [