@pyreon/storage 0.11.4 → 0.11.6

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

@@ -1,12 +1,12 @@
-import { effect } from "@pyreon/reactivity"
-import { afterEach, beforeEach, describe, expect, it } from "vitest"
-import { _resetRegistry, useStorage } from "../index"
+import { effect } from '@pyreon/reactivity'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { _resetRegistry, useStorage } from '../index'
 
 /**
  * Tests for cross-tab synchronization via the native `storage` event.
  * These test the listener that useStorage attaches to `window.addEventListener('storage', ...)`.
  */
-describe("useStorage — cross-tab sync", () => {
+describe('useStorage — cross-tab sync', () => {
   beforeEach(() => {
     localStorage.clear()
     _resetRegistry()
@@ -17,93 +17,93 @@ describe("useStorage — cross-tab sync", () => {
     _resetRegistry()
   })
 
-  it("updates signal when storage event fires with a new value", () => {
-    const theme = useStorage("theme", "light")
-    expect(theme()).toBe("light")
+  it('updates signal when storage event fires with a new value', () => {
+    const theme = useStorage('theme', 'light')
+    expect(theme()).toBe('light')
 
     window.dispatchEvent(
-      Object.assign(new Event("storage"), {
-        key: "theme",
-        newValue: JSON.stringify("dark"),
+      Object.assign(new Event('storage'), {
+        key: 'theme',
+        newValue: JSON.stringify('dark'),
         storageArea: localStorage,
       }),
     )
 
-    expect(theme()).toBe("dark")
+    expect(theme()).toBe('dark')
   })
 
-  it("resets to default when storage event fires with null newValue (key deleted)", () => {
-    const theme = useStorage("theme", "light")
-    theme.set("dark")
-    expect(theme()).toBe("dark")
+  it('resets to default when storage event fires with null newValue (key deleted)', () => {
+    const theme = useStorage('theme', 'light')
+    theme.set('dark')
+    expect(theme()).toBe('dark')
 
     window.dispatchEvent(
-      Object.assign(new Event("storage"), {
-        key: "theme",
+      Object.assign(new Event('storage'), {
+        key: 'theme',
         newValue: null,
         storageArea: localStorage,
       }),
     )
 
-    expect(theme()).toBe("light")
+    expect(theme()).toBe('light')
   })
 
-  it("ignores storage events for unregistered keys", () => {
-    const theme = useStorage("theme", "light")
+  it('ignores storage events for unregistered keys', () => {
+    const theme = useStorage('theme', 'light')
 
     window.dispatchEvent(
-      Object.assign(new Event("storage"), {
-        key: "unrelated-key",
-        newValue: JSON.stringify("value"),
+      Object.assign(new Event('storage'), {
+        key: 'unrelated-key',
+        newValue: JSON.stringify('value'),
         storageArea: localStorage,
       }),
     )
 
-    expect(theme()).toBe("light")
+    expect(theme()).toBe('light')
   })
 
-  it("ignores storage events with null key", () => {
-    const theme = useStorage("theme", "light")
+  it('ignores storage events with null key', () => {
+    const theme = useStorage('theme', 'light')
 
     window.dispatchEvent(
-      Object.assign(new Event("storage"), {
+      Object.assign(new Event('storage'), {
         key: null,
         newValue: null,
         storageArea: localStorage,
       }),
     )
 
-    expect(theme()).toBe("light")
+    expect(theme()).toBe('light')
   })
 
-  it("triggers reactive effect on cross-tab update", () => {
-    const theme = useStorage("theme", "light")
+  it('triggers reactive effect on cross-tab update', () => {
+    const theme = useStorage('theme', 'light')
     const values: string[] = []
 
     effect(() => {
       values.push(theme())
     })
 
-    expect(values).toEqual(["light"])
+    expect(values).toEqual(['light'])
 
     window.dispatchEvent(
-      Object.assign(new Event("storage"), {
-        key: "theme",
-        newValue: JSON.stringify("dark"),
+      Object.assign(new Event('storage'), {
+        key: 'theme',
+        newValue: JSON.stringify('dark'),
         storageArea: localStorage,
       }),
     )
 
-    expect(values).toEqual(["light", "dark"])
+    expect(values).toEqual(['light', 'dark'])
   })
 
-  it("handles corrupt JSON in storage event gracefully (falls back to default)", () => {
-    const count = useStorage("count", 0)
+  it('handles corrupt JSON in storage event gracefully (falls back to default)', () => {
+    const count = useStorage('count', 0)
 
     window.dispatchEvent(
-      Object.assign(new Event("storage"), {
-        key: "count",
-        newValue: "{invalid json",
+      Object.assign(new Event('storage'), {
+        key: 'count',
+        newValue: '{invalid json',
         storageArea: localStorage,
       }),
     )
@@ -112,27 +112,27 @@ describe("useStorage — cross-tab sync", () => {
     expect(count()).toBe(0)
   })
 
-  it("syncs object values across tabs", () => {
-    const prefs = useStorage("prefs", { sidebar: true, density: "comfortable" })
+  it('syncs object values across tabs', () => {
+    const prefs = useStorage('prefs', { sidebar: true, density: 'comfortable' })
 
     window.dispatchEvent(
-      Object.assign(new Event("storage"), {
-        key: "prefs",
-        newValue: JSON.stringify({ sidebar: false, density: "compact" }),
+      Object.assign(new Event('storage'), {
+        key: 'prefs',
+        newValue: JSON.stringify({ sidebar: false, density: 'compact' }),
         storageArea: localStorage,
       }),
     )
 
-    expect(prefs()).toEqual({ sidebar: false, density: "compact" })
+    expect(prefs()).toEqual({ sidebar: false, density: 'compact' })
   })
 
-  it("handles multiple rapid storage events", () => {
-    const count = useStorage("count", 0)
+  it('handles multiple rapid storage events', () => {
+    const count = useStorage('count', 0)
 
     for (let i = 1; i <= 5; i++) {
       window.dispatchEvent(
-        Object.assign(new Event("storage"), {
-          key: "count",
+        Object.assign(new Event('storage'), {
+          key: 'count',
           newValue: JSON.stringify(i),
           storageArea: localStorage,
         }),
@@ -142,19 +142,19 @@ describe("useStorage — cross-tab sync", () => {
     expect(count()).toBe(5)
   })
 
-  it("cross-tab sync works independently for different keys", () => {
-    const theme = useStorage("theme", "light")
-    const lang = useStorage("lang", "en")
+  it('cross-tab sync works independently for different keys', () => {
+    const theme = useStorage('theme', 'light')
+    const lang = useStorage('lang', 'en')
 
     window.dispatchEvent(
-      Object.assign(new Event("storage"), {
-        key: "theme",
-        newValue: JSON.stringify("dark"),
+      Object.assign(new Event('storage'), {
+        key: 'theme',
+        newValue: JSON.stringify('dark'),
         storageArea: localStorage,
       }),
     )
 
-    expect(theme()).toBe("dark")
-    expect(lang()).toBe("en") // unchanged
+    expect(theme()).toBe('dark')
+    expect(lang()).toBe('en') // unchanged
   })
 })

package/src/tests/custom.test.ts

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

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

@@ -1,7 +1,7 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { _resetDBCache, _resetRegistry, useIndexedDB } from "../index"
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { _resetDBCache, _resetRegistry, useIndexedDB } from '../index'
 
-describe("useIndexedDB — debounced writes", () => {
+describe('useIndexedDB — debounced writes', () => {
   beforeEach(() => {
     _resetRegistry()
     _resetDBCache()
@@ -14,81 +14,81 @@ describe("useIndexedDB — debounced writes", () => {
     vi.useRealTimers()
   })
 
-  it("signal updates immediately, IDB write is debounced", () => {
-    const draft = useIndexedDB("debounce-test", "initial", { debounceMs: 50 })
-    draft.set("updated")
+  it('signal updates immediately, IDB write is debounced', () => {
+    const draft = useIndexedDB('debounce-test', 'initial', { debounceMs: 50 })
+    draft.set('updated')
     // Signal is synchronous
-    expect(draft()).toBe("updated")
+    expect(draft()).toBe('updated')
   })
 
-  it("multiple rapid sets coalesce into one write (only last value)", () => {
-    const draft = useIndexedDB("coalesce-test", "", { debounceMs: 100 })
-    draft.set("first")
-    draft.set("second")
-    draft.set("third")
+  it('multiple rapid sets coalesce into one write (only last value)', () => {
+    const draft = useIndexedDB('coalesce-test', '', { debounceMs: 100 })
+    draft.set('first')
+    draft.set('second')
+    draft.set('third')
 
     // Signal reflects latest immediately
-    expect(draft()).toBe("third")
+    expect(draft()).toBe('third')
   })
 
-  it("custom debounceMs is respected", () => {
-    const fast = useIndexedDB("fast", "", { debounceMs: 10 })
-    fast.set("value")
-    expect(fast()).toBe("value")
+  it('custom debounceMs is respected', () => {
+    const fast = useIndexedDB('fast', '', { debounceMs: 10 })
+    fast.set('value')
+    expect(fast()).toBe('value')
 
-    const slow = useIndexedDB("slow", "", { debounceMs: 5000 })
-    slow.set("value")
-    expect(slow()).toBe("value")
+    const slow = useIndexedDB('slow', '', { debounceMs: 5000 })
+    slow.set('value')
+    expect(slow()).toBe('value')
   })
 
-  it("default debounceMs is 100", () => {
-    const sig = useIndexedDB("default-debounce", "initial")
-    sig.set("value")
-    expect(sig()).toBe("value")
+  it('default debounceMs is 100', () => {
+    const sig = useIndexedDB('default-debounce', 'initial')
+    sig.set('value')
+    expect(sig()).toBe('value')
   })
 
-  it("update() also triggers debounced write", () => {
-    const count = useIndexedDB("update-debounce", 0, { debounceMs: 50 })
+  it('update() also triggers debounced write', () => {
+    const count = useIndexedDB('update-debounce', 0, { debounceMs: 50 })
     count.update((n) => n + 1)
     count.update((n) => n + 1)
     count.update((n) => n + 1)
     expect(count()).toBe(3)
   })
 
-  it("remove() cancels pending debounced write", () => {
-    const draft = useIndexedDB("remove-cancel", "default", { debounceMs: 200 })
-    draft.set("pending-value")
+  it('remove() cancels pending debounced write', () => {
+    const draft = useIndexedDB('remove-cancel', 'default', { debounceMs: 200 })
+    draft.set('pending-value')
     draft.remove()
-    expect(draft()).toBe("default")
+    expect(draft()).toBe('default')
   })
 
-  it("custom dbName and storeName options", () => {
-    const sig = useIndexedDB("custom-db-key", "val", {
-      dbName: "my-app-db",
-      storeName: "my-store",
+  it('custom dbName and storeName options', () => {
+    const sig = useIndexedDB('custom-db-key', 'val', {
+      dbName: 'my-app-db',
+      storeName: 'my-store',
     })
-    sig.set("updated")
-    expect(sig()).toBe("updated")
+    sig.set('updated')
+    expect(sig()).toBe('updated')
   })
 
-  it("custom serializer/deserializer with IndexedDB", () => {
-    const sig = useIndexedDB("date-idb", new Date("2025-01-01"), {
+  it('custom serializer/deserializer with IndexedDB', () => {
+    const sig = useIndexedDB('date-idb', new Date('2025-01-01'), {
       serializer: (d) => d.toISOString(),
       deserializer: (s) => new Date(s),
       debounceMs: 50,
     })
-    const newDate = new Date("2025-06-15")
+    const newDate = new Date('2025-06-15')
     sig.set(newDate)
-    expect(sig().toISOString()).toBe("2025-06-15T00:00:00.000Z")
+    expect(sig().toISOString()).toBe('2025-06-15T00:00:00.000Z')
   })
 
-  it(".subscribe() works with debounced signals", () => {
-    const sig = useIndexedDB("sub-idb", "a", { debounceMs: 50 })
+  it('.subscribe() works with debounced signals', () => {
+    const sig = useIndexedDB('sub-idb', 'a', { debounceMs: 50 })
     let called = false
     const unsub = sig.subscribe(() => {
       called = true
     })
-    sig.set("b")
+    sig.set('b')
     expect(called).toBe(true)
     unsub()
   })