sveltekit-ui 1.1.74 → 1.1.76

package/dist/Components/StoragePicker/manager.svelte.d.ts

@@ -0,0 +1,48 @@
+export function create_storage_picker_manager(config: any): {
+    id: string;
+    readonly val: null;
+    readonly storage: null;
+    readonly storage_path: any[];
+    readonly default_folder_path: null;
+    readonly display_height: number;
+    readonly locally_uploaded_files: null;
+    readonly is_show_content: any;
+    readonly is_multiselect: any;
+    readonly is_disabled: any;
+    readonly is_read_only: any;
+    readonly error_message: null;
+    readonly storage_origins: null;
+    readonly mt: number;
+    readonly mb: number;
+    readonly breadcrumbs_manager: null;
+    readonly popover_manager: null;
+    readonly file_input_manager: null;
+    readonly select_file_from_storage_button_manager: null;
+    readonly folders_prepped: null;
+    readonly clear_button_manager: null;
+    readonly finish_multiselect_button_manager: null;
+    readonly acceptable_mime_types: any[] | null;
+    readonly ordered_items: {
+        folder_ids: any[];
+        storage_ids: any[];
+        locally_uploaded_files_ids: any[];
+    };
+    readonly is_file_chosen: boolean;
+    readonly locally_uploaded_files_prepped: any[];
+    readonly storage_files_prepped: any[];
+    readonly is_show_button: any;
+    readonly display_file: null;
+    readonly file_icon_manager: null;
+    init: (config: any) => void;
+    get_ordered_items: (storage: any, locally_uploaded_files: any, storage_path: any, acceptable_mime_types: any) => {
+        folder_ids: any[];
+        storage_ids: any[];
+        locally_uploaded_files_ids: any[];
+    };
+    select_file: (storage_item: any, loading_id: any) => Promise<void>;
+    clear: (is_call_finish?: boolean) => void;
+    set_files_prepped: () => void;
+    open_popover: () => void;
+    set_val: (input: any) => Promise<void>;
+    on_destroy: () => void;
+};

package/dist/Components/StoragePicker/{index.svelte.js → manager.svelte.js}

@@ -5,13 +5,13 @@ import {
   clean_custom_identifier,
   mime_type_extensions,
 } from "../../client/index.js"
-import { create_button_manager } from "../Button/index.svelte.js"
-import { create_popover_manager } from "../Popover/index.svelte.js"
-import { create_audio_manager } from "../Audio/index.svelte.js"
-import { create_image_manager } from "../Image/index.svelte.js"
-import { create_breadcrumbs_manager } from "../Breadcrumbs/index.svelte.js"
-import { create_file_input_manager } from "../FileInput/index.svelte.js"
-import { create_icon_manager } from "../Icon/index.svelte.js"
+import { create_button_manager } from "../Button/manager.svelte.js"
+import { create_popover_manager } from "../Popover/manager.svelte.js"
+import { create_audio_manager } from "../Audio/manager.svelte.js"
+import { create_image_manager } from "../Image/manager.svelte.js"
+import { create_breadcrumbs_manager } from "../Breadcrumbs/manager.svelte.js"
+import { create_file_input_manager } from "../FileInput/manager.svelte.js"
+import { create_icon_manager } from "../Icon/manager.svelte.js"
 
 export function create_storage_picker_manager(config) {
   const id = create_unique_id(null, 20)
@@ -37,14 +37,56 @@ export function create_storage_picker_manager(config) {
   let finish_multiselect_button_manager = $state(null)
   let display_file = $state(null)
   let file_icon_manager = $state(null)
+  let error_message = $state(null)
 
   let is_show_content = $derived(set_closurable(config?.is_show_content, true))
   let is_multiselect = $derived(set_closurable(config?.is_multiselect, false))
-  let is_disabled = $derived(set_closurable(config?.is_disabled, false))
+  let is_read_only = $derived(set_closurable(config?.is_read_only, false))
+  let is_disabled = $derived(set_closurable(config?.is_disabled, false) || is_read_only)
+  let is_show_button = $derived(set_closurable(config?.is_show_button, true))
   let storage_src = $derived(
     set_closurable(config?.storage_src, "https://www.contibase.com/api/v1/storage/{storage_id}")
   )
   let select_file_loading_id = $state(null)
+  let is_destroyed = false
+  let operation_version = 0
+  let active_abort_controller = null
+  const persistent_object_urls = new Set()
+  const display_object_urls = new Set()
+
+  function create_owned_object_url(file, collection) {
+    const object_url = URL.createObjectURL(file)
+    collection.add(object_url)
+    return object_url
+  }
+
+  function revoke_object_urls(collection) {
+    for (const object_url of collection) {
+      URL.revokeObjectURL(object_url)
+    }
+    collection.clear()
+  }
+
+  function revoke_owned_object_url(object_url, collection) {
+    if (!object_url || !collection.has(object_url)) return
+    URL.revokeObjectURL(object_url)
+    collection.delete(object_url)
+  }
+
+  function cancel_pending_operation() {
+    operation_version++
+    active_abort_controller?.abort()
+    active_abort_controller = null
+    select_file_loading_id = null
+  }
+
+  function on_destroy() {
+    if (is_destroyed) return
+    is_destroyed = true
+    cancel_pending_operation()
+    revoke_object_urls(display_object_urls)
+    revoke_object_urls(persistent_object_urls)
+  }
 
   function get_src(src, storage_id) {
     if (src) {
@@ -56,31 +98,35 @@ export function create_storage_picker_manager(config) {
     }
   }
 
-  async function set_display_file() {
+  function set_display_file() {
+    revoke_object_urls(display_object_urls)
     if (Array.isArray(val)) {
       let display_files = []
       for (let item of val) {
-        const display_file_res = await set_display_single_file(item)
+        const display_file_res = set_display_single_file(item)
         display_files.push(display_file_res)
       }
       display_file = display_files
       return
     }
-    const display_file_res = await set_display_single_file(val)
+    const display_file_res = set_display_single_file(val)
     display_file = display_file_res
   }
 
-  async function set_display_single_file(input) {
+  function set_display_single_file(input) {
     let display_file_loc = null
     if (input?.file) {
       display_file_loc = {
-        mime_type: input?.file?.type,
-        src: URL.createObjectURL(input?.file),
+        ...input,
+        mime_type: input?.file?.type || input?.mime_type,
+        src: input?.src ?? create_owned_object_url(input.file, display_object_urls),
+        file_icon_manager,
       }
     } else if (input?.id) {
       display_file_loc = {
         ...input,
         src: get_src(input?.src, input?.id),
+        file_icon_manager,
       }
     }
     if (display_file_loc?.mime_type == "audio/mpeg") {
@@ -90,7 +136,7 @@ export function create_storage_picker_manager(config) {
         image_src: display_file_loc?.image_src,
         image_type: display_file_loc?.image_type,
       })
-    } else if (["image/webp", "image/jpeg", "image/png", "image/gif"].includes(display_file_loc?.mime_type)) {
+    } else if (["image/webp", "image/jpeg", "image/png", "image/gif", "image/svg+xml"].includes(display_file_loc?.mime_type)) {
       display_file_loc.manager = create_image_manager({
         src: display_file_loc?.src,
         display_max_height: 200,
@@ -102,7 +148,10 @@ export function create_storage_picker_manager(config) {
     return display_file_loc
   }
 
-  let acceptable_mime_types = $derived(Array.isArray(config?.accept) ? config?.accept : null)
+  let acceptable_mime_types = $derived.by(() => {
+    const accept = set_closurable(config?.accept, null)
+    return Array.isArray(accept) ? accept : null
+  })
   let ordered_items = $derived(get_ordered_items(storage, locally_uploaded_files, storage_path, acceptable_mime_types))
   let is_file_chosen = $derived((Array.isArray(val) && val.length > 0) || !!val?.file || !!val?.file_name)
 
@@ -167,78 +216,107 @@ export function create_storage_picker_manager(config) {
     })
   }
 
-  async function fetch_and_convert_to_base64(storage_id, file_name, mime_type) {
-    try {
-      let storage_src_loc = storage_src.replace("{storage_id}", storage_id)
-      console.log("storage_src_loc", storage_src_loc)
-      const response = await fetch(storage_src_loc)
-      if (!response.ok) {
-        throw new Error(`Failed to fetch file from storage. Status: ${response.status}`)
-      }
-      const blob = await response.blob()
-      const file = new File([blob], file_name, { type: mime_type })
-      const base64_content = await convert_file_to_base64(file)
-      return base64_content
-    } catch (error) {
-      console.error("Error fetching or converting file to Base64:", error)
-      return null
+  async function fetch_and_convert_to_base64(storage_id, file_name, mime_type, signal) {
+    if (!storage_id) throw new Error("Storage file is missing an id.")
+    let storage_src_loc = storage_src.replace("{storage_id}", storage_id)
+    const response = await fetch(storage_src_loc, { signal })
+    if (!response.ok) {
+      throw new Error(`Failed to fetch file from storage. Status: ${response.status}`)
+    }
+    const blob = await response.blob()
+    const file = new File([blob], file_name || "file", { type: mime_type || blob.type })
+    return await convert_file_to_base64(file)
+  }
+
+  async function prepare_storage_item(storage_item, signal) {
+    if (!storage_item || typeof storage_item !== "object") {
+      throw new Error("No file was provided.")
     }
+    const prepared_item = { ...storage_item }
+    if (prepared_item.file) {
+      prepared_item.base64_content = await convert_file_to_base64(prepared_item.file)
+    } else if (prepared_item.id) {
+      prepared_item.base64_content = await fetch_and_convert_to_base64(
+        prepared_item.id,
+        prepared_item.file_name,
+        prepared_item.mime_type,
+        signal
+      )
+    }
+    return prepared_item
   }
 
   async function select_file(storage_item, loading_id) {
+    if (is_disabled || is_destroyed || select_file_loading_id) return
     if (!loading_id) {
       loading_id = create_unique_id(null, 20)
     }
+    const current_operation = ++operation_version
+    active_abort_controller = typeof AbortController === "undefined" ? null : new AbortController()
     select_file_loading_id = loading_id
-    if (is_multiselect) {
-      const existing_index = Array.isArray(val) ? val.findIndex((h) => h?.id == storage_item?.id) : -1
-      if (existing_index > -1) {
-        val = val.filter((h) => h?.id != storage_item?.id)
-      } else {
-        if (storage_item?.file) {
-          storage_item.base64_content = await convert_file_to_base64(storage_item?.file)
+    error_message = null
+    try {
+      if (is_multiselect) {
+        const existing_index = Array.isArray(val) ? val.findIndex((h) => h?.id == storage_item?.id) : -1
+        if (existing_index > -1) {
+          val = val.filter((h) => h?.id != storage_item?.id)
         } else {
-          storage_item.base64_content = await fetch_and_convert_to_base64(
-            storage_item?.id,
-            storage_item?.file_name,
-            storage_item?.mime_type
-          )
+          const prepared_item = await prepare_storage_item(storage_item, active_abort_controller?.signal)
+          if (is_destroyed || current_operation !== operation_version) return
+          val = [...(Array.isArray(val) ? val : []), prepared_item]
         }
-        val = [...(Array.isArray(val) ? val : []), storage_item]
-      }
-    } else {
-      if (storage_item?.file) {
-        storage_item.base64_content = await convert_file_to_base64(storage_item?.file)
       } else {
-        storage_item.base64_content = await fetch_and_convert_to_base64(
-          storage_item?.id,
-          storage_item?.file_name,
-          storage_item?.mime_type
-        )
+        const prepared_item = await prepare_storage_item(storage_item, active_abort_controller?.signal)
+        if (is_destroyed || current_operation !== operation_version) return
+        val = prepared_item
+        if (typeof config?.on_finish == "function") {
+          await config.on_finish(val)
+        }
+        if (is_destroyed || current_operation !== operation_version) return
+        popover_manager?.close()
+      }
+      set_display_file()
+    } catch (error) {
+      if (!is_destroyed && error?.name !== "AbortError") {
+        error_message = error?.message ?? "Unable to select file."
       }
-      val = storage_item
-      if (typeof config?.on_finish == "function") {
-        config?.on_finish(val)
+    } finally {
+      if (current_operation === operation_version) {
+        select_file_loading_id = null
+        active_abort_controller = null
       }
-      popover_manager?.close()
     }
-    set_display_file()
-    select_file_loading_id = null
   }
 
   async function set_val(input) {
-    if (input && typeof input == "object" && !Array.isArray(input)) {
-      if (input?.file) {
-        input.base64_content = await convert_file_to_base64(input?.file)
-      } else {
-        input.base64_content = await fetch_and_convert_to_base64(input?.id, input?.file_name, input?.mime_type)
+    cancel_pending_operation()
+    const current_operation = operation_version
+    active_abort_controller = typeof AbortController === "undefined" ? null : new AbortController()
+    error_message = null
+    try {
+      let next_val = input
+      if (Array.isArray(input)) {
+        next_val = await Promise.all(
+          input.map((item) => prepare_storage_item(item, active_abort_controller?.signal))
+        )
+      } else if (input && typeof input == "object") {
+        next_val = await prepare_storage_item(input, active_abort_controller?.signal)
+      }
+      if (is_destroyed || current_operation !== operation_version) return
+      val = next_val
+      set_display_file()
+    } catch (error) {
+      if (!is_destroyed && error?.name !== "AbortError") {
+        error_message = error?.message ?? "Unable to set file."
       }
+    } finally {
+      if (current_operation === operation_version) active_abort_controller = null
     }
-    val = input
-    set_display_file()
   }
 
   function clear(is_call_finish = true) {
+    cancel_pending_operation()
+    error_message = null
     val = null
     if (is_call_finish && typeof config?.on_finish == "function") {
       config?.on_finish(val)
@@ -258,6 +336,7 @@ export function create_storage_picker_manager(config) {
         const loading_id = create_unique_id(null, 20)
         let locally_uploaded_file_prepped = {
           ...locally_uploaded_file,
+          file_icon_manager,
           select_button_manager: create_button_manager({
             text: () =>
               Array.isArray(val) && val.some((h) => h?.id == locally_uploaded_file?.id)
@@ -266,7 +345,7 @@ export function create_storage_picker_manager(config) {
             selected_type: () =>
               Array.isArray(val) && val.some((h) => h?.id == locally_uploaded_file?.id) ? "selected" : null,
             is_loading: () => select_file_loading_id == loading_id,
-            is_disabled: () => select_file_loading_id && select_file_loading_id != loading_id,
+            is_disabled: () => is_disabled || !!select_file_loading_id,
             mt: 1,
             on_click: () => select_file(locally_uploaded_file, loading_id),
           }),
@@ -278,7 +357,9 @@ export function create_storage_picker_manager(config) {
             type: "audio/mpeg",
           })
         } else if (
-          ["image/webp", "image/jpeg", "image/png", "image/gif"].includes(locally_uploaded_file_prepped?.mime_type)
+          ["image/webp", "image/jpeg", "image/png", "image/gif", "image/svg+xml"].includes(
+            locally_uploaded_file_prepped?.mime_type
+          )
         ) {
           locally_uploaded_file_prepped.manager = create_image_manager({
             src: get_src(locally_uploaded_file?.src, locally_uploaded_file?.id),
@@ -315,6 +396,7 @@ export function create_storage_picker_manager(config) {
               icon_pos: "left",
               text_align: "left",
               text: folder_id,
+              is_disabled: () => is_disabled,
               on_click: () => {
                 storage_path = deep_copy([...storage_path, folder_id])
                 set_files_prepped()
@@ -332,12 +414,13 @@ export function create_storage_picker_manager(config) {
           let storage_file_prepped_loc = {
             ...storage_item,
             src: src,
+            file_icon_manager,
             select_button_manager: create_button_manager({
               text: () =>
                 Array.isArray(val) && val.some((h) => h?.id == storage_id) ? "Deselect File" : "Select File",
               selected_type: () => (Array.isArray(val) && val.some((h) => h?.id == storage_id) ? "selected" : null),
               is_loading: () => select_file_loading_id == loading_id,
-              is_disabled: () => select_file_loading_id && select_file_loading_id != loading_id,
+              is_disabled: () => is_disabled || !!select_file_loading_id,
               mt: 1,
               on_click: () => select_file(storage?.[storage_id], loading_id),
             }),
@@ -348,7 +431,9 @@ export function create_storage_picker_manager(config) {
               src: src,
               type: "audio/mpeg",
             })
-          } else if (["image/webp", "image/jpeg", "image/png", "image/gif"].includes(storage_item?.mime_type)) {
+          } else if (
+            ["image/webp", "image/jpeg", "image/png", "image/gif", "image/svg+xml"].includes(storage_item?.mime_type)
+          ) {
             storage_file_prepped_loc.manager = create_image_manager({
               src: src,
               display_max_height: 200,
@@ -365,26 +450,74 @@ export function create_storage_picker_manager(config) {
   }
 
   function open_popover() {
+    if (is_disabled) return
+    set_files_prepped()
     popover_manager.open()
   }
 
+  function normalize_file_collection(input) {
+    const value = set_closurable(input, null)
+    if (!Array.isArray(value)) return value
+    return value.reduce((acc, item) => {
+      if (item?.id) acc[item.id] = item
+      return acc
+    }, {})
+  }
+
+  async function add_locally_uploaded_files(input) {
+    if (is_disabled || is_destroyed) return
+    error_message = null
+    const files = (Array.isArray(input) ? input : [input]).filter(Boolean)
+    const locally_uploaded_files_to_add = {}
+    const created_urls = []
+    try {
+      for (const file of files) {
+        const id = create_unique_id(null, 20)
+        const base64_content = await convert_file_to_base64(file)
+        if (is_destroyed) return
+        const src = create_owned_object_url(file, persistent_object_urls)
+        created_urls.push(src)
+        locally_uploaded_files_to_add[id] = {
+          id,
+          file,
+          src,
+          file_name: clean_custom_identifier(String(file?.name ?? "").replace(/\..+$/, "")),
+          mime_type: file?.type,
+          file_extension: mime_type_extensions?.[file?.type],
+          size_kb: file?.size ? Math.round(file.size * 0.001) : null,
+          base64_content,
+        }
+      }
+      locally_uploaded_files = {
+        ...(locally_uploaded_files && typeof locally_uploaded_files == "object" && !Array.isArray(locally_uploaded_files)
+          ? locally_uploaded_files
+          : {}),
+        ...locally_uploaded_files_to_add,
+      }
+      set_locally_uploaded_files_prepped()
+    } catch (error) {
+      for (const object_url of created_urls) {
+        revoke_owned_object_url(object_url, persistent_object_urls)
+      }
+      if (!is_destroyed) error_message = error?.message ?? "Unable to add uploaded file."
+    } finally {
+      if (!is_destroyed) file_input_manager?.clear_files()
+    }
+  }
+
   function init(config) {
-    storage =
-      config?.storage && Array.isArray(config?.storage)
-        ? config?.storage.reduce((acc, item) => {
-            acc[item.id] = item
-            return acc
-          }, {})
-        : config?.storage
-    locally_uploaded_files =
-      config?.locally_uploaded_files && Array.isArray(config?.locally_uploaded_files)
-        ? config?.locally_uploaded_files.reduce((acc, item) => {
-            acc[item?.id] = item
-            return acc
-          }, {})
-        : config?.locally_uploaded_files
-    storage_path = Array.isArray(config?.default_folder_path) ? config?.default_folder_path : []
-    storage_origins = config?.storage_origins ?? ["locally_uploaded_files", "storage"]
+    storage = normalize_file_collection(config?.storage)
+    locally_uploaded_files = normalize_file_collection(config?.locally_uploaded_files)
+    const configured_default_folder_path = set_closurable(config?.default_folder_path, null)
+    default_folder_path = Array.isArray(configured_default_folder_path) ? deep_copy(configured_default_folder_path) : []
+    storage_path = Array.isArray(configured_default_folder_path) ? deep_copy(configured_default_folder_path) : []
+    const configured_storage_origins = set_closurable(config?.storage_origins, null)
+    storage_origins = Array.isArray(configured_storage_origins)
+      ? configured_storage_origins
+      : ["locally_uploaded_files", "storage"]
+    display_height = Number(set_closurable(config?.display_height, 20)) || 20
+    mt = Number(set_closurable(config?.mt, 0)) || 0
+    mb = Number(set_closurable(config?.mb, 0)) || 0
     popover_manager = create_popover_manager({
       min_width: 320,
       target_width: 900,
@@ -401,60 +534,16 @@ export function create_storage_picker_manager(config) {
       is_loading: () => select_file_loading_id,
       mb: 1,
       is_disabled: () => is_disabled,
+      on_click: () => set_files_prepped(),
       popover_target: () => `popover_${popover_manager?.id}`,
     })
     file_input_manager = create_file_input_manager({
-      accept: acceptable_mime_types,
+      accept: () => acceptable_mime_types,
       is_multiselect: true,
       is_drop_zone: true,
-      is_disabled: () => is_disabled,
-      on_get_file: async (input) => {
-        console.log("on_get_file", input)
-        let locally_uploaded_files_to_add = {}
-        if (Array.isArray(input)) {
-          for (let file of input) {
-            console.log("item", file)
-            const id = create_unique_id(null, 20)
-            let file_obj = {
-              id: id,
-              file: file,
-              src: file ? URL.createObjectURL(file) : null,
-              file_name: clean_custom_identifier(file?.name.replace(/\..+$/, "")),
-              mime_type: file?.type,
-              file_extension: mime_type_extensions?.[file?.type],
-              size_kb: file?.size ? Math.round(file?.size * 0.001) : null,
-            }
-            const base64_content = await convert_file_to_base64(file)
-            file_obj.base64_content = base64_content
-            locally_uploaded_files_to_add[id] = file_obj
-          }
-        } else {
-          const id = create_unique_id(null, 20)
-          let file_obj = {
-            id: id,
-            file: input,
-            src: input ? URL.createObjectURL(input) : null,
-            file_name: clean_custom_identifier(input?.name.replace(/\..+$/, "")),
-            mime_type: input?.type,
-            file_extension: mime_type_extensions?.[input?.type],
-            size_kb: input?.size ? Math.round(input?.size * 0.001) : null,
-          }
-          const base64_content = await convert_file_to_base64(input)
-          file_obj.base64_content = base64_content
-          locally_uploaded_files_to_add[id] = file_obj
-        }
-        locally_uploaded_files = {
-          ...(locally_uploaded_files &&
-          typeof locally_uploaded_files == "object" &&
-          !Array.isArray(locally_uploaded_files)
-            ? locally_uploaded_files
-            : {}),
-          ...locally_uploaded_files_to_add,
-        }
-        set_locally_uploaded_files_prepped()
-        set_display_file()
-        file_input_manager.clear_files()
-      },
+      is_disabled: () => is_disabled || !!select_file_loading_id,
+      is_read_only: () => is_read_only,
+      on_get_file: (input) => void add_locally_uploaded_files(input),
     })
     clear_button_manager = create_button_manager({
       type: "outlined",
@@ -479,7 +568,6 @@ export function create_storage_picker_manager(config) {
         }`,
       is_disabled: () => is_disabled || (Array.isArray(val) && val.length < 1),
       on_click: () => {
-        console.log("val_fin", deep_copy(val))
         set_display_file()
         if (typeof config?.on_finish == "function") {
           config?.on_finish(val)
@@ -494,6 +582,7 @@ export function create_storage_picker_manager(config) {
       color: "var(--g6-t)",
     })
     set_files_prepped()
+    void set_val(set_closurable(config?.val, null))
   }
 
   init(config)
@@ -527,6 +616,12 @@ export function create_storage_picker_manager(config) {
     get is_disabled() {
       return is_disabled
     },
+    get is_read_only() {
+      return is_read_only
+    },
+    get error_message() {
+      return error_message
+    },
     get storage_origins() {
       return storage_origins
     },
@@ -573,7 +668,7 @@ export function create_storage_picker_manager(config) {
       return storage_files_prepped
     },
     get is_show_button() {
-      return config?.is_show_button ?? true
+      return is_show_button
     },
     get display_file() {
       return display_file
@@ -588,5 +683,6 @@ export function create_storage_picker_manager(config) {
     set_files_prepped,
     open_popover,
     set_val,
+    on_destroy,
   }
 }

package/dist/Components/SuccessCheck/index.svelte

@@ -11,6 +11,8 @@
     fill="none"
     stroke-linecap="round"
     stroke-linejoin="round"
+    aria-hidden="true"
+    focusable="false"
   >
     <circle class="checkmark_circle" cx="256" cy="256" r="196.16" />
     <path class="checkmark_check" d="m162.63 265.42 55.71 56.49 131-131.82" />

package/dist/Components/SuccessCheck/index.svelte.d.ts

@@ -0,0 +1,15 @@
+export default Index;
+type Index = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const Index: import("svelte").Component<{
+    is_show?: boolean;
+    color?: string;
+    sw?: number;
+}, {}, "">;
+type $$ComponentProps = {
+    is_show?: boolean;
+    color?: string;
+    sw?: number;
+};

package/dist/Components/TableAdvanced/ColumnInput/index.svelte.d.ts

@@ -0,0 +1,11 @@
+export default Index;
+type Index = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const Index: import("svelte").Component<{
+    manager: any;
+}, {}, "">;
+type $$ComponentProps = {
+    manager: any;
+};