aontu 0.43.0 → 0.45.1

package/src/val/PathVal.ts

@@ -1,435 +0,0 @@
-/* Copyright (c) 2025 Richard Rodger, MIT License */
-
-
-import type {
-  Val,
-  ValSpec,
-} from '../type'
-
-import {
-  DONE,
-} from '../type'
-
-import {
-  walk,
-} from '../utility'
-
-import { AontuContext } from '../ctx'
-import { unite } from '../unify'
-
-import { makeNilErr } from '../err'
-
-import {
-  top
-} from './top'
-
-import { StringVal } from './StringVal'
-import { IntegerVal } from './IntegerVal'
-import { NumberVal } from './NumberVal'
-import { VarVal } from './VarVal'
-import { ConjunctVal } from './ConjunctVal'
-import { DisjunctVal } from './DisjunctVal'
-import { FeatureVal } from './FeatureVal'
-
-
-class PathVal extends FeatureVal {
-  isPath = true
-  isGenable = true
-  cjo = 32500
-
-  absolute: boolean = false
-  prefix: boolean = false
-  _resolved: Val | undefined = undefined
-
-  constructor(
-    spec: {
-      peg: any[],
-      absolute?: boolean,
-      prefix?: boolean
-    },
-    ctx?: AontuContext
-  ) {
-    super(spec, ctx)
-    this.peg = []
-
-    this.absolute = true === this.absolute ? true : // absolute sticks
-      true === spec.absolute ? true : false
-
-    this.prefix = true === spec.prefix
-
-    for (let pI = 0; pI < spec.peg.length; pI++) {
-      this.append(spec.peg[pI])
-    }
-  }
-
-
-  append(part: any) {
-    let partval
-
-    if ('string' === typeof part) {
-      partval = part
-      this.peg.push(partval)
-    }
-
-    else if (part instanceof StringVal) {
-      partval = part.peg
-      this.peg.push(partval)
-    }
-
-    else if (part instanceof IntegerVal) {
-      partval = part.src
-      this.peg.push(partval)
-    }
-
-    else if (part instanceof NumberVal) {
-      let partvals: string[] = part.src.split('.')
-      this.peg.push(...partvals)
-    }
-
-    else if (part instanceof VarVal) {
-      partval = part
-      this.peg.push(partval)
-    }
-
-    else if (part instanceof PathVal) {
-      if (part.absolute) {
-        this.absolute = true
-      }
-
-      if (this.prefix) {
-        if (part.prefix) {
-          this.peg.push('.')
-        }
-      }
-      else {
-        if (part.prefix) {
-          if (0 === this.peg.length) {
-            this.prefix = true
-          }
-
-          else if (0 < this.peg.length) {
-            this.peg.push('.')
-          }
-        }
-      }
-
-      this.peg.push(...part.peg)
-    }
-  }
-
-
-  unify(peer: Val, ctx: AontuContext): Val {
-    peer = peer ?? top()
-
-    // Already resolved (e.g. path value from path() function) — skip find
-    if (this.done) return this
-
-    let out: Val = this
-    const found = this.find(ctx)
-
-    if (found != null && !found.isNil) {
-      out = unite(ctx, found, peer, 'path')
-    }
-    else if (found?.isNil) {
-      out = found
-    }
-    else {
-      // Not yet resolvable — increment dc to signal not done
-      this.dc = DONE === this.dc ? DONE : this.dc + 1
-    }
-
-    return out
-  }
-
-
-  find(ctx: AontuContext) {
-    let out: Val | undefined = undefined
-
-    // Check if self.path starts with peg (cycle detection).
-    // Element-by-element comparison avoids string join+startsWith allocations.
-    let isprefixpath = this.peg.length <= this.path.length
-    if (isprefixpath) {
-      for (let i = 0; i < this.peg.length; i++) {
-        if (this.peg[i] !== this.path[i]) {
-          isprefixpath = false
-          break
-        }
-      }
-    }
-    // Degenerate case: peg is all empty strings (e.g. path("")) and path is empty.
-    if (!isprefixpath && this.peg.length > 0 && this.path.length === 0) {
-      let allEmpty = true
-      for (let i = 0; i < this.peg.length; i++) {
-        if ('' !== this.peg[i]) { allEmpty = false; break }
-      }
-      isprefixpath = allEmpty
-    }
-
-    let refpath: string[] = []
-    let pI = 0
-    // let descent = ''
-
-    if (isprefixpath) {
-      // console.log('SELFPATH', selfpath, 'PEGPATH', pegpath)
-      out = makeNilErr(ctx, 'path_cycle', this)
-    }
-    else {
-
-      let parts: string[] = []
-
-      let modes: string[] = []
-
-      for (let pI = 0; pI < this.peg.length; pI++) {
-        let part = this.peg[pI]
-        if (part instanceof VarVal) {
-          let strval = (part as VarVal).peg
-          let name = strval ? '' + strval.peg : ''
-
-          if ('KEY' === name) {
-            if (pI === this.peg.length - 1) {
-              modes.push(name)
-            }
-            else {
-              // TODO: return a Nil explaining error
-              return
-            }
-          }
-
-          if ('SELF' === name) {
-            if (pI === 0) {
-              modes.push(name)
-            }
-            else {
-              // TODO: return a Nil explaining error
-              return
-            }
-          }
-          else if ('PARENT' === name) {
-            if (pI === 0) {
-              modes.push(name)
-            }
-            else {
-              // TODO: return a Nil explaining error
-              return
-            }
-          }
-          else if (0 === modes.length) {
-            part = (part as VarVal).unify(top(), ctx)
-            if (part.isNil) {
-              // TODO: var not found, so can't find path
-              return
-            }
-            else {
-              part = '' + part.peg
-            }
-          }
-        }
-        else {
-          parts.push(part)
-        }
-      }
-
-      if (this.absolute) {
-        refpath = parts
-      }
-      else {
-        // TODO: deprecate $KEY, etc
-        refpath = this.path.slice(
-          0,
-          (
-            modes.includes('SELF') ? 0 :
-              modes.includes('PARENT') ? -1 :
-                -1 // siblings
-          )
-        ).concat(parts)
-      }
-
-      let sep = '.'
-      refpath = refpath
-        .reduce(((a: string[], p: string) =>
-          (p === sep ? a.length = a.length - 1 : a.push(p), a)), [])
-
-      if (modes.includes('KEY')) {
-        let key = this.path[this.path.length - 2]
-        let sv = new StringVal({ peg: null == key ? '' : key }, ctx)
-
-        // TODO: other props?
-        sv.dc = DONE
-        sv.path = this.path
-
-        return sv
-      }
-
-      let node: Val | null = ctx.root as Val
-
-      let nopath = false
-
-      if (null != node) {
-        for (; pI < refpath.length; pI++) {
-          let part = refpath[pI]
-          // console.log('PART', pI, part, node)
-
-          // descent += (' | ' + pI + '=' + node.canon) // Util.inspect(node))
-
-          if (node.isMap) {
-            node = node.peg[part]
-          }
-          else if (node.isList) {
-            node = node.peg[part]
-          }
-          else if (node.isConjunct || node.isDisjunct) {
-            // Collect matching children from all junction terms,
-            // flattening nested conjuncts and disjuncts.
-            // Spreads match any key — their peg is always included.
-            const matches: Val[] = []
-            const stack = [...node.peg]
-            while (stack.length > 0) {
-              const term = stack.pop()!
-              if (term.isConjunct || term.isDisjunct) {
-                stack.push(...term.peg)
-              }
-              else if (term.isSpread) {
-                matches.push(term.peg)
-              }
-              else if ((term.isMap || term.isList) && term.peg[part] != null) {
-                matches.push(term.peg[part])
-              }
-            }
-            if (matches.length === 1) {
-              node = matches[0]
-            }
-            else if (matches.length > 1) {
-              node = node.isConjunct
-                ? new ConjunctVal({ peg: matches })
-                : new DisjunctVal({ peg: matches })
-            }
-            else {
-              node = null
-            }
-          }
-          else if (node.done) {
-            nopath = true
-            break;
-          }
-          else {
-            break;
-          }
-
-          if (null == node) {
-            nopath = true
-            break
-          }
-
-        }
-      }
-
-      // console.log('REFPATH', ctx.cc, pI, refpath, nopath, ctx.root, node)
-
-
-      if (nopath) {
-        out = makeNilErr(ctx, 'no_path', this)
-      }
-      else if (pI === refpath.length && node != null) {
-        out = node
-
-        // Types and hidden values are cloned and made concrete
-        if (null != out) { //  && (out.mark.type || out.mark.hide)) {
-
-          // console.log('FOUND-A', out)
-
-          if (this.mark.type || this.mark.hide) {
-            out.mark.type = this.mark.type
-            out.mark.hide = this.mark.hide
-          }
-
-          if (this.mark._hide_found) {
-            out.mark.hide = true
-          }
-
-          // Cache clone+walk results per (ref, target) per iteration.
-          const cacheKey = this.id + '|' + out.id
-          const cache = ctx._refCloneCache
-          const cached = cache?.get(cacheKey)
-          if (cached !== undefined) {
-            out = cached
-          }
-          else {
-            out = out.clone(ctx)
-            out.mark.type = false
-            out.mark.hide = false
-
-            walk(out, (_key: string | number | undefined, val: Val) => {
-              val.mark.type = false
-              val.mark.hide = false
-              return val
-            })
-
-            cache?.set(cacheKey, out)
-          }
-        }
-      }
-    }
-
-    // console.log('REF-FIND', ctx.cc, this.id, selfpath, 'PEG=', pegpath, 'RP', pI, refpath.join('.'), descent, 'O=', out?.id, out?.canon, out?.done)
-
-    return out
-  }
-
-
-
-  same(peer: Val): boolean {
-    return null == peer ? false : this.peg === peer.peg
-  }
-
-
-  clone(ctx: AontuContext, spec?: ValSpec): Val {
-    let out = (super.clone(ctx, {
-      peg: this.peg,
-      absolute: this.absolute,
-      ...(spec || {})
-    }) as PathVal)
-    return out
-  }
-
-
-  get canon() {
-    let str =
-      (this.absolute ? '$' : '') +
-      (0 < this.peg.length ? '.' : '') +
-      this.peg.map((p: any) => '.' === p ? '' :
-        (p.isVal ? p.canon : '' + p))
-        .join('.')
-    return str
-  }
-
-
-  gen(ctx: AontuContext) {
-    let nil = makeNilErr(
-      ctx,
-      'ref',
-      this,
-      undefined,
-    )
-
-    nil.path = this.path
-    nil.site.url = this.site.url
-    nil.site.row = this.site.row
-    nil.site.col = this.site.col
-
-    return undefined
-  }
-
-
-  inspection() {
-    return [
-      this.absolute ? 'absolute' : '',
-      this.prefix ? 'prefix' : '',
-    ].filter(p => '' != p).join(',')
-  }
-
-}
-
-
-export {
-  PathVal,
-}

package/src/val/SpreadVal.ts

@@ -1,275 +0,0 @@
-/* Copyright (c) 2025 Richard Rodger, MIT License */
-
-// SpreadVal represents a spread constraint (&:{...}).
-// It owns all spread application logic — MapVal and ListVal know
-// nothing about spreads. A parsed `{a:1, &:{x:2}}` becomes
-// `ConjunctVal([MapVal({a:1}), SpreadVal({x:2})])`.
-//
-// SpreadVal.unify applies the constraint to a peer MapVal/ListVal
-// by unifying each of the peer's children with a per-key clone of
-// the spread constraint.
-
-import type {
-  Val,
-  ValSpec,
-} from '../type'
-
-import {
-  DONE,
-} from '../type'
-
-import { AontuContext } from '../ctx'
-import { unite } from '../unify'
-
-import {
-  propagateMarks,
-  walk,
-  explainOpen,
-  ec,
-  explainClose,
-} from '../utility'
-
-import { makeNilErr } from '../err'
-
-import {
-  top
-} from './top'
-
-import { FeatureVal } from './FeatureVal'
-import { ConjunctVal } from './ConjunctVal'
-import { NilVal } from './NilVal'
-import { MapVal } from './MapVal'
-import { ListVal } from './ListVal'
-
-
-class SpreadVal extends FeatureVal {
-  isSpread = true
-  isGenable = true
-  cjo = 110000  // Sorts after MapVal/ListVal in ConjunctVal norm
-
-  constructor(spec: ValSpec, ctx?: AontuContext) {
-    super(spec, ctx)
-  }
-
-
-  unify(peer: Val, ctx: AontuContext): Val {
-    peer = peer ?? top()
-
-    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Spread', this, peer)
-
-    let out: Val
-
-    if (peer.isTop) {
-      // Self-unify: spread is a constraint, not a value that converges.
-      // Mark done to prevent fixpoint cycling.
-      out = this
-      out.dc = DONE
-    }
-    else if ((peer as any).isSpread) {
-      // SpreadVal + SpreadVal: unify the two constraints
-      const merged = unite(
-        te ? ctx.clone({ explain: ec(te, 'SPR') }) : ctx,
-        this.peg, peer.peg, 'spread-merge')
-      out = new SpreadVal({ peg: merged }, ctx)
-      out.dc = merged.done ? DONE : this.dc + 1
-    }
-    else if (peer.isMap) {
-      // SpreadVal + MapVal: apply spread to each map key
-      out = this.applyToMap(peer as any, ctx, te)
-    }
-    else if (peer.isList) {
-      // SpreadVal + ListVal: apply spread to each list element
-      out = this.applyToList(peer as any, ctx, te)
-    }
-    else if (peer.isConjunct) {
-      // SpreadVal + ConjunctVal: unify with the conjunct.
-      // The conjunct fold will place us last (high cjo).
-      out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'SCJ') }) : ctx)
-    }
-    else {
-      // SpreadVal + other: defer by wrapping in ConjunctVal
-      out = new ConjunctVal({ peg: [peer, this] }, ctx)
-      out.dc = this.dc + 1
-    }
-
-    // Track unresolved spread count.
-    // cc=0: increment for spreads that don't vanish.
-    // cc>0: decrement when a spread vanishes.
-    if (0 === ctx.cc) {
-      if (out.isSpread && !out.done) {
-        ctx.sc++
-      }
-    }
-    else if (ctx.sc > 0) {
-      if (!(out.isSpread && !out.done)) {
-        ctx.sc--
-      }
-    }
-
-    ctx.explain && explainClose(te, out)
-    return out
-  }
-
-
-  // Apply this spread constraint to each key in a MapVal.
-  // Uses unite() per key with the correct descended context.
-  applyToMap(map: MapVal, ctx: AontuContext, te: any): Val {
-    const spread = this.peg
-
-    const mapKeys = Object.keys(map.peg)
-
-    // If map has no keys, preserve the spread for future merges.
-    // Mark as DONE to prevent fixpoint cycling.
-    if (mapKeys.length === 0) {
-      const out = new ConjunctVal({ peg: [map, this] }, ctx)
-      out.dc = DONE
-      return out
-    }
-
-    const out = new MapVal({ peg: {} }, ctx)
-    out.closed = map.closed
-    out.optionalKeys = 0 < map.optionalKeys.length
-      ? [...map.optionalKeys] : map.optionalKeys
-    out.site = map.site
-
-    let done = true
-
-    for (const key of mapKeys) {
-      const child = map.peg[key]
-      const keyctx = ctx.descend(key)
-      // Clone the spread for this key's context, then resolve any
-      // path-dependent functions (key(), path(), etc.) by unifying
-      // with TOP. This ensures the spread values are concrete before
-      // being merged as peer keys into the child map.
-      let key_spread = spread.spreadClone(keyctx)
-      if (!key_spread.done) {
-        key_spread = unite(keyctx, key_spread, top(), 'spread-resolve')
-      }
-
-      // Clear type marks on the spread constraint root and its
-      // direct children — type() constrains but should not mark
-      // children as type-invisible.
-      key_spread.mark.type = false
-      key_spread.mark.hide = false
-      if (key_spread.isMap) {
-        for (const k in key_spread.peg) {
-          if (key_spread.peg[k]?.isVal) {
-            key_spread.peg[k].mark.type = false
-          }
-        }
-      }
-
-      propagateMarks(map, child)
-
-      out.peg[key] =
-        undefined === child ? key_spread :
-          child.isNil ? child :
-            key_spread.isNil ? key_spread :
-              key_spread.isTop && child.done ? child :
-                child.isTop && key_spread.done ? key_spread :
-                  unite(te ? keyctx.clone({ explain: ec(te, 'SK:' + key) }) : keyctx,
-                    child, key_spread, 'spread-apply')
-
-      done = done && (DONE === out.peg[key].dc)
-    }
-
-    out.dc = done ? DONE : map.dc + 1
-
-    propagateMarks(map, out)
-    // NOTE: do not propagate type/hide marks from the spread constraint
-    // to the output — a type spread constrains children but doesn't
-    // make them type-invisible.
-
-    return out
-  }
-
-
-  // Apply this spread constraint to each element in a ListVal.
-  applyToList(list: ListVal, ctx: AontuContext, te: any): Val {
-    const spread = this.peg
-
-    const listKeys = Object.keys(list.peg)
-
-    if (listKeys.length === 0) {
-      const out = new ConjunctVal({ peg: [list, this] }, ctx)
-      out.dc = DONE
-      return out
-    }
-
-    const out = new ListVal({ peg: [] }, ctx)
-    out.closed = list.closed
-    out.optionalKeys = 0 < list.optionalKeys.length
-      ? [...list.optionalKeys] : list.optionalKeys
-    out.site = list.site
-
-    let done = true
-
-    for (const key of listKeys) {
-      const child = list.peg[key]
-      const keyctx = ctx.descend(key)
-      const key_spread = spread.spreadClone(keyctx)
-
-      propagateMarks(list, child)
-
-      out.peg[key as any] =
-        undefined === child ? key_spread :
-          child.isNil ? child :
-            key_spread.isNil ? key_spread :
-              key_spread.isTop && child.done ? child :
-                child.isTop && key_spread.done ? key_spread :
-                  unite(te ? keyctx.clone({ explain: ec(te, 'SL:' + key) }) : keyctx,
-                    child, key_spread, 'spread-apply-list')
-
-      done = done && (DONE === out.peg[key as any]?.dc)
-    }
-
-    out.dc = done ? DONE : list.dc + 1
-
-    propagateMarks(list, out)
-
-    return out
-  }
-
-
-  clone(ctx: AontuContext, spec?: ValSpec): Val {
-    const out = new SpreadVal({
-      peg: this.peg.clone(ctx, spec),
-      ...(spec || {}),
-    }, ctx)
-    out.dc = this.done ? DONE : out.dc
-    out.site = this.site
-    return out
-  }
-
-
-  spreadClone(ctx: AontuContext): Val {
-    if (!this.isPathDependent) return this
-    return this.clone(ctx)
-  }
-
-
-  get canon(): string {
-    // Use {&:...} for map spreads, [&:...] for list spreads, {&:X} for scalars
-    const pc = this.peg.canon
-    if (this.peg.isMap) return '{&:' + pc.slice(1, -1) + '}'   // {&:k:v,...}
-    if (this.peg.isList) return '[&:' + pc.slice(1, -1) + ']'  // [&:v,...]
-    return '{&:' + pc + '}'
-  }
-
-
-  gen(_ctx: AontuContext) {
-    // Unresolved spread (never applied to a map/list) generates
-    // as undefined — the spread is a constraint, not a value.
-    return undefined
-  }
-
-
-  inspection() {
-    return 'spread'
-  }
-}
-
-
-export {
-  SpreadVal,
-}