@rkmodules/rules 0.0.75 → 0.0.77

package/dist/index.esm.js

@@ -633,12 +633,12 @@ var value = {
     }); },
 };
 
-var _a$6;
-var primitives$6 = (_a$6 = {},
-    _a$6[getValue.name] = getValue,
-    _a$6[log.name] = log,
-    _a$6[value.name] = value,
-    _a$6);
+var _a$7;
+var primitives$7 = (_a$7 = {},
+    _a$7[getValue.name] = getValue,
+    _a$7[log.name] = log,
+    _a$7[value.name] = value,
+    _a$7);
 
 var add$1 = {
     name: "add",
@@ -1129,23 +1129,23 @@ var tanDeg = {
     }); },
 };
 
-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 _a$6;
+var primitives$6 = (_a$6 = {},
+    _a$6[calc.name] = calc,
+    _a$6[equalTo.name] = equalTo,
+    _a$6[lessThan.name] = lessThan,
+    _a$6[greaterThan.name] = greaterThan,
+    _a$6[add$1.name] = add$1,
+    _a$6[subtract$1.name] = subtract$1,
+    _a$6[multiply.name] = multiply,
+    _a$6[divide.name] = divide,
+    _a$6[modulo.name] = modulo,
+    _a$6[sinDeg.name] = sinDeg,
+    _a$6[cosDeg.name] = cosDeg,
+    _a$6[tanDeg.name] = tanDeg,
+    _a$6[sqrt.name] = sqrt,
+    _a$6[pow.name] = pow,
+    _a$6);
 
 var filterList = {
     name: "filterList",
@@ -1290,39 +1290,6 @@ var mergeGroup = {
     }); },
 };
 
-var shiftList = {
-    name: "shiftList",
-    label: "Shift List",
-    description: "Shifts the list to the left, removing the first element and adding it at the end if wrap is enabled",
-    inputs: {
-        list: "any",
-        step: { type: "number", default: 1, step: 1 },
-        wrap: "boolean",
-    },
-    outputs: {
-        list: "any",
-    },
-    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, {
-                    list: nAryOnTreeBranch([inputs.list || {}, inputs.step || {}, inputs.wrap || {}], function (_a) {
-                        var _b;
-                        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);
-                        }
-                        var shifted = list.slice(n);
-                        if (wrap[0]) {
-                            shifted.push.apply(shifted, __spreadArray([], __read(list.slice(0, n)), false));
-                        }
-                        return shifted;
-                    }),
-                }];
-        });
-    }); },
-};
-
 var cartesianGroups = {
     name: "cartesianGroups",
     label: "Cartesian Groups",
@@ -1388,17 +1355,96 @@ var concat = {
     }); },
 };
 
-var _a$4;
-var primitives$4 = (_a$4 = {},
-    _a$4[splitGroup.name] = splitGroup,
-    _a$4[mergeGroup.name] = mergeGroup,
-    _a$4[listItem.name] = listItem,
-    _a$4[listLength.name] = listLength,
-    _a$4[filterList.name] = filterList,
-    _a$4[shiftList.name] = shiftList,
-    _a$4[cartesianGroups.name] = cartesianGroups,
-    _a$4[concat.name] = concat,
-    _a$4);
+var relativeItem = {
+    name: "relativeItem",
+    label: "Relative Item",
+    description: "Pairs each item in the tree with its next item",
+    inputs: {
+        tree: { type: "any" },
+        offset: { type: "number", default: 1, step: 1 },
+    },
+    params: {
+        wrap: { type: "boolean", default: true },
+    },
+    outputs: {
+        itemA: "any",
+        itemB: "any",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    itemA: inputs.tree || {},
+                    itemB: binaryOnTreeBranch(inputs.tree || {}, inputs.offset || {}, function (branch, offsets) {
+                        var mapped = branch.map(function (_, i) {
+                            var _a, _b;
+                            var offset = (_a = offsets[0]) !== null && _a !== void 0 ? _a : 1;
+                            var index = i + offset;
+                            if (params.wrap) {
+                                index = index % branch.length;
+                                if (index < 0)
+                                    index += branch.length;
+                            }
+                            return (_b = branch[index]) !== null && _b !== void 0 ? _b : DISCARD;
+                        });
+                        return mapped.filter(function (v) { return v !== DISCARD; });
+                    }),
+                }];
+        });
+    }); },
+};
+
+var relativeItems = {
+    name: "relativeItems",
+    label: "Relative Items",
+    description: "Pairs each item in the tree with an item in another tree at a specified offset",
+    inputs: {
+        treeA: { type: "any" },
+        treeB: { type: "any" },
+        offset: { type: "number", default: 1, step: 1 },
+    },
+    params: {
+        wrap: { type: "boolean", default: true },
+    },
+    outputs: {
+        itemA: "any",
+        itemB: "any",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    itemA: inputs.treeA || {},
+                    itemB: binaryOnTreeBranch(inputs.treeB || {}, inputs.offset || {}, function (branch, offsets) {
+                        var mapped = branch.map(function (_, i) {
+                            var _a, _b;
+                            var offset = (_a = offsets[0]) !== null && _a !== void 0 ? _a : 1;
+                            var index = i + offset;
+                            if (params.wrap) {
+                                index = index % branch.length;
+                                if (index < 0)
+                                    index += branch.length;
+                            }
+                            return (_b = branch[index]) !== null && _b !== void 0 ? _b : DISCARD;
+                        });
+                        return mapped.filter(function (v) { return v !== DISCARD; });
+                    }),
+                }];
+        });
+    }); },
+};
+
+var _a$5;
+var primitives$5 = (_a$5 = {},
+    _a$5[splitGroup.name] = splitGroup,
+    _a$5[mergeGroup.name] = mergeGroup,
+    _a$5[listItem.name] = listItem,
+    _a$5[listLength.name] = listLength,
+    _a$5[filterList.name] = filterList,
+    // [shiftList.name]: shiftList,
+    _a$5[relativeItem.name] = relativeItem,
+    _a$5[relativeItems.name] = relativeItems,
+    _a$5[cartesianGroups.name] = cartesianGroups,
+    _a$5[concat.name] = concat,
+    _a$5);
 
 var series = {
     name: "series",
@@ -1435,10 +1481,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 mergeTree = {
     name: "mergeTree",
@@ -1491,11 +1537,11 @@ var simplifyTree = {
     }); },
 };
 
-var _a$2;
-var primitives$2 = (_a$2 = {},
-    _a$2[mergeTree.name] = mergeTree,
-    _a$2[simplifyTree.name] = simplifyTree,
-    _a$2);
+var _a$3;
+var primitives$3 = (_a$3 = {},
+    _a$3[mergeTree.name] = mergeTree,
+    _a$3[simplifyTree.name] = simplifyTree,
+    _a$3);
 
 var groupAnd = {
     name: "groupAnd",
@@ -1539,17 +1585,17 @@ var groupOr = {
     }); },
 };
 
-var _a$1;
-var primitives$1 = (_a$1 = {},
-    _a$1[groupAnd.name] = groupAnd,
-    _a$1[groupOr.name] = groupOr,
-    _a$1);
+var _a$2;
+var primitives$2 = (_a$2 = {},
+    _a$2[groupAnd.name] = groupAnd,
+    _a$2[groupOr.name] = groupOr,
+    _a$2);
 
-var output = {
-    name: "output",
-    label: "Output",
-    description: "Data output.",
-    nodeType: "Output",
+var inputs = {
+    name: "inputs",
+    label: "Input",
+    description: "Data input.",
+    nodeType: "Input",
     inputs: {},
     outputs: {},
     impl: function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -1559,11 +1605,11 @@ var output = {
     }); },
 };
 
-var inputs = {
-    name: "inputs",
-    label: "Input",
-    description: "Data input.",
-    nodeType: "Input",
+var output = {
+    name: "output",
+    label: "Output",
+    description: "Data output.",
+    nodeType: "Output",
     inputs: {},
     outputs: {},
     impl: function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -1573,8 +1619,14 @@ var inputs = {
     }); },
 };
 
-var Lib = { Util: primitives$6, Math: primitives$5, List: primitives$4, Sequence: primitives$3, Tree: primitives$2, Logic: primitives$1 };
-var primitives = __assign(__assign(__assign(__assign(__assign(__assign({ inputs: inputs, output: output }, primitives$6), primitives$5), primitives$4), primitives$3), primitives$2), primitives$1);
+var _a$1;
+var primitives$1 = (_a$1 = {},
+    _a$1[inputs.name] = inputs,
+    _a$1[output.name] = output,
+    _a$1);
+
+var Lib = { Util: primitives$7, Math: primitives$6, List: primitives$5, Sequence: primitives$4, Tree: primitives$3, Logic: primitives$2, IO: primitives$1 };
+var primitives = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, primitives$1), primitives$7), primitives$6), primitives$5), primitives$4), primitives$3), primitives$2);
 
 function isPrimitive(node) {
     return node.impl !== undefined;