@rsdoctor/core 0.0.2-beta.0

package/dist/rules/rule.js

@@ -0,0 +1,140 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rule_exports = {};
+__export(rule_exports, {
+  Rule: () => Rule,
+  defineRule: () => defineRule
+});
+module.exports = __toCommonJS(rule_exports);
+var import_types = require("@rsdoctor/types");
+var import_lodash = require("lodash");
+var import_utils = require("./utils");
+class Rule {
+  static from(data) {
+    return new Rule({
+      check: data.check,
+      onCheckEnd: data.onCheckEnd,
+      meta: {
+        ...data.meta,
+        code: import_types.Rule.RuleMessageCodeEnumerated.Extend,
+        severity: (0, import_utils.toSeverity)(data.meta.severity, import_types.Linter.Severity.Warn)
+      }
+    });
+  }
+  constructor(data) {
+    this.check = data.check;
+    this.meta = data.meta;
+    this.onCheckEnd = typeof data.onCheckEnd === "function" ? data.onCheckEnd : import_utils.noop;
+    this._severity = this.meta.severity;
+    this._config = this.meta.defaultConfig;
+  }
+  get code() {
+    return this.meta.code;
+  }
+  get title() {
+    return this.meta.title;
+  }
+  get severity() {
+    return this._severity;
+  }
+  get config() {
+    return this._config;
+  }
+  get category() {
+    return this.meta.category;
+  }
+  setOption(opt) {
+    let severity;
+    let config;
+    if (Array.isArray(opt)) {
+      severity = (0, import_utils.toSeverity)(opt[0], this.meta.severity);
+      config = opt[1];
+    } else {
+      severity = (0, import_utils.toSeverity)(opt, this.meta.severity);
+      config = void 0;
+    }
+    this._severity = severity;
+    this._config = (0, import_lodash.isPlainObject)(config) ? {
+      ...this.meta.defaultConfig,
+      ...config
+    } : config || this.meta.defaultConfig;
+  }
+  match(level) {
+    if (level === import_types.Linter.Severity.Ignore || this.severity === import_types.Linter.Severity.Ignore) {
+      return false;
+    }
+    if (level === import_types.Linter.Severity.Error) {
+      return this.severity === import_types.Linter.Severity.Error || this.severity === import_types.Linter.Severity.Warn;
+    }
+    if (level === import_types.Linter.Severity.Warn) {
+      return this.severity === import_types.Linter.Severity.Warn;
+    }
+    return false;
+  }
+  async validate(context) {
+    const errors = [];
+    const replace = [];
+    const report = (data, remove) => {
+      if (remove) {
+        replace.push(remove);
+      }
+      const error = {
+        ...data,
+        code: this.code,
+        severity: this.severity,
+        category: this.category,
+        title: this.title.toUpperCase()
+      };
+      errors.push(error);
+    };
+    await this.check({
+      ...context,
+      ruleConfig: this.config,
+      report
+    });
+    return {
+      errors,
+      replace
+    };
+  }
+  async afterValidate({
+    hooks,
+    validateResult,
+    data
+  }) {
+    if (this.onCheckEnd === import_utils.noop)
+      return;
+    await this.onCheckEnd({
+      data: {
+        ...data,
+        ruleConfig: this.config
+      },
+      hooks,
+      validateResult
+    });
+  }
+}
+function defineRule(ruleCreator) {
+  return ruleCreator();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Rule,
+  defineRule
+});

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

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

@@ -0,0 +1,124 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var default_import_check_exports = {};
+__export(default_import_check_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(default_import_check_exports);
+var import_module = require("module");
+var import_types = require("@rsdoctor/types");
+var import_ruleUtils = require("@rsdoctor/utils/ruleUtils");
+var import_utils = require("./utils");
+var import_rule = require("../../rule");
+const title = "default-import-check";
+const rule = (0, import_rule.defineRule)(() => {
+  const parserOpt = {
+    ecmaVersion: 6
+  };
+  const exportsDefault = import_ruleUtils.parser.internal.parseExpressionAt(
+    "exports.default",
+    0,
+    parserOpt
+  );
+  const moduleExportsDefault = import_ruleUtils.parser.internal.parseExpressionAt(
+    "module.exports.default",
+    0,
+    parserOpt
+  );
+  return {
+    meta: {
+      code: "E1002",
+      title,
+      category: "compile",
+      severity: import_types.Linter.Severity.Warn,
+      defaultConfig: {
+        ignore: []
+      }
+    },
+    check({ moduleGraph, report, ruleConfig }) {
+      const dependencyWithNode = moduleGraph.getDependencies().filter((dep) => dep.meta.exportsType === "dynamic").filter((dep) => !dep.module.path.includes("node_modules")).filter(
+        (dep) => !ruleConfig.ignore.includes(dep.request) && !import_module.builtinModules.includes(dep.request)
+      ).filter((dep) => dep.dependency.meta.hasSetEsModuleStatement).filter((dep) => dep.dependency.getProgram()).filter(
+        (dep) => !(0, import_utils.hasSameLeftInAssignStatement)(dep.dependency.getProgram(), [
+          exportsDefault,
+          moduleExportsDefault
+        ])
+      ).map((dependency) => {
+        const { module: module2, request } = dependency;
+        const node = module2.getProgram() && (0, import_utils.getDefaultImportByRequest)(module2.getProgram(), request);
+        return node ? {
+          dependency,
+          node
+        } : {};
+      }).filter((dep) => dep?.dependency);
+      for (const { dependency, node } of dependencyWithNode) {
+        if (!dependency)
+          continue;
+        const document = (0, import_utils.getSourceRangeFromTransformedOffset)(
+          dependency.module,
+          node
+        );
+        if (!document) {
+          continue;
+        }
+        const message = "Do not to use the default import when you import a cjs module.";
+        const canFix = !document.isTransformed && !document.path.includes("node_modules");
+        if (canFix) {
+          const fixData = (0, import_utils.getFixData)(dependency.module, node, document.range);
+          const detail = {
+            type: "code-change",
+            file: {
+              path: document.path,
+              actual: document.content,
+              line: document.range.start.line,
+              expected: (0, import_ruleUtils.getDocument)(document.content).edit(fixData)
+            }
+          };
+          report({
+            message,
+            document,
+            detail,
+            suggestions: {
+              description: "Use namespace import instead.",
+              fixData
+            }
+          });
+        } else {
+          const detail = {
+            type: "code-view",
+            file: {
+              path: document.path,
+              content: document.content,
+              ranges: [node.loc]
+            }
+          };
+          report({
+            message,
+            document,
+            detail
+          });
+        }
+      }
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -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/default-import-check/utils.js

@@ -0,0 +1,93 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getDefaultImportByRequest: () => getDefaultImportByRequest,
+  getFixData: () => getFixData,
+  getSourceRangeFromTransformedOffset: () => getSourceRangeFromTransformedOffset,
+  hasSameLeftInAssignStatement: () => hasSameLeftInAssignStatement,
+  importDeclarationToString: () => importDeclarationToString
+});
+module.exports = __toCommonJS(utils_exports);
+var import_ruleUtils = require("@rsdoctor/utils/ruleUtils");
+var import_lodash = require("lodash");
+function getDefaultImportByRequest(node, request) {
+  return import_ruleUtils.parser.utils.getDefaultImports(node).find((decl) => decl.source.value === request);
+}
+function hasSameLeftInAssignStatement(node, compare) {
+  return node.body.filter(import_ruleUtils.parser.asserts.isExpressionStatement).map((node2) => node2.expression).filter(import_ruleUtils.parser.asserts.isAssignmentExpression).map((node2) => node2.left).find(
+    (node2) => compare.some((item) => import_ruleUtils.parser.utils.isSameSemantics(node2, item))
+  );
+}
+function importDeclarationToString(node) {
+  const defaultSpecifier = node.specifiers[0];
+  const rawRequest = (node.source.raw ?? "").trim();
+  return `import * as ${defaultSpecifier.local.name} from ${rawRequest}`;
+}
+function getFixData(module2, node, originalRange) {
+  const { source, transformed } = module2.getSource();
+  const document = (0, import_ruleUtils.getDocument)(source);
+  const newImportText = importDeclarationToString(node);
+  const oldText = transformed.substring(node.start, node.end);
+  const hasLastSemi = oldText[oldText.length - 1] === ";";
+  return {
+    start: document.offsetAt(originalRange.start),
+    end: document.offsetAt(originalRange.end),
+    newText: hasLastSemi ? `${newImportText};` : newImportText
+  };
+}
+function getSourceRangeFromTransformedOffset(module2, node) {
+  const source = module2.getSource();
+  const sourceMap = module2.getSourceMap();
+  const transformedStart = node.loc.start;
+  const transformedEnd = node.loc.end;
+  if (!transformedStart || !transformedEnd) {
+    return;
+  }
+  const transformedReport = {
+    path: module2.path,
+    content: source.transformed,
+    isTransformed: true,
+    range: {
+      start: transformedStart,
+      end: transformedEnd
+    }
+  };
+  if (!sourceMap) {
+    return transformedReport;
+  }
+  const sourceRange = module2.getSourceRange(node.loc);
+  if ((0, import_lodash.isUndefined)(sourceRange?.start.line) || (0, import_lodash.isUndefined)(sourceRange?.start.column) || (0, import_lodash.isUndefined)(sourceRange?.end?.line) || (0, import_lodash.isUndefined)(sourceRange?.end?.column)) {
+    return transformedReport;
+  }
+  return {
+    path: module2.path,
+    isTransformed: false,
+    content: source.source,
+    range: sourceRange
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultImportByRequest,
+  getFixData,
+  getSourceRangeFromTransformedOffset,
+  hasSameLeftInAssignStatement,
+  importDeclarationToString
+});

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

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

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

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var duplicate_package_exports = {};
+__export(duplicate_package_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(duplicate_package_exports);
+var import_types = require("@rsdoctor/types");
+var import_semver = require("semver");
+var import_types2 = require("./types");
+var import_utils = require("./utils");
+var import_rule = require("../../rule");
+const title = "duplicate-package";
+const rule = (0, import_rule.defineRule)(() => ({
+  meta: {
+    code: "E1001",
+    title,
+    category: "bundle",
+    severity: import_types.Linter.Severity.Warn,
+    defaultConfig: {
+      checkVersion: "major",
+      ignore: []
+    }
+  },
+  check({ packageGraph, report, root, ruleConfig }) {
+    const checkVersion = import_types2.CheckVersionMap[ruleConfig.checkVersion];
+    const packages = packageGraph.getDuplicatePackages().filter((pkg) => !ruleConfig.ignore.includes(pkg[0].name)).map((pkgs) => {
+      return pkgs.filter((current) => {
+        const check = pkgs.reduce(
+          // eslint-disable-next-line no-bitwise
+          (ans, pkg) => ans | import_types2.CheckVersionMap[(0, import_semver.diff)(current.version, pkg.version) ?? "null"],
+          0
+        );
+        return check <= checkVersion;
+      }).sort(
+        (_packA, _packB) => (0, import_semver.gt)(_packA.version, _packB.version) ? 1 : -1
+      );
+    }).filter((pkgs) => pkgs.length > 1);
+    for (const pkg of packages) {
+      const message = (0, import_utils.getErrorMsg)(pkg, root);
+      const detail = {
+        type: "package-relation",
+        packages: pkg.map((item) => (0, import_utils.getErrorDetail)(item, packageGraph))
+      };
+      report({
+        message,
+        detail
+      });
+    }
+  }
+}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

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

@@ -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/types.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  CheckVersion: () => CheckVersion,
+  CheckVersionMap: () => CheckVersionMap
+});
+module.exports = __toCommonJS(types_exports);
+var CheckVersion = /* @__PURE__ */ ((CheckVersion2) => {
+  CheckVersion2[CheckVersion2["null"] = 0] = "null";
+  CheckVersion2[CheckVersion2["prerelease"] = 1] = "prerelease";
+  CheckVersion2[CheckVersion2["prepatch"] = 16] = "prepatch";
+  CheckVersion2[CheckVersion2["patch"] = 256] = "patch";
+  CheckVersion2[CheckVersion2["preminor"] = 4096] = "preminor";
+  CheckVersion2[CheckVersion2["minor"] = 65536] = "minor";
+  CheckVersion2[CheckVersion2["premajor"] = 1048576] = "premajor";
+  CheckVersion2[CheckVersion2["major"] = 16777216] = "major";
+  return CheckVersion2;
+})(CheckVersion || {});
+var CheckVersionMap = /* @__PURE__ */ ((CheckVersionMap2) => {
+  CheckVersionMap2[CheckVersionMap2["null"] = 0] = "null";
+  CheckVersionMap2[CheckVersionMap2["prerelease"] = 1] = "prerelease";
+  CheckVersionMap2[CheckVersionMap2["prepatch"] = 17] = "prepatch";
+  CheckVersionMap2[CheckVersionMap2["patch"] = 273] = "patch";
+  CheckVersionMap2[CheckVersionMap2["preminor"] = 4369] = "preminor";
+  CheckVersionMap2[CheckVersionMap2["minor"] = 69905] = "minor";
+  CheckVersionMap2[CheckVersionMap2["premajor"] = 1118481] = "premajor";
+  CheckVersionMap2[CheckVersionMap2["major"] = 17895697] = "major";
+  return CheckVersionMap2;
+})(CheckVersionMap || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckVersion,
+  CheckVersionMap
+});

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

@@ -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/duplicate-package/utils.js

@@ -0,0 +1,89 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getErrorDetail: () => getErrorDetail,
+  getErrorMsg: () => getErrorMsg
+});
+module.exports = __toCommonJS(utils_exports);
+var import_path = __toESM(require("path"));
+var import_bytes = __toESM(require("bytes"));
+function getErrorMsg(packages, root) {
+  const pkgName = packages[0].name;
+  let message = `Multiple packages of ${pkgName} found:
+`;
+  for (const pkg of packages) {
+    message += `  ${pkg.version} ${(0, import_bytes.default)(
+      pkg.getSize().parsedSize
+    )} ${import_path.default.relative(root, pkg.root)}
+`;
+  }
+  return message.slice(0, -1);
+}
+function getErrorDetail(pkg, pkgGraph) {
+  function getImported(pkg2, ans) {
+    const dependencies = pkgGraph.getDependenciesFromPackage(pkg2);
+    for (const dep of dependencies) {
+      if (!dep.refDependency) {
+        continue;
+      }
+      if (ans.some((dep2) => dep2.dependency === pkg2)) {
+        continue;
+      }
+      if (!dep.package) {
+        return ans.concat(dep);
+      }
+      return getImported(dep.package, ans.concat(dep));
+    }
+    return ans;
+  }
+  const packageImportLinks = getImported(pkg, []);
+  return {
+    target: {
+      name: pkg.name,
+      version: pkg.version,
+      root: pkg.root
+    },
+    targetSize: {
+      sourceSize: pkg.getSize().sourceSize,
+      parsedSize: pkg.getSize().parsedSize
+    },
+    dependencies: packageImportLinks.map((item) => {
+      return {
+        dependencyId: item.refDependency.id,
+        group: item.package ? `${item.package.name}@${item.package.version}` : void 0
+      };
+    })
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getErrorDetail,
+  getErrorMsg
+});

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

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