@mhmo91/schmancy 0.8.6 → 0.9.3

package/src/store/context-create.ts

@@ -0,0 +1,284 @@
+// 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

@@ -0,0 +1,298 @@
+// 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)
+	}
+}