@reliverse/dler 2.3.2 → 2.3.4

package/dist/cmds/rm/impl.js

@@ -0,0 +1,509 @@
+import { existsSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { createIncludeFilter } from "@reliverse/matcha";
+import path from "@reliverse/pathkit";
+import { logger } from "@reliverse/relinka";
+import { hasWorkspaces, readPackageJSON, writePackageJSON } from "@reliverse/typerso";
+import { runInstallCommand } from "../update/utils.js";
+const packageInfoCache = /* @__PURE__ */ new Map();
+async function getWorkspacePackageInfos(monorepoInfo) {
+  if (packageInfoCache.has(monorepoInfo.rootPath)) {
+    return packageInfoCache.get(monorepoInfo.rootPath);
+  }
+  if (!monorepoInfo.workspacePackages) {
+    const empty = [];
+    packageInfoCache.set(monorepoInfo.rootPath, empty);
+    return empty;
+  }
+  const packageInfos = [];
+  const readPromises = monorepoInfo.workspacePackages.map(async (pkgPath) => {
+    const packageJson = await readPackageJSON(pkgPath);
+    if (packageJson?.name) {
+      return {
+        name: packageJson.name,
+        path: pkgPath,
+        json: packageJson
+      };
+    }
+    return null;
+  });
+  const results = await Promise.all(readPromises);
+  for (const result of results) {
+    if (result) {
+      packageInfos.push(result);
+    }
+  }
+  packageInfoCache.set(monorepoInfo.rootPath, packageInfos);
+  return packageInfos;
+}
+const monorepoCache = /* @__PURE__ */ new Map();
+async function detectMonorepo(startDir) {
+  const cwd = resolve(startDir ?? process.cwd());
+  if (monorepoCache.has(cwd)) {
+    return monorepoCache.get(cwd);
+  }
+  let currentDir = cwd;
+  while (true) {
+    const packageJsonPath2 = path.join(currentDir, "package.json");
+    if (existsSync(packageJsonPath2)) {
+      const packageJson2 = await readPackageJSON(currentDir);
+      if (packageJson2 && hasWorkspaces(packageJson2)) {
+        const workspacePackages = await discoverWorkspacePackages(currentDir, packageJson2);
+        const result2 = {
+          isMonorepo: true,
+          rootPath: currentDir,
+          rootPackageJson: packageJson2,
+          workspacePackages
+        };
+        monorepoCache.set(cwd, result2);
+        return result2;
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    throw new Error("No package.json found in current directory or any parent directory");
+  }
+  const packageJson = await readPackageJSON(cwd);
+  if (!packageJson) {
+    throw new Error("Could not read package.json");
+  }
+  const result = {
+    isMonorepo: false,
+    rootPath: cwd,
+    rootPackageJson: packageJson
+  };
+  monorepoCache.set(cwd, result);
+  return result;
+}
+const workspaceCache = /* @__PURE__ */ new Map();
+async function discoverWorkspacePackages(monorepoRoot, rootPackageJson) {
+  if (workspaceCache.has(monorepoRoot)) {
+    return workspaceCache.get(monorepoRoot);
+  }
+  const packages = [];
+  if (!rootPackageJson.workspaces?.packages) {
+    workspaceCache.set(monorepoRoot, packages);
+    return packages;
+  }
+  const patterns = Array.isArray(rootPackageJson.workspaces.packages) ? rootPackageJson.workspaces.packages : [];
+  const packagePaths = [];
+  const validationPromises = [];
+  for (const pattern of patterns) {
+    if (pattern.includes("*")) {
+      const glob = new Bun.Glob(pattern);
+      const matches = glob.scanSync({ cwd: monorepoRoot, onlyFiles: false });
+      for (const match of matches) {
+        const packagePath = resolve(monorepoRoot, match);
+        packagePaths.push(packagePath);
+        validationPromises.push(isValidWorkspacePackage(packagePath));
+      }
+    } else {
+      const packagePath = resolve(monorepoRoot, pattern);
+      packagePaths.push(packagePath);
+      validationPromises.push(isValidWorkspacePackage(packagePath));
+    }
+  }
+  const validationResults = await Promise.all(validationPromises);
+  for (let i = 0; i < packagePaths.length; i++) {
+    if (validationResults[i]) {
+      packages.push(packagePaths[i]);
+    }
+  }
+  workspaceCache.set(monorepoRoot, packages);
+  return packages;
+}
+async function isValidWorkspacePackage(packagePath) {
+  const packageJsonPath = path.join(packagePath, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  const packageJson = await readPackageJSON(packagePath);
+  return !!packageJson?.name;
+}
+function resolveCatalog(monorepoInfo, catalogOption) {
+  if (!monorepoInfo.isMonorepo) {
+    return { catalogName: null, catalogPath: null };
+  }
+  const workspaces = monorepoInfo.rootPackageJson.workspaces;
+  if (catalogOption === false) {
+    return { catalogName: null, catalogPath: null };
+  }
+  let catalogName;
+  if (typeof catalogOption === "string") {
+    catalogName = catalogOption;
+  } else {
+    catalogName = "catalog";
+  }
+  const catalogExists = workspaces[catalogName];
+  if (!catalogExists) {
+    if (typeof catalogOption === "string") {
+      throw new Error(`Catalog '${catalogName}' not found in workspaces configuration`);
+    }
+    return { catalogName: null, catalogPath: null };
+  }
+  return {
+    catalogName,
+    catalogPath: catalogName
+  };
+}
+function containsGlobPattern(str) {
+  return str.includes("*") || str.includes("?") || str.includes("[") || str.includes("{");
+}
+function containsMultipleTargets(str) {
+  return str.includes(" ") && str.trim().split(/\s+/).length > 1;
+}
+async function resolveTargetPackage(monorepoInfo, options) {
+  const { target, w } = options;
+  if (w) {
+    return {
+      packagePath: monorepoInfo.rootPath,
+      packageJson: monorepoInfo.rootPackageJson
+    };
+  }
+  if (target) {
+    if (!monorepoInfo.isMonorepo) {
+      throw new Error("--target can only be used in monorepo environments");
+    }
+    if (target === ".") {
+      const cwd = resolve(options.cwd ?? process.cwd());
+      if (path.relative(monorepoInfo.rootPath, cwd) === "") {
+        return {
+          packagePath: monorepoInfo.rootPath,
+          packageJson: monorepoInfo.rootPackageJson
+        };
+      }
+      const workspacePackage = monorepoInfo.workspacePackages?.find(
+        (pkgPath) => path.relative(pkgPath, cwd) === "" || cwd === pkgPath || cwd.startsWith(pkgPath + path.sep)
+      );
+      if (workspacePackage) {
+        const packageInfos2 = await getWorkspacePackageInfos(monorepoInfo);
+        const cachedInfo = packageInfos2.find((info) => info.path === workspacePackage);
+        if (cachedInfo) {
+          return {
+            packagePath: workspacePackage,
+            packageJson: cachedInfo.json
+          };
+        }
+        const packageJson = await readPackageJSON(workspacePackage);
+        if (!packageJson) {
+          throw new Error(`Could not read package.json from ${workspacePackage}`);
+        }
+        return {
+          packagePath: workspacePackage,
+          packageJson
+        };
+      }
+      throw new Error(`Current directory is not a workspace package and not the monorepo root`);
+    }
+    if (containsMultipleTargets(target)) {
+      const targetNames = target.trim().split(/\s+/);
+      const packageInfos2 = await getWorkspacePackageInfos(monorepoInfo);
+      const targets = [];
+      for (const targetName of targetNames) {
+        if (targetName === "*") {
+          targets.push(
+            ...packageInfos2.map((pkg) => ({
+              packagePath: pkg.path,
+              packageJson: pkg.json
+            }))
+          );
+        } else if (containsGlobPattern(targetName)) {
+          const includeFilter = createIncludeFilter(targetName);
+          const matchingPackages = includeFilter(packageInfos2);
+          if (matchingPackages.length === 0) {
+            throw new Error(`No workspace packages match pattern '${targetName}'`);
+          }
+          targets.push(
+            ...matchingPackages.map((pkg) => ({
+              packagePath: pkg.path,
+              packageJson: pkg.json
+            }))
+          );
+        } else {
+          const matchingPackage2 = packageInfos2.find((info) => info.name === targetName);
+          if (!matchingPackage2) {
+            throw new Error(`Workspace package '${targetName}' not found`);
+          }
+          targets.push({
+            packagePath: matchingPackage2.path,
+            packageJson: matchingPackage2.json
+          });
+        }
+      }
+      const uniqueTargets = targets.filter(
+        (target2, index, self) => index === self.findIndex((t) => t.packagePath === target2.packagePath)
+      );
+      return {
+        targets: uniqueTargets,
+        isMultiple: true
+      };
+    }
+    if (target === "*") {
+      const packageInfos2 = await getWorkspacePackageInfos(monorepoInfo);
+      const targets = packageInfos2.map((pkg) => ({
+        packagePath: pkg.path,
+        packageJson: pkg.json
+      }));
+      return {
+        targets,
+        isMultiple: true
+      };
+    }
+    const packageInfos = await getWorkspacePackageInfos(monorepoInfo);
+    const matchingPackage = packageInfos.find((info) => info.name === target);
+    if (!matchingPackage) {
+      throw new Error(`Workspace package '${target}' not found`);
+    }
+    return {
+      packagePath: matchingPackage.path,
+      packageJson: matchingPackage.json
+    };
+  }
+  if (monorepoInfo.isMonorepo) {
+    return {
+      packagePath: monorepoInfo.rootPath,
+      packageJson: monorepoInfo.rootPackageJson
+    };
+  } else {
+    return {
+      packagePath: monorepoInfo.rootPath,
+      packageJson: monorepoInfo.rootPackageJson
+    };
+  }
+}
+async function removeDependencyFromPackage(packagePath, packageJson, packageName, scope, dryRun, verbose) {
+  const packageJsonPath = path.join(packagePath, "package.json");
+  const relativePath = relative(process.cwd(), packageJsonPath) || "package.json";
+  const allScopes = [
+    "prod",
+    "dev",
+    "peer",
+    "optional"
+  ];
+  let changesMade = false;
+  if (scope) {
+    const fieldName = getDependencyFieldName(scope);
+    if (!packageJson[fieldName]?.[packageName]) {
+      const foundInScopes = [];
+      for (const checkScope of allScopes) {
+        const checkFieldName = getDependencyFieldName(checkScope);
+        if (packageJson[checkFieldName]?.[packageName]) {
+          foundInScopes.push(checkScope);
+        }
+      }
+      if (foundInScopes.length > 0) {
+        logger.warn(
+          `\u26A0\uFE0F  ${packageName} not found in ${fieldName} of ${relativePath}, but found in: ${foundInScopes.join(", ")}`
+        );
+        logger.warn(`\u{1F4A1} Try using --${foundInScopes[0]} flag`);
+      } else {
+        if (verbose) {
+          logger.info(`\u2139\uFE0F  ${packageName} not found in ${fieldName} of ${relativePath}`);
+        }
+      }
+      return false;
+    }
+    delete packageJson[fieldName][packageName];
+    if (Object.keys(packageJson[fieldName]).length === 0) {
+      delete packageJson[fieldName];
+    }
+    if (dryRun) {
+      if (verbose) {
+        logger.log(`\u{1F4DD} Would remove ${packageName} from ${fieldName} in ${relativePath}`);
+      }
+    } else {
+      await writePackageJSON(packageJsonPath, packageJson);
+    }
+    return true;
+  }
+  for (const checkScope of allScopes) {
+    const fieldName = getDependencyFieldName(checkScope);
+    if (packageJson[fieldName]?.[packageName]) {
+      delete packageJson[fieldName][packageName];
+      if (Object.keys(packageJson[fieldName]).length === 0) {
+        delete packageJson[fieldName];
+      }
+      changesMade = true;
+      if (dryRun) {
+        if (verbose) {
+          logger.log(`\u{1F4DD} Would remove ${packageName} from ${fieldName} in ${relativePath}`);
+        }
+      }
+    }
+  }
+  if (changesMade && !dryRun) {
+    await writePackageJSON(packageJsonPath, packageJson);
+  }
+  if (!changesMade && verbose) {
+    logger.info(`\u2139\uFE0F  ${packageName} not found in any dependency section of ${relativePath}`);
+  }
+  return changesMade;
+}
+async function removeDependencyFromCatalog(monorepoInfo, catalogInfo, packageName, dryRun, verbose) {
+  const workspaces = monorepoInfo.rootPackageJson.workspaces;
+  const catalogExists = workspaces[catalogInfo.catalogName];
+  if (!catalogExists) {
+    throw new Error(`Catalog '${catalogInfo.catalogName}' not found`);
+  }
+  if (!catalogExists[packageName]) {
+    if (verbose) {
+      logger.info(`\u2139\uFE0F  ${packageName} not found in catalog '${catalogInfo.catalogName}'`);
+    }
+    return false;
+  }
+  if (dryRun) {
+    if (verbose) {
+      logger.log(`\u{1F4DD} Would remove ${packageName} from catalog '${catalogInfo.catalogName}'`);
+    }
+  } else {
+    delete catalogExists[packageName];
+    await writePackageJSON(
+      path.join(monorepoInfo.rootPath, "package.json"),
+      monorepoInfo.rootPackageJson
+    );
+  }
+  return true;
+}
+function getDependencyFieldName(scope) {
+  switch (scope) {
+    case "dev":
+      return "devDependencies";
+    case "prod":
+      return "dependencies";
+    case "peer":
+      return "peerDependencies";
+    case "optional":
+      return "optionalDependencies";
+  }
+}
+export async function removeDependency(packageNames, options) {
+  const packageNameArray = Array.isArray(packageNames) ? packageNames : [packageNames];
+  let totalChangesMade = false;
+  const removedPackages = [];
+  const monorepoInfo = await detectMonorepo(options.cwd);
+  logger.log(
+    `\u{1F4E6} Detected ${monorepoInfo.isMonorepo ? "monorepo" : "single package"} at ${monorepoInfo.rootPath}`
+  );
+  const catalogInfo = resolveCatalog(monorepoInfo, options.catalog);
+  if (catalogInfo.catalogName) {
+    logger.log(`\u{1F4DA} Using catalog '${catalogInfo.catalogName}'`);
+  }
+  const targetResult = await resolveTargetPackage(monorepoInfo, options);
+  if ("isMultiple" in targetResult && targetResult.isMultiple) {
+    if (options.verbose) {
+      logger.log(`\u{1F3AF} Target packages (${targetResult.targets.length}):`);
+      for (const target of targetResult.targets) {
+        const relativePath = relative(process.cwd(), target.packagePath) || "package.json";
+        logger.log(`   \u2022 ${relativePath}`);
+      }
+    }
+    for (const packageName of packageNameArray) {
+      let changesMade = false;
+      if (catalogInfo.catalogName && monorepoInfo.isMonorepo) {
+        const catalogChanged = await removeDependencyFromCatalog(
+          monorepoInfo,
+          catalogInfo,
+          packageName,
+          options.dryRun,
+          options.verbose
+        );
+        changesMade = changesMade || catalogChanged;
+        for (const target of targetResult.targets) {
+          const packageChanged = await removeDependencyFromPackage(
+            target.packagePath,
+            target.packageJson,
+            packageName,
+            options.scope,
+            options.dryRun,
+            options.verbose
+          );
+          changesMade = changesMade || packageChanged;
+        }
+      } else {
+        for (const target of targetResult.targets) {
+          const packageChanged = await removeDependencyFromPackage(
+            target.packagePath,
+            target.packageJson,
+            packageName,
+            options.scope,
+            options.dryRun,
+            options.verbose
+          );
+          changesMade = changesMade || packageChanged;
+        }
+      }
+      if (changesMade) {
+        removedPackages.push(packageName);
+      }
+      totalChangesMade = totalChangesMade || changesMade;
+    }
+  } else {
+    const targetInfo = targetResult;
+    const relativePath = relative(process.cwd(), targetInfo.packagePath) || "package.json";
+    logger.log(`\u{1F3AF} Target package: ${relativePath}`);
+    for (const packageName of packageNameArray) {
+      let changesMade = false;
+      if (catalogInfo.catalogName && monorepoInfo.isMonorepo) {
+        const catalogChanged = await removeDependencyFromCatalog(
+          monorepoInfo,
+          catalogInfo,
+          packageName,
+          options.dryRun,
+          options.verbose
+        );
+        changesMade = changesMade || catalogChanged;
+        const packageChanged = await removeDependencyFromPackage(
+          targetInfo.packagePath,
+          targetInfo.packageJson,
+          packageName,
+          options.scope,
+          options.dryRun,
+          options.verbose
+        );
+        changesMade = changesMade || packageChanged;
+      } else {
+        const packageChanged = await removeDependencyFromPackage(
+          targetInfo.packagePath,
+          targetInfo.packageJson,
+          packageName,
+          options.scope,
+          options.dryRun,
+          options.verbose
+        );
+        changesMade = changesMade || packageChanged;
+      }
+      if (changesMade) {
+        removedPackages.push(packageName);
+      }
+      totalChangesMade = totalChangesMade || changesMade;
+    }
+  }
+  if (removedPackages.length > 0) {
+    if (options.dryRun) {
+      logger.log(`\u{1F4DD} Would remove dependencies: ${removedPackages.join(", ")}`);
+    } else {
+      logger.success(`\u2705 Removed dependencies: ${removedPackages.join(", ")}`);
+    }
+  } else {
+    logger.log("\u2139\uFE0F  No dependencies to remove");
+  }
+  if (totalChangesMade && options.install && !options.dryRun) {
+    try {
+      logger.log("Applying changes (bun install)...");
+      await runInstallCommand(options.verbose);
+      logger.log("Package removal completed successfully");
+    } catch (error) {
+      logger.warn(`bun install failed: ${error instanceof Error ? error.message : String(error)}`);
+      logger.log("Run 'bun install' manually to apply the changes");
+    }
+  } else if (!(options.dryRun || options.install)) {
+    logger.log("Run 'bun install' to apply the changes");
+  }
+  return totalChangesMade;
+}

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

@@ -1,8 +1,2 @@
-declare const _default: import("@reliverse/rempts-core").Command<{
-    action: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
-    name: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
-    value: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | undefined, {}>>;
-    persist: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    yes: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-}, {}, string>;
+declare const _default: any;
 export default _default;

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

@@ -1,9 +1,2 @@
-declare const _default: import("@reliverse/rempts-core").Command<{
-    pattern: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<string | string[] | undefined, {}>>;
-    watch: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    coverage: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    bail: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-    timeout: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<number | undefined, {}>>;
-    all: import("@reliverse/rempts-core").CLIOption<import("arktype").BaseType<boolean | undefined, {}>>;
-}, {}, string>;
+declare const _default: any;
 export default _default;

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

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

package/dist/cmds/tsc/cache.js

@@ -1,34 +1,31 @@
 import { existsSync, statSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { loadCache, saveCache } from "../../utils/cache.js";
 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,
+      cacheDir: options.cacheDir ?? "node_modules/.cache/dler",
       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 {
       this.options.enabled = false;
     }
   }
   async loadMetadata() {
-    if (!existsSync(this.metadataPath)) {
+    const cachedMetadata = await loadCache("tsc");
+    if (!cachedMetadata) {
       this.metadata = {
         version: CACHE_VERSION,
         lastUpdated: Date.now(),
@@ -36,22 +33,14 @@ export class TscCache {
       };
       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 {
+    if (Date.now() - cachedMetadata.lastUpdated > this.options.maxAge) {
       this.metadata = {
         version: CACHE_VERSION,
         lastUpdated: Date.now(),
         packages: {}
       };
+    } else {
+      this.metadata = cachedMetadata;
     }
   }
   async saveMetadata() {
@@ -60,7 +49,7 @@ export class TscCache {
     }
     try {
       this.metadata.lastUpdated = Date.now();
-      await writeFile(this.metadataPath, JSON.stringify(this.metadata, null, 2), "utf-8");
+      await saveCache("tsc", this.metadata);
     } catch {
     }
   }

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

@@ -1,15 +1,2 @@
-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>;
+declare const _default: any;
 export default _default;