@rkmodules/rules 0.0.1

package/dist/index.js

@@ -0,0 +1,1635 @@
+'use strict';
+
+var mathjs = require('mathjs');
+var react = require('@xyflow/react');
+var zustand = require('zustand');
+var middleware = require('zustand/middleware');
+var useInner = require('@rkmodules/use-inner');
+var React = require('react');
+var katex = require('katex');
+var classNames = require('classnames');
+require('katex/dist/katex.min.css');
+require('@xyflow/react/dist/style.css');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Creates a new branch for each item in the existing tree branches
+ * @param tree
+ * @returns
+ */
+function graftTree$1(tree) {
+    return Object.fromEntries(Object.entries(tree).reduce(function (entries, _a) {
+        var _b = __read(_a, 2), path = _b[0], values = _b[1];
+        entries.push.apply(entries, __spreadArray([], __read(values.map(function (value, index) {
+            return [path + ";" + index, [value]];
+        })), false));
+        return entries;
+    }, []));
+}
+/**
+ * Reduce the complexity of a tree by merging the outermost branches.
+ * @param tree
+ */
+function trimTree$1(tree, depth) {
+    var _a;
+    if (depth === void 0) { depth = 1; }
+    if (depth <= 0)
+        return tree;
+    var result = {};
+    for (var path in tree) {
+        var parts = path.split(";");
+        // leave at least a path length of 1
+        var end = depth >= parts.length ? 1 : -depth;
+        var newPath = parts.slice(0, end).join(";");
+        if (!result[newPath]) {
+            result[newPath] = [];
+        }
+        // flatten onto new branch
+        (_a = result[newPath]).push.apply(_a, __spreadArray([], __read(tree[path]), false));
+    }
+    return result;
+}
+/**
+ * checks if the given structure is a data tree
+ */
+function isTree(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length > 0 &&
+        Object.values(value).every(function (v) { return Array.isArray(v); }));
+}
+/**
+ * turns a value or array of values into a tree
+ */
+function broadCast(value) {
+    if (Array.isArray(value)) {
+        return { "0": value };
+    }
+    if (isTree(value)) {
+        return value;
+    }
+    return { "0": [value] };
+}
+function getBranch(tree, path) {
+    return tree[path];
+}
+/**
+ * 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
+ * @param fn
+ * @returns
+ */
+function mapTree(tree, fn) {
+    var result = {};
+    var _loop_2 = function (path) {
+        var mapResult = tree[path].flatMap(function (v, i) { return fn(v, path, i); });
+        if (mapResult.length) {
+            result[path] = mapResult;
+        }
+    };
+    for (var path in tree) {
+        _loop_2(path);
+    }
+    return result;
+}
+function mapTreeBranch(tree, fn) {
+    var result = {};
+    for (var path in tree) {
+        var newBranch = fn(tree[path], path);
+        if (newBranch) {
+            result[path] = newBranch;
+        }
+    }
+    return result;
+}
+/**
+ * n-ary operation on a tree, branch by branch
+ * - branches are matched by index,
+ * - last branches are repeated when the branch count differs
+ * - branch names from the longest or first tree are used
+ * - if a corresponding index does not exist in the branch, its item argument is undefined
+ * - the callback function is called with (items, paths)
+ * @param trees
+ * @param fn
+ * @returns
+ */
+function nAryOnTreeBranch(trees, fn) {
+    var result = {};
+    var allKeys = trees.map(function (tree) { return Object.keys(tree); });
+    var maxBranches = Math.max.apply(Math, __spreadArray([], __read(allKeys.map(function (keys) { return keys.length; })), false));
+    var _loop_3 = function (i) {
+        var paths = allKeys.map(function (keys) { return keys[Math.min(i, keys.length - 1)]; });
+        var branches = trees.map(function (tree) { return tree[paths[trees.indexOf(tree)]] || []; });
+        // get all the paths of which the trees are the longest, use the first
+        var maxPaths = paths.filter(function (_, i) { return allKeys[i].length === maxBranches; });
+        var path = maxPaths[0];
+        var newBranch = fn(branches, paths);
+        if (newBranch === null || newBranch === void 0 ? void 0 : newBranch.length) {
+            result[path] = newBranch;
+        }
+    };
+    for (var i = 0; i < maxBranches; i++) {
+        _loop_3(i);
+    }
+    return result;
+}
+/**
+ * n-ary operation on a tree, branch by branch
+ * - branches are matched by index,
+ * - last branches are repeated when the branch count differs
+ * - branch names from the longest or first tree are used
+ * - if a corresponding index does not exist in the branch, its item argument is undefined
+ * - the callback function is called with (items, paths, index)
+ * @param trees
+ * @param fn
+ * @returns
+ */
+function nAryOnTree(trees, fn) {
+    return nAryOnTreeBranch(trees, function (branches, paths) {
+        var maxLength = Math.max.apply(Math, __spreadArray([], __read(branches.map(function (b) { return b.length; })), false));
+        if (maxLength === 0)
+            return; // Skip empty branches
+        return Array.from({ length: maxLength }, function (_, i) {
+            var items = branches.map(function (b) { return b[i]; });
+            return fn(items, paths, i);
+        });
+    });
+}
+/**
+ * binary operation on a tree, branch by branch
+ * - branches are matched by index,
+ * - last branches are repeated when the branch count differs
+ * - branch names from the longest or first tree are used
+ * - if a corresponding index does not exist in the branch, its item argument is undefined
+ * - the callback function is called with (itemA, itemB, pathA, pathB)
+ * @param treeA
+ * @param treeB
+ * @param fn
+ * @returns
+ */
+function binaryOnTreeBranch(treeA, treeB, fn) {
+    return nAryOnTreeBranch([treeA, treeB], function (_a, _b) {
+        var _c = __read(_a, 2), branchA = _c[0], branchB = _c[1];
+        var _d = __read(_b, 2), pathA = _d[0], pathB = _d[1];
+        return fn(branchA, branchB, pathA, pathB);
+    });
+}
+/**
+ * binary operation on a tree, branch by branch
+ * - branches are matched by index,
+ * - last branches are repeated when the branch count differs
+ * - branch names from the longest or first tree are used
+ * - if a corresponding index does not exist in the branch, its item argument is undefined
+ * - the callback function is called with (itemA, itemB, pathA, pathB, index)
+ * @param treeA
+ * @param treeB
+ * @param fn
+ * @returns
+ */
+function binaryOnTree(treeA, treeB, fn) {
+    return nAryOnTree([treeA, treeB], function (_a, _b, index) {
+        var _c = __read(_a, 2), itemA = _c[0], itemB = _c[1];
+        var _d = __read(_b, 2), pathA = _d[0], pathB = _d[1];
+        return fn(itemA, itemB, pathA, pathB, index);
+    });
+}
+function sameShape(a, b) {
+    var sa = Object.keys(a).sort().join("|");
+    var sb = Object.keys(b).sort().join("|");
+    return sa === sb;
+}
+/**
+ * flattens the whole tree into an array
+ */
+function toArray(a) {
+    return Object.values(a).flat();
+}
+
+// utilities
+/**
+ * merges two trees by concatenating the branches with the same path
+ * @param a
+ * @param b
+ * @returns
+ */
+function mergeTrees(a, b) {
+    var e_1, _a;
+    var _b;
+    var out = __assign({}, a);
+    try {
+        for (var _c = __values(Object.entries(b)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 2), k = _e[0], arr = _e[1];
+            out[k] = ((_b = out[k]) !== null && _b !== void 0 ? _b : []).concat(arr);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return out;
+}
+
+function isReference(value) {
+    return (typeof value === "string" &&
+        value.startsWith("<") &&
+        value.endsWith(">"));
+}
+function parseReference(ref) {
+    return ref.slice(1, -1);
+}
+function uid() {
+    return Math.random().toString(36).substring(2, 15);
+}
+function getValue$1(obj, path) {
+    if (!(obj && path)) {
+        return;
+    }
+    var parts = path.split(".");
+    var value = obj[parts.shift() || ""];
+    while (parts.length && value) {
+        value = value[parts.shift() || ""];
+    }
+    return value;
+}
+function interpolateValue(value, scope) {
+    if (Array.isArray(value)) {
+        if (value.length && value.every(isTree)) {
+            // combine the trees into one
+            var tree = value.reduce(function (acc, t) { return mergeTrees(acc, t); });
+            return mapTree(tree, function (v) { return interpolateValue(v, scope); });
+        }
+        return broadCast(value);
+    }
+    if (isTree(value)) {
+        return mapTree(value, function (v) { return interpolateValue(v, scope); });
+    }
+    if (typeof value === "object" && value !== null) {
+        if (Object.keys(value).length === 0) {
+            return {};
+        }
+        // interpolate to a record of trees:
+        var interpolated = interpolate(value, scope);
+        // then, for each value, combine the branches with the same index
+        var keys_1 = Object.keys(interpolated);
+        return nAryOnTree(Object.values(interpolated), function (items) {
+            return Object.fromEntries(items.map(function (item, keyIndex) {
+                return [keys_1[keyIndex], item];
+            }));
+        });
+    }
+    if (!isReference(value)) {
+        return value;
+    }
+    var parts = parseReference(value).split(".");
+    var mappedValue = getValue$1(scope, parts.slice(0, 2).join("."));
+    if (parts.length > 2) {
+        // deep interpolate
+        mappedValue = mapTree(mappedValue, function (v) {
+            return getValue$1(v, parts.slice(2).join("."));
+        });
+    }
+    return mappedValue;
+}
+function interpolate(inputs, scope) {
+    return Object.fromEntries(Object.entries(inputs).map(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        var mappedValue = interpolateValue(value, scope);
+        return [key, broadCast(mappedValue)];
+    }));
+}
+
+/**
+ * TODO: need rank polymorhism on the tree item sizes
+ */
+var getValue = {
+    name: "getValue",
+    label: "Get Value",
+    inputs: {
+        tree: "any",
+        path: "string",
+    },
+    outputs: {
+        tree: "any",
+    },
+    // TODO: may want to do something with other values of path
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var paths, tree;
+        return __generator(this, function (_a) {
+            paths = toArray(inputs.path || {});
+            tree = mapTree(inputs.tree, function (value) {
+                // get the property from the object
+                return getValue$1(value, paths[0]);
+            });
+            return [2 /*return*/, { tree: tree }];
+        });
+    }); },
+};
+
+var log = {
+    name: "log",
+    label: "Log",
+    description: "Logs the input data to the console",
+    nodeType: "Log",
+    inputs: {
+        data: "any",
+    },
+    outputs: {
+        data: "any", // Return the data for potential further use
+    },
+    impl: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            console.table(input.data);
+            return [2 /*return*/, {
+                    data: input.data, // Return the data for potential further use
+                }];
+        });
+    }); },
+};
+
+/**
+ * value primitive function
+ */
+var value = {
+    name: "value",
+    label: "Value",
+    inputs: {},
+    params: {
+        value: "string",
+        type: {
+            type: "string",
+            options: ["number", "boolean", "string"],
+        },
+    },
+    outputs: {
+        value: "any",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var value;
+        return __generator(this, function (_a) {
+            value = params.value;
+            switch (params.type) {
+                case "number":
+                    return [2 /*return*/, { value: Number(value) }];
+                case "boolean":
+                    return [2 /*return*/, { value: Boolean(value) }];
+                case "string":
+                    return [2 /*return*/, { value: String(value) }];
+                default:
+                    // return as is
+                    return [2 /*return*/, { value: value }];
+            }
+        });
+    }); },
+};
+
+var _a$2;
+var primitives$3 = (_a$2 = {},
+    _a$2[getValue.name] = getValue,
+    _a$2[log.name] = log,
+    _a$2[value.name] = value,
+    _a$2);
+
+var math$1 = mathjs.create(mathjs.all, {});
+function evaluate(expression, scope) {
+    // console.log("evaluating", expression, "in", scope);
+    var result;
+    try {
+        result = math$1.evaluate(expression, scope);
+        if (typeof result.toNumber === "function") {
+            result = result.toNumber();
+        }
+    }
+    catch (e) {
+        console.log("Calc:", e);
+        console.log("Calc:", { expression: expression, scope: scope });
+        // todo: communicate errors
+    }
+    // console.log("result", result);
+    return result;
+}
+/**
+ * TODO: need rank polymorhism on the tree item sizes
+ */
+var calc = {
+    name: "calc",
+    label: "Calc",
+    nodeType: "Calc",
+    inputs: {},
+    params: {
+        expression: "string",
+    },
+    outputs: {
+        result: "number",
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var expression, inputEntries, result;
+        return __generator(this, function (_a) {
+            expression = params.expression;
+            if (!expression)
+                return [2 /*return*/, {}];
+            inputEntries = Object.entries(inputs);
+            if (!inputEntries.every(function (_a, i, a) {
+                var _b = __read(_a, 2); _b[0]; var v = _b[1];
+                return sameShape(v, a[0][1]);
+            })) {
+                throw new Error("All inputs must have the same shape");
+            }
+            // if no inputs, just return the result of the expression
+            if (inputEntries.length === 0) {
+                return [2 /*return*/, { result: broadCast(evaluate(expression, {})) }];
+            }
+            result = mapTree(inputEntries[0][1], function (_, p, i) {
+                // create a scope for each input
+                var vars = {};
+                inputEntries.forEach(function (_a) {
+                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                    vars[key] = value[p][i];
+                });
+                return evaluate(expression, vars);
+            });
+            // await new Promise((resolve) => setTimeout(resolve, 5000)); // yield to event loop
+            return [2 /*return*/, { result: result }];
+        });
+    }); },
+};
+var BUILT_INS = new Set([
+    // constants
+    "pi",
+    "e",
+    "tau",
+    "phi",
+    "Infinity",
+    "NaN",
+    "i",
+    "true",
+    "false",
+    "null",
+    // common built-in functions (skip as variables when used as callees)
+    "sin",
+    "cos",
+    "tan",
+    "asin",
+    "acos",
+    "atan",
+    "atan2",
+    "sinh",
+    "cosh",
+    "tanh",
+    "log",
+    "log10",
+    "ln",
+    "exp",
+    "sqrt",
+    "abs",
+    "min",
+    "max",
+    "round",
+    "floor",
+    "ceil",
+    "sum",
+    "mean",
+    "median",
+    "mode",
+    "std",
+    "var",
+    "pow",
+    "mod",
+    "gcd",
+    "lcm",
+    "derivative",
+    "integral",
+    "simplify",
+    "im",
+    "re",
+]);
+/**
+ * Return a sorted list of unbound symbol names in a MathJS expression.
+ * @param expr The expression string, e.g. "x + y"
+ * @param scope Names already defined/known (e.g. from your evaluation scope)
+ * @param extraBound Extra names to treat as bound (e.g. UI reserved words)
+ */
+function getUnboundSymbols(expr, scope, extraBound) {
+    if (scope === void 0) { scope = {}; }
+    if (extraBound === void 0) { extraBound = []; }
+    var ast;
+    try {
+        ast = math$1.parse(expr);
+    }
+    catch (_a) {
+        return [];
+    }
+    var bound = new Set(__spreadArray(__spreadArray([], __read(Object.keys(scope)), false), __read(extraBound), false));
+    var free = new Set();
+    var isFunctionCallee = function (node, parent) {
+        return (parent === null || parent === void 0 ? void 0 : parent.type) === "FunctionNode" && parent.fn === node;
+    };
+    ast.traverse(function (node, _path, parent) {
+        if (node.type !== "SymbolNode")
+            return;
+        var name = node.name;
+        // Skip if symbol is the function name in a call, e.g. sin in sin(x)
+        if (isFunctionCallee(node, parent))
+            return;
+        // Skip mathjs built-ins and anything caller said is already bound
+        if (BUILT_INS.has(name) || bound.has(name))
+            return;
+        free.add(name);
+    });
+    // If you want to also exclude left-hand sides of assignments within the expr:
+    // (Uncommon in "fill in variables" UIs, but easy to guard against.)
+    ast.traverse(function (node) {
+        if (node.type === "AssignmentNode") {
+            var target = node.object;
+            if ((target === null || target === void 0 ? void 0 : target.type) === "SymbolNode") {
+                free.delete(target.name);
+            }
+        }
+    });
+    return Array.from(free).sort();
+}
+
+var greaterThan = {
+    name: "greaterThan",
+    label: "Greater Than",
+    description: "Compare on greater than or greater than or equal to",
+    inputs: {
+        a: "number",
+        b: "number",
+    },
+    outputs: {
+        gt: "boolean",
+        gte: "boolean",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    gt: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        return itemA > itemB;
+                    }),
+                    gte: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        return itemA >= itemB;
+                    }),
+                }];
+        });
+    }); },
+};
+
+var lessThan = {
+    name: "lessThan",
+    label: "Less Than",
+    description: "Compare on less than or less than or equal to",
+    inputs: {
+        a: "number",
+        b: "number",
+    },
+    outputs: {
+        lt: "boolean",
+        lte: "boolean",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    lt: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        return itemA < itemB;
+                    }),
+                    lte: binaryOnTree(inputs.a, inputs.b, function (itemA, itemB) {
+                        return itemA <= itemB;
+                    }),
+                }];
+        });
+    }); },
+};
+
+var _a$1;
+var primitives$2 = (_a$1 = {},
+    _a$1[calc.name] = calc,
+    _a$1[lessThan.name] = lessThan,
+    _a$1[greaterThan.name] = greaterThan,
+    _a$1);
+
+var filterList = {
+    name: "filterList",
+    label: "Filter List",
+    description: "filters the list by a boolean value",
+    inputs: {
+        list: "any",
+        keep: "boolean",
+    },
+    outputs: {
+        list: "any",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    list: binaryOnTreeBranch(inputs.list, inputs.keep, function (branchA, branchB) {
+                        return branchA.filter(function (item, index) {
+                            return (branchB[Math.min(index, branchB.length - 1)] ===
+                                true);
+                        });
+                    }),
+                }];
+        });
+    }); },
+};
+
+var graftTree = {
+    name: "graftTree",
+    label: "Graft Tree",
+    description: "Creates a new branch for each item in the existing tree branches",
+    inputs: {
+        tree: "any",
+    },
+    outputs: {
+        tree: "any", // Return the grafted nodes
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    tree: graftTree$1(inputs.tree),
+                }];
+        });
+    }); },
+};
+
+var listItem = {
+    name: "listItem",
+    label: "List Item",
+    description: "Retrieve the items from the list at the specified indices",
+    inputs: {
+        list: "any",
+        index: "number",
+    },
+    outputs: {
+        item: "any",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    item: mapTreeBranch(inputs.list, function (branch, path) {
+                        var indices = getBranch(inputs.index, path);
+                        if (indices) {
+                            return indices.map(function (i) { return branch[i]; });
+                        }
+                    }),
+                }];
+        });
+    }); },
+};
+
+var listLength = {
+    name: "listLength",
+    label: "List Length",
+    description: "Get the length of a list",
+    inputs: {
+        list: "any",
+    },
+    outputs: {
+        length: "number",
+    },
+    impl: function (inputs) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, {
+                    length: mapTreeBranch(inputs.list, function (branch) {
+                        return [branch.length];
+                    }),
+                }];
+        });
+    }); },
+};
+
+var trimTree = {
+    name: "trimTree",
+    label: "Trim Tree",
+    description: "Reduce the complexity of a tree by merging the outermost branches.",
+    inputs: {
+        tree: "any",
+    },
+    params: {
+        depth: "number", // Optional depth to trim the tree
+    },
+    outputs: {
+        tree: "any", // Return the trimed nodes
+    },
+    impl: function (inputs, params) { return __awaiter(void 0, void 0, void 0, function () {
+        var depth;
+        var _a;
+        return __generator(this, function (_b) {
+            depth = (_a = params.depth) !== null && _a !== void 0 ? _a : 1;
+            return [2 /*return*/, {
+                    tree: trimTree$1(inputs.tree, depth),
+                }];
+        });
+    }); },
+};
+
+var _a;
+var primitives$1 = (_a = {},
+    _a[graftTree.name] = graftTree,
+    _a[trimTree.name] = trimTree,
+    _a[listItem.name] = listItem,
+    _a[listLength.name] = listLength,
+    _a[filterList.name] = filterList,
+    _a);
+
+var primitives = __assign(__assign(__assign({}, primitives$3), primitives$2), primitives$1);
+
+function isPrimitive(node) {
+    return node.impl !== undefined;
+}
+
+function normalizeVarDef(varDef) {
+    if (typeof varDef === "string") {
+        return {
+            type: varDef,
+        };
+    }
+    return varDef;
+}
+function getReferences(inputs) {
+    var references = [];
+    Object.entries(inputs).forEach(function (_a) {
+        var _b = __read(_a, 2), name = _b[0], value = _b[1];
+        var values = Array.isArray(value) ? value : [value];
+        values.forEach(function (value) {
+            if (!isReference(value)) {
+                return;
+            }
+            var path = parseReference(value);
+            var parts = path.split(".");
+            references.push({
+                name: name,
+                path: path,
+                parts: parts,
+                refNode: parts[0],
+                refField: parts.slice(1).join("."),
+            });
+        });
+    });
+    return references;
+}
+function applyNodeDelete(fn, nodeIds) {
+    var newFn = __assign(__assign({}, fn), { body: __assign({}, fn.body) });
+    nodeIds.forEach(function (id) {
+        delete newFn.body[id];
+    });
+    // remove any references to the deleted nodes
+    Object.entries(newFn.body).forEach(function (_a) {
+        var _b = __read(_a, 2), id = _b[0], node = _b[1];
+        Object.entries(node.inputs || {}).forEach(function (_a) {
+            var _b;
+            var _c = __read(_a, 2), name = _c[0], value = _c[1];
+            if (isReference(value)) {
+                var path = parseReference(value);
+                var parts = path.split(".");
+                if (nodeIds.includes(parts[0])) {
+                    (_b = newFn.body[id].inputs) === null || _b === void 0 ? true : delete _b[name];
+                }
+            }
+        });
+    });
+    return newFn;
+}
+function applyEdgeDelete(fn, fromNode, toNode, fromField, toField) {
+    var newFn = __assign(__assign({}, fn), { body: __assign({}, fn.body) });
+    var from = newFn.body[fromNode];
+    var to = newFn.body[toNode];
+    if (!from || !to) {
+        console.warn("Invalid nodes for edge deletion");
+        return newFn;
+    }
+    if (to.inputs && to.inputs[toField] === "<".concat(fromNode, ".").concat(fromField, ">")) {
+        delete to.inputs[toField];
+    }
+    else {
+        console.warn("No matching edge found to delete");
+    }
+    return newFn;
+}
+function applyNodeAdd(fn, nodeName) {
+    var newFn = __assign(__assign({}, fn), { body: __assign({}, fn.body) });
+    var id = uid();
+    while (newFn.body[id]) {
+        id = uid();
+    }
+    newFn.body[id] = {
+        name: nodeName,
+        inputs: {},
+        params: {},
+    };
+    return topSort(newFn);
+}
+function applyNodeConnect(fn, fromNode, toNode, fromField, toField) {
+    var newFn = __assign(__assign({}, fn), { body: __assign({}, fn.body) });
+    var from = newFn.body[fromNode];
+    var to = newFn.body[toNode];
+    if (!from || !to) {
+        console.warn("Invalid nodes for connection");
+        return newFn;
+    }
+    if (!to.inputs) {
+        to.inputs = {};
+    }
+    // add the reference
+    to.inputs[toField] = "<".concat(fromNode, ".").concat(fromField, ">");
+    return topSort(newFn);
+}
+function topSort(fn) {
+    var ordered = [];
+    var visiting = new Set();
+    var done = new Set();
+    var visit = function (id) {
+        // if already done, return
+        if (done.has(id))
+            return;
+        // if being visited, we have a loop
+        if (visiting.has(id)) {
+            throw new Error("Circular dependency detected: ".concat(id));
+        }
+        // mark as visiting
+        visiting.add(id);
+        var fnCall = fn.body[id];
+        if (!fnCall) {
+            console.warn("Function ".concat(id, " not found in body"), fn);
+        }
+        // check the inputs and visit them
+        Object.values(fnCall.inputs || {}).forEach(function (input) {
+            if (isReference(input)) {
+                var _a = __read(parseReference(input).split("."), 1), id_1 = _a[0];
+                // visit inputs
+                if (id_1 !== "inputs") {
+                    visit(id_1);
+                }
+            }
+        });
+        // push to end of the list
+        ordered.push(id);
+        // finish visting
+        visiting.delete(id);
+        // mark as done
+        done.add(id);
+    };
+    Object.keys(fn.body).forEach(visit);
+    console.log("sorted", ordered);
+    var orderedBody = Object.fromEntries(ordered.map(function (id) { return [id, fn.body[id]]; }));
+    return __assign(__assign({}, fn), { body: orderedBody });
+}
+var Engine = /** @class */ (function () {
+    function Engine(morePrimitives) {
+        if (morePrimitives === void 0) { morePrimitives = {}; }
+        this.listeners = {};
+        this.cache = {};
+        this.cacheMiss = Symbol("cacheMiss");
+        this.fnIndex = __assign(__assign({}, primitives), morePrimitives);
+    }
+    Engine.prototype.checkCache = function (fnName, inputs) {
+        if (!this.cache[fnName]) {
+            return this.cacheMiss;
+        }
+        // TODO: need to check the interpolated inputs, as the references can be the same
+        // however, the interpolation does create new objects
+        return {};
+    };
+    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;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _a = node.body, body = _a === void 0 ? {} : _a;
+                        executionId = uid();
+                        context = {
+                            scope: { inputs: inputs },
+                            timings: {},
+                            activations: {},
+                        };
+                        startTime = performance.now();
+                        _b = body;
+                        _c = [];
+                        for (_d in _b)
+                            _c.push(_d);
+                        _i = 0;
+                        _e.label = 1;
+                    case 1:
+                        if (!(_i < _c.length)) return [3 /*break*/, 5];
+                        _d = _c[_i];
+                        if (!(_d in _b)) return [3 /*break*/, 4];
+                        name_1 = _d;
+                        fnCall = body[name_1];
+                        fn = this.fnIndex[fnCall.name];
+                        if (!fn) {
+                            throw new Error("function ".concat(fnCall.name, " not found in index"));
+                        }
+                        inputs_1 = interpolate(fnCall.inputs || {}, context.scope);
+                        params_1 = fnCall.params || {};
+                        result_1 = {};
+                        cacheResult = this.checkCache(name_1, inputs_1);
+                        if (!(cacheResult !== this.cacheMiss)) return [3 /*break*/, 2];
+                        // use as result
+                        result_1 = cacheResult;
+                        // store the result in the scope
+                        context.scope[name_1] = result_1;
+                        return [3 /*break*/, 4];
+                    case 2:
+                        // cache miss, call the function implementation
+                        context.activations[name_1] = true;
+                        startTime_1 = performance.now();
+                        this.fireEvent("functionCall", {
+                            name: name_1,
+                            inputs: inputs_1,
+                            params: params_1,
+                            executionId: executionId,
+                            context: context,
+                            startTime: startTime_1,
+                        });
+                        return [4 /*yield*/, fn.impl(inputs_1, params_1)];
+                    case 3:
+                        result_1 = _e.sent();
+                        endTime_1 = performance.now();
+                        context.activations[name_1] = false;
+                        context.timings[name_1] = endTime_1 - startTime_1;
+                        // store the result in the scope
+                        context.scope[name_1] = result_1;
+                        this.fireEvent("functionResult", {
+                            name: name_1,
+                            inputs: inputs_1,
+                            params: params_1,
+                            executionId: executionId,
+                            context: context,
+                            startTime: startTime_1,
+                            endTime: endTime_1,
+                            duration: endTime_1 - startTime_1,
+                        });
+                        _e.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 5:
+                        result = interpolate(node.outputs || {}, context.scope);
+                        endTime = performance.now();
+                        // fire event
+                        this.fireEvent("result", {
+                            name: node.name,
+                            inputs: inputs,
+                            params: params,
+                            executionId: executionId,
+                            context: context,
+                            startTime: startTime,
+                            endTime: endTime,
+                            duration: endTime - startTime,
+                        });
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /**
+     * creates an function that can be evaluated by calling its implementation
+     * @param node
+     * @returns
+     */
+    Engine.prototype.build = function (node, id) {
+        var _this = this;
+        if (isPrimitive(node)) {
+            // already a primitive
+            return node;
+        }
+        var _a = node.body, body = _a === void 0 ? {} : _a, props = __rest(node, ["body"]);
+        var primitive = __assign(__assign({}, props), { outputs: {}, mount: function (trigger) {
+                // mount all the nodes
+                var unsubs = [];
+                Object.values(body).forEach(function (n) {
+                    var _a;
+                    var fn = _this.fnIndex[n.name];
+                    if (!fn) {
+                        console.warn("function ".concat(n.name, " not found in index"));
+                        return;
+                    }
+                    var unsub = (_a = fn.mount) === null || _a === void 0 ? void 0 : _a.call(fn, trigger);
+                    if (unsub) {
+                        unsubs.push(unsub);
+                    }
+                });
+                return function () {
+                    var e_1, _a;
+                    console.log("Unmounting function: ".concat(node.name));
+                    try {
+                        // unmount all the nodes
+                        for (var unsubs_1 = __values(unsubs), unsubs_1_1 = unsubs_1.next(); !unsubs_1_1.done; unsubs_1_1 = unsubs_1.next()) {
+                            var unsub = unsubs_1_1.value;
+                            unsub();
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (unsubs_1_1 && !unsubs_1_1.done && (_a = unsubs_1.return)) _a.call(unsubs_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                };
+            }, impl: function (inputs, params) { return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    console.log("Running function: ".concat(node.name), node, inputs, params);
+                    return [2 /*return*/, this.runGraph(node, inputs, params)];
+                });
+            }); } });
+        this.fnIndex[primitive.name] = primitive;
+        return primitive;
+    };
+    Engine.prototype.mount = function (node) {
+        var _this = this;
+        var _a;
+        return (_a = node.mount) === null || _a === void 0 ? void 0 : _a.call(node, function () {
+            console.log("Triggering node: ".concat(node.name));
+            _this.run(node);
+        });
+    };
+    Engine.prototype.subscribe = function (eventName, listener) {
+        var _this = this;
+        if (!this.listeners[eventName]) {
+            this.listeners[eventName] = new Set();
+        }
+        if (!this.listeners[eventName].has(listener)) {
+            this.listeners[eventName].add(listener);
+        }
+        return function () {
+            _this.listeners[eventName].delete(listener);
+        };
+    };
+    Engine.prototype.fireEvent = function (eventName, event) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(this.listeners[eventName] || []), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var listener = _c.value;
+                listener(event);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    Engine.prototype.run = function (node_1) {
+        return __awaiter(this, arguments, void 0, function (node, inputs) {
+            var builtFn, mappedInputs, result;
+            var _a;
+            if (inputs === void 0) { inputs = {}; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!isPrimitive(node)) {
+                            builtFn = this.getFunction(node.name);
+                            if (!builtFn) {
+                                // not yet build
+                                builtFn = this.build(node);
+                            }
+                            return [2 /*return*/, this.run(builtFn, inputs)];
+                        }
+                        console.log("Engine running with inputs", inputs, interpolate(inputs, {}));
+                        mappedInputs = interpolate(inputs, {});
+                        return [4 /*yield*/, ((_a = node.impl) === null || _a === void 0 ? void 0 : _a.call(node, mappedInputs, {}))];
+                    case 1:
+                        result = _b.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    Engine.prototype.getFunction = function (name) {
+        return this.fnIndex[name];
+    };
+    return Engine;
+}());
+
+var variableStore = zustand.create(function (set, get, api) {
+    return middleware.persist(function (pset, pget) { return ({
+        data: {},
+        getVar: function (scope, name, persist) {
+            if (persist) {
+                return pget().data["".concat(scope, "|").concat(name)];
+            }
+            else {
+                return get().data["".concat(scope, "|").concat(name)];
+            }
+        },
+        setVar: function (scope, name, value, persist) {
+            var _a, _b;
+            if (persist) {
+                var data = __assign(__assign({}, pget().data), (_a = {}, _a["".concat(scope, "|").concat(name)] = value, _a));
+                pset({ data: data });
+            }
+            else {
+                var data = __assign(__assign({}, get().data), (_b = {}, _b["".concat(scope, "|").concat(name)] = value, _b));
+                set({ data: data });
+            }
+        },
+    }); }, {
+        name: "variable-storage", // unique name
+        // getStorage: () => sessionStorage, // (optional) by default the 'localStorage' is used
+    })(set, get, api);
+});
+/**
+ * scope restricts the variable scope, for example to a view id
+ * @param scope
+ * @param name
+ */
+var useVariable = function (scope, name, initial, persist) {
+    if (persist === void 0) { persist = true; }
+    var value = variableStore(function (_a) {
+        var getVar = _a.getVar;
+        return getVar(scope, name, persist);
+    });
+    if (typeof value === "undefined")
+        value = initial;
+    var setVar = variableStore(function (_a) {
+        var setVar = _a.setVar;
+        return setVar;
+    });
+    var setValue = function (value) { return setVar(scope, name, value, persist); };
+    return [value, setValue];
+};
+
+var dummyEngine = new Engine();
+var EngineContext = React.createContext(dummyEngine);
+var useEngine = function () {
+    return React.useContext(EngineContext);
+};
+var ChangeContext = React.createContext(function () { });
+var useChange = function () {
+    return React.useContext(ChangeContext);
+};
+
+var styles = {"DefaultNode":"DefaultNode_R2P6c","selected":"selected_VmB-F","active":"active_zjUzx","Log":"Log_dsq5e","Label":"Label_wBwWA","Output":"Output_e4yF-","type-string":"type-string_XVlwo","type-number":"type-number_0cg49","type-boolean":"type-boolean_t4ba5","type-any":"type-any_FPwjQ","Table":"Table_aZyRT"};
+
+function NodeContainer(_a) {
+    var _b;
+    var id = _a.id, label = _a.label, className = _a.className, selected = _a.selected, children = _a.children;
+    var engine = useEngine();
+    var _c = __read(React.useState(false), 2), active = _c[0], setActive = _c[1];
+    React.useEffect(function () {
+        if (!id)
+            return;
+        var removeOnCall = engine.subscribe("functionCall", function (event) {
+            if (event.name === id) {
+                setActive(true);
+            }
+        });
+        var removeOnResult = engine.subscribe("functionResult", function (event) {
+            if (event.name === id) {
+                setTimeout(function () { return setActive(false); }, Math.max(0, 1000 - (event.duration || 0)));
+            }
+        });
+        return function () {
+            removeOnCall();
+            removeOnResult();
+        };
+    }, [id]);
+    return (React.createElement("div", { className: classNames(className, styles.DefaultNode, (_b = {},
+            _b[styles.selected] = selected,
+            _b[styles.active] = active,
+            _b)) },
+        React.createElement("div", { className: styles.Label }, label),
+        children));
+}
+
+function Control(_a) {
+    var value = _a.value, type = _a.type, options = _a.options, onChange = _a.onChange;
+    if (options) {
+        return (React.createElement("select", { value: value || "", onChange: function (e) { return onChange === null || onChange === void 0 ? void 0 : onChange(e.target.value); } }, options.map(function (option) { return (React.createElement("option", { key: option, value: option }, option)); })));
+    }
+    switch (type) {
+        case "any":
+        case "string":
+            return (React.createElement("input", { type: "text", value: value || "", onChange: function (e) { return onChange === null || onChange === void 0 ? void 0 : onChange(e.target.value); } }));
+        case "number":
+            return (React.createElement("input", { type: "number", value: value || "", onChange: function (e) { return onChange === null || onChange === void 0 ? void 0 : onChange(Number(e.target.value)); } }));
+        case "boolean":
+            return (React.createElement("input", { type: "checkbox", checked: Boolean(value), onChange: function (e) { return onChange === null || onChange === void 0 ? void 0 : onChange(e.target.checked); } }));
+        default:
+            return (React.createElement("span", null,
+                String(value),
+                " (",
+                type,
+                ")"));
+    }
+}
+
+var Input = function (_a) {
+    var _b;
+    var name = _a.name, varDef = _a.varDef, id = _a.id, data = _a.data, onChange = _a.onChange;
+    var normalized = normalizeVarDef(varDef);
+    var value = (_b = data.inputs) === null || _b === void 0 ? void 0 : _b[name];
+    var isRef = isReference(value);
+    var handleInputChange = function (param) { return function (value) {
+        var _a;
+        // Update the function instance with the new input value
+        var body = __assign({}, data.caller.body);
+        var call = __assign({}, (body[id] || {}));
+        call.inputs = __assign(__assign({}, call.inputs), (_a = {}, _a[param] = value, _a));
+        body[id] = call;
+        var updatedFn = __assign(__assign({}, data.caller), { body: body });
+        onChange(updatedFn);
+    }; };
+    return (React.createElement("tr", { key: name, className: classNames(styles.Input, styles["type-".concat(normalized.type)]) },
+        React.createElement("td", null,
+            name,
+            React.createElement(react.Handle, { type: "target", position: react.Position.Left, id: "".concat(id, "-").concat(name) })),
+        React.createElement("td", null, !isRef && (React.createElement(Control, { type: normalized.type, value: value, onChange: handleInputChange(name) })))));
+};
+
+var Param = function (_a) {
+    var _b;
+    var id = _a.id, name = _a.name, varDef = _a.varDef, data = _a.data, onChange = _a.onChange;
+    var normalized = normalizeVarDef(varDef);
+    var value = (_b = data.params) === null || _b === void 0 ? void 0 : _b[name];
+    var isRef = isReference(value);
+    var handleParamChange = function (param) { return function (value) {
+        var _a;
+        // Update the function instance with the new param value
+        var body = __assign({}, data.caller.body);
+        var call = __assign({}, (body[id] || {}));
+        call.params = __assign(__assign({}, call.params), (_a = {}, _a[param] = value, _a));
+        body[id] = call;
+        var updatedFn = __assign(__assign({}, data.caller), { body: body });
+        onChange(updatedFn);
+    }; };
+    return (React.createElement("tr", { key: name, className: classNames(styles.Input, styles["type-".concat(normalized.type)]) },
+        React.createElement("td", null, name),
+        React.createElement("td", null, !isRef && (React.createElement(Control, { type: normalized.type, options: normalized.options, value: value, onChange: handleParamChange(name) })))));
+};
+
+var Output = function (_a) {
+    var name = _a.name, varDef = _a.varDef, id = _a.id;
+    var normalized = normalizeVarDef(varDef);
+    return (React.createElement("tr", { key: name, className: classNames(styles.Output, styles["type-".concat(normalized.type)]) },
+        React.createElement("td", { colSpan: 2 },
+            name,
+            React.createElement(react.Handle, { type: "source", position: react.Position.Right, id: "".concat(id, "-").concat(name) }))));
+};
+
+function GenericNode(_a) {
+    var id = _a.id, data = _a.data, selected = _a.selected, inputs = _a.inputs, outputs = _a.outputs, params = _a.params, children = _a.children, onChange = _a.onChange;
+    return (React.createElement(NodeContainer, { label: data.name, selected: selected, id: id },
+        children,
+        React.createElement("table", null,
+            React.createElement("tbody", null,
+                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, onChange: onChange }));
+                }),
+                Object.entries(params || {}).map(function (_a) {
+                    var _b = __read(_a, 2), name = _b[0], varDef = _b[1];
+                    return (React.createElement(Param, { key: name, name: name, varDef: varDef, id: id, data: data, onChange: onChange }));
+                })))));
+}
+
+var math = mathjs.create(mathjs.all, {});
+function MathView(_a) {
+    var expr = _a.expr, _b = _a.displayMode, displayMode = _b === void 0 ? false : _b;
+    var latex = "";
+    try {
+        latex = math.parse(expr).toTex({ parenthesis: "auto" });
+    }
+    catch (e) {
+        latex = String(expr); // fallback on parse error
+    }
+    var html = katex.renderToString(latex, {
+        throwOnError: false,
+        displayMode: displayMode,
+    });
+    return React.createElement("span", { dangerouslySetInnerHTML: { __html: html } });
+}
+var Calc = React.memo(function (_a) {
+    var _b;
+    var id = _a.id, data = _a.data, selected = _a.selected;
+    var engine = useEngine();
+    var onChange = useChange();
+    var calledFn = engine.getFunction(data.name);
+    if (!calledFn) {
+        return (React.createElement(NodeContainer, { label: "Function not found", selected: selected }));
+    }
+    var expression = (((_b = data.params) === null || _b === void 0 ? void 0 : _b.expression) || "").toString();
+    // add free variables to inputs
+    var inputs = __assign({}, (calledFn.inputs || {}));
+    var symbols = getUnboundSymbols(expression);
+    symbols.forEach(function (symbol) {
+        if (!inputs[symbol]) {
+            inputs[symbol] = {
+                type: "number",
+            };
+        }
+    });
+    return (React.createElement(GenericNode, { id: id, data: data, selected: selected, inputs: inputs, outputs: calledFn.outputs, params: calledFn.params, onChange: onChange },
+        React.createElement(MathView, { expr: expression, displayMode: true })));
+});
+Calc.displayName = "CalcNode";
+
+var Default = React.memo(function (_a) {
+    var id = _a.id, data = _a.data, selected = _a.selected;
+    var engine = useEngine();
+    var onChange = useChange();
+    var calledFn = engine.getFunction(data.name);
+    if (!calledFn) {
+        return (React.createElement(NodeContainer, { label: "Function not found", selected: selected }));
+    }
+    return (React.createElement(GenericNode, { id: id, data: data, selected: selected, inputs: calledFn.inputs, outputs: calledFn.outputs, params: calledFn.params, onChange: onChange }));
+});
+Default.displayName = "DefaultNode";
+
+var Log = React.memo(function (_a) {
+    var id = _a.id, data = _a.data, selected = _a.selected;
+    var engine = useEngine();
+    var calledFn = engine.getFunction(data.name);
+    var _b = __read(React.useState(null), 2), value = _b[0], setValue = _b[1];
+    React.useEffect(function () {
+        return engine.subscribe("functionResult", function (event) {
+            var _a;
+            if (event.name === id) {
+                setValue(((_a = event.context.scope[id]) === null || _a === void 0 ? void 0 : _a.data) || null);
+            }
+        });
+    }, []);
+    if (!calledFn) {
+        return (React.createElement(NodeContainer, { label: "Function not found", selected: selected }));
+    }
+    return (React.createElement(NodeContainer, { id: id, label: data.name, selected: selected, className: styles.Log },
+        React.createElement("div", { className: styles.Table },
+            React.createElement("table", null, Object.entries(value || {}).map(function (_a) {
+                var _b = __read(_a, 2), key = _b[0], val = _b[1];
+                return (React.createElement(React.Fragment, { key: key },
+                    React.createElement("tbody", null,
+                        React.createElement("tr", null,
+                            React.createElement("th", { colSpan: 2 }, "{".concat(key, "}"))),
+                        val.map(function (item, index) { return (React.createElement("tr", { key: "".concat(key, "-").concat(index) },
+                            React.createElement("td", null, index),
+                            React.createElement("td", { title: JSON.stringify(item, null, 2) }, item === null || item === void 0 ? void 0 : item.toString()))); }))));
+            }))),
+        React.createElement(react.Handle, { type: "target", position: react.Position.Left, id: "".concat(id, "-data") }),
+        React.createElement(react.Handle, { type: "source", position: react.Position.Right, id: "".concat(id, "-data") })));
+});
+Log.displayName = "LogNode";
+
+var nodeTypes = {
+    Default: Default,
+    Calc: Calc,
+    Log: Log,
+};
+
+function createGraph(fn, engine, positions) {
+    var nodes = [];
+    var edges = [];
+    Object.entries(fn.body || {}).forEach(function (_a, index) {
+        var _b = __read(_a, 2), id = _b[0], fncall = _b[1];
+        var reffedFn = engine.getFunction(fncall.name);
+        // create a node for each function call
+        nodes.push({
+            id: id,
+            data: {
+                name: fncall.name,
+                caller: fn,
+                inputs: fncall.inputs,
+                params: fncall.params,
+            },
+            position: (positions === null || positions === void 0 ? void 0 : positions[id]) || { x: 250 * index, y: 0 },
+            dragHandle: ".".concat(styles.Label),
+            type: (reffedFn === null || reffedFn === void 0 ? void 0 : reffedFn.nodeType) || "Default",
+        });
+        var refs = getReferences(fncall.inputs || {});
+        refs.forEach(function (ref) {
+            // create an edge for each reference
+            edges.push({
+                id: "".concat(ref.path, "-").concat(id, ".").concat(ref.name),
+                source: ref.refNode,
+                target: id,
+                sourceHandle: "".concat(ref.refNode, "-").concat(ref.refField),
+                targetHandle: "".concat(id, "-").concat(ref.name),
+            });
+        });
+    });
+    return { nodes: nodes, edges: edges };
+}
+function FlowInner(_a) {
+    var fn = _a.function, engine = _a.engine, onChange = _a.onChange;
+    var _b = __read(useVariable("rules", "".concat(fn.name, ".positions"), {}), 2), positions = _b[0], setPositions = _b[1];
+    var _c = React.useMemo(function () {
+        return createGraph(fn, engine, positions);
+    }, [fn, engine]), initialNodes = _c.nodes, initialEdges = _c.edges;
+    var _d = __read(useInner(initialNodes), 2), nodes = _d[0], setNodes = _d[1];
+    var _e = __read(useInner(initialEdges), 2), edges = _e[0], setEdges = _e[1];
+    // useLayoutNodes();
+    var updatePosition = function (event, node) {
+        var _a;
+        setPositions(__assign(__assign({}, positions), (_a = {}, _a[node.id] = node.position, _a)));
+    };
+    var onNodesChange = React.useCallback(function (changes) {
+        return setNodes(function (nodesSnapshot) {
+            return react.applyNodeChanges(changes, nodesSnapshot);
+        });
+    }, [setNodes]);
+    var onEdgesChange = React.useCallback(function (changes) {
+        return setEdges(function (edgesSnapshot) {
+            return react.applyEdgeChanges(changes, edgesSnapshot);
+        });
+    }, [setEdges]);
+    var onConnect = React.useCallback(function (params) {
+        var _a, _b;
+        var sourceField = (_a = params.sourceHandle) === null || _a === void 0 ? void 0 : _a.split("-")[1];
+        var targetField = (_b = params.targetHandle) === null || _b === void 0 ? void 0 : _b.split("-")[1];
+        if (!sourceField || !targetField) {
+            console.warn("Invalid connection handles", params);
+            return;
+        }
+        onChange === null || onChange === void 0 ? void 0 : onChange(applyNodeConnect(fn, params.source, params.target, sourceField, targetField));
+        setEdges(function (edgesSnapshot) { return react.addEdge(params, edgesSnapshot); });
+    }, [setEdges, fn, onChange]);
+    var onNodesDelete = React.useCallback(function (nodesToDelete) {
+        onChange === null || onChange === void 0 ? void 0 : onChange(applyNodeDelete(fn, nodesToDelete.map(function (n) { return n.id; })));
+        setNodes(function (nodesSnapshot) {
+            return nodesSnapshot.filter(function (node) { return !nodesToDelete.some(function (n) { return n.id === node.id; }); });
+        });
+        setEdges(function (edgesSnapshot) {
+            return edgesSnapshot.filter(function (edge) {
+                return !nodesToDelete.some(function (n) { return n.id === edge.source || n.id === edge.target; });
+            });
+        });
+    }, [setNodes, setEdges, onChange, fn]);
+    var onEdgesDelete = React.useCallback(function (edgesToDelete) {
+        var newFn = fn;
+        edgesToDelete.forEach(function (edge) {
+            var _a, _b;
+            var sourceField = (_a = edge.sourceHandle) === null || _a === void 0 ? void 0 : _a.split("-")[1];
+            var targetField = (_b = edge.targetHandle) === null || _b === void 0 ? void 0 : _b.split("-")[1];
+            if (!sourceField || !targetField) {
+                console.warn("Invalid connection handles", edge);
+                return;
+            }
+            newFn = applyEdgeDelete(newFn, edge.source, edge.target, sourceField, targetField);
+        });
+        onChange === null || onChange === void 0 ? void 0 : onChange(newFn);
+        setEdges(function (edgesSnapshot) {
+            return edgesSnapshot.filter(function (edge) { return !edgesToDelete.some(function (e) { return e.id === edge.id; }); });
+        });
+    }, [setEdges, onChange, fn]);
+    return (React.createElement(react.ReactFlow, { nodes: nodes, edges: edges, nodeTypes: nodeTypes, onNodesChange: onNodesChange, onEdgesChange: onEdgesChange, onNodesDelete: onNodesDelete, onEdgesDelete: onEdgesDelete, onNodeDragStop: updatePosition, onConnect: onConnect, fitView: true, 
+        // panOnDrag={false}
+        selectionOnDrag: true, minZoom: 0.1, deleteKeyCode: "Delete" },
+        React.createElement(react.Background, { color: "#ccc", variant: react.BackgroundVariant.Dots }),
+        React.createElement(react.Controls, null)));
+}
+function Flow(_a) {
+    var fn = _a.function, engine = _a.engine, _b = _a.onChange, onChange = _b === void 0 ? function () { } : _b;
+    return (React.createElement(EngineContext.Provider, { value: engine },
+        React.createElement(ChangeContext.Provider, { value: onChange },
+            React.createElement(react.ReactFlowProvider, null,
+                React.createElement(FlowInner, { function: fn, engine: engine, onChange: onChange })))));
+}
+
+exports.Engine = Engine;
+exports.Flow = Flow;
+exports.applyEdgeDelete = applyEdgeDelete;
+exports.applyNodeAdd = applyNodeAdd;
+exports.applyNodeConnect = applyNodeConnect;
+exports.applyNodeDelete = applyNodeDelete;
+exports.createGraph = createGraph;
+exports.getReferences = getReferences;
+exports.getValue = getValue$1;
+exports.interpolate = interpolate;
+exports.isReference = isReference;
+exports.normalizeVarDef = normalizeVarDef;
+exports.parseReference = parseReference;
+exports.primitives = primitives;
+exports.topSort = topSort;
+exports.uid = uid;
+//# sourceMappingURL=index.js.map