@xylabs/ts-scripts-yarn3 7.4.2 → 7.4.3

package/dist/xy/index.mjs

@@ -602,33 +602,48 @@ var dead = () => {
 // src/actions/deplint/deplint.ts
 import chalk16 from "chalk";
 
+// src/actions/deplint/findFiles.ts
+import fs2 from "fs";
+
 // src/actions/deplint/findFilesByGlob.ts
 import { globSync } from "glob";
-function findFilesByGlob(cwd, pattern) {
-  return globSync(pattern, { cwd, absolute: true });
+function findFilesByGlob(cwd, pattern, ignore) {
+  return globSync(pattern, {
+    cwd,
+    absolute: true,
+    ignore,
+    nodir: true
+  });
 }
 
 // src/actions/deplint/findFiles.ts
-function findFiles(path7) {
-  const allSourceInclude = ["./src/**/*.{ts,tsx,mts,cts,js,mjs,cjs}"];
-  const allDistInclude = ["./dist/**/*.d.ts", "./dist/**/*.{mjs,js,cjs}"];
-  const allConfigInclude = ["./*.config.{ts,mts,mjs,js}"];
-  const srcFiles = allSourceInclude.flatMap((pattern) => findFilesByGlob(path7, pattern));
-  const distFiles = allDistInclude.flatMap((pattern) => findFilesByGlob(path7, pattern));
-  const configFiles = allConfigInclude.flatMap((pattern) => findFilesByGlob(path7, pattern));
-  return {
-    srcFiles,
-    distFiles,
-    configFiles
-  };
+var codeExtensions = "*.{ts,tsx,mts,cts,js,mjs,cjs}";
+function getWorkspaceIgnores(location) {
+  try {
+    const raw = fs2.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 fs3 from "fs";
 import path3 from "path";
 function getDependenciesFromPackageJson(packageJsonPath) {
   const packageJsonFullPath = path3.resolve(packageJsonPath);
-  const rawContent = fs2.readFileSync(packageJsonFullPath, "utf8");
+  const rawContent = fs3.readFileSync(packageJsonFullPath, "utf8");
   const packageJson = JSON.parse(rawContent);
   const dependencies = packageJson.dependencies ? Object.keys(packageJson.dependencies) : [];
   const devDependencies = packageJson.devDependencies ? Object.keys(packageJson.devDependencies) : [];
@@ -641,7 +656,7 @@ function getDependenciesFromPackageJson(packageJsonPath) {
 }
 
 // src/actions/deplint/getExtendsFromTsconfigs.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import { globSync as globSync2 } from "glob";
 
 // src/actions/deplint/getBasePackageName.ts
@@ -666,7 +681,7 @@ function getExtendsFromTsconfigs(location) {
   const packages = /* @__PURE__ */ new Set();
   for (const file of tsconfigFiles) {
     try {
-      const content = fs3.readFileSync(file, "utf8");
+      const content = fs4.readFileSync(file, "utf8");
       const cleaned = content.replaceAll(/\/\/.*/g, "").replaceAll(/,\s*([}\]])/g, "$1");
       const parsed = JSON.parse(cleaned);
       const refs = parseExtendsField(parsed.extends);
@@ -682,7 +697,7 @@ function getExtendsFromTsconfigs(location) {
 }
 
 // src/actions/deplint/getImportsFromFile.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
 import ts from "typescript";
 function isTypeOnlyImportClause(clause) {
@@ -697,7 +712,7 @@ function isTypeOnlyImportClause(clause) {
   return clause.isTypeOnly;
 }
 function getImportsFromFile(filePath, importPaths, typeImportPaths) {
-  const sourceCode = fs4.readFileSync(filePath, "utf8");
+  const sourceCode = fs5.readFileSync(filePath, "utf8");
   const isMjsFile = filePath.endsWith(".mjs");
   const sourceFile = ts.createSourceFile(
     path4.basename(filePath),
@@ -708,14 +723,14 @@ function getImportsFromFile(filePath, importPaths, typeImportPaths) {
   );
   const imports = [];
   const typeImports = [];
-  const isDeclarationFile = filePath.endsWith(".d.ts");
+  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 || isDeclarationFile) {
+        if (isTypeImport || isDeclarationFile2) {
           typeImports.push(trimmed);
         } else {
           imports.push(trimmed);
@@ -750,41 +765,34 @@ 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({
-  srcFiles,
+  allFiles,
   distFiles,
-  configFiles = [],
   tsconfigExtends = []
 }) {
-  const srcImportPaths = {};
+  const allImportPaths = {};
   const distImportPaths = {};
   const distTypeImportPaths = {};
-  const configImportPaths = {};
-  for (const path7 of srcFiles) getImportsFromFile(path7, srcImportPaths, srcImportPaths).flat();
-  for (const path7 of configFiles) getImportsFromFile(path7, configImportPaths, configImportPaths).flat();
-  const distTypeFiles = distFiles.filter((file) => file.endsWith(".d.ts") || file.endsWith(".d.cts") || file.endsWith(".d.mts"));
-  const distCodeFiles = distFiles.filter((file) => !(file.endsWith(".d.ts") || file.endsWith(".d.cts") || file.endsWith(".d.mts")));
+  for (const path7 of allFiles) getImportsFromFile(path7, allImportPaths, allImportPaths).flat();
+  const distTypeFiles = distFiles.filter(isDeclarationFile);
+  const distCodeFiles = distFiles.filter((file) => !isDeclarationFile(file));
   for (const path7 of distCodeFiles) getImportsFromFile(path7, distImportPaths, distImportPaths).flat();
   for (const path7 of distTypeFiles) getImportsFromFile(path7, distTypeImportPaths, distTypeImportPaths).flat();
-  const srcImports = Object.keys(srcImportPaths);
+  const allImports = Object.keys(allImportPaths);
   const distImports = Object.keys(distImportPaths);
-  const distTypeImports = Object.keys(distTypeImportPaths);
-  const externalSrcImports = removeInternalImports(srcImports);
+  const externalAllImports = removeInternalImports(allImports);
   const externalDistImports = removeInternalImports(distImports);
-  const externalDistTypeImports = removeInternalImports(distTypeImports);
-  const externalConfigImports = removeInternalImports(Object.keys(configImportPaths));
+  const externalDistTypeImports = removeInternalImports(Object.keys(distTypeImportPaths));
   for (const ext of tsconfigExtends) {
-    if (!externalSrcImports.includes(ext)) externalSrcImports.push(ext);
-    if (!externalConfigImports.includes(ext)) externalConfigImports.push(ext);
+    if (!externalAllImports.includes(ext)) externalAllImports.push(ext);
   }
   return {
-    configImportPaths,
-    srcImports,
-    srcImportPaths,
-    externalConfigImports,
-    externalSrcImports,
-    distImports,
+    allImportPaths,
+    allImports,
     distImportPaths,
+    distImports,
+    externalAllImports,
     externalDistImports,
     externalDistTypeImports
   };
@@ -836,17 +844,17 @@ function getUnlistedDevDependencies({ name, location }, {
   dependencies,
   peerDependencies
 }, {
-  srcImportPaths,
-  externalSrcImports,
+  allImportPaths,
+  externalAllImports,
   distImports
 }) {
   let unlistedDevDependencies = 0;
-  for (const imp of externalSrcImports) {
+  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(`[${chalk12.blue(name)}] Missing devDependency in package.json: ${chalk12.red(imp)}`);
-      if (srcImportPaths[imp]) {
-        console.log(`  ${srcImportPaths[imp].join("\n ")}`);
+      if (allImportPaths[imp]) {
+        console.log(`  ${allImportPaths[imp].join("\n ")}`);
       }
     }
   }
@@ -863,13 +871,13 @@ import chalk13 from "chalk";
 function getUnusedDependencies({ name, location }, { dependencies }, {
   externalDistImports,
   externalDistTypeImports,
-  externalSrcImports
+  externalAllImports
 }) {
   let unusedDependencies = 0;
   for (const dep of dependencies) {
     if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
       unusedDependencies++;
-      if (externalSrcImports.includes(dep)) {
+      if (externalAllImports.includes(dep)) {
         console.log(`[${chalk13.blue(name)}] dependency should be devDependency in package.json: ${chalk13.red(dep)}`);
       } else {
         console.log(`[${chalk13.blue(name)}] Unused dependency in package.json: ${chalk13.red(dep)}`);
@@ -888,13 +896,13 @@ function getUnusedDependencies({ name, location }, { dependencies }, {
 import chalk14 from "chalk";
 
 // src/actions/deplint/getRequiredPeerDependencies.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path5 from "path";
 function findDepPackageJson(location, dep) {
   let dir = location;
   while (true) {
     const candidate = path5.join(dir, "node_modules", dep, "package.json");
-    if (fs5.existsSync(candidate)) return candidate;
+    if (fs6.existsSync(candidate)) return candidate;
     const parent = path5.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
@@ -906,7 +914,7 @@ function getRequiredPeerDependencies(location, allDeps) {
     const depPkgPath = findDepPackageJson(location, dep);
     if (!depPkgPath) continue;
     try {
-      const raw = fs5.readFileSync(depPkgPath, "utf8");
+      const raw = fs6.readFileSync(depPkgPath, "utf8");
       const pkg = JSON.parse(raw);
       if (pkg.peerDependencies) {
         for (const peer of Object.keys(pkg.peerDependencies)) {
@@ -920,13 +928,13 @@ function getRequiredPeerDependencies(location, allDeps) {
 }
 
 // src/actions/deplint/getScriptReferencedPackages.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path6 from "path";
 function getBinNames(location, dep) {
   const depPkgPath = findDepPackageJson(location, dep);
   if (!depPkgPath) return [];
   try {
-    const raw = fs6.readFileSync(depPkgPath, "utf8");
+    const raw = fs7.readFileSync(depPkgPath, "utf8");
     const pkg = JSON.parse(raw);
     if (!pkg.bin) return [];
     if (typeof pkg.bin === "string") return [pkg.name?.split("/").pop() ?? dep];
@@ -942,7 +950,7 @@ function getScriptReferencedPackages(location, allDeps) {
   const pkgPath = path6.join(location, "package.json");
   let scripts = {};
   try {
-    const raw = fs6.readFileSync(pkgPath, "utf8");
+    const raw = fs7.readFileSync(pkgPath, "utf8");
     const pkg = JSON.parse(raw);
     scripts = pkg.scripts ?? {};
   } catch {
@@ -972,14 +980,14 @@ function getScriptReferencedPackages(location, allDeps) {
 }
 
 // src/actions/deplint/implicitDevDependencies.ts
-import fs7 from "fs";
+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 = ({ srcFiles, configFiles }) => hasFileWithExtension([...srcFiles, ...configFiles], tsExtensions);
+var hasTypescriptFiles = ({ allFiles }) => hasFileWithExtension(allFiles, tsExtensions);
 var decoratorPattern = /^\s*@[a-zA-Z]\w*/m;
-var hasDecorators = ({ srcFiles }) => srcFiles.filter((f) => tsExtensions.some((ext) => f.endsWith(ext))).some((file) => {
+var hasDecorators = ({ allFiles }) => allFiles.filter((f) => tsExtensions.some((ext) => f.endsWith(ext))).some((file) => {
   try {
-    const content = fs7.readFileSync(file, "utf8");
+    const content = fs8.readFileSync(file, "utf8");
     return decoratorPattern.test(content);
   } catch {
     return false;
@@ -992,7 +1000,7 @@ function hasImportPlugin({ location, allDependencies }) {
     const pkgPath = findDepPackageJson(location, dep);
     if (!pkgPath) continue;
     try {
-      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf8"));
       const transitiveDeps = [
         ...Object.keys(pkg.dependencies ?? {}),
         ...Object.keys(pkg.peerDependencies ?? {})
@@ -1029,18 +1037,15 @@ function getImplicitDevDependencies(context) {
 
 // src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
 var allExternalImports = ({
-  externalSrcImports,
+  externalAllImports,
   externalDistImports,
-  externalDistTypeImports,
-  externalConfigImports
+  externalDistTypeImports
 }) => {
-  const all = /* @__PURE__ */ new Set([
-    ...externalSrcImports,
+  return /* @__PURE__ */ new Set([
+    ...externalAllImports,
     ...externalDistImports,
-    ...externalDistTypeImports,
-    ...externalConfigImports
+    ...externalDistTypeImports
   ]);
-  return all;
 };
 function isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs) {
   if (implicitDeps.has(dep)) return true;
@@ -1105,18 +1110,15 @@ function getUnusedPeerDependencies({ name, location }, { peerDependencies, depen
 }
 
 // src/actions/deplint/checkPackage/checkPackage.ts
-function logVerbose(name, location, srcFiles, distFiles, configFiles, tsconfigExtends) {
+function logVerbose(name, location, allFiles, distFiles, tsconfigExtends) {
   console.info(`Checking package: ${name} at ${location}`);
-  console.info(`Source files: ${srcFiles.length}, Distribution files: ${distFiles.length}, Config files: ${configFiles.length}`);
-  for (const file of srcFiles) {
-    console.info(`Source file: ${file}`);
+  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 file of configFiles) {
-    console.info(`Config file: ${file}`);
-  }
   for (const ext of tsconfigExtends) {
     console.info(`Tsconfig extends: ${ext}`);
   }
@@ -1129,33 +1131,24 @@ function checkPackage({
   peerDeps = false,
   verbose = false
 }) {
-  const {
-    srcFiles,
-    distFiles,
-    configFiles
-  } = findFiles(location);
+  const { allFiles, distFiles } = findFiles(location);
   const tsconfigExtends = getExtendsFromTsconfigs(location);
   if (verbose) {
-    logVerbose(name, location, srcFiles, distFiles, configFiles, tsconfigExtends);
+    logVerbose(name, location, allFiles, distFiles, tsconfigExtends);
   }
   const checkDeps = deps || !(deps || devDeps || peerDeps);
   const checkDevDeps = devDeps || !(deps || devDeps || peerDeps);
   const checkPeerDeps = peerDeps;
   const sourceParams = getExternalImportsFromFiles({
-    srcFiles,
+    allFiles,
     distFiles,
-    configFiles,
     tsconfigExtends
   });
   const packageParams = getDependenciesFromPackageJson(`${location}/package.json`);
   const unlistedDependencies = checkDeps ? getUnlistedDependencies({ name, location }, packageParams, sourceParams) : 0;
   const unusedDependencies = checkDeps ? getUnusedDependencies({ name, location }, packageParams, sourceParams) : 0;
   const unlistedDevDependencies = checkDevDeps ? getUnlistedDevDependencies({ name, location }, packageParams, sourceParams) : 0;
-  const fileContext = {
-    configFiles,
-    distFiles,
-    srcFiles
-  };
+  const fileContext = { allFiles, distFiles };
   const unusedDevDependencies = checkDevDeps ? getUnusedDevDependencies({ name, location }, packageParams, sourceParams, fileContext) : 0;
   const unusedPeerDependencies = checkPeerDeps ? getUnusedPeerDependencies({ name, location }, packageParams, sourceParams) : 0;
   const totalErrors = unlistedDependencies + unlistedDevDependencies + unusedDependencies + unusedDevDependencies + unusedPeerDependencies;