pacc 8.9.3 → 8.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "8.9.3",
+  "version": "8.10.0",
   "publishConfig": {
     "access": "public",
     "provenance": true

package/src/ast.mjs

@@ -1,48 +1,23 @@
+import {
+  DOUBLE_BAR,
+  DOUBLE_AMPERSAND,
+  EQUAL,
+  NOT_EQUAL,
+  LESS,
+  LESS_EQUAL,
+  GREATER,
+  GREATER_EQUAL,
+  STAR,
+  DIVIDE,
+  PLUS,
+  MINUS
+} from "./tokens.mjs";
+
 /**
  * @typedef {Object} AST
  * @property {Function} [eval]
  */
 
-/**
- *
- * @param {Token} token
- * @param {AST} left
- * @param {AST} right
- *
- */
-function binopError(token, left, right) {
-  throw new Error(`Unexpected '${token.str || token}'`, { cause: token });
-}
-
-export function binop(token, left, right, fallback) {
-  if(token.led) { return token.led(left,right); }
-
-  return fallback(token, left, right);
-}
-
-function binopEval(node, current, context) {
-  return binop(
-    node.token,
-    node.left.eval ? node.left.eval(node.left, current, context) : node.left,
-    node.right.eval
-      ? node.right.eval(node.right, current, context)
-      : node.right,
-    binopError
-  );
-}
-
-export function ASTBinop(token, left, right) {
-  if (!left.eval && !right.eval) {
-    return binop(token, left, right, binopError);
-  }
-
-  return {
-    eval: binopEval,
-    token,
-    left,
-    right
-  };
-}
 
 export function pathEval(node, current, context) {
   let collection = false;

package/src/expression.mjs

@@ -1,15 +1,4 @@
-import {
-  tokens,
-  DOT,
-  OPEN_ROUND,
-  CLOSE_ROUND,
-  OPEN_BRACKET,
-  CLOSE_BRACKET,
-  IDENTIFIER,
-  COMMA,
-  EOF
-} from "./tokens.mjs";
-import { pathEval, functionEval, ASTTrue, ASTBinop } from "./ast.mjs";
+import { tokens, EOF } from "./tokens.mjs";
 
 export function parseOnly(input, context = {}) {
   context.getGlobal ||= a => globals[a];
@@ -30,129 +19,44 @@ export function parseOnly(input, context = {}) {
     }
   }
 
-  function expect(expected) {
-    if (token !== expected) {
-      throw new Error(
-        `unexpected '${token?.str || token}' expecting '${expected.str}'`,
-        { cause: token }
-      );
-    }
-    advance();
-  }
-
-  function nud(last, left) {
-    switch (last) {
-      case OPEN_ROUND: {
-        const sequence = [];
-
-        while (token !== CLOSE_ROUND) {
-          sequence.push(expression(0));
-          if (token === COMMA) {
-            advance();
-          }
-        }
-        expect(CLOSE_ROUND);
-
-        // TODO always a sequence ?
-        return sequence.length > 1 ? sequence : sequence[0];
-      }
-      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;
-      }
-
-      case IDENTIFIER:
-        return { eval: pathEval, path: [value] };
-
-      case EOF:
-        throw new Error("unexpected EOF");
-    }
-
-    if (last.type === "prefix") {
-      return { token: last, left, right: expression(last.precedence) };
-    }
-
-    return last;
-  }
-
-  function led(last, left) {
-    switch (last.type) {
-      case "infixr":
-        return ASTBinop(last, left, expression(last.precedence - 1));
-
-      case "infix": {
-        const right = expression(last.precedence);
-
-        if (last === DOT) {
-          return last.led(left, right);
-        }
-
-        return ASTBinop(last, left, right);
+  const parser = {
+    get node() {
+      return node;
+    },
+    get token() {
+      return token;
+    },
+    get value() {
+      return value;
+    },
+    advance,
+    expect(expected) {
+      if (token !== expected) {
+        throw new Error(
+          `unexpected '${token?.str || token}' expecting '${expected.str}'`,
+          { cause: token }
+        );
       }
-    }
-
-    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;
+      advance();
+    },
+    expression(precedence) {
+      const last = token;
+      advance();
+      node = last.nud ? last.nud(parser) : last;
 
+      while (token.precedence > precedence) {
+        const last = token;
         advance();
-
-        return left;
+        node = last.led(parser, node);
       }
-      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 };
-  }
 
-  function expression(precedence) {
-    const last = token;
-    advance();
-    node = nud(last, node);
-
-    while (token.precedence > precedence) {
-      const last = token;
-      advance();
-      node = led(last, node);
+      return node;
     }
-
-    return node;
-  }
+  };
 
   advance();
 
-  return expression(token.precedence ?? 0);
+  return parser.expression(token.precedence ?? 0);
 }
 
 export function parse(input, context) {

package/src/filter.mjs

@@ -7,7 +7,10 @@ import {
   GREATER,
   GREATER_EQUAL
 } from "pacc";
-import { binop } from "./ast.mjs";
+
+function binop(token, left, right) {
+  return token.binop(left, right);
+}
 
 function dateOp(op, value, against) {
   return binop(op, value.getTime(), against.getTime());

package/src/tokens.mjs

@@ -1,3 +1,5 @@
+import { pathEval, ASTTrue, functionEval } from "./ast.mjs";
+
 /**
  * Token lookup
  */
@@ -8,6 +10,8 @@ const lookup = {};
  * @property {string} str
  */
 
+function infix() {}
+
 /**
  *
  * @param {string} str
@@ -16,16 +20,61 @@ const lookup = {};
  * @param {Function} [led]
  * @returns {Token}
  */
-function createToken(str, precedence = 0, type, led) {
+function createToken(
+  str,
+  precedence = 0,
+  type,
+  led = () => {},
+  nud = () => {}
+) {
   const token = { str, precedence, type };
-  if (led) {
-    token.led = led;
+
+  switch (type) {
+    case "infix":
+      token.led = (parser, left) =>
+        led(left, parser.expression(token.precedence));
+      break;
+    case "infixr":
+      token.led = (parser, left) =>
+        led(left, parser.expression(token.precedence - 1));
+      break;
+    default:
+      token.led = led;
   }
+
+  token.nud = nud;
   lookup[str] = [token];
   return token;
 }
 
-export /** @type {Token} */ const PLUS = createToken(
+function createBinopToken(str, precedence, type, binop) {
+  const token = createToken(str, precedence, type, (left, right) => {
+    if (!left.eval && !right.eval) {
+      return binop(left, right);
+    }
+
+    return {
+      eval: (node, current, context) =>
+        binop(
+          node.left.eval
+            ? node.left.eval(node.left, current, context)
+            : node.left,
+          node.right.eval
+            ? node.right.eval(node.right, current, context)
+            : node.right
+        ),
+      token,
+      left,
+      right
+    };
+  });
+
+  token.binop = binop;
+
+  return token;
+}
+
+export /** @type {Token} */ const PLUS = createBinopToken(
   "+",
   50,
   "infix",
@@ -38,64 +87,132 @@ export /** @type {Token} */ const PLUS = createToken(
     return left + right;
   }
 );
-export /** @type {Token} */ const MINUS = createToken(
+
+export /** @type {Token} */ const MINUS = createBinopToken(
   "-",
   50,
   "infix",
   (left, right) => left - right
 );
-export /** @type {Token} */ const STAR = createToken(
+export /** @type {Token} */ const STAR = createBinopToken(
   "*",
   60,
   "infix",
   (left, right) => left * right
 );
-export /** @type {Token} */ const DIVIDE = createToken(
+export /** @type {Token} */ const DIVIDE = createBinopToken(
   "/",
   60,
   "infix",
   (left, right) => left / right
 );
 export /** @type {Token} */ const NOT = createToken("!");
-export /** @type {Token} */ const NOT_EQUAL = createToken(
+export /** @type {Token} */ const NOT_EQUAL = createBinopToken(
   "!=",
   40,
   "infixr",
   (left, right) => left != right
 );
-export /** @type {Token} */ const EQUAL = createToken(
+export /** @type {Token} */ const EQUAL = createBinopToken(
   "=",
   40,
   "infixr",
   (left, right) => left == right
 );
-export /** @type {Token} */ const GREATER = createToken(
+export /** @type {Token} */ const GREATER = createBinopToken(
   ">",
   40,
   "infixr",
   (left, right) => left > right
 );
-export /** @type {Token} */ const GREATER_EQUAL = createToken(
+export /** @type {Token} */ const GREATER_EQUAL = createBinopToken(
   ">=",
   40,
   "infixr",
   (left, right) => left >= right
 );
-export /** @type {Token} */ const LESS = createToken(
+export /** @type {Token} */ const LESS = createBinopToken(
   "<",
   40,
   "infixr",
   (left, right) => left < right
 );
-export /** @type {Token} */ const LESS_EQUAL = createToken(
+export /** @type {Token} */ const LESS_EQUAL = createBinopToken(
   "<=",
   40,
   "infixr",
   (left, right) => left <= right
 );
-export /** @type {Token} */ const OPEN_ROUND = createToken("(", 40, "prefix");
+export /** @type {Token} */ const OPEN_ROUND = createToken(
+  "(",
+  40,
+  "prefix",
+  (parser, left) => {
+    const args = [];
+    while (parser.token !== CLOSE_ROUND) {
+      args.push(parser.expression(0));
+      if (parser.token === COMMA) {
+        parser.advance();
+      }
+    }
+    left.args = args;
+    left.eval = functionEval;
+
+    parser.advance();
+
+    return left;
+  },
+  parser => {
+    const sequence = [];
+
+    while (parser.token !== CLOSE_ROUND) {
+      sequence.push(parser.expression(0));
+      if (parser.token === COMMA) {
+        parser.advance();
+      }
+    }
+    parser.expect(CLOSE_ROUND);
+
+    // TODO always a sequence ?
+    return sequence.length > 1 ? sequence : sequence[0];
+  }
+);
+
 export /** @type {Token} */ const CLOSE_ROUND = createToken(")", 0, "infix");
-export /** @type {Token} */ const OPEN_BRACKET = createToken("[", 10, "prefix");
+export /** @type {Token} */ const OPEN_BRACKET = createToken(
+  "[",
+  10,
+  "prefix",
+  (parser, left) => {
+    if (parser.token === CLOSE_BRACKET) {
+      parser.advance();
+      left.path.push(ASTTrue);
+    } else {
+      const predicate = parser.expression(0);
+      parser.expect(CLOSE_BRACKET);
+      left.path.push(predicate);
+    }
+    return left;
+  },
+  parser => {
+    if (parser.token === CLOSE_BRACKET) {
+      parser.advance();
+      return ASTTrue;
+    }
+
+    const node = parser.expression(0);
+    parser.expect(CLOSE_BRACKET);
+
+    switch (typeof node) {
+      case "string":
+      case "number":
+        return { eval: pathEval, path: [node] };
+    }
+
+    return node;
+  }
+);
+
 export /** @type {Token} */ const CLOSE_BRACKET = createToken("]", 0, "infix");
 export /** @type {Token} */ const OPEN_CURLY = createToken("{");
 export /** @type {Token} */ const CLOSE_CURLY = createToken("}");
@@ -117,21 +234,38 @@ export /** @type {Token} */ const DOT = createToken(
   }
 );
 export /** @type {Token} */ const AMPERSAND = createToken("&");
-export /** @type {Token} */ const DOUBLE_AMPERSAND = createToken(
+export /** @type {Token} */ const DOUBLE_AMPERSAND = createBinopToken(
   "&&",
   30,
   "infixr",
   (left, right) => left && right
 );
 export /** @type {Token} */ const BAR = createToken("|");
-export /** @type {Token} */ const DOUBLE_BAR = createToken(
+export /** @type {Token} */ const DOUBLE_BAR = createBinopToken(
   "||",
   30,
   "infixr",
   (left, right) => left || right
 );
-export /** @type {Token} */ const IDENTIFIER = createToken("IDENTIFIER", 0);
-export /** @type {Token} */ const EOF = createToken("EOF", -1, "eof");
+export /** @type {Token} */ const IDENTIFIER = createToken(
+  "IDENTIFIER",
+  0,
+  undefined,
+  undefined,
+  parser => {
+    return { eval: pathEval, path: [parser.value] };
+  }
+);
+
+export /** @type {Token} */ const EOF = createToken(
+  "EOF",
+  -1,
+  "eof",
+  undefined,
+  parser => {
+    throw new Error("unexpected EOF");
+  }
+);
 
 export const keywords = {
   true: [true],

package/types/ast.d.mts

@@ -1,5 +1,7 @@
-export function binop(token: any, left: any, right: any, fallback: any): any;
-export function ASTBinop(token: any, left: any, right: any): any;
+/**
+ * @typedef {Object} AST
+ * @property {Function} [eval]
+ */
 export function pathEval(node: any, current: any, context: any): any;
 export function functionEval(node: any, current: any, context: any): any;
 export namespace ASTTrue {