@nu-art/ts-common 0.401.4 → 0.401.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/ts-common",
-  "version": "0.401.4",
+  "version": "0.401.6",
   "description": "Core TypeScript infrastructure library for building modular applications with lifecycle management, logging, validation, and utilities",
   "type": "module",
   "keywords": [
@@ -37,8 +37,8 @@
     "run-tests": "ts-mocha --timeout 50000 -p src/test/tsconfig.json src/test/run-all-tests.ts"
   },
   "dependencies": {
-    "@nu-art/testalot": "0.401.4",
-    "@nu-art/logger": "0.401.4",
+    "@nu-art/testalot": "0.401.6",
+    "@nu-art/logger": "0.401.6",
     "fast-csv": "^5.0.2",
     "export-to-csv": "0.2.1",
     "moment": "^2.29.4",

package/utils/version-tools.d.ts

@@ -1,26 +1,34 @@
 /**
  * Compares two semantic version strings.
  *
- * Extracts the major.minor.patch pattern from each version string and compares
- * them numerically. Only the first matching pattern is used (e.g., "1.2.3-beta"
- * becomes "1.2.3").
+ * Normalizes version strings by replacing non-numeric characters with dots,
+ * then compares them numerically segment by segment. Supports versions with
+ * any number of segments (e.g., "1.0.0", "1.0.0--rc.17", "1.2.3.4.5").
+ *
+ * **Normalization process**:
+ * - Replaces all non-numeric characters (letters, dashes, etc.) with dots
+ * - Collapses multiple consecutive dots into a single dot
+ * - Extracts numeric segments for comparison
  *
  * **Comparison logic**:
- * - Compares major, then minor, then patch numbers
+ * - Compares segments from left to right numerically
+ * - If all segments are equal up to the minimum length, the version with more segments is considered greater
  * - Returns -1 if first version is greater
  * - Returns 0 if versions are equal
  * - Returns 1 if second version is greater
  *
- * @param firstVersion - First version string (must contain X.Y.Z pattern)
- * @param secondVersion - Second version string (must contain X.Y.Z pattern)
+ * @param firstVersion - First version string (must contain at least one numeric segment)
+ * @param secondVersion - Second version string (must contain at least one numeric segment)
  * @returns Comparison result: -1, 0, or 1
- * @throws BadImplementationException if versions are undefined or don't contain X.Y.Z pattern
+ * @throws BadImplementationException if versions are undefined or don't contain numeric segments
  *
  * @example
  * ```typescript
  * compareVersions('1.2.3', '1.2.4') // Returns 1 (second is greater)
  * compareVersions('2.0.0', '1.9.9') // Returns -1 (first is greater)
  * compareVersions('1.0.0', '1.0.0') // Returns 0 (equal)
+ * compareVersions('1.0.0--rc.17', '1.0.0--rc.18') // Returns 1 (second is greater)
+ * compareVersions('1.0.0', '1.0.0.1') // Returns 1 (second has more segments)
  * ```
  */
 export declare function compareVersions(firstVersion: string, secondVersion: string): 0 | 1 | -1;

package/utils/version-tools.js

@@ -18,29 +18,64 @@
 import { BadImplementationException } from '../core/exceptions/exceptions.js';
 import { tsValidateResult } from '../validator/validator-core.js';
 import { tsValidateVersion } from '../validator/validators.js';
+/**
+ * Normalizes a version string by converting non-numeric characters to dots,
+ * collapsing multiple consecutive dots, and extracting numeric segments.
+ *
+ * @param version - Version string to normalize
+ * @returns Array of numeric segments
+ * @throws BadImplementationException if version contains no numeric segments
+ *
+ * @example
+ * ```typescript
+ * normalizeVersion('1.0.0--rc.17') // Returns [1, 0, 0, 17]
+ * normalizeVersion('2.3.4-suffix') // Returns [2, 3, 4]
+ * normalizeVersion('1.2.3.4.5') // Returns [1, 2, 3, 4, 5]
+ * ```
+ */
+function normalizeVersion(version) {
+    // Replace all non-numeric characters with dots
+    let normalized = version.replace(/[^\d]/g, '.');
+    // Replace multiple consecutive dots with single dot
+    normalized = normalized.replace(/\.+/g, '.');
+    // Trim leading/trailing dots
+    normalized = normalized.replace(/^\.+|\.+$/g, '');
+    if (!normalized)
+        throw new BadImplementationException(`Unable to extract calculable version from '${version}' - no numeric segments found`);
+    // Split and convert to numbers
+    return normalized.split('.').map(Number);
+}
 /**
  * Compares two semantic version strings.
  *
- * Extracts the major.minor.patch pattern from each version string and compares
- * them numerically. Only the first matching pattern is used (e.g., "1.2.3-beta"
- * becomes "1.2.3").
+ * Normalizes version strings by replacing non-numeric characters with dots,
+ * then compares them numerically segment by segment. Supports versions with
+ * any number of segments (e.g., "1.0.0", "1.0.0--rc.17", "1.2.3.4.5").
+ *
+ * **Normalization process**:
+ * - Replaces all non-numeric characters (letters, dashes, etc.) with dots
+ * - Collapses multiple consecutive dots into a single dot
+ * - Extracts numeric segments for comparison
  *
  * **Comparison logic**:
- * - Compares major, then minor, then patch numbers
+ * - Compares segments from left to right numerically
+ * - If all segments are equal up to the minimum length, the version with more segments is considered greater
  * - Returns -1 if first version is greater
  * - Returns 0 if versions are equal
  * - Returns 1 if second version is greater
  *
- * @param firstVersion - First version string (must contain X.Y.Z pattern)
- * @param secondVersion - Second version string (must contain X.Y.Z pattern)
+ * @param firstVersion - First version string (must contain at least one numeric segment)
+ * @param secondVersion - Second version string (must contain at least one numeric segment)
  * @returns Comparison result: -1, 0, or 1
- * @throws BadImplementationException if versions are undefined or don't contain X.Y.Z pattern
+ * @throws BadImplementationException if versions are undefined or don't contain numeric segments
  *
  * @example
  * ```typescript
  * compareVersions('1.2.3', '1.2.4') // Returns 1 (second is greater)
  * compareVersions('2.0.0', '1.9.9') // Returns -1 (first is greater)
  * compareVersions('1.0.0', '1.0.0') // Returns 0 (equal)
+ * compareVersions('1.0.0--rc.17', '1.0.0--rc.18') // Returns 1 (second is greater)
+ * compareVersions('1.0.0', '1.0.0.1') // Returns 1 (second has more segments)
  * ```
  */
 export function compareVersions(firstVersion, secondVersion) {
@@ -48,26 +83,23 @@ export function compareVersions(firstVersion, secondVersion) {
         throw new BadImplementationException('First version is undefined');
     if (!secondVersion)
         throw new BadImplementationException('Second version is undefined');
-    const extractedFirstVersion = firstVersion.match(/\d+\.\d+\.\d+/)?.[0];
-    if (!extractedFirstVersion)
-        throw new BadImplementationException(`Unable to extract calculable version from '${firstVersion}'`);
-    firstVersion = extractedFirstVersion;
-    const extractedSecondVersion = secondVersion.match(/\d+\.\d+\.\d+/)?.[0];
-    if (!extractedSecondVersion)
-        throw new BadImplementationException(`Unable to extract calculable version from '${secondVersion}'`);
-    secondVersion = extractedSecondVersion;
-    const firstVersionAsArray = firstVersion.split('\.');
-    const secondVersionAsArray = secondVersion.split('\.');
-    for (let i = 0; i < firstVersionAsArray.length; i++) {
-        const secondVal = +secondVersionAsArray[i];
-        const firstVal = +firstVersionAsArray[i];
+    const firstVersionAsArray = normalizeVersion(firstVersion);
+    const secondVersionAsArray = normalizeVersion(secondVersion);
+    const minLength = Math.min(firstVersionAsArray.length, secondVersionAsArray.length);
+    // Compare segments up to the minimum length
+    for (let i = 0; i < minLength; i++) {
+        const firstVal = firstVersionAsArray[i];
+        const secondVal = secondVersionAsArray[i];
         if (secondVal > firstVal)
             return 1;
-        if (secondVal === firstVal)
-            continue;
         if (secondVal < firstVal)
             return -1;
     }
+    // If all segments are equal up to minimum length, compare by length
+    if (firstVersionAsArray.length > secondVersionAsArray.length)
+        return -1;
+    if (firstVersionAsArray.length < secondVersionAsArray.length)
+        return 1;
     return 0;
 }
 /**