@reliverse/dler 2.3.3 → 2.3.4

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.3",
+  "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.d.ts",
+  "types": "./dist/mod.d.d.d.ts",
   "exports": {
     ".": {
       "types": "./dist/mod.d.ts",
@@ -39,26 +39,27 @@
     }
   },
   "dependencies": {
-    "@reliverse/build": "2.3.3",
-    "@reliverse/bump": "2.3.3",
-    "@reliverse/config": "2.3.3",
-    "@reliverse/datetime": "2.3.3",
-    "@reliverse/helpers": "2.3.3",
-    "@reliverse/mapkit": "2.3.3",
-    "@reliverse/matcha": "2.3.3",
-    "@reliverse/pathkit": "2.3.3",
-    "@reliverse/publish": "2.3.3",
-    "@reliverse/relico": "2.3.3",
-    "@reliverse/relifso": "2.3.3",
-    "@reliverse/relinka": "2.3.3",
-    "@reliverse/rempts-core": "2.3.3",
-    "@reliverse/rempts-utils": "2.3.3",
-    "@reliverse/typerso": "2.3.3",
+    "@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"