stone-lang 0.1.0

package/packages/semver.js

@@ -0,0 +1,635 @@
+/**
+ * Stone Semver Library
+ *
+ * Implements semantic versioning (semver) parsing and comparison.
+ * Supports version ranges like ^, ~, >=, <, etc.
+ */
+
+/**
+ * Parsed semantic version
+ */
+export class SemVer {
+  constructor(major, minor, patch, prerelease = [], build = []) {
+    this.major = major;
+    this.minor = minor;
+    this.patch = patch;
+    this.prerelease = prerelease;
+    this.build = build;
+  }
+
+  toString() {
+    let version = `${this.major}.${this.minor}.${this.patch}`;
+    if (this.prerelease.length > 0) {
+      version += '-' + this.prerelease.join('.');
+    }
+    if (this.build.length > 0) {
+      version += '+' + this.build.join('.');
+    }
+    return version;
+  }
+
+  /**
+   * Compare this version to another
+   * Returns: -1 if this < other, 0 if equal, 1 if this > other
+   */
+  compare(other) {
+    // Compare major.minor.patch
+    if (this.major !== other.major) {
+      return this.major > other.major ? 1 : -1;
+    }
+    if (this.minor !== other.minor) {
+      return this.minor > other.minor ? 1 : -1;
+    }
+    if (this.patch !== other.patch) {
+      return this.patch > other.patch ? 1 : -1;
+    }
+
+    // Prerelease versions have lower precedence than normal versions
+    if (this.prerelease.length === 0 && other.prerelease.length > 0) {
+      return 1; // this is release, other is prerelease
+    }
+    if (this.prerelease.length > 0 && other.prerelease.length === 0) {
+      return -1; // this is prerelease, other is release
+    }
+
+    // Compare prerelease identifiers
+    const minLen = Math.min(this.prerelease.length, other.prerelease.length);
+    for (let i = 0; i < minLen; i++) {
+      const a = this.prerelease[i];
+      const b = other.prerelease[i];
+
+      if (a === b) continue;
+
+      const aIsNum = typeof a === 'number';
+      const bIsNum = typeof b === 'number';
+
+      if (aIsNum && bIsNum) {
+        return a > b ? 1 : -1;
+      }
+      if (aIsNum) {
+        return -1; // numbers have lower precedence than strings
+      }
+      if (bIsNum) {
+        return 1;
+      }
+      // Both are strings
+      return a > b ? 1 : -1;
+    }
+
+    // Longer prerelease has higher precedence
+    if (this.prerelease.length !== other.prerelease.length) {
+      return this.prerelease.length > other.prerelease.length ? 1 : -1;
+    }
+
+    return 0;
+  }
+
+  eq(other) { return this.compare(other) === 0; }
+  lt(other) { return this.compare(other) < 0; }
+  lte(other) { return this.compare(other) <= 0; }
+  gt(other) { return this.compare(other) > 0; }
+  gte(other) { return this.compare(other) >= 0; }
+}
+
+/**
+ * Parse a version string into a SemVer object
+ * @param {string} version - Version string (e.g., "1.2.3", "1.0.0-alpha.1+build.123")
+ * @returns {SemVer} Parsed version
+ */
+export function parseVersion(version) {
+  if (version instanceof SemVer) return version;
+
+  const str = String(version).trim();
+  if (!str) {
+    throw new SemVerError(`Invalid version: empty string`);
+  }
+
+  // Split off build metadata
+  let [versionPart, ...buildParts] = str.split('+');
+  const build = buildParts.length > 0 ? buildParts.join('+').split('.') : [];
+
+  // Split off prerelease
+  let [corePart, ...prereleaseParts] = versionPart.split('-');
+  const prereleaseStr = prereleaseParts.join('-');
+  const prerelease = prereleaseStr ? parsePrerelease(prereleaseStr) : [];
+
+  // Parse major.minor.patch
+  const parts = corePart.split('.');
+  if (parts.length < 1 || parts.length > 3) {
+    throw new SemVerError(`Invalid version format: ${version}`);
+  }
+
+  const major = parseVersionNumber(parts[0], 'major', version);
+  const minor = parts.length > 1 ? parseVersionNumber(parts[1], 'minor', version) : 0;
+  const patch = parts.length > 2 ? parseVersionNumber(parts[2], 'patch', version) : 0;
+
+  return new SemVer(major, minor, patch, prerelease, build);
+}
+
+function parseVersionNumber(str, name, fullVersion) {
+  if (!/^\d+$/.test(str)) {
+    throw new SemVerError(`Invalid ${name} version in: ${fullVersion}`);
+  }
+  const num = parseInt(str, 10);
+  if (num < 0) {
+    throw new SemVerError(`Negative ${name} version in: ${fullVersion}`);
+  }
+  return num;
+}
+
+function parsePrerelease(str) {
+  return str.split('.').map(part => {
+    if (/^\d+$/.test(part)) {
+      return parseInt(part, 10);
+    }
+    return part;
+  });
+}
+
+/**
+ * Semver Error
+ */
+export class SemVerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'SemVerError';
+  }
+}
+
+// =============================================================================
+// Version Ranges
+// =============================================================================
+
+/**
+ * Range comparator types
+ */
+const ComparatorType = {
+  EQ: 'EQ',     // =1.2.3 or 1.2.3
+  GT: 'GT',     // >1.2.3
+  GTE: 'GTE',   // >=1.2.3
+  LT: 'LT',     // <1.2.3
+  LTE: 'LTE',   // <=1.2.3
+  ANY: 'ANY',   // * or x
+};
+
+/**
+ * A single comparator (e.g., >=1.2.3)
+ */
+class Comparator {
+  constructor(type, version = null) {
+    this.type = type;
+    this.version = version;
+  }
+
+  /**
+   * Check if a version satisfies this comparator
+   */
+  test(version) {
+    if (this.type === ComparatorType.ANY) {
+      return true;
+    }
+
+    const v = parseVersion(version);
+
+    switch (this.type) {
+      case ComparatorType.EQ:
+        return v.eq(this.version);
+      case ComparatorType.GT:
+        return v.gt(this.version);
+      case ComparatorType.GTE:
+        return v.gte(this.version);
+      case ComparatorType.LT:
+        return v.lt(this.version);
+      case ComparatorType.LTE:
+        return v.lte(this.version);
+      default:
+        return false;
+    }
+  }
+
+  toString() {
+    switch (this.type) {
+      case ComparatorType.ANY: return '*';
+      case ComparatorType.EQ: return this.version.toString();
+      case ComparatorType.GT: return '>' + this.version.toString();
+      case ComparatorType.GTE: return '>=' + this.version.toString();
+      case ComparatorType.LT: return '<' + this.version.toString();
+      case ComparatorType.LTE: return '<=' + this.version.toString();
+      default: return '';
+    }
+  }
+}
+
+/**
+ * A version range (set of comparators combined with AND, with multiple sets combined with OR)
+ */
+export class VersionRange {
+  constructor(comparatorSets = []) {
+    // Each set is an array of comparators (ANDed together)
+    // Multiple sets are ORed together
+    this.comparatorSets = comparatorSets;
+  }
+
+  /**
+   * Check if a version satisfies this range
+   */
+  test(version) {
+    if (this.comparatorSets.length === 0) {
+      return true; // Empty range matches anything
+    }
+
+    // OR between sets
+    return this.comparatorSets.some(set => {
+      // AND within each set
+      return set.every(comparator => comparator.test(version));
+    });
+  }
+
+  toString() {
+    return this.comparatorSets
+      .map(set => set.map(c => c.toString()).join(' '))
+      .join(' || ');
+  }
+}
+
+/**
+ * Parse a version range string
+ * Supports:
+ *   - Exact: 1.2.3
+ *   - Comparators: >1.0.0, >=1.0.0, <2.0.0, <=2.0.0
+ *   - Caret: ^1.2.3 (>=1.2.3 <2.0.0)
+ *   - Tilde: ~1.2.3 (>=1.2.3 <1.3.0)
+ *   - Wildcards: 1.x, 1.2.x, 1.*, *
+ *   - Ranges: >=1.0.0 <2.0.0
+ *   - OR: 1.2.3 || 2.0.0
+ *
+ * @param {string} range - Range string
+ * @returns {VersionRange} Parsed range
+ */
+export function parseRange(range) {
+  if (range instanceof VersionRange) return range;
+
+  const str = String(range).trim();
+  if (!str || str === '*' || str === 'x' || str === 'X') {
+    return new VersionRange([[new Comparator(ComparatorType.ANY)]]);
+  }
+
+  // Split by || for OR groups
+  const orParts = str.split('||').map(s => s.trim()).filter(s => s);
+  const comparatorSets = orParts.map(parseAndGroup);
+
+  return new VersionRange(comparatorSets);
+}
+
+/**
+ * Parse a single AND group (e.g., ">=1.0.0 <2.0.0")
+ */
+function parseAndGroup(str) {
+  const comparators = [];
+  const tokens = tokenizeRange(str);
+
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+
+    // Caret range: ^1.2.3
+    if (token === '^') {
+      i++;
+      const version = parseVersion(tokens[i]);
+      comparators.push(...expandCaret(version));
+      i++;
+      continue;
+    }
+
+    // Tilde range: ~1.2.3
+    if (token === '~') {
+      i++;
+      const version = parseVersion(tokens[i]);
+      comparators.push(...expandTilde(version));
+      i++;
+      continue;
+    }
+
+    // Comparators: >=, >, <=, <, =
+    if (token === '>=' || token === '>' || token === '<=' || token === '<' || token === '=') {
+      const type = {
+        '>=': ComparatorType.GTE,
+        '>': ComparatorType.GT,
+        '<=': ComparatorType.LTE,
+        '<': ComparatorType.LT,
+        '=': ComparatorType.EQ,
+      }[token];
+
+      i++;
+      const version = parseVersion(tokens[i]);
+      comparators.push(new Comparator(type, version));
+      i++;
+      continue;
+    }
+
+    // Wildcard: 1.x, 1.2.x, 1.*, *
+    if (isWildcard(token)) {
+      comparators.push(...expandWildcard(token));
+      i++;
+      continue;
+    }
+
+    // Exact version: 1.2.3
+    const version = parseVersion(token);
+    comparators.push(new Comparator(ComparatorType.EQ, version));
+    i++;
+  }
+
+  return comparators;
+}
+
+/**
+ * Tokenize a range string
+ */
+function tokenizeRange(str) {
+  const tokens = [];
+  let current = '';
+
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+
+    if (char === ' ' || char === '\t') {
+      if (current) {
+        tokens.push(current);
+        current = '';
+      }
+      continue;
+    }
+
+    if (char === '^' || char === '~') {
+      if (current) {
+        tokens.push(current);
+        current = '';
+      }
+      tokens.push(char);
+      continue;
+    }
+
+    if (char === '>' || char === '<' || char === '=') {
+      if (current) {
+        tokens.push(current);
+        current = '';
+      }
+      // Check for >= or <=
+      if ((char === '>' || char === '<') && str[i + 1] === '=') {
+        tokens.push(char + '=');
+        i++;
+      } else {
+        tokens.push(char);
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current) {
+    tokens.push(current);
+  }
+
+  return tokens;
+}
+
+/**
+ * Check if a token is a wildcard (contains x, X, or *)
+ */
+function isWildcard(token) {
+  return /[xX*]/.test(token);
+}
+
+/**
+ * Expand a caret range (^1.2.3 -> >=1.2.3 <2.0.0)
+ * For 0.x versions: ^0.2.3 -> >=0.2.3 <0.3.0
+ */
+function expandCaret(version) {
+  const comparators = [];
+  comparators.push(new Comparator(ComparatorType.GTE, version));
+
+  let upper;
+  if (version.major === 0) {
+    if (version.minor === 0) {
+      // ^0.0.x -> >=0.0.x <0.0.(x+1)
+      upper = new SemVer(0, 0, version.patch + 1);
+    } else {
+      // ^0.x.y -> >=0.x.y <0.(x+1).0
+      upper = new SemVer(0, version.minor + 1, 0);
+    }
+  } else {
+    // ^x.y.z -> >=x.y.z <(x+1).0.0
+    upper = new SemVer(version.major + 1, 0, 0);
+  }
+
+  comparators.push(new Comparator(ComparatorType.LT, upper));
+  return comparators;
+}
+
+/**
+ * Expand a tilde range (~1.2.3 -> >=1.2.3 <1.3.0)
+ */
+function expandTilde(version) {
+  const comparators = [];
+  comparators.push(new Comparator(ComparatorType.GTE, version));
+
+  const upper = new SemVer(version.major, version.minor + 1, 0);
+  comparators.push(new Comparator(ComparatorType.LT, upper));
+
+  return comparators;
+}
+
+/**
+ * Expand a wildcard (1.x -> >=1.0.0 <2.0.0)
+ */
+function expandWildcard(token) {
+  const parts = token.split('.');
+
+  // * or x -> any
+  if (parts.length === 1 && (parts[0] === '*' || parts[0].toLowerCase() === 'x')) {
+    return [new Comparator(ComparatorType.ANY)];
+  }
+
+  const major = parts[0] === '*' || parts[0].toLowerCase() === 'x' ? null : parseInt(parts[0], 10);
+
+  // 1.x or 1.*
+  if (parts.length === 2 || (parts.length === 3 && (parts[2] === '*' || parts[2].toLowerCase() === 'x'))) {
+    if (major === null) {
+      return [new Comparator(ComparatorType.ANY)];
+    }
+
+    const minor = parts.length > 1 && parts[1] !== '*' && parts[1].toLowerCase() !== 'x'
+      ? parseInt(parts[1], 10)
+      : null;
+
+    if (minor === null) {
+      // 1.x -> >=1.0.0 <2.0.0
+      return [
+        new Comparator(ComparatorType.GTE, new SemVer(major, 0, 0)),
+        new Comparator(ComparatorType.LT, new SemVer(major + 1, 0, 0)),
+      ];
+    } else {
+      // 1.2.x -> >=1.2.0 <1.3.0
+      return [
+        new Comparator(ComparatorType.GTE, new SemVer(major, minor, 0)),
+        new Comparator(ComparatorType.LT, new SemVer(major, minor + 1, 0)),
+      ];
+    }
+  }
+
+  // Fallback: treat as exact
+  return [new Comparator(ComparatorType.EQ, parseVersion(token.replace(/[xX*]/g, '0')))];
+}
+
+// =============================================================================
+// Utility Functions
+// =============================================================================
+
+/**
+ * Check if a version satisfies a range
+ * @param {string|SemVer} version - Version to check
+ * @param {string|VersionRange} range - Range to check against
+ * @returns {boolean} True if version satisfies range
+ */
+export function satisfies(version, range) {
+  const v = parseVersion(version);
+  const r = parseRange(range);
+  return r.test(v);
+}
+
+/**
+ * Compare two versions
+ * @returns {number} -1, 0, or 1
+ */
+export function compare(a, b) {
+  return parseVersion(a).compare(parseVersion(b));
+}
+
+/**
+ * Check if a > b
+ */
+export function gt(a, b) {
+  return compare(a, b) > 0;
+}
+
+/**
+ * Check if a >= b
+ */
+export function gte(a, b) {
+  return compare(a, b) >= 0;
+}
+
+/**
+ * Check if a < b
+ */
+export function lt(a, b) {
+  return compare(a, b) < 0;
+}
+
+/**
+ * Check if a <= b
+ */
+export function lte(a, b) {
+  return compare(a, b) <= 0;
+}
+
+/**
+ * Check if a == b
+ */
+export function eq(a, b) {
+  return compare(a, b) === 0;
+}
+
+/**
+ * Sort versions in ascending order
+ */
+export function sort(versions) {
+  return [...versions].sort(compare);
+}
+
+/**
+ * Sort versions in descending order
+ */
+export function rsort(versions) {
+  return [...versions].sort((a, b) => compare(b, a));
+}
+
+/**
+ * Find the highest version that satisfies a range
+ * @param {string[]} versions - Available versions
+ * @param {string} range - Version range
+ * @returns {string|null} Highest matching version or null
+ */
+export function maxSatisfying(versions, range) {
+  const r = parseRange(range);
+  const matching = versions.filter(v => r.test(parseVersion(v)));
+  if (matching.length === 0) return null;
+  return rsort(matching)[0];
+}
+
+/**
+ * Find the lowest version that satisfies a range
+ * @param {string[]} versions - Available versions
+ * @param {string} range - Version range
+ * @returns {string|null} Lowest matching version or null
+ */
+export function minSatisfying(versions, range) {
+  const r = parseRange(range);
+  const matching = versions.filter(v => r.test(parseVersion(v)));
+  if (matching.length === 0) return null;
+  return sort(matching)[0];
+}
+
+/**
+ * Check if a version is valid semver
+ */
+export function valid(version) {
+  try {
+    parseVersion(version);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Coerce a string into a valid semver if possible
+ */
+export function coerce(version) {
+  try {
+    return parseVersion(version).toString();
+  } catch {
+    // Try to extract version-like pattern
+    const match = String(version).match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (match) {
+      const major = parseInt(match[1], 10);
+      const minor = match[2] ? parseInt(match[2], 10) : 0;
+      const patch = match[3] ? parseInt(match[3], 10) : 0;
+      return new SemVer(major, minor, patch).toString();
+    }
+    return null;
+  }
+}
+
+export default {
+  SemVer,
+  SemVerError,
+  VersionRange,
+  parseVersion,
+  parseRange,
+  satisfies,
+  compare,
+  gt,
+  gte,
+  lt,
+  lte,
+  eq,
+  sort,
+  rsort,
+  maxSatisfying,
+  minSatisfying,
+  valid,
+  coerce,
+};