@rkmodules/rules 0.0.67 → 0.0.69

package/dist/index.cjs.js

@@ -138,7 +138,7 @@ var DISCARD = Symbol("DISCARD");
  * @param tree
  * @returns
  */
-function simplifyTree(tree) {
+function simplifyTree$1(tree) {
     var keys = Object.keys(tree);
     if (keys.length <= 1)
         return tree; // ✅ Don't simplify if only one path
@@ -254,6 +254,9 @@ function broadCast(value) {
 function getBranch(tree, path) {
     return tree[path];
 }
+function getPaths(tree) {
+    return Object.keys(tree);
+}
 /**
  * maps a tree, the tree branches are flatmapped, so if an array is returned for each item in the list, a flat list is returned
  * @param tree
@@ -653,6 +656,8 @@ var add$1 = {
         return __generator(this, function (_a) {
             return [2 /*return*/, {
                     sum: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        if (itemA === undefined || itemB === undefined)
+                            return DISCARD;
                         return itemA + itemB;
                     }, true),
                 }];
@@ -819,6 +824,29 @@ function getUnboundSymbols(expr, scope, extraBound) {
     return Array.from(free).sort();
 }
 
+var cosDeg = {
+    name: "cosDeg",
+    label: "Cosine",
+    description: "Cosine of angle in degrees",
+    inputs: {
+        a: { type: "number", default: 0 },
+    },
+    outputs: {
+        cos: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    cos: mapTree(inputs.a, function (angle) {
+                        if (angle === undefined)
+                            return DISCARD;
+                        return Math.cos((angle * Math.PI) / 180);
+                    }),
+                }];
+        });
+    }); },
+};
+
 var divide = {
     name: "divide",
     label: "Divide",
@@ -834,6 +862,8 @@ var divide = {
         return __generator(this, function (_a) {
             return [2 /*return*/, {
                     quotient: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        if (itemA === undefined || itemB === undefined)
+                            return DISCARD;
                         if (itemB === 0)
                             return DISCARD;
                         return itemA / itemB;
@@ -843,6 +873,36 @@ var divide = {
     }); },
 };
 
+var equalTo = {
+    name: "equalTo",
+    label: "Equal to",
+    description: "Compare equal and not equal",
+    inputs: {
+        a: { type: "number", default: 0 },
+        b: { type: "number", default: 0 },
+    },
+    outputs: {
+        eq: "boolean",
+        neq: "boolean",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    eq: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        if (itemA === undefined || itemB === undefined)
+                            return DISCARD;
+                        return itemA === itemB;
+                    }, true),
+                    neq: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        if (itemA === undefined || itemB === undefined)
+                            return DISCARD;
+                        return itemA !== itemB;
+                    }, true),
+                }];
+        });
+    }); },
+};
+
 var greaterThan = {
     name: "greaterThan",
     label: "Greater Than",
@@ -903,6 +963,30 @@ var lessThan = {
     }); },
 };
 
+var modulo = {
+    name: "modulo",
+    label: "Modulo",
+    description: "Division remainder of two numbers",
+    inputs: {
+        a: { type: "number", default: 1 },
+        b: { type: "number", default: 1 },
+    },
+    outputs: {
+        mod: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    mod: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        if (itemA === undefined || itemB === undefined)
+                            return DISCARD;
+                        return itemA % itemB;
+                    }, true),
+                }];
+        });
+    }); },
+};
+
 var multiply = {
     name: "multiply",
     label: "Multiply",
@@ -918,6 +1002,8 @@ var multiply = {
         return __generator(this, function (_a) {
             return [2 /*return*/, {
                     product: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        if (itemA === undefined || itemB === undefined)
+                            return DISCARD;
                         return itemA * itemB;
                     }, true),
                 }];
@@ -925,6 +1011,78 @@ var multiply = {
     }); },
 };
 
+var pow = {
+    name: "pow",
+    label: "Power",
+    description: "Power a number",
+    inputs: {
+        x: { type: "number", default: 0 },
+        n: { type: "number", default: 2 },
+    },
+    outputs: {
+        pow: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    pow: binaryOnTree(inputs.x, inputs.n, function (x, n) {
+                        if (x === undefined || n === undefined)
+                            return DISCARD;
+                        return Math.pow(x, n);
+                    }),
+                }];
+        });
+    }); },
+};
+
+var sinDeg = {
+    name: "sinDeg",
+    label: "Sine",
+    description: "Sine of angle in degrees",
+    inputs: {
+        a: { type: "number", default: 0 },
+    },
+    outputs: {
+        sin: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    sin: mapTree(inputs.a, function (angle) {
+                        if (angle === undefined)
+                            return DISCARD;
+                        return Math.sin((angle * Math.PI) / 180);
+                    }),
+                }];
+        });
+    }); },
+};
+
+var sqrt = {
+    name: "sqrt",
+    label: "Square root",
+    description: "Square root of a number",
+    inputs: {
+        x: { type: "number", default: 0 },
+    },
+    outputs: {
+        sqrt: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    sqrt: mapTree(inputs.x, function (x) {
+                        if (x === undefined)
+                            return DISCARD;
+                        if (x < 0)
+                            return DISCARD;
+                        return Math.sqrt(x);
+                    }),
+                }];
+        });
+    }); },
+};
+
 var subtract$1 = {
     name: "subtract",
     label: "Subtract",
@@ -940,6 +1098,8 @@ var subtract$1 = {
         return __generator(this, function (_a) {
             return [2 /*return*/, {
                     difference: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        if (itemA === undefined || itemB === undefined)
+                            return DISCARD;
                         return itemA - itemB;
                     }, true),
                 }];
@@ -947,15 +1107,45 @@ var subtract$1 = {
     }); },
 };
 
+var tanDeg = {
+    name: "tanDeg",
+    label: "Tangent",
+    description: "Tangent of angle in degrees",
+    inputs: {
+        a: { type: "number", default: 0 },
+    },
+    outputs: {
+        tan: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    tan: mapTree(inputs.a, function (angle) {
+                        if (angle === undefined)
+                            return DISCARD;
+                        return Math.tan((angle * Math.PI) / 180);
+                    }),
+                }];
+        });
+    }); },
+};
+
 var _a$5;
 var primitives$5 = (_a$5 = {},
     _a$5[calc.name] = calc,
+    _a$5[equalTo.name] = equalTo,
     _a$5[lessThan.name] = lessThan,
     _a$5[greaterThan.name] = greaterThan,
     _a$5[add$1.name] = add$1,
     _a$5[subtract$1.name] = subtract$1,
     _a$5[multiply.name] = multiply,
     _a$5[divide.name] = divide,
+    _a$5[modulo.name] = modulo,
+    _a$5[sinDeg.name] = sinDeg,
+    _a$5[cosDeg.name] = cosDeg,
+    _a$5[tanDeg.name] = tanDeg,
+    _a$5[sqrt.name] = sqrt,
+    _a$5[pow.name] = pow,
     _a$5);
 
 var filterList = {
@@ -966,24 +1156,35 @@ var filterList = {
         list: "any",
         keep: "boolean",
     },
+    params: {
+        removeEmpty: { type: "boolean", default: false },
+    },
     outputs: {
         list: "any",
         others: "any",
     },
-    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, {
                     list: binaryOnTreeBranch(inputs.list || {}, inputs.keep || {}, function (branchA, branchB) {
-                        return branchA.filter(function (item, index) {
+                        var result = branchA.filter(function (item, index) {
                             return (branchB[Math.min(index, branchB.length - 1)] ===
                                 true);
                         });
+                        if (!result.length && params.removeEmpty) {
+                            return DISCARD;
+                        }
+                        return result;
                     }),
                     others: binaryOnTreeBranch(inputs.list || {}, inputs.keep || {}, function (branchA, branchB) {
-                        return branchA.filter(function (item, index) {
+                        var result = branchA.filter(function (item, index) {
                             return (branchB[Math.min(index, branchB.length - 1)] ===
                                 false);
                         });
+                        if (!result.length && params.removeEmpty) {
+                            return DISCARD;
+                        }
+                        return result;
                     }),
                 }];
         });
@@ -1123,6 +1324,45 @@ var shiftList = {
     }); },
 };
 
+var cartesianGroups = {
+    name: "cartesianGroups",
+    label: "Cartesian Groups",
+    description: "Duplicate groups such that all pairings are created.",
+    inputs: {
+        treeA: "any",
+        treeB: "any",
+    },
+    params: {},
+    outputs: {
+        treeA: "any",
+        treeB: "any",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var pathsA, pathsB, treeA, treeB;
+        return __generator(this, function (_a) {
+            if (!inputs.treeA || !inputs.treeB) {
+                return [2 /*return*/, {}];
+            }
+            pathsA = getPaths(inputs.treeA);
+            pathsB = getPaths(inputs.treeB);
+            treeA = {};
+            treeB = {};
+            pathsB.forEach(function (pathB, ib) {
+                pathsA.forEach(function (pathA, ia) {
+                    var pa = "".concat(ib, ";").concat(pathA);
+                    treeA[pa] = inputs.treeA[pathA];
+                    var pb = "".concat(pathB, ";").concat(ia);
+                    treeB[pb] = inputs.treeB[pathB];
+                });
+            });
+            return [2 /*return*/, {
+                    treeA: treeA,
+                    treeB: treeB,
+                }];
+        });
+    }); },
+};
+
 var _a$4;
 var primitives$4 = (_a$4 = {},
     _a$4[splitGroup.name] = splitGroup,
@@ -1131,6 +1371,7 @@ var primitives$4 = (_a$4 = {},
     _a$4[listLength.name] = listLength,
     _a$4[filterList.name] = filterList,
     _a$4[shiftList.name] = shiftList,
+    _a$4[cartesianGroups.name] = cartesianGroups,
     _a$4);
 
 var series = {
@@ -1202,9 +1443,32 @@ var mergeTree = {
     }); },
 };
 
+var simplifyTree = {
+    name: "simplifyTree",
+    label: "Simplify Tree",
+    description: "Simplify a tree by removing redundant groups.",
+    inputs: {
+        tree: "any",
+    },
+    outputs: {
+        tree: "any",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            if (!inputs.tree) {
+                return [2 /*return*/, {}];
+            }
+            return [2 /*return*/, {
+                    tree: simplifyTree$1(inputs.tree),
+                }];
+        });
+    }); },
+};
+
 var _a$2;
 var primitives$2 = (_a$2 = {},
     _a$2[mergeTree.name] = mergeTree,
+    _a$2[simplifyTree.name] = simplifyTree,
     _a$2);
 
 var groupAnd = {
@@ -1220,7 +1484,7 @@ var groupAnd = {
     impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, {
-                    result: mapTreeBranch(inputs.tree, function (branch) {
+                    result: mapTreeBranch(inputs.tree || {}, function (branch) {
                         return [branch.reduce(function (acc, val) { return acc && val; }, true)];
                     }),
                 }];
@@ -1241,7 +1505,7 @@ var groupOr = {
     impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             return [2 /*return*/, {
-                    result: mapTreeBranch(inputs.tree, function (branch) {
+                    result: mapTreeBranch(inputs.tree || {}, function (branch) {
                         return [branch.reduce(function (acc, val) { return acc || val; }, false)];
                     }),
                 }];
@@ -6165,6 +6429,7 @@ exports.binaryOnTreeBranch = binaryOnTreeBranch;
 exports.broadCast = broadCast;
 exports.expandTree = expandTree;
 exports.getBranch = getBranch;
+exports.getPaths = getPaths;
 exports.getReferences = getReferences;
 exports.getValue = getValue$1;
 exports.graftTree = graftTree;
@@ -6181,7 +6446,7 @@ exports.normalizeVarDef = normalizeVarDef;
 exports.parseReference = parseReference;
 exports.primitives = primitives;
 exports.sameShape = sameShape;
-exports.simplifyTree = simplifyTree;
+exports.simplifyTree = simplifyTree$1;
 exports.toArray = toArray;
 exports.topSort = topSort;
 exports.treeSize = treeSize;