@take-out/helpers 0.0.31 → 0.0.33

package/types/storage/createStorage.d.ts

@@ -0,0 +1,65 @@
+/**
+* namespaced storage interface with JSON serialization
+* @template K - key type (string literal union for type-safe keys)
+* @template V - value type (automatically JSON serialized/deserialized)
+*/
+export interface Storage<
+	K extends string = string,
+	V = unknown
+> {
+	/** get a JSON-parsed value by key */
+	get(key: K): V | undefined;
+	/** set a value (JSON serialized) */
+	set(key: K, value: V): void;
+	/** remove a key */
+	remove(key: K): void;
+	/** check if key exists */
+	has(key: K): boolean;
+	/** get all keys in this namespace */
+	keys(): K[];
+	/** remove all keys in this namespace */
+	clear(): void;
+	/** get raw string value (no JSON parsing) - localStorage compatible */
+	getItem(key: K): string | null;
+	/** set raw string value (no JSON serialization) - localStorage compatible */
+	setItem(key: K, value: string): void;
+}
+/**
+* create a namespaced storage instance
+* @param namespace - unique prefix for all keys (throws if already used)
+* @returns storage instance with get/set (JSON) and getItem/setItem (raw) methods
+* @example
+* const store = createStorage<'token' | 'user', string>('auth')
+* store.set('token', 'abc123')
+* store.get('token') // 'abc123'
+*/
+export declare function createStorage<
+	K extends string,
+	V
+>(namespace: string): Storage<K, V>;
+/**
+* single-value storage interface
+* @template T - value type (automatically JSON serialized/deserialized)
+*/
+export interface StorageValue<T> {
+	/** get the stored value */
+	get(): T | undefined;
+	/** set the value */
+	set(value: T): void;
+	/** remove the value */
+	remove(): void;
+	/** check if value exists */
+	has(): boolean;
+}
+/**
+* create a single-value storage (wrapper around createStorage)
+* @param key - unique storage key
+* @returns storage value instance
+* @example
+* const token = createStorageValue<string>('auth-token')
+* token.set('abc123')
+* token.get() // 'abc123'
+*/
+export declare function createStorageValue<T>(key: string): StorageValue<T>;
+
+//# sourceMappingURL=createStorage.d.ts.map

package/types/storage/createStorage.d.ts.map

@@ -0,0 +1,18 @@
+{
+  "mappings": ";;;;;AASA,iBAAiB;CAAQ;CAA2B;EAAa;;CAE/D,IAAIA,KAAK,IAAI;;CAEb,IAAIA,KAAK,GAAGC,OAAO;;CAEnB,OAAOD,KAAK;;CAEZ,IAAIA,KAAK;;CAET,QAAQ;;CAER;;CAEA,QAAQA,KAAK;;CAEb,QAAQA,KAAK,GAAGE;AACjB;;;;;;;;;;AAWD,OAAO,iBAAS;CAAc;CAAkB;EAAGC,oBAAoB,QAAQ,GAAG;;;;;AA2ElF,iBAAiB,aAAa,GAAG;;CAE/B,OAAO;;CAEP,IAAIC,OAAO;;CAEX;;CAEA;AACD;;;;;;;;;;AAWD,OAAO,iBAAS,mBAAmB,GAAGC,cAAc,aAAa",
+  "names": [
+    "key: K",
+    "value: V",
+    "value: string",
+    "namespace: string",
+    "value: T",
+    "key: string"
+  ],
+  "sources": [
+    "src/storage/createStorage.ts"
+  ],
+  "sourcesContent": [
+    "import { getStorageDriver } from './driver'\n\nconst namespaces = new Set<string>()\n\n/**\n * namespaced storage interface with JSON serialization\n * @template K - key type (string literal union for type-safe keys)\n * @template V - value type (automatically JSON serialized/deserialized)\n */\nexport interface Storage<K extends string = string, V = unknown> {\n  /** get a JSON-parsed value by key */\n  get(key: K): V | undefined\n  /** set a value (JSON serialized) */\n  set(key: K, value: V): void\n  /** remove a key */\n  remove(key: K): void\n  /** check if key exists */\n  has(key: K): boolean\n  /** get all keys in this namespace */\n  keys(): K[]\n  /** remove all keys in this namespace */\n  clear(): void\n  /** get raw string value (no JSON parsing) - localStorage compatible */\n  getItem(key: K): string | null\n  /** set raw string value (no JSON serialization) - localStorage compatible */\n  setItem(key: K, value: string): void\n}\n\n/**\n * create a namespaced storage instance\n * @param namespace - unique prefix for all keys (throws if already used)\n * @returns storage instance with get/set (JSON) and getItem/setItem (raw) methods\n * @example\n * const store = createStorage<'token' | 'user', string>('auth')\n * store.set('token', 'abc123')\n * store.get('token') // 'abc123'\n */\nexport function createStorage<K extends string, V>(namespace: string): Storage<K, V> {\n  if (namespaces.has(namespace)) {\n    throw new Error(`storage namespace already exists: ${namespace}`)\n  }\n  namespaces.add(namespace)\n\n  const prefix = `${namespace}:`\n  const prefixKey = (key: string) => `${prefix}${key}`\n\n  return {\n    get(key: K): V | undefined {\n      const driver = getStorageDriver()\n      if (!driver) return undefined\n      const raw = driver.getItem(prefixKey(key))\n      if (raw == null) return undefined\n      try {\n        return JSON.parse(raw)\n      } catch {\n        return undefined\n      }\n    },\n\n    set(key: K, value: V): void {\n      const driver = getStorageDriver()\n      if (!driver) return\n      driver.setItem(prefixKey(key), JSON.stringify(value))\n    },\n\n    remove(key: K): void {\n      const driver = getStorageDriver()\n      if (!driver) return\n      driver.removeItem(prefixKey(key))\n    },\n\n    has(key: K): boolean {\n      const driver = getStorageDriver()\n      if (!driver) return false\n      return driver.getItem(prefixKey(key)) != null\n    },\n\n    keys(): K[] {\n      const driver = getStorageDriver()\n      if (!driver) return []\n      return driver\n        .getAllKeys()\n        .filter((k) => k.startsWith(prefix))\n        .map((k) => k.slice(prefix.length) as K)\n    },\n\n    clear(): void {\n      const driver = getStorageDriver()\n      if (!driver) return\n      for (const key of this.keys()) {\n        driver.removeItem(prefixKey(key))\n      }\n    },\n\n    getItem(key: K): string | null {\n      const driver = getStorageDriver()\n      if (!driver) return null\n      return driver.getItem(prefixKey(key)) ?? null\n    },\n\n    setItem(key: K, value: string): void {\n      const driver = getStorageDriver()\n      if (!driver) return\n      driver.setItem(prefixKey(key), value)\n    },\n  }\n}\n\n/**\n * single-value storage interface\n * @template T - value type (automatically JSON serialized/deserialized)\n */\nexport interface StorageValue<T> {\n  /** get the stored value */\n  get(): T | undefined\n  /** set the value */\n  set(value: T): void\n  /** remove the value */\n  remove(): void\n  /** check if value exists */\n  has(): boolean\n}\n\n/**\n * create a single-value storage (wrapper around createStorage)\n * @param key - unique storage key\n * @returns storage value instance\n * @example\n * const token = createStorageValue<string>('auth-token')\n * token.set('abc123')\n * token.get() // 'abc123'\n */\nexport function createStorageValue<T>(key: string): StorageValue<T> {\n  const storage = createStorage<'value', T>(`_v:${key}`)\n  return {\n    get: (): T | undefined => storage.get('value'),\n    set: (value: T): void => storage.set('value', value),\n    remove: (): void => storage.remove('value'),\n    has: (): boolean => storage.has('value'),\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/storage/driver.d.ts

@@ -0,0 +1,5 @@
+import type { StorageDriver } from "./types";
+export declare function setStorageDriver(d: StorageDriver): void;
+export declare function getStorageDriver(): StorageDriver | null;
+
+//# sourceMappingURL=driver.d.ts.map

package/types/storage/driver.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAAA,cAAc,qBAAqB,SAAS;AAI5C,OAAO,iBAAS,iBAAiBA,GAAG;AAIpC,OAAO,iBAAS,oBAAoB",
+  "names": [
+    "d: StorageDriver"
+  ],
+  "sources": [
+    "src/storage/driver.ts"
+  ],
+  "sourcesContent": [
+    "import type { StorageDriver } from './types'\n\nlet driver: StorageDriver | null = null\n\nexport function setStorageDriver(d: StorageDriver): void {\n  driver = d\n}\n\nexport function getStorageDriver(): StorageDriver | null {\n  if (driver) return driver\n  if (typeof localStorage !== 'undefined') {\n    return {\n      getItem: (key) => localStorage.getItem(key),\n      setItem: (key, value) => localStorage.setItem(key, value),\n      removeItem: (key) => localStorage.removeItem(key),\n      getAllKeys: () => Object.keys(localStorage),\n    }\n  }\n  return null\n}\n"
+  ],
+  "version": 3
+}

package/types/storage/index.d.ts

@@ -0,0 +1,6 @@
+export { createStorage, createStorageValue } from "./createStorage";
+export type { Storage, StorageValue } from "./createStorage";
+export { getStorageDriver, setStorageDriver } from "./driver";
+export type { StorageDriver } from "./types";
+
+//# sourceMappingURL=index.d.ts.map

package/types/storage/index.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,SAAS,eAAe,0BAA0B;AAClD,cAAc,SAAS,oBAAoB;AAC3C,SAAS,kBAAkB,wBAAwB;AACnD,cAAc,qBAAqB",
+  "names": [],
+  "sources": [
+    "src/storage/index.ts"
+  ],
+  "sourcesContent": [
+    "export { createStorage, createStorageValue } from './createStorage'\nexport type { Storage, StorageValue } from './createStorage'\nexport { getStorageDriver, setStorageDriver } from './driver'\nexport type { StorageDriver } from './types'\n"
+  ],
+  "version": 3
+}

package/types/storage/types.d.ts

@@ -0,0 +1,8 @@
+export interface StorageDriver {
+	getItem(key: string): string | null | undefined;
+	setItem(key: string, value: string): void;
+	removeItem(key: string): void;
+	getAllKeys(): string[];
+}
+
+//# sourceMappingURL=types.d.ts.map

package/types/storage/types.d.ts.map

@@ -0,0 +1,14 @@
+{
+  "mappings": "AAAA,iBAAiB,cAAc;CAC7B,QAAQA;CACR,QAAQA,aAAaC;CACrB,WAAWD;CACX;AACD",
+  "names": [
+    "key: string",
+    "value: string"
+  ],
+  "sources": [
+    "src/storage/types.ts"
+  ],
+  "sourcesContent": [
+    "export interface StorageDriver {\n  getItem(key: string): string | null | undefined\n  setItem(key: string, value: string): void\n  removeItem(key: string): void\n  getAllKeys(): string[]\n}\n"
+  ],
+  "version": 3
+}

package/src/array/fuzzy.ts

@@ -1,39 +0,0 @@
-import Fuse, { type FuseSearchOptions, type IFuseOptions } from 'fuse.js'
-
-export type FuzzyOptions = IFuseOptions<unknown>
-
-// fuse does some insane staleness in getFn that doesn't make sense so pulled it all the way out here
-let lastSearch = ''
-
-export function createFuzzy<
-  A extends Record<string, any>,
-  Results extends A[] | readonly A[],
->(
-  items: Results,
-  options?: IFuseOptions<A>
-): {
-  search: (val: string, options?: FuseSearchOptions) => Results
-} {
-  const fuse = new Fuse(items, {
-    isCaseSensitive: false,
-    threshold: 0.5,
-    ...options,
-    getFn(obj, path, ...rest) {
-      if (obj.skipFuzzy) {
-        return lastSearch
-      }
-      return Fuse.config.getFn(obj, path)
-    },
-  })
-
-  return {
-    search: (val: string, options?: FuseSearchOptions): Results => {
-      if (!val) {
-        return items
-      }
-      lastSearch = val
-      const results = fuse.search(val, options).map((result) => result.item)
-      return results as Results
-    },
-  }
-}

package/src/browser/localStorage.ts

@@ -1,311 +0,0 @@
-const created = new Set<string>()
-
-const STORAGE_TRACKING_KEY = '__localStorage_tracking__'
-const STORAGE_ORDER_KEY = '__localStorage_order__'
-
-interface StorageTracking {
-  [key: string]: number // key -> size in bytes
-}
-
-interface LocalStorageOptions {
-  synced?: boolean
-  disableSetOnBlur?: boolean
-
-  /**
-   * Limit in kB
-   */
-  storageLimit?: number
-}
-
-export function createLocalStorage<K extends string, V>(
-  name: string,
-  { synced = false, disableSetOnBlur = false, storageLimit }: LocalStorageOptions = {}
-) {
-  if (created.has(name)) {
-    throw new Error(`Already defined this localStorage namespace: ${name}`)
-  }
-  created.add(name)
-
-  let isWindowActive = true
-  if (typeof window !== 'undefined' && disableSetOnBlur) {
-    const handleFocus = () => {
-      isWindowActive = true
-    }
-    const handleBlur = () => {
-      isWindowActive = false
-    }
-
-    window.addEventListener('focus', handleFocus)
-    window.addEventListener('blur', handleBlur)
-
-    isWindowActive = document.hasFocus()
-  }
-
-  const listeners = new Map<string, Set<(value: any) => void>>()
-
-  if (synced && typeof window !== 'undefined') {
-    const handleStorageChange = (event: StorageEvent) => {
-      if (event.key?.startsWith(`${name}:`) && event.storageArea === localStorage) {
-        const key = event.key.slice(name.length + 1)
-        const newValue = event.newValue ? JSON.parse(event.newValue) : undefined
-        const keyListeners = listeners.get(key)
-        if (keyListeners) {
-          keyListeners.forEach((listener) => listener(newValue))
-        }
-      }
-    }
-
-    window.addEventListener('storage', handleStorageChange)
-  }
-
-  const getFullKey = (key: string) => `${name}:${key}`
-
-  return {
-    get: (key: K): V | undefined => {
-      if (typeof localStorage === 'undefined') {
-        console.warn(`No localStorage`)
-        return
-      }
-
-      const fullKey = getFullKey(key)
-      const item = localStorage.getItem(fullKey)
-      if (item && storageLimit) {
-        updateKeyAccess(fullKey)
-      }
-      return item ? JSON.parse(item) : undefined
-    },
-
-    set: (key: K, value: V): void => {
-      if (typeof localStorage === 'undefined') {
-        console.warn(`No localStorage`)
-        return
-      }
-
-      if (disableSetOnBlur && !isWindowActive) {
-        return
-      }
-
-      const fullKey = getFullKey(key)
-      const serializedValue = JSON.stringify(value)
-
-      if (storageLimit) {
-        const newSize = getStringSizeInBytes(serializedValue)
-        enforceStorageLimit(fullKey, newSize, storageLimit)
-        const tracking = getStorageTracking()
-        tracking[fullKey] = newSize
-        setStorageTracking(tracking)
-        updateKeyAccess(fullKey)
-      }
-
-      localStorage.setItem(fullKey, serializedValue)
-    },
-
-    remove: (key: K): void => {
-      if (typeof localStorage === 'undefined') {
-        console.warn(`No localStorage`)
-        return
-      }
-
-      // don't remove if window is not active and disablesetonblur is true
-      if (disableSetOnBlur && !isWindowActive) {
-        return
-      }
-
-      const fullKey = getFullKey(key)
-      localStorage.removeItem(fullKey)
-
-      // clean up tracking data if storage limit is enabled
-      if (storageLimit) {
-        const tracking = getStorageTracking()
-        delete tracking[fullKey]
-        setStorageTracking(tracking)
-
-        const order = getStorageOrder()
-        const index = order.indexOf(fullKey)
-        if (index > -1) {
-          order.splice(index, 1)
-          setStorageOrder(order)
-        }
-      }
-    },
-
-    exists: (key: K): boolean => {
-      const fullKey = getFullKey(key)
-      return localStorage.getItem(fullKey) != null
-    },
-
-    clear: (): void => {
-      if (typeof localStorage === 'undefined') {
-        console.warn(`No localStorage`)
-        return
-      }
-
-      // Remove all keys with this namespace
-      const keysToRemove: string[] = []
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i)
-        if (key?.startsWith(`${name}:`)) {
-          keysToRemove.push(key)
-        }
-      }
-
-      keysToRemove.forEach((key) => localStorage.removeItem(key))
-
-      // Clean up tracking data
-      if (storageLimit) {
-        const tracking = getStorageTracking()
-        const order = getStorageOrder()
-
-        keysToRemove.forEach((key) => {
-          delete tracking[key]
-          const index = order.indexOf(key)
-          if (index > -1) {
-            order.splice(index, 1)
-          }
-        })
-
-        setStorageTracking(tracking)
-        setStorageOrder(order)
-      }
-    },
-
-    subscribe: (key: string, listener: (value: V | undefined) => void): (() => void) => {
-      if (!synced) {
-        console.warn(`Subscribe only works when synced option is enabled`)
-        return () => {}
-      }
-
-      if (!listeners.has(key)) {
-        listeners.set(key, new Set())
-      }
-      const keyListeners = listeners.get(key)!
-      keyListeners.add(listener)
-
-      return () => {
-        keyListeners.delete(listener)
-        if (keyListeners.size === 0) {
-          listeners.delete(key)
-        }
-      }
-    },
-
-    keys: (): string[] => {
-      if (typeof localStorage === 'undefined') {
-        return []
-      }
-
-      const keys: string[] = []
-      const prefix = `${name}:`
-
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i)
-        if (key?.startsWith(prefix)) {
-          keys.push(key.slice(prefix.length))
-        }
-      }
-
-      return keys
-    },
-  }
-}
-
-export function createLocalStorageValue<T>(
-  key: string,
-  options: LocalStorageOptions = {}
-) {
-  const storage = createLocalStorage<string, T>(`single:${key}`, options)
-  const storageKey = 'value'
-
-  return {
-    get: (): T | undefined => {
-      return storage.get(storageKey)
-    },
-
-    set: (value: T): void => {
-      storage.set(storageKey, value)
-    },
-
-    remove: (): void => {
-      storage.remove(storageKey)
-    },
-
-    exists: (): boolean => {
-      return storage.exists(storageKey)
-    },
-
-    clear: (): void => {
-      storage.clear()
-    },
-
-    subscribe: (listener: (value: T | undefined) => void): (() => void) => {
-      return storage.subscribe(storageKey, listener)
-    },
-  }
-}
-
-function getStorageTracking(): StorageTracking {
-  if (typeof localStorage === 'undefined') return {}
-  const tracking = localStorage.getItem(STORAGE_TRACKING_KEY)
-  return tracking ? JSON.parse(tracking) : {}
-}
-
-function setStorageTracking(tracking: StorageTracking): void {
-  if (typeof localStorage === 'undefined') return
-  localStorage.setItem(STORAGE_TRACKING_KEY, JSON.stringify(tracking))
-}
-
-function getStorageOrder(): string[] {
-  if (typeof localStorage === 'undefined') return []
-  const order = localStorage.getItem(STORAGE_ORDER_KEY)
-  return order ? JSON.parse(order) : []
-}
-
-function setStorageOrder(order: string[]): void {
-  if (typeof localStorage === 'undefined') return
-  localStorage.setItem(STORAGE_ORDER_KEY, JSON.stringify(order))
-}
-
-function getStringSizeInBytes(str: string): number {
-  return new Blob([str]).size
-}
-
-function updateKeyAccess(key: string): void {
-  const order = getStorageOrder()
-  const index = order.indexOf(key)
-  if (index > -1) {
-    order.splice(index, 1)
-  }
-  order.push(key) // move to end (most recent)
-  setStorageOrder(order)
-}
-
-function enforceStorageLimit(newKey: string, newSize: number, limitKB: number): void {
-  const tracking = getStorageTracking()
-  const order = getStorageOrder()
-
-  let totalSize = Object.values(tracking).reduce((sum, size) => sum + size, 0)
-  totalSize += newSize // add the new item size
-
-  const limitBytes = limitKB * 1024
-
-  while (totalSize > limitBytes && order.length > 0) {
-    const oldestKey = order.shift()!
-
-    if (
-      oldestKey === newKey ||
-      oldestKey === STORAGE_TRACKING_KEY ||
-      oldestKey === STORAGE_ORDER_KEY
-    ) {
-      continue
-    }
-
-    const oldSize = tracking[oldestKey] || 0
-    totalSize -= oldSize
-
-    localStorage.removeItem(oldestKey)
-    delete tracking[oldestKey]
-  }
-
-  setStorageTracking(tracking)
-  setStorageOrder(order)
-}

package/types/ensure/catchEnsureErrors.d.ts

@@ -1,3 +0,0 @@
-export declare function catchEnsureErrors<T extends Function>(fn: T): T;
-
-//# sourceMappingURL=catchEnsureErrors.d.ts.map

package/types/ensure/catchEnsureErrors.d.ts.map

@@ -1,13 +0,0 @@
-{
-  "mappings": "AAEA,OAAO,iBAAS,kBAAkB,UAAU,UAAUA,IAAI,IAAI",
-  "names": [
-    "fn: T"
-  ],
-  "sources": [
-    "src/ensure/catchEnsureErrors.ts"
-  ],
-  "sourcesContent": [
-    "import { EnsureError } from '../error/errors'\n\nexport function catchEnsureErrors<T extends Function>(fn: T): T {\n  return ((...args: any[]) => {\n    try {\n      return fn(...args)\n    } catch (error) {\n      if (error instanceof EnsureError) {\n        console.error(`EnsureError: ${error.message}`)\n        return\n      }\n      throw error\n    }\n  }) as unknown as T\n}\n"
-  ],
-  "version": 3
-}

package/types/ensure/ensureSingleton.d.ts

@@ -1,7 +0,0 @@
-// Ensures a singleton value is stored on `globalThis` using a symbol key.
-// This creates a stable singleton that survives hot-reloads during development.
-// We store values on globalThis using `Symbol.for` keys to avoid collisions
-// across independently bundled modules.
-export declare function ensureSingleton<T>(key: string, factory: () => T): T;
-
-//# sourceMappingURL=ensureSingleton.d.ts.map

package/types/ensure/ensureSingleton.d.ts.map

@@ -1,14 +0,0 @@
-{
-  "mappings": ";;;;AAMA,OAAO,iBAAS,gBAAgB,GAAGA,aAAaC,eAAe,IAAI",
-  "names": [
-    "key: string",
-    "factory: () => T"
-  ],
-  "sources": [
-    "src/ensure/ensureSingleton.ts"
-  ],
-  "sourcesContent": [
-    "// Ensures a singleton value is stored on `globalThis` using a symbol key.\n// This creates a stable singleton that survives hot-reloads during development.\n\n// We store values on globalThis using `Symbol.for` keys to avoid collisions\n// across independently bundled modules.\n\nexport function ensureSingleton<T>(key: string, factory: () => T): T {\n  const symbolKey = Symbol.for(key)\n  const g = globalThis as Record<symbol, unknown>\n\n  if (!g[symbolKey]) {\n    g[symbolKey] = factory()\n  }\n\n  return g[symbolKey] as T\n}\n"
-  ],
-  "version": 3
-}

package/types/files/download.d.ts

@@ -1,4 +0,0 @@
-export declare function downloadFile(data: string, filename: string, mimeType?: string);
-export declare function downloadFromUrl(url: string, filename?: string);
-
-//# sourceMappingURL=download.d.ts.map

package/types/files/download.d.ts.map

@@ -1,16 +0,0 @@
-{
-  "mappings": "AAuCA,OAAO,iBAAe,aACpBA,cACAC,kBACA;AAYF,OAAO,iBAAe,gBAAgBC,aAAaC",
-  "names": [
-    "data: string",
-    "filename: string",
-    "url: string",
-    "filename?: string"
-  ],
-  "sources": [
-    "src/files/download.ts"
-  ],
-  "sourcesContent": [
-    "import { isTauri } from '../constants'\n\nasync function saveInTauri(data: string | Blob, filename: string) {\n  // @ts-ignore - tauri plugins only available in tauri environment\n  const { save } = await import('@tauri-apps/plugin-dialog')\n  // @ts-ignore - tauri plugins only available in tauri environment\n  const { writeTextFile, writeBinaryFile } = await import('@tauri-apps/plugin-fs')\n\n  const extension = filename.split('.').pop() || ''\n  const filePath = await save({\n    defaultPath: filename,\n    filters: [\n      {\n        name: `${extension.toUpperCase()} files`,\n        extensions: [extension],\n      },\n    ],\n  })\n\n  if (filePath) {\n    if (typeof data === 'string') {\n      await writeTextFile(filePath, data)\n    } else {\n      const arrayBuffer = await data.arrayBuffer()\n      await writeBinaryFile(filePath, new Uint8Array(arrayBuffer))\n    }\n  }\n}\n\nfunction downloadInBrowser(url: string, filename: string) {\n  const a = document.createElement('a')\n  a.href = url\n  a.download = filename\n  a.target = '_blank'\n  document.body.appendChild(a)\n  a.click()\n  document.body.removeChild(a)\n}\n\nexport async function downloadFile(\n  data: string,\n  filename: string,\n  mimeType = 'application/json'\n) {\n  if (isTauri) {\n    await saveInTauri(data, filename)\n  } else {\n    const blob = new Blob([data], { type: mimeType })\n    const url = URL.createObjectURL(blob)\n    downloadInBrowser(url, filename)\n    URL.revokeObjectURL(url)\n  }\n}\n\nexport async function downloadFromUrl(url: string, filename?: string) {\n  const resolvedFilename = filename || url.split('/').pop() || 'download'\n\n  if (isTauri) {\n    try {\n      const response = await fetch(url)\n      const blob = await response.blob()\n      await saveInTauri(blob, resolvedFilename)\n    } catch (error) {\n      console.error('Failed to download file:', error)\n      downloadInBrowser(url, resolvedFilename)\n    }\n  } else {\n    downloadInBrowser(url, resolvedFilename)\n  }\n}\n"
-  ],
-  "version": 3
-}

package/types/global/globalContext.d.ts

@@ -1,6 +0,0 @@
-import { type Context } from "react";
-// create or retrieve a React context that is stored on `globalThis`.
-// this ensures a stable singleton that survives hot-reloads during development.
-export declare function createGlobalContext<T>(key: string, defaultValue: T): Context<T>;
-
-//# sourceMappingURL=globalContext.d.ts.map

package/types/global/globalContext.d.ts.map

@@ -1,14 +0,0 @@
-{
-  "mappings": "AAAA,cAAc,eAA8B,OAAO;;;AAMnD,OAAO,iBAAS,oBAAoB,GAAGA,aAAaC,cAAc,IAAI,QAAQ",
-  "names": [
-    "key: string",
-    "defaultValue: T"
-  ],
-  "sources": [
-    "src/global/globalContext.ts"
-  ],
-  "sourcesContent": [
-    "import { type Context, createContext } from 'react'\nimport { ensureSingleton } from '../ensure/ensureSingleton'\n\n// create or retrieve a React context that is stored on `globalThis`.\n// this ensures a stable singleton that survives hot-reloads during development.\n\nexport function createGlobalContext<T>(key: string, defaultValue: T): Context<T> {\n  return ensureSingleton(key, () => createContext<T>(defaultValue))\n}\n"
-  ],
-  "version": 3
-}