@mhmo91/schmancy 0.9.28 → 0.10.2

package/src/store/context-create.ts

@@ -1,284 +0,0 @@
-// src/store/context-create.ts - Fixed version
-
-import { SchmancyArrayStore } from './context-array'
-import SchmancyCollectionStore from './context-collection'
-import { SchmancyStoreObject } from './context-object'
-import { IArrayStore, ICollectionStore, IStore, StorageType } from './types'
-
-/**
- * Type guard to check if an object is empty
- */
-function isEmptyObject(obj: unknown): boolean {
-	if (typeof obj !== 'object' || obj === null) {
-		return false
-	}
-	return Object.keys(obj).length === 0
-}
-
-/**
- * Type guard for Map objects
- */
-function isMap<K, V>(value: unknown): value is Map<K, V> {
-	return value instanceof Map
-}
-
-/**
- * Type guard for Array objects
- */
-function isArray<T>(value: unknown): value is Array<T> {
-	return Array.isArray(value)
-}
-
-/**
- * Type guard for plain objects (not arrays, maps, null, etc.)
- */
-function isPlainObject(value: unknown): boolean {
-	return (
-		value !== null &&
-		typeof value === 'object' &&
-		!Array.isArray(value) &&
-		!(value instanceof Map) &&
-		!(value instanceof Set) &&
-		!(value instanceof Date) &&
-		!(value instanceof RegExp) &&
-		Object.getPrototypeOf(value) === Object.prototype
-	)
-}
-
-/**
- * Creates a regular object store with better typing and error handling
- */
-function createObjectStore<T extends Record<string, any>>(
-	initialData: T,
-	storage: StorageType,
-	key: string,
-): IStore<T> & SchmancyStoreObject<T> {
-	try {
-		// Validate storage type
-		if (storage === 'indexeddb') {
-			console.warn(`IndexedDB storage is not optimal for plain objects. Using 'local' instead for key: ${key}`)
-			storage = 'local'
-		}
-
-		// Ensure initialData is a plain object
-		if (!isPlainObject(initialData)) {
-			console.warn(`Initial data is not a plain object. Converting to object for key: ${key}`)
-			initialData = { ...initialData } as T
-		}
-
-		// Create the store instance
-		const store = SchmancyStoreObject.getInstance<T>(storage, key, initialData)
-
-		// Initialize with provided data if store is empty
-		if (isEmptyObject(store.value)) {
-			store.set({ ...initialData }) // Use spread to create a copy
-		}
-
-		return store
-	} catch (err) {
-		console.error(`Failed to create object store for key: ${key}`, err)
-		// Fall back to a basic implementation that won't throw
-		const fallbackStore = SchmancyStoreObject.getInstance<T>(
-			'memory', // Fallback to memory storage
-			`${key}-fallback`,
-			initialData,
-		)
-		console.warn(`Using fallback memory store for key: ${key}`)
-		return fallbackStore
-	}
-}
-
-/**
- * Creates a collection store with better typing and error handling
- */
-function createCollectionStore<V>(
-	initialData: Map<string, V>,
-	storage: StorageType,
-	key: string,
-): ICollectionStore<V> & SchmancyCollectionStore<V> {
-	try {
-		// Create the store instance
-		const store = SchmancyCollectionStore.getInstance(storage, key, initialData)
-
-		// Initialize with provided data if store is empty
-		if (!store.value.size) {
-			// Create a new Map instance to avoid modifying the input
-			store.replace(new Map(initialData))
-		}
-
-		return store
-	} catch (err) {
-		console.error(`Failed to create collection store for key: ${key}`, err)
-		// Fall back to a basic implementation that won't throw
-		const fallbackStore = SchmancyCollectionStore.getInstance<V>(
-			'memory', // Fallback to memory storage
-			`${key}-fallback`,
-			new Map(initialData),
-		)
-		console.warn(`Using fallback memory store for key: ${key}`)
-		return fallbackStore
-	}
-}
-
-/**
- * Creates an array store with better typing and error handling
- */
-function createArrayStore<T>(
-	initialData: T[],
-	storage: StorageType,
-	key: string,
-): IArrayStore<T> & SchmancyArrayStore<T> {
-	try {
-		// Create the store instance
-		const store = SchmancyArrayStore.getInstance(storage, key, initialData)
-
-		// Initialize with provided data if store is empty
-		if (!store.value.length) {
-			// Create a new array instance to avoid modifying the input
-			store.replace([...initialData])
-		}
-
-		return store
-	} catch (err) {
-		console.error(`Failed to create array store for key: ${key}`, err)
-		// Fall back to a basic implementation that won't throw
-		const fallbackStore = SchmancyArrayStore.getInstance<T>(
-			'memory', // Fallback to memory storage
-			`${key}-fallback`,
-			[...initialData],
-		)
-		console.warn(`Using fallback memory store for key: ${key}`)
-		return fallbackStore
-	}
-}
-
-// Function overloads for better type inference
-/**
- * Creates a context for managing object state
- * @param initialData The initial object data
- * @param storage Storage type to use
- * @param key Unique key for the store
- * @returns A store instance for the object
- */
-export function createContext<T extends Record<string, any>>(
-	initialData: T,
-	storage: StorageType,
-	key: string,
-): IStore<T> & SchmancyStoreObject<T>
-
-/**
- * Creates a context for managing collection state
- * @param initialData The initial Map collection
- * @param storage Storage type to use
- * @param key Unique key for the store
- * @returns A collection store instance
- */
-export function createContext<V>(
-	initialData: Map<string, V>,
-	storage: StorageType,
-	key: string,
-): ICollectionStore<V> & SchmancyCollectionStore<V>
-
-/**
- * Creates a context for managing array state
- * @param initialData The initial array
- * @param storage Storage type to use
- * @param key Unique key for the store
- * @returns An array store instance
- */
-export function createContext<T>(
-	initialData: T[],
-	storage: StorageType,
-	key: string,
-): IArrayStore<T> & SchmancyArrayStore<T>
-
-/**
- * Implementation of the createContext function with complete type checking
- * and robust error handling
- */
-export function createContext<T extends Record<string, any> | Map<string, any> | any[]>(
-	initialData: T,
-	storage: StorageType,
-	key: string,
-):
-	| (IStore<T> & SchmancyStoreObject<T>)
-	| (ICollectionStore<any> & SchmancyCollectionStore<any>)
-	| (IArrayStore<any> & SchmancyArrayStore<any>) {
-	try {
-		// Validate input
-		if (initialData === null || initialData === undefined) {
-			console.error('Initial data cannot be null or undefined')
-			// Provide a sensible default based on type expected
-			if (key.includes('collection') || key.includes('map')) {
-				initialData = new Map() as unknown as T
-			} else if (key.includes('array') || key.includes('list')) {
-				initialData = [] as unknown as T
-			} else {
-				initialData = {} as T
-			}
-		}
-
-		// Determine store type based on input data with improved type checking
-		if (isMap<string, any>(initialData)) {
-			return createCollectionStore<any>(initialData, storage, key)
-		} else if (isArray<any>(initialData)) {
-			return createArrayStore<any>(initialData, storage, key)
-		} else if (typeof initialData === 'object') {
-			return createObjectStore<any>(initialData as Record<string, any>, storage, key)
-		} else {
-			// Handle non-object data by wrapping it
-			console.warn(`Initial data must be an object, array, or Map. Got ${typeof initialData}. Creating object wrapper.`)
-			return createObjectStore<any>({ value: initialData } as Record<string, any>, storage, key)
-		}
-	} catch (error) {
-		// Last-resort error handling
-		console.error(`Fatal error creating context for ${key}:`, error)
-
-		// Create an emergency fallback store that won't throw
-		return createObjectStore<any>(
-			typeof initialData === 'object' && initialData !== null ? { ...initialData } : { value: initialData },
-			'memory',
-			`emergency-fallback-${key}`,
-		)
-	}
-}
-
-/**
- * Creates an array context with simplified API and type inference
- * @param initialData The initial array data
- * @param key Unique key for the store
- * @param storage Storage type to use (defaults to 'local')
- * @returns An array store instance
- */
-export function createArrayContext<T>(
-	initialData: T[] = [],
-	key: string,
-	storage: StorageType = 'local',
-): IArrayStore<T> & SchmancyArrayStore<T> {
-	try {
-		return createContext<T>(initialData, storage, key)
-	} catch (err) {
-		console.error(`Failed to create array context for key: ${key}`, err)
-		// Return a fallback store
-		return createArrayStore<T>(initialData, 'memory', `${key}-fallback`)
-	}
-}
-
-/**
- * Creates a testable array context
- * @param initialData The initial array data
- * @param key Unique key for the store
- * @returns An array store that uses memory storage
- */
-export function createTestArrayContext<T>(
-	initialData: T[] = [],
-	key: string = 'test-array',
-): IArrayStore<T> & SchmancyArrayStore<T> {
-	try {
-		return createContext<T>(initialData, 'memory', key)
-	} catch (err) {
-		console.error(`Failed to create test array context for key: ${key}`, err)
-		// Return a fallback store with a different key
-		return createArrayStore<T>(initialData, 'memory', `${key}-emergency-fallback`)
-	}
-}

package/src/store/context-object.ts

@@ -1,298 +0,0 @@
-// src/store/context-object.ts - Fixed version
-
-import { BaseStore } from './store.class'
-import { IStore, StorageType, StoreError } from './types'
-import { produce, Draft, castDraft, immerable } from 'immer'
-
-/**
- * Enhanced store object with better TypeScript support and immutability
- * Now extends BaseStore for common functionality and uses Immer
- */
-export class SchmancyStoreObject<T extends Record<string, any>> extends BaseStore<T> implements IStore<T> {
-	// Mark as immerable so Immer can create drafts of this class
-	[immerable] = true
-
-	public static type = 'object'
-
-	// Static map to hold instances with proper typing
-	private static instances: Map<string, SchmancyStoreObject<any>> = new Map()
-
-	/**
-	 * Static method to get or create an instance with strong typing
-	 */
-	public static getInstance<T extends Record<string, any>>(
-		storage: StorageType,
-		key: string,
-		defaultValue: T,
-	): SchmancyStoreObject<T> {
-		const instanceKey = `${storage}:${key}`
-		if (!this.instances.has(instanceKey)) {
-			this.instances.set(instanceKey, new SchmancyStoreObject<T>(storage, key, defaultValue))
-		}
-		return this.instances.get(instanceKey) as SchmancyStoreObject<T>
-	}
-
-	/**
-	 * Set state with proper typing and immutability using Immer
-	 */
-	public set(value: Partial<T>, merge: boolean = true): void {
-		try {
-			if (!this.isImmerDraftable(this.value)) {
-				// If current value isn't draftable, handle directly
-				const nextState = merge ? { ...this.value, ...value } : (value as T)
-
-				this.updateState(nextState)
-				this.error$.next(null)
-				return
-			}
-
-			// Use Immer to create an immutable update
-			const nextState = produce(this.value, draft => {
-				if (merge) {
-					// Handle null/undefined value safely
-					if (value === null || value === undefined) {
-						return
-					}
-
-					// Merge new values into existing state
-					// Use castDraft to properly type the value for the draft context
-					try {
-						Object.assign(draft, castDraft(value) as Draft<Partial<T>>)
-					} catch (err) {
-						console.warn('[SchmancyStoreObject] Error casting to draft, falling back to direct assign:', err)
-						// Fallback to direct property assignment
-						Object.keys(value).forEach(key => {
-							;(draft as any)[key] = (value as any)[key]
-						})
-					}
-				} else {
-					// For complete replacement, return a completely new object
-					// This is handled specially by Immer
-					try {
-						return castDraft(value as T) as Draft<T>
-					} catch (err) {
-						console.warn('[SchmancyStoreObject] Error casting to draft, returning value directly:', err)
-						return value as unknown as Draft<T>
-					}
-				}
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null) // Clear any previous errors
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error updating store: ${this.key}`, err, { value, merge })
-			this.error$.next(error)
-			console.error(error)
-
-			// Fallback to direct update
-			try {
-				const fallbackState = merge ? { ...this.value, ...value } : (value as T)
-				this.updateState(fallbackState)
-			} catch (fallbackErr) {
-				console.error('Failed fallback update:', fallbackErr)
-			}
-		}
-	}
-
-	/**
-	 * Reset the store to its default value
-	 */
-	public clear(): void {
-		try {
-			// Create a fresh copy of the default value using Immer
-			if (this.isImmerDraftable(this.defaultValue)) {
-				const freshDefaultValue = produce(this.defaultValue, draft => draft)
-				this.set(freshDefaultValue, false)
-			} else {
-				// For non-draftable values, use direct replacement
-				this.set(this.defaultValue as any, false)
-			}
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error clearing store: ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-
-			// Fallback to direct reset
-			this.updateState(this.defaultValue)
-		}
-	}
-
-	/**
-	 * Delete a specific key from the store with type checking and immutability
-	 */
-	public delete<K extends keyof T>(key: K): void {
-		try {
-			if (!this.isImmerDraftable(this.value)) {
-				// Handle non-draftable objects directly
-				const nextState = { ...this.value }
-				delete nextState[key]
-				this.updateState(nextState as T)
-				return
-			}
-
-			// Use Immer to create an immutable update that removes the key
-			const nextState = produce(this.value, draft => {
-				// Use type assertion to tell TypeScript this is safe
-				delete draft[key as keyof Draft<T>]
-			})
-
-			this.updateState(nextState)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error deleting key ${String(key)} from store: ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-
-			// Fallback to direct modification
-			try {
-				const fallbackState = { ...this.value }
-				delete fallbackState[key]
-				this.updateState(fallbackState as T)
-			} catch (fallbackErr) {
-				console.error('Failed fallback delete:', fallbackErr)
-			}
-		}
-	}
-
-	/**
-	 * Update a nested property at a specific path
-	 * @param path Dot-separated path to the property (e.g., 'user.profile.name')
-	 * @param value New value to set
-	 */
-	public setPath(path: string, value: any): void {
-		try {
-			if (!path) {
-				console.warn('[SchmancyStoreObject] Empty path provided to setPath')
-				return
-			}
-
-			if (!this.isImmerDraftable(this.value)) {
-				// Handle non-draftable objects with direct modification
-				const parts = path.split('.')
-				const nextState = { ...this.value }
-				let current: any = nextState
-
-				for (let i = 0; i < parts.length - 1; i++) {
-					const part = parts[i]
-					if (current[part] === undefined) {
-						current[part] = {}
-					} else if (typeof current[part] !== 'object' || current[part] === null) {
-						current[part] = {}
-					}
-					current = current[part]
-				}
-
-				current[parts[parts.length - 1]] = value
-				this.updateState(nextState)
-				return
-			}
-
-			// Use Immer for immutable deep updates
-			const nextState = produce(this.value, draft => {
-				const parts = path.split('.')
-				let current: any = draft
-
-				// Navigate to the parent of the property we want to update
-				for (let i = 0; i < parts.length - 1; i++) {
-					const part = parts[i]
-
-					// Create the path if it doesn't exist
-					if (current[part] === undefined) {
-						current[part] = {}
-					} else if (typeof current[part] !== 'object' || current[part] === null) {
-						// Convert to object if it's not one already
-						current[part] = {}
-					}
-
-					current = current[part]
-				}
-
-				// Set the value at the final path segment
-				const lastPart = parts[parts.length - 1]
-				try {
-					current[lastPart] = castDraft(value)
-				} catch (err) {
-					console.warn('[SchmancyStoreObject] Error casting to draft, setting directly:', err)
-					current[lastPart] = value
-				}
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error setting path ${path} in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-
-			// Fallback to direct path setting
-			try {
-				const parts = path.split('.')
-				const nextState = { ...this.value }
-				let current: any = nextState
-
-				for (let i = 0; i < parts.length - 1; i++) {
-					const part = parts[i]
-					if (current[part] === undefined) {
-						current[part] = {}
-					} else if (typeof current[part] !== 'object' || current[part] === null) {
-						current[part] = {}
-					}
-					current = current[part]
-				}
-
-				current[parts[parts.length - 1]] = value
-				this.updateState(nextState)
-			} catch (fallbackErr) {
-				console.error('Failed fallback setPath:', fallbackErr)
-			}
-		}
-	}
-
-	/**
-	 * Process stored value by merging with default value
-	 */
-	protected processStoredValue(storedValue: T): T {
-		try {
-			// Use Immer to create a clean merged state if possible
-			if (this.isImmerDraftable(this.defaultValue) && this.isImmerDraftable(storedValue)) {
-				return produce(this.defaultValue, draft => {
-					Object.assign(draft, castDraft(storedValue) as Draft<T>)
-				})
-			} else {
-				// Otherwise use a standard merge
-				return { ...this.defaultValue, ...storedValue }
-			}
-		} catch (err) {
-			console.warn(`[SchmancyStoreObject] Error processing stored value, returning as-is:`, err)
-			return storedValue
-		}
-	}
-
-	/**
-	 * Setup development tools for debugging
-	 */
-	protected setupDevTools(): void {
-		if (typeof window !== 'undefined') {
-			// Add to global store registry
-			;(window as any).__STORES__ = (window as any).__STORES__ || {}
-			;(window as any).__STORES__[this.key] = {
-				getState: () => this.value,
-				set: this.set.bind(this),
-				delete: this.delete.bind(this),
-				clear: this.clear.bind(this),
-				setPath: this.setPath.bind(this),
-				subscribe: (callback: (state: T) => void) => {
-					const subscription = this.$.subscribe(callback)
-					return () => subscription.unsubscribe()
-				},
-			}
-		}
-	}
-
-	/**
-	 * Inherit isImmerDraftable from BaseStore, but also check for [immerable]
-	 */
-	protected isImmerDraftable(value: any): boolean {
-		// Use the parent implementation and add our own checks
-		return value !== null && typeof value === 'object' && (super.isImmerDraftable(value) || value[immerable] === true)
-	}
-}