@rkmodules/rules 0.0.60 → 0.0.62

package/dist/index.cjs.js

@@ -239,6 +239,9 @@ function isSingleTon(value) {
 }
 /**
  * turns a value or array of values into a tree
+ * - a single value becomes a tree with one branch "0" and one item
+ * - an array of values becomes a tree with one branch "0" and the items in the array
+ * - a tree is returned as is
  */
 function broadCast(value) {
     if (Array.isArray(value)) {
@@ -259,14 +262,14 @@ function getBranch(tree, path) {
  * @returns
  */
 function mapTree(tree, fn) {
-    return nAryOnTree([tree], function (_a, _b, index) {
+    return nAryOnTree([tree], function mapTreeCallback(_a, _b, index) {
         var _c = __read(_a, 1), item = _c[0];
         var _d = __read(_b, 1), path = _d[0];
         return fn(item, path, index);
     });
 }
 function mapTreeBranch(tree, fn) {
-    return nAryOnTreeBranch([tree], function (_a, _b) {
+    return nAryOnTreeBranch([tree], function mapTreeBranchCallback(_a, _b) {
         var _c = __read(_a, 1), branch = _c[0];
         var _d = __read(_b, 1), path = _d[0];
         return fn(branch, path);
@@ -319,7 +322,7 @@ function nAryOnTreeBranch(trees, fn) {
  * @returns
  */
 function nAryOnTree(trees, fn, fill) {
-    return nAryOnTreeBranch(trees, function (branches, paths) {
+    return nAryOnTreeBranch(trees, function nAryOnTreeCallback(branches, paths) {
         var maxLength = Math.max.apply(Math, __spreadArray([], __read(branches.map(function (b) { return b.length; })), false));
         if (maxLength === 0)
             return; // Skip empty branches
@@ -356,7 +359,7 @@ function nAryOnTree(trees, fn, fill) {
  * @returns
  */
 function binaryOnTreeBranch(treeA, treeB, fn) {
-    return nAryOnTreeBranch([treeA, treeB], function (_a, _b) {
+    return nAryOnTreeBranch([treeA, treeB], function binaryOnTreeBranchCallback(_a, _b) {
         var _c = __read(_a, 2), branchA = _c[0], branchB = _c[1];
         var _d = __read(_b, 2), pathA = _d[0], pathB = _d[1];
         return fn(branchA, branchB, pathA, pathB);
@@ -375,7 +378,7 @@ function binaryOnTreeBranch(treeA, treeB, fn) {
  * @returns
  */
 function binaryOnTree(treeA, treeB, fn, fill) {
-    return nAryOnTree([treeA, treeB], function (_a, _b, index) {
+    return nAryOnTree([treeA, treeB], function binaryOnTreeCallback(_a, _b, index) {
         var _c = __read(_a, 2), itemA = _c[0], itemB = _c[1];
         var _d = __read(_b, 2), pathA = _d[0], pathB = _d[1];
         return fn(itemA, itemB, pathA, pathB, index);
@@ -403,30 +406,42 @@ function toArray(a) {
  * @param b
  * @returns
  */
-function mergeTrees(a, b) {
-    var e_1, _a;
-    var _b;
-    var out = __assign({}, a);
-    try {
-        for (var _c = __values(Object.entries(b)), _d = _c.next(); !_d.done; _d = _c.next()) {
-            var _e = __read(_d.value, 2), k = _e[0], arr = _e[1];
-            out[k] = ((_b = out[k]) !== null && _b !== void 0 ? _b : []).concat(arr);
-        }
+function mergeTrees() {
+    var others = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        others[_i] = arguments[_i];
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
+    var a = others.shift() || { 0: [] };
+    var out = __assign({}, a);
+    others.forEach(function (b) {
+        var e_1, _a;
+        var _b;
         try {
-            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            for (var _c = __values(Object.entries(b)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var _e = __read(_d.value, 2), k = _e[0], arr = _e[1];
+                out[k] = ((_b = out[k]) !== null && _b !== void 0 ? _b : []).concat(arr);
+            }
         }
-        finally { if (e_1) throw e_1.error; }
-    }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
     return out;
 }
 
 function isReference(value) {
-    return (typeof value === "string" &&
-        value.startsWith("<") &&
-        value.endsWith(">"));
+    return (typeof value === "string" && !!value.match(/^<([\w\.]+)>$/)
+    // value.startsWith("<") &&
+    // value.endsWith(">")
+    );
+}
+function hasReference(value) {
+    var _a;
+    return typeof value === "string" && !!((_a = value.match) === null || _a === void 0 ? void 0 : _a.call(value, /<(.*?)>/g));
 }
 function parseReference(ref) {
     return ref.slice(1, -1);
@@ -446,29 +461,35 @@ function getValue$1(obj, path) {
     return value;
 }
 function interpolateValue(value, scope) {
+    // interpolating arrays
     if (Array.isArray(value)) {
         if (!value.length)
-            return broadCast([]);
-        if (!value.every(isTree)) {
-            // interpolate to an array of trees
-            var mappedValue_1 = value.map(function (v) { return interpolateValue(v, scope); });
-            if (!mappedValue_1.every(isTree)) {
+            return [];
+        if (value.every(isTree)) {
+            // array of trees: merge the trees into one
+            var tree = mergeTrees.apply(void 0, __spreadArray([], __read(value), false));
+            // then interpolate each value in the tree in case there are references
+            return mapTree(tree, function (v) { return interpolateValue(v, scope); });
+        }
+        else {
+            // array of other values: interpolate to an array of trees
+            var mappedValue = value.map(function (v) {
+                return broadCast(interpolateValue(v, scope));
+            });
+            if (!mappedValue.every(isTree)) {
                 // this is a bit of a hack when the values were all plain values
                 // in that case, just return them, which will result in a single tree
-                return mappedValue_1;
+                return mappedValue;
             }
             // then, for each value, combine the branches with the same index
-            return nAryOnTreeBranch(mappedValue_1, function (branches) { return branches.flat(); });
-        }
-        else {
-            // combine the trees into one
-            var tree = value.reduce(function (acc, t) { return mergeTrees(acc, t); });
-            return mapTree(tree, function (v) { return interpolateValue(v, scope); });
+            return mergeTrees.apply(void 0, __spreadArray([], __read(mappedValue), false));
         }
     }
+    // a tree is mapped over each value
     if (isTree(value)) {
         return mapTree(value, function (v) { return interpolateValue(v, scope); });
     }
+    // an object is interpolated recursively
     if (typeof value === "object" && value !== null) {
         if (Object.keys(value).length === 0) {
             return {};
@@ -483,18 +504,33 @@ function interpolateValue(value, scope) {
             }));
         });
     }
-    if (!isReference(value)) {
-        return value;
-    }
-    var parts = parseReference(value).split(".");
-    var mappedValue = getValue$1(scope, parts.slice(0, 2).join("."));
-    if (parts.length > 2) {
-        // deep interpolate
-        mappedValue = mapTree(mappedValue, function (v) {
-            return getValue$1(v, parts.slice(2).join("."));
-        });
+    if (hasReference(value)) {
+        if (isReference(value)) {
+            // it's a simple reference string
+            var parts_1 = parseReference(value).split(".");
+            var mappedValue = getValue$1(scope, parts_1.slice(0, 2).join("."));
+            if (parts_1.length > 2) {
+                // deep interpolate
+                mappedValue = mapTree(mappedValue, function (v) {
+                    return getValue$1(v, parts_1.slice(2).join("."));
+                });
+            }
+            return mappedValue;
+        }
+        else {
+            // it's a template string, break up as an array of strings and references and interpolate each to a tree
+            var strings = value.split(/(<.*?>)/);
+            var trees = strings.map(function (str) {
+                return broadCast(interpolateValue(str, scope));
+            });
+            // create a combined string for each item, filling in missing items witht the last
+            var combined = nAryOnTree(trees, function (items) {
+                return items.join("");
+            }, true);
+            return combined;
+        }
     }
-    return mappedValue;
+    return value;
 }
 function interpolate(inputs, scope) {
     return Object.fromEntries(Object.entries(inputs).map(function (_a) {
@@ -5126,6 +5162,7 @@ exports.getBranch = getBranch;
 exports.getReferences = getReferences;
 exports.getValue = getValue$1;
 exports.graftTree = graftTree;
+exports.hasReference = hasReference;
 exports.interpolate = interpolate;
 exports.isReference = isReference;
 exports.isSingleTon = isSingleTon;