@rkmodules/rules 0.0.111 → 0.0.112

package/dist/index.esm.js

@@ -1878,12 +1878,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);