@rkmodules/rules 0.0.67 → 0.0.68

package/dist/index.esm.js

@@ -136,7 +136,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
@@ -252,6 +252,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
@@ -651,6 +654,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),
                 }];
@@ -817,6 +822,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",
@@ -832,6 +860,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;
@@ -901,6 +931,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",
@@ -916,6 +970,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),
                 }];
@@ -923,6 +979,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",
@@ -938,6 +1066,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),
                 }];
@@ -945,6 +1075,29 @@ 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,
@@ -954,6 +1107,12 @@ var primitives$5 = (_a$5 = {},
     _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 = {
@@ -1121,6 +1280,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,
@@ -1129,6 +1327,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 = {
@@ -1200,9 +1399,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 = {
@@ -6153,5 +6375,5 @@ function DDContext(_a) {
     return React.createElement(DndProvider, { backend: HTML5Backend }, children);
 }
 
-export { DDContext, DISCARD, Engine, Flow, Lib, binaryOnTree, binaryOnTreeBranch, broadCast, expandTree, getBranch, getReferences, getValue$1 as getValue, graftTree, hasReference, interpolate, isReference, isSingleTon, isTree, mapTree, mapTreeBranch, nAryOnTree, nAryOnTreeBranch, normalizeVarDef, parseReference, primitives, sameShape, simplifyTree, toArray, topSort, treeSize, trimTree, uid$1 as uid, useDraggableNode, useFlow, useFunction, usePositions, useUpdatePositions, useVariable };
+export { DDContext, DISCARD, Engine, Flow, Lib, binaryOnTree, binaryOnTreeBranch, broadCast, expandTree, getBranch, getPaths, getReferences, getValue$1 as getValue, graftTree, hasReference, interpolate, isReference, isSingleTon, isTree, mapTree, mapTreeBranch, nAryOnTree, nAryOnTreeBranch, normalizeVarDef, parseReference, primitives, sameShape, simplifyTree$1 as simplifyTree, toArray, topSort, treeSize, trimTree, uid$1 as uid, useDraggableNode, useFlow, useFunction, usePositions, useUpdatePositions, useVariable };
 //# sourceMappingURL=index.esm.js.map