@xylabs/ts-scripts-yarn3 7.4.28 → 7.5.1

package/dist/actions/deplint/checkPackage/index.mjs

@@ -1,672 +0,0 @@
-// src/actions/deplint/findFiles.ts
-import fs from "fs";
-
-// src/actions/deplint/findFilesByGlob.ts
-import { globSync } from "glob";
-function findFilesByGlob(cwd, pattern, ignore) {
-  return globSync(pattern, {
-    cwd,
-    absolute: true,
-    ignore,
-    nodir: true
-  });
-}
-
-// src/actions/deplint/findFiles.ts
-var codeExtensions = "*.{ts,tsx,mts,cts,js,mjs,cjs}";
-function getWorkspaceIgnores(location) {
-  try {
-    const raw = fs.readFileSync(`${location}/package.json`, "utf8");
-    const pkg = JSON.parse(raw);
-    return pkg.workspaces ?? [];
-  } catch {
-    return [];
-  }
-}
-function findFiles(location) {
-  const workspaceIgnores = getWorkspaceIgnores(location).map((w) => `${w}/**`);
-  const ignore = ["**/node_modules/**", "dist/**", ...workspaceIgnores];
-  const allFiles = findFilesByGlob(location, `./**/${codeExtensions}`, ignore);
-  const distFiles = [
-    ...findFilesByGlob(location, "./dist/**/*.d.ts"),
-    ...findFilesByGlob(location, `./dist/**/${codeExtensions}`)
-  ];
-  return { allFiles, distFiles };
-}
-
-// src/actions/deplint/getDependenciesFromPackageJson.ts
-import fs2 from "fs";
-import path from "path";
-function getDependenciesFromPackageJson(packageJsonPath) {
-  const packageJsonFullPath = path.resolve(packageJsonPath);
-  const rawContent = fs2.readFileSync(packageJsonFullPath, "utf8");
-  const packageJson = JSON.parse(rawContent);
-  const dependencies = packageJson.dependencies ? Object.keys(packageJson.dependencies) : [];
-  const devDependencies = packageJson.devDependencies ? Object.keys(packageJson.devDependencies) : [];
-  const peerDependencies = packageJson.peerDependencies ? Object.keys(packageJson.peerDependencies) : [];
-  return {
-    dependencies,
-    devDependencies,
-    peerDependencies
-  };
-}
-
-// src/actions/deplint/getExtendsFromTsconfigs.ts
-import fs3 from "fs";
-import { globSync as globSync2 } from "glob";
-
-// src/actions/deplint/getBasePackageName.ts
-function getBasePackageName(importName) {
-  const importNameScrubbed = importName.replaceAll('"', "").trim();
-  if (importNameScrubbed.startsWith("@")) {
-    const parts = importNameScrubbed.split("/");
-    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : importNameScrubbed;
-  }
-  return importNameScrubbed.split("/")[0];
-}
-
-// src/actions/deplint/getExtendsFromTsconfigs.ts
-var isExternalReference = (ref) => !ref.startsWith(".") && !ref.startsWith("/");
-function parseExtendsField(value) {
-  if (typeof value === "string") return [value];
-  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
-  return [];
-}
-function getExtendsFromTsconfigs(location) {
-  const tsconfigFiles = globSync2("./tsconfig*.json", { cwd: location, absolute: true });
-  const packages = /* @__PURE__ */ new Set();
-  for (const file of tsconfigFiles) {
-    try {
-      const content = fs3.readFileSync(file, "utf8");
-      const cleaned = content.replaceAll(/\/\/.*/g, "").replaceAll(/,\s*([}\]])/g, "$1");
-      const parsed = JSON.parse(cleaned);
-      const refs = parseExtendsField(parsed.extends);
-      for (const ref of refs) {
-        if (isExternalReference(ref)) {
-          packages.add(getBasePackageName(ref));
-        }
-      }
-    } catch {
-    }
-  }
-  return [...packages];
-}
-
-// src/actions/deplint/getImportsFromFile.ts
-import fs4 from "fs";
-import path2 from "path";
-import ts from "typescript";
-function isTypeOnlyImportClause(clause) {
-  if (clause === void 0) {
-    return false;
-  }
-  if ("phaseModifier" in clause) {
-    const mod = clause.phaseModifier;
-    const kind = typeof mod === "number" ? mod : mod?.kind;
-    return kind === ts.SyntaxKind.TypeKeyword;
-  }
-  return clause.isTypeOnly;
-}
-function getImportsFromFile(filePath, importPaths, typeImportPaths) {
-  const sourceCode = fs4.readFileSync(filePath, "utf8");
-  const isMjsFile = filePath.endsWith(".mjs");
-  const sourceFile = ts.createSourceFile(
-    path2.basename(filePath),
-    sourceCode,
-    ts.ScriptTarget.Latest,
-    true,
-    isMjsFile ? ts.ScriptKind.JS : void 0
-  );
-  const imports = [];
-  const typeImports = [];
-  const isDeclarationFile2 = filePath.endsWith(".d.ts");
-  function visit(node) {
-    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier?.getFullText();
-      const isTypeImport = ts.isImportDeclaration(node) ? isTypeOnlyImportClause(node.importClause) : false;
-      if (typeof moduleSpecifier === "string") {
-        const trimmed = moduleSpecifier.replaceAll("'", "").replaceAll('"', "").trim();
-        if (isTypeImport || isDeclarationFile2) {
-          typeImports.push(trimmed);
-        } else {
-          imports.push(trimmed);
-        }
-      }
-    } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-      const [arg] = node.arguments;
-      if (ts.isStringLiteral(arg)) {
-        imports.push(arg.text);
-      }
-    } else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length > 0 && ts.isStringLiteral(node.arguments[0])) {
-      imports.push(node.arguments[0].text);
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  for (const ref of sourceFile.typeReferenceDirectives) {
-    typeImports.push(ref.fileName);
-  }
-  const importsStartsWithExcludes = [".", "#", "node:"];
-  const isValidImport = (imp) => !importsStartsWithExcludes.some((exc) => imp.startsWith(exc)) && !imp.includes("*") && !imp.includes("!");
-  const cleanedImports = imports.filter(isValidImport).map(getBasePackageName);
-  const cleanedTypeImports = typeImports.filter(isValidImport).map(getBasePackageName);
-  for (const imp of cleanedImports) {
-    importPaths[imp] = importPaths[imp] ?? [];
-    importPaths[imp].push(filePath);
-  }
-  for (const imp of cleanedTypeImports) {
-    typeImportPaths[imp] = typeImportPaths[imp] ?? [];
-    typeImportPaths[imp].push(filePath);
-  }
-  return [cleanedImports, cleanedTypeImports];
-}
-
-// src/actions/deplint/getExternalImportsFromFiles.ts
-var internalImportPrefixes = [".", "#", "node:"];
-var removeInternalImports = (imports) => {
-  return imports.filter((imp) => !internalImportPrefixes.some((prefix) => imp.startsWith(prefix)));
-};
-var isDeclarationFile = (file) => file.endsWith(".d.ts") || file.endsWith(".d.cts") || file.endsWith(".d.mts");
-function getExternalImportsFromFiles({
-  allFiles,
-  distFiles,
-  tsconfigExtends = []
-}) {
-  const allImportPaths = {};
-  const distImportPaths = {};
-  const distTypeImportPaths = {};
-  for (const path6 of allFiles) getImportsFromFile(path6, allImportPaths, allImportPaths).flat();
-  const distTypeFiles = distFiles.filter(isDeclarationFile);
-  const distCodeFiles = distFiles.filter((file) => !isDeclarationFile(file));
-  for (const path6 of distCodeFiles) getImportsFromFile(path6, distImportPaths, distImportPaths).flat();
-  for (const path6 of distTypeFiles) getImportsFromFile(path6, distTypeImportPaths, distTypeImportPaths).flat();
-  const allImports = Object.keys(allImportPaths);
-  const distImports = Object.keys(distImportPaths);
-  const externalAllImports = removeInternalImports(allImports);
-  const externalDistImports = removeInternalImports(distImports);
-  const externalDistTypeImports = removeInternalImports(Object.keys(distTypeImportPaths));
-  for (const ext of tsconfigExtends) {
-    if (!externalAllImports.includes(ext)) externalAllImports.push(ext);
-  }
-  return {
-    allImportPaths,
-    allImports,
-    distImportPaths,
-    distImports,
-    externalAllImports,
-    externalDistImports,
-    externalDistTypeImports
-  };
-}
-
-// src/actions/deplint/checkPackage/getUnlistedDependencies.ts
-import { builtinModules } from "module";
-import chalk from "chalk";
-function isRuntimeImportListed(imp, name, dependencies, peerDependencies) {
-  return dependencies.includes(imp) || imp === name || peerDependencies.includes(imp) || builtinModules.includes(imp);
-}
-function isTypeImportListed(imp, name, dependencies, devDependencies, peerDependencies) {
-  return dependencies.includes(imp) || imp === name || dependencies.includes(`@types/${imp}`) || peerDependencies.includes(imp) || peerDependencies.includes(`@types/${imp}`) || devDependencies.includes(`@types/${imp}`) || builtinModules.includes(imp);
-}
-function logMissing(name, imp, importPaths) {
-  console.log(`[${chalk.blue(name)}] Missing dependency in package.json: ${chalk.red(imp)}`);
-  if (importPaths[imp]) {
-    console.log(`  ${importPaths[imp].join("\n ")}`);
-  }
-}
-function getUnlistedDependencies({ name, location }, {
-  dependencies,
-  devDependencies,
-  peerDependencies
-}, {
-  externalDistImports,
-  externalDistTypeImports,
-  distImportPaths
-}) {
-  let unlistedDependencies = 0;
-  for (const imp of externalDistImports) {
-    if (!isRuntimeImportListed(imp, name, dependencies, peerDependencies)) {
-      unlistedDependencies++;
-      logMissing(name, imp, distImportPaths);
-    }
-  }
-  for (const imp of externalDistTypeImports) {
-    if (!isTypeImportListed(imp, name, dependencies, devDependencies, peerDependencies)) {
-      unlistedDependencies++;
-      logMissing(name, imp, distImportPaths);
-    }
-  }
-  if (unlistedDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk.yellow(packageLocation)}
-`);
-  }
-  return unlistedDependencies;
-}
-
-// src/actions/deplint/checkPackage/getUnlistedDevDependencies.ts
-import { builtinModules as builtinModules2 } from "module";
-import chalk2 from "chalk";
-function getUnlistedDevDependencies({ name, location }, {
-  devDependencies,
-  dependencies,
-  peerDependencies
-}, {
-  allImportPaths,
-  externalAllImports,
-  distImports
-}) {
-  let unlistedDevDependencies = 0;
-  for (const imp of externalAllImports) {
-    if (!distImports.includes(imp) && imp !== name && !dependencies.includes(imp) && !dependencies.includes(`@types/${imp}`) && !peerDependencies.includes(imp) && !peerDependencies.includes(`@types/${imp}`) && !devDependencies.includes(imp) && !devDependencies.includes(`@types/${imp}`) && !builtinModules2.includes(imp)) {
-      unlistedDevDependencies++;
-      console.log(`[${chalk2.blue(name)}] Missing devDependency in package.json: ${chalk2.red(imp)}`);
-      if (allImportPaths[imp]) {
-        console.log(`  ${allImportPaths[imp].join("\n ")}`);
-      }
-    }
-  }
-  if (unlistedDevDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk2.yellow(packageLocation)}
-`);
-  }
-  return unlistedDevDependencies;
-}
-
-// src/actions/deplint/checkPackage/getUnusedDependencies.ts
-import chalk3 from "chalk";
-function getUnusedDependencies({ name, location }, { dependencies }, {
-  externalDistImports,
-  externalDistTypeImports,
-  externalAllImports
-}, exclude) {
-  let unusedDependencies = 0;
-  for (const dep of dependencies) {
-    if (exclude?.has(dep)) continue;
-    if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
-      unusedDependencies++;
-      if (externalAllImports.includes(dep)) {
-        console.log(`[${chalk3.blue(name)}] dependency should be devDependency in package.json: ${chalk3.red(dep)}`);
-      } else {
-        console.log(`[${chalk3.blue(name)}] Unused dependency in package.json: ${chalk3.red(dep)}`);
-      }
-    }
-  }
-  if (unusedDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk3.yellow(packageLocation)}
-`);
-  }
-  return unusedDependencies;
-}
-
-// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
-import chalk4 from "chalk";
-
-// src/actions/deplint/getCliReferencedPackagesFromFiles.ts
-import fs7 from "fs";
-import path5 from "path";
-import ts2 from "typescript";
-
-// src/actions/deplint/getScriptReferencedPackages.ts
-import fs6 from "fs";
-import path4 from "path";
-
-// src/actions/deplint/getRequiredPeerDependencies.ts
-import fs5 from "fs";
-import path3 from "path";
-function findDepPackageJson(location, dep) {
-  let dir = location;
-  while (true) {
-    const candidate = path3.join(dir, "node_modules", dep, "package.json");
-    if (fs5.existsSync(candidate)) return candidate;
-    const parent = path3.dirname(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-function getRequiredPeerDependencies(location, allDeps) {
-  const required = /* @__PURE__ */ new Set();
-  for (const dep of allDeps) {
-    const depPkgPath = findDepPackageJson(location, dep);
-    if (!depPkgPath) continue;
-    try {
-      const raw = fs5.readFileSync(depPkgPath, "utf8");
-      const pkg = JSON.parse(raw);
-      if (pkg.peerDependencies) {
-        for (const peer of Object.keys(pkg.peerDependencies)) {
-          required.add(peer);
-        }
-      }
-    } catch {
-    }
-  }
-  return required;
-}
-
-// src/actions/deplint/getScriptReferencedPackages.ts
-function getBinNames(location, dep) {
-  const depPkgPath = findDepPackageJson(location, dep);
-  if (!depPkgPath) return [];
-  try {
-    const raw = fs6.readFileSync(depPkgPath, "utf8");
-    const pkg = JSON.parse(raw);
-    if (!pkg.bin) return [];
-    if (typeof pkg.bin === "string") return [pkg.name?.split("/").pop() ?? dep];
-    return Object.keys(pkg.bin);
-  } catch {
-    return [];
-  }
-}
-function tokenizeScript(script) {
-  return script.split(/[&|;$()"`\s]+/).map((t) => t.trim()).filter(Boolean);
-}
-function getScriptReferencedPackages(location, allDeps) {
-  const pkgPath = path4.join(location, "package.json");
-  let scripts = {};
-  try {
-    const raw = fs6.readFileSync(pkgPath, "utf8");
-    const pkg = JSON.parse(raw);
-    scripts = pkg.scripts ?? {};
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-  const scriptText = Object.values(scripts).join(" ");
-  const tokens = new Set(tokenizeScript(scriptText));
-  const binToPackage = /* @__PURE__ */ new Map();
-  for (const dep of allDeps) {
-    const bins = getBinNames(location, dep);
-    for (const bin of bins) {
-      binToPackage.set(bin, dep);
-    }
-  }
-  const referenced = /* @__PURE__ */ new Set();
-  for (const token of tokens) {
-    const baseName = getBasePackageName(token);
-    if (allDeps.includes(baseName)) {
-      referenced.add(baseName);
-    }
-    const pkg = binToPackage.get(token);
-    if (pkg) {
-      referenced.add(pkg);
-    }
-  }
-  return referenced;
-}
-
-// src/actions/deplint/getCliReferencedPackagesFromFiles.ts
-var shellCommandFunctions = /* @__PURE__ */ new Set(["execSync", "exec"]);
-var directExecFunctions = /* @__PURE__ */ new Set(["spawn", "spawnSync", "execFile", "execFileSync"]);
-var allExecFunctions = /* @__PURE__ */ new Set([...shellCommandFunctions, ...directExecFunctions]);
-function getCommandTokensFromFile(filePath) {
-  const tokens = /* @__PURE__ */ new Set();
-  let sourceCode;
-  try {
-    sourceCode = fs7.readFileSync(filePath, "utf8");
-  } catch {
-    return tokens;
-  }
-  const isMjsFile = filePath.endsWith(".mjs");
-  const sourceFile = ts2.createSourceFile(
-    path5.basename(filePath),
-    sourceCode,
-    ts2.ScriptTarget.Latest,
-    true,
-    isMjsFile ? ts2.ScriptKind.JS : void 0
-  );
-  function visit(node) {
-    if (ts2.isCallExpression(node) && node.arguments.length > 0) {
-      const fnName = getFunctionName(node.expression);
-      if (fnName && allExecFunctions.has(fnName)) {
-        const firstArg = node.arguments[0];
-        if (ts2.isStringLiteral(firstArg) || ts2.isNoSubstitutionTemplateLiteral(firstArg)) {
-          const value = firstArg.text;
-          if (shellCommandFunctions.has(fnName)) {
-            for (const token of tokenizeScript(value)) {
-              tokens.add(token);
-            }
-          } else {
-            tokens.add(value);
-          }
-        } else if (ts2.isTemplateExpression(firstArg)) {
-          const head = firstArg.head.text;
-          if (head) {
-            for (const token of tokenizeScript(head)) {
-              tokens.add(token);
-            }
-          }
-        }
-      }
-    }
-    ts2.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return tokens;
-}
-function getFunctionName(expr) {
-  if (ts2.isIdentifier(expr)) {
-    return expr.text;
-  }
-  if (ts2.isPropertyAccessExpression(expr) && ts2.isIdentifier(expr.name)) {
-    return expr.name.text;
-  }
-  return void 0;
-}
-function getCliReferencedPackagesFromFiles(allFiles, location, allDeps) {
-  const allTokens = /* @__PURE__ */ new Set();
-  for (const file of allFiles) {
-    for (const token of getCommandTokensFromFile(file)) {
-      allTokens.add(token);
-    }
-  }
-  if (allTokens.size === 0) return /* @__PURE__ */ new Set();
-  const binToPackage = /* @__PURE__ */ new Map();
-  for (const dep of allDeps) {
-    for (const bin of getBinNames(location, dep)) {
-      binToPackage.set(bin, dep);
-    }
-  }
-  const referenced = /* @__PURE__ */ new Set();
-  for (const token of allTokens) {
-    const baseName = getBasePackageName(token);
-    if (allDeps.includes(baseName)) {
-      referenced.add(baseName);
-    }
-    const pkg = binToPackage.get(token);
-    if (pkg) {
-      referenced.add(pkg);
-    }
-  }
-  return referenced;
-}
-
-// src/actions/deplint/implicitDevDependencies.ts
-import fs8 from "fs";
-var hasFileWithExtension = (files, extensions) => files.some((f) => extensions.some((ext) => f.endsWith(ext)));
-var tsExtensions = [".ts", ".tsx", ".mts", ".cts"];
-var hasTypescriptFiles = ({ allFiles }) => hasFileWithExtension(allFiles, tsExtensions);
-var decoratorPattern = /^\s*@[a-zA-Z]\w*/m;
-var hasDecorators = ({ allFiles }) => allFiles.filter((f) => tsExtensions.some((ext) => f.endsWith(ext))).some((file) => {
-  try {
-    const content = fs8.readFileSync(file, "utf8");
-    return decoratorPattern.test(content);
-  } catch {
-    return false;
-  }
-});
-var importPlugins = /* @__PURE__ */ new Set(["eslint-plugin-import-x", "eslint-plugin-import"]);
-function hasImportPlugin({ location, allDependencies }) {
-  if (allDependencies.some((d) => importPlugins.has(d))) return true;
-  for (const dep of allDependencies) {
-    const pkgPath = findDepPackageJson(location, dep);
-    if (!pkgPath) continue;
-    try {
-      const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
-      const transitiveDeps = [
-        ...Object.keys(pkg.dependencies ?? {}),
-        ...Object.keys(pkg.peerDependencies ?? {})
-      ];
-      if (transitiveDeps.some((d) => importPlugins.has(d))) return true;
-    } catch {
-    }
-  }
-  return false;
-}
-var hasVitest = ({ allDependencies }) => allDependencies.includes("vitest");
-var rules = [
-  {
-    package: "typescript",
-    isNeeded: hasTypescriptFiles
-  },
-  {
-    package: "eslint-import-resolver-typescript",
-    isNeeded: (context) => hasTypescriptFiles(context) && context.allDependencies.includes("eslint") && hasImportPlugin(context)
-  },
-  {
-    package: "tslib",
-    isNeeded: hasDecorators
-  },
-  {
-    package: "@vitest/coverage-v8",
-    isNeeded: hasVitest
-  }
-];
-function getImplicitDevDependencies(context) {
-  const implicit = /* @__PURE__ */ new Set();
-  for (const rule of rules) {
-    if (rule.isNeeded(context)) {
-      implicit.add(rule.package);
-    }
-  }
-  return implicit;
-}
-
-// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
-var allExternalImports = ({
-  externalAllImports,
-  externalDistImports,
-  externalDistTypeImports
-}) => {
-  return /* @__PURE__ */ new Set([
-    ...externalAllImports,
-    ...externalDistImports,
-    ...externalDistTypeImports
-  ]);
-};
-function isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs, cliRefs) {
-  if (implicitDeps.has(dep)) return true;
-  if (requiredPeers.has(dep)) return true;
-  if (scriptRefs.has(dep)) return true;
-  if (cliRefs.has(dep)) return true;
-  if (dep.startsWith("@types/")) {
-    const baseName = dep.replace(/^@types\//, "");
-    return allImports.has(baseName) || allImports.has(dep) || implicitDeps.has(baseName);
-  }
-  return allImports.has(dep);
-}
-function getUnusedDevDependencies({ name, location }, {
-  devDependencies,
-  dependencies,
-  peerDependencies
-}, sourceParams, fileContext, exclude) {
-  const allImports = allExternalImports(sourceParams);
-  const allDeps = [...dependencies, ...devDependencies, ...peerDependencies];
-  const implicitDeps = getImplicitDevDependencies({
-    ...fileContext,
-    allDependencies: allDeps,
-    location
-  });
-  const requiredPeers = getRequiredPeerDependencies(location, allDeps);
-  const scriptRefs = getScriptReferencedPackages(location, allDeps);
-  const cliRefs = getCliReferencedPackagesFromFiles(fileContext.allFiles, location, allDeps);
-  let unusedDevDependencies = 0;
-  for (const dep of devDependencies) {
-    if (exclude?.has(dep)) continue;
-    if (dependencies.includes(dep) || peerDependencies.includes(dep)) continue;
-    if (!isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs, cliRefs)) {
-      unusedDevDependencies++;
-      console.log(`[${chalk4.blue(name)}] Unused devDependency in package.json: ${chalk4.red(dep)}`);
-    }
-  }
-  if (unusedDevDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk4.yellow(packageLocation)}
-`);
-  }
-  return unusedDevDependencies;
-}
-
-// src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
-import chalk5 from "chalk";
-function getUnusedPeerDependencies({ name, location }, { peerDependencies, dependencies }, { externalDistImports, externalDistTypeImports }, exclude) {
-  let unusedDependencies = 0;
-  for (const dep of peerDependencies) {
-    if (exclude?.has(dep)) continue;
-    if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
-      unusedDependencies++;
-      if (dependencies.includes(dep)) {
-        console.log(`[${chalk5.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk5.red(dep)}`);
-      } else {
-        console.log(`[${chalk5.blue(name)}] Unused peerDependency in package.json: ${chalk5.red(dep)}`);
-      }
-    }
-  }
-  if (unusedDependencies > 0) {
-    const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk5.yellow(packageLocation)}
-`);
-  }
-  return unusedDependencies;
-}
-
-// src/actions/deplint/checkPackage/checkPackage.ts
-function logVerbose(name, location, allFiles, distFiles, tsconfigExtends) {
-  console.info(`Checking package: ${name} at ${location}`);
-  console.info(`All files: ${allFiles.length}, Distribution files: ${distFiles.length}`);
-  for (const file of allFiles) {
-    console.info(`File: ${file}`);
-  }
-  for (const file of distFiles) {
-    console.info(`Distribution file: ${file}`);
-  }
-  for (const ext of tsconfigExtends) {
-    console.info(`Tsconfig extends: ${ext}`);
-  }
-}
-function checkPackage({
-  name,
-  location,
-  deps = false,
-  devDeps = false,
-  exclude,
-  peerDeps = false,
-  verbose = false
-}) {
-  const { allFiles, distFiles } = findFiles(location);
-  const tsconfigExtends = getExtendsFromTsconfigs(location);
-  if (verbose) {
-    logVerbose(name, location, allFiles, distFiles, tsconfigExtends);
-  }
-  const checkDeps = deps || !(deps || devDeps || peerDeps);
-  const checkDevDeps = devDeps || !(deps || devDeps || peerDeps);
-  const checkPeerDeps = peerDeps;
-  const sourceParams = getExternalImportsFromFiles({
-    allFiles,
-    distFiles,
-    tsconfigExtends
-  });
-  const packageParams = getDependenciesFromPackageJson(`${location}/package.json`);
-  const unlistedDependencies = checkDeps ? getUnlistedDependencies({ name, location }, packageParams, sourceParams) : 0;
-  const unusedDependencies = checkDeps ? getUnusedDependencies({ name, location }, packageParams, sourceParams, exclude) : 0;
-  const unlistedDevDependencies = checkDevDeps ? getUnlistedDevDependencies({ name, location }, packageParams, sourceParams) : 0;
-  const fileContext = { allFiles, distFiles };
-  const unusedDevDependencies = checkDevDeps ? getUnusedDevDependencies({ name, location }, packageParams, sourceParams, fileContext, exclude) : 0;
-  const unusedPeerDependencies = checkPeerDeps ? getUnusedPeerDependencies({ name, location }, packageParams, sourceParams, exclude) : 0;
-  const totalErrors = unlistedDependencies + unlistedDevDependencies + unusedDependencies + unusedDevDependencies + unusedPeerDependencies;
-  return totalErrors;
-}
-export {
-  checkPackage
-};
-//# sourceMappingURL=index.mjs.map