@pyreon/storage 0.9.0 → 0.11.0

package/src/tests/local.test.ts

@@ -1,8 +1,8 @@
-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"
 
-describe('useStorage (localStorage)', () => {
+describe("useStorage (localStorage)", () => {
   beforeEach(() => {
     localStorage.clear()
     _resetRegistry()
@@ -13,203 +13,203 @@ describe('useStorage (localStorage)', () => {
     _resetRegistry()
   })
 
-  it('returns default value when key is not in storage', () => {
-    const theme = useStorage('theme', 'light')
-    expect(theme()).toBe('light')
+  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("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(".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)
+  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)
+    expect(JSON.parse(localStorage.getItem("count")!)).toBe(1)
   })
 
-  it('.peek() reads without subscribing', () => {
-    const theme = useStorage('theme', 'light')
-    expect(theme.peek()).toBe('light')
+  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')
+  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()
+    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')
+  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')
+  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' })
+  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({
+    prefs.set({ sidebar: false, density: "compact" })
+    expect(prefs()).toEqual({ sidebar: false, density: "compact" })
+    expect(JSON.parse(localStorage.getItem("prefs")!)).toEqual({
       sidebar: false,
-      density: 'compact',
+      density: "compact",
     })
   })
 
-  it('works with arrays', () => {
-    const items = useStorage('items', [1, 2, 3])
+  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)
+  it("works with booleans", () => {
+    const flag = useStorage("flag", false)
     flag.set(true)
     expect(flag()).toBe(true)
-    expect(JSON.parse(localStorage.getItem('flag')!)).toBe(true)
+    expect(JSON.parse(localStorage.getItem("flag")!)).toBe(true)
   })
 
-  it('works with numbers', () => {
-    const count = useStorage('count', 42)
+  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("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')
+  it("calls onError when deserialization fails", () => {
+    localStorage.setItem("broken", "{invalid")
     const errors: Error[] = []
-    const value = useStorage('broken', 'default', {
+    const value = useStorage("broken", "default", {
       onError: (e) => {
         errors.push(e)
         return undefined
       },
     })
-    expect(value()).toBe('default')
+    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',
+  it("onError can return a custom fallback", () => {
+    localStorage.setItem("broken", "{invalid")
+    const value = useStorage("broken", "default", {
+      onError: () => "custom-fallback",
     })
-    expect(value()).toBe('custom-fallback')
+    expect(value()).toBe("custom-fallback")
   })
 
-  it('custom serializer/deserializer work', () => {
-    const date = useStorage('date', new Date('2025-01-01'), {
+  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'))
+    expect(date()).toEqual(new Date("2025-01-01"))
 
-    const newDate = new Date('2025-06-15')
+    const newDate = new Date("2025-06-15")
     date.set(newDate)
-    expect(localStorage.getItem('date')).toBe('2025-06-15T00:00:00.000Z')
+    expect(localStorage.getItem("date")).toBe("2025-06-15T00:00:00.000Z")
   })
 
-  it('is reactive — works in effects', () => {
-    const theme = useStorage('theme', 'light')
+  it("is reactive — works in effects", () => {
+    const theme = useStorage("theme", "light")
     const values: string[] = []
 
     effect(() => {
       values.push(theme())
     })
 
-    expect(values).toEqual(['light'])
+    expect(values).toEqual(["light"])
 
-    theme.set('dark')
-    expect(values).toEqual(['light', 'dark'])
+    theme.set("dark")
+    expect(values).toEqual(["light", "dark"])
   })
 
-  it('.subscribe() works', () => {
-    const theme = useStorage('theme', 'light')
+  it(".subscribe() works", () => {
+    const theme = useStorage("theme", "light")
     let callCount = 0
     const unsub = theme.subscribe(() => {
       callCount++
     })
 
-    theme.set('dark')
+    theme.set("dark")
     expect(callCount).toBeGreaterThanOrEqual(1)
     unsub()
   })
 
-  it('.debug() returns debug info', () => {
-    const theme = useStorage('theme', 'light')
+  it(".debug() returns debug info", () => {
+    const theme = useStorage("theme", "light")
     const info = theme.debug()
-    expect(info.value).toBe('light')
+    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(".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')
+  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'),
+    const event = Object.assign(new Event("storage"), {
+      key: "theme",
+      newValue: JSON.stringify("dark"),
       storageArea: localStorage,
     })
     window.dispatchEvent(event)
 
-    expect(theme()).toBe('dark')
+    expect(theme()).toBe("dark")
   })
 
-  it('cross-tab sync with null newValue resets to default', () => {
-    const theme = useStorage('theme', 'light')
-    theme.set('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',
+    const event = Object.assign(new Event("storage"), {
+      key: "theme",
       newValue: null,
       storageArea: localStorage,
     })
     window.dispatchEvent(event)
 
-    expect(theme()).toBe('light')
+    expect(theme()).toBe("light")
   })
 
-  it('after remove(), a new useStorage call creates a fresh signal', () => {
-    const a = useStorage('temp', 'first')
-    a.set('modified')
+  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')
+    const b = useStorage("temp", "second")
+    expect(b()).toBe("second")
     expect(a).not.toBe(b)
   })
 })

package/src/tests/session.test.ts

@@ -1,7 +1,7 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { _resetRegistry, useSessionStorage } from '../index'
+import { afterEach, beforeEach, describe, expect, it } from "vitest"
+import { _resetRegistry, useSessionStorage } from "../index"
 
-describe('useSessionStorage', () => {
+describe("useSessionStorage", () => {
   beforeEach(() => {
     sessionStorage.clear()
     _resetRegistry()
@@ -12,56 +12,56 @@ describe('useSessionStorage', () => {
     _resetRegistry()
   })
 
-  it('returns default value when key is not in storage', () => {
-    const step = useSessionStorage('step', 0)
+  it("returns default value when key is not in storage", () => {
+    const step = useSessionStorage("step", 0)
     expect(step()).toBe(0)
   })
 
-  it('reads existing value from sessionStorage', () => {
-    sessionStorage.setItem('step', JSON.stringify(3))
-    const step = useSessionStorage('step', 0)
+  it("reads existing value from sessionStorage", () => {
+    sessionStorage.setItem("step", JSON.stringify(3))
+    const step = useSessionStorage("step", 0)
     expect(step()).toBe(3)
   })
 
-  it('.set() updates signal and sessionStorage', () => {
-    const step = useSessionStorage('step', 0)
+  it(".set() updates signal and sessionStorage", () => {
+    const step = useSessionStorage("step", 0)
     step.set(5)
     expect(step()).toBe(5)
-    expect(JSON.parse(sessionStorage.getItem('step')!)).toBe(5)
+    expect(JSON.parse(sessionStorage.getItem("step")!)).toBe(5)
   })
 
-  it('.remove() clears from storage and resets to default', () => {
-    const step = useSessionStorage('step', 0)
+  it(".remove() clears from storage and resets to default", () => {
+    const step = useSessionStorage("step", 0)
     step.set(5)
     step.remove()
     expect(step()).toBe(0)
-    expect(sessionStorage.getItem('step')).toBeNull()
+    expect(sessionStorage.getItem("step")).toBeNull()
   })
 
-  it('returns same signal instance for same key', () => {
-    const a = useSessionStorage('step', 0)
-    const b = useSessionStorage('step', 0)
+  it("returns same signal instance for same key", () => {
+    const a = useSessionStorage("step", 0)
+    const b = useSessionStorage("step", 0)
     expect(a).toBe(b)
   })
 
-  it('works with objects', () => {
-    const form = useSessionStorage('form-draft', { name: '', email: '' })
-    form.set({ name: 'Alice', email: 'alice@example.com' })
-    expect(form()).toEqual({ name: 'Alice', email: 'alice@example.com' })
+  it("works with objects", () => {
+    const form = useSessionStorage("form-draft", { name: "", email: "" })
+    form.set({ name: "Alice", email: "alice@example.com" })
+    expect(form()).toEqual({ name: "Alice", email: "alice@example.com" })
   })
 
-  it('handles corrupt storage values gracefully', () => {
-    sessionStorage.setItem('broken', '{{invalid')
-    const value = useSessionStorage('broken', 'default')
-    expect(value()).toBe('default')
+  it("handles corrupt storage values gracefully", () => {
+    sessionStorage.setItem("broken", "{{invalid")
+    const value = useSessionStorage("broken", "default")
+    expect(value()).toBe("default")
   })
 
-  it('does not share signals with localStorage', async () => {
-    const { useStorage } = await import('../local')
-    const local = useStorage('key', 'local-default')
-    const session = useSessionStorage('key', 'session-default')
+  it("does not share signals with localStorage", async () => {
+    const { useStorage } = await import("../local")
+    const local = useStorage("key", "local-default")
+    const session = useSessionStorage("key", "session-default")
     expect(local).not.toBe(session)
-    expect(local()).toBe('local-default')
-    expect(session()).toBe('session-default')
+    expect(local()).toBe("local-default")
+    expect(session()).toBe("session-default")
   })
 })

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Signal } from '@pyreon/reactivity'
+import type { Signal } from "@pyreon/reactivity"
 
 // ─── Storage Signal ──────────────────────────────────────────────────────────
 
@@ -42,7 +42,7 @@ export interface CookieOptions<T> extends StorageOptions<T> {
   /** HTTPS only — default: false */
   secure?: boolean
   /** SameSite policy — default: 'lax' */
-  sameSite?: 'strict' | 'lax' | 'none'
+  sameSite?: "strict" | "lax" | "none"
 }
 
 // ─── IndexedDB Options ───────────────────────────────────────────────────────

package/src/utils.ts

@@ -1,4 +1,4 @@
-import type { StorageOptions } from './types'
+import type { StorageOptions } from "./types"
 
 // ─── SSR Detection ───────────────────────────────────────────────────────────
 
@@ -6,7 +6,7 @@ import type { StorageOptions } from './types'
  * Check if we're running in a browser environment.
  */
 export function isBrowser(): boolean {
-  return typeof window !== 'undefined' && typeof document !== 'undefined'
+  return typeof window !== "undefined" && typeof document !== "undefined"
 }
 
 // ─── Serialization ───────────────────────────────────────────────────────────
@@ -14,10 +14,7 @@ export function isBrowser(): boolean {
 /**
  * Serialize a value to a string for storage.
  */
-export function serialize<T>(
-  value: T,
-  serializer?: StorageOptions<T>['serializer'],
-): string {
+export function serialize<T>(value: T, serializer?: StorageOptions<T>["serializer"]): string {
   if (serializer) return serializer(value)
   return JSON.stringify(value)
 }
@@ -29,8 +26,8 @@ export function serialize<T>(
 export function deserialize<T>(
   raw: string,
   defaultValue: T,
-  deserializer?: StorageOptions<T>['deserializer'],
-  onError?: StorageOptions<T>['onError'],
+  deserializer?: StorageOptions<T>["deserializer"],
+  onError?: StorageOptions<T>["onError"],
 ): T {
   try {
     if (deserializer) return deserializer(raw)
@@ -50,14 +47,13 @@ export function deserialize<T>(
  * Safely get a Web Storage instance (localStorage or sessionStorage).
  * Returns null if not available (SSR, security restrictions, etc.).
  */
-export function getWebStorage(type: 'local' | 'session'): Storage | null {
+export function getWebStorage(type: "local" | "session"): Storage | null {
   if (!isBrowser()) return null
   try {
-    const storage =
-      type === 'local' ? window.localStorage : window.sessionStorage
+    const storage = type === "local" ? window.localStorage : window.sessionStorage
     // Test that it actually works (can throw in private browsing)
-    const testKey = '__pyreon_storage_test__'
-    storage.setItem(testKey, '1')
+    const testKey = "__pyreon_storage_test__"
+    storage.setItem(testKey, "1")
     storage.removeItem(testKey)
     return storage
   } catch {