@soulbatical/tetra-dev-toolkit 1.18.0 → 1.18.1

package/bin/tetra-check-peers.js

@@ -38,50 +38,89 @@ function readJson(path) {
 }
 
 function satisfiesRange(installed, range) {
-  // Simple semver range check without external deps
-  // Handles: exact "2.93.3", caret "^2.93.3", tilde "~2.93.3", star "*", >= ">= 8.0.0"
+  // Check if a consumer's dependency range can satisfy a peer dep range.
+  // Both `installed` and `range` can be semver ranges (^2.48.0, ^2.93.3, etc.)
+  // We check if the ranges CAN overlap — i.e., there exists a version that satisfies both.
   if (!installed || !range) return false
-  if (range === '*') return true
+  if (range === '*' || installed === '*') return true
 
-  // Clean versions: remove leading ^ ~ >= <= > < =
   const cleanVersion = (v) => v.replace(/^[\^~>=<\s]+/, '').trim()
   const parseVersion = (v) => {
     const cleaned = cleanVersion(v)
     const parts = cleaned.split('.').map(Number)
     return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0 }
   }
+  const versionGte = (a, b) => {
+    if (a.major !== b.major) return a.major > b.major
+    if (a.minor !== b.minor) return a.minor > b.minor
+    return a.patch >= b.patch
+  }
 
-  const inst = parseVersion(installed)
-  const req = parseVersion(range)
+  // For || ranges, check each part independently
+  const rangeParts = range.split('||').map(p => p.trim())
+  const installedParts = installed.split('||').map(p => p.trim())
 
-  if (range.startsWith('>=')) {
-    // >= check
-    if (inst.major > req.major) return true
-    if (inst.major === req.major && inst.minor > req.minor) return true
-    if (inst.major === req.major && inst.minor === req.minor && inst.patch >= req.patch) return true
+  return rangeParts.some(rPart => {
+    return installedParts.some(iPart => {
+      return rangesOverlap(iPart, rPart, parseVersion, versionGte)
+    })
+  })
+}
+
+function rangesOverlap(installedRange, requiredRange, parseVersion, versionGte) {
+  const isCaret = (r) => r.startsWith('^')
+  const isTilde = (r) => r.startsWith('~')
+  const isGte = (r) => r.startsWith('>=')
+
+  const inst = parseVersion(installedRange)
+  const req = parseVersion(requiredRange)
+
+  // Both caret ranges with same major: they overlap if their ranges intersect
+  // ^2.48.0 allows 2.48.0 - 2.x.x, ^2.93.3 allows 2.93.3 - 2.x.x
+  // They overlap because ^2.48.0 includes 2.93.3
+  if ((isCaret(installedRange) || !installedRange.match(/^[\^~>=]/)) &&
+      (isCaret(requiredRange) || !requiredRange.match(/^[\^~>=]/))) {
+    // Same major = ranges can overlap
+    if (inst.major === req.major) {
+      // The higher minimum must be reachable from the lower range
+      // ^2.48.0 (allows up to <3.0.0) can reach 2.93.3 ✓
+      // ^3.0.0 cannot reach 2.93.3 ✗
+      return true // Same major with caret = always overlapping
+    }
+    // Different major with exact versions: only if equal
+    if (!isCaret(installedRange) && !isCaret(requiredRange)) {
+      return inst.major === req.major && inst.minor === req.minor && inst.patch === req.patch
+    }
     return false
   }
 
-  if (range.startsWith('^') || range.includes('||')) {
-    // Caret: same major, >= minor.patch
-    // For ranges with || (e.g. "^18.0.0 || ^19.0.0"), check each part
-    const parts = range.split('||').map(p => p.trim())
-    return parts.some(part => {
-      const r = parseVersion(part)
-      if (inst.major !== r.major) return false
-      if (inst.minor > r.minor) return true
-      if (inst.minor === r.minor && inst.patch >= r.patch) return true
-      return false
-    })
+  // >= range checks
+  if (isGte(requiredRange)) {
+    // Required >= X.Y.Z: consumer's range must be able to produce a version >= X.Y.Z
+    // ^9.0.0 can produce 9.0.0+ which is >= 8.0.0 ✓
+    // ^5.3.3 can produce 5.3.3+ which is >= 5.0.0 ✓
+    // The max version of consumer's caret range is <(major+1).0.0
+    // So: consumer max >= required min
+    const consumerMax = isCaret(installedRange) ? { major: inst.major + 1, minor: 0, patch: 0 } : inst
+    return versionGte(consumerMax, req)
+  }
+  if (isGte(installedRange)) {
+    // Consumer has >= X, required has ^Y.Z.W — any version >= X could satisfy ^Y if X <= Y
+    return true // >= is open-ended, always overlaps with bounded ranges
   }
 
-  if (range.startsWith('~')) {
-    // Tilde: same major.minor, >= patch
-    if (inst.major !== req.major || inst.minor !== req.minor) return false
-    return inst.patch >= req.patch
+  // Tilde: ~X.Y.Z allows X.Y.Z - X.Y+1.0
+  if (isTilde(installedRange) || isTilde(requiredRange)) {
+    if (inst.major !== req.major) return false
+    // Tilde ranges on same major.minor overlap
+    if (isTilde(installedRange) && isTilde(requiredRange)) {
+      return inst.minor === req.minor
+    }
+    // Tilde + caret: tilde range must include or be included in caret range
+    return inst.minor === req.minor || (isCaret(requiredRange) && inst.minor >= req.minor)
   }
 
-  // Exact version match
+  // Fallback: exact match
   return inst.major === req.major && inst.minor === req.minor && inst.patch === req.patch
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulbatical/tetra-dev-toolkit",
-  "version": "1.18.0",
+  "version": "1.18.1",
   "publishConfig": {
     "access": "restricted"
   },