@rkmodules/rules 0.0.66 → 0.0.68

package/dist/index.esm.css

@@ -93,7 +93,6 @@
     box-shadow: 0px 0px 3px 2px var(--node-active-line);
 }
 
-
 .Log_dsq5e {
     --bg: var(--log-background, var(--node-background));
     --ln: var(--log-line, var(--node-line));
@@ -120,7 +119,6 @@
     position: relative;
 }
 
-
 .DefaultNode_R2P6c input,
 .DefaultNode_R2P6c select {
     border: 1px solid var(--ln);
@@ -129,7 +127,6 @@
     box-sizing: border-box;
 }
 
-
 .Description_f9s4l {
     font-size: 0.8em;
     opacity: 0.7;
@@ -140,10 +137,6 @@
     max-width: 200px;
 }
 
-
-
-
-
 .PreviewHead_oFT4K {
     margin-top: 16px;
     text-align: center;
@@ -154,15 +147,17 @@
     gap: 8px;
     color: #444;
 }
-.PreviewHead_oFT4K::before, .PreviewHead_oFT4K::after {
-    content: '🠻';
+.PreviewHead_oFT4K::before,
+.PreviewHead_oFT4K::after {
+    content: "🠻";
 }
-.PreviewHead_oFT4K.expanded_3vnbi::before, .PreviewHead_oFT4K.expanded_3vnbi::after {
-    content: '🠹';
+.PreviewHead_oFT4K.expanded_3vnbi::before,
+.PreviewHead_oFT4K.expanded_3vnbi::after {
+    content: "🠹";
 }
 
 .Preview_HbkZ6 {
-    background-color: rgba(0,0,0,0.1);
+    background-color: rgba(0, 0, 0, 0.1);
     border-top: 1px solid var(--ln);
     padding: 4px;
     max-height: 300px;
@@ -178,7 +173,6 @@
     border-top: 1px solid var(--ln);
 }
 
-
 .Table_aZyRT {
     margin: 2px;
     max-height: 400px;
@@ -189,14 +183,13 @@
     border: 1px solid var(--ln);
 }
 
-
 .GroupHead_QJhST {
     display: flex;
     align-items: center;
-    height: 22px;;
+    height: 22px;
 }
 .GroupHead_QJhST::before {
-    content: '🢒';
+    content: "🢒";
     display: flex;
     width: 22px;
     height: 22px;
@@ -205,11 +198,25 @@
     text-align: center;
     font-size: 1.8em;
     color: var(--type-color);
+    transform: rotate(0deg);
+    transition: transform 0.2s ease;
+}
+.GroupHead_QJhST.expanded_3vnbi::before {
     transform: rotate(90deg);
 }
-.GroupHead_QJhST span {
-    opacity: 0.7;
+.GroupName_Qvu4r {
+    opacity: 0.6;
+    font-style: italic;
+    flex: 1;
+}
+.GroupCnt_3ctdd {
+    opacity: 0.6;
+    font-style: italic;
+}
+.GroupMore_D1Kiz {
+    opacity: 0.6;
     font-style: italic;
+    text-align: center;
 }
 
 .GroupChildren_NKx-B {

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 = {
@@ -1029,6 +1188,7 @@ var listItem = {
                 if (indices) {
                     return indices.map(function (i) { return branch[i]; });
                 }
+                return DISCARD;
             });
             others = binaryOnTreeBranch(inputs.list || {}, inputs.index || {}, function (branch, indices) {
                 return branch.filter(function (_, i) { return !(indices === null || indices === void 0 ? void 0 : indices.includes(i)); });
@@ -1104,7 +1264,7 @@ var shiftList = {
             return [2 /*return*/, {
                     list: nAryOnTreeBranch([inputs.list || {}, inputs.step || {}, inputs.wrap || {}], function (_a) {
                         var _b;
-                        var _c = __read(_a, 3), list = _c[0], step = _c[1], wrap = _c[2];
+                        var _c = __read(_a, 3), _d = _c[0], list = _d === void 0 ? [] : _d, _e = _c[1], step = _e === void 0 ? [] : _e, _f = _c[2], wrap = _f === void 0 ? [] : _f;
                         var n = (_b = step[0]) !== null && _b !== void 0 ? _b : 1;
                         if (wrap[0]) {
                             n = n % (list.length || 1);
@@ -1120,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,
@@ -1128,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 = {
@@ -1150,7 +1350,10 @@ var series = {
                         graftTree(inputs.step),
                         graftTree(inputs.count),
                     ], function (_a) {
-                        var _b = __read(_a, 3), _c = __read(_b[0], 1), _d = _c[0], start = _d === void 0 ? 0 : _d, _e = __read(_b[1], 1), _f = _e[0], step = _f === void 0 ? 1 : _f, _g = __read(_b[2], 1), _h = _g[0], count = _h === void 0 ? 10 : _h;
+                        var _b = __read(_a, 3), _c = _b[0], starts = _c === void 0 ? [] : _c, _d = _b[1], steps = _d === void 0 ? [] : _d, _e = _b[2], counts = _e === void 0 ? [] : _e;
+                        var start = starts[0];
+                        var step = steps[0];
+                        var count = counts[0];
                         var series = [];
                         for (var i = 0; i < count; i++) {
                             series.push(start + i * step);
@@ -1196,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 = {
@@ -4523,7 +4749,7 @@ var Output = function (_a) {
             normalized.label || name)));
 };
 
-var styles = {"DefaultNode":"DefaultNode_R2P6c","selected":"selected_VmB-F","active":"active_zjUzx","Log":"Log_dsq5e","Label":"Label_wBwWA","Description":"Description_f9s4l","PreviewHead":"PreviewHead_oFT4K","expanded":"expanded_3vnbi","Preview":"Preview_HbkZ6","Duration":"Duration_0jqWx","GroupHead":"GroupHead_QJhST","GroupChildren":"GroupChildren_NKx-B","GroupLeaf":"GroupLeaf_eliT8"};
+var styles = {"DefaultNode":"DefaultNode_R2P6c","selected":"selected_VmB-F","active":"active_zjUzx","Log":"Log_dsq5e","Label":"Label_wBwWA","Description":"Description_f9s4l","PreviewHead":"PreviewHead_oFT4K","expanded":"expanded_3vnbi","Preview":"Preview_HbkZ6","Duration":"Duration_0jqWx","GroupHead":"GroupHead_QJhST","GroupName":"GroupName_Qvu4r","GroupCnt":"GroupCnt_3ctdd","GroupMore":"GroupMore_D1Kiz","GroupChildren":"GroupChildren_NKx-B","GroupLeaf":"GroupLeaf_eliT8"};
 
 function NodeContainer(_a) {
     var _b;
@@ -4560,48 +4786,67 @@ function NodeContainer(_a) {
 
 function createTreeStructure(tree) {
     var keys = Object.keys(tree);
-    var structure = [];
+    var structure = { name: "root", children: [] };
     keys.forEach(function (key) {
         var path = key.split(";");
         var parent = structure;
         for (var i = 0; i < path.length; i++) {
             var part = parseInt(path[i], 10);
-            if (!parent[part]) {
-                parent[part] = [];
+            if (!parent.children[part]) {
+                parent.children[part] = {
+                    name: path.slice(0, i + 1).join(";"),
+                    children: [],
+                };
             }
-            parent = parent[part];
+            parent = parent.children[part];
         }
-        parent.push({ items: tree[key] });
+        parent.items = tree[key];
     });
     return structure;
 }
 function TreeBranchView(_a) {
-    var branch = _a.branch, name = _a.name;
+    var _b;
+    var _c, _d;
+    var branch = _a.branch;
+    var _e = __read(React.useState(true), 2), expanded = _e[0], setExpanded = _e[1];
+    var isLeaf = !!branch.items;
+    var subCnt = branch.children.length || ((_c = branch.items) === null || _c === void 0 ? void 0 : _c.length) || 0;
+    var maxCnt = 10;
     return (React.createElement("div", null,
-        React.createElement("div", { className: styles.GroupHead },
-            React.createElement("span", null,
+        React.createElement("div", { className: classNames((_b = {}, _b[styles.expanded] = expanded, _b), styles.GroupHead), onClick: function () { return setExpanded(!expanded); } },
+            React.createElement("div", { className: styles.GroupName },
                 "group ",
-                name)),
-        React.createElement("div", { className: styles.GroupChildren }, branch.map(function (item, index) {
-            // sub branch
-            if (Array.isArray(item)) {
-                return (React.createElement(TreeBranchView, { key: index, branch: item, name: "".concat(name, ";").concat(index) }));
-            }
-            // items
-            return (React.createElement("div", { key: index }, item.items.map(function (it, i) {
-                var _a;
-                var label = (_a = it === null || it === void 0 ? void 0 : it.toString) === null || _a === void 0 ? void 0 : _a.call(it);
-                if (label === "[object Object]") {
-                    label = "{...}";
-                }
-                return (React.createElement("div", { key: i, className: styles.GroupLeaf, title: JSON.stringify(it, null, 2) }, label));
-            })));
-        }))));
+                branch.name),
+            React.createElement("div", { className: styles.GroupCnt },
+                "(",
+                subCnt,
+                ")")),
+        expanded && (React.createElement("div", { className: styles.GroupChildren },
+            !isLeaf &&
+                branch.children.map(function (subgroup, index) {
+                    // sub branch
+                    return (React.createElement(TreeBranchView, { key: index, branch: subgroup }));
+                }),
+            isLeaf && (React.createElement(React.Fragment, null, (_d = branch.items) === null || _d === void 0 ? void 0 :
+                _d.slice(0, maxCnt).map(function (item, index) {
+                    var _a;
+                    // items
+                    var label = (_a = item === null || item === void 0 ? void 0 : item.toString) === null || _a === void 0 ? void 0 : _a.call(item);
+                    if (label === "[object Object]") {
+                        label = "{...}";
+                    }
+                    return (React.createElement("div", { key: index },
+                        React.createElement("div", { className: styles.GroupLeaf, title: JSON.stringify(item, null, 2) }, label)));
+                }),
+                branch.items && branch.items.length > maxCnt && (React.createElement("div", { className: styles.GroupMore },
+                    "... ",
+                    branch.items.length - maxCnt,
+                    " more"))))))));
 }
 function TreeView(_a) {
     var value = _a.value;
     var structure = createTreeStructure(value || {});
-    return (React.createElement("div", null, structure.map(function (branch, index) { return (React.createElement(TreeBranchView, { key: index, branch: branch, name: index })); })));
+    return (React.createElement("div", null, structure.children.map(function (branch, index) { return (React.createElement(TreeBranchView, { key: index, branch: branch })); })));
 }
 var Log = React.memo(function (_a) {
     var id = _a.id, data = _a.data, selected = _a.selected;
@@ -4637,9 +4882,10 @@ function GenericNode(_a) {
     var previewValue = focus ? result[focus] : Object.values(result)[0];
     React.useEffect(function () {
         return engine.subscribe("functionResult", function (event) {
+            var _a;
             if (event.name === id) {
                 setResult(event.result || {});
-                setDuration(event.duration || null);
+                setDuration((_a = event.duration) !== null && _a !== void 0 ? _a : null);
             }
         });
     }, []);
@@ -4664,7 +4910,7 @@ function GenericNode(_a) {
                 _b)), onClick: function () { return setShowPreview(!showPreview); } }, "Preview"),
         showPreview && (React.createElement("div", { className: styles.Preview },
             React.createElement(TreeView, { value: previewValue }),
-            duration && (React.createElement("div", { className: styles.Duration },
+            duration !== null && (React.createElement("div", { className: styles.Duration },
                 duration.toFixed(2),
                 " ms"))))));
 }
@@ -6129,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