@mhmo91/schmancy 0.9.27 → 0.10.1

package/src/store/context-array.ts

@@ -1,358 +0,0 @@
-// src/store/context-array.ts - Array store implementation with Immer
-import { Draft, castDraft, produce } from 'immer'
-import { throttleTime } from 'rxjs'
-import { BaseStore } from './store.class'
-import { IArrayStore, StorageType, StoreError } from './types'
-
-/**
- * Enhanced array store with TypeScript support and immutability
- * Extends BaseStore for common functionality
- */
-export class SchmancyArrayStore<T = any> extends BaseStore<T[]> implements IArrayStore<T> {
-	public static type = 'array'
-
-	// Static map to hold instances
-	private static instances: Map<string, SchmancyArrayStore<any>> = new Map()
-
-	/**
-	 * Static method to get or create an instance with proper typing
-	 */
-	public static getInstance<T = any>(storage: StorageType, key: string, defaultValue: T[] = []): SchmancyArrayStore<T> {
-		const instanceKey = `${storage}:${key}`
-		if (!this.instances.has(instanceKey)) {
-			this.instances.set(instanceKey, new SchmancyArrayStore<T>(storage, key, defaultValue))
-		}
-		return this.instances.get(instanceKey) as SchmancyArrayStore<T>
-	}
-
-	/**
-	 * Constructor extension to set up persistence
-	 */
-	constructor(storageType: StorageType, key: string, defaultValue: T[] = []) {
-		super(storageType, key, defaultValue)
-
-		// Set up persistence throttling for better performance
-		if (storageType !== 'memory') {
-			this.setupPersistence()
-		}
-	}
-
-	/**
-	 * Set up persistence to storage with throttling
-	 */
-	private setupPersistence(): void {
-		this.$.pipe(throttleTime(100, undefined, { leading: true, trailing: true })).subscribe(currentValue => {
-			this.storage.save(currentValue).catch(err => {
-				const error = new StoreError<unknown>(`Error saving to ${this.storageType} storage for ${this.key}`, err)
-				this.error$.next(error)
-				console.error(error)
-			})
-		})
-	}
-
-	/**
-	 * Add an item to the end of the array
-	 */
-	public push(...items: T[]): void {
-		try {
-			// Use Immer to create a new immutable array
-			const nextState = produce(this.value, draft => {
-				draft.push(...items.map(item => castDraft(item) as Draft<T>))
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null) // Clear any previous errors
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error pushing items in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Remove and return the last item from the array
-	 */
-	public pop(): T | undefined {
-		try {
-			// Get the item before modifying the array
-			const originalItem = this.value.length > 0 ? this.value[this.value.length - 1] : undefined
-
-			// Use Immer to create a new immutable array
-			const nextState = produce(this.value, draft => {
-				draft.pop()
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null) // Clear any previous errors
-			return originalItem
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error popping item from ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-			return undefined
-		}
-	}
-	/**
-	 * Add item(s) to the beginning of the array
-	 */
-	public unshift(...items: T[]): void {
-		try {
-			// Use Immer to create a new immutable array
-			const nextState = produce(this.value, draft => {
-				draft.unshift(...items.map(item => castDraft(item) as Draft<T>))
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error unshifting items in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Remove and return the first item from the array
-	 */
-	public shift(): T | undefined {
-		try {
-			// Get the item before modifying the array
-			const originalItem = this.value.length > 0 ? this.value[0] : undefined
-
-			// Use Immer to create a new immutable array
-			const nextState = produce(this.value, draft => {
-				draft.shift()
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-			return originalItem
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error shifting item from ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-			return undefined
-		}
-	}
-
-	/**
-	 * Update an item at a specific index
-	 */
-	public set(index: number, value: T): void {
-		try {
-			// Use Immer to create a new immutable array
-			const nextState = produce(this.value, draft => {
-				if (index >= 0 && index < draft.length) {
-					draft[index] = castDraft(value) as Draft<T>
-				} else {
-					throw new Error(`Index ${index} out of bounds (length: ${draft.length})`)
-				}
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error setting item at index ${index} in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Get item at a specific index
-	 */
-	public get(index: number): T | undefined {
-		return this.value[index]
-	}
-
-	/**
-	 * Remove items from the array
-	 */
-	public splice(start: number, deleteCount?: number, ...items: T[]): T[] {
-		try {
-			// Get a copy of the current array
-			const originalArray = [...this.value]
-
-			// Perform splice on the copy to get the removed items
-			const removed = originalArray.splice(start, deleteCount ?? 0, ...items)
-
-			// Now use Immer to create the new state with the same changes
-			const nextState = produce(this.value, draft => {
-				draft.splice(start, deleteCount ?? 0, ...items.map(item => castDraft(item) as Draft<T>))
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-			return removed
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error splicing items in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-			return []
-		}
-	}
-
-	/**
-	 * Remove an item by value (first occurrence)
-	 */
-	public remove(item: T, compareFn?: (a: T, b: T) => boolean): boolean {
-		try {
-			const equals = compareFn || ((a, b) => a === b)
-
-			// Find the index in the original array
-			const index = this.value.findIndex(currentItem => equals(currentItem, item))
-
-			// If found, remove using Immer
-			if (index !== -1) {
-				const nextState = produce(this.value, draft => {
-					draft.splice(index, 1)
-				})
-
-				this.updateState(nextState)
-				this.error$.next(null)
-				return true
-			}
-
-			// Item not found
-			this.error$.next(null)
-			return false
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error removing item in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-			return false
-		}
-	}
-
-	/**
-	 * Replace entire array
-	 */
-	public replace(newArray: T[]): void {
-		try {
-			// Create a fresh immutable copy with Immer
-			const nextState = produce(newArray, draft => draft)
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error replacing array in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Filter items in the array
-	 */
-	public filter(predicate: (value: T, index: number, array: T[]) => boolean): void {
-		try {
-			// Filter the original array first
-			const filteredArray = this.value.filter(predicate)
-
-			// Then use Immer to create a new immutable array
-			const nextState = produce(this.value, draft => {
-				// Clear the draft array and fill it with the filtered items
-				draft.length = 0
-				draft.push(...filteredArray.map(item => castDraft(item) as Draft<T>))
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error filtering array in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Map over the array and transform items
-	 */
-	public map<U>(mapper: (value: T, index: number, array: T[]) => U): U[] {
-		return this.value.map(mapper)
-	}
-
-	/**
-	 * Sort the array in place
-	 */
-	public sort(compareFn?: (a: T, b: T) => number): void {
-		try {
-			// Create a copy of the current array and apply the sort operation
-			const sortedArray = [...this.value].sort(compareFn)
-
-			// Use Immer to create a new immutable array that matches the sorted array
-			const nextState = produce(this.value, draft => {
-				// Clear the array and refill it with the sorted items
-				draft.length = 0
-				draft.push(...sortedArray.map(item => castDraft(item) as Draft<T>))
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error sorting array in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Update a specific item using a callback function
-	 */
-	public update(index: number, updater: (item: Draft<T>) => void): void {
-		try {
-			// Use Immer to create a new immutable array
-			const nextState = produce(this.value, draft => {
-				if (index >= 0 && index < draft.length) {
-					updater(draft[index])
-				} else {
-					throw new Error(`Index ${index} out of bounds (length: ${draft.length})`)
-				}
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error updating item at index ${index} in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Clear the array
-	 */
-	public clear(): void {
-		this.updateState([])
-	}
-
-	/**
-	 * 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,
-				push: this.push.bind(this),
-				pop: this.pop.bind(this),
-				unshift: this.unshift.bind(this),
-				shift: this.shift.bind(this),
-				set: this.set.bind(this),
-				get: this.get.bind(this),
-				splice: this.splice.bind(this),
-				remove: this.remove.bind(this),
-				replace: this.replace.bind(this),
-				filter: this.filter.bind(this),
-				map: this.map.bind(this),
-				sort: this.sort.bind(this),
-				update: this.update.bind(this),
-				clear: this.clear.bind(this),
-				subscribe: (callback: (state: T[]) => void) => {
-					const subscription = this.$.subscribe(callback)
-					return () => subscription.unsubscribe()
-				},
-			}
-		}
-	}
-}

package/src/store/context-collection.ts

@@ -1,218 +0,0 @@
-// src/store/context-collection.ts - Updated with Immer for immutability
-import { throttleTime } from 'rxjs'
-import { BaseStore } from './store.class'
-import { ICollectionStore, StorageType, StoreError } from './types'
-import { produce, Draft, castDraft } from 'immer'
-
-/**
- * Enhanced collection store with better TypeScript support and immutability
- * Now extends BaseStore for common functionality
- */
-export default class SchmancyCollectionStore<V = any> extends BaseStore<Map<string, V>> implements ICollectionStore<V> {
-	public static type = 'collection'
-
-	// Static map to hold instances
-	private static instances: Map<string, SchmancyCollectionStore<any>> = new Map()
-
-	/**
-	 * Static method to get or create an instance with proper typing
-	 */
-	public static getInstance<V = any>(
-		storage: StorageType,
-		key: string,
-		defaultValue: Map<string, V>,
-	): SchmancyCollectionStore<V> {
-		const instanceKey = `${storage}:${key}`
-		if (!this.instances.has(instanceKey)) {
-			this.instances.set(instanceKey, new SchmancyCollectionStore<V>(storage, key, defaultValue))
-		}
-		return this.instances.get(instanceKey) as SchmancyCollectionStore<V>
-	}
-
-	/**
-	 * Set values in the collection with proper typing and immutability.
-	 * Supports multiple input types to prevent common developer mistakes.
-	 * 
-	 * @example
-	 * // Single key-value pair
-	 * store.set('key1', value1)
-	 * 
-	 * @example
-	 * // Merge from a Map
-	 * const dataMap = new Map([['key1', value1], ['key2', value2]])
-	 * store.set(dataMap)
-	 * 
-	 * @example
-	 * // Merge from an object
-	 * store.set({ key1: value1, key2: value2 })
-	 */
-	public set<T = V>(keyOrData: string | Map<string, T> | Record<string, T>, value?: T): void {
-		try {
-			const nextState = produce(this.value, draft => {
-				// Handle different input types
-				if (typeof keyOrData === 'string') {
-					// Traditional key-value pair
-					if (value === undefined) {
-						throw new Error('Value is required when setting a single key')
-					}
-					draft.set(keyOrData, castDraft(value) as unknown as Draft<V>)
-				} else if (keyOrData instanceof Map) {
-					// Merge all entries from the Map
-					Array.from(keyOrData.entries()).forEach(([key, val]) => {
-						draft.set(key, castDraft(val) as unknown as Draft<V>)
-					})
-				} else if (typeof keyOrData === 'object' && keyOrData !== null) {
-					// Merge all properties from the object
-					Object.entries(keyOrData).forEach(([key, val]) => {
-						draft.set(key, castDraft(val) as unknown as Draft<V>)
-					})
-				} else {
-					throw new Error('Invalid input: expected string key with value, Map, or object')
-				}
-			})
-
-			// Update the state with the new immutable Map
-			this.updateState(nextState)
-			this.error$.next(null) // Clear any previous errors
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error setting values in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Merge a Map into the collection. This is a helper method that provides
-	 * explicit semantics for merging operations.
-	 * 
-	 * @param map The Map to merge into the collection
-	 * @example
-	 * const dataMap = new Map([['key1', value1], ['key2', value2]])
-	 * store.merge(dataMap)
-	 */
-	public merge<T = V>(map: Map<string, T>): void {
-		this.set(map)
-	}
-
-	/**
-	 * Delete a value from the collection immutably
-	 */
-	public delete(key: string): void {
-		try {
-			// Use Immer to create a new immutable Map with the key deleted
-			const nextState = produce(this.value, draft => {
-				draft.delete(key)
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null) // Clear any previous errors
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error deleting key ${key} from ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Clear the collection immutably
-	 */
-	public clear(): void {
-		// Create a fresh empty Map
-		this.updateState(new Map<string, V>())
-	}
-
-	/**
-	 * Batch update multiple items in the collection
-	 * @param updates Object with keys and values to update
-	 */
-	public batchUpdate(updates: Record<string, V>): void {
-		try {
-			// Use Immer to apply all updates in a single immutable operation
-			const nextState = produce(this.value, draft => {
-				Object.entries(updates).forEach(([key, value]) => {
-					draft.set(key, castDraft(value) as unknown as Draft<V>)
-				})
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error batch updating in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Update an existing item in the collection using an updater function
-	 * @param key Key of the item to update
-	 * @param updater Function that receives the current value and returns the new value
-	 */
-	public update(key: string, updater: (currentValue: Draft<V>) => void): void {
-		try {
-			// Use Immer to update the specific item
-			const nextState = produce(this.value, draft => {
-				const currentValue = draft.get(key)
-				if (currentValue !== undefined) {
-					updater(currentValue)
-					// No need to set the value back since it's updated in place
-				}
-			})
-
-			this.updateState(nextState)
-			this.error$.next(null)
-		} catch (err) {
-			const error = new StoreError<unknown>(`Error updating item ${key} in ${this.key}`, err)
-			this.error$.next(error)
-			console.error(error)
-		}
-	}
-
-	/**
-	 * Constructor extension to set up persistence
-	 */
-	constructor(storageType: StorageType, key: string, defaultValue: Map<string, V>) {
-		super(storageType, key, defaultValue)
-
-		// Set up persistence throttling for better performance
-		if (storageType !== 'memory') {
-			this.setupPersistence()
-		}
-	}
-
-	/**
-	 * Set up persistence to storage with throttling
-	 */
-	private setupPersistence(): void {
-		this.$.pipe(throttleTime(100, undefined, { leading: true, trailing: true })).subscribe(currentValue => {
-			this.storage.save(currentValue).catch(err => {
-				const error = new StoreError<unknown>(`Error saving to ${this.storageType} storage for ${this.key}`, err)
-				this.error$.next(error)
-				console.error(error)
-			})
-		})
-	}
-
-	/**
-	 * 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),
-				merge: this.merge.bind(this),
-				delete: this.delete.bind(this),
-				clear: this.clear.bind(this),
-				batchUpdate: this.batchUpdate.bind(this),
-				update: this.update.bind(this),
-				subscribe: (callback: (state: Map<string, V>) => void) => {
-					const subscription = this.$.subscribe(callback)
-					return () => subscription.unsubscribe()
-				},
-			}
-		}
-	}
-}