@reliverse/dler 1.7.153 → 2.0.1

package/dist/cmds/publish/cmd.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env bun
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import {
+  publishAllPackages
+} from "@reliverse/dler-publish";
+const publishCmd = async (args) => {
+  try {
+    if (typeof process.versions.bun === "undefined") {
+      logger.error("\u274C This command requires Bun runtime. Sorry.");
+      process.exit(1);
+    }
+    const options = {
+      dryRun: args.dryRun,
+      tag: args.tag,
+      access: args.access,
+      otp: args.otp,
+      authType: args.authType,
+      verbose: args.verbose,
+      bump: args.bump,
+      concurrency: args.concurrency,
+      registry: args.registry,
+      kind: args.kind,
+      bumpDisable: args.bumpDisable
+    };
+    const results = await publishAllPackages(args.cwd, args.ignore, options);
+    if (results.warningCount > 0) {
+      for (const result of results.results) {
+        if (result.warning) {
+          logger.warn(`  \u26A0\uFE0F  ${result.packageName}: ${result.warning}`);
+        }
+      }
+    }
+    if (results.hasErrors) {
+      logger.error(
+        `
+\u274C Publishing failed: ${results.errorCount} error(s), ${results.successCount} success(es)`
+      );
+      for (const result of results.results) {
+        if (!result.success) {
+          logger.error(`  \u274C ${result.packageName}: ${result.error}`);
+        }
+      }
+      process.exit(1);
+    }
+    logger.success(
+      `
+\u2705 All packages published successfully! (${results.successCount} packages)`
+    );
+    if (args.verbose) {
+      for (const result of results.results) {
+        if (result.success && !result.warning) {
+          logger.log(`  \u2705 ${result.packageName}@${result.version}`);
+        }
+      }
+    }
+  } catch (error) {
+    logger.error("\n\u274C Publish failed:");
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+    process.exit(1);
+  }
+};
+const publishCmdArgs = defineCmdArgs({
+  ignore: {
+    type: "string",
+    description: "Package(s) to ignore (supports wildcards like @reliverse/*)"
+  },
+  cwd: {
+    type: "string",
+    description: "Working directory (monorepo root)"
+  },
+  bump: {
+    type: "string",
+    description: "Version bump type: major, minor, patch, premajor, preminor, prepatch, prerelease"
+  },
+  tag: {
+    type: "string",
+    description: "npm dist-tag (default: latest)"
+  },
+  access: {
+    type: "string",
+    description: "Access level: public or restricted (default: public)"
+  },
+  dryRun: {
+    type: "boolean",
+    description: "Simulate publishing without actually publishing (default: false)"
+  },
+  otp: {
+    type: "string",
+    description: "One-time password for 2FA authentication"
+  },
+  authType: {
+    type: "string",
+    description: "Authentication method: web or legacy (default: web)"
+  },
+  concurrency: {
+    type: "number",
+    description: "Number of packages to publish concurrently (default: 3)"
+  },
+  verbose: {
+    type: "boolean",
+    description: "Verbose mode (default: false)"
+  },
+  registry: {
+    type: "string",
+    description: "Registry to publish to: npm, jsr, vercel, npm-jsr, or none (default: npm)"
+  },
+  kind: {
+    type: "string",
+    description: "Package kind: library, browser-app, native-app, or cli (default: library)"
+  },
+  bumpDisable: {
+    type: "boolean",
+    description: "Disable version bumping for all published packages, overwrites config (default: false)"
+  }
+});
+const publishCmdCfg = defineCmdCfg({
+  name: "publish",
+  description: "Publish workspace packages to npm registry using Bun's native publish command. Automatically handles version bumping, package.json modification, and dist folder validation. Supports dler.ts configuration for per-package settings.",
+  examples: [
+    "dler publish",
+    'dler publish --ignore "@reliverse/*"',
+    'dler publish --ignore "@reliverse/dler-colors" --ignore "@reliverse/dler-v1"',
+    'dler publish --ignore "@reliverse/dler-colors @reliverse/dler-v1"',
+    "dler publish --cwd /path/to/monorepo",
+    "dler publish --cwd /path/to/monorepo --ignore @reliverse/*",
+    "dler publish --bump patch",
+    "dler publish --bump minor --tag next",
+    "dler publish --bump major --access public",
+    "dler publish --dry-run",
+    "dler publish --dry-run --verbose",
+    "dler publish --tag alpha",
+    "dler publish --access restricted",
+    "dler publish --otp 123456",
+    "dler publish --auth-type legacy",
+    "dler publish --concurrency 3",
+    "dler publish --verbose",
+    "dler publish --bump patch --tag next --dry-run --verbose",
+    "dler publish --ignore @reliverse/* --bump minor --concurrency 2",
+    "dler publish --registry npm",
+    "dler publish --registry jsr",
+    "dler publish --registry vercel",
+    "dler publish --registry npm-jsr",
+    "dler publish --registry none",
+    "dler publish --kind library",
+    "dler publish --kind browser-app",
+    "dler publish --kind native-app",
+    "dler publish --kind cli",
+    "dler publish --kind library --registry npm",
+    "dler publish --kind browser-app --registry vercel",
+    "dler publish --kind cli --registry jsr",
+    "dler publish --bumpDisable",
+    "dler publish --bumpDisable --dry-run",
+    "dler publish --bumpDisable --tag next",
+    "",
+    "# Configuration Examples:",
+    "# Create dler.ts in your monorepo root:",
+    "# export default {",
+    "#   publish: {",
+    "#     global: { access: 'public', tag: 'latest', registry: 'npm', kind: 'library' },",
+    "#     packages: { ",
+    "#       'my-library': { tag: 'next', bump: 'minor', registry: 'jsr', kind: 'library' },",
+    "#       'my-web-app': { registry: 'vercel', kind: 'browser-app' },",
+    "#       'my-native-app': { registry: 'none', kind: 'native-app' },",
+    "#       'my-cli-tool': { registry: 'npm', kind: 'cli' },",
+    "#       'my-library': { bumpDisable: true, tag: 'next' }",
+    "#     },",
+    "#     patterns: [{ pattern: '*example*', config: { dryRun: true, registry: 'vercel', kind: 'browser-app' } }]",
+    "#   }",
+    "# }",
+    "",
+    "# Note: Make sure to run 'dler build --prepareForPublish' first to:",
+    "# - Generate dist folders and declaration files",
+    "# - Transform package.json exports field for built files",
+    "# - Add bin field for CLI packages",
+    "# - Set private: false and publishConfig",
+    "# The publish command will then handle version bumping and registry publishing",
+    "# CLI flags override dler.ts configuration settings"
+  ]
+});
+export default defineCmd(publishCmd, publishCmdArgs, publishCmdCfg);

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+declare const _default: any;
+export default _default;

package/dist/cmds/shell/cmd.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env bun
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import { $ } from "bun";
+const shellCmd = async (args) => {
+  try {
+    const commandParts = args.x.split(/\s+/);
+    const [command, ...commandArgs] = commandParts;
+    await $`${command} ${commandArgs.join(" ")}`;
+  } catch (error) {
+    logger.error("\n\u274C Command failed:");
+    if (error instanceof Error) {
+      if ("exitCode" in error) {
+        logger.error(`Exit code: ${error.exitCode}`);
+        if (error.stdout) {
+          logger.error(`STDOUT: ${error.stdout.toString()}`);
+        }
+        if (error.stderr) {
+          logger.error(`STDERR: ${error.stderr.toString()}`);
+        }
+      } else {
+        logger.error(error.message);
+      }
+    } else {
+      logger.error(String(error));
+    }
+    process.exit(1);
+  }
+};
+const shellCmdArgs = defineCmdArgs({
+  x: {
+    type: "string",
+    required: true,
+    description: "Shell command to execute"
+  }
+});
+const shellCmdCfg = defineCmdCfg({
+  name: "shell",
+  description: "Execute shell commands using Bun Shell API",
+  examples: [
+    'dler shell --x "echo Hello World"',
+    'dler shell --x "ls -la"',
+    'dler shell --x "cat package.json | grep name"'
+  ]
+});
+export default defineCmd(shellCmd, shellCmdArgs, shellCmdCfg);

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

@@ -0,0 +1,27 @@
+import type { PackageInfo } from "./impl.js";
+import type { PackageCacheEntry, TscCacheOptions } from "./types.js";
+export declare class TscCache {
+    private options;
+    private metadata;
+    private metadataPath;
+    constructor(options?: Partial<TscCacheOptions>);
+    initialize(): Promise<void>;
+    private loadMetadata;
+    private saveMetadata;
+    private getSourceFiles;
+    private hasSourceFilesChanged;
+    shouldSkipPackage(pkg: PackageInfo): Promise<boolean>;
+    getCachedResult(pkg: PackageInfo): Promise<PackageCacheEntry | null>;
+    updatePackageCache(pkg: PackageInfo, result: {
+        success: boolean;
+        errorCount: number;
+        warningCount: number;
+        output?: string;
+        filteredOutput?: string;
+    }): Promise<void>;
+    clearCache(): Promise<void>;
+    getCacheStats(): {
+        totalPackages: number;
+        successfulPackages: number;
+    };
+}

package/dist/cmds/tsc/cache.js

@@ -0,0 +1,160 @@
+import { existsSync, statSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const CACHE_VERSION = "1.0.0";
+const DEFAULT_CACHE_DIR = "node_modules/.cache/dler-tsc";
+const DEFAULT_MAX_AGE = 24 * 60 * 60 * 1e3;
+export class TscCache {
+  options;
+  metadata = null;
+  metadataPath;
+  constructor(options = {}) {
+    this.options = {
+      enabled: options.enabled ?? true,
+      cacheDir: options.cacheDir ?? DEFAULT_CACHE_DIR,
+      maxAge: options.maxAge ?? DEFAULT_MAX_AGE
+    };
+    this.metadataPath = join(this.options.cacheDir, "metadata.json");
+  }
+  async initialize() {
+    if (!this.options.enabled) return;
+    try {
+      await mkdir(this.options.cacheDir, { recursive: true });
+      await this.loadMetadata();
+    } catch (error) {
+      this.options.enabled = false;
+    }
+  }
+  async loadMetadata() {
+    if (!existsSync(this.metadataPath)) {
+      this.metadata = {
+        version: CACHE_VERSION,
+        lastUpdated: Date.now(),
+        packages: {}
+      };
+      return;
+    }
+    try {
+      const content = await readFile(this.metadataPath, "utf-8");
+      this.metadata = JSON.parse(content);
+      if (Date.now() - this.metadata.lastUpdated > this.options.maxAge) {
+        this.metadata = {
+          version: CACHE_VERSION,
+          lastUpdated: Date.now(),
+          packages: {}
+        };
+      }
+    } catch {
+      this.metadata = {
+        version: CACHE_VERSION,
+        lastUpdated: Date.now(),
+        packages: {}
+      };
+    }
+  }
+  async saveMetadata() {
+    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"
+      );
+    } catch {
+    }
+  }
+  async getSourceFiles(packagePath) {
+    const sourceFiles = [];
+    const tsConfigPath = join(packagePath, "tsconfig.json");
+    if (!existsSync(tsConfigPath)) {
+      return sourceFiles;
+    }
+    try {
+      const glob = new Bun.Glob("**/*.{ts,tsx}");
+      const matches = glob.scanSync({
+        cwd: packagePath,
+        onlyFiles: true
+      });
+      for (const match of matches) {
+        const filePath = join(packagePath, match);
+        if (existsSync(filePath)) {
+          const stats = statSync(filePath);
+          sourceFiles.push({
+            path: match,
+            mtime: stats.mtime.getTime(),
+            size: stats.size
+          });
+        }
+      }
+    } catch {
+    }
+    return sourceFiles;
+  }
+  hasSourceFilesChanged(cached, current) {
+    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);
+      if (!currentFile || currentFile.mtime !== cachedFile.mtime || currentFile.size !== cachedFile.size) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async shouldSkipPackage(pkg) {
+    if (!this.options.enabled || !this.metadata) return false;
+    const cacheEntry = this.metadata.packages[pkg.name];
+    if (!cacheEntry || !cacheEntry.lastSuccess) return false;
+    const timeSinceLastSuccess = Date.now() - cacheEntry.lastSuccess;
+    if (timeSinceLastSuccess > this.options.maxAge) return false;
+    const currentSourceFiles = await this.getSourceFiles(pkg.path);
+    if (this.hasSourceFilesChanged(cacheEntry.sourceFiles, currentSourceFiles)) {
+      return false;
+    }
+    return true;
+  }
+  async getCachedResult(pkg) {
+    if (!this.options.enabled || !this.metadata) return null;
+    const cacheEntry = this.metadata.packages[pkg.name];
+    if (!cacheEntry) return null;
+    const currentSourceFiles = await this.getSourceFiles(pkg.path);
+    if (this.hasSourceFilesChanged(cacheEntry.sourceFiles, currentSourceFiles)) {
+      return null;
+    }
+    return cacheEntry;
+  }
+  async updatePackageCache(pkg, result) {
+    if (!this.options.enabled || !this.metadata) return;
+    const sourceFiles = await this.getSourceFiles(pkg.path);
+    const now = Date.now();
+    this.metadata.packages[pkg.name] = {
+      lastCheck: now,
+      lastSuccess: result.success ? now : this.metadata.packages[pkg.name]?.lastSuccess ?? null,
+      sourceFiles,
+      hasErrors: !result.success,
+      errorCount: result.errorCount,
+      warningCount: result.warningCount,
+      output: result.output,
+      filteredOutput: result.filteredOutput
+    };
+    await this.saveMetadata();
+  }
+  async clearCache() {
+    if (!this.options.enabled) return;
+    this.metadata = {
+      version: CACHE_VERSION,
+      lastUpdated: Date.now(),
+      packages: {}
+    };
+    await this.saveMetadata();
+  }
+  getCacheStats() {
+    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
+    ).length;
+    return { totalPackages, successfulPackages };
+  }
+}

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

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

package/dist/cmds/tsc/cmd.js

@@ -0,0 +1,111 @@
+import {
+  defineCmd,
+  defineCmdArgs,
+  defineCmdCfg
+} from "@reliverse/dler-launcher";
+import { logger } from "@reliverse/dler-logger";
+import { runTscOnAllPackages } from "./impl.js";
+const tscCmd = async (args) => {
+  try {
+    if (typeof process.versions.bun === "undefined") {
+      logger.error("\u274C This command requires Bun runtime. Sorry.");
+      process.exit(1);
+    }
+    const results = await runTscOnAllPackages(args.ignore, args.cwd, {
+      concurrency: args.concurrency,
+      stopOnError: args.stopOnError,
+      verbose: args.verbose,
+      copyLogs: args.copyLogs,
+      cache: args.cache,
+      incremental: args.incremental,
+      autoConcurrency: args.autoConcurrency,
+      skipUnchanged: args.skipUnchanged,
+      buildMode: args.buildMode
+    });
+    if (results.hasErrors) {
+      process.exit(1);
+    }
+    logger.success("\n\u2705 All packages passed type checking!");
+  } catch (error) {
+    logger.error("\n\u274C TypeScript check failed:");
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+    process.exit(1);
+  }
+};
+const tscCmdArgs = defineCmdArgs({
+  ignore: {
+    type: "string",
+    description: "Package(s) to ignore (supports wildcards like @reliverse/*)"
+  },
+  cwd: {
+    type: "string",
+    description: "Working directory (monorepo root)"
+  },
+  concurrency: {
+    type: "number",
+    description: "Number of packages to check concurrently (default: CPU cores)"
+  },
+  stopOnError: {
+    type: "boolean",
+    description: "Stop on first error instead of collecting all errors (default: false)"
+  },
+  verbose: {
+    type: "boolean",
+    description: "Verbose mode (default: false)"
+  },
+  copyLogs: {
+    type: "boolean",
+    description: "Copy failed package logs to clipboard (default: false)"
+  },
+  cache: {
+    type: "boolean",
+    description: "Enable caching for faster subsequent runs (default: true)"
+  },
+  incremental: {
+    type: "boolean",
+    description: "Use TypeScript incremental compilation (default: true)"
+  },
+  autoConcurrency: {
+    type: "boolean",
+    description: "Auto-detect optimal concurrency based on CPU cores (default: false)"
+  },
+  skipUnchanged: {
+    type: "boolean",
+    description: "Skip packages with no changes since last check (default: true)"
+  },
+  buildMode: {
+    type: "boolean",
+    description: "Use tsc --build for project references (default: false)"
+  }
+});
+const tscCmdCfg = defineCmdCfg({
+  name: "tsc",
+  description: "Run TypeScript type checking on all workspace packages",
+  examples: [
+    "dler tsc",
+    'dler tsc --ignore "@reliverse/*"',
+    'dler tsc --ignore "@reliverse/dler-colors" --ignore "@reliverse/dler-v1"',
+    'dler tsc --ignore "@reliverse/dler-colors @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"
+  ]
+});
+export default defineCmd(tscCmd, tscCmdArgs, tscCmdCfg);

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

@@ -0,0 +1,41 @@
+export interface PackageInfo {
+    name: string;
+    path: string;
+    hasTsConfig: boolean;
+}
+interface TscResult {
+    package: PackageInfo;
+    success: boolean;
+    skipped: boolean;
+    cached: boolean;
+    totalErrors: number;
+    totalWarnings: number;
+    filteredErrors: number;
+    filteredWarnings: number;
+    output: string;
+    filteredOutput: string;
+    executionTime: number;
+}
+interface TscSummary {
+    totalPackages: number;
+    failedPackages: number;
+    successfulPackages: number;
+    skippedPackages: number;
+    totalErrors: number;
+    totalWarnings: number;
+    hasErrors: boolean;
+    results: TscResult[];
+}
+interface TscOptions {
+    concurrency?: number;
+    stopOnError?: boolean;
+    verbose?: boolean;
+    copyLogs?: boolean;
+    cache?: boolean;
+    incremental?: boolean;
+    autoConcurrency?: boolean;
+    skipUnchanged?: boolean;
+    buildMode?: boolean;
+}
+export declare const runTscOnAllPackages: (ignore?: string | string[], cwd?: string, options?: TscOptions) => Promise<TscSummary>;
+export {};