@rkmodules/rules 0.0.116 → 0.0.118

package/dist/index.cjs.js

@@ -767,13 +767,13 @@ var value = {
     }); },
 };
 
-var _a$8;
-var primitives$8 = (_a$8 = {},
-    _a$8[getValue.name] = getValue,
-    _a$8[log.name] = log,
-    _a$8[value.name] = value,
-    _a$8[getType.name] = getType,
-    _a$8);
+var _a$9;
+var primitives$9 = (_a$9 = {},
+    _a$9[getValue.name] = getValue,
+    _a$9[log.name] = log,
+    _a$9[value.name] = value,
+    _a$9[getType.name] = getType,
+    _a$9);
 
 function isNumber() {
     var ns = [];
@@ -1384,27 +1384,27 @@ var sum = {
     }); },
 };
 
-var _a$7;
-var primitives$7 = (_a$7 = {},
-    _a$7[calc.name] = calc,
-    _a$7[equalTo.name] = equalTo,
-    _a$7[lessThan.name] = lessThan,
-    _a$7[greaterThan.name] = greaterThan,
-    _a$7[add$1.name] = add$1,
-    _a$7[subtract$1.name] = subtract$1,
-    _a$7[multiply.name] = multiply,
-    _a$7[divide.name] = divide,
-    _a$7[modulo.name] = modulo,
-    _a$7[sinDeg.name] = sinDeg,
-    _a$7[cosDeg.name] = cosDeg,
-    _a$7[tanDeg.name] = tanDeg,
-    _a$7[sqrt.name] = sqrt,
-    _a$7[pow.name] = pow,
-    _a$7[round.name] = round,
-    _a$7[ceil.name] = ceil,
-    _a$7[floor.name] = floor,
-    _a$7[sum.name] = sum,
-    _a$7);
+var _a$8;
+var primitives$8 = (_a$8 = {},
+    _a$8[calc.name] = calc,
+    _a$8[equalTo.name] = equalTo,
+    _a$8[lessThan.name] = lessThan,
+    _a$8[greaterThan.name] = greaterThan,
+    _a$8[add$1.name] = add$1,
+    _a$8[subtract$1.name] = subtract$1,
+    _a$8[multiply.name] = multiply,
+    _a$8[divide.name] = divide,
+    _a$8[modulo.name] = modulo,
+    _a$8[sinDeg.name] = sinDeg,
+    _a$8[cosDeg.name] = cosDeg,
+    _a$8[tanDeg.name] = tanDeg,
+    _a$8[sqrt.name] = sqrt,
+    _a$8[pow.name] = pow,
+    _a$8[round.name] = round,
+    _a$8[ceil.name] = ceil,
+    _a$8[floor.name] = floor,
+    _a$8[sum.name] = sum,
+    _a$8);
 
 var joinStrings = {
     name: "joinStrings",
@@ -1483,12 +1483,12 @@ var toString = {
     }); },
 };
 
-var _a$6;
-var primitives$6 = (_a$6 = {},
-    _a$6[toString.name] = toString,
-    _a$6[joinStrings.name] = joinStrings,
-    _a$6[stringEqualTo.name] = stringEqualTo,
-    _a$6);
+var _a$7;
+var primitives$7 = (_a$7 = {},
+    _a$7[toString.name] = toString,
+    _a$7[joinStrings.name] = joinStrings,
+    _a$7[stringEqualTo.name] = stringEqualTo,
+    _a$7);
 
 var filterList = {
     name: "filterList",
@@ -1720,43 +1720,47 @@ var listInput = {
     },
     outputs: {
         tree: "string",
+        array: "array",
     },
     impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        var tree;
         return __generator(this, function (_a) {
+            tree = mapTreeBranch(inputs.list || {}, function (branch) {
+                if (!branch || branch.length === 0)
+                    return DISCARD;
+                var allLines = branch.flatMap(function (text) {
+                    return text.replace(/(^[\n\r]+)|([\n\r]+$)/, "").split("\n");
+                });
+                if (allLines.every(function (line) { return isBoolStr(line); })) {
+                    allLines = allLines.map(function (line) { return line.toLowerCase() === "true"; });
+                }
+                else if (allLines.every(function (line) { return isNumStr(line); })) {
+                    allLines = allLines.map(function (line) {
+                        if (!line)
+                            return undefined;
+                        return Number(line);
+                    });
+                }
+                return allLines;
+            });
             return [2 /*return*/, {
-                    tree: mapTreeBranch(inputs.list || {}, function (branch) {
-                        if (!branch || branch.length === 0)
-                            return DISCARD;
-                        var allLines = branch.flatMap(function (text) {
-                            return text.replace(/(^[\n\r]+)|([\n\r]+$)/, "").split("\n");
-                        });
-                        if (allLines.every(function (line) { return isBoolStr(line); })) {
-                            allLines = allLines.map(function (line) { return line.toLowerCase() === "true"; });
-                        }
-                        else if (allLines.every(function (line) { return isNumStr(line); })) {
-                            allLines = allLines.map(function (line) {
-                                if (!line)
-                                    return undefined;
-                                return Number(line);
-                            });
-                        }
-                        return allLines;
-                    }),
+                    tree: tree,
+                    array: mapTreeBranch(tree, function (branch) { return [branch]; }),
                 }];
         });
     }); },
 };
 
-var _a$5;
-var primitives$5 = (_a$5 = {},
-    _a$5[listInput.name] = listInput,
-    _a$5[listItem.name] = listItem,
-    _a$5[listLength.name] = listLength,
-    _a$5[filterList.name] = filterList,
-    _a$5[relativeItem.name] = relativeItem,
-    _a$5[relativeItems.name] = relativeItems,
-    _a$5[concat.name] = concat,
-    _a$5);
+var _a$6;
+var primitives$6 = (_a$6 = {},
+    _a$6[listInput.name] = listInput,
+    _a$6[listItem.name] = listItem,
+    _a$6[listLength.name] = listLength,
+    _a$6[filterList.name] = filterList,
+    _a$6[relativeItem.name] = relativeItem,
+    _a$6[relativeItems.name] = relativeItems,
+    _a$6[concat.name] = concat,
+    _a$6);
 
 var splitGroup = {
     name: "splitGroup",
@@ -1844,8 +1848,8 @@ var cartesianGroups = {
 var mergeTree = {
     name: "mergeTree",
     label: "Merge Tree",
-    description: "Merge multiple trees into a single tree.",
-    nodeType: "Merge",
+    description: "Merge groups with the same index into a single tree.",
+    nodeType: "DynamicInput",
     inputs: {},
     outputs: {
         result: "any",
@@ -1854,14 +1858,13 @@ var mergeTree = {
         var result;
         return __generator(this, function (_a) {
             result = {};
-            Object.values(inputs).forEach(function (input) {
-                Object.entries(input).forEach(function (_a) {
-                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
-                    if (!result[key]) {
-                        result[key] = value;
+            Object.values(inputs).forEach(function (tree) {
+                forEachBranch(tree, function (branch, path) {
+                    if (!result[path]) {
+                        result[path] = branch;
                     }
                     else {
-                        result[key] = __spreadArray(__spreadArray([], __read(result[key]), false), __read(value), false);
+                        result[path] = __spreadArray(__spreadArray([], __read(result[path]), false), __read(branch), false);
                     }
                 });
             });
@@ -2019,18 +2022,18 @@ var treeItem = {
     }); },
 };
 
-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);
+var _a$5;
+var primitives$5 = (_a$5 = {},
+    _a$5[splitGroup.name] = splitGroup,
+    _a$5[mergeGroup.name] = mergeGroup,
+    _a$5[groupAll.name] = groupAll,
+    _a$5[filterTree.name] = filterTree,
+    _a$5[treeItem.name] = treeItem,
+    _a$5[simplifyTree.name] = simplifyTree,
+    _a$5[normalizeTree.name] = normalizeTree,
+    _a$5[cartesianGroups.name] = cartesianGroups,
+    _a$5[mergeTree.name] = mergeTree,
+    _a$5);
 
 var series = {
     name: "series",
@@ -2067,10 +2070,10 @@ var series = {
     }); },
 };
 
-var _a$3;
-var primitives$3 = (_a$3 = {},
-    _a$3[series.name] = series,
-    _a$3);
+var _a$4;
+var primitives$4 = (_a$4 = {},
+    _a$4[series.name] = series,
+    _a$4);
 
 var groupAnd = {
     name: "groupAnd",
@@ -2168,12 +2171,12 @@ var groupStats = {
     }); },
 };
 
-var _a$2;
-var primitives$2 = (_a$2 = {},
-    _a$2[groupAnd.name] = groupAnd,
-    _a$2[groupOr.name] = groupOr,
-    _a$2[groupStats.name] = groupStats,
-    _a$2);
+var _a$3;
+var primitives$3 = (_a$3 = {},
+    _a$3[groupAnd.name] = groupAnd,
+    _a$3[groupOr.name] = groupOr,
+    _a$3[groupStats.name] = groupStats,
+    _a$3);
 
 var inputs = {
     name: "inputs",
@@ -2203,14 +2206,134 @@ var output = {
     }); },
 };
 
+var _a$2;
+var primitives$2 = (_a$2 = {},
+    _a$2[inputs.name] = inputs,
+    _a$2[output.name] = output,
+    _a$2);
+
+var mergeObject = {
+    name: "mergeObject",
+    label: "Merge Object",
+    description: "Merges objects in groups",
+    nodeType: "DynamicInput",
+    inputs: {},
+    outputs: {
+        object: "any",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        var object;
+        return __generator(this, function (_a) {
+            object = {};
+            Object.values(inputs).forEach(function (tree) {
+                forEachBranch(tree, function (branch, path) {
+                    if (!object[path]) {
+                        object[path] = [{}];
+                    }
+                    object[path] = [Object.assign.apply(Object, __spreadArray([object[path][0]], __read(branch), false))];
+                });
+            });
+            return [2 /*return*/, {
+                    object: object,
+                }];
+        });
+    }); },
+};
+
+var object = {
+    name: "object",
+    label: "Object",
+    description: "Creates an object",
+    inputs: {
+        key: "string",
+        value: "string",
+    },
+    outputs: {
+        object: "any",
+    },
+    impl: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var pairs;
+        var _c = _b.key, key = _c === void 0 ? {} : _c, _d = _b.value, value = _d === void 0 ? {} : _d;
+        return __generator(this, function (_e) {
+            pairs = binaryOnTree(key, value, function (k, v) {
+                return [[k, v]];
+            }, true);
+            return [2 /*return*/, {
+                    object: mapTreeBranch(pairs, function (pairs) {
+                        return [Object.fromEntries(pairs)];
+                    }),
+                }];
+        });
+    }); },
+};
+
+var listToArray = {
+    name: "listToArray",
+    label: "To Array",
+    description: "Converts each branch to an array",
+    inputs: {
+        items: "any",
+    },
+    outputs: {
+        arrays: "any",
+    },
+    impl: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var _c = _b.items, items = _c === void 0 ? {} : _c;
+        return __generator(this, function (_d) {
+            return [2 /*return*/, {
+                    arrays: mapTreeBranch(items, function (items) {
+                        return [items];
+                    }),
+                }];
+        });
+    }); },
+};
+
+var objectEntries = {
+    name: "objectEntries",
+    label: "Entries",
+    description: "Gets keys and pairs of an object",
+    inputs: {
+        object: "any",
+    },
+    outputs: {
+        keys: "string",
+        values: "any",
+    },
+    impl: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+        var keys, values;
+        var _c = _b.object, object = _c === void 0 ? {} : _c;
+        return __generator(this, function (_d) {
+            keys = mapTree(object, function (obj) { return Object.keys(obj); });
+            values = mapTree(object, function (obj) { return Object.values(obj); });
+            return [2 /*return*/, {
+                    keys: keys,
+                    values: values,
+                }];
+        });
+    }); },
+};
+
 var _a$1;
 var primitives$1 = (_a$1 = {},
-    _a$1[inputs.name] = inputs,
-    _a$1[output.name] = output,
+    _a$1[object.name] = object,
+    _a$1[listToArray.name] = listToArray,
+    _a$1[mergeObject.name] = mergeObject,
+    _a$1[objectEntries.name] = objectEntries,
     _a$1);
 
-var Lib = { Util: primitives$8, Math: primitives$7, String: primitives$6, List: primitives$5, Group: primitives$4, Sequence: primitives$3, Logic: primitives$2, IO: primitives$1 };
-var primitives = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, primitives$1), primitives$8), primitives$7), primitives$6), primitives$5), primitives$4), primitives$3), primitives$2);
+var Lib = {
+    Util: primitives$9,
+    Math: primitives$8,
+    String: primitives$7,
+    List: primitives$6,
+    Group: primitives$5,
+    Sequence: primitives$4,
+    Logic: primitives$3,
+    IO: primitives$2,
+    Json: primitives$1,
+};
+var primitives = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, primitives$2), primitives$9), primitives$8), primitives$7), primitives$6), primitives$5), primitives$4), primitives$3), primitives$1);
 
 function isPrimitive(node) {
     return node.impl !== undefined;
@@ -5986,54 +6109,17 @@ InputNode.displayName = "InputNode";
 function uid() {
     return Math.random().toString(36).substring(2, 15);
 }
-var Merge = React.memo(function (_a) {
-    var _b;
-    var _c;
+var DynamicInput = React.memo(function (_a) {
     var id = _a.id, data = _a.data, selected = _a.selected;
-    var outputEntries = Object.entries(data.outputDefs || {});
-    var focus = (_c = outputEntries[0]) === null || _c === void 0 ? void 0 : _c[0];
-    var _d = __read(React.useState(false), 2), showPreview = _d[0], setShowPreview = _d[1];
-    var engine = useEngine();
-    var _e = __read(React.useState({}), 2), result = _e[0], setResult = _e[1];
-    var _f = __read(React.useState(null), 2), duration = _f[0], setDuration = _f[1];
-    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((_a = event.duration) !== null && _a !== void 0 ? _a : null);
-            }
-        });
-    }, []);
     var inputs = Object.fromEntries(Object.keys(data.inputs || {}).map(function (name, i) { return [
         name,
         { type: "any", label: "D".concat(i + 1) },
     ]; }));
     var inputCount = Object.keys(inputs).length;
     inputs[uid()] = { type: "any", label: "D".concat(inputCount + 1) };
-    var outputs = __assign({}, (data.outputDefs || {}));
-    return (React.createElement(NodeContainer, { label: data.label, selected: selected, id: id },
-        React.createElement("div", { className: styles.Description }, data.description),
-        React.createElement("div", { className: styles.Ports },
-            Object.entries(outputs || {}).map(function (_a) {
-                var _b = __read(_a, 2), name = _b[0], varDef = _b[1];
-                return (React.createElement(Output, { key: name, name: name, varDef: varDef, id: id }));
-            }),
-            Object.entries(inputs || {}).map(function (_a) {
-                var _b = __read(_a, 2), name = _b[0], varDef = _b[1];
-                return (React.createElement(Input, { key: name, name: name, varDef: varDef, id: id, data: data }));
-            })),
-        React.createElement("div", { className: classNames(styles.PreviewHead, (_b = {},
-                _b[styles.expanded] = showPreview,
-                _b)), onClick: function () { return setShowPreview(!showPreview); } }, "Preview"),
-        showPreview && (React.createElement("div", { className: styles.Preview },
-            React.createElement(TreeView, { value: previewValue }),
-            duration !== null && (React.createElement("div", { className: styles.Duration },
-                duration.toFixed(2),
-                " ms"))))));
+    return (React.createElement(GenericNode, { inputs: inputs, id: id, data: data, selected: selected }));
 });
-Merge.displayName = "MergeNode";
+DynamicInput.displayName = "DynamicInputNode";
 
 /**
  * todo: create a factory for output component
@@ -6133,11 +6219,28 @@ var OutputNode = React.memo(function (_a) {
 });
 OutputNode.displayName = "OutputNode";
 
+var DynamicOutput = React.memo(function (_a) {
+    var id = _a.id, data = _a.data, selected = _a.selected;
+    var _b = __read(React.useState({}), 2), outputs = _b[0], setOutputs = _b[1];
+    var engine = useEngine();
+    React.useEffect(function () {
+        return engine.subscribe("functionResult", function (event) {
+            if (event.name === id) {
+                var result = event.result || {};
+                setOutputs(Object.fromEntries(Object.keys(result).map(function (name, i) { return [name, "any"]; })));
+            }
+        });
+    }, []);
+    return (React.createElement(GenericNode, { outputs: outputs, id: id, data: data, selected: selected }));
+});
+DynamicOutput.displayName = "DynamicOutputNode";
+
 var nodeTypes = {
     Default: Default,
     Calc: Calc,
     Log: Log,
-    Merge: Merge,
+    DynamicInput: DynamicInput,
+    DynamicOutput: DynamicOutput,
     Input: InputNode,
     Output: OutputNode,
 };
@@ -7616,6 +7719,7 @@ exports.DDContext = DDContext;
 exports.DISCARD = DISCARD;
 exports.Engine = Engine;
 exports.Flow = Flow;
+exports.GenericNode = GenericNode;
 exports.Lib = Lib;
 exports.binaryOnTree = binaryOnTree;
 exports.binaryOnTreeBranch = binaryOnTreeBranch;