pacc 4.23.0 → 4.24.0

package/package.json

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

package/src/expand.mjs

@@ -1,5 +1,4 @@
 import { parse } from "./expression.mjs";
-import { tokens } from "./tokens.mjs";
 
 const maxNestingLevel = 5;
 
@@ -20,8 +19,7 @@ export function expand(object, context) {
       const v = object.replace(
         /\$\{([^\}]*)\}/g,
         (match, expression, offset, string) => {
-          context.tokens = tokens(expression);
-          let value = parse(context);
+          let value = parse(expression,context);
 
           if (typeof value === "string" || value instanceof String) {
             value = _expand(value, path);

package/src/expression.mjs

@@ -1,4 +1,5 @@
 import {
+  tokens,
   DOT,
   OPEN_ROUND,
   CLOSE_ROUND,
@@ -16,6 +17,7 @@ import {
   DIVIDE,
   PLUS,
   MINUS,
+  IDENTIFIER,
   EOF
 } from "./tokens.mjs";
 
@@ -50,8 +52,10 @@ export function binop(op, left, right, fallback) {
   return fallback(op, left, right);
 }
 
-export function parse(context) {
-  let node, token;
+export function parse(input, context = {}) {
+  input = tokens(input);
+
+  let node, token, value;
 
   function error(message) {
     const error = new Error(message);
@@ -79,9 +83,9 @@ export function parse(context) {
           }
           break;
         case "object":
-          const input = result;
+          const r = result;
           function* filter() {
-            for (const x of input) {
+            for (const x of r) {
               if (p.eval(p, x)) {
                 yield x;
               }
@@ -95,8 +99,15 @@ export function parse(context) {
   };
 
   const advance = () => {
-    const { value, done } = context.tokens.next();
-    token = done ? EOF : value;
+    const next = input.next();
+    if (next.done) {
+      token = EOF;
+    } else {
+      token = next.value[0];
+      if (next.value.length > 1) {
+        value = next.value[1];
+      }
+    }
   };
 
   const expect = expected => {
@@ -119,6 +130,7 @@ export function parse(context) {
             const node = expression(0);
             expect(CLOSE_BRACKET);
             switch (typeof node) {
+              case "string":
               case "number":
                 return { eval: pathEval, path: [node] };
             }
@@ -133,13 +145,16 @@ export function parse(context) {
 
     switch (typeof token) {
       case "string":
-        return { eval: pathEval, path: [token] };
       case "number":
       case "bigint":
       case "boolean":
         return token;
     }
 
+    if (token === IDENTIFIER) {
+      return { eval: pathEval, path: [value] };
+    }
+
     return { token };
   };
 
@@ -156,6 +171,7 @@ export function parse(context) {
               return binop(token, left, right, binopError);
           }
         }
+
         return {
           eval: (node, current) =>
             binop(
@@ -246,7 +262,7 @@ export function parse(context) {
   if (context.exec !== false && result?.eval) {
     result = result.eval(result, context.root);
 
-    if(typeof result === 'function') {
+    if (typeof result === "function") {
       return [...result()];
     }
   }

package/src/settergetter.mjs

@@ -13,7 +13,8 @@ import {
   LESS_EQUAL,
   GREATER,
   GREATER_EQUAL,
-  STAR
+  STAR,
+  IDENTIFIER
 } from "./tokens.mjs";
 import { parse } from "./expression.mjs";
 import { prepareValue } from "./attributes.mjs";
@@ -27,7 +28,7 @@ import { prepareValue } from "./attributes.mjs";
  * @param {Object} definition type def
  */
 export function setAttribute(object, expression, value, definition) {
-  const { path } = parse({ tokens: tokens(expression), exec: false });
+  const { path } = parse(expression, { exec: false });
 
   let anchor, anchorKey;
 
@@ -60,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({ tokens: tokens(expression), exec: false });
+  const { path } = parse(expression, { exec: false });
 
   for (const key of path) {
     if (object !== undefined) {
@@ -80,7 +81,7 @@ export function getAttribute(object, expression, definition) {
     }
   }
 
-  if(object === undefined && definition) {
+  if (object === undefined && definition) {
     object = definition.default;
   }
 
@@ -114,14 +115,14 @@ export function getAttributeAndOperator(object, expression) {
   const next = tokens(expression);
 
   for (const token of next) {
-    switch (token) {
+    switch (token[0]) {
       case GREATER_EQUAL:
       case LESS_EQUAL:
       case GREATER:
       case LESS:
       case EQUAL:
       case NOT_EQUAL:
-        op = token;
+        op = token[0];
         break;
       case DOT:
       case OPEN_BRACKET:
@@ -142,20 +143,37 @@ export function getAttributeAndOperator(object, expression) {
           error.expression = expression;
           throw error;
         }
-        predicateTokens.push(token);
+        predicateTokens.push(token[0]);
         break;
 
+      case IDENTIFIER:
+        if (object !== undefined) {
+          switch (typeof object[token[1]]) {
+            case "function":
+              object = object[token[1]]();
+              if (typeof object[Symbol.iterator] === "function") {
+                object = [...object];
+              }
+              break;
+            default:
+              object = object[token[1]];
+              break;
+            case "undefined":
+              return [undefined, op];
+          }
+        }
+        break;
       default:
         if (object !== undefined) {
-          switch (typeof object[token]) {
+          switch (typeof object[token[0]]) {
             case "function":
-              object = object[token]();
+              object = object[token[0]]();
               if (typeof object[Symbol.iterator] === "function") {
                 object = [...object];
               }
               break;
             default:
-              object = object[token];
+              object = object[token[0]];
               break;
             case "undefined":
               return [undefined, op];

package/src/tokens.mjs

@@ -15,7 +15,7 @@ const lookup = {};
  */
 function createToken(str, precedence = 0, type) {
   const token = { str, precedence, type };
-  lookup[str] = token;
+  lookup[str] = [token];
   return token;
 }
 
@@ -53,6 +53,7 @@ export /** @type {Token} */ const DOUBLE_AMPERSAND = createToken(
 );
 export /** @type {Token} */ const BAR = createToken("|");
 export /** @type {Token} */ const DOUBLE_BAR = createToken("||", 30, "infixr");
+export /** @type {Token} */ const IDENTIFIER = createToken("IDENTIFIER", 0);
 export /** @type {Token} */ const EOF = createToken("EOF", -1, "eof");
 
 /**
@@ -67,11 +68,11 @@ export function* tokens(string) {
   function maybeKeyword() {
     switch (value) {
       case "true":
-        return true;
+        return [true];
       case "false":
-        return false;
+        return [false];
       default:
-        return value;
+        return [IDENTIFIER, value];
     }
   }
 
@@ -108,13 +109,15 @@ export function* tokens(string) {
       case "\t":
       case " ":
         switch (state) {
+          case "number":
+          case "number-fraction":
+            yield [value];
+            state = undefined;
           case undefined:
             break;
           case "string":
             value += c;
             break;
-          case "number-fraction":
-          case "number":
           case "identifier":
             yield maybeKeyword();
             value = undefined;
@@ -136,12 +139,17 @@ export function* tokens(string) {
       case '"':
       case "'":
         switch (state) {
+          case "number":
+          case "number-fraction":
+            yield [value];
+          case undefined:
+            value = "";
+            state = "string";
+            break;
           case "string":
-            yield value;
+            yield [value];
             state = undefined;
             break;
-          case "number-fraction":
-          case "number":
           case "identifier":
             yield maybeKeyword();
             value = "";
@@ -149,10 +157,8 @@ export function* tokens(string) {
             break;
           default:
             yield lookup[state];
-          case undefined:
             value = "";
             state = "string";
-            break;
         }
         break;
       case "!":
@@ -161,6 +167,12 @@ export function* tokens(string) {
       case "&":
       case "|":
         switch (state) {
+          case "number":
+          case "number-fraction":
+            yield [value];
+          case undefined:
+            state = c;
+            break;
           case "&":
           case "|":
             if (state === c) {
@@ -172,15 +184,9 @@ export function* tokens(string) {
               state = c;
             }
             break;
-          case undefined:
-            state = c;
-            break;
           case "string":
             value += c;
             break;
-
-          case "number-fraction":
-          case "number":
           case "identifier":
             yield maybeKeyword();
             state = c;
@@ -193,14 +199,15 @@ export function* tokens(string) {
 
       case "=":
         switch (state) {
+          case "number":
+          case "number-fraction":
+            yield [value];
           case undefined:
             state = c;
             break;
           case "string":
             value += c;
             break;
-          case "number-fraction":
-          case "number":
           case "identifier":
             yield maybeKeyword();
             state = c;
@@ -229,20 +236,22 @@ export function* tokens(string) {
       case "{":
       case "}":
         switch (state) {
+          case "number":
+          case "number-fraction":
+            yield [value];
+          case undefined:
+            state = c;
+            break;
           case "string":
             value += c;
             break;
-          case "number":
-          case "number-fraction":
           case "identifier":
             yield maybeKeyword();
             state = c;
             break;
           default:
             yield lookup[state];
-          case undefined:
             state = c;
-            break;
         }
         break;
       case "0":
@@ -283,16 +292,21 @@ export function* tokens(string) {
 
       default:
         switch (state) {
+          case "number":
+          case "number-fraction":
+            yield [value];
+          case undefined:
+            state = "identifier";
+            value = c;
+            break;
           case "string":
           case "identifier":
             value += c;
             break;
           default:
             yield lookup[state];
-          case undefined:
-            state = "identifier";
             value = c;
-            break;
+            state = "identifier";
         }
     }
   }
@@ -307,6 +321,8 @@ export function* tokens(string) {
       throw error;
     case "number-fraction":
     case "number":
+      yield [value];
+      break;
     case "identifier":
       yield maybeKeyword();
       break;

package/types/expression.d.mts

@@ -1,2 +1,2 @@
 export function binop(op: any, left: any, right: any, fallback: any): any;
-export function parse(context: any): any;
+export function parse(input: any, context?: {}): any;

package/types/tokens.d.mts

@@ -33,6 +33,7 @@ export namespace AMPERSAND { }
 export namespace DOUBLE_AMPERSAND { }
 export namespace BAR { }
 export namespace DOUBLE_BAR { }
+export namespace IDENTIFIER { }
 export namespace EOF { }
 export type Token = {
     str: string;