@reliverse/dler 2.2.17 → 2.3.1

package/dist/cmds/update/utils.js

@@ -24,7 +24,7 @@ export function isSemverCompatible(currentVersionRange, latestVersion) {
     if (isWorkspaceDependency(currentVersionRange)) {
       return false;
     }
-    if (!currentVersionRange.startsWith("^") && !currentVersionRange.startsWith("~")) {
+    if (!(currentVersionRange.startsWith("^") || currentVersionRange.startsWith("~"))) {
       return false;
     }
     return semver.satisfies(latestVersion, currentVersionRange);
@@ -40,37 +40,57 @@ export function collectTargetDependencies(pkg) {
   const optionalDependencies = pkg.optionalDependencies || {};
   for (const dep of Object.keys(dependencies)) {
     const version = dependencies[dep];
-    if (!version) continue;
-    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    if (!version) {
+      continue;
+    }
+    if (!map[dep]) {
+      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    }
     map[dep].versionSpec = version;
     map[dep].locations.add("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) {
+      continue;
+    }
+    if (!map[dep]) {
+      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    }
     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) {
+      continue;
+    }
+    if (!map[dep]) {
+      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    }
     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) {
+      continue;
+    }
+    if (!map[dep]) {
+      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    }
     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 (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    if (!version) {
+      continue;
+    }
+    if (!map[dep]) {
+      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    }
     map[dep].versionSpec = version;
     map[dep].locations.add("catalog");
   }
@@ -79,8 +99,12 @@ export function collectTargetDependencies(pkg) {
     const catalog = workspacesCatalogs[catalogName] || {};
     for (const dep of Object.keys(catalog)) {
       const version = catalog[dep];
-      if (!version) continue;
-      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      if (!version) {
+        continue;
+      }
+      if (!map[dep]) {
+        map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      }
       map[dep].versionSpec = version;
       map[dep].locations.add(`catalogs.${catalogName}`);
     }
@@ -88,8 +112,12 @@ export function collectTargetDependencies(pkg) {
   const topLevelCatalog = pkg.catalog || {};
   for (const dep of Object.keys(topLevelCatalog)) {
     const version = topLevelCatalog[dep];
-    if (!version) continue;
-    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    if (!version) {
+      continue;
+    }
+    if (!map[dep]) {
+      map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+    }
     map[dep].versionSpec = version;
     map[dep].locations.add("catalog");
   }
@@ -98,8 +126,12 @@ export function collectTargetDependencies(pkg) {
     const catalog = topLevelCatalogs[catalogName] || {};
     for (const dep of Object.keys(catalog)) {
       const version = catalog[dep];
-      if (!version) continue;
-      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      if (!version) {
+        continue;
+      }
+      if (!map[dep]) {
+        map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
+      }
       map[dep].versionSpec = version;
       map[dep].locations.add(`catalogs.${catalogName}`);
     }
@@ -108,44 +140,63 @@ export function collectTargetDependencies(pkg) {
 }
 export function applyVersionUpdate(pkg, depName, newVersion, locations) {
   if (locations.has("dependencies")) {
-    if (!pkg.dependencies) pkg.dependencies = {};
+    if (!pkg.dependencies) {
+      pkg.dependencies = {};
+    }
     pkg.dependencies[depName] = newVersion;
   }
   if (locations.has("devDependencies")) {
-    if (!pkg.devDependencies) pkg.devDependencies = {};
+    if (!pkg.devDependencies) {
+      pkg.devDependencies = {};
+    }
     pkg.devDependencies[depName] = newVersion;
   }
   if (locations.has("peerDependencies")) {
-    if (!pkg.peerDependencies) pkg.peerDependencies = {};
+    if (!pkg.peerDependencies) {
+      pkg.peerDependencies = {};
+    }
     pkg.peerDependencies[depName] = newVersion;
   }
   if (locations.has("optionalDependencies")) {
-    if (!pkg.optionalDependencies) pkg.optionalDependencies = {};
+    if (!pkg.optionalDependencies) {
+      pkg.optionalDependencies = {};
+    }
     pkg.optionalDependencies[depName] = newVersion;
   }
   const ensureWorkspaces = () => {
-    if (!pkg.workspaces) pkg.workspaces = {};
+    if (!pkg.workspaces) {
+      pkg.workspaces = {};
+    }
   };
   if (locations.has("catalog")) {
     ensureWorkspaces();
     const workspaces = pkg.workspaces;
     if (workspaces) {
-      if (!workspaces.catalog) workspaces.catalog = {};
+      if (!workspaces.catalog) {
+        workspaces.catalog = {};
+      }
       workspaces.catalog[depName] = newVersion;
     }
-    if (pkg.catalog) pkg.catalog[depName] = newVersion;
+    if (pkg.catalog) {
+      pkg.catalog[depName] = newVersion;
+    }
   }
   for (const loc of locations) {
     const match = /^catalogs\.(.+)$/.exec(loc);
     if (match) {
       const catalogName = match[1] ?? "";
-      if (!catalogName) continue;
+      if (!catalogName) {
+        continue;
+      }
       ensureWorkspaces();
       const workspaces = pkg.workspaces;
       if (workspaces) {
-        if (!workspaces.catalogs) workspaces.catalogs = {};
-        if (!workspaces.catalogs[catalogName])
+        if (!workspaces.catalogs) {
+          workspaces.catalogs = {};
+        }
+        if (!workspaces.catalogs[catalogName]) {
           workspaces.catalogs[catalogName] = {};
+        }
         workspaces.catalogs[catalogName][depName] = newVersion;
       }
       if (pkg.catalogs?.[catalogName]) {
@@ -155,9 +206,7 @@ export function applyVersionUpdate(pkg, depName, newVersion, locations) {
   }
 }
 export async function fetchVersionFromRegistry(packageName) {
-  const response = await fetch(
-    `https://registry.npmjs.org/${packageName}/latest`
-  );
+  const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
   if (!response.ok) {
     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
   }
@@ -168,9 +217,7 @@ export async function getLatestVersion(packageName) {
   try {
     return await fetchVersionFromRegistry(packageName);
   } catch (error) {
-    throw new Error(
-      `Failed to get latest version for ${packageName}: ${error}`
-    );
+    throw new Error(`Failed to get latest version for ${packageName}: ${error}`);
   }
 }
 export async function checkPackageUpdate(packageName, versionSpec, locations, options) {
@@ -178,7 +225,7 @@ export async function checkPackageUpdate(packageName, versionSpec, locations, op
     const latest = await getLatestVersion(packageName);
     const cleanCurrent = versionSpec.replace(/^[\^~]/, "");
     let isCompatible = isSemverCompatible(versionSpec, latest);
-    const isExact = !versionSpec.startsWith("^") && !versionSpec.startsWith("~");
+    const isExact = !(versionSpec.startsWith("^") || versionSpec.startsWith("~"));
     if (isExact || !isCompatible && options.allowMajor) {
       isCompatible = true;
     }
@@ -215,9 +262,7 @@ export function prepareDependenciesForUpdate(allDepsMap, args) {
         return dep === pattern;
       });
     });
-    const exactMatches = filteredDeps.filter(
-      (dep) => namePatterns.includes(dep)
-    );
+    const exactMatches = filteredDeps.filter((dep) => namePatterns.includes(dep));
     const patternMatches = filteredDeps.length - exactMatches.length;
     if (patternMatches > 0) {
       logger.debug(
@@ -225,9 +270,7 @@ export function prepareDependenciesForUpdate(allDepsMap, args) {
       );
     }
     if (filteredDeps.length === 0) {
-      logger.warn(
-        `No dependencies found matching patterns: ${namePatterns.join(", ")}`
-      );
+      logger.warn(`No dependencies found matching patterns: ${namePatterns.join(", ")}`);
     }
   } else {
     const ignoreList = args.ignore || [];
@@ -241,18 +284,14 @@ export function prepareDependenciesForUpdate(allDepsMap, args) {
     });
     const ignoredCount = depsToUpdate.length - filteredDeps.length;
     if (ignoredCount > 0 && ignoreList.length > 0) {
-      logger.debug(
-        `Ignored ${ignoredCount} dependencies matching ignore patterns`
-      );
+      logger.debug(`Ignored ${ignoredCount} dependencies matching ignore patterns`);
     }
   }
   const ignoreFields = args.ignoreFields || [];
   if (ignoreFields.length > 0) {
     filteredDeps = filteredDeps.filter((dep) => {
       const locations = allDepsMap[dep]?.locations || /* @__PURE__ */ new Set();
-      return !Array.from(locations).some(
-        (location) => ignoreFields.includes(location)
-      );
+      return !Array.from(locations).some((location) => ignoreFields.includes(location));
     });
     const ignoredFieldsCount = depsToUpdate.length - filteredDeps.length;
     if (ignoredFieldsCount > 0) {
@@ -263,13 +302,19 @@ export function prepareDependenciesForUpdate(allDepsMap, args) {
   }
   return filteredDeps.filter((dep) => {
     const versionSpec = allDepsMap[dep]?.versionSpec ?? "";
-    if (!versionSpec) return false;
-    if (isNonSemverSpecifier(versionSpec)) return false;
+    if (!versionSpec) {
+      return false;
+    }
+    if (isNonSemverSpecifier(versionSpec)) {
+      return false;
+    }
     return true;
   });
 }
 export async function updatePackageJsonFile(packageJsonPath, dependencies, updatesToApply, savePrefix, fieldsToIgnore = []) {
-  if (updatesToApply.length === 0) return 0;
+  if (updatesToApply.length === 0) {
+    return 0;
+  }
   try {
     const packageJson = JSON.parse(
       await fs.readFile(packageJsonPath, { encoding: "utf8" })
@@ -277,7 +322,9 @@ export async function updatePackageJsonFile(packageJsonPath, dependencies, updat
     const updatedPackageJson = { ...packageJson };
     for (const update of updatesToApply) {
       const depInfo = dependencies[update.package];
-      if (!depInfo) continue;
+      if (!depInfo) {
+        continue;
+      }
       const locations = depInfo.locations || /* @__PURE__ */ new Set();
       const shouldIgnore = Array.from(locations).some(
         (location) => fieldsToIgnore.includes(location)
@@ -296,19 +343,12 @@ export async function updatePackageJsonFile(packageJsonPath, dependencies, updat
       } else {
         newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
       }
-      applyVersionUpdate(
-        updatedPackageJson,
-        update.package,
-        newVersion,
-        locations
-      );
+      applyVersionUpdate(updatedPackageJson, update.package, newVersion, locations);
     }
-    await fs.writeFile(
-      packageJsonPath,
-      `${JSON.stringify(updatedPackageJson, null, 2)}
-`,
-      { encoding: "utf8" }
-    );
+    await fs.writeFile(packageJsonPath, `${JSON.stringify(updatedPackageJson, null, 2)}
+`, {
+      encoding: "utf8"
+    });
     return updatesToApply.length;
   } catch (error) {
     logger.warn(
@@ -320,9 +360,7 @@ export async function updatePackageJsonFile(packageJsonPath, dependencies, updat
 export function displayStructuredUpdateResults(results, packageJsonFiles, fileDepsMap, showDetails = false) {
   const toUpdate = results.filter((r) => r.updated && !r.error);
   const errors = results.filter((r) => r.error);
-  const upToDate = results.filter(
-    (r) => !r.updated && !r.error && r.semverCompatible
-  );
+  const upToDate = results.filter((r) => !(r.updated || r.error) && r.semverCompatible);
   if (errors.length > 0) {
     logger.warn(`Failed to check ${errors.length} dependencies:`);
     for (const error of errors) {
@@ -368,29 +406,25 @@ export function displayStructuredUpdateResults(results, packageJsonFiles, fileDe
       }
       byCategory.get(category)?.push(result);
     }
-    const upToDateInFile = fileResults.filter(
-      (r) => !r.updated && !r.error && r.semverCompatible
-    );
+    const upToDateInFile = fileResults.filter((r) => !(r.updated || r.error) && r.semverCompatible);
     if (upToDateInFile.length > 0) {
       logger.log(`  * ${upToDateInFile.length} deps are already up to date`);
     }
     const toUpdateInFile = fileResults.filter((r) => r.updated && !r.error);
     if (toUpdateInFile.length > 0) {
       logger.log(`  * ${toUpdateInFile.length} deps can be updated:`);
-      const sortedCategories = Array.from(byCategory.entries()).sort(
-        ([a], [b]) => {
-          const order = {
-            catalog: 0,
-            dependencies: 1,
-            devDependencies: 2,
-            peerDependencies: 3,
-            optionalDependencies: 4
-          };
-          const aOrder = order[a] ?? 999;
-          const bOrder = order[b] ?? 999;
-          return aOrder - bOrder;
-        }
-      );
+      const sortedCategories = Array.from(byCategory.entries()).sort(([a], [b]) => {
+        const order = {
+          catalog: 0,
+          dependencies: 1,
+          devDependencies: 2,
+          peerDependencies: 3,
+          optionalDependencies: 4
+        };
+        const aOrder = order[a] ?? 999;
+        const bOrder = order[b] ?? 999;
+        return aOrder - bOrder;
+      });
       for (const [category, updates] of sortedCategories) {
         const categoryUpdates = updates.filter((r) => r.updated && !r.error);
         if (categoryUpdates.length > 0) {

package/dist/mod.d.ts

@@ -0,0 +1,3 @@
+export { defineConfig, type LoadedConfig, loadConfig, type RemptsConfig, } from "@reliverse/rempts-core";
+export { findEntry } from "./utils/find-entry.js";
+export declare const version = "0.1.0";

package/dist/mod.js

@@ -0,0 +1,6 @@
+export {
+  defineConfig,
+  loadConfig
+} from "@reliverse/rempts-core";
+export { findEntry } from "./utils/find-entry.js";
+export const version = "0.1.0";

package/dist/utils/find-entry.d.ts

@@ -0,0 +1 @@
+export declare function findEntry(cwd?: string): Promise<string | undefined>;

package/dist/utils/find-entry.js

@@ -0,0 +1,46 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+const COMMON_ENTRIES = [
+  "src/cli.ts",
+  "src/mod.ts",
+  "src/main.ts",
+  "cli.ts",
+  "mod.ts",
+  "index.ts",
+  "main.ts",
+  "src/cli.js",
+  "src/index.js",
+  "src/mod.js",
+  "src/main.js",
+  "cli.js",
+  "mod.js",
+  "index.js",
+  "main.js"
+];
+export async function findEntry(cwd = process.cwd()) {
+  for (const entry of COMMON_ENTRIES) {
+    const fullPath = path.join(cwd, entry);
+    if (existsSync(fullPath)) {
+      return entry;
+    }
+  }
+  const pkgPath = path.join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = await Bun.file(pkgPath).json();
+      if (pkg.bin) {
+        if (typeof pkg.bin === "string") {
+          return pkg.bin;
+        }
+        if (typeof pkg.bin === "object") {
+          const firstBin = Object.values(pkg.bin)[0];
+          if (typeof firstBin === "string") {
+            return firstBin;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}

package/package.json

@@ -1,42 +1,65 @@
 {
   "name": "@reliverse/dler",
+  "version": "2.3.1",
   "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.",
-  "author": "reliverse",
-  "version": "2.2.17",
-  "private": false,
-  "type": "module",
+  "keywords": [
+    "build-tool",
+    "bun",
+    "cli",
+    "development",
+    "rempts",
+    "toolchain",
+    "typescript"
+  ],
+  "homepage": "https://github.com/reliverse/dler#readme",
+  "bugs": {
+    "url": "https://github.com/reliverse/dler/issues"
+  },
+  "license": "MIT",
+  "author": "blefnk",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reliverse/dler.git",
+    "directory": "packages/cli"
+  },
   "bin": {
-    "dler": "dist/cli.js"
+    "dler": "./src/cli.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "module": "./src/mod.ts",
+  "types": "./src/mod.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "import": "./dist/mod.js"
+    }
   },
   "dependencies": {
+    "@reliverse/build": "2.3.1",
+    "@reliverse/bump": "2.3.1",
+    "@reliverse/config": "2.3.1",
+    "@reliverse/datetime": "2.3.1",
+    "@reliverse/helpers": "2.3.1",
+    "@reliverse/mapkit": "2.3.1",
+    "@reliverse/matcha": "2.3.1",
+    "@reliverse/pathkit": "2.3.1",
+    "@reliverse/publish": "2.3.1",
+    "@reliverse/relico": "2.3.1",
+    "@reliverse/relifso": "2.3.1",
+    "@reliverse/relinka": "2.3.1",
+    "@reliverse/rempts-core": "2.3.1",
+    "@reliverse/rempts-utils": "2.3.1",
+    "@reliverse/typerso": "2.3.1",
     "c12": "^3.3.3",
-    "semver": "^7.7.3",
-    "lookpath": "^1.2.3",
     "clipboardy": "^5.0.2",
-    "@reliverse/datetime": "2.2.9",
-    "@reliverse/config": "2.2.9",
-    "@reliverse/publish": "2.2.9",
-    "@reliverse/bump": "2.2.10",
-    "@reliverse/build": "2.2.9",
-    "@reliverse/relinka": "2.2.9",
-    "@reliverse/matcha": "2.2.9",
-    "@reliverse/rempts": "2.2.9",
-    "@reliverse/helpers": "2.2.13",
-    "@reliverse/typerso": "2.2.9",
-    "@reliverse/relifso": "2.2.10",
-    "@reliverse/mapkit": "2.2.9",
-    "@reliverse/pathkit": "2.2.13"
+    "lookpath": "^1.2.3",
+    "semver": "^7.7.3",
+    "arktype": "^2.1.29"
   },
-  "keywords": [
-    "dler",
-    "build"
-  ],
   "publishConfig": {
     "access": "public"
-  },
-  "files": [
-    "dist",
-    "package.json"
-  ],
-  "license": "MIT"
+  }
 }

package/src/cli.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+
+import { createApp } from "@reliverse/rempts-core";
+
+const cli = await createApp({
+  entryFile: import.meta.path,
+});
+
+await cli.run();

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Nazar Kornienko (blefnk), Bleverse, Reliverse
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.