sveltekit-ui 1.0.7 → 1.0.9

package/src/lib/Components/FunctionInput/index.svelte.js

@@ -1,1215 +0,0 @@
-import { create_unique_id, deep_copy, node_types, function_types, node_categories } from "$lib/client/index.js"
-import { create_button_manager } from "$lib/Components/Button/index.svelte.js"
-import { create_icon_manager } from "$lib/Components/Icon/index.svelte.js"
-import { create_node_manager } from "$lib/Components/FunctionInput/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_category_buttons = $state(null)
-  let dragging_node = $state(null)
-  let root_node_manager = $state(null)
-  let trashcan_icon_manager = $state(null)
-
-  let node_toolbox_items_prepped = $state(null)
-
-  let selected_version = $derived(versions?.[selected_version_index])
-
-  function set_node_toolbox_items_prepped() {
-    let node_toolbox_items_loc = []
-    if (Object.keys(function_types || {}).length > 0) {
-      console.log("function_types", function_types)
-      for (let node_type of Object.keys(function_types || {})) {
-        console.log("node_typeddd", node_type, function_types?.[node_type])
-        node_toolbox_items_loc.push({
-          category: function_types?.[node_type]?.category,
-          node_manager: create_node_manager({
-            is_clickable_only: false,
-            is_preview: true,
-            node_type: node_type,
-            node_types: function_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),
-          }),
-        })
-      }
-    }
-    console.log("node_toolbox_items_loc", node_toolbox_items_loc)
-    node_toolbox_items_prepped = 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: () => (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 = function_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(function_types?.[node_type]?.fields || {}).length > 0) {
-      default_node = {
-        type: node_type,
-        value: {},
-      }
-      for (let [key, value] of Object.entries(function_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 (function_types?.[node_type]?.kind == "literal") {
-      default_node = {
-        type: node_type,
-        value: function_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: function_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 = function_types?.stack_literal?.child_node_options
-      } else {
-        drop_area_node_options =
-          function_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 = function_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 = function_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()
-    set_node_toolbox_items_prepped()
-  }
-  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 function_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 root_node_manager() {
-      return root_node_manager
-    },
-    get trashcan_icon_manager() {
-      return trashcan_icon_manager
-    },
-    get node_toolbox_items_prepped() {
-      return node_toolbox_items_prepped
-    },
-    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,
-  }
-}