aontu 0.30.1 → 0.30.2

package/src/val/Val.ts

@@ -0,0 +1,294 @@
+/* Copyright (c) 2022-2025 Richard Rodger, MIT License */
+
+import { inspect } from 'node:util'
+
+import type { AontuContext } from '../ctx'
+
+import {
+  Site
+} from '../site'
+
+
+type ValMark = {
+  type: boolean,
+  hide: boolean,
+
+  // Custom marks must have _ prefix.
+  [name: `_${string}`]: boolean,
+}
+
+type ValSpec = {
+  peg?: any,
+  mark?: Partial<ValMark>,
+  kind?: any,
+  row?: number,
+  col?: number,
+  url?: string,
+  path?: string[],
+  id?: number,
+  src?: string,
+
+  // NilVal specific
+  why?: string,
+  msg?: string,
+  err?: any[] | any,
+
+  // RefVal specific
+  absolute?: boolean,
+  prefix?: boolean,
+}
+
+// import { AontuError, descErr, makeNilErr } from '../err'
+// import { AontuError } from '../err'
+
+
+const DONE = -1
+
+const SPREAD = Symbol('spread')
+
+
+let ID = 1000
+
+
+abstract class Val {
+  isVal = true
+
+  isTop = false
+  isNil = false
+  isMap = false
+  isList = false
+  isScalar = false
+  isScalarKind = false
+  isRef = false
+  isPref = false
+  isVar = false
+  isBag = false
+  isNumber = false
+  isInteger = false
+  isString = false
+  isBoolean = false
+  isConjunct = false
+  isDisjunct = false
+  isJunction = false
+
+  isOp = false
+  isPlusOp = false
+
+  isFunc = false
+  isCloseFunc = false
+  isCopyFunc = false
+  isHideFunc = false
+  isMoveFunc = false
+  isKeyFunc = false
+  isLowerFunc = false
+  isOpenFunc = false
+  isPathFunc = false
+  isPrefFunc = false
+  isSuperFunc = false
+  isTypeFunc = false
+  isUpperFunc = false
+
+  id: number
+  dc: number = 0
+  path: string[] = []
+  site: Site = new Site()
+
+  // Map of boolean flags.
+  mark: ValMark = { type: false, hide: false }
+
+  // Actual native value.
+  peg: any = undefined
+
+  // TODO: used for top level result - not great
+  // err: Omit<any[], "push"> = []
+  err: any[] = []
+  explain: any[] | null = null
+
+  uh: number[]
+
+  deps?: any
+
+  #ctx: any
+
+  // TODO: Site needed in ctor
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    this.#ctx = ctx
+
+    this.peg = spec?.peg
+
+    if (Array.isArray(this.peg)) {
+      let spread = (this.peg as any)[SPREAD]
+      this.peg = this.peg.filter(n => undefined !== n)
+        ; (this.peg as any)[SPREAD] = spread
+    }
+
+    this.path = ctx?.path || []
+
+    // TODO: make this work
+    // this.id = spec?.id ?? (ctx ? ++ctx.vc : ++ID)
+    this.id = ++ID
+
+    this.uh = []
+
+    this.mark.type = !!spec.mark?.type
+    this.mark.hide = !!spec.mark?.hide
+
+    // console.log('BV', this.id, this.constructor.name, this.peg?.canon)
+  }
+
+
+  ctx() {
+    return this.#ctx
+  }
+
+
+  get done() {
+    return this.dc === DONE
+  }
+
+
+  same(peer: Val): boolean {
+    return null == peer ? false : this.id === peer.id
+  }
+
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let cloneCtx
+
+    let cut = this.path.indexOf('&')
+    cut = -1 < cut ? cut + 1 : ctx.path.length
+    cloneCtx = ctx.clone({
+      path: ctx.path.concat(this.path.slice(cut))
+    })
+
+    let fullspec = {
+      peg: this.peg,
+      mark: { type: this.mark.type, hide: this.mark.hide },
+      ...(spec ?? {})
+    }
+
+    let out = new (this as any)
+      .constructor(fullspec, cloneCtx)
+
+    out.site.row = spec?.row ?? this.site.row ?? -1
+    out.site.col = spec?.col ?? this.site.col ?? -1
+    out.site.url = spec?.url ?? this.site.url ?? ''
+
+    // TODO: should not be needed - update all VAL ctors to handle spec.mark
+    out.mark.type = this.mark.type && (fullspec.mark?.type ?? true)
+    out.mark.hide = this.mark.hide && (fullspec.mark?.hide ?? true)
+
+    return out
+  }
+
+
+  place(v: Val) {
+    v.site.row = this.site.row
+    v.site.col = this.site.col
+    v.site.url = this.site.url
+    return v
+  }
+
+  // NOTE: MUST not mutate! Val immutability is a critical assumption.
+  unify(_peer: Val, _ctx: AontuContext): Val { return this }
+
+  // TODO: indicate marks in some way that is ignored by reparse.
+  // Need an annotation/taggins syntax? a:{}/type ?
+  get canon(): string { return '' }
+
+
+  errcanon(): string {
+    return 0 === this.err.length ? '' : `<ERRS:${this.err.length}>`
+  }
+
+
+  gen(_ctx: AontuContext): any {
+    return undefined
+  }
+
+
+  notdone() {
+    this.dc = DONE === this.dc ? DONE : this.dc + 1
+  }
+
+
+  abstract superior(): Val
+
+
+  [inspect.custom](_d: number, _o: any, _inspect: any): string {
+    let s = ['<' + this.constructor.name.replace(/Val$/, '') + '/' + this.id]
+
+    s.push('/' + this.path.join('.') + '/')
+
+    s.push([
+      DONE === this.dc ? 'D' : 'd' + this.dc,
+      ...Object.entries(this.mark).filter(n => n[1]).map(n => n[0]).sort()
+    ].filter(n => null != n).join(','))
+
+    let insp = this.inspection(inspect)
+    if (null != insp && '' != insp) {
+      s.push('/' + insp)
+    }
+
+    s.push('/')
+
+    if ('object' === typeof this.peg) {
+      s.push(inspectpeg(this.peg))
+    }
+    else if ('function' === typeof this.peg) {
+      s.push(this.peg.name)
+    }
+    else {
+      s.push(this.peg)
+    }
+
+    s.push('>')
+
+    const out = s.join('')
+
+    return out
+  }
+
+
+  inspection(_inspect: Function) {
+    return ''
+  }
+
+}
+
+
+function inspectpeg(peg: any) {
+  return pretty(!Array.isArray(peg) ? inspect(peg) :
+    ('[' + peg.map(n => inspect(n)).join(',\n') + ']'))
+}
+
+function pretty(s: string) {
+  return (
+    (String(s))
+      .replace(/\[Object: null prototype\]/g, '')
+      .replace(/\s+/g, '')
+  )
+}
+
+
+function empty(o: any) {
+  return (
+    (Array.isArray(o) && 0 === o.length)
+    || (null != o && 'object' === typeof o && 0 === Object.keys(o).length)
+    || false
+  )
+}
+
+
+
+export type {
+  ValMark,
+  ValSpec,
+}
+
+export {
+  Val,
+  DONE,
+  SPREAD,
+  empty
+}

package/src/val/VarVal.ts

@@ -0,0 +1,171 @@
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
+
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  descErr,
+  makeNilErr,
+  AontuError
+} from '../err'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+
+
+import { StringVal } from './StringVal'
+import { NilVal } from './NilVal'
+import { FeatureVal } from './FeatureVal'
+import { NullVal } from './NullVal'
+import { BooleanVal } from './BooleanVal'
+import { NumberVal } from './NumberVal'
+import { IntegerVal } from './IntegerVal'
+
+
+import {
+  explainOpen,
+  ec,
+  explainClose,
+} from '../utility'
+
+
+// TODO: KEY, SELF, PARENT are reserved names - error
+
+class VarVal extends FeatureVal {
+  isVar = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Var', this, peer)
+
+    let out: Val
+
+    let nameVal
+
+    if (this.peg.isVal) {
+      // $.a.b.c - convert path to absolute
+      // if (this.peg instanceof RefVal) {
+      if (this.peg.isRef) {
+        this.peg.absolute = true
+        nameVal = this.peg
+      }
+      else {
+        nameVal = this.peg.unify(peer, ctx.clone({ explain: ec(te, 'PEG') }))
+      }
+    }
+    else {
+      // TODO: how to pass row+col?
+      nameVal = new StringVal({ peg: '' + this.peg }, ctx)
+    }
+
+    // if (!(nameVal instanceof RefVal) && DONE === nameVal.dc) {
+    if (!(nameVal.isRef) && DONE === nameVal.dc) {
+      if (nameVal instanceof StringVal) {
+        let found = ctx.vars[nameVal.peg]
+        if (undefined === found) {
+          out = makeNilErr(ctx, 'unknown_var', this, peer)
+        }
+
+        // TODO: support complex values
+        const ft = typeof found
+        if (null === found) {
+          out = this.place(new NullVal({ peg: null }))
+        }
+        else if ('string' === ft) {
+          out = new StringVal({ peg: found })
+        }
+        else if ('boolean' === ft) {
+          out = new BooleanVal({ peg: found })
+        }
+        else if ('number' === ft) {
+          out = Number.isInteger(found) ?
+            new IntegerVal({ peg: found }) :
+            new NumberVal({ peg: found })
+        }
+        else if ('object' === ft && found.isVal) {
+          out = found
+        }
+        else {
+          out = makeNilErr(ctx, 'invalid_var_kind', this, peer)
+        }
+      }
+      else {
+        out = makeNilErr(ctx, 'var[' + typeof nameVal + ']', this, peer)
+      }
+    }
+    else {
+      out = nameVal
+    }
+
+    explainClose(te, out)
+
+    return out
+  }
+
+
+  same(peer: Val): boolean {
+    return null == peer ? false : peer instanceof VarVal && this.peg === peer.peg
+  }
+
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    let out = (super.clone(ctx, spec) as VarVal)
+    return out
+  }
+
+
+  get canon() {
+    return '$' + (this.peg?.isVal ? this.peg.canon : '' + this.peg)
+  }
+
+
+  gen(ctx?: AontuContext) {
+    // Unresolved var cannot be generated, so always an error.
+    let nil = makeNilErr(
+      ctx,
+      'var',
+      this,
+      undefined
+    )
+
+    // TODO: refactor to use Site
+    nil.path = this.path
+    nil.site.url = this.site.url
+    nil.site.row = this.site.row
+    nil.site.col = this.site.col
+
+    descErr(nil, ctx)
+
+    if (ctx) {
+      // ctx.err.push(nil)
+      ctx.adderr(nil)
+    }
+    else {
+      throw new AontuError(nil.msg)
+    }
+
+    return undefined
+  }
+}
+
+
+export {
+  VarVal,
+}

package/src/val/top.ts

@@ -0,0 +1,12 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+
+import { TopVal } from './TopVal'
+
+const TOP = new TopVal({})
+
+
+export function top(): TopVal {
+  return TOP
+}
+

package/src/val/valutil.ts

@@ -0,0 +1,31 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+import { AontuError } from '../err'
+import { ScalarVal } from './ScalarVal'
+import { NumberVal } from './NumberVal'
+import { StringVal } from './StringVal'
+import { BooleanVal } from './BooleanVal'
+import { NullVal } from './NullVal'
+
+
+// TODO: move to FuncBaseVal
+export function makeScalar(scalar: any): ScalarVal {
+  const st = typeof scalar
+  const spec = { peg: scalar }
+
+  if ('number' === st) {
+    return new NumberVal(spec)
+  }
+  else if ('string' === st) {
+    return new StringVal(spec)
+  }
+  else if ('boolean' === st) {
+    return new BooleanVal(spec)
+  }
+  else if (null === scalar) {
+    return new NullVal(spec)
+  }
+  else {
+    throw new AontuError('Not a scalar: ' + scalar)
+  }
+}