sveltekit-ui 1.0.5 → 1.0.7

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

@@ -169,7 +169,7 @@ export function create_chart_manager(config) {
   }
 
   function time_tic_size(seconds) {
-    const ticOptions = [
+    const tic_options = [
       300, //5m
       600, //10m
       900, //15m
@@ -194,9 +194,9 @@ export function create_chart_manager(config) {
       15768000, //6m
       31536000, //1y
     ]
-    for (let i = 0; i < ticOptions.length - 1; i++) {
-      if (ticOptions[i] < seconds && ticOptions[i + 1] > seconds) {
-        return ticOptions[i + 1]
+    for (let i = 0; i < tic_options.length - 1; i++) {
+      if (tic_options[i] < seconds && tic_options[i + 1] > seconds) {
+        return tic_options[i + 1]
       }
     }
     return "-"
@@ -321,25 +321,25 @@ export function create_chart_manager(config) {
     const day = dateObject.getDate()
     const hour = dateObject.getHours()
     const minute = dateObject.getMinutes()
-    const yearSt = JSON.stringify(year)
-    const monthSt = months[month]
-    let daySt = JSON.stringify(day)
-    // if(daySt.length < 2){ daySt = '0' + daySt }
-    let hourSt = JSON.stringify(hour)
-    // if(hourSt.length < 2){ hourSt = '0' + hourSt }
-    let minuteSt = JSON.stringify(minute)
-    if (minuteSt.length < 2) {
-      minuteSt = "0" + minuteSt
+    const year_st = JSON.stringify(year)
+    const month_st = months[month]
+    let day_st = JSON.stringify(day)
+    // if(day_st.length < 2){ day_st = '0' + day_st }
+    let hour_st = JSON.stringify(hour)
+    // if(hour_st.length < 2){ hour_st = '0' + hour_st }
+    let minute_st = JSON.stringify(minute)
+    if (minute_st.length < 2) {
+      minute_st = "0" + minute_st
     }
-    const hourMinuteSt = hourSt + ":" + minuteSt
+    const hour_minute_st = hour_st + ":" + minute_st
     if (minute > 0 || hour > 0) {
-      return hourMinuteSt
+      return hour_minute_st
     } else if (day > 1) {
-      return daySt
+      return day_st
     } else if (month > 0) {
-      return monthSt
+      return month_st
     }
-    return yearSt
+    return year_st
   }
 
   function prep_x_axis(
@@ -459,7 +459,7 @@ export function create_chart_manager(config) {
   }
 
   function next_big_num_under_target(target) {
-    const numBases = [
+    const num_bases = [
       100000000000000, 10000000000000, 1000000000000, 100000000000, 10000000000, 1000000000, 100000000, 50000000,
       20000000, 10000000, 5000000, 2000000, 1000000, 750000, 500000, 400000, 250000, 200000, 150000, 100000, 75000,
       50000, 40000, 25000, 20000, 15000, 10000, 7500, 5000, 4000, 3000, 2500, 2000, 1500, 1250, 1000, 750, 500, 400,
@@ -468,7 +468,7 @@ export function create_chart_manager(config) {
       0.0001, 0.00008, 0.00005, 0.00004, 0.00003, 0.00002, 0.00001, 0.000008, 0.000005, 0.000004, 0.000003, 0.000002,
       0.000001, 0.0000008, 0.0000005, 0.0000004, 0.0000003, 0.0000002, 0.0000001,
     ]
-    for (let num of numBases) {
+    for (let num of num_bases) {
       if (num < target) {
         return num
       }
@@ -477,7 +477,7 @@ export function create_chart_manager(config) {
   }
 
   function tic_size(num) {
-    const ticOptions = [
+    const tic_options = [
       0.0000001, 0.0000002, 0.0000003, 0.0000004, 0.0000005, 0.0000008, 0.000001, 0.000002, 0.000003, 0.000004,
       0.000005, 0.000008, 0.00001, 0.00002, 0.00003, 0.00004, 0.00005, 0.00008, 0.0001, 0.0002, 0.0003, 0.0004, 0.0005,
       0.0008, 0.001, 0.002, 0.003, 0.004, 0.005, 0.008, 0.01, 0.02, 0.03, 0.04, 0.05, 0.08, 0.1, 0.2, 0.3, 0.4, 0.5,
@@ -486,9 +486,9 @@ export function create_chart_manager(config) {
       250000, 400000, 500000, 750000, 1000000, 2000000, 5000000, 10000000, 20000000, 50000000, 100000000, 1000000000,
       10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000,
     ]
-    for (let i = 0; i < ticOptions.length - 1; i++) {
-      if (ticOptions[i] < num && ticOptions[i + 1] > num) {
-        return ticOptions[i + 1]
+    for (let i = 0; i < tic_options.length - 1; i++) {
+      if (tic_options[i] < num && tic_options[i + 1] > num) {
+        return tic_options[i + 1]
       }
     }
     return "-"
@@ -587,67 +587,68 @@ export function create_chart_manager(config) {
   }
 
   function short_lab(num) {
-    var ifneg = 1
+    var if_neg = 1
     if ((typeof num === typeof null) | (typeof num === typeof undefined)) {
       return "-"
     }
     if (num < 0) {
-      ifneg = -1
+      if_neg = -1
     }
     var amount
     amount = Math.abs(num)
     if (amount === 0) {
       return 0
     } else if (amount >= 0 && amount < 0.0001) {
-      return Math.round((ifneg * amount).toFixed(8) * 10000000 + Number.EPSILON) / 10000000
+      return Math.round((if_neg * amount).toFixed(8) * 10000000 + Number.EPSILON) / 10000000
     } else if (amount >= 0.0001 && amount < 0.001) {
-      return Math.round((ifneg * amount).toFixed(7) * 1000000 + Number.EPSILON) / 1000000
+      return Math.round((if_neg * amount).toFixed(7) * 1000000 + Number.EPSILON) / 1000000
     } else if (amount >= 0.001 && amount < 0.01) {
-      return Math.round((ifneg * amount).toFixed(6) * 100000 + Number.EPSILON) / 100000
+      return Math.round((if_neg * amount).toFixed(6) * 100000 + Number.EPSILON) / 100000
     } else if (amount >= 0.01 && amount < 0.1) {
-      return Math.round((ifneg * amount).toFixed(5) * 10000 + Number.EPSILON) / 10000
+      return Math.round((if_neg * amount).toFixed(5) * 10000 + Number.EPSILON) / 10000
     } else if (amount >= 0.1 && amount < 10) {
-      return Math.round((ifneg * amount).toFixed(4) * 1000 + Number.EPSILON) / 1000
+      return Math.round((if_neg * amount).toFixed(4) * 1000 + Number.EPSILON) / 1000
     } else if (amount >= 10 && amount < 1000) {
-      return (ifneg * amount).toFixed(2)
+      return (if_neg * amount).toFixed(2)
     } else if (amount >= 1000 && amount < 1000000) {
-      return (ifneg * amount).toFixed().replace(/\B(?=(\d{3})+(?!\d))/g, ",")
+      return (if_neg * amount).toFixed().replace(/\B(?=(\d{3})+(?!\d))/g, ",")
     } else if (amount >= 1000000 && amount < 10000000) {
-      return (ifneg * (amount / 1000000)).toFixed(2) + " M"
+      return (if_neg * (amount / 1000000)).toFixed(2) + " M"
     } else if (amount >= 10000000 && amount < 100000000) {
-      return (ifneg * (amount / 1000000)).toFixed(1) + " M"
+      return (if_neg * (amount / 1000000)).toFixed(1) + " M"
     } else if (amount >= 100000000 && amount < 1000000000) {
-      return (ifneg * (amount / 1000000)).toFixed() + " M"
+      return (if_neg * (amount / 1000000)).toFixed() + " M"
     } else if (amount >= 1000000000 && amount < 10000000000) {
-      return (ifneg * (amount / 1000000000)).toFixed(2) + " B"
+      return (if_neg * (amount / 1000000000)).toFixed(2) + " B"
     } else if (amount >= 10000000000 && amount < 100000000000) {
-      return (ifneg * (amount / 1000000000)).toFixed(1) + " B"
+      return (if_neg * (amount / 1000000000)).toFixed(1) + " B"
     } else if (amount >= 100000000000 && amount < 1000000000000) {
-      return (ifneg * (amount / 1000000000)).toFixed() + " B"
+      return (if_neg * (amount / 1000000000)).toFixed() + " B"
     } else if (amount >= 1000000000000 && amount < 10000000000000) {
-      return (ifneg * (amount / 1000000000000)).toFixed(2) + " T"
+      return (if_neg * (amount / 1000000000000)).toFixed(2) + " T"
     } else if (amount >= 10000000000000 && amount < 100000000000000) {
-      return (ifneg * (amount / 1000000000000)).toFixed(1) + " T"
+      return (if_neg * (amount / 1000000000000)).toFixed(1) + " T"
     } else if (amount >= 100000000000000 && amount < 1000000000000000) {
-      return (ifneg * (amount / 1000000000000)).toFixed() + " T"
+      return (if_neg * (amount / 1000000000000)).toFixed() + " T"
     } else if (amount >= 1000000000000000 && amount < 10000000000000000n) {
-      return (ifneg * (amount / 1000000000000000)).toFixed(2) + " Q"
+      return (if_neg * (amount / 1000000000000000)).toFixed(2) + " Q"
     } else if (amount >= 10000000000000000n && amount < 100000000000000000n) {
-      return (ifneg * (amount / 1000000000000000)).toFixed(1) + " Q"
+      return (if_neg * (amount / 1000000000000000)).toFixed(1) + " Q"
     } else if (amount >= 100000000000000000n && amount < 1000000000000000000n) {
-      return (ifneg * (amount / 1000000000000000)).toFixed() + " Q"
+      return (if_neg * (amount / 1000000000000000)).toFixed() + " Q"
     } else if (amount >= 1000000000000000000n && amount < 10000000000000000000n) {
-      return (ifneg * (amount / 1000000000000000000n)).toFixed(2) + " QN"
+      return (if_neg * (amount / 1000000000000000000n)).toFixed(2) + " QN"
     } else if (amount >= 10000000000000000000n && amount < 100000000000000000000n) {
-      return (ifneg * (amount / 1000000000000000000n)).toFixed(1) + " QN"
+      return (if_neg * (amount / 1000000000000000000n)).toFixed(1) + " QN"
     } else if (amount >= 100000000000000000000n && amount < 1000000000000000000000n) {
-      return (ifneg * (amount / 1000000000000000000n)).toFixed() + " QN"
+      return (if_neg * (amount / 1000000000000000000n)).toFixed() + " QN"
     } else {
       return "Big"
     }
   }
 
   function handle_scroll_frame(e) {
+    e.preventDefault()
     const res = scroll_frame(
       e,
       chart_prepped.shown_start_x,
@@ -1047,6 +1048,10 @@ export function create_chart_manager(config) {
     }
   }
 
+  function set_datasets(input) {
+    datasets = input
+  }
+
   function init(config) {
     console.log("init_chart", config)
     datasets = config?.datasets
@@ -1080,5 +1085,6 @@ export function create_chart_manager(config) {
     handle_chart_hover_leave,
     set_grid_width,
     gen_color,
+    set_datasets,
   }
 }

package/dist/Components/FunctionInput/Node/helpers/Field/index.svelte.js

@@ -160,7 +160,6 @@ export function create_field_manager(config) {
   )
 
   function init(config) {
-    console.log("jj", config?.bar_item, typeof config?.bar_item)
     bar_item = config?.bar_item ? deep_copy(config?.bar_item) : null
     manager = get_manager()
   }

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

@@ -7,31 +7,56 @@ import { create_field_manager } from "./helpers/Field/index.svelte.js"
 export function create_node_manager(config) {
   console.log("create_node_man", config)
   let node_structure = $state(null)
+  let is_clickable_only = $state(false)
+  let node_path = $state(null)
+  let node_types = $state(null)
+  let node_type = $state(null)
+  let node_value = $state(null)
+  let node_categories = $state(null)
 
   let preview_text = $derived(
-    `${config?.node_type}(${config?.node_types?.[config?.node_type]?.input?.type})→(${
-      config?.node_types?.[config?.node_type]?.output?.type ?? "void"
-    })`
+    `${node_type}(${node_types?.[node_type]?.input?.type})→(${node_types?.[node_type]?.output?.type ?? "void"})`
   )
 
-  let full_node_type = $derived(config?.node_types?.[config?.node_type])
-  let h = $derived(config?.node_categories?.[config?.node_types?.[config?.node_type]?.category]?.h || 4)
+  let full_node_type = $derived(node_types?.[node_type])
+  let h = $derived(node_categories?.[node_types?.[node_type]?.category]?.h || 4)
 
-  function get_node_structure() {
-    console.log("get_node_structure", deep_copy({ config, full_node_type }))
+  function handle_drag_start(e) {
+    if (is_clickable_only || node_path == "main") {
+      e.preventDefault()
+    } else if (typeof config?.handle_node_drag_start == "function") {
+      config?.handle_node_drag_start()
+    }
+  }
+
+  function handle_drag_end(e) {
+    if (is_clickable_only) {
+      e.preventDefault()
+    } else if (typeof config?.handle_node_drag_start == "function") {
+      config?.handle_node_drag_end()
+    }
+  }
+
+  function init(config) {
+    node_categories = config?.node_categories
+    node_path = config?.node_path
+    node_types = config?.node_types
+    node_type = config?.node_type
+    node_value = config?.node_value
+    is_clickable_only = !!config?.is_clickable_only
     let node_structure_loc = []
     if (Array.isArray(full_node_type?.node_structure)) {
       for (let i = 0; i < full_node_type?.node_structure.length; i++) {
         let node_item = deep_copy(full_node_type.node_structure?.[i])
         if (node_item?.ui_type == "stack") {
           node_item.stack_area_manager = create_stack_area_manager({
-            parent_node_type: config?.node_type,
-            node_path: [...(Array.isArray(config?.node_path) ? config?.node_path : []), node_item?.field].filter(
+            parent_node_type: node_type,
+            node_path: [...(Array.isArray(node_path) ? node_path : []), node_item?.field].filter(
               (item) => item !== null && item !== undefined
             ),
-            node_type: config?.node_value?.[node_item?.field]?.type,
-            node_value: config?.node_value?.[node_item?.field]?.value,
-            node_types: config?.node_types,
+            node_type: node_value?.[node_item?.field]?.type,
+            node_value: node_value?.[node_item?.field]?.value,
+            node_types: node_types,
             is_preview: false,
             drag_or_select_node: config?.drag_or_select_node,
             handle_node_drag_start: config?.handle_node_drag_start,
@@ -43,9 +68,9 @@ export function create_node_manager(config) {
               if (node_item[j]?.ui_type == "input") {
                 node_item[j].field_manager = create_field_manager({
                   bar_item: node_item[j],
-                  node_path: config?.node_path,
-                  node_type: config?.node_type,
-                  node_value: config?.node_value,
+                  node_path: node_path,
+                  node_type: node_type,
+                  node_value: node_value,
                   is_preview: !!config?.is_preview,
                   on_set_node_value: (input) => config?.on_set_node_value(input),
                   get_selected_version_node_at_path: (input) => config?.get_selected_version_node_at_path(input),
@@ -53,13 +78,12 @@ export function create_node_manager(config) {
               } else {
                 node_item[j].field_manager = create_field_manager({
                   bar_item: node_item?.[j],
-                  parent_node_type: config?.node_type,
-                  node_path: [
-                    ...(Array.isArray(config?.node_path) ? config?.node_path : []),
-                    node_item[j]?.field,
-                  ].filter((item) => item !== null && item !== undefined),
-                  node_type: config?.node_value?.[node_item[j]?.field]?.type,
-                  node_value: config?.node_value?.[node_item[j]?.field]?.value,
+                  parent_node_type: node_type,
+                  node_path: [...(Array.isArray(node_path) ? node_path : []), node_item[j]?.field].filter(
+                    (item) => item !== null && item !== undefined
+                  ),
+                  node_type: node_value?.[node_item[j]?.field]?.type,
+                  node_value: node_value?.[node_item[j]?.field]?.value,
                   is_preview: !!config?.is_preview,
                   on_set_node_value: (input) => config?.on_set_node_value(input),
                   get_selected_version_node_at_path: (input) => config?.get_selected_version_node_at_path(input),
@@ -71,37 +95,17 @@ export function create_node_manager(config) {
         node_structure_loc.push(node_item)
       }
     }
-    return node_structure_loc
-  }
-
-  function handle_drag_start(e) {
-    if (config?.is_clickable_only || config?.node_path == "main") {
-      e.preventDefault()
-    } else if (config?.handle_node_drag_start) {
-      config?.handle_node_drag_start()
-    }
-  }
-
-  function handle_drag_end(e) {
-    if (config?.is_clickable_only) {
-      e.preventDefault()
-    } else if (config?.handle_node_drag_start) {
-      config?.handle_node_drag_end()
-    }
-  }
-
-  function init(config) {
-    node_structure = get_node_structure()
+    node_structure = node_structure_loc
   }
 
   init(config)
 
   return {
     get node_path() {
-      return config?.node_path
+      return node_path
     },
     get node_type() {
-      return config?.node_type
+      return node_type
     },
     get is_preview() {
       return !!config?.is_preview

package/dist/Components/FunctionInput/index.svelte

@@ -101,11 +101,11 @@
           {/if}
         </div>
         <div class="node_types_container">
-          {#if Array.isArray(manager?.node_toolbox_items)}
-            {#each manager?.node_toolbox_items as node_toolbox_item}
+          {#if Array.isArray(manager?.node_toolbox_items_prepped)}
+            {#each manager?.node_toolbox_items_prepped as node_toolbox_item_prepped}
               <!-- aaa|{node_toolbox_item} -->
               <!-- <pre>{JSON.stringify(node_toolbox_item, null, 2)}</pre> -->
-              <Node manager={node_toolbox_item} />
+              <Node manager={node_toolbox_item_prepped?.node_manager} />
             {/each}
           {/if}
         </div>

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

@@ -1,4 +1,4 @@
-import { create_unique_id, deep_copy, node_types, node_categories } from "../../client/index.js"
+import { create_unique_id, deep_copy, node_types, function_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"
@@ -20,46 +20,49 @@ export function create_function_manager(config) {
   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 node_toolbox_items_prepped = $state(null)
+
   let selected_version = $derived(versions?.[selected_version_index])
 
-  function get_node_toolbox_items() {
+  function set_node_toolbox_items_prepped() {
     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),
-            })
-          )
-        }
+    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),
+          }),
+        })
       }
     }
-    return node_toolbox_items_loc
+    console.log("node_toolbox_items_loc", node_toolbox_items_loc)
+    node_toolbox_items_prepped = node_toolbox_items_loc
   }
 
   function get_node_category_buttons() {
@@ -83,10 +86,7 @@ export function create_function_manager(config) {
             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
-            },
+            on_click: () => (selected_category = node_category?.id),
           }),
         })
       }
@@ -151,7 +151,7 @@ export function create_function_manager(config) {
     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]
+    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") {
@@ -214,21 +214,21 @@ export function create_function_manager(config) {
 
   function get_default_node_value(node_type) {
     let default_node = null
-    if (node_type && Object.keys(node_types?.[node_type]?.fields || {}).length > 0) {
+    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(node_types?.[node_type]?.fields)) {
+      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 (node_types?.[node_type]?.kind == "literal") {
+    } else if (function_types?.[node_type]?.kind == "literal") {
       default_node = {
         type: node_type,
-        value: node_types?.[node_type]?.value ?? null,
+        value: function_types?.[node_type]?.value ?? null,
       }
     }
     return default_node
@@ -305,7 +305,7 @@ export function create_function_manager(config) {
       node_value: node_value,
       is_clickable_only: false,
       is_preview: true,
-      node_types,
+      node_types: function_types,
       node_categories,
       c: 12,
       handle_node_drag_start: () =>
@@ -349,10 +349,10 @@ export function create_function_manager(config) {
       }
       let drop_area_node_options = []
       if (drop_area_node_type == "stack_literal") {
-        drop_area_node_options = node_types?.stack_literal?.child_node_options
+        drop_area_node_options = function_types?.stack_literal?.child_node_options
       } else {
         drop_area_node_options =
-          node_types?.[drop_area_node_type]?.fields?.[
+          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
       }
@@ -466,7 +466,7 @@ export function create_function_manager(config) {
       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 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),
@@ -500,7 +500,7 @@ export function create_function_manager(config) {
           ]
           break
         }
-        // let found_node_type = node_types?.[structure?.[input?.defined_function_node_path]?.node_type]?.input
+        // 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,
@@ -1122,7 +1122,7 @@ export function create_function_manager(config) {
     })
     node_category_buttons = get_node_category_buttons()
     set_root_node_prepped()
-    node_toolbox_items = get_node_toolbox_items()
+    set_node_toolbox_items_prepped()
   }
   init(config)
 
@@ -1149,7 +1149,7 @@ export function create_function_manager(config) {
       return console_result
     },
     get node_types() {
-      return node_types
+      return function_types
     },
     get dragging_node() {
       return dragging_node
@@ -1193,15 +1193,15 @@ export function create_function_manager(config) {
     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
     },
+    get node_toolbox_items_prepped() {
+      return node_toolbox_items_prepped
+    },
     update_function,
     undo,
     redo,

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

@@ -214,7 +214,7 @@ export function create_location_manager(config) {
       strokeColor: leg.stroke_color || "oklch(70% 0.3 210)",
       lineWidth: leg.line_width || 3,
     })
-    const poly_line = new mapkit.Poly_lineOverlay(coords, { style: overlay_style })
+    const poly_line = new mapkit.PolylineOverlay(coords, { style: overlay_style })
     map.addOverlay(poly_line)
   }
 

package/dist/Components/LocationInput/index.svelte

@@ -12,7 +12,9 @@
 
   onMount(() => {
     if (!manager?.is_popover) {
+      // setTimeout(() => {
       manager?.initialize_map()
+      // }, 100)
     }
   })
 </script>
@@ -60,9 +62,9 @@
             {#each manager?.suggestions_prepped as suggestion_prepped}
               <div class="search_item_container">
                 <div class="search_item">
-                  <h3>{suggestion_prepped?.display_lines?.[0]}</h3>
-                  {#if suggestion_prepped?.display_lines?.[1]}
-                    <p>{suggestion_prepped?.display_lines?.[1]}</p>
+                  <h3>{suggestion_prepped?.displayLines?.[0]}</h3>
+                  {#if suggestion_prepped?.displayLines?.[1]}
+                    <p>{suggestion_prepped?.displayLines?.[1]}</p>
                   {/if}
                   <!-- {#if Array.isArray(suggestion_prepped?.poi_category) && suggestion_prepped.poi_category.length > 0}
                       <div style="display: flex; flex-wrap: wrap; gap: .5rem;">

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

@@ -586,6 +586,7 @@ export function create_location_input_manager(config) {
   }
 
   function prepare_search_options(is_autocomplete = false) {
+    console.log("prepare_search_options")
     const result_type = Array.isArray(search_filter_result_type_dropdown_manager?.val)
       ? search_filter_result_type_dropdown_manager?.val
       : []
@@ -637,6 +638,7 @@ export function create_location_input_manager(config) {
         )
       )
     }
+    console.log("zzz", options)
     return options
   }
 
@@ -646,6 +648,7 @@ export function create_location_input_manager(config) {
       return
     }
     const autocomplete_search_options = prepare_search_options(true)
+    console.log("autocomplete_search_options", autocomplete_search_options)
     const place_search = new mapkit.Search()
     place_search.autocomplete(
       input,
@@ -657,6 +660,7 @@ export function create_location_input_manager(config) {
         if (result.results.length > 0) {
           let suggestions_prepped_loc = []
           if (Array.isArray(result.results)) {
+            console.log("suggestions_results", result.results)
             for (let suggestion of result.results) {
               let choose_selection_button_manager = $state(null)
               if (suggestion?.id) {
@@ -687,6 +691,7 @@ export function create_location_input_manager(config) {
 
   function search_for(input) {
     const search_options = prepare_search_options()
+    console.log("search_options", search_options)
     map.removeAnnotations(map.annotations)
     const place_search = new mapkit.Search()
     place_search.search(