sveltekit-ui 1.0.0

package/dist/Components/FunctionInput/index.svelte.js

@@ -0,0 +1,1215 @@
+import { create_unique_id, deep_copy, node_types, node_categories } from "../../client/index.js"
+import { create_button_manager } from "../Button/index.svelte.js"
+import { create_icon_manager } from "../Icon/index.svelte.js"
+import { create_node_manager } from "./Node/index.svelte.js"
+import { browser } from "$app/environment"
+
+export function create_function_manager(config) {
+  let init_function = $state(null)
+  let id = $state(null)
+  let name = $state(null)
+  let description = $state(null)
+  let db_epoch_updated = $state(null)
+  let db_epoch_created = $state(null)
+  let versions = $state([])
+  let selected_version_index = $state(0)
+  let error_message = $state(null)
+  let console_logs = $state(null)
+  let console_result = $state(null)
+  let node_path = $state([])
+  let selected_category = $state("main")
+  let undo_version_button_manager = $state(null)
+  let redo_version_button_manager = $state(null)
+  let node_toolbox_items = $state(null)
+  let node_category_buttons = $state(null)
+  let dragging_node = $state(null)
+  let root_node_manager = $state(null)
+  let trashcan_icon_manager = $state(null)
+
+  let selected_version = $derived(versions?.[selected_version_index])
+
+  function get_node_toolbox_items() {
+    let node_toolbox_items_loc = []
+    if (Object.keys(node_types || {}).length > 0) {
+      for (let node_type of Object.keys(node_types || {})) {
+        if (node_types?.[node_type]?.category == selected_category) {
+          node_toolbox_items_loc.push(
+            create_node_manager({
+              is_clickable_only: false,
+              is_preview: true,
+              node_type: node_type,
+              node_types,
+              node_path,
+              node_categories,
+              c: 12,
+              drag_or_select_node: drag_or_select_node,
+              handle_node_drag_start: () =>
+                handle_node_drag_start({
+                  node_path: node_path,
+                  node_type: node_type,
+                }),
+              handle_node_drag_end: () =>
+                handle_node_drag_end({
+                  node_path: node_path,
+                  node_type: node_type,
+                }),
+              on_set_node_value: (input) => set_node_value(input),
+            })
+          )
+        }
+      }
+    }
+    return node_toolbox_items_loc
+  }
+
+  function get_node_category_buttons() {
+    let sorted_node_categories_array = Object.keys(node_categories)
+      .sort((a, b) => node_categories[a].display_order - node_categories[b].display_order)
+      .map((key) => ({
+        id: key,
+        h: node_categories[key].h,
+        display_order: node_categories[key].display_order,
+      }))
+    let node_category_buttons_loc = []
+    if (Array.isArray(sorted_node_categories_array) && sorted_node_categories_array.length > 0) {
+      for (let node_category of sorted_node_categories_array) {
+        const is_selected = selected_category == node_category?.id
+        node_category_buttons_loc.push({
+          is_selected: is_selected,
+          button_manager: create_button_manager({
+            min_height: 5,
+            text: node_category?.id,
+            h: node_category?.h,
+            c: 10,
+            l: 16,
+            selected_type: () => (is_selected ? "selected" : null),
+            on_click: () => {
+              node_toolbox_items = get_node_toolbox_items() // prob instead do once for all then filter by category
+              selected_category = node_category?.id
+            },
+          }),
+        })
+      }
+    }
+    return node_category_buttons_loc
+  }
+
+  function undo() {
+    if (versions.length - selected_version_index > 1) {
+      selected_version_index += 1
+    }
+  }
+
+  function redo() {
+    if (versions.length > 0) {
+      selected_version_index -= 1
+    }
+  }
+
+  function transition(action) {
+    if (!browser.startViewTransition) {
+      return
+    }
+    document.startViewTransition(action)
+  }
+
+  function handle_node_drag_start(node_data) {
+    transition(() => (dragging_node = node_data))
+  }
+
+  function handle_node_drag_end() {
+    transition(() => (dragging_node = null))
+  }
+
+  function get_defined_at_path(node_path) {
+    let structure_loc = deep_copy(selected_version)
+    let res = get_defined_at_path_traverse(structure_loc, node_path)
+    console.log("get_defined_at_path_res", res)
+    return res?.defined
+  }
+
+  function get_defined_at_path_traverse(node, seek_until_node_path, iter_node_path = []) {
+    let defined = {}
+    let is_path_found = false
+    if (!Array.isArray(seek_until_node_path) || !Array.isArray(iter_node_path)) {
+      is_path_found = true
+    } else if (seek_until_node_path.length <= iter_node_path.length) {
+      for (let i = 0; i < iter_node_path.length; i++) {
+        if (typeof iter_node_path[i] == "number") {
+          if (iter_node_path[i] >= seek_until_node_path?.[i]) {
+            is_path_found = true
+            break
+          }
+        } else if (iter_node_path[i] != seek_until_node_path?.[i]) {
+          break
+        } else if (i == seek_until_node_path.length - 1) {
+          is_path_found = true
+          break
+        }
+      }
+    }
+    if (!node || !Array.isArray(seek_until_node_path) || seek_until_node_path.length == 0) {
+      return { defined, is_path_found }
+    }
+    let full_node_type = node_types?.[node?.type]
+    // should add the other define things like in loop or sort or use node kind to find definitions
+    // maybe also if im showing type in ui then assignments should update type but prob too difficult to predit with if else stuff
+    if (node?.type == "define") {
+      if (node?.value?.identifier?.type == "identifier_literal" && node?.value?.identifier?.value) {
+        let cleaned_identifier = node?.value?.identifier?.value.toLowerCase()
+        cleaned_identifier = cleaned_identifier.replace(/[^a-z0-9]/g, "_")
+        cleaned_identifier = cleaned_identifier.replace(/_{2,}/g, "_")
+        cleaned_identifier = cleaned_identifier.replace(/^_+|_+$/g, "")
+        defined[cleaned_identifier] = {
+          path: iter_node_path,
+          type: node?.value?.value?.type,
+        }
+      }
+    } else if (node?.type == "stack_literal") {
+      if (Array.isArray(node?.value)) {
+        for (let i = 0; i < node?.value.length; i++) {
+          let res = get_defined_at_path_traverse(node?.value?.[i], seek_until_node_path, [...iter_node_path, i])
+          defined = { ...defined, ...res?.defined }
+          if (res?.is_path_found) {
+            is_path_found = true
+            break
+          }
+        }
+      }
+    } else if (full_node_type?.kind != "literal" || Object.keys(full_node_type?.fields || {}).length) {
+      for (let key of Object.keys(full_node_type?.fields || {})) {
+        if (node?.value) {
+          let res = get_defined_at_path_traverse(node?.value?.[key], seek_until_node_path, [...iter_node_path, key])
+          defined = { ...defined, ...res?.defined }
+          if (res?.is_path_found) {
+            is_path_found = true
+            break
+          }
+        }
+      }
+    }
+    return { defined, is_path_found }
+  }
+
+  function get_node_at_path(iter_node, remaining_node_path) {
+    if (!Array.isArray(remaining_node_path) || remaining_node_path.length == 0) {
+      return iter_node
+    }
+    let [first, ...rest_of_node_path] = remaining_node_path
+    return get_node_at_path(iter_node?.value?.[first], rest_of_node_path)
+  }
+
+  function remove_node(iter_node, remaining_node_path) {
+    if (!Array.isArray(remaining_node_path) || remaining_node_path.length == 0) {
+      return null
+    }
+    let [first, ...rest_of_node_path] = remaining_node_path
+    if (remaining_node_path.length == 1 && typeof first == "number" && Array.isArray(iter_node?.value)) {
+      iter_node.value = [...iter_node.value].filter((_, index) => index !== first)
+    } else {
+      iter_node.value[first] = remove_node(iter_node?.value?.[first], rest_of_node_path)
+    }
+    return iter_node
+  }
+
+  function get_default_node_value(node_type) {
+    let default_node = null
+    if (node_type && Object.keys(node_types?.[node_type]?.fields || {}).length > 0) {
+      default_node = {
+        type: node_type,
+        value: {},
+      }
+      for (let [key, value] of Object.entries(node_types?.[node_type]?.fields)) {
+        default_node.value[key] = null
+        if (value?.forced_node) {
+          default_node.value[key] = get_default_node_value(value?.forced_node) // careful about triggering infinate recursion here
+        }
+      }
+    } else if (node_types?.[node_type]?.kind == "literal") {
+      default_node = {
+        type: node_type,
+        value: node_types?.[node_type]?.value ?? null,
+      }
+    }
+    return default_node
+  }
+
+  function set_value_at_node_path(iter_node, remaining_node_path, value = null, is_insert = false) {
+    if (!iter_node || !Array.isArray(remaining_node_path) || remaining_node_path.length == 0) {
+      return value
+    }
+    let [first, ...rest_of_node_path] = remaining_node_path
+    if (remaining_node_path.length == 1) {
+      if (typeof first == "number") {
+        if (!Array.isArray(iter_node?.value)) {
+          iter_node.value = []
+        }
+        if (is_insert) {
+          iter_node.value.splice(first, 0, value)
+        } else {
+          iter_node.value[first].value = value
+        }
+      } else {
+        console.log("ggg1", deep_copy({ iter_node, first, value }))
+        iter_node.value[first].value = value
+      }
+    } else {
+      let temp = set_value_at_node_path(iter_node?.value?.[first], rest_of_node_path, value, is_insert)
+      iter_node.value[first] = temp
+    }
+    return iter_node
+  }
+
+  function set_node_at_node_path(iter_node, remaining_node_path, node_to_add = null, is_insert = false) {
+    console.log("set_node_at_node_path", { iter_node, remaining_node_path, node_to_add, is_insert })
+    if (!iter_node) {
+      return null
+    } else if (!Array.isArray(remaining_node_path) || remaining_node_path.length == 0) {
+      return node_to_add
+    }
+    let [first, ...rest_of_node_path] = remaining_node_path
+    if (remaining_node_path.length == 1) {
+      if (typeof first == "number") {
+        if (!Array.isArray(iter_node?.value)) {
+          iter_node.value = []
+        }
+        if (is_insert) {
+          iter_node.value.splice(first, 0, node_to_add)
+        } else {
+          iter_node.value[first] = node_to_add
+        }
+      } else {
+        iter_node.value[first] = node_to_add
+      }
+    } else {
+      let temp = set_node_at_node_path(iter_node?.value?.[first], rest_of_node_path, node_to_add, is_insert)
+      iter_node.value[first] = temp
+    }
+    return iter_node
+  }
+
+  function set_node_value(node_path, value) {
+    let structure_loc = deep_copy(selected_version)
+    structure_loc = set_value_at_node_path(structure_loc, node_path, value)
+    versions = [structure_loc, ...versions.slice(selected_version_index)]
+  }
+
+  function set_root_node_prepped() {
+    console.log("set_root_node_prepped")
+    let node_value = selected_version?.value
+    let node_type = selected_version?.type
+    let node_path = []
+    root_node_manager = create_node_manager({
+      node_type: node_type,
+      node_path: node_path,
+      node_value: node_value,
+      is_clickable_only: false,
+      is_preview: true,
+      node_types,
+      node_categories,
+      c: 12,
+      handle_node_drag_start: () =>
+        handle_node_drag_start({
+          node_path: node_path,
+          node_type: node_type,
+        }),
+      handle_node_drag_end: () =>
+        handle_node_drag_end({
+          node_path: node_path,
+          node_type: node_type,
+        }),
+      on_set_node_value: (input) => set_node_value(input),
+      drag_or_select_node: drag_or_select_node,
+    })
+  }
+
+  function drag_or_select_node(
+    drop_area_node_path,
+    drop_area_node_type,
+    is_click = false,
+    clicked_node_type = null,
+    is_trash = false
+  ) {
+    console.log("drag_or_select_node", {
+      drop_area_node_path,
+      drop_area_node_type,
+      is_click,
+      clicked_node_type,
+      is_trash,
+    })
+    let node_to_insert = dragging_node
+    error_message = null
+    let structure_loc = deep_copy(selected_version)
+    if (is_trash) {
+      structure_loc = remove_node(structure_loc, node_to_insert?.node_path)
+      console.log("post_rem", deep_copy(structure_loc))
+    } else {
+      if (is_click) {
+        node_to_insert = { node_type: clicked_node_type }
+      }
+      let drop_area_node_options = []
+      if (drop_area_node_type == "stack_literal") {
+        drop_area_node_options = node_types?.stack_literal?.child_node_options
+      } else {
+        drop_area_node_options =
+          node_types?.[drop_area_node_type]?.fields?.[
+            Array.isArray(drop_area_node_path) ? drop_area_node_path[drop_area_node_path.length - 1] : -1
+          ]?.node_options
+      }
+      if (!Array.isArray(drop_area_node_options) || !drop_area_node_options.includes(node_to_insert?.node_type)) {
+        error_message = `"${node_to_insert?.node_type}" not allowed in "${drop_area_node_type}" ${
+          Array.isArray(drop_area_node_path) && drop_area_node_path.length > 0
+            ? `at path [${drop_area_node_path.join(", ")}]`
+            : ""
+        }`
+        set_root_node_prepped()
+        return
+      }
+      if (node_to_insert?.node_path) {
+        let node_value_at_path = get_node_at_path(structure_loc, node_to_insert?.node_path)
+        structure_loc = remove_node(structure_loc, node_to_insert?.node_path)
+        if (
+          drop_area_node_path.length >= node_to_insert?.node_path.length &&
+          typeof node_to_insert?.node_path[node_to_insert?.node_path.length - 1] == "number" &&
+          drop_area_node_path[node_to_insert?.node_path.length - 1] >=
+            node_to_insert?.node_path[node_to_insert?.node_path.length - 1]
+        ) {
+          drop_area_node_path[node_to_insert?.node_path.length - 1] =
+            drop_area_node_path[node_to_insert?.node_path.length - 1] - 1
+        }
+        structure_loc = set_node_at_node_path(structure_loc, drop_area_node_path, node_value_at_path, true)
+      } else if (node_to_insert?.node_type) {
+        let default_node_value = get_default_node_value(node_to_insert?.node_type)
+        structure_loc = set_node_at_node_path(structure_loc, drop_area_node_path, default_node_value, true)
+      } else {
+        error_message = "Node to insert type_id not set"
+        return
+      }
+    }
+    versions = [structure_loc, ...versions.slice(selected_version_index)]
+    selected_version_index = 0
+    dragging_node = null
+    set_root_node_prepped()
+  }
+
+  function run_node_literal(structure, node_path, defined = {}, parent_node_path) {
+    let logs = []
+    let output = null
+    let is_return = false
+    if (!structure || !structure.hasOwnProperty(node_path)) {
+      return {
+        logs: [
+          {
+            kind: "error",
+            label: "Runtime Error",
+            value: `node_path, ${node_path}, not found.`,
+          },
+        ],
+        output,
+        is_return,
+        defined,
+      }
+    }
+    function crunch_literal(structure, input, input_type, defined, parent_node_path) {
+      let logs = []
+      if (input_type?.is_custom_literal || input_type?.hasOwnProperty("node_options")) {
+        if (input?.node_path && input_type?.type != "node") {
+          let run_node_literal_res = run_node_literal(structure, input?.node_path, defined, parent_node_path)
+          input = run_node_literal_res?.output
+          defined = run_node_literal_res?.defined
+          logs = [...logs, ...run_node_literal_res?.logs]
+        }
+      } else if (input_type?.type == "array" || Array.isArray(input)) {
+        if (Array.isArray(input)) {
+          for (let i = 0; i < input.length; i++) {
+            let crunch_literal_res = crunch_literal(structure, input?.[i], input_type?.items, defined, parent_node_path)
+            defined = crunch_literal_res?.defined
+            logs = [...logs, ...crunch_literal_res?.logs]
+            input[i] = crunch_literal_res?.output
+            if (crunch_literal_res?.is_return) {
+              return {
+                defined,
+                output: input,
+                logs,
+              }
+            }
+          }
+        }
+      } else if (typeof input == "object" && !Array.isArray(input)) {
+        for (let key of Object.keys(input || {})) {
+          let crunch_literal_res = crunch_literal(
+            structure,
+            input?.[key],
+            input_type?.properties?.[key],
+            defined,
+            parent_node_path
+          )
+          defined = crunch_literal_res?.defined
+          logs = [...logs, ...crunch_literal_res?.logs]
+          input[key] = crunch_literal_res?.output
+          if (crunch_literal_res?.is_return) {
+            return {
+              defined,
+              output: input,
+              logs,
+            }
+          }
+        }
+      }
+      return {
+        defined,
+        output: input,
+        logs,
+      }
+    }
+    if (structure?.[node_path]?.node_type == "define") {
+      defined[node_path] = { defined_in_node_path: parent_node_path }
+      return { logs, output, defined, is_return }
+    }
+    let found_node_type = node_types?.[structure?.[node_path]?.node_type]?.input
+    let crunch_literal_res = crunch_literal(
+      deep_copy(structure),
+      deep_copy(structure?.[node_path]?.input),
+      found_node_type,
+      deep_copy(defined),
+      parent_node_path
+    )
+    defined = crunch_literal_res?.defined
+    logs = [...logs, ...crunch_literal_res?.logs]
+    let input = crunch_literal_res?.output
+    switch (structure?.[node_path]?.node_type) {
+      case "define":
+        // handle this before to avoid crunching input
+        break
+      case "call_function_method":
+        //tbd
+        break
+      case "call_defined":
+        // tbd need to conslider that may be function method or direct function or maybe seperate these nodes
+        console.log("call_defined_pre", deep_copy({ defined, input }))
+        if (!defined.hasOwnProperty(input?.defined_function_node_path)) {
+          logs = [
+            ...logs,
+            {
+              kind: "error",
+              label: "Runtime Error",
+              value: `Called function, ${
+                structure?.[input?.defined_function_node_path]?.input?.name ?? input?.defined_function_node_path
+              }, not defined`,
+            },
+          ]
+          break
+        }
+        // let found_node_type = node_types?.[structure?.[input?.defined_function_node_path]?.node_type]?.input
+        // let crunch_literal_res = crunch_literal(
+        //   deep_copy(structure),
+        //   structure?.[input?.defined_function_node_path]?.input,
+        //   found_node_type,
+        //   defined,
+        //   node_path
+        // )
+        // defined = crunch_literal_res?.defined
+        // logs = [...logs, ...crunch_literal_res?.logs]
+        //   the above may be a better equivalent to below
+        if (Array.isArray(structure?.[input?.defined_function_node_path]?.input?.do)) {
+          for (let do_item of structure?.[input?.defined_function_node_path]?.input?.do) {
+            if (do_item?.node_path) {
+              let run_node_literal_res = run_node_literal(structure, do_item?.node_path, defined, node_path)
+              logs = [...logs, ...run_node_literal_res?.logs]
+              defined = run_node_literal_res?.defined
+              is_return = run_node_literal_res?.is_return
+              if (is_return) {
+                output = run_node_literal_res?.output
+                for (let [key, val] of Object.entries(defined || {})) {
+                  if (val?.defined_in_node_path == node_path) {
+                    delete defined[key]
+                  }
+                }
+                break
+              }
+            }
+          }
+          for (let [key, val] of Object.entries(defined || {})) {
+            if (val?.defined_in_node_path == node_path) {
+              delete defined[key]
+            }
+          }
+        }
+        break
+      case "if_then":
+        if (input.condition) {
+          if (Array.isArray(input?.passed_do)) {
+            for (let do_item of input?.passed_do) {
+              let run_node_literal_res = run_node_literal(structure, do_item?.node_path, defined, node_path)
+              logs = [...logs, ...run_node_literal_res?.logs]
+              defined = run_node_literal_res?.defined
+              is_return = run_node_literal_res?.is_return
+              if (is_return) {
+                output = run_node_literal_res?.output
+                break
+              }
+            }
+            for (let [key, val] of Object.entries(defined || {})) {
+              if (val?.defined_in_node_path == node_path) {
+                delete defined[key]
+              }
+            }
+          }
+        }
+        break
+      case "if_then_else":
+        if (input.condition) {
+          if (Array.isArray(input?.passed_do)) {
+            for (let do_item of input?.passed_do) {
+              let run_node_literal_res = run_node_literal(structure, do_item?.node_path, defined, node_path)
+              logs = [...logs, ...run_node_literal_res?.logs]
+              defined = run_node_literal_res?.defined
+              is_return = run_node_literal_res?.is_return
+              if (is_return) {
+                output = run_node_literal_res?.output
+                break
+              }
+            }
+            for (let [key, val] of Object.entries(defined || {})) {
+              if (val?.defined_in_node_path == node_path) {
+                delete defined[key]
+              }
+            }
+          }
+        } else {
+          if (Array.isArray(input?.failed_do)) {
+            for (let do_item of input?.failed_do) {
+              let run_node_literal_res = run_node_literal(structure, do_item?.node_path, defined, node_path)
+              logs = [...logs, ...run_node_literal_res?.logs]
+              defined = run_node_literal_res?.defined
+              is_return = run_node_literal_res?.is_return
+              if (is_return) {
+                output = run_node_literal_res?.output
+                break
+              }
+            }
+            for (let [key, val] of Object.entries(defined || {})) {
+              if (val?.defined_in_node_path == node_path) {
+                delete defined[key]
+              }
+            }
+          }
+        }
+        break
+      case "for_loop":
+        let loop_over = input?.loop_over
+        if (typeof loop_over === "object" && !Array.isArray(loop_over)) {
+          loop_over = Object.entries(loop_over).map(([key, value]) => ({ key, value }))
+        } else if (!isNaN(loop_over)) {
+          loop_over = Array.from({ length: loop_over }, (_, i) => i)
+        }
+        if (Array.isArray(loop_over) && Array.isArray(input?.do)) {
+          defined[node_path] = { defined_in_node_path: node_path, value: null }
+          for (let value of loop_over) {
+            defined[node_path].value = value
+            for (let do_item of input?.do) {
+              let run_node_literal_res = run_node_literal(structure, do_item?.node_path, defined, node_path)
+              logs = [...logs, ...run_node_literal_res?.logs]
+              defined = run_node_literal_res?.defined
+              is_return = run_node_literal_res?.is_return
+              if (is_return) {
+                output = run_node_literal_res?.output
+                break
+              }
+            }
+          }
+          for (let [key, val] of Object.entries(defined || {})) {
+            if (val?.defined_in_node_path == node_path) {
+              delete defined[key]
+            }
+          }
+        }
+        break
+      case "return":
+        is_return = true
+        output = input
+        break
+      case "log":
+        logs = [{ kind: input?.kind, label: input?.label, value: input?.value }]
+        break
+      case "define":
+        defined[node_path] = { defined_in_node_path: parent_node_path, value: input?.value }
+        break
+      case "set_defined":
+        if (defined.hasOwnProperty(input?.defined_node_path)) {
+          defined[input?.defined_node_path].value = input?.value
+        } else {
+          logs = [
+            ...logs,
+            {
+              kind: "error",
+              label: "Runtime Error",
+              value: `Variable, ${
+                structure?.[input?.defined_function_node_path]?.input?.name ?? input?.defined_function_node_path
+              }, not defined`,
+            },
+          ]
+        }
+        break
+      case "get_defined":
+        if (!defined.hasOwnProperty(input?.defined_node_path)) {
+          logs = [
+            ...logs,
+            {
+              kind: "error",
+              label: "Runtime Error",
+              value: `Variable, ${
+                structure?.[input?.defined_function_node_path]?.input?.name ?? input?.defined_function_node_path
+              }, not defined`,
+            },
+          ]
+        } else {
+          output = defined[input?.defined_node_path]?.value
+        }
+        break
+      case "select_defined":
+        output = input?.defined_node_path
+        break
+      case "set_defined_object_field":
+        if (defined.hasOwnProperty(input?.defined_node_path)) {
+          defined[input?.defined_node_path].value[input?.field_name] = input?.value
+        } else {
+          logs = [
+            ...logs,
+            {
+              kind: "error",
+              label: "Runtime Error",
+              value: `Variable, ${
+                structure?.[input?.defined_function_node_path]?.input?.name ?? input?.defined_function_node_path
+              }, not defined`,
+            },
+          ]
+        }
+        break
+      case "truthy_compare":
+        if (input?.operator == "logical_or") {
+          output = input?.a || input?.b
+        } else if (input?.operator == "nullish_coalescing") {
+          output = input?.a ?? input?.b
+        } else if (input?.operator == "and") {
+          output = input?.a && input?.b
+        }
+        break
+      case "arithmetic_binary_operation":
+        if (input?.operator === "add") {
+          output = input?.a + input?.b
+        } else if (input?.operator === "subtract") {
+          output = input?.a - input?.b
+        } else if (input?.operator === "multiply") {
+          output = input?.a * input?.b
+        } else if (input?.operator === "divide") {
+          output = input?.a / input?.b
+        } else if (input?.operator === "remainder") {
+          output = input?.a % input?.b
+        } else if (input?.operator === "exponent") {
+          output = Math.pow(input?.a, input?.b)
+        } else if (input?.operator === "min") {
+          output = Math.min(input?.a, input?.b)
+        } else if (input?.operator === "max") {
+          output = Math.max(input?.a, input?.b)
+        } else if (input?.operator === "rand_value_between") {
+          output = Math.random() * (input?.b - input?.a) + input?.a //may make its own thing
+        } else if (input?.operator === "to_precision") {
+          output = Number(input?.a).toPrecision(input?.b)
+        } else {
+          output = null
+        }
+        break
+      case "compare_numbers":
+        if (input?.operator == "less_than") {
+          output = input?.a < input?.b
+        } else if (input?.operator == "less_than_or_equal") {
+          output = input?.a <= input?.b
+        } else if (input?.operator == "greater_than") {
+          output = input?.a > input?.b
+        } else if (input?.operator == "greater_than_or_equal") {
+          output = input?.a >= input?.b
+        } else if (input?.operator == "equal_to") {
+          output = input?.a == input?.b
+        } else if (input?.operator == "not_equal_to") {
+          output = input?.a != input?.b
+        }
+        break
+      case "compare_text":
+        if (input?.operator === "equal_to") {
+          output = input?.a == input?.b
+        } else if (input?.operator === "not_equal_to") {
+          output = input?.a !== input?.b
+        } else if (input?.operator === "contains") {
+          output = input?.a?.includes(input?.b)
+        } else if (input?.operator === "does_not_contain") {
+          output = !input?.a?.includes(input?.b)
+        } else if (input?.operator === "starts_with") {
+          output = input?.a?.startsWith(input?.b)
+        } else if (input?.operator === "ends_with") {
+          output = input?.a?.endsWith(input?.b)
+        }
+        break
+      case "round":
+        if (input?.operator === "nearest_int") {
+          output = Math.round(input?.a)
+        } else if (input?.operator === "floor_int") {
+          output = Math.floor(input?.a)
+        } else if (input?.operator === "ceil_int") {
+          output = Math.ceil(input?.a)
+        } else if (input?.operator === "absolute_value") {
+          output = Math.abs(input?.a)
+        }
+        break
+      case "parse":
+        if (input?.operator === "to_int") {
+          output = parseInt(input?.value)
+        } else if (input?.operator === "to_float") {
+          output = parseFloat(input?.value)
+        } else if (input?.operator === "to_object") {
+          output = JSON.parse(input?.value)
+        } else if (input?.operator === "to_array") {
+          output = Array.isArray(input?.value) ? input?.value : JSON.parse(input?.value)
+        } else if (input?.operator === "to_boolean") {
+          output = Boolean(input?.value)
+        } else if (input?.operator === "to_account_id") {
+          output = input?.value?.toString() // assuming account_id should be a string
+        } else {
+          output = null
+        }
+        break
+      case "add_item_to_array":
+        if (Array.isArray(input?.array)) {
+          if (input?.where_to_add == "start") {
+            output = [input?.value_to_add, ...input?.array]
+          } else if (input?.where_to_add == "end") {
+            output = [...input?.array, input?.value_to_add]
+          } else {
+            output = null
+          }
+        }
+        break
+      case "add_item_to_array_at_index":
+        if (Array.isArray(input?.array) && typeof input?.where_to_add == "number") {
+          output = [...input.array]
+          output.splice(input.where_to_add, 0, input.value_to_add)
+        }
+        break
+      case "remove_item_from_array":
+        if (Array.isArray(input?.array)) {
+          output = [...input.array]
+          if (input.where_to_remove === "start") {
+            output.shift()
+          } else if (input.where_to_remove === "end") {
+            output.pop()
+          } else {
+            output = null
+          }
+        } else {
+          output = null
+        }
+        break
+      case "remove_item_from_array_at_index":
+        if (Array.isArray(input?.array)) {
+          output = [...input.array].filter((_, index) => index !== input?.where_to_remove)
+        }
+        break
+      case "concat_arrays":
+        if (Array.isArray(input?.first_array) && Array.isArray(input?.second_array)) {
+          output = [...input?.first_array, ...input?.second_array]
+        }
+        break
+      case "local_compare":
+        output = input?.a.localCompare(input?.b)
+        break
+      case "sort_array":
+        if (Array.isArray(input?.array) && Array.isArray(input?.do)) {
+          defined[node_path] = {
+            defined_in_node_path: node_path,
+            a: null,
+            b: null,
+          }
+          input.array.sort((a, b) => {
+            defined[node_path].a = a
+            defined[node_path].b = b
+            let sort_value = 0
+            for (let do_item of input?.do) {
+              let run_node_literal_res = run_node_literal(structure, do_item?.node_path, defined, node_path)
+              logs = [...logs, ...run_node_literal_res?.logs]
+              defined = run_node_literal_res?.defined
+              if (run_node_literal_res?.is_return) {
+                sort_value =
+                  run_node_literal_res?.output == true
+                    ? 1
+                    : run_node_literal_res?.output == false
+                    ? -1
+                    : run_node_literal_res?.output
+                break
+              }
+            }
+            return sort_value
+          })
+          output = input.array
+          for (let [key, val] of Object.entries(defined || {})) {
+            if (val?.defined_in_node_path == node_path) {
+              delete defined[key]
+            }
+          }
+        }
+        break
+      case "slice":
+        if (typeof input?.value === "string" || Array.isArray(input?.value)) {
+          output = input?.value.slice(input?.start_index, input?.end_index)
+        }
+        break
+      case "join_array_of_text_items":
+        if (Array.isArray(input)) {
+          output = [...input].join()
+        }
+        break
+      case "reverse_array":
+        if (Array.isArray(input)) {
+          output = [...input].reverse()
+        }
+        break
+      case "join_array_of_text":
+        if (Array.isArray(input?.array)) {
+          output = [...input.array].join()
+        }
+        break
+      case "sum_of_number_array":
+        if (Array.isArray(input)) {
+          output = input.reduce((acc, curr) => acc + curr, 0)
+        }
+        break
+      case "average_of_number_array":
+        if (Array.isArray(input)) {
+          output = input.reduce((acc, curr) => acc + curr, 0) / input.length
+        }
+        break
+      case "split_text":
+        if (input?.text && input?.delimiter) {
+          output = input?.text.split(input?.delimiter)
+        }
+        break
+      case "replace_text":
+        if (input?.base_text && input?.replace_text && input?.replacement_text) {
+          output = input?.base_text.replace(input?.replace_text, input?.replacement_text)
+        }
+        break
+      case "trim_text":
+        if (input) {
+          output = input?.trim()
+        }
+        break
+      case "get_length":
+        if (Array.isArray(input)) {
+          output = input.length
+        } else if (typeof input === "object") {
+          output = Object.keys(input).length
+        } else if (typeof input === "string") {
+          output = input.length
+        }
+        break
+      case "empty_array":
+        output = []
+        break
+      case "empty_object":
+        output = {}
+        break
+      case "null":
+        output = null
+        break
+      case "email_address_literal":
+        output = input
+        break
+      case "int_literal":
+        output = input
+      case "bigint_literal":
+        output = input
+      case "float_literal":
+        output = input
+      case "text_literal":
+        output = input
+        break
+      case "checkbox_literal":
+        output = !!input
+        break
+      case "time_literal":
+        output = input
+        break
+      case "location_literal":
+        output = input
+        break
+      case "color_literal":
+        output = input
+        break
+      case "object_literal":
+        console.log("object_literal", input)
+        let obj = {}
+        if (Array.isArray(input)) {
+          for (let i = 0; i < input.length; i++) {
+            for (let key of ["key", "value"]) {
+              console.log("object_literal1", input?.[i][key])
+              if (input?.[i][key]?.type) {
+                let run_node_literal_res = run_node_literal(structure, input[i][key].input, defined, node_path)
+                logs = [...logs, ...run_node_literal_res?.logs]
+                input[i][key] = run_node_literal_res?.output
+              }
+            }
+            obj[input[i]?.key] = input[i]?.value
+            console.log("object_literal3", obj)
+          }
+        }
+        output = obj
+        break
+      case "subscriber_id_literal":
+        output = input
+        break
+      case "call_endpoint":
+        // input = {
+        //   endpoint: , text
+        //   headers: , json
+        //   body:
+        // }
+        output = input
+        break
+      case "set_custom_field_on_subscriber":
+        // input = {
+        //   subscriber_id: , text
+        //   custom_field_name:
+        //   value:
+        // }
+        break
+      case "set_subscriber_tier":
+        // input = {
+        //   subscriber_id: , text
+        //   tier:
+        // }
+        break
+      case "send_email":
+        // input = {
+        //   send_from_account_id: , text
+        //   email_template_id:
+        //   email_variables:
+        //   email_options:
+        // }
+        break
+      default:
+        output = input
+        break
+    }
+    return { logs, output, defined, is_return }
+  }
+
+  function run_selected_config(input = {}) {
+    let selected_config = deep_copy(selected_version)
+    console.log("prerun structure", JSON.parse(JSON.stringify(selected_config)))
+    let init_literal = null //tbd
+    let wrapped_structure = {
+      ...selected_config,
+      call_main_function_00: {
+        node_type: "call_defined",
+        input: {
+          defined_function_node_path: "main_function_000000000",
+          input: init_literal,
+        },
+      },
+    }
+    let run_node_res = run_node_literal(wrapped_structure, "call_main_function_00", {
+      main_function_000000000: { defined_in_node_path: null },
+    })
+    console.log("run_node_res", run_node_res)
+    console_logs = run_node_res?.logs
+    console_result = run_node_res?.output
+    return run_node_res
+  }
+
+  let update_function_is_loading = $state(false)
+  let update_function_success_trigger = $state(0)
+  let update_function_error_trigger = $state(0)
+  let update_function_error_message = $state(null)
+  async function update_function(account_id) {
+    console.log("update_function", account_id)
+    try {
+      update_function_is_loading = true
+      update_function_error_message = null
+      let update_function_res = await fetch(`/api/v1/accounts/${account_id}/functions/${id}`, {
+        method: "PUT",
+        body: JSON.stringify({
+          name: name,
+          description: description,
+          structure: selected_version,
+        }),
+      })
+      let update_function_res_body = await update_function_res.json()
+      console.log("update_function_res_body", update_function_res_body)
+      if (!update_function_res.ok) {
+        throw new Error(update_function_res_body?.message ?? "Error creating function.")
+      }
+      if (selected_version_index > 0) {
+        versions = versions.splice(selected_version_index)
+        selected_version_index = 0
+      }
+      name = update_function_res_body?.name
+      description = update_function_res_body?.description
+      db_epoch_updated = update_function_res_body?.db_epoch_updated
+      db_epoch_created = update_function_res_body?.db_epoch_created
+      update_function_success_trigger += 1
+    } catch (err) {
+      update_function_error_message = err
+      update_function_error_trigger += 1
+    } finally {
+      update_function_is_loading = false
+    }
+  }
+
+  function init(config) {
+    init_function = config
+    id = config?.id
+    name = config?.name
+    description = config?.description
+    db_epoch_updated = config?.db_epoch_updated
+    db_epoch_created = config?.db_epoch_created
+    node_path = config?.node_path
+    if (config?.structure) {
+      versions = [config?.structure]
+    } else {
+      versions = [
+        {
+          type: "config",
+          value: {
+            parameters: {
+              type: "parameters_literal",
+              value: null,
+            },
+            is_do_collapsed: {
+              type: "arrow_toggle_literal",
+              value: false,
+            },
+            do: {
+              type: "stack_literal",
+              value: [],
+            },
+          },
+        },
+      ]
+    }
+    selected_version_index = 0
+    undo_version_button_manager = create_button_manager({
+      type: "soft",
+      is_no_wrap: true,
+      icon_sw: 40,
+      is_uniform: true,
+      support_icon: "undo_arrow",
+      is_disabled: versions.length < 2 || versions.length - selected_version_index < 2,
+      on_click: () => undo(),
+    })
+    redo_version_button_manager = create_button_manager({
+      type: "soft",
+      is_no_wrap: true,
+      icon_sw: 40,
+      is_uniform: true,
+      support_icon: "redo_arrow",
+      is_disabled: versions.length < 2 || versions.length - selected_version_index < 1,
+      on_click: () => redo(),
+    })
+    trashcan_icon_manager = create_icon_manager({
+      icon_id: "trashcan",
+      size: 8,
+      sw: 10,
+      color: "oklch(var(--l10-t) var(--c11) var(--h1))",
+    })
+    node_category_buttons = get_node_category_buttons()
+    set_root_node_prepped()
+    node_toolbox_items = get_node_toolbox_items()
+  }
+  init(config)
+
+  return {
+    get selected_category() {
+      return selected_category
+    },
+    get versions() {
+      return versions
+    },
+    get selected_version_index() {
+      return selected_version_index
+    },
+    get selected_version() {
+      return selected_version
+    },
+    get error_message() {
+      return error_message
+    },
+    get console_logs() {
+      return console_logs
+    },
+    get console_result() {
+      return console_result
+    },
+    get node_types() {
+      return node_types
+    },
+    get dragging_node() {
+      return dragging_node
+    },
+    get init_function() {
+      return init_function
+    },
+    get id() {
+      return id
+    },
+    get name() {
+      return name
+    },
+    get description() {
+      return description
+    },
+    get db_epoch_updated() {
+      return db_epoch_updated
+    },
+    get db_epoch_created() {
+      return db_epoch_created
+    },
+    get update_function_is_loading() {
+      return update_function_is_loading
+    },
+    get update_function_success_trigger() {
+      return update_function_success_trigger
+    },
+    get update_function_error_trigger() {
+      return update_function_error_trigger
+    },
+    get update_function_error_message() {
+      return update_function_error_message
+    },
+    get undo_version_button_manager() {
+      return undo_version_button_manager
+    },
+    get redo_version_button_manager() {
+      return redo_version_button_manager
+    },
+    get node_category_buttons() {
+      return node_category_buttons
+    },
+    get node_toolbox_items() {
+      return node_toolbox_items
+    },
+    get root_node_manager() {
+      return root_node_manager
+    },
+    get trashcan_icon_manager() {
+      return trashcan_icon_manager
+    },
+    update_function,
+    undo,
+    redo,
+    handle_node_drag_start,
+    handle_node_drag_end,
+    drag_or_select_node,
+    set_node_value,
+    get_defined_at_path,
+    run_node_literal,
+  }
+}