@rkmodules/rules 0.0.89 → 0.0.91

package/dist/index.esm.js

@@ -1129,6 +1129,75 @@ var tanDeg = {
     }); },
 };
 
+var ceil = {
+    name: "ceil",
+    label: "Round up",
+    description: "Round a number up to the nearest integer",
+    inputs: {
+        x: { type: "number", default: 0 },
+    },
+    outputs: {
+        ceil: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    ceil: mapTree(inputs.x, function (x) {
+                        if (x === undefined)
+                            return DISCARD;
+                        return Math.ceil(x);
+                    }),
+                }];
+        });
+    }); },
+};
+
+var floor = {
+    name: "floor",
+    label: "Round down",
+    description: "Round a number down to the nearest integer",
+    inputs: {
+        x: { type: "number", default: 0 },
+    },
+    outputs: {
+        floor: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    floor: mapTree(inputs.x, function (x) {
+                        if (x === undefined)
+                            return DISCARD;
+                        return Math.floor(x);
+                    }),
+                }];
+        });
+    }); },
+};
+
+var round = {
+    name: "round",
+    label: "Round",
+    description: "Round a number to the nearest integer",
+    inputs: {
+        x: { type: "number", default: 0 },
+    },
+    outputs: {
+        round: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    round: mapTree(inputs.x, function (x) {
+                        if (x === undefined)
+                            return DISCARD;
+                        return Math.round(x);
+                    }),
+                }];
+        });
+    }); },
+};
+
 var _a$6;
 var primitives$6 = (_a$6 = {},
     _a$6[calc.name] = calc,
@@ -1145,6 +1214,9 @@ var primitives$6 = (_a$6 = {},
     _a$6[tanDeg.name] = tanDeg,
     _a$6[sqrt.name] = sqrt,
     _a$6[pow.name] = pow,
+    _a$6[round.name] = round,
+    _a$6[ceil.name] = ceil,
+    _a$6[floor.name] = floor,
     _a$6);
 
 var filterList = {
@@ -1734,7 +1806,7 @@ var Engine = /** @class */ (function () {
     };
     Engine.prototype.runGraph = function (node, inputs, params) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, body, executionId, context, startTime, _b, _c, _d, _i, name_1, fnCall, fn, inputs_1, params_1, result_1, cacheResult, startTime_1, endTime_1, result, endTime;
+            var _a, body, executionId, context, startTime, _b, _c, _d, _i, name_1, fnCall, fn, inputs_1, params_1, result_1, cacheResult, startTime_1, endTime_1, result, endTime, response;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
@@ -1794,6 +1866,7 @@ var Engine = /** @class */ (function () {
                         });
                         return [4 /*yield*/, fn.impl(inputs_1, params_1, this)];
                     case 3:
+                        // call the implentation of sub functions
                         result_1 = _e.sent();
                         endTime_1 = performance.now();
                         context.activations[name_1] = false;
@@ -1818,8 +1891,7 @@ var Engine = /** @class */ (function () {
                     case 5:
                         result = interpolate(node.outputs || {}, context.scope);
                         endTime = performance.now();
-                        // fire event
-                        this.fireEvent("result", {
+                        response = {
                             name: node.name,
                             inputs: inputs,
                             params: params,
@@ -1829,15 +1901,18 @@ var Engine = /** @class */ (function () {
                             startTime: startTime,
                             endTime: endTime,
                             duration: endTime - startTime,
-                        });
+                        };
+                        // fire event
+                        this.fireEvent("result", response);
                         // console.log("Engine run done", result, context, endTime - startTime);
-                        return [2 /*return*/, result];
+                        return [2 /*return*/, response];
                 }
             });
         });
     };
     /**
      * creates an function that can be evaluated by calling its implementation
+     * and registers it in the function index
      * @param node
      * @returns
      */
@@ -1848,6 +1923,7 @@ var Engine = /** @class */ (function () {
             return node;
         }
         var _a = node.body, body = _a === void 0 ? {} : _a, props = __rest(node, ["body"]);
+        // create a primitive function, one that has an implementation and optional mounting function
         var primitive = __assign(__assign({}, props), { outputs: Object.fromEntries(Object.entries(node.outputs || {}).map(function (_a) {
                 var _b = __read(_a, 2), key = _b[0]; _b[1];
                 return [key, { type: "any" }];
@@ -1884,17 +1960,18 @@ var Engine = /** @class */ (function () {
                         finally { if (e_1) throw e_1.error; }
                     }
                 };
-            }, impl: function (inputs, params) { return __awaiter(_this, void 0, void 0, function () {
+            }, impl: function (inputs, params, engine) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
                 return __generator(this, function (_a) {
-                    // console.log(
-                    //     `Running function: ${node.name}`,
-                    //     node,
-                    //     inputs,
-                    //     params
-                    // );
-                    return [2 /*return*/, this.runGraph(node, inputs, params)];
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, engine.runGraph(node, inputs, params)];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response.result];
+                    }
                 });
             }); } });
+        // register the primitive
         this.fnIndex[primitive.name] = primitive;
         return primitive;
     };
@@ -1962,6 +2039,22 @@ var Engine = /** @class */ (function () {
             });
         });
     };
+    Engine.prototype.runDetailed = function (node, inputs) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var unsub = _this.subscribe("result", function (event) {
+                            if (event.name === node.name) {
+                                resolve(event);
+                                unsub();
+                            }
+                        });
+                        _this.run(node, inputs);
+                    })];
+            });
+        });
+    };
     Engine.prototype.getFunction = function (name) {
         return this.fnIndex[name];
     };