@reliverse/dler 2.2.17 → 2.3.1

package/dist/cmds/test/cmd.js

@@ -0,0 +1,157 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { relico } from "@reliverse/relico";
+import { defineCommand, loadConfig, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+export default defineCommand({
+  description: "Run tests for your CLI",
+  alias: "t",
+  options: {
+    pattern: option(type("string | string[] | undefined"), {
+      short: "p",
+      description: "Test file patterns"
+    }),
+    watch: option(type("boolean | undefined"), {
+      short: "w",
+      description: "Watch for changes"
+    }),
+    coverage: option(type("boolean | undefined"), {
+      short: "c",
+      description: "Generate coverage report"
+    }),
+    bail: option(type("boolean | undefined"), {
+      short: "b",
+      description: "Stop on first failure"
+    }),
+    timeout: option(type("number | undefined"), {
+      description: "Test timeout in milliseconds"
+    }),
+    all: option(type("boolean | undefined"), {
+      description: "Run tests in all packages (workspace mode)"
+    })
+  },
+  handler: async ({ flags, positional, spinner, colors }) => {
+    const config = await loadConfig();
+    if (flags.all && config.workspace?.packages) {
+      const packages = config.workspace.packages;
+      let allPassed = true;
+      for (const packagePattern of packages) {
+        const packageDirs = await findPackageDirectories(packagePattern);
+        for (const packageDir of packageDirs) {
+          const spin = spinner(`Testing ${packageDir}...`);
+          spin.start();
+          try {
+            const result = await runTests(packageDir, flags, config);
+            if (result.success) {
+              spin.succeed(`${packageDir} tests passed`);
+            } else {
+              spin.fail(`${packageDir} tests failed`);
+              allPassed = false;
+              if (flags.bail) {
+                break;
+              }
+            }
+          } catch (error) {
+            spin.fail(`${packageDir} tests failed`);
+            console.error(relico.red(error instanceof Error ? error.message : String(error)));
+            allPassed = false;
+            if (flags.bail) {
+              break;
+            }
+          }
+        }
+        if (!allPassed && flags.bail) {
+          break;
+        }
+      }
+      if (!allPassed) {
+        process.exit(1);
+      }
+    } else {
+      const spin = spinner("Running tests...");
+      spin.start();
+      try {
+        const result = await runTests(".", flags, config);
+        if (result.success) {
+          spin.succeed("All tests passed!");
+          console.log(relico.green(`\u2713 ${result.passed} tests passed`));
+          if (result.skipped > 0) {
+            console.log(relico.yellow(`\u229D ${result.skipped} tests skipped`));
+          }
+        } else {
+          spin.fail("Tests failed");
+          console.log(relico.red(`\u2717 ${result.failed} tests failed`));
+          process.exit(1);
+        }
+      } catch (error) {
+        spin.fail("Tests failed");
+        console.error(relico.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+      }
+    }
+  }
+});
+async function runTests(cwd, flags, config) {
+  return new Promise((resolve, reject) => {
+    const args = ["test"];
+    const patterns = flags.pattern || config.test?.pattern || "**/*.test.ts";
+    const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+    args.push(...patternArray);
+    if (flags.watch ?? config.test?.watch) {
+      args.push("--watch");
+    }
+    if (flags.coverage ?? config.test?.coverage) {
+      args.push("--coverage");
+    }
+    if (flags.bail) {
+      args.push("--bail");
+    }
+    if (flags.timeout) {
+      args.push("--timeout", flags.timeout.toString());
+    }
+    const proc = spawn("bun", args, {
+      cwd,
+      stdio: ["inherit", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        NODE_ENV: "test"
+      }
+    });
+    let stdout = "";
+    let _stderr = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+      process.stdout.write(data);
+    });
+    proc.stderr?.on("data", (data) => {
+      _stderr += data.toString();
+      process.stderr.write(data);
+    });
+    proc.on("exit", (code) => {
+      const passed = (stdout.match(/✓/g) || []).length;
+      const failed = (stdout.match(/✗/g) || []).length;
+      const skipped = (stdout.match(/⊝/g) || []).length;
+      resolve({
+        success: code === 0,
+        passed,
+        failed,
+        skipped
+      });
+    });
+    proc.on("error", reject);
+  });
+}
+async function findPackageDirectories(pattern) {
+  if (pattern.endsWith("/*")) {
+    const baseDir = pattern.slice(0, -2);
+    if (existsSync(baseDir)) {
+      const entries = await readdir(baseDir, { withFileTypes: true });
+      return entries.filter(
+        (entry) => entry.isDirectory() && existsSync(path.join(baseDir, entry.name, "package.json"))
+      ).map((entry) => path.join(baseDir, entry.name));
+    }
+  }
+  return [];
+}

package/dist/cmds/tsc/cache.d.ts

@@ -1,9 +1,9 @@
 import type { PackageInfo } from "./impl.js";
 import type { PackageCacheEntry, TscCacheOptions } from "./types.js";
 export declare class TscCache {
-    private options;
+    private readonly options;
     private metadata;
-    private metadataPath;
+    private readonly metadataPath;
     constructor(options?: Partial<TscCacheOptions>);
     initialize(): Promise<void>;
     private loadMetadata;

package/dist/cmds/tsc/cache.js

@@ -17,11 +17,13 @@ export class TscCache {
     this.metadataPath = join(this.options.cacheDir, "metadata.json");
   }
   async initialize() {
-    if (!this.options.enabled) return;
+    if (!this.options.enabled) {
+      return;
+    }
     try {
       await mkdir(this.options.cacheDir, { recursive: true });
       await this.loadMetadata();
-    } catch (_error) {
+    } catch {
       this.options.enabled = false;
     }
   }
@@ -53,14 +55,12 @@ export class TscCache {
     }
   }
   async saveMetadata() {
-    if (!this.options.enabled || !this.metadata) return;
+    if (!(this.options.enabled && this.metadata)) {
+      return;
+    }
     try {
       this.metadata.lastUpdated = Date.now();
-      await writeFile(
-        this.metadataPath,
-        JSON.stringify(this.metadata, null, 2),
-        "utf-8"
-      );
+      await writeFile(this.metadataPath, JSON.stringify(this.metadata, null, 2), "utf-8");
     } catch {
     }
   }
@@ -92,7 +92,9 @@ export class TscCache {
     return sourceFiles;
   }
   hasSourceFilesChanged(cached, current) {
-    if (cached.length !== current.length) return true;
+    if (cached.length !== current.length) {
+      return true;
+    }
     const currentMap = new Map(current.map((file) => [file.path, file]));
     for (const cachedFile of cached) {
       const currentFile = currentMap.get(cachedFile.path);
@@ -103,11 +105,17 @@ export class TscCache {
     return false;
   }
   async shouldSkipPackage(pkg) {
-    if (!this.options.enabled || !this.metadata) return false;
+    if (!(this.options.enabled && this.metadata)) {
+      return false;
+    }
     const cacheEntry = this.metadata.packages[pkg.name];
-    if (!cacheEntry || !cacheEntry.lastSuccess) return false;
+    if (!cacheEntry?.lastSuccess) {
+      return false;
+    }
     const timeSinceLastSuccess = Date.now() - cacheEntry.lastSuccess;
-    if (timeSinceLastSuccess > this.options.maxAge) return false;
+    if (timeSinceLastSuccess > this.options.maxAge) {
+      return false;
+    }
     const currentSourceFiles = await this.getSourceFiles(pkg.path);
     if (this.hasSourceFilesChanged(cacheEntry.sourceFiles, currentSourceFiles)) {
       return false;
@@ -115,9 +123,13 @@ export class TscCache {
     return true;
   }
   async getCachedResult(pkg) {
-    if (!this.options.enabled || !this.metadata) return null;
+    if (!(this.options.enabled && this.metadata)) {
+      return null;
+    }
     const cacheEntry = this.metadata.packages[pkg.name];
-    if (!cacheEntry) return null;
+    if (!cacheEntry) {
+      return null;
+    }
     const currentSourceFiles = await this.getSourceFiles(pkg.path);
     if (this.hasSourceFilesChanged(cacheEntry.sourceFiles, currentSourceFiles)) {
       return null;
@@ -125,7 +137,9 @@ export class TscCache {
     return cacheEntry;
   }
   async updatePackageCache(pkg, result) {
-    if (!this.options.enabled || !this.metadata) return;
+    if (!(this.options.enabled && this.metadata)) {
+      return;
+    }
     const sourceFiles = await this.getSourceFiles(pkg.path);
     const now = Date.now();
     this.metadata.packages[pkg.name] = {
@@ -135,13 +149,15 @@ export class TscCache {
       hasErrors: !result.success,
       errorCount: result.errorCount,
       warningCount: result.warningCount,
-      output: result.output,
-      filteredOutput: result.filteredOutput
+      ...result.output && { output: result.output },
+      ...result.filteredOutput && { filteredOutput: result.filteredOutput }
     };
     await this.saveMetadata();
   }
   async clearCache() {
-    if (!this.options.enabled) return;
+    if (!this.options.enabled) {
+      return;
+    }
     this.metadata = {
       version: CACHE_VERSION,
       lastUpdated: Date.now(),
@@ -150,7 +166,9 @@ export class TscCache {
     await this.saveMetadata();
   }
   getCacheStats() {
-    if (!this.metadata) return { totalPackages: 0, successfulPackages: 0 };
+    if (!this.metadata) {
+      return { totalPackages: 0, successfulPackages: 0 };
+    }
     const totalPackages = Object.keys(this.metadata.packages).length;
     const successfulPackages = Object.values(this.metadata.packages).filter(
       (entry) => entry.lastSuccess !== null

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

@@ -1,2 +1,15 @@
-declare const _default: any;
+declare const _default: import("@reliverse/rempts-core").Command<{
+    filter: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
+    ignore: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
+    cwd: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
+    concurrency: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<number | undefined, {}>>;
+    stopOnError: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
+    verbose: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
+    copyLogs: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
+    cache: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
+    incremental: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
+    autoConcurrency: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
+    skipUnchanged: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
+    buildMode: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
+}, {}, string>;
 export default _default;

package/dist/cmds/tsc/cmd.js

@@ -1,105 +1,69 @@
 import { logger } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
 import { runTscOnAllPackages } from "./impl.js";
 export default defineCommand({
-  meta: {
-    name: "tsc",
-    description: "Run TypeScript type checking on all workspace packages",
-    examples: [
-      "dler tsc",
-      'dler tsc --filter "@reliverse/rempts,@reliverse/build"',
-      'dler tsc --ignore "@reliverse/*"',
-      'dler tsc --ignore "@reliverse/relico" --ignore "@reliverse/dler-v1"',
-      'dler tsc --ignore "@reliverse/relico @reliverse/dler-v1"',
-      "dler tsc --cwd /path/to/monorepo",
-      "dler tsc --cwd /path/to/monorepo --ignore @reliverse/*",
-      "dler tsc --concurrency 8",
-      "dler tsc --concurrency 2 --stopOnError",
-      "dler tsc --ignore @reliverse/* --concurrency 6 --stopOnError",
-      "dler tsc --verbose",
-      "dler tsc --verbose --ignore @reliverse/*",
-      "dler tsc --verbose --concurrency 2 --stopOnError",
-      "dler tsc --copy-logs",
-      "dler tsc --copy-logs --verbose",
-      "dler tsc --auto-concurrency",
-      "dler tsc --no-cache",
-      "dler tsc --no-incremental",
-      "dler tsc --build-mode",
-      "dler tsc --skip-unchanged",
-      "dler tsc --auto-concurrency --build-mode --verbose"
-    ]
-  },
-  args: defineArgs({
-    filter: {
-      type: "string",
-      description: "Package(s) to include (supports wildcards and comma-separated values like '@reliverse/rempts,@reliverse/build'). Takes precedence over --ignore when both are provided.",
-      positional: true
-    },
-    ignore: {
-      type: "string",
+  description: "Run TypeScript type checking on all workspace packages",
+  options: {
+    filter: option(type("string | undefined"), {
+      description: "Package(s) to include (supports wildcards and comma-separated values like 'rempts,@reliverse/build'). Takes precedence over --ignore when both are provided."
+    }),
+    ignore: option(type("string | undefined"), {
       description: "Package(s) to ignore (supports wildcards like @reliverse/*)"
-    },
-    cwd: {
-      type: "string",
+    }),
+    cwd: option(type("string | undefined"), {
       description: "Working directory (monorepo root)"
-    },
-    concurrency: {
-      type: "number",
+    }),
+    concurrency: option(type("number | undefined"), {
       description: "Number of packages to check concurrently (default: CPU cores)"
-    },
-    stopOnError: {
-      type: "boolean",
+    }),
+    stopOnError: option(type("boolean | undefined"), {
       description: "Stop on first error instead of collecting all errors (default: false)"
-    },
-    verbose: {
-      type: "boolean",
+    }),
+    verbose: option(type("boolean | undefined"), {
       description: "Verbose mode (default: false)"
-    },
-    copyLogs: {
-      type: "boolean",
+    }),
+    copyLogs: option(type("boolean | undefined"), {
       description: "Copy failed package logs to clipboard (default: true, skipped in CI)",
       default: true
-    },
-    cache: {
-      type: "boolean",
+    }),
+    cache: option(type("boolean | undefined"), {
       description: "Enable caching for faster subsequent runs (default: true)"
-    },
-    incremental: {
-      type: "boolean",
+    }),
+    incremental: option(type("boolean | undefined"), {
       description: "Use TypeScript incremental compilation (default: true)"
-    },
-    autoConcurrency: {
-      type: "boolean",
+    }),
+    autoConcurrency: option(type("boolean | undefined"), {
       description: "Auto-detect optimal concurrency based on CPU cores (default: false)"
-    },
-    skipUnchanged: {
-      type: "boolean",
+    }),
+    skipUnchanged: option(type("boolean | undefined"), {
       description: "Skip packages with no changes since last check (default: true)"
-    },
-    buildMode: {
-      type: "boolean",
+    }),
+    buildMode: option(type("boolean | undefined"), {
       description: "Use tsc --build for project references (default: false)"
-    }
-  }),
-  run: async ({ args }) => {
+    })
+  },
+  handler: async ({ flags }) => {
     try {
       if (typeof process.versions.bun === "undefined") {
         logger.error("\u274C This command requires Bun runtime. Sorry.");
         process.exit(1);
       }
       const isCI = process.env.CI === "true" || !process.stdout.isTTY;
-      const shouldCopyLogs = args.copyLogs !== false && !isCI;
-      const results = await runTscOnAllPackages(args.ignore, args.cwd, {
-        filter: args.filter,
-        concurrency: args.concurrency,
-        stopOnError: args.stopOnError,
-        verbose: args.verbose,
+      const shouldCopyLogs = flags.copyLogs !== false && !isCI;
+      const results = await runTscOnAllPackages(flags.ignore, flags.cwd, {
         copyLogs: shouldCopyLogs,
-        cache: args.cache,
-        incremental: args.incremental,
-        autoConcurrency: args.autoConcurrency,
-        skipUnchanged: args.skipUnchanged,
-        buildMode: args.buildMode
+        ...flags.filter && { filter: flags.filter },
+        ...flags.concurrency && { concurrency: flags.concurrency },
+        ...flags.stopOnError && { stopOnError: flags.stopOnError },
+        ...flags.verbose && { verbose: flags.verbose },
+        ...flags.cache && { cache: flags.cache },
+        ...flags.incremental && { incremental: flags.incremental },
+        ...flags.autoConcurrency && {
+          autoConcurrency: flags.autoConcurrency
+        },
+        ...flags.skipUnchanged && { skipUnchanged: flags.skipUnchanged },
+        ...flags.buildMode && { buildMode: flags.buildMode }
       });
       if (results.hasErrors) {
         process.exit(1);