@reliverse/dler 2.3.3 → 2.3.4

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

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

package/dist/cmds/rm/cmd.js

@@ -0,0 +1,133 @@
+import { logger } from "@reliverse/relinka";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { removeDependency } from "./impl.js";
+export default defineCommand({
+  description: "Remove dependencies from package.json files with catalog support",
+  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: "Remove dependency from root package.json"
+    }),
+    // Catalog options
+    catalog: option(type("string | boolean | undefined"), {
+      short: "c",
+      description: "Use catalog mode. Can be 'true', 'false', or a catalog name (e.g., 'testing')",
+      default: true
+    }),
+    // Dependency scope/type
+    scope: option(type("'dev'|'prod'|'peer'|'optional' | undefined"), {
+      short: "s",
+      description: "Dependency scope: dev, prod, peer, optional"
+    }),
+    dev: option(type("boolean | undefined"), {
+      short: "D",
+      description: "Remove from devDependencies (shorthand for --scope dev)"
+    }),
+    prod: option(type("boolean | undefined"), {
+      short: "P",
+      description: "Remove from dependencies (shorthand for --scope prod)"
+    }),
+    peer: option(type("boolean | undefined"), {
+      short: "R",
+      description: "Remove from peerDependencies (shorthand for --scope peer)"
+    }),
+    optional: option(type("boolean | undefined"), {
+      short: "O",
+      description: "Remove from optionalDependencies (shorthand for --scope optional)"
+    }),
+    // Other options
+    install: option(type("boolean | undefined"), {
+      description: "Run install after removing dependencies (default: true)",
+      short: "i",
+      default: true
+    }),
+    cwd: option(type("string | undefined"), {
+      description: "Working directory (monorepo root)"
+    }),
+    dryRun: option(type("boolean | undefined"), {
+      short: "n",
+      description: "Show what would be done without making changes"
+    }),
+    verbose: option(type("boolean | undefined"), {
+      short: "v",
+      description: "Verbose output"
+    })
+  },
+  handler: async ({ flags, positional }) => {
+    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 rm <package>");
+        process.exit(1);
+      }
+      if (positional.length === 0) {
+        logger.error("\u274C No package names provided.");
+        logger.log("Usage: dler rm <package> [package2...] [options]");
+        logger.log("");
+        logger.log("Examples:");
+        logger.log("  dler rm lodash");
+        logger.log("  dler rm typescript --dev");
+        logger.log("  dler rm react react-dom --target @scope/ui");
+        process.exit(1);
+      }
+      const packageList = positional.join(", ");
+      logger.log(`\u{1F5D1}\uFE0F  Removing dependencies: ${packageList}`);
+      if (flags.dryRun) {
+        logger.log("\u{1F50D} Running in dry-run mode (no changes will be made)");
+      }
+      const packageNames = positional;
+      let scope;
+      if (flags.scope) {
+        scope = flags.scope;
+      } else if (flags.dev) {
+        scope = "dev";
+      } else if (flags.prod) {
+        scope = "prod";
+      } else if (flags.peer) {
+        scope = "peer";
+      } else if (flags.optional) {
+        scope = "optional";
+      }
+      let catalogMode = flags.catalog ?? true;
+      if (typeof flags.catalog === "string") {
+        catalogMode = flags.catalog;
+      }
+      const options = {
+        target: flags.target || flags.package || flags.pkg,
+        w: flags.w,
+        catalog: catalogMode,
+        scope,
+        install: flags.install ?? true,
+        cwd: flags.cwd || void 0,
+        dryRun: flags.dryRun ?? false,
+        verbose: flags.verbose ?? false
+      };
+      await removeDependency(packageNames, options);
+    } catch (error) {
+      logger.error("\n\u274C Failed to remove dependencies:");
+      if (error instanceof Error) {
+        logger.error(error.message);
+      } else {
+        logger.error(String(error));
+      }
+      logger.log("");
+      logger.log("\u{1F4A1} Tips:");
+      logger.log("  \u2022 Check if the package names are spelled correctly");
+      logger.log("  \u2022 Ensure the packages are actually installed");
+      logger.log("  \u2022 Use --verbose flag for more detailed output");
+      logger.log("  \u2022 Use --dry-run flag to see what would be changed without making changes");
+      process.exit(1);
+    }
+  }
+});

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

@@ -0,0 +1,17 @@
+export interface RemoveOptions {
+    target?: string;
+    w?: boolean;
+    catalog: boolean | string;
+    scope?: "dev" | "prod" | "peer" | "optional";
+    install: boolean;
+    cwd?: string;
+    dryRun: boolean;
+    verbose: boolean;
+}
+export interface MonorepoInfo {
+    isMonorepo: boolean;
+    rootPath: string;
+    rootPackageJson: any;
+    workspacePackages?: string[];
+}
+export declare function removeDependency(packageNames: string | string[], options: RemoveOptions): Promise<boolean>;

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/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;