@pipeline-builder/api-core 5.2.7 → 5.2.9

package/lib/utils/semver.js

@@ -0,0 +1,120 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The small slice of semver the platform needs without a dependency: ordering
+ * versions (SemVer 2.0 §11, prereleases included) and checking a version
+ * against an `engines`-style range. Shared by the CLI's `--upgrade` and the
+ * server's minimum-client-version gate so both order versions identically.
+ */
+const SEMVER = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parse(v) {
+    const m = SEMVER.exec(v.trim());
+    if (!m)
+        return null;
+    return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ? m[4].split('.') : [] };
+}
+/** True for a full `x.y.z[-pre][+build]` version (a leading `v` is allowed). */
+export function isSemver(v) {
+    return parse(v) !== null;
+}
+/**
+ * -1 / 0 / 1 ordering of two versions per SemVer §11: numeric x.y.z, a
+ * prerelease sorts before its release, and prerelease identifiers compare
+ * numerically when both are numeric (`rc.2` < `rc.10`), else as ASCII, with a
+ * numeric identifier below an alphanumeric one and a shorter set below a
+ * longer one that it prefixes. Throws on a value that isn't a version.
+ */
+export function compareSemver(a, b) {
+    const x = parse(a);
+    const y = parse(b);
+    if (!x || !y)
+        throw new Error(`Not a semver version: ${!x ? a : b}`);
+    for (let i = 0; i < 3; i++) {
+        if (x.nums[i] !== y.nums[i])
+            return x.nums[i] < y.nums[i] ? -1 : 1;
+    }
+    if (!x.pre.length || !y.pre.length) {
+        if (x.pre.length === y.pre.length)
+            return 0;
+        return x.pre.length ? -1 : 1;
+    }
+    for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+        const p = x.pre[i];
+        const q = y.pre[i];
+        if (p === undefined)
+            return -1;
+        if (q === undefined)
+            return 1;
+        if (p === q)
+            continue;
+        const pn = /^\d+$/.test(p);
+        const qn = /^\d+$/.test(q);
+        if (pn && qn)
+            return Number(p) < Number(q) ? -1 : 1;
+        if (pn !== qn)
+            return pn ? -1 : 1;
+        return p < q ? -1 : 1;
+    }
+    return 0;
+}
+/** A partial version (`26`, `26.13`) padded to x.y.z, or null. */
+function padded(v) {
+    const m = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(-[0-9A-Za-z.-]+)?$/.exec(v);
+    if (!m)
+        return null;
+    return `${m[1]}.${m[2] ?? 0}.${m[3] ?? 0}${m[4] ?? ''}`;
+}
+function satisfiesComparator(version, comparator) {
+    const m = /^(>=|<=|>|<|=|\^|~)?\s*(.+)$/.exec(comparator);
+    if (!m)
+        return null;
+    const op = m[1] ?? '=';
+    const base = padded(m[2]);
+    if (!base)
+        return null;
+    const c = compareSemver(version, base);
+    switch (op) {
+        case '>=': return c >= 0;
+        case '>': return c > 0;
+        case '<=': return c <= 0;
+        case '<': return c < 0;
+        case '=': return c === 0;
+        default: {
+            // ^ keeps the left-most non-zero part fixed; ~ keeps major.minor fixed.
+            const [maj, min] = base.split(/[.-]/).map(Number);
+            const upper = op === '~' ? `${maj}.${min + 1}.0` : maj > 0 ? `${maj + 1}.0.0` : `0.${min + 1}.0`;
+            return c >= 0 && compareSemver(version, `${upper}-0`) < 0;
+        }
+    }
+}
+/**
+ * Whether `version` satisfies an `engines`-style range: comparator sets joined
+ * by `||`, each a space-separated AND of `>=`, `>`, `<=`, `<`, `=`, `^`, `~` or
+ * bare versions (partials like `>= 26` allowed). `*` / empty match anything.
+ * Returns null when the range uses syntax outside that (hyphen ranges, `x`
+ * wildcards), so the caller can decide rather than guess.
+ */
+export function satisfiesRange(version, range) {
+    if (!isSemver(version))
+        return null;
+    const trimmed = range.trim();
+    if (trimmed === '' || trimmed === '*')
+        return true;
+    let any = false;
+    for (const set of trimmed.split('||')) {
+        // Join an operator to its version (`>= 26.13.0` → `>=26.13.0`), then split.
+        const comparators = set.trim().replace(/(>=|<=|>|<|=|\^|~)\s+/g, '$1').split(/\s+/).filter(Boolean);
+        let all = true;
+        for (const comparator of comparators) {
+            const ok = satisfiesComparator(version, comparator);
+            if (ok === null)
+                return null;
+            if (!ok)
+                all = false;
+        }
+        if (all)
+            any = true;
+    }
+    return any;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"semver.js","sources":["../../src/utils/semver.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The small slice of semver the platform needs without a dependency: ordering\n * versions (SemVer 2.0 §11, prereleases included) and checking a version\n * against an `engines`-style range. Shared by the CLI's `--upgrade` and the\n * server's minimum-client-version gate so both order versions identically.\n */\n\nconst SEMVER = /^v?(\\d+)\\.(\\d+)\\.(\\d+)(?:-([0-9A-Za-z.-]+))?(?:\\+[0-9A-Za-z.-]+)?$/;\n\ninterface Parsed { nums: [number, number, number]; pre: string[] }\n\nfunction parse(v: string): Parsed | null {\n  const m = SEMVER.exec(v.trim());\n  if (!m) return null;\n  return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ? m[4].split('.') : [] };\n}\n\n/** True for a full `x.y.z[-pre][+build]` version (a leading `v` is allowed). */\nexport function isSemver(v: string): boolean {\n  return parse(v) !== null;\n}\n\n/**\n * -1 / 0 / 1 ordering of two versions per SemVer §11: numeric x.y.z, a\n * prerelease sorts before its release, and prerelease identifiers compare\n * numerically when both are numeric (`rc.2` < `rc.10`), else as ASCII, with a\n * numeric identifier below an alphanumeric one and a shorter set below a\n * longer one that it prefixes. Throws on a value that isn't a version.\n */\nexport function compareSemver(a: string, b: string): -1 | 0 | 1 {\n  const x = parse(a);\n  const y = parse(b);\n  if (!x || !y) throw new Error(`Not a semver version: ${!x ? a : b}`);\n  for (let i = 0; i < 3; i++) {\n    if (x.nums[i] !== y.nums[i]) return x.nums[i]! < y.nums[i]! ? -1 : 1;\n  }\n  if (!x.pre.length || !y.pre.length) {\n    if (x.pre.length === y.pre.length) return 0;\n    return x.pre.length ? -1 : 1;\n  }\n  for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {\n    const p = x.pre[i];\n    const q = y.pre[i];\n    if (p === undefined) return -1;\n    if (q === undefined) return 1;\n    if (p === q) continue;\n    const pn = /^\\d+$/.test(p);\n    const qn = /^\\d+$/.test(q);\n    if (pn && qn) return Number(p) < Number(q) ? -1 : 1;\n    if (pn !== qn) return pn ? -1 : 1;\n    return p < q ? -1 : 1;\n  }\n  return 0;\n}\n\n/** A partial version (`26`, `26.13`) padded to x.y.z, or null. */\nfunction padded(v: string): string | null {\n  const m = /^v?(\\d+)(?:\\.(\\d+))?(?:\\.(\\d+))?(-[0-9A-Za-z.-]+)?$/.exec(v);\n  if (!m) return null;\n  return `${m[1]}.${m[2] ?? 0}.${m[3] ?? 0}${m[4] ?? ''}`;\n}\n\nfunction satisfiesComparator(version: string, comparator: string): boolean | null {\n  const m = /^(>=|<=|>|<|=|\\^|~)?\\s*(.+)$/.exec(comparator);\n  if (!m) return null;\n  const op = m[1] ?? '=';\n  const base = padded(m[2]!);\n  if (!base) return null;\n  const c = compareSemver(version, base);\n  switch (op) {\n    case '>=': return c >= 0;\n    case '>': return c > 0;\n    case '<=': return c <= 0;\n    case '<': return c < 0;\n    case '=': return c === 0;\n    default: {\n      // ^ keeps the left-most non-zero part fixed; ~ keeps major.minor fixed.\n      const [maj, min] = base.split(/[.-]/).map(Number) as [number, number];\n      const upper = op === '~' ? `${maj}.${min + 1}.0` : maj > 0 ? `${maj + 1}.0.0` : `0.${min + 1}.0`;\n      return c >= 0 && compareSemver(version, `${upper}-0`) < 0;\n    }\n  }\n}\n\n/**\n * Whether `version` satisfies an `engines`-style range: comparator sets joined\n * by `||`, each a space-separated AND of `>=`, `>`, `<=`, `<`, `=`, `^`, `~` or\n * bare versions (partials like `>= 26` allowed). `*` / empty match anything.\n * Returns null when the range uses syntax outside that (hyphen ranges, `x`\n * wildcards), so the caller can decide rather than guess.\n */\nexport function satisfiesRange(version: string, range: string): boolean | null {\n  if (!isSemver(version)) return null;\n  const trimmed = range.trim();\n  if (trimmed === '' || trimmed === '*') return true;\n  let any = false;\n  for (const set of trimmed.split('||')) {\n    // Join an operator to its version (`>= 26.13.0` → `>=26.13.0`), then split.\n    const comparators = set.trim().replace(/(>=|<=|>|<|=|\\^|~)\\s+/g, '$1').split(/\\s+/).filter(Boolean);\n    let all = true;\n    for (const comparator of comparators) {\n      const ok = satisfiesComparator(version, comparator);\n      if (ok === null) return null;\n      if (!ok) all = false;\n    }\n    if (all) any = true;\n  }\n  return any;\n}\n"]}

package/package.json

@@ -127,7 +127,7 @@
       ]
     }
   },
-  "version": "5.2.7",
+  "version": "5.2.9",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },