pacc 8.3.1 → 8.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "8.3.1",
+  "version": "8.4.1",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -39,7 +39,7 @@
   },
   "devDependencies": {
     "ava": "^6.4.1",
-    "browser-ava": "^2.3.51",
+    "browser-ava": "^2.3.52",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",
     "semantic-release": "^25.0.3",

package/src/ast.mjs

@@ -30,7 +30,7 @@ function binopError(op, left, right) {
 }
 
 export function binop(op, left, right, fallback) {
-  if(op.binop) { return op.binop(left,right); }
+  if(op.led) { return op.led(left,right); }
 
   return fallback(op, left, right);
 }

package/src/expression.mjs

@@ -11,15 +11,7 @@ import {
 } from "./tokens.mjs";
 import { pathEval, functionEval, ASTTrue, ASTBinop } from "./ast.mjs";
 
-/**
- *
- * @param {string} message
- */
-export function error(message) {
-  throw new Error(message);
-}
-
-export function parse(input, context = {}) {
+export function parseOnly(input, context = {}) {
   context.getGlobal ||= a => globals[a];
 
   input = tokens(input, context);
@@ -40,55 +32,51 @@ export function parse(input, context = {}) {
 
   const expect = expected => {
     if (token !== expected) {
-      error(`unexpected '${token?.str || token}' expecting '${expected.str}'`);
+      throw new Error(
+        `unexpected '${token?.str || token}' expecting '${expected.str}'`,
+        { cause: token }
+      );
     }
     advance();
   };
 
   const nud = (last, left) => {
-    switch (last.type) {
-      case "prefix":
-        switch (last) {
-          case OPEN_ROUND: {
-            const node = expression(0);
-            expect(CLOSE_ROUND);
-            return node;
-          }
-          case OPEN_BRACKET: {
-            if (token === CLOSE_BRACKET) {
-              advance();
-              return ASTTrue;
-            }
-
-            const node = expression(0);
-            expect(CLOSE_BRACKET);
-            switch (typeof node) {
-              case "string":
-              case "number":
-                return { eval: pathEval, path: [node] };
-            }
-
-            return node;
-          }
+    switch (last) {
+      case OPEN_ROUND: {
+        const node = expression(0);
+        expect(CLOSE_ROUND);
+        return node;
+      }
+      case OPEN_BRACKET: {
+        if (token === CLOSE_BRACKET) {
+          advance();
+          return ASTTrue;
         }
-        return { token: last, left, right: expression(last.precedence) };
-      case "eof":
-        error("unexpected EOF");
-    }
 
-    switch (typeof last) {
-      case "string":
-      case "number":
-      case "bigint":
-      case "boolean":
-        return last;
+        const node = expression(0);
+        expect(CLOSE_BRACKET);
+
+        switch (typeof node) {
+          case "string":
+          case "number":
+            return { eval: pathEval, path: [node] };
+        }
+
+        return node;
+      }
+
+      case IDENTIFIER:
+        return { eval: pathEval, path: [value] };
+
+      case EOF:
+        throw new Error("unexpected EOF");
     }
 
-    if (last === IDENTIFIER) {
-      return { eval: pathEval, path: [value] };
+    if (last.type === "prefix") {
+      return { token: last, left, right: expression(last.precedence) };
     }
 
-    return { token: last };
+    return last;
   };
 
   const led = (last, left) => {
@@ -100,50 +88,40 @@ export function parse(input, context = {}) {
         const right = expression(last.precedence);
 
         if (last === DOT) {
-          if (left.path) {
-            left.path.push(...right.path);
-            return left;
-          }
-
-          if (left.eval) {
-            right.path.unshift(left);
-            return right;
-          }
-
-          return { eval: pathEval, path: [left.token, right.token] };
+          return last.led(left, right);
         }
 
         return ASTBinop(last, left, right);
       }
-      case "prefix":
-        switch (last) {
-          case OPEN_ROUND: {
-            const args = [];
-            while (token !== CLOSE_ROUND) {
-              args.push(expression(0));
-              if (token === COMMA) {
-                advance();
-              }
-            }
-            left.args = args;
-            left.eval = functionEval;
+    }
 
+    switch (last) {
+      case OPEN_ROUND: {
+        const args = [];
+        while (token !== CLOSE_ROUND) {
+          args.push(expression(0));
+          if (token === COMMA) {
             advance();
-
-            return left;
-          }
-          case OPEN_BRACKET: {
-            if (token === CLOSE_BRACKET) {
-              advance();
-              left.path.push(ASTTrue);
-            } else {
-              const predicate = expression(0);
-              expect(CLOSE_BRACKET);
-              left.path.push(predicate);
-            }
-            return left;
           }
         }
+        left.args = args;
+        left.eval = functionEval;
+
+        advance();
+
+        return left;
+      }
+      case OPEN_BRACKET: {
+        if (token === CLOSE_BRACKET) {
+          advance();
+          left.path.push(ASTTrue);
+        } else {
+          const predicate = expression(0);
+          expect(CLOSE_BRACKET);
+          left.path.push(predicate);
+        }
+        return left;
+      }
     }
 
     return { token };
@@ -165,17 +143,12 @@ export function parse(input, context = {}) {
 
   advance();
 
-  let result = expression(token.precedence ?? 0);
-
-  if (context.exec !== false && result?.eval) {
-    result = result.eval(result, context.root, context);
-
-    /*if (typeof result === "function") {
-      return [...result()];
-    }*/
-  }
+  return expression(token.precedence ?? 0);
+}
 
-  return result;
+export function parse(input, context) {
+  const result = parseOnly(input, context);
+  return result.eval ? result.eval(result, context.root, context) : result;
 }
 
 export const globals = {

package/src/settergetter.mjs

@@ -16,7 +16,7 @@ import {
   STAR,
   IDENTIFIER
 } from "./tokens.mjs";
-import { parse } from "./expression.mjs";
+import { parseOnly } from "./expression.mjs";
 import { toInternal } from "./attributes.mjs";
 
 /**
@@ -28,7 +28,7 @@ import { toInternal } from "./attributes.mjs";
  * @param {Object} definition type def
  */
 export function setAttribute(object, expression, value, definition) {
-  const { path } = parse(expression, { exec: false });
+  const { path } = parseOnly(expression);
 
   let anchor, anchorKey;
 
@@ -61,7 +61,7 @@ export function setAttribute(object, expression, value, definition) {
  * @returns {any} value associated with the given property name
  */
 export function getAttribute(object, expression, definition) {
-  const { path } = parse(expression, { exec: false });
+  const { path } = parseOnly(expression);
 
   for (const key of path) {
     if (object !== undefined) {

package/src/tokens.mjs

@@ -13,12 +13,13 @@ const lookup = {};
  * @param {string} str
  * @param {number} [precedence]
  * @param {string} [type]
+ * @param {Function} [led]
  * @returns {Token}
  */
-function createToken(str, precedence = 0, type, binop) {
+function createToken(str, precedence = 0, type, led) {
   const token = { str, precedence, type };
-  if (binop) {
-    token.binop = binop;
+  if (led) {
+    token.led = led;
   }
   lookup[str] = [token];
   return token;
@@ -95,7 +96,20 @@ export /** @type {Token} */ const QUESTION = createToken("?", 20, "infix");
 export /** @type {Token} */ const COLON = createToken(":", undefined, "infix");
 export /** @type {Token} */ const SEMICOLON = createToken(";");
 export /** @type {Token} */ const COMMA = createToken(",");
-export /** @type {Token} */ const DOT = createToken(".", 80, "infix");
+export /** @type {Token} */ const DOT = createToken(
+  ".",
+  80,
+  "infix",
+  (left, right) => {
+    if (left.path) {
+      right.path.unshift(...left.path);
+    } else {
+      console.log("DOT",right);
+      right.path.unshift(left);
+    }
+    return right;
+  }
+);
 export /** @type {Token} */ const AMPERSAND = createToken("&");
 export /** @type {Token} */ const DOUBLE_AMPERSAND = createToken(
   "&&",

package/types/expression.d.mts

@@ -1,9 +1,5 @@
-/**
- *
- * @param {string} message
- */
-export function error(message: string): void;
-export function parse(input: any, context?: {}): any;
+export function parseOnly(input: any, context?: {}): any;
+export function parse(input: any, context: any): any;
 export namespace globals {
     export function _in(a: any, b: any): boolean;
     export { _in as in };