@pyreon/storage 0.11.4 → 0.11.6

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,9 +11,9 @@ 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 =
@@ -43,10 +43,10 @@ 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
@@ -60,9 +60,9 @@ export function useStorage<T>(
   const sig = signal<T>(initialValue)
 
   // Create the storage signal by extending the base signal
-  const storageSig = createStorageSignal(sig, key, defaultValue, "local", options)
+  const storageSig = createStorageSignal(sig, key, defaultValue, 'local', options)
 
-  setEntry("local", key, storageSig, defaultValue)
+  setEntry('local', key, storageSig, defaultValue)
   attachStorageListener()
 
   return storageSig
@@ -78,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)
@@ -92,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 ─────────────────────────────────────────────────────────
 

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,10 +24,10 @@ 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
@@ -39,9 +39,9 @@ export function useSessionStorage<T>(
   }
 
   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-remove.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import {
   _resetRegistry,
   clearStorage,
@@ -6,9 +6,9 @@ import {
   useCookie,
   useSessionStorage,
   useStorage,
-} from "../index"
+} from '../index'
 
-describe("removeStorage — comprehensive", () => {
+describe('removeStorage — comprehensive', () => {
   beforeEach(() => {
     localStorage.clear()
     sessionStorage.clear()
@@ -21,63 +21,63 @@ describe("removeStorage — comprehensive", () => {
     _resetRegistry()
   })
 
-  it("removes localStorage entry and resets signal to default", () => {
-    const theme = useStorage("theme", "light")
-    theme.set("dark")
-    removeStorage("theme")
-    expect(theme()).toBe("light")
-    expect(localStorage.getItem("theme")).toBeNull()
+  it('removes localStorage entry and resets signal to default', () => {
+    const theme = useStorage('theme', 'light')
+    theme.set('dark')
+    removeStorage('theme')
+    expect(theme()).toBe('light')
+    expect(localStorage.getItem('theme')).toBeNull()
   })
 
-  it("removes sessionStorage entry", () => {
-    const step = useSessionStorage("step", 0)
+  it('removes sessionStorage entry', () => {
+    const step = useSessionStorage('step', 0)
     step.set(5)
-    removeStorage("step", { type: "session" })
+    removeStorage('step', { type: 'session' })
     expect(step()).toBe(0)
-    expect(sessionStorage.getItem("step")).toBeNull()
+    expect(sessionStorage.getItem('step')).toBeNull()
   })
 
-  it("removes cookie entry", () => {
-    const locale = useCookie("locale", "en")
-    locale.set("de")
-    removeStorage("locale", { type: "cookie" })
-    expect(locale()).toBe("en")
+  it('removes cookie entry', () => {
+    const locale = useCookie('locale', 'en')
+    locale.set('de')
+    removeStorage('locale', { type: 'cookie' })
+    expect(locale()).toBe('en')
   })
 
-  it("removes raw localStorage entry without a signal", () => {
-    localStorage.setItem("orphan", "value")
-    removeStorage("orphan")
-    expect(localStorage.getItem("orphan")).toBeNull()
+  it('removes raw localStorage entry without a signal', () => {
+    localStorage.setItem('orphan', 'value')
+    removeStorage('orphan')
+    expect(localStorage.getItem('orphan')).toBeNull()
   })
 
-  it("removes raw sessionStorage entry without a signal", () => {
-    sessionStorage.setItem("orphan", "value")
-    removeStorage("orphan", { type: "session" })
-    expect(sessionStorage.getItem("orphan")).toBeNull()
+  it('removes raw sessionStorage entry without a signal', () => {
+    sessionStorage.setItem('orphan', 'value')
+    removeStorage('orphan', { type: 'session' })
+    expect(sessionStorage.getItem('orphan')).toBeNull()
   })
 
-  it("removes cookie without a registered signal (no throw)", () => {
-    expect(() => removeStorage("nonexistent", { type: "cookie" })).not.toThrow()
+  it('removes cookie without a registered signal (no throw)', () => {
+    expect(() => removeStorage('nonexistent', { type: 'cookie' })).not.toThrow()
   })
 
-  it("defaults to localStorage when no type specified", () => {
-    localStorage.setItem("default-type", "val")
-    removeStorage("default-type")
-    expect(localStorage.getItem("default-type")).toBeNull()
+  it('defaults to localStorage when no type specified', () => {
+    localStorage.setItem('default-type', 'val')
+    removeStorage('default-type')
+    expect(localStorage.getItem('default-type')).toBeNull()
   })
 
-  it("after removeStorage, a new useStorage call creates fresh signal", () => {
-    const a = useStorage("resettable", "first")
-    a.set("modified")
-    removeStorage("resettable")
+  it('after removeStorage, a new useStorage call creates fresh signal', () => {
+    const a = useStorage('resettable', 'first')
+    a.set('modified')
+    removeStorage('resettable')
 
-    const b = useStorage("resettable", "second")
-    expect(b()).toBe("second")
+    const b = useStorage('resettable', 'second')
+    expect(b()).toBe('second')
     expect(a).not.toBe(b)
   })
 })
 
-describe("clearStorage — comprehensive", () => {
+describe('clearStorage — comprehensive', () => {
   beforeEach(() => {
     localStorage.clear()
     sessionStorage.clear()
@@ -90,10 +90,10 @@ describe("clearStorage — comprehensive", () => {
     _resetRegistry()
   })
 
-  it("clears all managed localStorage entries", () => {
-    const a = useStorage("a", 1)
-    const b = useStorage("b", 2)
-    const c = useStorage("c", 3)
+  it('clears all managed localStorage entries', () => {
+    const a = useStorage('a', 1)
+    const b = useStorage('b', 2)
+    const c = useStorage('c', 3)
     a.set(10)
     b.set(20)
     c.set(30)
@@ -104,55 +104,55 @@ describe("clearStorage — comprehensive", () => {
     expect(c()).toBe(3)
   })
 
-  it("clears all managed sessionStorage entries", () => {
-    const a = useSessionStorage("a", "x")
-    const b = useSessionStorage("b", "y")
-    a.set("modified-a")
-    b.set("modified-b")
+  it('clears all managed sessionStorage entries', () => {
+    const a = useSessionStorage('a', 'x')
+    const b = useSessionStorage('b', 'y')
+    a.set('modified-a')
+    b.set('modified-b')
 
-    clearStorage("session")
-    expect(a()).toBe("x")
-    expect(b()).toBe("y")
+    clearStorage('session')
+    expect(a()).toBe('x')
+    expect(b()).toBe('y')
   })
 
-  it("clears managed cookie entries", () => {
-    const locale = useCookie("locale", "en")
-    locale.set("de")
+  it('clears managed cookie entries', () => {
+    const locale = useCookie('locale', 'en')
+    locale.set('de')
 
-    clearStorage("cookie")
-    expect(locale()).toBe("en")
+    clearStorage('cookie')
+    expect(locale()).toBe('en')
   })
 
   it('clears all backends with "all"', () => {
-    const local = useStorage("local-key", "default")
-    const session = useSessionStorage("session-key", "default")
-    const cookie = useCookie("cookie-key", "default")
-    local.set("changed")
-    session.set("changed")
-    cookie.set("changed")
+    const local = useStorage('local-key', 'default')
+    const session = useSessionStorage('session-key', 'default')
+    const cookie = useCookie('cookie-key', 'default')
+    local.set('changed')
+    session.set('changed')
+    cookie.set('changed')
 
-    clearStorage("all")
-    expect(local()).toBe("default")
-    expect(session()).toBe("default")
-    expect(cookie()).toBe("default")
+    clearStorage('all')
+    expect(local()).toBe('default')
+    expect(session()).toBe('default')
+    expect(cookie()).toBe('default')
   })
 
-  it("clearStorage with no managed entries does not throw", () => {
+  it('clearStorage with no managed entries does not throw', () => {
     expect(() => clearStorage()).not.toThrow()
-    expect(() => clearStorage("session")).not.toThrow()
-    expect(() => clearStorage("cookie")).not.toThrow()
-    expect(() => clearStorage("indexeddb")).not.toThrow()
-    expect(() => clearStorage("all")).not.toThrow()
+    expect(() => clearStorage('session')).not.toThrow()
+    expect(() => clearStorage('cookie')).not.toThrow()
+    expect(() => clearStorage('indexeddb')).not.toThrow()
+    expect(() => clearStorage('all')).not.toThrow()
   })
 
-  it("clearStorage does not affect unmanaged entries", () => {
-    localStorage.setItem("unmanaged", "value")
-    const managed = useStorage("managed", "default")
-    managed.set("changed")
+  it('clearStorage does not affect unmanaged entries', () => {
+    localStorage.setItem('unmanaged', 'value')
+    const managed = useStorage('managed', 'default')
+    managed.set('changed')
 
     clearStorage()
-    expect(managed()).toBe("default")
+    expect(managed()).toBe('default')
     // Unmanaged key should still exist (clearStorage only affects registered signals)
-    expect(localStorage.getItem("unmanaged")).toBe("value")
+    expect(localStorage.getItem('unmanaged')).toBe('value')
   })
 })

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