pacc 4.25.1 → 4.26.0

package/README.md

@@ -79,26 +79,28 @@ const result = getAttribute({ a: [0,{ b: 4 }]}, "a[1].b");
 *   [priority\_attribute](#priority_attribute)
 *   [timeout\_attribute](#timeout_attribute)
 *   [language\_attribute](#language_attribute)
-*   [filter](#filter)
+*   [expand](#expand)
     *   [Parameters](#parameters-3)
-*   [setAttributes](#setattributes)
+*   [filter](#filter)
     *   [Parameters](#parameters-4)
-*   [getAttributes](#getattributes)
+*   [setAttributes](#setattributes)
     *   [Parameters](#parameters-5)
+*   [getAttributes](#getattributes)
+    *   [Parameters](#parameters-6)
 *   [tokens](#tokens)
 *   [tokens](#tokens-1)
-    *   [Parameters](#parameters-6)
-*   [setAttribute](#setattribute)
     *   [Parameters](#parameters-7)
-*   [getAttribute](#getattribute)
+*   [setAttribute](#setattribute)
     *   [Parameters](#parameters-8)
-*   [getAttributeAndOperator](#getattributeandoperator)
+*   [getAttribute](#getattribute)
     *   [Parameters](#parameters-9)
+*   [getAttributeAndOperator](#getattributeandoperator)
+    *   [Parameters](#parameters-10)
 *   [lookup](#lookup)
 *   [Token](#token)
     *   [Properties](#properties-1)
 *   [createToken](#createtoken)
-    *   [Parameters](#parameters-10)
+    *   [Parameters](#parameters-11)
 *   [PLUS](#plus)
 *   [MINUS](#minus)
 *   [STAR](#star)
@@ -135,7 +137,7 @@ Create attributes from its definition.
 ### Parameters
 
 *   `newDefinitions` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** 
-*   `presentDefinitions` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)?** optional merg in attributes
+*   `presentDefinitions` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)?** optional merge in attributes
 
 Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** attributes
 
@@ -367,6 +369,22 @@ Type: [AttributeDefinition](#attributedefinition)
 
 Type: [AttributeDefinition](#attributedefinition)
 
+## expand
+
+Expand expressions inside of object graphs.
+
+### Parameters
+
+*   `object` **any** 
+*   `context` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)**  (optional, default `{}`)
+
+    *   `context.root` **any** 
+    *   `context.stopClass` **[function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?** 
+    *   `context.leadIn` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** 
+    *   `context.leadOut` **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** 
+
+Returns **any** 
+
 ## filter
 
 Generate filter function.

package/package.json

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

package/src/expand.mjs

@@ -3,11 +3,13 @@ import { parse } from "./expression.mjs";
 const maxNestingLevel = 5;
 
 /**
- *
+ * Expand expressions inside of object graphs.
  * @param {any} object
  * @param {Object} context
  * @param {any} context.root
- * @param {function} context.stopClass
+ * @param {function} [context.stopClass]
+ * @param {string} [context.leadIn]
+ * @param {string} [context.leadOut]
  * @returns {any}
  */
 export function expand(object, context = {}) {

package/src/expression.mjs

@@ -18,6 +18,7 @@ import {
   PLUS,
   MINUS,
   IDENTIFIER,
+  COMMA,
   EOF
 } from "./tokens.mjs";
 
@@ -121,10 +122,10 @@ export function parse(input, context = {}) {
     advance();
   };
 
-  const nud = (token, left) => {
-    switch (token.type) {
+  const nud = (last, left) => {
+    switch (last.type) {
       case "prefix":
-        switch (token) {
+        switch (last) {
           case OPEN_ROUND: {
             const node = expression(0);
             expect(CLOSE_ROUND);
@@ -142,66 +143,66 @@ export function parse(input, context = {}) {
             return node;
           }
         }
-        return { token, left, right: expression(token.precedence) };
+        return { token: last, left, right: expression(last.precedence) };
       case "eof":
         error("unexpected EOF");
     }
 
-    switch (typeof token) {
+    switch (typeof last) {
       case "string":
       case "number":
       case "bigint":
       case "boolean":
-        return token;
+        return last;
     }
 
-    if (token === IDENTIFIER) {
+    if (last === IDENTIFIER) {
       return { eval: pathEval, path: [value] };
     }
 
-    return { token };
+    return { token: last };
   };
 
-  const led = (token, left) => {
-    switch (token.type) {
+  const led = (last, left) => {
+    switch (last.type) {
       case "infixr": {
-        const right = expression(token.precedence - 1);
+        const right = expression(last.precedence - 1);
         if (typeof left === typeof right) {
           switch (typeof left) {
             case "string":
             case "number":
             case "bigint":
             case "boolean":
-              return binop(token, left, right, binopError);
+              return binop(last, left, right, binopError);
           }
         }
 
         return {
           eval: (node, current) =>
             binop(
-              token,
+              last,
               left.eval ? left.eval(left, current) : left,
               right.eval ? right.eval(right, current) : right,
               binopError
             ),
-          token,
+          last,
           left,
           right
         };
       }
 
       case "infix": {
-        let right = expression(token.precedence);
+        let right = expression(last.precedence);
 
         if (typeof left === typeof right) {
           switch (typeof left) {
             case "string":
             case "number":
             case "bigint":
-              return binop(token, left, right, binopError);
+              return binop(last, left, right, binopError);
           }
         }
-        if (token === DOT) {
+        if (last === DOT) {
           if (left.path) {
             left.path.push(...right.path);
             return left;
@@ -221,18 +222,33 @@ export function parse(input, context = {}) {
         return {
           eval: (node, current) =>
             binop(
-              token,
+              last,
               left.eval ? left.eval(left, current) : left,
               right.eval ? right.eval(right, current) : right,
               binopError
             ),
-          token,
+          token: last,
           left,
           right
         };
       }
       case "prefix":
-        switch (token) {
+        switch (last) {
+          case OPEN_ROUND:
+            {
+              const args = [];
+              while (token !== CLOSE_ROUND) {
+                args.push(expression(0));
+                if (token === COMMA) {
+                  advance();
+                }
+              }
+              left.path.push(args);
+              left.eval = node =>
+                context.globals[node.path[0]](...node.path[1]);
+              return left;
+            }
+            break;
           case OPEN_BRACKET: {
             const predicate = expression(0);
             expect(CLOSE_BRACKET);

package/src/tokens.mjs

@@ -34,7 +34,7 @@ export /** @type {Token} */ const GREATER_EQUAL = createToken(
 );
 export /** @type {Token} */ const LESS = createToken("<", 40, "infixr");
 export /** @type {Token} */ const LESS_EQUAL = createToken("<=", 40, "infixr");
-export /** @type {Token} */ const OPEN_ROUND = createToken("(", 0, "prefix");
+export /** @type {Token} */ const OPEN_ROUND = createToken("(", 40, "prefix");
 export /** @type {Token} */ const CLOSE_ROUND = createToken(")", 0, "infix");
 export /** @type {Token} */ const OPEN_BRACKET = createToken("[", 10, "prefix");
 export /** @type {Token} */ const CLOSE_BRACKET = createToken("]", 0, "infix");

package/types/expand.d.mts

@@ -1,12 +1,16 @@
 /**
- *
+ * Expand expressions inside of object graphs.
  * @param {any} object
  * @param {Object} context
  * @param {any} context.root
- * @param {function} context.stopClass
+ * @param {function} [context.stopClass]
+ * @param {string} [context.leadIn]
+ * @param {string} [context.leadOut]
  * @returns {any}
  */
 export function expand(object: any, context?: {
     root: any;
-    stopClass: Function;
+    stopClass?: Function;
+    leadIn?: string;
+    leadOut?: string;
 }): any;