@reliverse/dler 2.3.2 → 2.3.4

package/dist/cmds/tsc/impl.js

@@ -153,47 +153,60 @@ const hasProjectReferences = async (packagePath) => {
     return false;
   }
 };
-const findTscExecutable = async (packagePath) => {
-  const localTscPath = join(packagePath, "node_modules", ".bin", "tsc");
-  if (existsSync(localTscPath)) {
-    return localTscPath;
-  }
-  let currentDir = resolve(packagePath, "..");
-  while (currentDir !== "/") {
-    const parentLocalTscPath = join(currentDir, "node_modules", ".bin", "tsc");
-    if (existsSync(parentLocalTscPath)) {
-      return parentLocalTscPath;
+const findTypeScriptExecutable = async (packagePath, preferTsgo = false) => {
+  const findExecutable = async (name) => {
+    const localPath = join(packagePath, "node_modules", ".bin", name);
+    if (existsSync(localPath)) {
+      return localPath;
+    }
+    let currentDir = resolve(packagePath, "..");
+    while (currentDir !== "/") {
+      const parentLocalPath = join(currentDir, "node_modules", ".bin", name);
+      if (existsSync(parentLocalPath)) {
+        return parentLocalPath;
+      }
+      const parentDir = resolve(currentDir, "..");
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
     }
-    const parentDir = resolve(currentDir, "..");
-    if (parentDir === currentDir) {
-      break;
+    const globalPath = await lookpath(name);
+    if (globalPath) {
+      return globalPath;
     }
-    currentDir = parentDir;
-  }
-  const globalTscPath = await lookpath("tsc");
-  if (globalTscPath) {
-    return globalTscPath;
+    return null;
+  };
+  if (preferTsgo) {
+    const tsgoPath = await findExecutable("tsgo");
+    if (tsgoPath) {
+      return { executable: tsgoPath, usedTsgo: true };
+    }
+    const tscPath = await findExecutable("tsc");
+    return { executable: tscPath, usedTsgo: false };
+  } else {
+    const tscPath = await findExecutable("tsc");
+    return { executable: tscPath, usedTsgo: false };
   }
-  return null;
 };
 const runTscCommand = async (packagePath, options = {}) => {
+  const { incremental = true, buildMode = false, preferTsgo = false } = options;
   try {
-    const { incremental = true, buildMode = false, tscExecutable: providedTsc } = options;
-    const tscExecutable = providedTsc ?? await findTscExecutable(packagePath);
-    if (!tscExecutable) {
+    const { executable, usedTsgo } = await findTypeScriptExecutable(packagePath, preferTsgo);
+    if (!executable) {
       throw new Error(
-        "TypeScript not found. Skipping package (install typescript locally or globally to enable type checking)."
+        `${preferTsgo ? "tsgo" : "tsc"} not found. Skipping package (install ${preferTsgo ? "@typescript/native-preview" : "typescript"} locally or globally to enable type checking).`
       );
     }
     let args;
     if (buildMode && await hasProjectReferences(packagePath)) {
-      args = [tscExecutable, "--build"];
-      if (incremental) {
+      args = [executable, "--build"];
+      if (incremental && !usedTsgo) {
         args.push("--incremental");
       }
     } else {
-      args = [tscExecutable, "--noEmit"];
-      if (incremental) {
+      args = [executable, "--noEmit"];
+      if (incremental && !usedTsgo) {
         args.push("--incremental");
         const tsBuildInfoPath = join(
           packagePath,
@@ -215,8 +228,18 @@ const runTscCommand = async (packagePath, options = {}) => {
     const exitCode = await proc.exited;
     return { stdout, stderr, exitCode };
   } catch (error) {
+    if (preferTsgo && error instanceof Error && !error.message.includes("TypeScript not found")) {
+      try {
+        logger.warn(`\u26A0\uFE0F  tsgo failed, falling back to tsc: ${error.message}`);
+        return runTscCommand(packagePath, { ...options, preferTsgo: false });
+      } catch (fallbackError) {
+        throw new Error(
+          `Failed to spawn TypeScript compiler (both tsgo and tsc): ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`
+        );
+      }
+    }
     throw new Error(
-      `Failed to spawn tsc: ${error instanceof Error ? error.message : String(error)}`
+      `Failed to spawn TypeScript compiler: ${error instanceof Error ? error.message : String(error)}`
     );
   }
 };
@@ -271,15 +294,15 @@ const checkRequiredDependencies = async (packagePath) => {
   try {
     const pkg = await readPackageJSON(packagePath);
     if (!pkg) {
-      return { hasTypeScript: false, hasTypesBun: false };
+      return { hasTypeScript: false, hasNativePreview: false };
     }
     const deps = pkg.dependencies && typeof pkg.dependencies === "object" ? pkg.dependencies : {};
     const devDeps = pkg.devDependencies && typeof pkg.devDependencies === "object" ? pkg.devDependencies : {};
     const hasTypeScript = "typescript" in deps || "typescript" in devDeps;
-    const hasTypesBun = "@types/bun" in deps || "@types/bun" in devDeps;
-    return { hasTypeScript, hasTypesBun };
+    const hasNativePreview = "@typescript/native-preview" in deps || "@typescript/native-preview" in devDeps;
+    return { hasTypeScript, hasNativePreview };
   } catch {
-    return { hasTypeScript: false, hasTypesBun: false };
+    return { hasTypeScript: false, hasNativePreview: false };
   }
 };
 const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
@@ -303,19 +326,13 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
       executionTime: Date.now() - startTime
     };
   }
-  const { hasTypeScript, hasTypesBun } = await checkRequiredDependencies(pkg.path);
-  if (!(hasTypeScript && hasTypesBun)) {
-    const missing = [];
-    if (!hasTypeScript) {
-      missing.push("typescript");
-    }
-    if (!hasTypesBun) {
-      missing.push("@types/bun");
-    }
+  const { hasTypeScript, hasNativePreview } = await checkRequiredDependencies(pkg.path);
+  if (!(hasNativePreview || hasTypeScript)) {
     throw new Error(
-      `Package ${pkg.name} has tsconfig.json but ${missing.join(" and ")} ${missing.length === 1 ? "is" : "are"} not listed in dependencies or devDependencies. Please add ${missing.join(" and ")} to this package's package.json (then run bun install).`
+      `Package ${pkg.name} has tsconfig.json but neither "@typescript/native-preview" nor "typescript" is listed in dependencies or devDependencies. Please add one of them to this package's package.json (then run bun install).`
     );
   }
+  const preferTsgo = hasNativePreview;
   if (cache) {
     const shouldSkip = await cache.shouldSkipPackage(pkg);
     if (shouldSkip) {
@@ -342,32 +359,35 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
     logger.info(`\u{1F50D} Checking ${pkg.name}...`);
   }
   try {
-    const tscExecutable = await findTscExecutable(pkg.path);
-    if (!tscExecutable) {
+    const { executable: tsExecutable, usedTsgo } = await findTypeScriptExecutable(
+      pkg.path,
+      preferTsgo
+    );
+    if (!tsExecutable) {
       throw new Error(
-        "TypeScript not found. Skipping package (install typescript locally or globally to enable type checking)."
+        `${preferTsgo ? "tsgo" : "tsc"} not found. Skipping package (install ${preferTsgo ? "@typescript/native-preview" : "typescript"} locally or globally to enable type checking).`
       );
     }
     if (verbose) {
-      const normalizedTscPath = resolve(tscExecutable);
+      const normalizedExecPath = resolve(tsExecutable);
       const normalizedPackagePath = resolve(pkg.path);
       const normalizedMonorepoRoot = resolve(monorepoRoot);
-      const relativeToPackage = relative(normalizedPackagePath, normalizedTscPath);
-      const relativeToMonorepo = relative(normalizedMonorepoRoot, normalizedTscPath);
+      const relativeToPackage = relative(normalizedPackagePath, normalizedExecPath);
+      const relativeToMonorepo = relative(normalizedMonorepoRoot, normalizedExecPath);
       let source;
-      if (normalizedTscPath.startsWith(normalizedPackagePath)) {
+      if (normalizedExecPath.startsWith(normalizedPackagePath)) {
         source = `local (${relativeToPackage})`;
-      } else if (normalizedTscPath.startsWith(normalizedMonorepoRoot)) {
+      } else if (normalizedExecPath.startsWith(normalizedMonorepoRoot)) {
         source = `monorepo root (${relativeToMonorepo})`;
       } else {
-        source = `global (${tscExecutable})`;
+        source = `global (${tsExecutable})`;
       }
-      logger.info(`   Using tsc: ${source}`);
+      logger.info(`   Using ${usedTsgo ? "tsgo" : "tsc"}: ${source}`);
     }
     const result = await runTscCommand(pkg.path, {
       incremental,
       buildMode,
-      tscExecutable
+      preferTsgo
     });
     const output = result.stdout + result.stderr;
     const filteredOutput = filterOutputLines(output, pkg.path, monorepoRoot);
@@ -404,9 +424,9 @@ const runTscOnPackage = async (pkg, monorepoRoot, options = {}) => {
     return tscResult;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("TypeScript not found") || errorMessage.includes("Executable not found")) {
+    if (errorMessage.includes(" not found") || errorMessage.includes("Executable not found")) {
       if (verbose) {
-        logger.info(`\u23ED\uFE0F  Skipping ${pkg.name} (TypeScript not installed in this package)`);
+        logger.info(`\u23ED\uFE0F  Skipping ${pkg.name} (TypeScript compiler not installed in this package)`);
       }
       return {
         package: pkg,
@@ -446,14 +466,11 @@ const collectAllResults = async (packages, monorepoRoot, options = {}, cache) =>
     incremental = true,
     buildMode = false
   } = options;
-  if (!verbose) {
-    logger.info(`Processing ${packages.length} packages...`);
-  }
   try {
     const tscResults = await pMap(
       packages,
       async (pkg, index) => {
-        if (!verbose) {
+        if (verbose) {
           logger.info(`Processing ${pkg.name} (${index + 1}/${packages.length})...`);
         }
         return runTscOnPackage(pkg, monorepoRoot, {
@@ -655,8 +672,7 @@ export const runTscOnAllPackages = async (ignore, cwd, options = {}) => {
     }
     const { stopOnError = false } = options;
     logger.info(
-      `   Checking ${packages.length} packages (concurrency: ${concurrency}, stopOnError: ${stopOnError})...
-`
+      `Checking ${packages.length} packages (concurrency: ${concurrency}, stopOnError: ${stopOnError})...`
     );
     if (verbose) {
       logger.info("\u{1F680} Starting TypeScript checks...\n");

package/dist/cmds/unused/cmd.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/cmds/unused/cmd.js

@@ -0,0 +1,105 @@
+import { logger } from "@reliverse/relinka";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { findUnusedDependencies } from "./impl.js";
+export default defineCommand({
+  description: "Find unused dependencies in package.json files",
+  options: {
+    // Target package selection
+    target: option(type("string | undefined"), {
+      short: "t",
+      description: "Target workspace package(s) (from workspaces.packages). Use '.' for current directory package. Supports multiple packages (space-separated) and glob patterns."
+    }),
+    package: option(type("string | undefined"), {
+      description: "Target workspace package(s) (alias for --target). Use '.' for current directory package. Supports multiple packages (space-separated) and glob patterns."
+    }),
+    pkg: option(type("string | undefined"), {
+      description: "Target workspace package(s) (alias for --target). Use '.' for current directory package. Supports multiple packages (space-separated) and glob patterns."
+    }),
+    w: option(type("boolean | undefined"), {
+      description: "Check unused dependencies in root package.json"
+    }),
+    // Scope filtering
+    scope: option(type("'dev'|'prod'|'peer'|'optional' | undefined"), {
+      short: "s",
+      description: "Check specific dependency scope: dev, prod, peer, optional. If not specified, checks all scopes."
+    }),
+    dev: option(type("boolean | undefined"), {
+      short: "D",
+      description: "Check only devDependencies (shorthand for --scope dev)"
+    }),
+    prod: option(type("boolean | undefined"), {
+      short: "P",
+      description: "Check only dependencies (shorthand for --scope prod)"
+    }),
+    peer: option(type("boolean | undefined"), {
+      short: "R",
+      description: "Check only peerDependencies (shorthand for --scope peer)"
+    }),
+    optional: option(type("boolean | undefined"), {
+      short: "O",
+      description: "Check only optionalDependencies (shorthand for --scope optional)"
+    }),
+    // Analysis options
+    ignore: option(type("string | undefined"), {
+      short: "i",
+      description: "Comma-separated list of package names to ignore when checking for unused dependencies"
+    }),
+    includePeer: option(type("boolean | undefined"), {
+      description: "Include peerDependencies in the analysis (default: false)",
+      default: false
+    }),
+    // Other options
+    cwd: option(type("string | undefined"), {
+      description: "Working directory (monorepo root)"
+    }),
+    verbose: option(type("boolean | undefined"), {
+      short: "v",
+      description: "Verbose output"
+    })
+  },
+  handler: async ({ flags }) => {
+    try {
+      if (typeof process.versions.bun === "undefined") {
+        logger.error("\u274C This command requires Bun runtime.");
+        logger.error("Please run this command using Bun: bun dler unused");
+        process.exit(1);
+      }
+      logger.log("\u{1F50D} Finding unused dependencies...");
+      let scope;
+      if (flags.scope) {
+        scope = flags.scope;
+      } else if (flags.dev) {
+        scope = "dev";
+      } else if (flags.peer) {
+        scope = "peer";
+      } else if (flags.optional) {
+        scope = "optional";
+      }
+      const ignoreList = flags.ignore ? flags.ignore.split(",").map((pkg) => pkg.trim()).filter(Boolean) : void 0;
+      const options = {
+        target: flags.target || flags.package || flags.pkg,
+        w: flags.w,
+        scope,
+        ignore: ignoreList,
+        includePeer: flags.includePeer ?? false,
+        cwd: flags.cwd || void 0,
+        verbose: flags.verbose ?? false
+      };
+      await findUnusedDependencies(options);
+    } catch (error) {
+      logger.error("\n\u274C Failed to find unused dependencies:");
+      if (error instanceof Error) {
+        logger.error(error.message);
+      } else {
+        logger.error(String(error));
+      }
+      logger.log("");
+      logger.log("\u{1F4A1} Tips:");
+      logger.log("  \u2022 Ensure you're in a valid project directory with package.json");
+      logger.log("  \u2022 Use --verbose flag for more detailed output");
+      logger.log("  \u2022 Use --ignore flag to exclude specific packages from analysis");
+      process.exit(1);
+    }
+  }
+});

package/dist/cmds/unused/impl.d.ts

@@ -0,0 +1,16 @@
+export interface UnusedOptions {
+    target?: string;
+    w?: boolean;
+    scope?: "dev" | "prod" | "peer" | "optional";
+    ignore?: string[];
+    includePeer: boolean;
+    cwd?: string;
+    verbose: boolean;
+}
+export interface MonorepoInfo {
+    isMonorepo: boolean;
+    rootPath: string;
+    rootPackageJson: any;
+    workspacePackages?: string[];
+}
+export declare function findUnusedDependencies(options: UnusedOptions): Promise<void>;