aontu 0.1.1 → 0.3.0

package/lib/val.ts

@@ -37,9 +37,10 @@ import {
 
 
 type ValMap = { [key: string]: Val }
+type ValList = Val[]
 
-const DONE = -1
 
+const DONE = -1
 
 
 // There can be only one.
@@ -55,21 +56,6 @@ const TOP: Val = {
 
   unify(peer: Val, _ctx: Context): Val {
     return peer
-
-    /*
-    if (peer instanceof DisjunctVal) {
-      return peer.unify(this, ctx)
-    }
-    else if (peer instanceof ConjunctVal) {
-      return peer.unify(this, ctx)
-    }
-    else if (peer instanceof RefVal) {
-      return peer.unify(this, ctx)
-    }
-    else {
-      return peer
-    }
-    */
   },
 
   get canon() { return 'top' },
@@ -261,6 +247,7 @@ class ScalarVal<T> extends Val {
     this.done = DONE
   }
   unify(peer: Val, ctx: Context): Val {
+    // Exactly equal scalars are handled in op/unite
     if (peer instanceof ScalarTypeVal) {
       return peer.unify(this, ctx)
     }
@@ -518,6 +505,118 @@ class MapVal extends Val {
 }
 
 
+
+class ListVal extends Val {
+  static SPREAD = Symbol('spread')
+
+  spread = {
+    cj: (undefined as Val | undefined),
+  }
+
+  constructor(peg: ValList, ctx?: Context) {
+    super(peg, ctx)
+
+    let spread = (this.peg as any)[ListVal.SPREAD]
+    delete (this.peg as any)[ListVal.SPREAD]
+
+    if (spread) {
+      if ('&' === spread.o) {
+        // TODO: handle existing spread!
+        this.spread.cj =
+          new ConjunctVal(Array.isArray(spread.v) ? spread.v : [spread.v], ctx)
+      }
+    }
+  }
+
+  // NOTE: order of keys is not preserved!
+  // not possible in any case - consider {a,b} unify {b,a}
+  unify(peer: Val, ctx: Context): Val {
+    let done: boolean = true
+    let out: ListVal = TOP === peer ? this : new ListVal([], ctx)
+
+    out.spread.cj = this.spread.cj
+
+    if (peer instanceof ListVal) {
+      out.spread.cj = null == out.spread.cj ? peer.spread.cj : (
+        null == peer.spread.cj ? out.spread.cj : (
+          out.spread.cj = new ConjunctVal([out.spread.cj, peer.spread.cj], ctx)
+        )
+      )
+    }
+
+
+    out.done = this.done + 1
+
+    if (this.spread.cj) {
+      out.spread.cj =
+        DONE !== this.spread.cj.done ? unite(ctx, this.spread.cj) :
+          this.spread.cj
+    }
+
+    let spread_cj = out.spread.cj || TOP
+
+    // Always unify children first
+    for (let key in this.peg) {
+      out.peg[key] =
+        unite(ctx.descend(key), this.peg[key], spread_cj)
+
+      done = (done && DONE === out.peg[key].done)
+    }
+
+    if (peer instanceof ListVal) {
+      let upeer: ListVal = (unite(ctx, peer) as ListVal)
+
+      for (let peerkey in upeer.peg) {
+        let peerchild = upeer.peg[peerkey]
+        let child = out.peg[peerkey]
+
+        let oval = out.peg[peerkey] =
+          undefined === child ? peerchild :
+            child instanceof Nil ? child :
+              peerchild instanceof Nil ? peerchild :
+                unite(ctx.descend(peerkey), child, peerchild)
+
+        if (this.spread.cj) {
+          out.peg[peerkey] = unite(ctx, out.peg[peerkey], spread_cj)
+        }
+
+        done = (done && DONE === oval.done)
+
+      }
+    }
+    else if (TOP !== peer) {
+      return Nil.make(ctx, 'map', this, peer)
+    }
+
+    out.done = done ? DONE : out.done
+    return out
+  }
+
+  get canon() {
+    let keys = Object.keys(this.peg)
+    return '[' +
+      (this.spread.cj ? '&:' + this.spread.cj.canon +
+        (0 < keys.length ? ',' : '') : '') +
+      keys
+        // NOTE: handle array non-index key vals
+        // .map(k => [JSON.stringify(k) + ':' + this.peg[k].canon]).join(',') +
+        .map(k => [this.peg[k].canon]).join(',') +
+      ']'
+  }
+
+  gen(ctx?: Context) {
+    let out: any = this.peg.map((v: Val) => v.gen(ctx))
+    // for (let p in this.peg) {
+    //   out[p] = this.peg[p].gen(ctx)
+    // }
+
+    return out
+  }
+}
+
+
+
+
 // TODO: move main logic to op/conjunct
 class ConjunctVal extends Val {
   constructor(peg: Val[], ctx?: Context) {
@@ -750,23 +849,13 @@ class DisjunctVal extends Val {
 class RefVal extends Val {
   parts: string[]
   absolute: boolean
-  sep = '.' // was '/'
-
-  // constructor(peg: string | string[], ctx?: Context) {
-  //   super(peg, ctx)
-  //   this.parts = 'string' === typeof peg ? peg.split(this.sep) : peg
-  //   this.parts = this.parts.filter(p => '' != p)
-  //   // this.absolute = peg.startsWith(this.sep)
-  // }
-
+  sep = '.'
 
   constructor(peg: any[], abs?: boolean) {
     super('')
     this.absolute = true === abs
     this.parts = []
 
-    // console.log('RV', peg)
-
     for (let part of peg) {
       this.append(part)
     }
@@ -793,8 +882,6 @@ class RefVal extends Val {
     }
 
     this.peg = (this.absolute ? this.sep : '') + this.parts.join(this.sep)
-
-    // console.log('APPEND 1', this.parts)
   }
 
   unify(peer: Val, ctx: Context): Val {
@@ -805,12 +892,9 @@ class RefVal extends Val {
       Nil.make(ctx, 'no-path', this, peer) : (resolved || this)
     let out: Val
 
-    // console.log('RV', this.id, this.done, this.canon, peer.canon, !!resolved, resolved instanceof RefVal, resolved && resolved.canon)
-
     if (resolved instanceof RefVal) {
       if (TOP === peer) {
         out = this
-        //out = new RefVal(this.peg, ctx)
       }
       else if (peer instanceof Nil) {
         out = Nil.make(ctx, 'ref[' + this.peg + ']', this, peer)
@@ -822,9 +906,6 @@ class RefVal extends Val {
       }
     }
     else {
-      //console.log('RVr', resolved.canon, peer.canon)
-
-      //out = resolved.unify(peer, ctx)
       out = unite(ctx, resolved, peer)
     }
 
@@ -833,17 +914,18 @@ class RefVal extends Val {
     return out
   }
 
+
   get canon() {
     return this.peg
   }
 
+
   gen(_ctx?: Context) {
     return undefined
   }
 }
 
 
-
 class PrefVal extends Val {
   pref: Val
   constructor(peg: any, pref?: any, ctx?: Context) {
@@ -852,42 +934,28 @@ class PrefVal extends Val {
   }
 
   // PrefVal unify always returns a PrefVal
-  // PrevVals can only be removed by becoming Nil in a Disjunct
+  // PrefVals can only be removed by becoming Nil in a Disjunct
   unify(peer: Val, ctx: Context): Val {
     let done = true
-
-    //let peer_peg = peer instanceof PrefVal ? peer.peg : peer
-    //let peer_pref = peer instanceof PrefVal ? peer.pref : peer
-
     let out: Val
-    /*
-          = new PrefVal(
-          this.peg.unify(peer_peg, ctx),
-          this.pref.unify(peer_pref, ctx),
-          ctx
-        )
-    */
 
     if (peer instanceof PrefVal) {
       out = new PrefVal(
-        //this.peg.unify(peer.peg, ctx),
-        //this.pref.unify(peer.pref, ctx),
-        unite(ctx, this.peg, peer.peg),
-        unite(ctx, this.pref, peer.pref),
+        unite(ctx, this.peg, peer.peg, 'Pref000'),
+        unite(ctx, this.pref, peer.pref, 'Pref010'),
         ctx
       )
+
     }
     else {
       out = new PrefVal(
-        //this.peg.unify(peer, ctx),
-        //this.pref.unify(peer, ctx),
-        unite(ctx, this.peg, peer),
-        unite(ctx, this.pref, peer),
+        // TODO: find a better way to drop Nil non-errors
+        unite(ctx?.clone({ err: [] }), this.peg, peer, 'Pref020'),
+        unite(ctx?.clone({ err: [] }), this.pref, peer, 'Pref030'),
         ctx
       )
     }
 
-
     done = done && DONE === out.peg.done &&
       (null != (out as PrefVal).pref ? DONE === (out as PrefVal).pref.done : true)
 
@@ -917,6 +985,7 @@ class PrefVal extends Val {
 }
 
 
+
 export {
   DONE,
   Integer,
@@ -929,6 +998,7 @@ export {
   BooleanVal,
   IntegerVal,
   MapVal,
+  ListVal,
   ConjunctVal,
   DisjunctVal,
   RefVal,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aontu",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "main": "dist/aontu.js",
   "type": "commonjs",
   "browser": "dist/aontu.min.js",
@@ -39,22 +39,23 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@jsonic/directive": "^0.5.0",
-    "@jsonic/expr": "^0.1.1",
-    "@jsonic/multisource": "0.4.0",
-    "@types/node": "^17.0.35",
-    "jsonic": "jsonicjs/jsonic#nextgen"
+    "@jsonic/directive": "^0.7.0",
+    "@jsonic/expr": "^0.4.1",
+    "@jsonic/jsonic-next": "2.1.0",
+    "@jsonic/multisource": "0.6.0",
+    "@jsonic/path": "^0.1.0",
+    "@types/node": "^18.0.0"
   },
   "devDependencies": {
-    "@hapi/code": "^8.0.7",
-    "@hapi/lab": "^24.5.1",
+    "@hapi/code": "^9.0.1",
+    "@hapi/lab": "^25.0.1",
     "benchmark": "^2.1.4",
     "coveralls": "^3.1.1",
     "hapi-lab-shim": "0.0.2",
     "lab-transform-typescript": "^3.0.1",
-    "prettier": "^2.6.2",
+    "prettier": "^2.7.1",
     "serve": "^13.0.2",
     "tinyify": "^3.0.0",
-    "typescript": "^4.7.2"
+    "typescript": "^4.7.3"
   }
 }