@pyreon/storage 0.9.0 → 0.11.0

package/src/indexed-db.ts

@@ -1,7 +1,7 @@
-import { signal } from '@pyreon/reactivity'
-import { getEntry, removeEntry, setEntry } from './registry'
-import type { IndexedDBOptions, StorageSignal } from './types'
-import { deserialize, isBrowser, serialize } from './utils'
+import { signal } from "@pyreon/reactivity"
+import { getEntry, removeEntry, setEntry } from "./registry"
+import type { IndexedDBOptions, StorageSignal } from "./types"
+import { deserialize, isBrowser, serialize } from "./utils"
 
 // ─── Database management ─────────────────────────────────────────────────────
 
@@ -30,13 +30,9 @@ function openDB(dbName: string, storeName: string): Promise<IDBDatabase> {
   return promise
 }
 
-function idbGet(
-  db: IDBDatabase,
-  storeName: string,
-  key: string,
-): Promise<string | null> {
+function idbGet(db: IDBDatabase, storeName: string, key: string): Promise<string | null> {
   return new Promise((resolve, reject) => {
-    const tx = db.transaction(storeName, 'readonly')
+    const tx = db.transaction(storeName, "readonly")
     const store = tx.objectStore(storeName)
     const request = store.get(key)
     request.onsuccess = () =>
@@ -45,14 +41,9 @@ function idbGet(
   })
 }
 
-function idbSet(
-  db: IDBDatabase,
-  storeName: string,
-  key: string,
-  value: string,
-): Promise<void> {
+function idbSet(db: IDBDatabase, storeName: string, key: string, value: string): Promise<void> {
   return new Promise((resolve, reject) => {
-    const tx = db.transaction(storeName, 'readwrite')
+    const tx = db.transaction(storeName, "readwrite")
     const store = tx.objectStore(storeName)
     const request = store.put(value, key)
     request.onsuccess = () => resolve()
@@ -60,13 +51,9 @@ function idbSet(
   })
 }
 
-function idbDelete(
-  db: IDBDatabase,
-  storeName: string,
-  key: string,
-): Promise<void> {
+function idbDelete(db: IDBDatabase, storeName: string, key: string): Promise<void> {
   return new Promise((resolve, reject) => {
-    const tx = db.transaction(storeName, 'readwrite')
+    const tx = db.transaction(storeName, "readwrite")
     const store = tx.objectStore(storeName)
     const request = store.delete(key)
     request.onsuccess = () => resolve()
@@ -96,27 +83,22 @@ export function useIndexedDB<T>(
   options: IndexedDBOptions<T> = {},
 ): StorageSignal<T> {
   // Return existing signal if already registered
-  const existing = getEntry<T>('indexeddb', key)
+  const existing = getEntry<T>("indexeddb", key)
   if (existing) return existing.signal
 
-  const dbName = options.dbName ?? 'pyreon-storage'
-  const storeName = options.storeName ?? 'kv'
+  const dbName = options.dbName ?? "pyreon-storage"
+  const storeName = options.storeName ?? "kv"
   const debounceMs = options.debounceMs ?? 100
 
   const sig = signal<T>(defaultValue)
 
   // Async initial load
-  if (isBrowser() && typeof indexedDB !== 'undefined') {
+  if (isBrowser() && typeof indexedDB !== "undefined") {
     openDB(dbName, storeName)
       .then((db) => idbGet(db, storeName, key))
       .then((raw) => {
         if (raw !== null) {
-          const value = deserialize(
-            raw,
-            defaultValue,
-            options.deserializer,
-            options.onError,
-          )
+          const value = deserialize(raw, defaultValue, options.deserializer, options.onError)
           sig.set(value)
         }
       })
@@ -134,12 +116,10 @@ export function useIndexedDB<T>(
     const value = pendingValue
     pendingValue = undefined
 
-    if (!isBrowser() || typeof indexedDB === 'undefined') return
+    if (!isBrowser() || typeof indexedDB === "undefined") return
 
     openDB(dbName, storeName)
-      .then((db) =>
-        idbSet(db, storeName, key, serialize(value, options.serializer)),
-      )
+      .then((db) => idbSet(db, storeName, key, serialize(value, options.serializer)))
       .catch(() => {
         // Write failed — signal still has the correct value
       })
@@ -159,7 +139,7 @@ export function useIndexedDB<T>(
   storageSig.direct = (updater: () => void) => sig.direct(updater)
   storageSig.debug = () => sig.debug()
 
-  Object.defineProperty(storageSig, 'label', {
+  Object.defineProperty(storageSig, "label", {
     get: () => sig.label,
     set: (v: string | undefined) => {
       sig.label = v
@@ -181,7 +161,7 @@ export function useIndexedDB<T>(
     pendingValue = undefined
     if (writeTimer !== null) clearTimeout(writeTimer)
 
-    if (isBrowser() && typeof indexedDB !== 'undefined') {
+    if (isBrowser() && typeof indexedDB !== "undefined") {
       openDB(dbName, storeName)
         .then((db) => idbDelete(db, storeName, key))
         .catch(() => {
@@ -189,10 +169,10 @@ export function useIndexedDB<T>(
         })
     }
 
-    removeEntry('indexeddb', key)
+    removeEntry("indexeddb", key)
   }
 
-  setEntry('indexeddb', key, storageSig, defaultValue)
+  setEntry("indexeddb", key, storageSig, defaultValue)
 
   return storageSig
 }

package/src/local.ts

@@ -1,7 +1,7 @@
-import { signal } from '@pyreon/reactivity'
-import { getEntry, removeEntry, setEntry } from './registry'
-import type { StorageOptions, StorageSignal } from './types'
-import { deserialize, getWebStorage, isBrowser, serialize } from './utils'
+import { signal } from "@pyreon/reactivity"
+import { getEntry, removeEntry, setEntry } from "./registry"
+import type { StorageOptions, StorageSignal } from "./types"
+import { deserialize, getWebStorage, isBrowser, serialize } from "./utils"
 
 // ─── Cross-tab sync ──────────────────────────────────────────────────────────
 
@@ -11,15 +11,13 @@ function attachStorageListener(): void {
   if (listenerAttached || !isBrowser()) return
   listenerAttached = true
 
-  window.addEventListener('storage', (e) => {
+  window.addEventListener("storage", (e) => {
     if (!e.key) return
-    const entry = getEntry('local', e.key)
+    const entry = getEntry("local", e.key)
     if (!entry) return
 
     const newValue =
-      e.newValue !== null
-        ? deserialize(e.newValue, entry.defaultValue)
-        : entry.defaultValue
+      e.newValue !== null ? deserialize(e.newValue, entry.defaultValue) : entry.defaultValue
 
     entry.signal.set(newValue)
   })
@@ -45,37 +43,26 @@ export function useStorage<T>(
   options?: StorageOptions<T>,
 ): StorageSignal<T> {
   // Return existing signal if already registered
-  const existing = getEntry<T>('local', key)
+  const existing = getEntry<T>("local", key)
   if (existing) return existing.signal
 
-  const storage = getWebStorage('local')
+  const storage = getWebStorage("local")
 
   // Read initial value from storage
   let initialValue = defaultValue
   if (storage) {
     const raw = storage.getItem(key)
     if (raw !== null) {
-      initialValue = deserialize(
-        raw,
-        defaultValue,
-        options?.deserializer,
-        options?.onError,
-      )
+      initialValue = deserialize(raw, defaultValue, options?.deserializer, options?.onError)
     }
   }
 
   const sig = signal<T>(initialValue)
 
   // Create the storage signal by extending the base signal
-  const storageSig = createStorageSignal(
-    sig,
-    key,
-    defaultValue,
-    'local',
-    options,
-  )
-
-  setEntry('local', key, storageSig, defaultValue)
+  const storageSig = createStorageSignal(sig, key, defaultValue, "local", options)
+
+  setEntry("local", key, storageSig, defaultValue)
   attachStorageListener()
 
   return storageSig
@@ -91,7 +78,7 @@ export function createStorageSignal<T>(
   sig: ReturnType<typeof signal<T>>,
   key: string,
   defaultValue: T,
-  backend: 'local' | 'session',
+  backend: "local" | "session",
   options?: StorageOptions<T>,
 ): StorageSignal<T> {
   const storage = getWebStorage(backend)
@@ -105,7 +92,7 @@ export function createStorageSignal<T>(
   storageSig.direct = (updater: () => void) => sig.direct(updater)
   storageSig.debug = () => sig.debug()
 
-  Object.defineProperty(storageSig, 'label', {
+  Object.defineProperty(storageSig, "label", {
     get: () => sig.label,
     set: (v: string | undefined) => {
       sig.label = v

package/src/registry.ts

@@ -1,4 +1,4 @@
-import type { StorageSignal } from './types'
+import type { StorageSignal } from "./types"
 
 // ─── Signal Registry ─────────────────────────────────────────────────────────
 
@@ -21,10 +21,7 @@ function registryKey(backend: string, key: string): string {
 /**
  * Get an existing signal from the registry.
  */
-export function getEntry<T>(
-  backend: string,
-  key: string,
-): RegistryEntry<T> | undefined {
+export function getEntry<T>(backend: string, key: string): RegistryEntry<T> | undefined {
   return registry.get(registryKey(backend, key)) as RegistryEntry<T> | undefined
 }
 

package/src/session.ts

@@ -1,8 +1,8 @@
-import { signal } from '@pyreon/reactivity'
-import { createStorageSignal } from './local'
-import { getEntry, setEntry } from './registry'
-import type { StorageOptions, StorageSignal } from './types'
-import { deserialize, getWebStorage } from './utils'
+import { signal } from "@pyreon/reactivity"
+import { createStorageSignal } from "./local"
+import { getEntry, setEntry } from "./registry"
+import type { StorageOptions, StorageSignal } from "./types"
+import { deserialize, getWebStorage } from "./utils"
 
 // ─── useSessionStorage ───────────────────────────────────────────────────────
 
@@ -24,35 +24,24 @@ export function useSessionStorage<T>(
   options?: StorageOptions<T>,
 ): StorageSignal<T> {
   // Return existing signal if already registered
-  const existing = getEntry<T>('session', key)
+  const existing = getEntry<T>("session", key)
   if (existing) return existing.signal
 
-  const storage = getWebStorage('session')
+  const storage = getWebStorage("session")
 
   // Read initial value from storage
   let initialValue = defaultValue
   if (storage) {
     const raw = storage.getItem(key)
     if (raw !== null) {
-      initialValue = deserialize(
-        raw,
-        defaultValue,
-        options?.deserializer,
-        options?.onError,
-      )
+      initialValue = deserialize(raw, defaultValue, options?.deserializer, options?.onError)
     }
   }
 
   const sig = signal<T>(initialValue)
-  const storageSig = createStorageSignal(
-    sig,
-    key,
-    defaultValue,
-    'session',
-    options,
-  )
+  const storageSig = createStorageSignal(sig, key, defaultValue, "session", options)
 
-  setEntry('session', key, storageSig, defaultValue)
+  setEntry("session", key, storageSig, defaultValue)
 
   return storageSig
 }

package/src/tests/clear.test.ts

@@ -1,13 +1,13 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
 import {
   _resetRegistry,
   clearStorage,
   removeStorage,
   useSessionStorage,
   useStorage,
-} from '../index'
+} from "../index"
 
-describe('removeStorage', () => {
+describe("removeStorage", () => {
   beforeEach(() => {
     localStorage.clear()
     sessionStorage.clear()
@@ -20,43 +20,43 @@ describe('removeStorage', () => {
     _resetRegistry()
   })
 
-  it('removes a localStorage entry via signal', () => {
-    const theme = useStorage('theme', 'light')
-    theme.set('dark')
+  it("removes a localStorage entry via signal", () => {
+    const theme = useStorage("theme", "light")
+    theme.set("dark")
 
-    removeStorage('theme')
-    expect(theme()).toBe('light')
-    expect(localStorage.getItem('theme')).toBeNull()
+    removeStorage("theme")
+    expect(theme()).toBe("light")
+    expect(localStorage.getItem("theme")).toBeNull()
   })
 
-  it('removes a sessionStorage entry', () => {
-    const step = useSessionStorage('step', 0)
+  it("removes a sessionStorage entry", () => {
+    const step = useSessionStorage("step", 0)
     step.set(3)
 
-    removeStorage('step', { type: 'session' })
+    removeStorage("step", { type: "session" })
     expect(step()).toBe(0)
-    expect(sessionStorage.getItem('step')).toBeNull()
+    expect(sessionStorage.getItem("step")).toBeNull()
   })
 
-  it('removes raw localStorage even without a signal', () => {
-    localStorage.setItem('orphan', 'value')
-    removeStorage('orphan')
-    expect(localStorage.getItem('orphan')).toBeNull()
+  it("removes raw localStorage even without a signal", () => {
+    localStorage.setItem("orphan", "value")
+    removeStorage("orphan")
+    expect(localStorage.getItem("orphan")).toBeNull()
   })
 
-  it('removes raw sessionStorage even without a signal', () => {
-    sessionStorage.setItem('orphan', 'value')
-    removeStorage('orphan', { type: 'session' })
-    expect(sessionStorage.getItem('orphan')).toBeNull()
+  it("removes raw sessionStorage even without a signal", () => {
+    sessionStorage.setItem("orphan", "value")
+    removeStorage("orphan", { type: "session" })
+    expect(sessionStorage.getItem("orphan")).toBeNull()
   })
 
-  it('removes cookie without a signal', () => {
-    removeStorage('orphan-cookie', { type: 'cookie' })
+  it("removes cookie without a signal", () => {
+    removeStorage("orphan-cookie", { type: "cookie" })
     // Should not throw even when cookie doesn't exist
   })
 })
 
-describe('clearStorage', () => {
+describe("clearStorage", () => {
   beforeEach(() => {
     localStorage.clear()
     sessionStorage.clear()
@@ -69,9 +69,9 @@ describe('clearStorage', () => {
     _resetRegistry()
   })
 
-  it('clears all managed localStorage entries', () => {
-    const a = useStorage('a', 1)
-    const b = useStorage('b', 2)
+  it("clears all managed localStorage entries", () => {
+    const a = useStorage("a", 1)
+    const b = useStorage("b", 2)
     a.set(10)
     b.set(20)
 
@@ -80,25 +80,25 @@ describe('clearStorage', () => {
     expect(b()).toBe(2)
   })
 
-  it('clears all managed sessionStorage entries', () => {
-    const a = useSessionStorage('a', 'x')
-    const b = useSessionStorage('b', 'y')
-    a.set('modified')
-    b.set('modified')
+  it("clears all managed sessionStorage entries", () => {
+    const a = useSessionStorage("a", "x")
+    const b = useSessionStorage("b", "y")
+    a.set("modified")
+    b.set("modified")
 
-    clearStorage('session')
-    expect(a()).toBe('x')
-    expect(b()).toBe('y')
+    clearStorage("session")
+    expect(a()).toBe("x")
+    expect(b()).toBe("y")
   })
 
   it('clears all backends with "all"', () => {
-    const local = useStorage('l', 'default')
-    const session = useSessionStorage('s', 'default')
-    local.set('changed')
-    session.set('changed')
-
-    clearStorage('all')
-    expect(local()).toBe('default')
-    expect(session()).toBe('default')
+    const local = useStorage("l", "default")
+    const session = useSessionStorage("s", "default")
+    local.set("changed")
+    session.set("changed")
+
+    clearStorage("all")
+    expect(local()).toBe("default")
+    expect(session()).toBe("default")
   })
 })

package/src/tests/cookie.test.ts

@@ -1,9 +1,9 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { _resetRegistry, setCookieSource, useCookie } from '../index'
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { _resetRegistry, setCookieSource, useCookie } from "../index"
 
 function clearAllCookies(): void {
-  for (const cookie of document.cookie.split(';')) {
-    const name = cookie.split('=')[0]?.trim()
+  for (const cookie of document.cookie.split(";")) {
+    const name = cookie.split("=")[0]?.trim()
     if (name) {
       // biome-ignore lint/suspicious/noDocumentCookie: test cleanup requires direct cookie access
       document.cookie = `${name}=; max-age=0; path=/`
@@ -11,7 +11,7 @@ function clearAllCookies(): void {
   }
 }
 
-describe('useCookie', () => {
+describe("useCookie", () => {
   beforeEach(() => {
     _resetRegistry()
     clearAllCookies()
@@ -22,128 +22,128 @@ describe('useCookie', () => {
     clearAllCookies()
   })
 
-  it('returns default value when cookie does not exist', () => {
-    const locale = useCookie('locale', 'en')
-    expect(locale()).toBe('en')
+  it("returns default value when cookie does not exist", () => {
+    const locale = useCookie("locale", "en")
+    expect(locale()).toBe("en")
   })
 
-  it('reads existing cookie value', () => {
+  it("reads existing cookie value", () => {
     // biome-ignore lint/suspicious/noDocumentCookie: test setup requires direct cookie access
-    document.cookie = `locale=${encodeURIComponent(JSON.stringify('de'))}; path=/`
-    const locale = useCookie('locale', 'en')
-    expect(locale()).toBe('de')
+    document.cookie = `locale=${encodeURIComponent(JSON.stringify("de"))}; path=/`
+    const locale = useCookie("locale", "en")
+    expect(locale()).toBe("de")
   })
 
-  it('.set() updates signal and writes cookie', () => {
-    const locale = useCookie('locale', 'en')
-    locale.set('fr')
-    expect(locale()).toBe('fr')
-    expect(document.cookie).toContain('locale')
+  it(".set() updates signal and writes cookie", () => {
+    const locale = useCookie("locale", "en")
+    locale.set("fr")
+    expect(locale()).toBe("fr")
+    expect(document.cookie).toContain("locale")
   })
 
-  it('.remove() deletes cookie and resets to default', () => {
-    const locale = useCookie('locale', 'en')
-    locale.set('fr')
+  it(".remove() deletes cookie and resets to default", () => {
+    const locale = useCookie("locale", "en")
+    locale.set("fr")
     locale.remove()
-    expect(locale()).toBe('en')
+    expect(locale()).toBe("en")
   })
 
-  it('returns same signal instance for same key', () => {
-    const a = useCookie('locale', 'en')
-    const b = useCookie('locale', 'en')
+  it("returns same signal instance for same key", () => {
+    const a = useCookie("locale", "en")
+    const b = useCookie("locale", "en")
     expect(a).toBe(b)
   })
 
-  it('works with objects', () => {
-    const prefs = useCookie('prefs', { dark: false })
+  it("works with objects", () => {
+    const prefs = useCookie("prefs", { dark: false })
     prefs.set({ dark: true })
     expect(prefs()).toEqual({ dark: true })
   })
 
-  it('.update() works', () => {
-    const count = useCookie('count', 0)
+  it(".update() works", () => {
+    const count = useCookie("count", 0)
     count.update((n) => n + 1)
     expect(count()).toBe(1)
   })
 
-  it('.peek() reads without subscribing', () => {
-    const locale = useCookie('locale', 'en')
-    expect(locale.peek()).toBe('en')
+  it(".peek() reads without subscribing", () => {
+    const locale = useCookie("locale", "en")
+    expect(locale.peek()).toBe("en")
   })
 
-  it('respects maxAge option', () => {
-    const locale = useCookie('locale', 'en', { maxAge: 3600 })
-    locale.set('de')
-    expect(document.cookie).toContain('locale')
+  it("respects maxAge option", () => {
+    const locale = useCookie("locale", "en", { maxAge: 3600 })
+    locale.set("de")
+    expect(document.cookie).toContain("locale")
   })
 
-  it('respects secure option', () => {
-    const token = useCookie('token', '', { secure: true })
-    token.set('abc123')
-    expect(token()).toBe('abc123')
+  it("respects secure option", () => {
+    const token = useCookie("token", "", { secure: true })
+    token.set("abc123")
+    expect(token()).toBe("abc123")
   })
 
-  it('respects expires option', () => {
+  it("respects expires option", () => {
     const future = new Date(Date.now() + 86400000)
-    const sig = useCookie('exp', 'val', { expires: future })
-    sig.set('updated')
-    expect(sig()).toBe('updated')
+    const sig = useCookie("exp", "val", { expires: future })
+    sig.set("updated")
+    expect(sig()).toBe("updated")
   })
 
-  it('respects domain option on set and remove', () => {
-    const sig = useCookie('dom', 'val', { domain: 'example.com' })
-    sig.set('updated')
-    expect(sig()).toBe('updated')
+  it("respects domain option on set and remove", () => {
+    const sig = useCookie("dom", "val", { domain: "example.com" })
+    sig.set("updated")
+    expect(sig()).toBe("updated")
     sig.remove()
-    expect(sig()).toBe('val')
+    expect(sig()).toBe("val")
   })
 
-  it('.subscribe() works', () => {
-    const sig = useCookie('sub', 'a')
+  it(".subscribe() works", () => {
+    const sig = useCookie("sub", "a")
     let called = false
     const unsub = sig.subscribe(() => {
       called = true
     })
-    sig.set('b')
+    sig.set("b")
     expect(called).toBe(true)
     unsub()
   })
 
-  it('.direct() works', () => {
-    const sig = useCookie('dir', 'a')
+  it(".direct() works", () => {
+    const sig = useCookie("dir", "a")
     let called = false
     const unsub = sig.direct(() => {
       called = true
     })
-    sig.set('b')
+    sig.set("b")
     expect(called).toBe(true)
     unsub()
   })
 
-  it('.debug() returns debug info', () => {
-    const sig = useCookie('dbg', 'test')
-    expect(sig.debug().value).toBe('test')
+  it(".debug() returns debug info", () => {
+    const sig = useCookie("dbg", "test")
+    expect(sig.debug().value).toBe("test")
   })
 
-  it('.label can be set and read', () => {
-    const sig = useCookie('lbl', 'val')
-    sig.label = 'my-cookie'
-    expect(sig.label).toBe('my-cookie')
+  it(".label can be set and read", () => {
+    const sig = useCookie("lbl", "val")
+    sig.label = "my-cookie"
+    expect(sig.label).toBe("my-cookie")
   })
 })
 
-describe('setCookieSource (SSR)', () => {
+describe("setCookieSource (SSR)", () => {
   beforeEach(() => {
     _resetRegistry()
   })
 
   afterEach(() => {
     _resetRegistry()
-    setCookieSource('')
+    setCookieSource("")
   })
 
-  it('stores server cookie string without throwing', () => {
-    setCookieSource('locale=de; theme=dark')
-    expect(() => setCookieSource('foo=bar')).not.toThrow()
+  it("stores server cookie string without throwing", () => {
+    setCookieSource("locale=de; theme=dark")
+    expect(() => setCookieSource("foo=bar")).not.toThrow()
   })
 })