@reliverse/dler 2.3.2 → 2.3.4

package/dist/cmds/update/impl.js

@@ -8,6 +8,7 @@ import {
   checkPackageUpdate,
   collectTargetDependencies,
   prepareDependenciesForUpdate,
+  prepareDependenciesForUpdateFromMap,
   runInstallCommand
 } from "./utils.js";
 export async function validatePackageJson() {
@@ -18,9 +19,9 @@ export async function validatePackageJson() {
   }
   return packageJsonPath;
 }
-export async function prepareAllUpdateCandidates() {
+export async function prepareAllUpdateCandidates(cwd) {
   const glob = new Glob("**/package.json");
-  const packageJsonFiles = [];
+  let packageJsonFiles = [];
   for await (const file of glob.scan({
     cwd: process.cwd(),
     onlyFiles: true
@@ -30,24 +31,34 @@ export async function prepareAllUpdateCandidates() {
       packageJsonFiles.push(fullPath);
     }
   }
+  if (cwd) {
+    const cwdPath = path.resolve(process.cwd(), cwd);
+    packageJsonFiles = packageJsonFiles.filter((filePath) => {
+      return filePath.startsWith(cwdPath + path.sep) || filePath === path.join(cwdPath, "package.json");
+    });
+  }
   if (packageJsonFiles.length === 0) {
     logger.warn("No package.json files found");
     return { packageJsonFiles: [], fileDepsMap: /* @__PURE__ */ new Map() };
   }
-  logger.debug(`Found ${packageJsonFiles.length} package.json files`);
   const fileDepsMap = /* @__PURE__ */ new Map();
-  for (const packageJsonPath of packageJsonFiles) {
+  const readPromises = packageJsonFiles.map(async (packageJsonPath) => {
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: "utf8" }));
       const { map } = collectTargetDependencies(packageJson);
-      fileDepsMap.set(packageJsonPath, map);
+      return { path: packageJsonPath, map };
     } catch (error) {
       logger.warn(
         `Failed to process ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
       );
+      return { path: packageJsonPath, map: {} };
     }
+  });
+  const readResults = await pMap(readPromises, (promise) => promise, { concurrency: 20 });
+  for (const result of readResults) {
+    fileDepsMap.set(result.path, result.map);
   }
-  logger.debug(`Processing ${packageJsonFiles.length} package.json files`);
+  logger.debug(`Processing ${packageJsonFiles.length} package.json files...`);
   return { packageJsonFiles, fileDepsMap };
 }
 export async function checkPackageUpdatesForFile(fileDepsMap, args) {
@@ -81,6 +92,56 @@ export async function checkPackageUpdatesForFile(fileDepsMap, args) {
     { concurrency: args.concurrency || 5 }
   );
 }
+export async function checkPackageUpdatesForAllFiles(globalDepsMap, args) {
+  const options = {
+    allowMajor: !!args.allowMajor,
+    savePrefix: "^",
+    // Use default prefix
+    concurrency: args.concurrency || 50
+    // Increased default concurrency for HTTP requests
+  };
+  const candidates = prepareDependenciesForUpdateFromMap(globalDepsMap, args);
+  if (candidates.length === 0) {
+    return [];
+  }
+  if (args.verbose) {
+    logger.debug(
+      `Checking ${candidates.length} unique dependencies across all files with concurrency ${options.concurrency}`
+    );
+  }
+  const promises = candidates.map(async (dep) => {
+    const depInfo = globalDepsMap.get(dep);
+    if (!depInfo?.versionSpec) {
+      return {
+        package: dep,
+        currentVersion: "unknown",
+        latestVersion: "unknown",
+        updated: false,
+        error: "Current version not found",
+        semverCompatible: false,
+        location: "unknown"
+      };
+    }
+    return checkPackageUpdate(dep, depInfo.versionSpec, depInfo.locations, options);
+  });
+  const results = await Promise.allSettled(promises);
+  return results.map((result, index) => {
+    if (result.status === "fulfilled") {
+      return result.value;
+    } else {
+      const dep = candidates[index] ?? "unknown";
+      return {
+        package: dep,
+        currentVersion: "unknown",
+        latestVersion: "unknown",
+        updated: false,
+        error: `Failed to check: ${result.reason}`,
+        semverCompatible: false,
+        location: "unknown"
+      };
+    }
+  });
+}
 export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap, updatesToApply, savePrefix, fieldsToIgnore = []) {
   if (updatesToApply.length === 0) {
     return 0;
@@ -127,9 +188,9 @@ export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap
     return 0;
   }
 }
-export async function handleInstallation() {
+export async function handleInstallation(verbose = false) {
   try {
-    await runInstallCommand();
+    await runInstallCommand(verbose);
     logger.log("Installation completed successfully");
   } catch (error) {
     logger.warn(`Install failed: ${error instanceof Error ? error.message : String(error)}`);

package/dist/cmds/update/utils.d.ts

@@ -48,6 +48,7 @@ export declare function isSemverCompatible(currentVersionRange: string, latestVe
 /**
  * Collect ALL dependencies from package.json.
  * Returns a map of dependency name to its version and all locations where it appears.
+ * Early filters out non-updateable dependencies to reduce processing.
  */
 export declare function collectTargetDependencies(pkg: PackageJsonWithCatalogs): {
     map: Record<string, DependencyInfo>;
@@ -61,9 +62,13 @@ export declare function applyVersionUpdate(pkg: PackageJsonWithCatalogs, depName
  */
 export declare function fetchVersionFromRegistry(packageName: string): Promise<string>;
 /**
- * Get latest version of a package
+ * Get latest version of a package with caching
  */
 export declare function getLatestVersion(packageName: string): Promise<string>;
+/**
+ * Initialize persistent cache (call this at the start of update operations)
+ */
+export declare function initializeCache(verbose?: boolean): Promise<void>;
 /**
  * Check if a package needs updating and get update information
  *
@@ -74,6 +79,18 @@ export declare function getLatestVersion(packageName: string): Promise<string>;
  * - When allowMajor=false: Only allows updates within semver range
  */
 export declare function checkPackageUpdate(packageName: string, versionSpec: string, locations: Set<string>, options: PackageCheckOptions): Promise<UpdateResult>;
+/**
+ * Filter and prepare dependencies for updating with glob pattern support (optimized for Map input)
+ */
+export declare function prepareDependenciesForUpdateFromMap(allDepsMap: Map<string, {
+    versionSpec: string;
+    locations: Set<string>;
+    files: Set<string>;
+}>, args: {
+    name?: string[];
+    ignore?: string[];
+    ignoreFields?: string[];
+}): string[];
 /**
  * Filter and prepare dependencies for updating with glob pattern support
  */
@@ -93,5 +110,5 @@ export declare function displayStructuredUpdateResults(results: UpdateResult[],
 /**
  * Run Bun install command
  */
-export declare function runInstallCommand(): Promise<void>;
+export declare function runInstallCommand(verbose?: boolean): Promise<void>;
 export {};

package/dist/cmds/update/utils.js

@@ -4,6 +4,42 @@ import fs from "@reliverse/relifso";
 import { logger } from "@reliverse/relinka";
 import { $ } from "bun";
 import semver from "semver";
+import { loadCache, saveCache } from "../../utils/cache.js";
+const versionCache = /* @__PURE__ */ new Map();
+const CACHE_TTL = 5 * 60 * 1e3;
+const PERSISTENT_CACHE_TTL = 24 * 60 * 60 * 1e3;
+async function loadPersistentCache(verbose = false) {
+  try {
+    const cacheData = await loadCache("update");
+    if (cacheData) {
+      if (Date.now() - cacheData.lastUpdated < PERSISTENT_CACHE_TTL) {
+        for (const [pkg, data] of Object.entries(cacheData.packages)) {
+          versionCache.set(pkg, data);
+        }
+        if (verbose) {
+          logger.debug(`Loaded ${Object.keys(cacheData.packages).length} cached package versions`);
+        }
+      } else {
+        logger.debug("Persistent cache expired, ignoring");
+      }
+    }
+  } catch (error) {
+    logger.debug(
+      `Failed to load persistent cache: ${error instanceof Error ? error.message : String(error)}, continuing without it`
+    );
+  }
+}
+async function savePersistentCache() {
+  try {
+    const cacheData = {
+      packages: Object.fromEntries(versionCache.entries()),
+      lastUpdated: Date.now()
+    };
+    await saveCache("update", cacheData);
+  } catch (error) {
+    logger.debug("Failed to save persistent cache");
+  }
+}
 export function isNpmAlias(versionSpec) {
   return versionSpec.startsWith("npm:");
 }
@@ -24,9 +60,6 @@ export function isSemverCompatible(currentVersionRange, latestVersion) {
     if (isWorkspaceDependency(currentVersionRange)) {
       return false;
     }
-    if (!(currentVersionRange.startsWith("^") || currentVersionRange.startsWith("~"))) {
-      return false;
-    }
     return semver.satisfies(latestVersion, currentVersionRange);
   } catch {
     return false;
@@ -38,75 +71,54 @@ export function collectTargetDependencies(pkg) {
   const devDependencies = pkg.devDependencies || {};
   const peerDependencies = pkg.peerDependencies || {};
   const optionalDependencies = pkg.optionalDependencies || {};
-  for (const dep of Object.keys(dependencies)) {
-    const version = dependencies[dep];
-    if (!version) {
-      continue;
-    }
+  const addDependency = (dep, version, location) => {
+    if (!version) return;
+    if (isNonSemverSpecifier(version)) return;
     if (!map[dep]) {
       map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
     }
     map[dep].versionSpec = version;
-    map[dep].locations.add("dependencies");
+    map[dep].locations.add(location);
+  };
+  for (const dep of Object.keys(dependencies)) {
+    const version = dependencies[dep];
+    if (version) {
+      addDependency(dep, version, "dependencies");
+    }
   }
   for (const dep of Object.keys(devDependencies)) {
     const version = devDependencies[dep];
-    if (!version) {
-      continue;
-    }
-    if (!map[dep]) {
-      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    if (version) {
+      addDependency(dep, version, "devDependencies");
     }
-    map[dep].versionSpec = version;
-    map[dep].locations.add("devDependencies");
   }
   for (const dep of Object.keys(peerDependencies)) {
     const version = peerDependencies[dep];
-    if (!version) {
-      continue;
-    }
-    if (!map[dep]) {
-      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    if (version) {
+      addDependency(dep, version, "peerDependencies");
     }
-    map[dep].versionSpec = version;
-    map[dep].locations.add("peerDependencies");
   }
   for (const dep of Object.keys(optionalDependencies)) {
     const version = optionalDependencies[dep];
-    if (!version) {
-      continue;
-    }
-    if (!map[dep]) {
-      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    if (version) {
+      addDependency(dep, version, "optionalDependencies");
     }
-    map[dep].versionSpec = version;
-    map[dep].locations.add("optionalDependencies");
   }
   const workspacesCatalog = pkg.workspaces?.catalog || {};
   for (const dep of Object.keys(workspacesCatalog)) {
     const version = workspacesCatalog[dep];
-    if (!version) {
-      continue;
+    if (version) {
+      addDependency(dep, version, "catalog");
     }
-    if (!map[dep]) {
-      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-    }
-    map[dep].versionSpec = version;
-    map[dep].locations.add("catalog");
   }
   const workspacesCatalogs = pkg.workspaces?.catalogs || {};
   for (const catalogName of Object.keys(workspacesCatalogs)) {
     const catalog = workspacesCatalogs[catalogName] || {};
     for (const dep of Object.keys(catalog)) {
       const version = catalog[dep];
-      if (!version) {
-        continue;
+      if (version) {
+        addDependency(dep, version, `catalogs.${catalogName}`);
       }
-      if (!map[dep]) {
-        map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-      }
-      map[dep].versionSpec = version;
-      map[dep].locations.add(`catalogs.${catalogName}`);
     }
   }
   const topLevelCatalog = pkg.catalog || {};
@@ -206,26 +218,51 @@ export function applyVersionUpdate(pkg, depName, newVersion, locations) {
   }
 }
 export async function fetchVersionFromRegistry(packageName) {
-  const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+  const normalizedName = packageName.toLowerCase();
+  const response = await fetch(`https://registry.npmjs.org/${normalizedName}/latest`, {
+    headers: {
+      // Use npm install headers for better compatibility and potentially faster responses
+      accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+    }
+  });
   if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    if (response.status === 404) {
+      throw new Error(`Package '${packageName}' not found in npm registry`);
+    }
+    throw new Error(
+      `Failed to fetch version for '${packageName}': HTTP ${response.status} ${response.statusText}`
+    );
   }
   const data = await response.json();
+  if (!data.version) {
+    throw new Error(`No version found for package '${packageName}'`);
+  }
   return data.version;
 }
 export async function getLatestVersion(packageName) {
+  const cached = versionCache.get(packageName);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.version;
+  }
   try {
-    return await fetchVersionFromRegistry(packageName);
+    const version = await fetchVersionFromRegistry(packageName);
+    versionCache.set(packageName, { version, timestamp: Date.now() });
+    savePersistentCache().catch(() => {
+    });
+    return version;
   } catch (error) {
     throw new Error(`Failed to get latest version for ${packageName}: ${error}`);
   }
 }
+export async function initializeCache(verbose = false) {
+  await loadPersistentCache(verbose);
+}
 export async function checkPackageUpdate(packageName, versionSpec, locations, options) {
   try {
     const latest = await getLatestVersion(packageName);
-    const cleanCurrent = versionSpec.replace(/^[\^~]/, "");
+    const cleanCurrent = versionSpec.replace(/^[\^~>=<]+/, "");
     let isCompatible = isSemverCompatible(versionSpec, latest);
-    const isExact = !(versionSpec.startsWith("^") || versionSpec.startsWith("~"));
+    const isExact = !(versionSpec.startsWith("^") || versionSpec.startsWith("~") || versionSpec.startsWith(">=") || versionSpec.startsWith(">") || versionSpec.startsWith("<=") || versionSpec.startsWith("<") || versionSpec.startsWith("="));
     if (isExact || !isCompatible && options.allowMajor) {
       isCompatible = true;
     }
@@ -249,6 +286,60 @@ export async function checkPackageUpdate(packageName, versionSpec, locations, op
     };
   }
 }
+export function prepareDependenciesForUpdateFromMap(allDepsMap, args) {
+  const depsToUpdate = Array.from(allDepsMap.keys());
+  let filteredDeps = [];
+  if (args.name && args.name.length > 0) {
+    const namePatterns = args.name;
+    filteredDeps = depsToUpdate.filter((dep) => {
+      return namePatterns.some((pattern) => {
+        if (pattern.includes("*") || pattern.includes("?") || pattern.includes("[") || pattern.includes("{")) {
+          return zeptomatch.isMatch(pattern, dep);
+        }
+        return dep === pattern;
+      });
+    });
+    const exactMatches = filteredDeps.filter((dep) => namePatterns.includes(dep));
+    const patternMatches = filteredDeps.length - exactMatches.length;
+    if (patternMatches > 0) {
+      logger.debug(
+        `Found ${exactMatches.length} exact matches and ${patternMatches} pattern matches`
+      );
+    }
+    if (filteredDeps.length === 0) {
+      logger.warn(`No dependencies found matching patterns: ${namePatterns.join(", ")}`);
+    }
+  } else {
+    const ignoreList = args.ignore || [];
+    filteredDeps = depsToUpdate.filter((dep) => {
+      return !ignoreList.some((ignorePattern) => {
+        if (ignorePattern.includes("*") || ignorePattern.includes("?") || ignorePattern.includes("[") || ignorePattern.includes("{")) {
+          return zeptomatch.isMatch(ignorePattern, dep);
+        }
+        return dep === ignorePattern;
+      });
+    });
+    const ignoredCount = depsToUpdate.length - filteredDeps.length;
+    if (ignoredCount > 0 && ignoreList.length > 0) {
+      logger.debug(`Ignored ${ignoredCount} dependencies matching ignore patterns`);
+    }
+  }
+  const ignoreFields = args.ignoreFields || [];
+  if (ignoreFields.length > 0) {
+    filteredDeps = filteredDeps.filter((dep) => {
+      const depInfo = allDepsMap.get(dep);
+      if (!depInfo) return false;
+      return !Array.from(depInfo.locations).some((location) => ignoreFields.includes(location));
+    });
+    const ignoredFieldsCount = depsToUpdate.length - filteredDeps.length;
+    if (ignoredFieldsCount > 0) {
+      logger.debug(
+        `Ignored ${ignoredFieldsCount} dependencies in ignored fields: ${ignoreFields.join(", ")}`
+      );
+    }
+  }
+  return filteredDeps;
+}
 export function prepareDependenciesForUpdate(allDepsMap, args) {
   const depsToUpdate = Object.keys(allDepsMap);
   let filteredDeps = [];
@@ -369,13 +460,6 @@ export function displayStructuredUpdateResults(results, packageJsonFiles, fileDe
     logger.log("");
   }
   if (!showDetails) {
-    if (toUpdate.length === 0) {
-      logger.log(`All ${upToDate.length} dependencies are already up to date`);
-    } else {
-      logger.log(
-        `${toUpdate.length} dependencies can be updated across ${packageJsonFiles.length} package.json files`
-      );
-    }
     return;
   }
   const resultsByFile = /* @__PURE__ */ new Map();
@@ -460,13 +544,17 @@ export function displayStructuredUpdateResults(results, packageJsonFiles, fileDe
     );
   }
 }
-export async function runInstallCommand() {
+export async function runInstallCommand(verbose = false) {
   try {
-    await $`bun install`.quiet();
+    const cmd = $`bun install`;
+    await cmd;
   } catch (error) {
-    logger.warn(
-      `Failed to run install command: ${error instanceof Error ? error.message : String(error)}`
-    );
+    logger.warn("Failed to run install command:");
+    if (error instanceof Error) {
+      logger.warn(error.message);
+    } else {
+      logger.warn(String(error));
+    }
     throw error;
   }
 }

package/dist/utils/cache.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Get the cache file path for a specific command
+ */
+export declare function getCacheFilePath(commandName: string): string;
+/**
+ * Ensure the cache directory exists
+ */
+export declare function ensureCacheDir(): Promise<void>;
+/**
+ * Load JSON data from cache file
+ */
+export declare function loadCache<T>(commandName: string): Promise<T | null>;
+/**
+ * Save JSON data to cache file
+ */
+export declare function saveCache<T>(commandName: string, data: T): Promise<void>;
+/**
+ * Check if cache file exists and get its modification time
+ */
+export declare function getCacheFileInfo(commandName: string): {
+    exists: boolean;
+    mtime?: number;
+};
+/**
+ * Clear cache for a specific command
+ */
+export declare function clearCommandCache(commandName: string): Promise<void>;
+/**
+ * Clear all dler caches
+ */
+export declare function clearAllCaches(): Promise<void>;

package/dist/utils/cache.js

@@ -0,0 +1,60 @@
+import { existsSync, statSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const CACHE_BASE_DIR = "node_modules/.cache/dler";
+export function getCacheFilePath(commandName) {
+  return join(CACHE_BASE_DIR, `${commandName}.json`);
+}
+export async function ensureCacheDir() {
+  try {
+    await mkdir(CACHE_BASE_DIR, { recursive: true });
+  } catch {
+  }
+}
+export async function loadCache(commandName) {
+  const cachePath = getCacheFilePath(commandName);
+  try {
+    if (!existsSync(cachePath)) {
+      return null;
+    }
+    const content = await readFile(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+export async function saveCache(commandName, data) {
+  const cachePath = getCacheFilePath(commandName);
+  try {
+    await ensureCacheDir();
+    await writeFile(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch {
+  }
+}
+export function getCacheFileInfo(commandName) {
+  const cachePath = getCacheFilePath(commandName);
+  if (!existsSync(cachePath)) {
+    return { exists: false };
+  }
+  try {
+    const stats = statSync(cachePath);
+    return { exists: true, mtime: stats.mtime.getTime() };
+  } catch {
+    return { exists: false };
+  }
+}
+export async function clearCommandCache(commandName) {
+  const cachePath = getCacheFilePath(commandName);
+  try {
+    if (existsSync(cachePath)) {
+      await writeFile(cachePath, "{}", "utf-8");
+    }
+  } catch {
+  }
+}
+export async function clearAllCaches() {
+  try {
+    await ensureCacheDir();
+  } catch {
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reliverse/dler",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "@reliverse/dler is a framework which helps TypeScript and JavaScript developers create their libraries and CLI tools. It provides ready-to-use primitives, so you don't have to write them from scratch.",
   "keywords": [
     "build-tool",
@@ -31,7 +31,7 @@
   ],
   "type": "module",
   "module": "./dist/mod.js",
-  "types": "./dist/mod.d.ts",
+  "types": "./dist/mod.d.d.d.ts",
   "exports": {
     ".": {
       "types": "./dist/mod.d.ts",
@@ -39,26 +39,27 @@
     }
   },
   "dependencies": {
-    "@reliverse/build": "2.3.2",
-    "@reliverse/bump": "2.3.2",
-    "@reliverse/config": "2.3.2",
-    "@reliverse/datetime": "2.3.2",
-    "@reliverse/helpers": "2.3.2",
-    "@reliverse/mapkit": "2.3.2",
-    "@reliverse/matcha": "2.3.2",
-    "@reliverse/pathkit": "2.3.2",
-    "@reliverse/publish": "2.3.2",
-    "@reliverse/relico": "2.3.2",
-    "@reliverse/relifso": "2.3.2",
-    "@reliverse/relinka": "2.3.2",
-    "@reliverse/rempts-core": "2.3.2",
-    "@reliverse/rempts-utils": "2.3.2",
-    "@reliverse/typerso": "2.3.2",
+    "@reliverse/build": "2.3.4",
+    "@reliverse/bump": "2.3.4",
+    "@reliverse/config": "2.3.4",
+    "@reliverse/datetime": "2.3.4",
+    "@reliverse/helpers": "2.3.4",
+    "@reliverse/mapkit": "2.3.4",
+    "@reliverse/matcha": "2.3.4",
+    "@reliverse/pathkit": "2.3.4",
+    "@reliverse/publish": "2.3.4",
+    "@reliverse/relico": "2.3.4",
+    "@reliverse/relifso": "2.3.4",
+    "@reliverse/relinka": "2.3.4",
+    "@reliverse/rempts-core": "2.3.4",
+    "@reliverse/rempts-utils": "2.3.4",
+    "@reliverse/typerso": "2.3.4",
     "c12": "^3.3.3",
     "clipboardy": "^5.0.2",
     "lookpath": "^1.2.3",
     "semver": "^7.7.3",
-    "arktype": "^2.1.29"
+    "arktype": "^2.1.29",
+    "lodash": "^4.17.21"
   },
   "publishConfig": {
     "access": "public"