aontu 0.30.1 → 0.31.0

package/src/site.ts

@@ -0,0 +1,34 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+} from './type'
+
+
+class Site {
+  row: number = -1
+  col: number = -1
+  url: string = ''
+
+  constructor(val?: Val | { row?: number, col?: number, url?: string }) {
+    if (val) {
+      if ('site' in val) {
+        // Val with site property
+        this.row = val.site?.row ?? -1
+        this.col = val.site?.col ?? -1
+        this.url = val.site?.url ?? ''
+      } else {
+        // Plain object with row, col, url
+        this.row = val.row ?? -1
+        this.col = val.col ?? -1
+        this.url = val.url ?? ''
+      }
+    }
+  }
+}
+
+
+export {
+  Site,
+}

package/src/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "module": "nodenext",
+    "noEmitOnError": true,
+    "outDir":"../dist",
+    "rootDir":".",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2021",
+    "declaration": true,
+    "declarationDir": "../dist"
+  }
+}
+

package/src/type.ts

@@ -0,0 +1,72 @@
+/* Copyright (c) 2022-2025 Richard Rodger, MIT License */
+
+import * as Fs from 'node:fs'
+
+// TODO: refactor these out
+
+import { Resolver } from '@jsonic/multisource'
+
+import { AontuContext } from './ctx'
+import { Val, DONE, SPREAD } from './val/Val'
+import type { ValMark, ValSpec } from './val/Val'
+
+
+type FST = typeof Fs
+
+
+
+type AontuOptions = {
+  src?: string    // Source text.
+  print?: number  // Print debug verbosity
+  resolver?: Resolver // Source resolver
+  base?: string // Base path for resolver
+  path?: string // Path of entry file
+  debug?: boolean
+  trace?: boolean
+  fs?: FST
+  deps?: any
+  log?: any
+  idcount?: number
+  collect?: boolean // Collect errors into an errs property, rather than throw them.
+  err?: any[]
+  explain?: any[]
+}
+
+
+const DEFAULT_OPTS: () => AontuOptions = () => {
+  return {
+    print: -1,
+    debug: false,
+    trace: false,
+  }
+}
+
+
+type ValMap = { [key: string]: Val }
+type ValList = Val[]
+
+
+
+type ErrContext = {
+  src?: string,
+  fs?: FST
+}
+
+export type {
+  Val,
+  ValMark,
+  ValSpec,
+  ValMap,
+  ValList,
+  AontuOptions,
+  ErrContext,
+  FST,
+}
+
+export {
+  DONE,
+  SPREAD,
+  DEFAULT_OPTS,
+  Resolver,
+}
+

package/src/unify.ts

@@ -0,0 +1,233 @@
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
+
+
+import type { Val } from './type'
+
+import { AontuContext } from './ctx'
+
+import { DONE } from './type'
+
+import { makeNilErr } from './err'
+
+import { NilVal } from './val/NilVal'
+
+import {
+  Lang
+} from './lang'
+
+
+import {
+  explainOpen, ec, explainClose,
+} from './utility'
+
+
+import {
+  top
+} from './val/top'
+
+
+// TODO: relation to unify loops?
+const MAXCYCLE = 9
+
+let uc = 0
+
+// Vals should only have to unify downwards (in .unify) over Vals they understand.
+// and for complex Vals, TOP, which means self unify if not yet done
+const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
+  const te = ctx.explain && explainOpen(ctx, ctx.explain, 'unite', a, b)
+
+  let out = a
+  let why = 'u'
+
+  const saw =
+    (a ? a.id + (a.done ? '' : '*') : '') + '~' + (b ? b.id + (b.done ? '' : '*') : '') +
+    '@' + ctx.pathstr
+
+
+  /*
+  if (1 < ctx.seen[saw]) {
+    console.log('UNITE-SAW', ctx.cc, saw, ctx.seen[saw], 1 < ctx.seen[saw] ? (a?.canon + ' ~ ' + b?.canon) : '')
+    // console.trace()
+    // process.exit()
+  }
+  */
+
+  // NOTE: if this error occurs "unreasonably", attemp to avoid unnecesary unification
+  // See for example PrefVal peg.id equality inspection.
+  if (MAXCYCLE < ctx.seen[saw]) {
+    // console.log('SAW', ctx.seen[saw], saw, a?.id, a?.canon, b?.id, b?.canon, ctx.cc)
+    out = makeNilErr(ctx, 'unify_cycle', a, b)
+  }
+  else {
+    ctx.seen[saw] = 1 + (ctx.seen[saw] ?? 0)
+
+    try {
+
+      let unified = false
+
+      if (b && (!a || a.isTop)) {
+        out = b
+        why = 'b'
+      }
+
+      else if (a && (!b || b.isTop)) {
+        out = a
+        why = 'a'
+      }
+
+      else if (a && b && !b.isTop) {
+        if (a.isNil) {
+          out = update(a, b)
+          why = 'an'
+        }
+        else if (b.isNil) {
+          out = update(b, a)
+          why = 'bn'
+        }
+        else if (a.isConjunct) {
+          out = a.unify(b, ctx.clone({ explain: ec(te, 'CJ') }))
+          unified = true
+          why = 'acj'
+        }
+        else if (
+          b.isConjunct
+          || b.isDisjunct
+          || b.isRef
+          || b.isPref
+          || b.isFunc
+        ) {
+
+          out = b.unify(a, ctx.clone({ explain: ec(te, 'BW') }))
+          unified = true
+          why = 'bv'
+        }
+
+        // Exactly equal scalars.
+        else if (a.constructor === b.constructor && a.peg === b.peg) {
+          out = update(a, b)
+          why = 'up'
+        }
+
+        else {
+          out = a.unify(b, ctx.clone({ explain: ec(te, 'GN') }))
+          unified = true
+          why = 'ab'
+        }
+      }
+
+      if (!out || !out.unify) {
+        out = makeNilErr(ctx, 'unite', a, b, whence + '/nil')
+        why += 'N'
+      }
+
+      // console.log('UNITE-DONE', out.id, out.canon, out.done)
+
+      // if (DONE !== out.dc && !unified) {
+      if (!out.done && !unified) {
+        let nout = out.unify(top(), ctx.clone({ explain: ec(te, 'ND') }))
+        out = nout
+        why += 'T'
+      }
+
+      // console.log('UNITE', why, a?.id, a?.canon, a?.done, b?.id, b?.canon, b?.done, '->', out?.id, out?.canon, out?.done)
+
+      uc++
+    }
+    catch (err: any) {
+      // console.log(err)
+      // TODO: handle unexpected
+      out = makeNilErr(ctx, 'internal', a, b)
+    }
+  }
+
+  ctx.explain && explainClose(te, out)
+
+  return out
+}
+
+
+function update(x: Val, _y: Val) {
+  // TODO: update x with y.site
+  return x
+}
+
+
+class Unify {
+  root: Val
+  res: Val
+  // err: Omit<NilVal[], "push">
+  err: any[]
+  explain: any[] | null
+  cc: number
+  lang: Lang
+
+  constructor(root: Val | string, lang?: Lang, ctx?: AontuContext | any, src?: any) {
+    this.lang = lang || new Lang()
+    if ('string' === typeof root) {
+      root = this.lang.parse(root)
+    }
+
+    if ('string' !== typeof src) {
+      src = ''
+    }
+
+    this.cc = 0
+    this.root = root
+    this.res = root
+    this.err = ctx?.err ?? root.err ?? []
+    this.explain = ctx?.explain ?? root.explain ?? null
+
+    let res = root
+    let uctx: AontuContext
+
+    // Only unify if no syntax errors
+    if (!(root as NilVal).isNil) {
+      if (ctx instanceof AontuContext) {
+        uctx = ctx
+      }
+      else {
+        uctx = new AontuContext({
+          ...(ctx || {}),
+          root: res,
+          err: this.err,
+          explain: this.explain,
+          src,
+        })
+      }
+
+      // TODO: messy
+      // uctx.seterr(this.err)
+      uctx.err = this.err
+      uctx.explain = this.explain
+
+      const explain = null == ctx?.explain ? undefined : ctx?.explain
+      const te = explain && explainOpen(uctx, explain, 'root', res)
+
+      // NOTE: if true === res.done already, then this loop never needs to run.
+      let maxcc = 9 // 99
+      for (; this.cc < maxcc && DONE !== res.dc; this.cc++) {
+        // console.log('CC', this.cc, res.canon)
+        uctx.cc = this.cc
+        res = unite(uctx.clone({ explain: ec(te, 'run') }), res, top(), 'unify')
+
+        if (0 < uctx.err.length) {
+          break
+        }
+
+        uctx = uctx.clone({ root: res })
+      }
+
+      uctx.explain && explainClose(te, res)
+    }
+
+    this.res = res
+  }
+}
+
+
+
+
+export {
+  Unify,
+  unite,
+}

package/src/utility.ts

@@ -0,0 +1,185 @@
+/* Copyright (c) 2023-2025 Richard Rodger, MIT License */
+
+
+
+import type { Val } from './type'
+
+
+// Mark value in source is propagated to target (true ratchets).
+function propagateMarks(source: Val, target: Val): void {
+  for (let name in source.mark) {
+    (target.mark as any)[name] = (target.mark as any)[name] || (source.mark as any)[name]
+  }
+}
+
+
+function formatPath(path: Val | string[], absolute?: boolean) {
+  let parts: string[]
+  if (Array.isArray(path)) {
+    parts = path
+  }
+  else {
+    parts = path.path
+  }
+
+  let pathstr = (0 < parts.length && false !== absolute ? '$.' : '') + parts.join('.')
+
+  return pathstr
+}
+
+
+type WalkApply = (
+  key: string | number | undefined,
+  val: Val,
+  parent: Val | undefined,
+  path: (string | number)[]
+) => Val
+
+/**
+ * Walk a Val structure depth first, applying functions before and after descending.
+ * Only traverses Val instances - stops at non-Val children.
+ */
+function walk(
+  // These arguments are the public interface.
+  val: Val,
+
+  // Before descending into a node.
+  before?: WalkApply,
+
+  // After descending into a node.
+  after?: WalkApply,
+
+  // Maximum recursive depth, default: 32. Use null for infinite depth.
+  maxdepth?: number | null,
+
+  // These arguments are used for recursive state.
+  key?: string | number,
+  parent?: Val,
+  path?: (string | number)[]
+): Val {
+  let out = null == before ? val : before(key, val, parent, path || [])
+
+  maxdepth = null != maxdepth && 0 <= maxdepth ? maxdepth : 32
+  if (null != maxdepth && 0 === maxdepth) {
+    return out
+  }
+  if (null != path && null != maxdepth && 0 < maxdepth && maxdepth <= path.length) {
+    return out
+  }
+
+  const child: any = out.peg
+
+  // Container Vals (Map etc) have peg = plain {} or []
+  if (null != child && !child.isVal) {
+    if ('object' === typeof child) {
+      for (let ckey in child) {
+        if (child[ckey] && child[ckey].isVal) {
+          child[ckey] = walk(
+            child[ckey], before, after, maxdepth, ckey, out, [...(path || []), ckey])
+        }
+      }
+    }
+    else if (Array.isArray(child)) {
+      for (let i = 0; i < child.length; i++) {
+        if (child[i] && child[i].isVal) {
+          child[i] = walk(
+            child[i], before, after, maxdepth, i, out, [...(path || []), '' + i])
+        }
+      }
+    }
+  }
+
+  out = null == after ? out : after(key, out, parent, path || [])
+
+  return out
+}
+
+
+const T_NOTE = 0
+const T_WHY = 1
+const T_PATH = 2
+const T_AVAL = 3
+const T_BVAL = 4
+const T_OVAL = 5
+const T_CHILDREN = 6
+
+
+function explainOpen(
+  ctx: any,
+  t: any[] | undefined | null | false,
+  note: string,
+  ac?: Val,
+  bc?: Val
+): any[] | null {
+  if (false === t) return null;
+
+  t = t ?? [null, 'root', null, null, null, null]
+  t[T_WHY] = t[T_WHY] ?? ''
+  t[T_NOTE] = (0 <= ctx.cc ? ctx.cc + '~' : '') + note
+  t[T_PATH] = ['$', ctx.path.join('.')].filter(p => '' != p).join('.') + '  '
+  if (ac) {
+    t[T_AVAL] = ac.id + (ac.done ? '' : '!') + '=' + ac.canon
+  }
+  if (bc) {
+    t[T_BVAL] = bc.id + (bc.done ? '' : '!') + '=' + bc.canon
+  }
+
+  return t
+}
+
+
+function ec(t: any[] | undefined | null, why: string) {
+  if (null == t) return;
+
+  const child = [null, why, null, null, null, null]
+  t[T_CHILDREN] = t[T_CHILDREN] ?? []
+  t[T_CHILDREN].push(child)
+  return child
+}
+
+
+function explainClose(t: any[] | undefined | null, out?: Val) {
+  if (null == t) return;
+
+  if (out) {
+    t[T_OVAL] = '-> ' + out.id + (out.done ? '' : '!') + '=' + out.canon
+  }
+}
+
+
+function formatExplain(t: any[], d?: number) {
+  d = null == d ? 0 : d
+  const indent = ('  '.repeat(d))
+
+  if (Array.isArray(t)) {
+    const b = [
+      indent + t.slice(0, t.length - 1).join(' ')
+    ]
+
+    const children = t[t.length - 1]
+    if (Array.isArray(children)) {
+      for (let ce of children) {
+        b.push(formatExplain(ce, d + 1))
+      }
+    }
+
+    return b.join('\n')
+  }
+  else {
+    return indent + t
+  }
+}
+
+
+
+export {
+  propagateMarks,
+  formatPath,
+  walk,
+  WalkApply,
+  explainOpen,
+  ec,
+  explainClose,
+  formatExplain,
+}
+

package/src/val/BagVal.ts

@@ -0,0 +1,33 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+
+import { FeatureVal } from './FeatureVal'
+
+
+abstract class BagVal extends FeatureVal {
+  isBag = true
+
+  closed: boolean = false
+  optionalKeys: string[] = []
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+  }
+}
+
+
+export {
+  BagVal,
+}

package/src/val/BooleanVal.ts

@@ -0,0 +1,32 @@
+/* Copyright (c) 2021-2023 Richard Rodger, MIT License */
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { ScalarVal } from './ScalarVal'
+
+class BooleanVal extends ScalarVal {
+  isBoolean = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super({ peg: spec.peg, kind: Boolean }, ctx)
+  }
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    return super.unify(peer, ctx)
+  }
+}
+
+
+export {
+  BooleanVal,
+}

package/src/val/CloseFuncVal.ts

@@ -0,0 +1,61 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+
+import { FuncBaseVal } from './FuncBaseVal'
+import { BagVal } from '../val/BagVal'
+
+
+class CloseFuncVal extends FuncBaseVal {
+  isCloseFunc = true
+
+  constructor(
+    spec: ValSpec,
+    ctx?: AontuContext
+  ) {
+    super(spec, ctx)
+    this.validateArgs(spec.peg, 1)
+  }
+
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new CloseFuncVal(spec)
+  }
+
+  funcname() {
+    return 'close'
+  }
+
+
+  resolve(ctx: AontuContext, args: Val[]) {
+    const argval: any = args[0]
+
+    if (null == argval) {
+      return makeNilErr(ctx, 'no_first_arg', this, undefined, 'close')
+    }
+
+    if (argval.isMap || argval.isList) {
+      (argval as BagVal).closed = true
+      // console.log('CLOSED', argval.canon)
+    }
+
+    return argval
+  }
+
+}
+
+
+export {
+  CloseFuncVal,
+}