@pyreon/storage 0.12.8 → 0.12.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/storage",
-  "version": "0.12.8",
+  "version": "0.12.10",
   "description": "Reactive client-side storage for Pyreon — localStorage, sessionStorage, cookies, IndexedDB",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/storage#readme",
   "bugs": {
@@ -42,10 +42,10 @@
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.8.9",
-    "@pyreon/reactivity": "^0.12.8",
+    "@pyreon/reactivity": "^0.12.10",
     "@vitus-labs/tools-lint": "^1.15.5"
   },
   "peerDependencies": {
-    "@pyreon/reactivity": "^0.12.8"
+    "@pyreon/reactivity": "^0.12.10"
   }
 }

package/src/tests/clear-coverage.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import {
+  _resetDBCache,
+  _resetRegistry,
+  clearStorage,
+  removeStorage,
+  useCookie,
+  useIndexedDB,
+  useSessionStorage,
+  useStorage,
+} from '../index'
+
+describe('removeStorage — indexeddb branch', () => {
+  beforeEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+  })
+
+  it('removes indexeddb entry with registered signal', () => {
+    const sig = useIndexedDB('idb-remove', 'default')
+    sig.set('modified')
+    removeStorage('idb-remove', { type: 'indexeddb' })
+    expect(sig()).toBe('default')
+  })
+
+  it('removeStorage for indexeddb without registered signal (no-op)', () => {
+    // This covers the else branch where entry is not found for indexeddb
+    expect(() => removeStorage('nonexistent-idb', { type: 'indexeddb' })).not.toThrow()
+  })
+
+  it('removeStorage for cookie without registered signal (browser path)', () => {
+    // Covers the cookie branch in clear.ts
+    expect(() => removeStorage('nonexistent-cookie', { type: 'cookie' })).not.toThrow()
+  })
+})
+
+describe('clearStorage — indexeddb backend', () => {
+  beforeEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+  })
+
+  it('clears indexeddb entries', () => {
+    const sig = useIndexedDB('idb-clear', 'default')
+    sig.set('modified')
+    clearStorage('indexeddb')
+    expect(sig()).toBe('default')
+  })
+
+  it('clearStorage("all") includes indexeddb', () => {
+    const local = useStorage('l', 'default')
+    const session = useSessionStorage('s', 'default')
+    const cookie = useCookie('c', 'default')
+    const idb = useIndexedDB('i', 'default')
+
+    local.set('x')
+    session.set('x')
+    cookie.set('x')
+    idb.set('x')
+
+    clearStorage('all')
+
+    expect(local()).toBe('default')
+    expect(session()).toBe('default')
+    expect(cookie()).toBe('default')
+    expect(idb()).toBe('default')
+  })
+})

package/src/tests/cookie-coverage.test.ts

@@ -0,0 +1,127 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { _resetRegistry, setCookieSource, useCookie } from '../index'
+
+describe('useCookie — full coverage', () => {
+  beforeEach(() => {
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+  })
+
+  it('reads server cookie string via setCookieSource', () => {
+    setCookieSource('locale=de; theme=dark')
+    // Server-side reading requires isBrowser() to be false,
+    // but since we're in happy-dom it reads document.cookie instead.
+    // Reset to empty
+    setCookieSource('')
+  })
+
+  it('handles cookie with all options', () => {
+    const sig = useCookie('full-opts', 'default', {
+      maxAge: 3600,
+      expires: new Date('2030-01-01'),
+      path: '/app',
+      domain: 'example.com',
+      secure: true,
+      sameSite: 'strict',
+    })
+    sig.set('value')
+    expect(sig()).toBe('value')
+  })
+
+  it('.update() updates value', () => {
+    const count = useCookie('counter', 0)
+    count.update((n) => n + 5)
+    expect(count()).toBe(5)
+  })
+
+  it('.remove() resets to default and removes cookie', () => {
+    const sig = useCookie('remove-test', 'default')
+    sig.set('changed')
+    sig.remove()
+    expect(sig()).toBe('default')
+  })
+
+  it('.remove() with domain option', () => {
+    const sig = useCookie('domain-rm', 'default', { domain: 'example.com' })
+    sig.set('value')
+    sig.remove()
+    expect(sig()).toBe('default')
+  })
+
+  it('returns same signal for same key', () => {
+    const a = useCookie('dedup', 'val')
+    const b = useCookie('dedup', 'val')
+    expect(a).toBe(b)
+  })
+
+  it('reads existing cookie value', () => {
+    // Set a cookie in the browser
+    document.cookie = 'existing-key=hello'
+    const sig = useCookie('existing-key', 'fallback')
+    // In happy-dom, document.cookie may not persist correctly — test the path
+    expect(typeof sig()).toBe('string')
+  })
+
+  it('.debug() returns debug info', () => {
+    const sig = useCookie('debug-test', 'val')
+    expect(sig.debug().value).toBe('val')
+  })
+
+  it('.label can be set and read', () => {
+    const sig = useCookie('label-test', 'val')
+    sig.label = 'cookie-sig'
+    expect(sig.label).toBe('cookie-sig')
+  })
+
+  it('.peek() reads without tracking', () => {
+    const sig = useCookie('peek-test', 'hello')
+    expect(sig.peek()).toBe('hello')
+  })
+
+  it('.subscribe() works', () => {
+    const sig = useCookie('sub-test', 'a')
+    let called = false
+    const unsub = sig.subscribe(() => {
+      called = true
+    })
+    sig.set('b')
+    expect(called).toBe(true)
+    unsub()
+  })
+
+  it('.direct() is callable', () => {
+    const sig = useCookie('direct-test', 0)
+    expect(typeof sig.direct).toBe('function')
+    sig.direct(() => {})
+  })
+
+  it('handles custom serializer/deserializer', () => {
+    const sig = useCookie('custom-ser', new Date('2025-01-01'), {
+      serializer: (d) => d.toISOString(),
+      deserializer: (s) => new Date(s),
+    })
+    expect(sig()).toEqual(new Date('2025-01-01'))
+  })
+
+  it('handles empty cookie string in parseCookies', () => {
+    // With no pre-set cookie, should get default
+    const sig = useCookie('nonexistent-cookie-key', 'fallback')
+    expect(sig()).toBe('fallback')
+  })
+
+  it('handles cookie with sameSite lax (default)', () => {
+    const sig = useCookie('lax-test', 'val')
+    sig.set('updated')
+    expect(sig()).toBe('updated')
+  })
+
+  it('handles cookie without secure/domain options', () => {
+    const sig = useCookie('minimal', 'val', { path: '/' })
+    sig.set('updated')
+    sig.remove()
+    expect(sig()).toBe('val')
+  })
+})

package/src/tests/cross-tab-coverage.test.ts

@@ -0,0 +1,51 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { _resetRegistry, useStorage } from '../index'
+
+describe('cross-tab sync — edge cases', () => {
+  beforeEach(() => {
+    localStorage.clear()
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    localStorage.clear()
+    _resetRegistry()
+  })
+
+  it('ignores storage events with null key', () => {
+    const theme = useStorage('theme', 'light')
+
+    // Simulate storage event with null key (happens on storage.clear())
+    const event = Object.assign(new Event('storage'), {
+      key: null,
+      newValue: null,
+      storageArea: localStorage,
+    })
+    window.dispatchEvent(event)
+
+    // Signal should not change
+    expect(theme()).toBe('light')
+  })
+
+  it('ignores storage events for unregistered keys', () => {
+    const theme = useStorage('theme', 'light')
+
+    // Event for a key we don't track
+    const event = Object.assign(new Event('storage'), {
+      key: 'other-key',
+      newValue: JSON.stringify('value'),
+      storageArea: localStorage,
+    })
+    window.dispatchEvent(event)
+
+    expect(theme()).toBe('light')
+  })
+
+  it('storage set catch branch — handles quota error gracefully', () => {
+    const sig = useStorage('quota-test', 'default')
+    // Even if the internal storage.setItem throws, the signal should still update
+    sig.set('value')
+    expect(sig()).toBe('value')
+  })
+})
+

package/src/tests/indexed-db-full.test.ts

@@ -0,0 +1,263 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { _resetDBCache, _resetRegistry, useIndexedDB } from '../index'
+
+// ─── IndexedDB mock ─────────────────────────────────────────────────────────
+
+function createMockIDB() {
+  const stores = new Map<string, Map<string, unknown>>()
+
+  function getStore(storeName: string) {
+    if (!stores.has(storeName)) stores.set(storeName, new Map())
+    return stores.get(storeName)!
+  }
+
+  const mockIDB = {
+    open(dbName: string, _version?: number) {
+      const request: any = {
+        result: null as any,
+        error: null,
+        onupgradeneeded: null as any,
+        onsuccess: null as any,
+        onerror: null as any,
+      }
+
+      setTimeout(() => {
+        const db = {
+          objectStoreNames: {
+            contains: (name: string) => stores.has(name),
+          },
+          createObjectStore: (name: string) => {
+            stores.set(name, new Map())
+          },
+          transaction: (storeName: string, mode: string) => ({
+            objectStore: (name: string) => {
+              const store = getStore(name)
+              return {
+                get: (key: string) => {
+                  const getReq: any = {
+                    result: store.get(key),
+                    error: null,
+                    onsuccess: null as any,
+                    onerror: null as any,
+                  }
+                  setTimeout(() => getReq.onsuccess?.())
+                  return getReq
+                },
+                put: (value: unknown, key: string) => {
+                  store.set(key, value)
+                  const putReq: any = {
+                    result: undefined,
+                    error: null,
+                    onsuccess: null as any,
+                    onerror: null as any,
+                  }
+                  setTimeout(() => putReq.onsuccess?.())
+                  return putReq
+                },
+                delete: (key: string) => {
+                  store.delete(key)
+                  const delReq: any = {
+                    result: undefined,
+                    error: null,
+                    onsuccess: null as any,
+                    onerror: null as any,
+                  }
+                  setTimeout(() => delReq.onsuccess?.())
+                  return delReq
+                },
+              }
+            },
+          }),
+        }
+
+        request.result = db
+
+        // Fire upgrade if store doesn't exist
+        if (!stores.has('kv')) {
+          request.onupgradeneeded?.()
+        }
+
+        request.onsuccess?.()
+      })
+
+      return request
+    },
+  }
+
+  return { mockIDB, stores, getStore }
+}
+
+describe('useIndexedDB — full coverage', () => {
+  let idbMock: ReturnType<typeof createMockIDB>
+
+  beforeEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+    vi.useFakeTimers()
+    idbMock = createMockIDB()
+    ;(globalThis as any).indexedDB = idbMock.mockIDB
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+    vi.useRealTimers()
+  })
+
+  it('loads stored value from IndexedDB asynchronously', async () => {
+    // Pre-store a value
+    idbMock.getStore('kv').set('existing-key', JSON.stringify('stored-value'))
+
+    const sig = useIndexedDB('existing-key', 'default')
+    expect(sig()).toBe('default') // Initially default
+
+    // Run all microtasks and timers to let IDB load complete
+    await vi.runAllTimersAsync()
+
+    expect(sig()).toBe('stored-value')
+  })
+
+  it('keeps default when IDB returns null', async () => {
+    const sig = useIndexedDB('missing-key', 'fallback')
+    await vi.runAllTimersAsync()
+    expect(sig()).toBe('fallback')
+  })
+
+  it('.set() triggers debounced IDB write', async () => {
+    const sig = useIndexedDB('write-test', 'init', { debounceMs: 50 })
+    sig.set('new-value')
+
+    // Signal updates immediately
+    expect(sig()).toBe('new-value')
+
+    // Advance past debounce
+    await vi.advanceTimersByTimeAsync(100)
+
+    // Value should be written to IDB
+    const stored = idbMock.getStore('kv').get('write-test')
+    expect(stored).toBe(JSON.stringify('new-value'))
+  })
+
+  it('.remove() deletes from IDB', async () => {
+    idbMock.getStore('kv').set('del-key', JSON.stringify('value'))
+    const sig = useIndexedDB('del-key', 'default')
+    await vi.runAllTimersAsync()
+
+    sig.remove()
+    expect(sig()).toBe('default')
+
+    // Let the delete happen
+    await vi.runAllTimersAsync()
+  })
+
+  it('.subscribe() works', () => {
+    const sig = useIndexedDB('sub-key', 'a')
+    let called = false
+    const unsub = sig.subscribe(() => {
+      called = true
+    })
+    sig.set('b')
+    expect(called).toBe(true)
+    unsub()
+  })
+
+  it('.direct() is callable', () => {
+    const sig = useIndexedDB('direct-key', 0)
+    // direct() delegates to the underlying signal's direct method
+    expect(typeof sig.direct).toBe('function')
+    sig.direct(() => {})
+  })
+
+  it('handles IDB open error gracefully', async () => {
+    // Override mock to reject
+    ;(globalThis as any).indexedDB = {
+      open() {
+        const request: any = {
+          result: null,
+          error: new Error('IDB blocked'),
+          onupgradeneeded: null,
+          onsuccess: null,
+          onerror: null,
+        }
+        setTimeout(() => request.onerror?.())
+        return request
+      },
+    }
+
+    _resetDBCache()
+    const sig = useIndexedDB('fail-key', 'safe-default')
+    await vi.runAllTimersAsync()
+
+    // Should keep default value
+    expect(sig()).toBe('safe-default')
+  })
+
+  it('custom serializer is used for writes', async () => {
+    const sig = useIndexedDB('custom-ser', { x: 1 }, {
+      serializer: (v) => `CUSTOM:${JSON.stringify(v)}`,
+      debounceMs: 10,
+    })
+
+    sig.set({ x: 2 })
+    await vi.advanceTimersByTimeAsync(50)
+
+    const stored = idbMock.getStore('kv').get('custom-ser')
+    expect(stored).toBe('CUSTOM:{"x":2}')
+  })
+
+  it('custom deserializer is used for reads', async () => {
+    idbMock.getStore('kv').set('custom-de', 'RAW:hello')
+
+    const sig = useIndexedDB('custom-de', '', {
+      deserializer: (s) => s.replace('RAW:', ''),
+    })
+    await vi.runAllTimersAsync()
+
+    expect(sig()).toBe('hello')
+  })
+
+  it('onError callback is called on deserialization failure', async () => {
+    idbMock.getStore('kv').set('bad-json', '{broken')
+
+    const errors: Error[] = []
+    const sig = useIndexedDB('bad-json', 'fallback', {
+      onError: (e) => {
+        errors.push(e)
+        return 'error-recovery'
+      },
+    })
+    await vi.runAllTimersAsync()
+
+    expect(sig()).toBe('error-recovery')
+    expect(errors).toHaveLength(1)
+  })
+
+  it('debounce coalesces multiple writes', async () => {
+    const sig = useIndexedDB('coalesce', 0, { debounceMs: 50 })
+    sig.set(1)
+    sig.set(2)
+    sig.set(3)
+
+    await vi.advanceTimersByTimeAsync(100)
+
+    const stored = idbMock.getStore('kv').get('coalesce')
+    expect(stored).toBe(JSON.stringify(3))
+  })
+
+  it('remove cancels pending debounced write', async () => {
+    const sig = useIndexedDB('remove-cancel', 'default', { debounceMs: 200 })
+    sig.set('pending')
+    sig.remove()
+
+    await vi.advanceTimersByTimeAsync(300)
+
+    expect(sig()).toBe('default')
+  })
+
+  it('flushWrite does nothing when pendingValue is undefined', async () => {
+    const sig = useIndexedDB('no-pending', 'val', { debounceMs: 10 })
+    // Don't set anything — just advance timers
+    await vi.advanceTimersByTimeAsync(50)
+    expect(sig()).toBe('val')
+  })
+})

package/src/tests/session-coverage.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { _resetRegistry, useSessionStorage } from '../index'
+
+describe('useSessionStorage — full coverage', () => {
+  beforeEach(() => {
+    sessionStorage.clear()
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    sessionStorage.clear()
+    _resetRegistry()
+  })
+
+  it('returns default value when key is not in storage', () => {
+    const val = useSessionStorage('step', 0)
+    expect(val()).toBe(0)
+  })
+
+  it('reads existing value from sessionStorage', () => {
+    sessionStorage.setItem('step', JSON.stringify(3))
+    const val = useSessionStorage('step', 0)
+    expect(val()).toBe(3)
+  })
+
+  it('.set() updates signal and sessionStorage', () => {
+    const val = useSessionStorage('step', 0)
+    val.set(5)
+    expect(val()).toBe(5)
+    expect(JSON.parse(sessionStorage.getItem('step')!)).toBe(5)
+  })
+
+  it('.update() works', () => {
+    const val = useSessionStorage('count', 10)
+    val.update((n) => n + 5)
+    expect(val()).toBe(15)
+  })
+
+  it('.remove() resets to default and clears sessionStorage', () => {
+    const val = useSessionStorage('temp', 'default')
+    val.set('modified')
+    val.remove()
+    expect(val()).toBe('default')
+    expect(sessionStorage.getItem('temp')).toBeNull()
+  })
+
+  it('returns same signal for same key', () => {
+    const a = useSessionStorage('key', 'val')
+    const b = useSessionStorage('key', 'val')
+    expect(a).toBe(b)
+  })
+
+  it('handles corrupt storage values gracefully', () => {
+    sessionStorage.setItem('broken', 'not valid json{{{')
+    const val = useSessionStorage('broken', 'fallback')
+    expect(val()).toBe('fallback')
+  })
+
+  it('custom serializer/deserializer', () => {
+    const val = useSessionStorage('date', new Date('2025-01-01'), {
+      serializer: (d) => d.toISOString(),
+      deserializer: (s) => new Date(s),
+    })
+    expect(val()).toEqual(new Date('2025-01-01'))
+  })
+
+  it('.debug() and .label work', () => {
+    const val = useSessionStorage('debug', 'test')
+    expect(val.debug().value).toBe('test')
+    val.label = 'session-sig'
+    expect(val.label).toBe('session-sig')
+  })
+
+  it('.peek() reads without subscribing', () => {
+    const val = useSessionStorage('peek', 'hello')
+    expect(val.peek()).toBe('hello')
+  })
+
+  it('onError callback is called on deserialization failure', () => {
+    sessionStorage.setItem('bad', '{invalid')
+    const errors: Error[] = []
+    const val = useSessionStorage('bad', 'default', {
+      onError: (e) => {
+        errors.push(e)
+        return 'recovered'
+      },
+    })
+    expect(val()).toBe('recovered')
+    expect(errors).toHaveLength(1)
+  })
+})

package/src/tests/utils-coverage.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest'
+import { deserialize, getWebStorage, serialize } from '../utils'
+
+describe('serialize', () => {
+  it('uses JSON.stringify by default', () => {
+    expect(serialize({ a: 1 })).toBe('{"a":1}')
+  })
+
+  it('uses custom serializer when provided', () => {
+    const custom = (v: number) => `NUM:${v}`
+    expect(serialize(42, custom)).toBe('NUM:42')
+  })
+})
+
+describe('deserialize', () => {
+  it('uses JSON.parse by default', () => {
+    expect(deserialize('"hello"', 'default')).toBe('hello')
+  })
+
+  it('uses custom deserializer when provided', () => {
+    const custom = (s: string) => s.toUpperCase()
+    expect(deserialize('hello', 'default', custom)).toBe('HELLO')
+  })
+
+  it('returns default value on parse error', () => {
+    expect(deserialize('{broken', 'fallback')).toBe('fallback')
+  })
+
+  it('calls onError and returns its result on parse error', () => {
+    const onError = (e: Error) => 'recovered'
+    expect(deserialize('{broken', 'default', undefined, onError)).toBe('recovered')
+  })
+
+  it('returns default when onError returns undefined', () => {
+    const onError = (_e: Error) => undefined
+    expect(deserialize('{broken', 'fallback', undefined, onError)).toBe('fallback')
+  })
+})
+
+describe('getWebStorage', () => {
+  it('returns localStorage for "local"', () => {
+    const storage = getWebStorage('local')
+    expect(storage).toBe(window.localStorage)
+  })
+
+  it('returns sessionStorage for "session"', () => {
+    const storage = getWebStorage('session')
+    expect(storage).toBe(window.sessionStorage)
+  })
+
+  it('returns null when storage throws (e.g. private browsing)', () => {
+    const originalLocalStorage = window.localStorage
+    // Mock localStorage to throw on setItem
+    Object.defineProperty(window, 'localStorage', {
+      value: {
+        setItem: () => {
+          throw new Error('Quota exceeded')
+        },
+        removeItem: () => {},
+        getItem: () => null,
+      },
+      writable: true,
+      configurable: true,
+    })
+
+    const result = getWebStorage('local')
+    expect(result).toBeNull()
+
+    // Restore
+    Object.defineProperty(window, 'localStorage', {
+      value: originalLocalStorage,
+      writable: true,
+      configurable: true,
+    })
+  })
+})