@take-out/helpers 0.0.32 → 0.0.34

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
-}