@pyreon/storage 0.11.4 → 0.11.6

package/src/tests/memory-storage.test.ts

@@ -1,8 +1,8 @@
-import { effect } from "@pyreon/reactivity"
-import { afterEach, beforeEach, describe, expect, it } from "vitest"
-import { _resetRegistry, createStorage, useMemoryStorage } from "../index"
+import { effect } from '@pyreon/reactivity'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { _resetRegistry, createStorage, useMemoryStorage } from '../index'
 
-describe("useMemoryStorage", () => {
+describe('useMemoryStorage', () => {
   beforeEach(() => {
     _resetRegistry()
   })
@@ -11,136 +11,136 @@ describe("useMemoryStorage", () => {
     _resetRegistry()
   })
 
-  it("works without any browser storage APIs (SSR-safe)", () => {
-    const sig = useMemoryStorage("ssr-key", "default")
-    expect(sig()).toBe("default")
-    sig.set("updated")
-    expect(sig()).toBe("updated")
+  it('works without any browser storage APIs (SSR-safe)', () => {
+    const sig = useMemoryStorage('ssr-key', 'default')
+    expect(sig()).toBe('default')
+    sig.set('updated')
+    expect(sig()).toBe('updated')
   })
 
-  it("persists values within the same session", () => {
-    const sig = useMemoryStorage("persist-key", "initial")
-    sig.set("saved")
-    expect(sig()).toBe("saved")
+  it('persists values within the same session', () => {
+    const sig = useMemoryStorage('persist-key', 'initial')
+    sig.set('saved')
+    expect(sig()).toBe('saved')
   })
 
-  it("deduplicates signals for same key", () => {
-    const a = useMemoryStorage("dedup", "val")
-    const b = useMemoryStorage("dedup", "val")
+  it('deduplicates signals for same key', () => {
+    const a = useMemoryStorage('dedup', 'val')
+    const b = useMemoryStorage('dedup', 'val')
     expect(a).toBe(b)
   })
 
-  it("returns different signals for different keys", () => {
-    const a = useMemoryStorage("key-a", "val")
-    const b = useMemoryStorage("key-b", "val")
+  it('returns different signals for different keys', () => {
+    const a = useMemoryStorage('key-a', 'val')
+    const b = useMemoryStorage('key-b', 'val')
     expect(a).not.toBe(b)
   })
 
-  it(".remove() resets to default", () => {
-    const sig = useMemoryStorage("removable", "default")
-    sig.set("changed")
+  it('.remove() resets to default', () => {
+    const sig = useMemoryStorage('removable', 'default')
+    sig.set('changed')
     sig.remove()
-    expect(sig()).toBe("default")
+    expect(sig()).toBe('default')
   })
 
-  it("after remove, a new call creates a fresh signal", () => {
-    const a = useMemoryStorage("fresh", "first")
-    a.set("modified")
+  it('after remove, a new call creates a fresh signal', () => {
+    const a = useMemoryStorage('fresh', 'first')
+    a.set('modified')
     a.remove()
 
-    const b = useMemoryStorage("fresh", "second")
-    expect(b()).toBe("second")
+    const b = useMemoryStorage('fresh', 'second')
+    expect(b()).toBe('second')
     expect(a).not.toBe(b)
   })
 
-  it(".update() works", () => {
-    const count = useMemoryStorage("count", 0)
+  it('.update() works', () => {
+    const count = useMemoryStorage('count', 0)
     count.update((n) => n + 1)
     count.update((n) => n + 1)
     expect(count()).toBe(2)
   })
 
-  it(".peek() reads without subscribing", () => {
-    const sig = useMemoryStorage("peek-key", "val")
-    expect(sig.peek()).toBe("val")
+  it('.peek() reads without subscribing', () => {
+    const sig = useMemoryStorage('peek-key', 'val')
+    expect(sig.peek()).toBe('val')
   })
 
-  it("is reactive in effects", () => {
-    const sig = useMemoryStorage("reactive", "a")
+  it('is reactive in effects', () => {
+    const sig = useMemoryStorage('reactive', 'a')
     const values: string[] = []
 
     effect(() => {
       values.push(sig())
     })
 
-    sig.set("b")
-    sig.set("c")
+    sig.set('b')
+    sig.set('c')
 
-    expect(values).toEqual(["a", "b", "c"])
+    expect(values).toEqual(['a', 'b', 'c'])
   })
 
-  it("works with complex objects", () => {
-    const sig = useMemoryStorage("obj", { name: "", items: [] as string[] })
-    sig.set({ name: "test", items: ["a", "b"] })
-    expect(sig()).toEqual({ name: "test", items: ["a", "b"] })
+  it('works with complex objects', () => {
+    const sig = useMemoryStorage('obj', { name: '', items: [] as string[] })
+    sig.set({ name: 'test', items: ['a', 'b'] })
+    expect(sig()).toEqual({ name: 'test', items: ['a', 'b'] })
   })
 
-  it("works with arrays", () => {
-    const sig = useMemoryStorage("arr", [1, 2, 3])
+  it('works with arrays', () => {
+    const sig = useMemoryStorage('arr', [1, 2, 3])
     sig.set([4, 5, 6])
     expect(sig()).toEqual([4, 5, 6])
   })
 
-  it("works with booleans", () => {
-    const sig = useMemoryStorage("bool", false)
+  it('works with booleans', () => {
+    const sig = useMemoryStorage('bool', false)
     sig.set(true)
     expect(sig()).toBe(true)
   })
 
-  it("works with null default", () => {
-    const sig = useMemoryStorage<string | null>("nullable", null)
+  it('works with null default', () => {
+    const sig = useMemoryStorage<string | null>('nullable', null)
     expect(sig()).toBeNull()
-    sig.set("value")
-    expect(sig()).toBe("value")
+    sig.set('value')
+    expect(sig()).toBe('value')
     sig.remove()
     expect(sig()).toBeNull()
   })
 
-  it(".debug() returns debug info", () => {
-    const sig = useMemoryStorage("debug", "test")
-    expect(sig.debug().value).toBe("test")
+  it('.debug() returns debug info', () => {
+    const sig = useMemoryStorage('debug', 'test')
+    expect(sig.debug().value).toBe('test')
   })
 
-  it(".label can be set and read", () => {
-    const sig = useMemoryStorage("label", "val")
-    sig.label = "my-memory-signal"
-    expect(sig.label).toBe("my-memory-signal")
+  it('.label can be set and read', () => {
+    const sig = useMemoryStorage('label', 'val')
+    sig.label = 'my-memory-signal'
+    expect(sig.label).toBe('my-memory-signal')
   })
 
-  it(".subscribe() works", () => {
-    const sig = useMemoryStorage("sub", "a")
+  it('.subscribe() works', () => {
+    const sig = useMemoryStorage('sub', 'a')
     let called = false
     const unsub = sig.subscribe(() => {
       called = true
     })
-    sig.set("b")
+    sig.set('b')
     expect(called).toBe(true)
     unsub()
   })
 
-  it(".direct() works", () => {
-    const sig = useMemoryStorage("dir", "a")
+  it('.direct() works', () => {
+    const sig = useMemoryStorage('dir', 'a')
     let called = false
     const unsub = sig.direct(() => {
       called = true
     })
-    sig.set("b")
+    sig.set('b')
     expect(called).toBe(true)
     unsub()
   })
 })
 
-describe("createStorage — custom backends", () => {
+describe('createStorage — custom backends', () => {
   beforeEach(() => {
     _resetRegistry()
   })
@@ -149,7 +149,7 @@ describe("createStorage — custom backends", () => {
     _resetRegistry()
   })
 
-  it("creates storage with a simple Map backend", () => {
+  it('creates storage with a simple Map backend', () => {
     const store = new Map<string, string>()
     const useCustom = createStorage({
       get: (k) => store.get(k) ?? null,
@@ -157,15 +157,15 @@ describe("createStorage — custom backends", () => {
       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("value")
-    expect(sig()).toBe("value")
-    expect(store.get("key")).toBe(JSON.stringify("value"))
+    sig.set('value')
+    expect(sig()).toBe('value')
+    expect(store.get('key')).toBe(JSON.stringify('value'))
   })
 
-  it("creates a named backend for separate deduplication", () => {
+  it('creates a named backend for separate deduplication', () => {
     const storeA = new Map<string, string>()
     const storeB = new Map<string, string>()
 
@@ -175,7 +175,7 @@ describe("createStorage — custom backends", () => {
         set: (k, v) => storeA.set(k, v),
         remove: (k) => storeA.delete(k),
       },
-      "backend-a",
+      'backend-a',
     )
 
     const useBackendB = createStorage(
@@ -184,19 +184,19 @@ describe("createStorage — custom backends", () => {
         set: (k, v) => storeB.set(k, v),
         remove: (k) => storeB.delete(k),
       },
-      "backend-b",
+      'backend-b',
     )
 
-    const sigA = useBackendA("key", "a-default")
-    const sigB = useBackendB("key", "b-default")
+    const sigA = useBackendA('key', 'a-default')
+    const sigB = useBackendB('key', 'b-default')
 
     // Different backends, same key — should be different signals
     expect(sigA).not.toBe(sigB)
-    expect(sigA()).toBe("a-default")
-    expect(sigB()).toBe("b-default")
+    expect(sigA()).toBe('a-default')
+    expect(sigB()).toBe('b-default')
   })
 
-  it("backend that transforms values (encryption-like)", () => {
+  it('backend that transforms values (encryption-like)', () => {
     // Simple "encryption" — just base64 encode/decode
     const store = new Map<string, string>()
     const useEncrypted = createStorage({
@@ -208,34 +208,34 @@ describe("createStorage — custom backends", () => {
       remove: (k) => store.delete(k),
     })
 
-    const sig = useEncrypted("secret", "default")
-    sig.set("my-secret-value")
+    const sig = useEncrypted('secret', 'default')
+    sig.set('my-secret-value')
 
-    expect(sig()).toBe("my-secret-value")
+    expect(sig()).toBe('my-secret-value')
     // Raw stored value should be base64 encoded
-    const raw = store.get("secret")
-    expect(raw).toBe(btoa(JSON.stringify("my-secret-value")))
+    const raw = store.get('secret')
+    expect(raw).toBe(btoa(JSON.stringify('my-secret-value')))
   })
 
-  it("handles backend.remove() errors gracefully", () => {
+  it('handles backend.remove() errors gracefully', () => {
     const useCustom = createStorage({
       get: () => null,
       set: () => {
         // no-op
       },
       remove: () => {
-        throw new Error("remove failed")
+        throw new Error('remove failed')
       },
     })
 
-    const sig = useCustom("key", "default")
-    sig.set("value")
+    const sig = useCustom('key', 'default')
+    sig.set('value')
     // remove() should not throw
     sig.remove()
-    expect(sig()).toBe("default")
+    expect(sig()).toBe('default')
   })
 
-  it("multiple hooks on same custom backend share deduplication", () => {
+  it('multiple hooks on same custom backend share deduplication', () => {
     const store = new Map<string, string>()
     const useCustom = createStorage(
       {
@@ -243,14 +243,14 @@ describe("createStorage — custom backends", () => {
         set: (k, v) => store.set(k, v),
         remove: (k) => store.delete(k),
       },
-      "shared",
+      'shared',
     )
 
-    const sig1 = useCustom("shared-key", "default")
-    sig1.set("updated")
+    const sig1 = useCustom('shared-key', 'default')
+    sig1.set('updated')
 
-    const sig2 = useCustom("shared-key", "default")
+    const sig2 = useCustom('shared-key', 'default')
     expect(sig1).toBe(sig2) // Same instance
-    expect(sig2()).toBe("updated")
+    expect(sig2()).toBe('updated')
   })
 })

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,7 +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)
 }
@@ -26,8 +26,8 @@ export function serialize<T>(value: T, serializer?: StorageOptions<T>["serialize
 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)
@@ -47,13 +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 {