@rkmodules/rules 0.0.111 → 0.0.113

package/dist/index.cjs.js

@@ -236,6 +236,12 @@ function isTree(value) {
         Object.keys(value).length > 0 &&
         Object.values(value).every(function (v) { return Array.isArray(v); }));
 }
+function isEmptyTree(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0);
+}
 function isSingleTon(value) {
     return (Object.keys(value).length === 1 && Object.values(value)[0].length === 1);
 }
@@ -252,6 +258,9 @@ function broadCast(value) {
     if (isTree(value)) {
         return value;
     }
+    if (isEmptyTree(value)) {
+        return {};
+    }
     return { "0": [value] };
 }
 function getBranch(tree, path) {
@@ -1880,12 +1889,118 @@ var groupAll = {
     }); },
 };
 
+var normalizeTree = {
+    name: "normalizeTree",
+    label: "Normalize Groups",
+    description: "Normalize a tree to consequtive groups and removed empty groups.",
+    inputs: {
+        tree: "any",
+    },
+    outputs: {
+        tree: "any",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        var normalized;
+        return __generator(this, function (_a) {
+            if (!inputs.tree) {
+                return [2 /*return*/, {}];
+            }
+            normalized = normalizePaths(inputs.tree);
+            return [2 /*return*/, {
+                    tree: mapTreeBranch(normalized, function (branch) {
+                        if (!branch.length) {
+                            return DISCARD;
+                        }
+                        return branch;
+                    }),
+                }];
+        });
+    }); },
+};
+
+var filterTree = {
+    name: "filterTree",
+    label: "Filter Tree",
+    description: "Filter groups by path matchers",
+    inputs: {
+        tree: "any",
+        query: { type: "string", default: "*" },
+    },
+    outputs: {
+        tree: "any",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var queries;
+        return __generator(this, function (_a) {
+            queries = toArray(inputs.query || {}).map(function (q) {
+                return q
+                    .trim()
+                    .split(";")
+                    .map(function (part) {
+                    return new RegExp("^" + part.replace(/\*/g, ".*") + "$");
+                });
+            });
+            return [2 /*return*/, {
+                    tree: mapTreeBranch(inputs.tree || {}, function (branch, path) {
+                        var pathSegments = path.split(";");
+                        var match = queries.some(function (query) {
+                            return query.every(function (regex, i) {
+                                if (!regex.test(pathSegments[i] || "")) {
+                                    return false;
+                                }
+                                return true;
+                            });
+                        });
+                        if (match) {
+                            return branch;
+                        }
+                        else {
+                            return DISCARD;
+                        }
+                    }),
+                }];
+        });
+    }); },
+};
+
+var treeItem = {
+    name: "treeItem",
+    label: "Tree Item",
+    description: "Retrieve the groups from a tree at specified indexes",
+    inputs: {
+        tree: "any",
+        index: { type: "number", default: 0 },
+    },
+    outputs: {
+        tree: "any",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var indices;
+        return __generator(this, function (_a) {
+            indices = toArray(inputs.index || {});
+            return [2 /*return*/, {
+                    tree: mapTreeBranch(inputs.tree || {}, function (branch, path, index) {
+                        if (indices.includes(index)) {
+                            return branch;
+                        }
+                        else {
+                            return DISCARD;
+                        }
+                    }),
+                }];
+        });
+    }); },
+};
+
 var _a$4;
 var primitives$4 = (_a$4 = {},
     _a$4[splitGroup.name] = splitGroup,
     _a$4[mergeGroup.name] = mergeGroup,
     _a$4[groupAll.name] = groupAll,
+    _a$4[filterTree.name] = filterTree,
+    _a$4[treeItem.name] = treeItem,
     _a$4[simplifyTree.name] = simplifyTree,
+    _a$4[normalizeTree.name] = normalizeTree,
     _a$4[cartesianGroups.name] = cartesianGroups,
     _a$4[mergeTree.name] = mergeTree,
     _a$4);
@@ -7485,6 +7600,7 @@ exports.getVariable = getVariable;
 exports.graftTree = graftTree;
 exports.hasReference = hasReference;
 exports.interpolate = interpolate;
+exports.isEmptyTree = isEmptyTree;
 exports.isReference = isReference;
 exports.isSingleTon = isSingleTon;
 exports.isTree = isTree;