@rkmodules/rules 0.0.154 → 0.0.156

package/dist/index.cjs.js

@@ -1867,12 +1867,69 @@ var coalesce = {
     }); },
 };
 
+var destructureList = {
+    name: "destructureList",
+    label: "Destructure List",
+    description: "Separates an list into a part with the specified values and the rest",
+    inputs: {
+        list: "any",
+        items: { type: "any" },
+    },
+    params: {
+    // all: { type: "boolean", default: true, label: "all fields" },
+    },
+    outputs: {
+        included: "any",
+        excluded: "any",
+        matches: "boolean",
+    },
+    impl: function (_a, params_1) { return __awaiter(void 0, [_a, params_1], void 0, function (_b, params) {
+        var split;
+        var _c = _b.list, list = _c === void 0 ? {} : _c, _d = _b.items, items = _d === void 0 ? {} : _d;
+        return __generator(this, function (_e) {
+            split = nAryOnTreeBranch([list, items], function (_a) {
+                var _b = __read(_a, 2), _c = _b[0], list = _c === void 0 ? [] : _c, _d = _b[1], items = _d === void 0 ? [] : _d;
+                var included = [];
+                var excluded = [];
+                var matches = [];
+                console.log("Destructuring list", list, items);
+                list.forEach(function (value) {
+                    var m = items.includes(value);
+                    matches.push(m);
+                    if (m) {
+                        included.push(value);
+                    }
+                    else {
+                        excluded.push(value);
+                    }
+                });
+                return [[included, excluded, matches]];
+            });
+            return [2 /*return*/, {
+                    included: mapTree(split, function (_a) {
+                        var _b = __read(_a, 1), l = _b[0];
+                        return l;
+                    }),
+                    excluded: mapTree(split, function (_a) {
+                        var _b = __read(_a, 2); _b[0]; var e = _b[1];
+                        return e;
+                    }),
+                    matches: mapTree(split, function (_a) {
+                        var _b = __read(_a, 3); _b[0]; _b[1]; var m = _b[2];
+                        return m;
+                    }),
+                }];
+        });
+    }); },
+};
+
 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[destructureList.name] = destructureList,
     _a$6[relativeItem.name] = relativeItem,
     _a$6[relativeItems.name] = relativeItems,
     _a$6[concat.name] = concat,
@@ -2631,9 +2688,9 @@ var setField = {
             newObject = nAryOnTree([object, key, value], function (_a) {
                 var _b = __read(_a, 3), o = _b[0], k = _b[1], v = _b[2];
                 var newObj = __assign({}, o);
-                if (o[k] !== undefined && !overwrite) {
+                if (newObj[k] !== undefined && !overwrite) {
                     // If the key already exists and overwrite is false, return the original object
-                    return o;
+                    return newObj;
                 }
                 if (k !== undefined) {
                     newObj[k] = v;
@@ -2647,6 +2704,61 @@ var setField = {
     }); },
 };
 
+var destructureObject = {
+    name: "destructureObject",
+    label: "Destructure Object",
+    description: "Separates an object into a part with the specified fields and the rest",
+    inputs: {
+        object: "any",
+        fields: { type: "string" },
+    },
+    params: {
+        all: { type: "boolean", default: true, label: "all fields" },
+    },
+    outputs: {
+        included: "any",
+        excluded: "any",
+    },
+    impl: function (_a, params_1) { return __awaiter(void 0, [_a, params_1], void 0, function (_b, params) {
+        var split;
+        var _c = _b.object, object = _c === void 0 ? {} : _c, _d = _b.fields, fields = _d === void 0 ? {} : _d;
+        return __generator(this, function (_e) {
+            if (params.all) {
+                fields = mapTreeBranch(fields, function (items) {
+                    return [items];
+                });
+            }
+            split = nAryOnTree([object, fields], function (_a) {
+                var _b = __read(_a, 2), obj = _b[0], _c = _b[1], flds = _c === void 0 ? [] : _c;
+                var included = {};
+                var excluded = {};
+                if (typeof obj !== "object" || obj === null)
+                    return DISCARD;
+                Object.entries(obj).forEach(function (_a) {
+                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                    if (flds.includes(key)) {
+                        included[key] = value;
+                    }
+                    else {
+                        excluded[key] = value;
+                    }
+                });
+                return [[included, excluded]];
+            }, true);
+            return [2 /*return*/, {
+                    included: mapTree(split, function (_a) {
+                        var _b = __read(_a, 2), i = _b[0]; _b[1];
+                        return i;
+                    }),
+                    excluded: mapTree(split, function (_a) {
+                        var _b = __read(_a, 2); _b[0]; var e = _b[1];
+                        return e;
+                    }),
+                }];
+        });
+    }); },
+};
+
 var _a$1;
 var primitives$1 = (_a$1 = {},
     _a$1[object.name] = object,
@@ -2656,6 +2768,7 @@ var primitives$1 = (_a$1 = {},
     _a$1[mergeObject.name] = mergeObject,
     _a$1[objectEntries.name] = objectEntries,
     _a$1[explodeObject.name] = explodeObject,
+    _a$1[destructureObject.name] = destructureObject,
     _a$1);
 
 var INFERRED = "inferred";