@mhmo91/schmancy 0.9.28 → 0.10.2

package/src/store/storage-manager.ts

@@ -1,269 +0,0 @@
-import { IStorageManager, StorageType, StoreError } from './types'
-
-/**
- * Custom JSON replacer to handle Map and Set serialization
- *
- * LIMITATIONS:
- * - Only supports Maps with string/number/primitive keys
- * - Object keys will be stringified and may collide (e.g., {id: 1} and {id: 2} both become "[object Object]")
- * - Circular references are not supported (JSON.stringify limitation)
- *
- * @example
- * ```typescript
- * // ✅ Supported
- * new Map([['key', 'value'], [123, 'number-key']])
- *
- * // ❌ Not supported (object keys will become strings)
- * new Map([[{id: 1}, 'value']])
- * ```
- */
-function mapSetReplacer(_key: string, value: unknown): unknown {
-	if (value instanceof Map) {
-		return {
-			__type: 'Map',
-			entries: Array.from(value.entries()),
-		}
-	}
-	if (value instanceof Set) {
-		return {
-			__type: 'Set',
-			values: Array.from(value.values()),
-		}
-	}
-	return value
-}
-
-/**
- * Custom JSON reviver to handle Map and Set deserialization
- *
- * Includes validation to prevent malformed data or __type injection attacks.
- * Invalid structures are ignored and returned as-is.
- */
-function mapSetReviver(_key: string, value: unknown): unknown {
-	if (value && typeof value === 'object' && '__type' in value) {
-		const typed = value as { __type: string; entries?: unknown[]; values?: unknown[] }
-
-		// Validate and reconstruct Map
-		if (typed.__type === 'Map') {
-			if (!Array.isArray(typed.entries)) {
-				console.warn('Invalid Map structure in storage (entries not an array), ignoring')
-				return value
-			}
-			// Validate all entries are [key, value] pairs
-			const isValid = typed.entries.every(e => Array.isArray(e) && e.length === 2)
-			if (!isValid) {
-				console.warn('Invalid Map structure in storage (malformed entries), ignoring')
-				return value
-			}
-			return new Map(typed.entries as Iterable<readonly [unknown, unknown]>)
-		}
-
-		// Validate and reconstruct Set
-		if (typed.__type === 'Set') {
-			if (!Array.isArray(typed.values)) {
-				console.warn('Invalid Set structure in storage (values not an array), ignoring')
-				return value
-			}
-			return new Set(typed.values)
-		}
-
-		// Unknown __type marker, log warning and ignore
-		console.warn(`Unknown __type "${typed.__type}" in storage, ignoring`)
-	}
-	return value
-}
-
-/**
- * Memory storage manager implementation
- */
-export class MemoryStorageManager<T> implements IStorageManager<T> {
-	private data: T | null = null
-
-	async load(): Promise<T | null> {
-		return this.data
-	}
-
-	async save(state: T): Promise<void> {
-		this.data = state
-	}
-
-	async clear(): Promise<void> {
-		this.data = null
-	}
-}
-
-/**
- * Local storage manager implementation
- */
-export class LocalStorageManager<T> implements IStorageManager<T> {
-	constructor(private key: string) {}
-
-	async load(): Promise<T | null> {
-		try {
-			const data = localStorage.getItem(this.key)
-			return data ? JSON.parse(data, mapSetReviver) : null
-		} catch (err) {
-			console.error(`Failed to load from localStorage (${this.key}):`, err)
-			return null
-		}
-	}
-
-	async save(state: T): Promise<void> {
-		try {
-			localStorage.setItem(this.key, JSON.stringify(state, mapSetReplacer))
-		} catch (err) {
-			console.error(`Failed to save to localStorage (${this.key}):`, err)
-			throw new StoreError<unknown>(`Failed to save to localStorage (${this.key})`, err)
-		}
-	}
-
-	async clear(): Promise<void> {
-		localStorage.removeItem(this.key)
-	}
-}
-
-/**
- * Session storage manager implementation
- */
-export class SessionStorageManager<T> implements IStorageManager<T> {
-	constructor(private key: string) {}
-
-	async load(): Promise<T | null> {
-		try {
-			const data = sessionStorage.getItem(this.key)
-			return data ? JSON.parse(data, mapSetReviver) : null
-		} catch (err) {
-			console.error(`Failed to load from sessionStorage (${this.key}):`, err)
-			return null
-		}
-	}
-
-	async save(state: T): Promise<void> {
-		try {
-			sessionStorage.setItem(this.key, JSON.stringify(state, mapSetReplacer))
-		} catch (err) {
-			console.error(`Failed to save to sessionStorage (${this.key}):`, err)
-			throw new StoreError<unknown>(`Failed to save to sessionStorage (${this.key})`, err)
-		}
-	}
-
-	async clear(): Promise<void> {
-		sessionStorage.removeItem(this.key)
-	}
-}
-
-/**
- * IndexedDB storage manager implementation with better error typing
- */
-export class IndexedDBStorageManager<T> implements IStorageManager<T> {
-	private static DB_NAME = 'StoreDB'
-	private static STORE_NAME = 'states'
-	private static DB_VERSION = 1
-
-	constructor(private key: string) {}
-
-	private openDB(): Promise<IDBDatabase> {
-		return new Promise<IDBDatabase>((resolve, reject) => {
-			const request = indexedDB.open(IndexedDBStorageManager.DB_NAME, IndexedDBStorageManager.DB_VERSION)
-
-			request.onupgradeneeded = () => {
-				const db = request.result
-				if (!db.objectStoreNames.contains(IndexedDBStorageManager.STORE_NAME)) {
-					db.createObjectStore(IndexedDBStorageManager.STORE_NAME)
-				}
-			}
-
-			request.onsuccess = () => resolve(request.result)
-			request.onerror = () => reject(request.error)
-		})
-	}
-
-	async load(): Promise<T | null> {
-		try {
-			const db = await this.openDB()
-			return new Promise<T | null>((resolve, reject) => {
-				const transaction = db.transaction(IndexedDBStorageManager.STORE_NAME, 'readonly')
-				const store = transaction.objectStore(IndexedDBStorageManager.STORE_NAME)
-				const request = store.get(this.key)
-
-				request.onsuccess = () => {
-					db.close()
-					resolve(request.result || null)
-				}
-
-				request.onerror = () => {
-					db.close()
-					reject(request.error)
-				}
-			})
-		} catch (err) {
-			console.error(`Failed to load from IndexedDB (${this.key}):`, err)
-			return null
-		}
-	}
-
-	async save(state: T): Promise<void> {
-		try {
-			const db = await this.openDB()
-			return new Promise<void>((resolve, reject) => {
-				const transaction = db.transaction(IndexedDBStorageManager.STORE_NAME, 'readwrite')
-				const store = transaction.objectStore(IndexedDBStorageManager.STORE_NAME)
-				const request = store.put(state, this.key)
-
-				request.onsuccess = () => {
-					db.close()
-					resolve()
-				}
-
-				request.onerror = () => {
-					db.close()
-					reject(request.error)
-				}
-			})
-		} catch (err) {
-			console.error(`Failed to save to IndexedDB (${this.key}):`, err)
-			throw new StoreError<unknown>(`Failed to save to IndexedDB (${this.key})`, err)
-		}
-	}
-
-	async clear(): Promise<void> {
-		try {
-			const db = await this.openDB()
-			return new Promise<void>((resolve, reject) => {
-				const transaction = db.transaction(IndexedDBStorageManager.STORE_NAME, 'readwrite')
-				const store = transaction.objectStore(IndexedDBStorageManager.STORE_NAME)
-				const request = store.delete(this.key)
-
-				request.onsuccess = () => {
-					db.close()
-					resolve()
-				}
-
-				request.onerror = () => {
-					db.close()
-					reject(request.error)
-				}
-			})
-		} catch (err) {
-			console.error(`Failed to clear from IndexedDB (${this.key}):`, err)
-			throw new StoreError<unknown>(`Failed to clear from IndexedDB (${this.key})`, err)
-		}
-	}
-}
-
-/**
- * Factory function to create the appropriate storage manager
- */
-export function createStorageManager<T>(type: StorageType, key: string): IStorageManager<T> {
-	switch (type) {
-		case 'local':
-			return new LocalStorageManager<T>(key)
-		case 'session':
-			return new SessionStorageManager<T>(key)
-		case 'indexeddb':
-			return new IndexedDBStorageManager<T>(key)
-		case 'memory':
-		default:
-			return new MemoryStorageManager<T>()
-	}
-}

package/src/store/store.class.ts

@@ -1,239 +0,0 @@
-// src/store/store.class.ts - Fixed version
-
-import { produce, enableMapSet, immerable } from 'immer'
-import { BehaviorSubject, Subject } from 'rxjs'
-import { createStorageManager } from './storage-manager'
-import { IStorageManager, StorageType, StoreError } from './types'
-
-// Enable Map and Set support for Immer
-enableMapSet()
-
-/**
- * Base store class to handle common functionality between store types
- * Now with Immer integration for immutability
- */
-export abstract class BaseStore<T> {
-	// Mark the class as immerable to allow Immer to create drafts
-	[immerable] = true
-
-	// State tracking
-	protected _ready: boolean = false
-	protected _destroy$ = new Subject<void>()
-
-	// Observable streams
-	public $: BehaviorSubject<T>
-	public error$ = new BehaviorSubject<StoreError | null>(null)
-
-	// Default value for the store
-	public readonly defaultValue: T
-
-	// Storage manager
-	protected storage: IStorageManager<T>
-
-	/**
-	 * Get store ready state
-	 */
-	public get ready(): boolean {
-		return this._ready
-	}
-
-	/**
-	 * Set store ready state
-	 */
-	public set ready(value: boolean) {
-		this._ready = value
-		this.updateState(this.$.value)
-	}
-
-	/**
-	 * Get the current value
-	 */
-	public get value(): T {
-		return this.$.getValue()
-	}
-
-	/**
-	 * Initialize the base store
-	 * @param storageType Storage type to use
-	 * @param key Unique key for the store
-	 * @param defaultValue Default/initial value
-	 */
-	constructor(
-		protected storageType: StorageType,
-		protected key: string,
-		defaultValue: T,
-	) {
-		// Before using produce, ensure the input is draftable
-		// This ensures Immer won't throw an error on non-draftable values
-		let safeDefaultValue: T
-
-		if (defaultValue instanceof Map) {
-			// For Maps, create a new Map instance
-			safeDefaultValue = new Map(defaultValue) as unknown as T
-		} else if (Array.isArray(defaultValue)) {
-			// For arrays, create a new array instance
-			safeDefaultValue = [...defaultValue] as unknown as T
-		} else if (defaultValue && typeof defaultValue === 'object') {
-			// For objects, create a shallow copy
-			safeDefaultValue = { ...defaultValue } as T
-		} else {
-			// For primitives or other non-draftable types
-			safeDefaultValue = defaultValue
-		}
-
-		// Make an immutable copy of the default value when possible
-		try {
-			this.defaultValue = this.isImmerDraftable(safeDefaultValue)
-				? produce(safeDefaultValue, draft => draft)
-				: safeDefaultValue
-		} catch (error) {
-			console.warn(`[BaseStore] Unable to produce immutable copy of defaultValue:`, error)
-			this.defaultValue = safeDefaultValue
-		}
-
-		// Initialize BehaviorSubject with the default value
-		this.$ = new BehaviorSubject<T>(this.defaultValue)
-		this.storage = createStorageManager<T>(storageType, key)
-
-		// Set ready immediately for memory storage
-		if (storageType === 'memory') {
-			this._ready = true
-		} else {
-			// Initialize from storage for persistent stores
-			this.initializeFromStorage()
-		}
-	}
-
-	/**
-	 * Check if a value can be safely used with Immer's produce
-	 */
-	protected isImmerDraftable(value: any): boolean {
-		return (
-			value !== null &&
-			typeof value === 'object' &&
-			(Array.isArray(value) ||
-				value instanceof Map ||
-				value instanceof Set ||
-				Object.getPrototypeOf(value) === Object.prototype ||
-				value[immerable] === true)
-		)
-	}
-
-	/**
-	 * Cleanup method for all store types
-	 */
-	public destroy(): void {
-		this._destroy$.next()
-		this._destroy$.complete()
-		this.$.complete()
-		this.error$.complete()
-	}
-
-	/**
-	 * Replace the entire store state immutably
-	 */
-	public replace(newValue: T): void {
-		try {
-			// Use Immer to create an immutable copy if possible
-			const nextState = this.isImmerDraftable(newValue) ? produce(newValue, draft => draft) : newValue
-
-			this.updateState(nextState)
-		} catch (error) {
-			const storeError = new StoreError<unknown>(`Error replacing state in ${this.key}`, error)
-			this.error$.next(storeError)
-			console.error(storeError)
-
-			// Fallback to direct assignment
-			this.updateState(newValue)
-		}
-	}
-
-	/**
-	 * Reset to default value - to be implemented by subclasses
-	 */
-	public abstract clear(): void
-
-	/**
-	 * Update the state with proper error handling and immutability
-	 */
-	protected updateState(newValue: T): void {
-		try {
-			// Ensure immutability by creating a fresh copy with Immer when possible
-			let nextState: T
-
-			if (this.isImmerDraftable(newValue)) {
-				nextState = produce(newValue, draft => draft)
-			} else {
-				nextState = newValue
-			}
-
-			this.$.next(nextState)
-
-			// Persist to storage
-			if (this.storageType !== 'memory') {
-				this.persistToStorage(nextState).catch(err => {
-					const error = new StoreError<unknown>(`Error saving to ${this.storageType} storage for ${this.key}`, err)
-					this.error$.next(error)
-					console.error(error)
-				})
-			}
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error updating state in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-
-			// Fallback to direct update
-			this.$.next(newValue)
-		}
-	}
-
-	/**
-	 * Initialize the store from persistent storage
-	 */
-	protected async initializeFromStorage(): Promise<void> {
-		try {
-			const storedValue = await this.storage.load()
-			if (storedValue) {
-				// Process and update state with the stored value
-				const processedValue = this.processStoredValue(storedValue)
-
-				try {
-					// Only use Immer if the value is draftable
-					const immutableValue = this.isImmerDraftable(processedValue)
-						? produce(processedValue, draft => draft)
-						: processedValue
-
-					this.updateState(immutableValue)
-				} catch (error) {
-					console.warn(`[BaseStore] Unable to create immutable copy, using value directly:`, error)
-					this.updateState(processedValue)
-				}
-			}
-			this._ready = true
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error loading from ${this.storageType} storage for ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-			this._ready = true // Mark as ready even if loading fails
-		}
-	}
-
-	/**
-	 * Process stored value (can be overridden by subclasses)
-	 */
-	protected processStoredValue(storedValue: T): T {
-		return storedValue
-	}
-
-	/**
-	 * Persist state to storage
-	 */
-	protected async persistToStorage(state: T): Promise<void> {
-		return this.storage.save(state)
-	}
-
-	/**
-	 * Setup development tools
-	 */
-	protected abstract setupDevTools(): void
-}