@helpers4/version 2.0.0-alpha.1 → 2.0.0-alpha.3

package/README.md

@@ -12,8 +12,8 @@ A set of helpers for working with URLs.
 [https://helpers4.js.org/version](https://helpers4.js.org/version)
 
 <!-- AUTOMATIC-METHODS -->
-- compare
 - stripV
+- compare
 - satisfiesRange
 - increment
 <!-- /AUTOMATIC-METHODS -->

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-export * from './compare';
-export * from './stripV';
-export * from './satisfiesRange';
-export * from './increment';
+export declare function stripV(version: string): string; export function stripV(version: null): null; export function stripV(version: undefined): undefined; export function stripV(version: string | null | undefined): string | null | undefined;
+export declare function compare(version1: string, version2: string): number;
+export declare function satisfiesRange(version: string, range: string): boolean;
+export declare function increment(version: string, type: 'major' | 'minor' | 'patch'): string;

package/lib/index.js

@@ -1,5 +1,108 @@
-// helpers/version/index.ts
-export * from "./compare";
-export * from "./stripV";
-export * from "./satisfiesRange";
-export * from "./increment";
+// helpers/version/stripV.ts
+function stripV(version) {
+  return typeof version === "string" && version.startsWith("v") ? version.slice(1) : version;
+}
+// helpers/version/compare.ts
+function compare(version1, version2) {
+  const normalize = (v) => v.replace(/^v/, "");
+  const v1 = normalize(version1);
+  const v2 = normalize(version2);
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  const maxLength = Math.max(parts1.length, parts2.length);
+  for (let i = 0;i < maxLength; i++) {
+    const part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+    if (part1 < part2)
+      return -1;
+    if (part1 > part2)
+      return 1;
+  }
+  return 0;
+}
+// helpers/version/satisfiesRange.ts
+function satisfiesRange(version, range) {
+  const normalize = (v) => v.replace(/^v/, "");
+  const normalizedVersion = normalize(version);
+  if (!range.match(/[~^<>=]/)) {
+    return normalizedVersion === normalize(range);
+  }
+  if (range.startsWith(">=")) {
+    const targetVersion = normalize(range.slice(2));
+    return compareVersionsSimple(normalizedVersion, targetVersion) >= 0;
+  }
+  if (range.startsWith(">")) {
+    const targetVersion = normalize(range.slice(1));
+    return compareVersionsSimple(normalizedVersion, targetVersion) > 0;
+  }
+  if (range.startsWith("<=")) {
+    const targetVersion = normalize(range.slice(2));
+    return compareVersionsSimple(normalizedVersion, targetVersion) <= 0;
+  }
+  if (range.startsWith("<")) {
+    const targetVersion = normalize(range.slice(1));
+    return compareVersionsSimple(normalizedVersion, targetVersion) < 0;
+  }
+  if (range.startsWith("^")) {
+    const targetVersion = normalize(range.slice(1));
+    const [targetMajor] = targetVersion.split(".").map(Number);
+    const [versionMajor] = normalizedVersion.split(".").map(Number);
+    return versionMajor === targetMajor && compareVersionsSimple(normalizedVersion, targetVersion) >= 0;
+  }
+  if (range.startsWith("~")) {
+    const targetVersion = normalize(range.slice(1));
+    const [targetMajor, targetMinor] = targetVersion.split(".").map(Number);
+    const [versionMajor, versionMinor] = normalizedVersion.split(".").map(Number);
+    return versionMajor === targetMajor && versionMinor === targetMinor && compareVersionsSimple(normalizedVersion, targetVersion) >= 0;
+  }
+  return false;
+}
+function compareVersionsSimple(version1, version2) {
+  const parts1 = version1.split(".").map(Number);
+  const parts2 = version2.split(".").map(Number);
+  const maxLength = Math.max(parts1.length, parts2.length);
+  for (let i = 0;i < maxLength; i++) {
+    const part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+    if (part1 < part2)
+      return -1;
+    if (part1 > part2)
+      return 1;
+  }
+  return 0;
+}
+// helpers/version/increment.ts
+function increment(version, type) {
+  const normalize = (v) => v.replace(/^v/, "");
+  const hasV = version.startsWith("v");
+  const normalizedVersion = normalize(version);
+  const parts = normalizedVersion.split(".").map(Number);
+  while (parts.length < 3) {
+    parts.push(0);
+  }
+  let [major, minor, patch] = parts;
+  switch (type) {
+    case "major":
+      major++;
+      minor = 0;
+      patch = 0;
+      break;
+    case "minor":
+      minor++;
+      patch = 0;
+      break;
+    case "patch":
+      patch++;
+      break;
+    default:
+      throw new Error(`Invalid increment type: ${type}`);
+  }
+  const result = `${major}.${minor}.${patch}`;
+  return hasV ? `v${result}` : result;
+}
+export {
+  stripV,
+  satisfiesRange,
+  increment,
+  compare
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helpers4/version",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "description": "A set of helpers in TS/JS, compatible with tree-shaking, for version.",
   "author": "baxyz <baxy@etik.com>",
   "license": "AGPL-3.0",
@@ -20,8 +20,8 @@
   "keywords": [
     "helpers",
     "version",
-    "compare",
     "stripV",
+    "compare",
     "satisfiesRange",
     "increment"
   ],