@pyreon/storage 0.6.0

package/src/tests/cookie.test.ts

@@ -0,0 +1,149 @@
+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()
+    if (name) {
+      // biome-ignore lint/suspicious/noDocumentCookie: test cleanup requires direct cookie access
+      document.cookie = `${name}=; max-age=0; path=/`
+    }
+  }
+}
+
+describe('useCookie', () => {
+  beforeEach(() => {
+    _resetRegistry()
+    clearAllCookies()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+    clearAllCookies()
+  })
+
+  it('returns default value when cookie does not exist', () => {
+    const locale = useCookie('locale', 'en')
+    expect(locale()).toBe('en')
+  })
+
+  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')
+  })
+
+  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')
+    locale.remove()
+    expect(locale()).toBe('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 })
+    prefs.set({ dark: true })
+    expect(prefs()).toEqual({ dark: true })
+  })
+
+  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('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 expires option', () => {
+    const future = new Date(Date.now() + 86400000)
+    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')
+    sig.remove()
+    expect(sig()).toBe('val')
+  })
+
+  it('.subscribe() works', () => {
+    const sig = useCookie('sub', 'a')
+    let called = false
+    const unsub = sig.subscribe(() => {
+      called = true
+    })
+    sig.set('b')
+    expect(called).toBe(true)
+    unsub()
+  })
+
+  it('.direct() works', () => {
+    const sig = useCookie('dir', 'a')
+    let called = false
+    const unsub = sig.direct(() => {
+      called = true
+    })
+    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('.label can be set and read', () => {
+    const sig = useCookie('lbl', 'val')
+    sig.label = 'my-cookie'
+    expect(sig.label).toBe('my-cookie')
+  })
+})
+
+describe('setCookieSource (SSR)', () => {
+  beforeEach(() => {
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+    setCookieSource('')
+  })
+
+  it('stores server cookie string without throwing', () => {
+    setCookieSource('locale=de; theme=dark')
+    expect(() => setCookieSource('foo=bar')).not.toThrow()
+  })
+})

package/src/tests/custom.test.ts

@@ -0,0 +1,207 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { _resetRegistry, createStorage, useMemoryStorage } from '../index'
+
+describe('createStorage', () => {
+  beforeEach(() => {
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+  })
+
+  it('creates a working storage hook from a custom backend', () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage({
+      get: (k) => store.get(k) ?? null,
+      set: (k, v) => store.set(k, v),
+      remove: (k) => store.delete(k),
+    })
+
+    const sig = useCustom('key', 'default')
+    expect(sig()).toBe('default')
+
+    sig.set('updated')
+    expect(sig()).toBe('updated')
+    expect(store.get('key')).toBe(JSON.stringify('updated'))
+  })
+
+  it('reads existing values from the backend', () => {
+    const store = new Map<string, string>()
+    store.set('key', JSON.stringify('existing'))
+
+    const useCustom = createStorage({
+      get: (k) => store.get(k) ?? null,
+      set: (k, v) => store.set(k, v),
+      remove: (k) => store.delete(k),
+    })
+
+    const sig = useCustom('key', 'default')
+    expect(sig()).toBe('existing')
+  })
+
+  it('.remove() clears from backend and resets signal', () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage({
+      get: (k) => store.get(k) ?? null,
+      set: (k, v) => store.set(k, v),
+      remove: (k) => store.delete(k),
+    })
+
+    const sig = useCustom('key', 'default')
+    sig.set('updated')
+    sig.remove()
+
+    expect(sig()).toBe('default')
+    expect(store.has('key')).toBe(false)
+  })
+
+  it('deduplicates signals for same backend + key', () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage(
+      {
+        get: (k) => store.get(k) ?? null,
+        set: (k, v) => store.set(k, v),
+        remove: (k) => store.delete(k),
+      },
+      'test-backend',
+    )
+
+    const a = useCustom('key', 'default')
+    const b = useCustom('key', 'default')
+    expect(a).toBe(b)
+  })
+
+  it('handles backend read errors gracefully', () => {
+    const useCustom = createStorage({
+      get: () => {
+        throw new Error('read failed')
+      },
+      set: () => {
+        // intentional no-op for error test
+      },
+      remove: () => {
+        // intentional no-op for error test
+      },
+    })
+
+    const sig = useCustom('key', 'fallback')
+    expect(sig()).toBe('fallback')
+  })
+
+  it('handles backend write errors gracefully', () => {
+    const useCustom = createStorage({
+      get: () => null,
+      set: () => {
+        throw new Error('write failed')
+      },
+      remove: () => {
+        // intentional no-op for error test
+      },
+    })
+
+    const sig = useCustom('key', 'default')
+    // Should not throw — signal still updates
+    sig.set('new-value')
+    expect(sig()).toBe('new-value')
+  })
+
+  it('.subscribe() delegates to underlying signal', () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage({
+      get: (k) => store.get(k) ?? null,
+      set: (k, v) => store.set(k, v),
+      remove: (k) => store.delete(k),
+    })
+
+    const sig = useCustom('sub-key', 'a')
+    let called = false
+    const unsub = sig.subscribe(() => {
+      called = true
+    })
+    sig.set('b')
+    expect(called).toBe(true)
+    unsub()
+  })
+
+  it('.direct() delegates to underlying signal', () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage({
+      get: (k) => store.get(k) ?? null,
+      set: (k, v) => store.set(k, v),
+      remove: (k) => store.delete(k),
+    })
+
+    const sig = useCustom('dir-key', 'a')
+    let called = false
+    const unsub = sig.direct(() => {
+      called = true
+    })
+    sig.set('b')
+    expect(called).toBe(true)
+    unsub()
+  })
+
+  it('.debug() and .label work', () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage({
+      get: (k) => store.get(k) ?? null,
+      set: (k, v) => store.set(k, v),
+      remove: (k) => store.delete(k),
+    })
+
+    const sig = useCustom('debug-key', 'test')
+    sig.label = 'my-signal'
+    expect(sig.label).toBe('my-signal')
+    expect(sig.debug().value).toBe('test')
+  })
+
+  it('supports custom serializer/deserializer', () => {
+    const store = new Map<string, string>()
+    const useCustom = createStorage({
+      get: (k) => store.get(k) ?? null,
+      set: (k, v) => store.set(k, v),
+      remove: (k) => store.delete(k),
+    })
+
+    const date = useCustom('date', new Date('2025-01-01'), {
+      serializer: (d) => d.toISOString(),
+      deserializer: (s) => new Date(s),
+    })
+
+    const newDate = new Date('2025-06-15')
+    date.set(newDate)
+    expect(date().toISOString()).toBe('2025-06-15T00:00:00.000Z')
+  })
+})
+
+describe('useMemoryStorage', () => {
+  beforeEach(() => {
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+  })
+
+  it('works as an in-memory storage', () => {
+    const sig = useMemoryStorage('key', 'default')
+    expect(sig()).toBe('default')
+
+    sig.set('updated')
+    expect(sig()).toBe('updated')
+  })
+
+  it('deduplicates signals', () => {
+    const a = useMemoryStorage('key', 'default')
+    const b = useMemoryStorage('key', 'default')
+    expect(a).toBe(b)
+  })
+
+  it('.remove() resets to default', () => {
+    const sig = useMemoryStorage('temp', 'initial')
+    sig.set('changed')
+    sig.remove()
+    expect(sig()).toBe('initial')
+  })
+})

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

@@ -0,0 +1,74 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { _resetDBCache, _resetRegistry, useIndexedDB } from '../index'
+
+describe('useIndexedDB', () => {
+  beforeEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+  })
+
+  afterEach(() => {
+    _resetRegistry()
+    _resetDBCache()
+  })
+
+  it('returns default value initially', () => {
+    const draft = useIndexedDB('draft', { title: '', body: '' })
+    // Initially returns default (IDB load is async)
+    expect(draft()).toEqual({ title: '', body: '' })
+  })
+
+  it('.set() updates signal immediately', () => {
+    const draft = useIndexedDB('draft', { title: '', body: '' })
+    draft.set({ title: 'Hello', body: 'World' })
+    expect(draft()).toEqual({ title: 'Hello', body: 'World' })
+  })
+
+  it('.update() updates signal', () => {
+    const count = useIndexedDB('count', 0)
+    count.update((n) => n + 1)
+    expect(count()).toBe(1)
+  })
+
+  it('.peek() reads without subscribing', () => {
+    const draft = useIndexedDB('draft', 'default')
+    expect(draft.peek()).toBe('default')
+  })
+
+  it('.remove() resets to default', () => {
+    const draft = useIndexedDB('draft', 'default')
+    draft.set('modified')
+    draft.remove()
+    expect(draft()).toBe('default')
+  })
+
+  it('returns same signal for same key', () => {
+    const a = useIndexedDB('key', 'value')
+    const b = useIndexedDB('key', 'value')
+    expect(a).toBe(b)
+  })
+
+  it('returns different signals for different keys', () => {
+    const a = useIndexedDB('key1', 'a')
+    const b = useIndexedDB('key2', 'b')
+    expect(a).not.toBe(b)
+  })
+
+  it('.debug() returns debug info', () => {
+    const draft = useIndexedDB('draft', 'test')
+    expect(draft.debug().value).toBe('test')
+  })
+
+  it('.label can be set', () => {
+    const draft = useIndexedDB('draft', '')
+    draft.label = 'draft-signal'
+    expect(draft.label).toBe('draft-signal')
+  })
+
+  it('set updates signal synchronously even though IDB write is async', () => {
+    const draft = useIndexedDB('sync-test', 'default', { debounceMs: 10 })
+    draft.set('immediate')
+    // Signal updates immediately — no need to wait for IDB
+    expect(draft()).toBe('immediate')
+  })
+})

package/src/tests/local.test.ts

@@ -0,0 +1,215 @@
+import { effect } from '@pyreon/reactivity'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { _resetRegistry, useStorage } from '../index'
+
+describe('useStorage (localStorage)', () => {
+  beforeEach(() => {
+    localStorage.clear()
+    _resetRegistry()
+  })
+
+  afterEach(() => {
+    localStorage.clear()
+    _resetRegistry()
+  })
+
+  it('returns default value when key is not in storage', () => {
+    const theme = useStorage('theme', 'light')
+    expect(theme()).toBe('light')
+  })
+
+  it('reads existing value from localStorage', () => {
+    localStorage.setItem('theme', JSON.stringify('dark'))
+    const theme = useStorage('theme', 'light')
+    expect(theme()).toBe('dark')
+  })
+
+  it('.set() updates signal and localStorage', () => {
+    const theme = useStorage('theme', 'light')
+    theme.set('dark')
+    expect(theme()).toBe('dark')
+    expect(JSON.parse(localStorage.getItem('theme')!)).toBe('dark')
+  })
+
+  it('.update() updates signal and localStorage', () => {
+    const count = useStorage('count', 0)
+    count.update((n) => n + 1)
+    expect(count()).toBe(1)
+    expect(JSON.parse(localStorage.getItem('count')!)).toBe(1)
+  })
+
+  it('.peek() reads without subscribing', () => {
+    const theme = useStorage('theme', 'light')
+    expect(theme.peek()).toBe('light')
+  })
+
+  it('.remove() clears from storage and resets to default', () => {
+    const theme = useStorage('theme', 'light')
+    theme.set('dark')
+    expect(theme()).toBe('dark')
+
+    theme.remove()
+    expect(theme()).toBe('light')
+    expect(localStorage.getItem('theme')).toBeNull()
+  })
+
+  it('returns same signal instance for same key (deduplication)', () => {
+    const a = useStorage('theme', 'light')
+    const b = useStorage('theme', 'light')
+    expect(a).toBe(b)
+  })
+
+  it('returns different signals for different keys', () => {
+    const a = useStorage('theme', 'light')
+    const b = useStorage('lang', 'en')
+    expect(a).not.toBe(b)
+  })
+
+  it('works with objects', () => {
+    const prefs = useStorage('prefs', { sidebar: true, density: 'comfortable' })
+    expect(prefs()).toEqual({ sidebar: true, density: 'comfortable' })
+
+    prefs.set({ sidebar: false, density: 'compact' })
+    expect(prefs()).toEqual({ sidebar: false, density: 'compact' })
+    expect(JSON.parse(localStorage.getItem('prefs')!)).toEqual({
+      sidebar: false,
+      density: 'compact',
+    })
+  })
+
+  it('works with arrays', () => {
+    const items = useStorage('items', [1, 2, 3])
+    expect(items()).toEqual([1, 2, 3])
+
+    items.set([4, 5])
+    expect(items()).toEqual([4, 5])
+  })
+
+  it('works with booleans', () => {
+    const flag = useStorage('flag', false)
+    flag.set(true)
+    expect(flag()).toBe(true)
+    expect(JSON.parse(localStorage.getItem('flag')!)).toBe(true)
+  })
+
+  it('works with numbers', () => {
+    const count = useStorage('count', 42)
+    expect(count()).toBe(42)
+  })
+
+  it('handles corrupt storage values gracefully', () => {
+    localStorage.setItem('broken', 'not valid json{{{')
+    const value = useStorage('broken', 'fallback')
+    expect(value()).toBe('fallback')
+  })
+
+  it('calls onError when deserialization fails', () => {
+    localStorage.setItem('broken', '{invalid')
+    const errors: Error[] = []
+    const value = useStorage('broken', 'default', {
+      onError: (e) => {
+        errors.push(e)
+        return undefined
+      },
+    })
+    expect(value()).toBe('default')
+    expect(errors).toHaveLength(1)
+  })
+
+  it('onError can return a custom fallback', () => {
+    localStorage.setItem('broken', '{invalid')
+    const value = useStorage('broken', 'default', {
+      onError: () => 'custom-fallback',
+    })
+    expect(value()).toBe('custom-fallback')
+  })
+
+  it('custom serializer/deserializer work', () => {
+    const date = useStorage('date', new Date('2025-01-01'), {
+      serializer: (d) => d.toISOString(),
+      deserializer: (s) => new Date(s),
+    })
+
+    expect(date()).toEqual(new Date('2025-01-01'))
+
+    const newDate = new Date('2025-06-15')
+    date.set(newDate)
+    expect(localStorage.getItem('date')).toBe('2025-06-15T00:00:00.000Z')
+  })
+
+  it('is reactive — works in effects', () => {
+    const theme = useStorage('theme', 'light')
+    const values: string[] = []
+
+    effect(() => {
+      values.push(theme())
+    })
+
+    expect(values).toEqual(['light'])
+
+    theme.set('dark')
+    expect(values).toEqual(['light', 'dark'])
+  })
+
+  it('.subscribe() works', () => {
+    const theme = useStorage('theme', 'light')
+    let callCount = 0
+    const unsub = theme.subscribe(() => {
+      callCount++
+    })
+
+    theme.set('dark')
+    expect(callCount).toBeGreaterThanOrEqual(1)
+    unsub()
+  })
+
+  it('.debug() returns debug info', () => {
+    const theme = useStorage('theme', 'light')
+    const info = theme.debug()
+    expect(info.value).toBe('light')
+  })
+
+  it('.label can be set and read', () => {
+    const theme = useStorage('theme', 'light')
+    theme.label = 'theme-signal'
+    expect(theme.label).toBe('theme-signal')
+  })
+
+  it('cross-tab sync via storage event', () => {
+    const theme = useStorage('theme', 'light')
+
+    // Simulate storage event from another tab
+    const event = Object.assign(new Event('storage'), {
+      key: 'theme',
+      newValue: JSON.stringify('dark'),
+      storageArea: localStorage,
+    })
+    window.dispatchEvent(event)
+
+    expect(theme()).toBe('dark')
+  })
+
+  it('cross-tab sync with null newValue resets to default', () => {
+    const theme = useStorage('theme', 'light')
+    theme.set('dark')
+
+    const event = Object.assign(new Event('storage'), {
+      key: 'theme',
+      newValue: null,
+      storageArea: localStorage,
+    })
+    window.dispatchEvent(event)
+
+    expect(theme()).toBe('light')
+  })
+
+  it('after remove(), a new useStorage call creates a fresh signal', () => {
+    const a = useStorage('temp', 'first')
+    a.set('modified')
+    a.remove()
+
+    const b = useStorage('temp', 'second')
+    expect(b()).toBe('second')
+    expect(a).not.toBe(b)
+  })
+})