pacc 8.9.3 → 8.11.0

package/README.md

@@ -32,16 +32,14 @@ const result = expand("${a + 1}",{ root: { a: 2 }});
 
 *   [AST](#ast)
     *   [Properties](#properties)
-*   [binopError](#binoperror)
-    *   [Parameters](#parameters)
 *   [prepareAttributesDefinitions](#prepareattributesdefinitions)
-    *   [Parameters](#parameters-1)
+    *   [Parameters](#parameters)
 *   [mergeAttributeDefinitions](#mergeattributedefinitions)
-    *   [Parameters](#parameters-2)
+    *   [Parameters](#parameters-1)
 *   [attributeIterator](#attributeiterator)
-    *   [Parameters](#parameters-3)
+    *   [Parameters](#parameters-2)
 *   [parseBytes](#parsebytes)
-    *   [Parameters](#parameters-4)
+    *   [Parameters](#parameters-3)
 *   [AttributeDefinition](#attributedefinition)
     *   [Properties](#properties-1)
 *   [default\_attribute](#default_attribute)
@@ -99,40 +97,40 @@ const result = expand("${a + 1}",{ root: { a: 2 }});
 *   [timeout\_attribute](#timeout_attribute)
 *   [language\_attribute](#language_attribute)
 *   [environmentValues](#environmentvalues)
-    *   [Parameters](#parameters-5)
+    *   [Parameters](#parameters-4)
 *   [expandContextDefault](#expandcontextdefault)
 *   [expandContextDoubbleCurly](#expandcontextdoubblecurly)
 *   [expand](#expand)
-    *   [Parameters](#parameters-6)
+    *   [Parameters](#parameters-5)
 *   [promises](#promises)
 *   [filter](#filter)
-    *   [Parameters](#parameters-7)
+    *   [Parameters](#parameters-6)
 *   [setAttributes](#setattributes)
-    *   [Parameters](#parameters-8)
+    *   [Parameters](#parameters-7)
 *   [getAttributes](#getattributes)
-    *   [Parameters](#parameters-9)
+    *   [Parameters](#parameters-8)
 *   [getAttributesJSON](#getattributesjson)
-    *   [Parameters](#parameters-10)
+    *   [Parameters](#parameters-9)
 *   [tokens](#tokens)
 *   [tokens](#tokens-1)
-    *   [Parameters](#parameters-11)
+    *   [Parameters](#parameters-10)
 *   [setAttribute](#setattribute)
-    *   [Parameters](#parameters-12)
+    *   [Parameters](#parameters-11)
 *   [getAttribute](#getattribute)
-    *   [Parameters](#parameters-13)
+    *   [Parameters](#parameters-12)
 *   [getAttributeAndOperator](#getattributeandoperator)
-    *   [Parameters](#parameters-14)
+    *   [Parameters](#parameters-13)
 *   [parseDuration](#parseduration)
-    *   [Parameters](#parameters-15)
+    *   [Parameters](#parameters-14)
 *   [formatDuration](#formatduration)
-    *   [Parameters](#parameters-16)
+    *   [Parameters](#parameters-15)
 *   [formatDurationISO](#formatdurationiso)
-    *   [Parameters](#parameters-17)
+    *   [Parameters](#parameters-16)
 *   [lookup](#lookup)
 *   [Token](#token)
     *   [Properties](#properties-2)
 *   [createToken](#createtoken)
-    *   [Parameters](#parameters-18)
+    *   [Parameters](#parameters-17)
 *   [PLUS](#plus)
 *   [MINUS](#minus)
 *   [STAR](#star)
@@ -164,7 +162,7 @@ const result = expand("${a + 1}",{ root: { a: 2 }});
 *   [Type](#type)
     *   [Properties](#properties-3)
 *   [raiseOnUnknownType](#raiseonunknowntype)
-    *   [Parameters](#parameters-19)
+    *   [Parameters](#parameters-18)
 
 ## AST
 
@@ -174,14 +172,6 @@ Type: [Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Globa
 
 *   `eval` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?** 
 
-## binopError
-
-### Parameters
-
-*   `token` **[Token](#token)** 
-*   `left` **[AST](#ast)** 
-*   `right` **[AST](#ast)** 
-
 ## prepareAttributesDefinitions
 
 Create attributes from its definition.
@@ -661,7 +651,8 @@ Type: [Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Globa
 *   `str` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** 
 *   `precedence` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?**  (optional, default `0`)
 *   `type` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** 
-*   `led` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?** 
+*   `led` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?**  (optional, default `()=>{}`)
+*   `nud`   (optional, default `()=>{}`)
 
 Returns **[Token](#token)** 
 

package/package.json

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

package/src/ast.mjs

@@ -1,49 +1,9 @@
+
 /**
  * @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;
   let first = true;

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/settergetter.mjs

@@ -14,7 +14,10 @@ import {
   GREATER,
   GREATER_EQUAL,
   STAR,
-  IDENTIFIER
+  IDENTIFIER,
+  STRING,
+  NUMBER,
+  BOOLEAN
 } from "./tokens.mjs";
 import { parseOnly } from "./expression.mjs";
 import { toInternal } from "./attributes.mjs";
@@ -146,6 +149,9 @@ export function getAttributeAndOperator(object, expression) {
         predicateTokens.push(token[0]);
         break;
 
+      case STRING:
+      case NUMBER:
+      case BOOLEAN:
       case IDENTIFIER:
         if (object !== undefined) {
           switch (typeof object[token[1]]) {
@@ -163,22 +169,6 @@ export function getAttributeAndOperator(object, expression) {
           }
         }
         break;
-      default:
-        if (object !== undefined) {
-          switch (typeof object[token[0]]) {
-            case "function":
-              object = object[token[0]]();
-              if (typeof object[Symbol.iterator] === "function") {
-                object = [...object];
-              }
-              break;
-            default:
-              object = object[token[0]];
-              break;
-            case "undefined":
-              return [undefined, op];
-          }
-        }
     }
   }
 

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,25 +234,65 @@ 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 STRING = createToken(
+  "STRING",
+  0,
+  undefined,
+  undefined,
+  parser => parser.value
+);
+
+export /** @type {Token} */ const NUMBER = createToken(
+  "NUMBER",
+  0,
+  undefined,
+  undefined,
+  parser => parser.value
+);
+export /** @type {Token} */ const BOOLEAN = createToken(
+  "BOOLEAN",
+  0,
+  undefined,
+  undefined,
+  parser => parser.value
+);
+
+export /** @type {Token} */ const EOF = createToken(
+  "EOF",
+  -1,
+  "eof",
+  undefined,
+  parser => {
+    throw new Error("unexpected EOF");
+  }
+);
 
 export const keywords = {
-  true: [true],
-  false: [false]
+  true: [BOOLEAN, true],
+  false: [BOOLEAN, false]
 };
 
 const esc = {
@@ -197,7 +354,7 @@ export function* tokens(string, options = {}) {
       case " ":
         switch (state) {
           case "number":
-            yield [options.parseFloat(value)];
+            yield [NUMBER, options.parseFloat(value)];
             state = undefined;
           case undefined:
             break;
@@ -226,13 +383,13 @@ export function* tokens(string, options = {}) {
       case "'":
         switch (state) {
           case "number":
-            yield [options.parseFloat(value)];
+            yield [NUMBER,options.parseFloat(value)];
           case undefined:
             startString(c);
             break;
           case "string":
             if (c === quote) {
-              yield [value];
+              yield [STRING, value];
               state = undefined;
             } else {
               value += c;
@@ -254,7 +411,7 @@ export function* tokens(string, options = {}) {
       case "|":
         switch (state) {
           case "number":
-            yield [options.parseFloat(value)];
+            yield [NUMBER, options.parseFloat(value)];
           case undefined:
             state = c;
             break;
@@ -285,7 +442,7 @@ export function* tokens(string, options = {}) {
       case "=":
         switch (state) {
           case "number":
-            yield [options.parseFloat(value)];
+            yield [NUMBER, options.parseFloat(value)];
           case undefined:
             state = c;
             break;
@@ -326,7 +483,7 @@ export function* tokens(string, options = {}) {
       case "}":
         switch (state) {
           case "number":
-            yield [options.parseFloat(value)];
+            yield [NUMBER, options.parseFloat(value)];
           case undefined:
             state = c;
             break;
@@ -377,7 +534,7 @@ export function* tokens(string, options = {}) {
       default:
         switch (state) {
           case "number":
-            yield [options.parseFloat(value)];
+            yield [NUMBER, options.parseFloat(value)];
           case undefined:
             state = "identifier";
             value = c;
@@ -400,7 +557,7 @@ export function* tokens(string, options = {}) {
     case "string":
       throw new Error("unterminated string", { cause: string });
     case "number":
-      yield [options.parseFloat(value)];
+      yield [NUMBER, options.parseFloat(value)];
       break;
     case "identifier":
       yield keywordOrIdentifier();

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 {

package/types/tokens.d.mts

@@ -34,11 +34,14 @@ export namespace DOUBLE_AMPERSAND { }
 export namespace BAR { }
 export namespace DOUBLE_BAR { }
 export namespace IDENTIFIER { }
+export namespace STRING { }
+export namespace NUMBER { }
+export namespace BOOLEAN { }
 export namespace EOF { }
 export namespace keywords {
-    let _true: boolean[];
+    let _true: (boolean | Token)[];
     export { _true as true };
-    let _false: boolean[];
+    let _false: (boolean | Token)[];
     export { _false as false };
 }
 export type Token = {