pacc 4.19.0 → 4.21.0

package/package.json

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

package/src/expand.mjs

@@ -0,0 +1,146 @@
+import { parse } from "./expression.mjs";
+import { tokens } from "./tokens.mjs";
+
+export function expand(object, context) {
+  const promises = [];
+  const maxNestingLevel = 5;
+
+  function _expand(object, path) {
+    if (path.length >= maxNestingLevel) {
+      throw new Error(
+        `Max nesting level ${maxNestingLevel} reached: ${object}`
+      );
+    }
+
+    if (typeof object === "string" || object instanceof String) {
+      let wholeValue;
+
+      const localPromises = [];
+      const v = object.replace(/\$\{([^\}]*)\}/g, (match, expression, offset, string) => {
+        context.tokens = tokens(expression);
+        let value = parse(context);
+
+        if (typeof value === "string" || value instanceof String) {
+          value = _expand(value, path);
+        } else if (value === undefined) {
+          value = "${" + expression + "}";
+        }
+        if (string.length === expression.length + 3) {
+          wholeValue = value;
+          return "";
+        }
+
+        if (value instanceof Promise) {
+          localPromises.push(value);
+          return "${" + (localPromises.length - 1) + "}";
+        }
+        return value;
+      });
+
+      if (wholeValue !== undefined) {
+        return wholeValue;
+      }
+
+      if (localPromises.length !== 0) {
+        return Promise.all(localPromises).then(all =>
+          v.replace(/\$\{(\d+)\}/g, (match, key) => all[parseInt(key, 10)])
+        );
+      }
+
+      return v;
+    }
+
+    switch (typeof object) {
+      case "undefined":
+      case "boolean":
+      case "number":
+      case "bigint":
+      case "function":
+        return object;
+    }
+
+    if (object === null || object instanceof Number || object instanceof Date) {
+      // TODO: find a better way to identify special cases
+      return object;
+    }
+
+    if (object instanceof Map) {
+      const r = new Map();
+      for (const [key, value] of object.entries()) {
+        const path2 = [
+          ...path,
+          {
+            key,
+            value
+          }
+        ];
+
+        r.set(_expand(key, path2), _expand(value, path2));
+      }
+
+      return r;
+    }
+
+    if (object instanceof Set) {
+      const r = new Set();
+      for (const value of object.values()) {
+        r.add(_expand(value, [...path, { value }]));
+      }
+
+      return r;
+    }
+
+    if (Array.isArray(object)) {
+      const array = new Array(object.length);
+
+      for (let index = 0; index < object.length; index++) {
+        const o = object[index];
+
+        const r = _expand(o, [
+          ...path,
+          {
+            key: index,
+            value: o
+          }
+        ]);
+        if (r instanceof Promise) {
+          promises.push(r);
+          r.then(f => (array[index] = f));
+        }
+        array[index] = r;
+      }
+
+      return array;
+    }
+
+    let newObject = {};
+
+    for (let [key, value] of Object.entries(object)) {
+      const newKey = _expand(key, path);
+      if (typeof newKey === "string" || newKey instanceof String) {
+        value = _expand(value, [
+          ...path,
+          {
+            key,
+            value
+          }
+        ]);
+        if (value instanceof Promise) {
+          promises.push(value);
+          value.then(v => (newObject[newKey] = v));
+        }
+        newObject[newKey] = value;
+      } else {
+        newObject = newKey;
+      }
+    }
+
+    return newObject;
+  }
+
+  const value = _expand(object, [], promises);
+  if (promises.length !== 0) {
+    return Promise.all(promises).then(() => value);
+  }
+  return value;
+}

package/src/expression.mjs

@@ -172,8 +172,10 @@ export function parse(context) {
 
       case "infix": {
         let right = expression(token.precedence);
+
         if (typeof left === typeof right) {
           switch (typeof left) {
+            case "string":
             case "number":
             case "bigint":
               return binop(token, left, right, binopError);

package/src/module.mjs

@@ -5,6 +5,7 @@ export * from "./attributes.mjs";
 export * from "./common-attributes.mjs";
 export * from "./properties.mjs";
 export * from "./expression.mjs";
+export * from "./expand.mjs";
 export {
   setAttribute,
   getAttribute,

package/types/expand.d.mts

@@ -0,0 +1 @@
+export function expand(object: any, context: any): any;

package/types/module.d.mts

@@ -5,4 +5,5 @@ export * from "./attributes.mjs";
 export * from "./common-attributes.mjs";
 export * from "./properties.mjs";
 export * from "./expression.mjs";
+export * from "./expand.mjs";
 export { setAttribute, getAttribute, getAttributeAndOperator } from "./settergetter.mjs";