@mhmo91/schmancy 0.9.28 → 0.10.2

package/types/src/store/context-collection.d.ts

@@ -1,74 +0,0 @@
-import { BaseStore } from './store.class';
-import { ICollectionStore, StorageType } from './types';
-import { Draft } 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> {
-    static type: string;
-    private static instances;
-    /**
-     * Static method to get or create an instance with proper typing
-     */
-    static getInstance<V = any>(storage: StorageType, key: string, defaultValue: Map<string, V>): 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 })
-     */
-    set<T = V>(keyOrData: string | Map<string, T> | Record<string, T>, value?: T): void;
-    /**
-     * 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)
-     */
-    merge<T = V>(map: Map<string, T>): void;
-    /**
-     * Delete a value from the collection immutably
-     */
-    delete(key: string): void;
-    /**
-     * Clear the collection immutably
-     */
-    clear(): void;
-    /**
-     * Batch update multiple items in the collection
-     * @param updates Object with keys and values to update
-     */
-    batchUpdate(updates: Record<string, V>): void;
-    /**
-     * 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
-     */
-    update(key: string, updater: (currentValue: Draft<V>) => void): void;
-    /**
-     * Constructor extension to set up persistence
-     */
-    constructor(storageType: StorageType, key: string, defaultValue: Map<string, V>);
-    /**
-     * Set up persistence to storage with throttling
-     */
-    private setupPersistence;
-    /**
-     * Setup development tools for debugging
-     */
-    protected setupDevTools(): void;
-}

package/types/src/store/context-create.d.ts

@@ -1,43 +0,0 @@
-import { SchmancyArrayStore } from './context-array';
-import SchmancyCollectionStore from './context-collection';
-import { SchmancyStoreObject } from './context-object';
-import { IArrayStore, ICollectionStore, IStore, StorageType } from './types';
-/**
- * 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 declare 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 declare 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 declare function createContext<T>(initialData: T[], storage: StorageType, key: string): IArrayStore<T> & SchmancyArrayStore<T>;
-/**
- * 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 declare function createArrayContext<T>(initialData: T[], key: string, storage?: StorageType): IArrayStore<T> & SchmancyArrayStore<T>;
-/**
- * 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 declare function createTestArrayContext<T>(initialData?: T[], key?: string): IArrayStore<T> & SchmancyArrayStore<T>;

package/types/src/store/context-object.d.ts

@@ -1,46 +0,0 @@
-import { BaseStore } from './store.class';
-import { IStore, StorageType } from './types';
-import { immerable } from 'immer';
-/**
- * Enhanced store object with better TypeScript support and immutability
- * Now extends BaseStore for common functionality and uses Immer
- */
-export declare class SchmancyStoreObject<T extends Record<string, any>> extends BaseStore<T> implements IStore<T> {
-    [immerable]: boolean;
-    static type: string;
-    private static instances;
-    /**
-     * Static method to get or create an instance with strong typing
-     */
-    static getInstance<T extends Record<string, any>>(storage: StorageType, key: string, defaultValue: T): SchmancyStoreObject<T>;
-    /**
-     * Set state with proper typing and immutability using Immer
-     */
-    set(value: Partial<T>, merge?: boolean): void;
-    /**
-     * Reset the store to its default value
-     */
-    clear(): void;
-    /**
-     * Delete a specific key from the store with type checking and immutability
-     */
-    delete<K extends keyof T>(key: K): void;
-    /**
-     * 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
-     */
-    setPath(path: string, value: any): void;
-    /**
-     * Process stored value by merging with default value
-     */
-    protected processStoredValue(storedValue: T): T;
-    /**
-     * Setup development tools for debugging
-     */
-    protected setupDevTools(): void;
-    /**
-     * Inherit isImmerDraftable from BaseStore, but also check for [immerable]
-     */
-    protected isImmerDraftable(value: any): boolean;
-}

package/types/src/store/filter-directive.d.ts

@@ -1,116 +0,0 @@
-/** Supported comparison operators with TypeScript literal types */
-export type ComparisonOperator = '==' | '!=' | '>' | '<' | '>=' | '<=' | 'includes' | 'notIncludes' | 'startsWith' | 'endsWith' | 'in' | 'notIn' | 'any';
-/**
- * Type-safe condition tuple
- */
-export type ConditionTuple = [field: string, op: ComparisonOperator, expected: unknown, strict?: boolean];
-/**
- * Type-safe condition object
- */
-export interface ConditionObject {
-    key: string | string[];
-    operator: ComparisonOperator;
-    value: unknown;
-    strict?: boolean;
-}
-/**
- * Unified query condition type
- */
-export type QueryCondition = ConditionTuple | ConditionObject;
-/**
- * Filter result with item and score
- */
-export interface ScoredItem<T> {
-    item: T;
-    score: number;
-}
-/**
- * Get a nested value from an object using a dot-separated path.
- * Checks explicitly for null/undefined so falsy values like 0 or false are preserved.
- */
-export declare const getFieldValue: <T = any>(item: Record<string, any>, path: string) => T;
-/**
- * Filter a Map of items given an array of query conditions.
- * For each query condition:
- * - If the expected value is empty/null/undefined, it is treated as a match.
- * - For non-fuzzy operators, the condition must strictly match.
- * - For the "any" operator, a fuzzy similarity score is computed.
- *   Items with a fuzzy score below a given threshold (e.g., 0.3) are excluded.
- *
- * The overall item score is the average of the scores from all conditions.
- * The results are sorted in descending order of relevance.
- *
- * @param items - A Map containing items to filter.
- * @param queries - An array of query conditions to apply.
- * @param fuzzyThreshold - Minimum score required for fuzzy matches (default: 0.3)
- * @returns An array of items that match all query conditions, sorted by relevance.
- */
-export declare function filterMapItems<T extends Record<string, any>>(items: Map<string, T>, queries?: QueryCondition[], fuzzyThreshold?: number): T[];
-/**
- * Filter an array of items using query conditions
- */
-export declare function filterArrayItems<T extends Record<string, any>>(items: T[], queries?: QueryCondition[], fuzzyThreshold?: number): T[];
-/**
- * Type guard for checking if a value is an array with better type inference
- * @param value Value to check
- * @returns True if the value is an array
- */
-export declare function isArray<T = unknown>(value: unknown): value is Array<T>;
-/**
- * Type guard for checking if a value is a string
- * @param value Value to check
- * @returns True if the value is a string
- */
-export declare function isString(value: unknown): value is string;
-/**
- * Type guard for checking if a value is a number
- * @param value Value to check
- * @returns True if the value is a number and not NaN
- */
-export declare function isNumber(value: unknown): value is number;
-/**
- * Type guard for checking if a value is a date
- * @param value Value to check
- * @returns True if the value is a valid Date object
- */
-export declare function isDate(value: unknown): value is Date;
-/**
- * Type guard for checking if a value is an iterable collection
- * @param value Value to check
- * @returns True if the value implements the iterable protocol
- */
-export declare function isIterable<T = unknown>(value: unknown): value is Iterable<T>;
-/**
- * Type guard for checking if a value is a Map
- * @param value Value to check
- * @returns True if the value is a Map
- */
-export declare function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V>;
-/**
- * Type guard for checking if a value is a Set
- * @param value Value to check
- * @returns True if the value is a Set
- */
-export declare function isSet<T = unknown>(value: unknown): value is Set<T>;
-/**
- * Type guard for checking if a value is a plain object (not an array, Map, etc.)
- * @param value Value to check
- * @returns True if the value is a plain object
- */
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-/**
- * Type guard for checking if a value is undefined or null
- * @param value Value to check
- * @returns True if the value is undefined or null
- */
-export declare function isNil(value: unknown): value is undefined | null;
-/**
- * Improved type-safe comparison function that uses appropriate type guards
- * @param op Comparison operator
- * @param actual Actual value
- * @param expected Expected value
- * @returns Result of the comparison
- */
-export declare function compareValues(op: ComparisonOperator, actual: unknown, expected: unknown): boolean;
-export declare const filterMap: typeof filterMapItems;
-export declare const filterArray: typeof filterArrayItems;

package/types/src/store/immer-integration.d.ts

@@ -1,54 +0,0 @@
-import { Draft, Immutable } from 'immer';
-/**
- * Create an immutable update for Maps
- * @param map Original Map to update
- * @param updater Function that can make "mutable" changes to the draft
- * @returns A new Map with the changes applied
- */
-export declare function updateMap<K, V>(map: Immutable<Map<K, V>>, updater: (draft: Draft<Map<K, V>>) => void): Map<K, V>;
-/**
- * Create an immutable update for a specific item in a Map
- * @param map Original Map to update
- * @param key Key of the item to update
- * @param updater Function that can make "mutable" changes to the item
- * @returns A new Map with the item updated
- */
-export declare function updateItem<K, V>(map: Immutable<Map<K, V>>, key: K, updater: (item: Draft<V>) => void): Map<K, V>;
-/**
- * Immutably filter a Map
- * @param map Original Map to filter
- * @param predicate Function that returns true for items to keep
- * @returns A new Map with only the matching items
- */
-export declare function filterMap<K, V>(map: Immutable<Map<K, V>>, predicate: (value: Immutable<V>, key: Immutable<K>) => boolean): Map<K, V>;
-/**
- * Create an immutable update for an object
- * @param obj Original object to update
- * @param updater Function that can make "mutable" changes to the draft
- * @returns A new object with the changes applied
- */
-export declare function updateObject<T extends Record<string, any>>(obj: Immutable<T>, updater: (draft: Draft<T>) => void): T;
-/**
- * Merge objects immutably
- * @param target Original object
- * @param source Source object to merge in
- * @returns A new object with properties merged
- */
-export declare function mergeObjects<T extends Record<string, any>>(target: Immutable<T>, source: Partial<T>): T;
-/**
- * Type guard to check if an object is a Map
- */
-export declare function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V>;
-/**
- * Creates a readonly version of a type
- * This is a utility that uses Immer's Immutable type to make a type readonly
- * @param value The value to cast as immutable
- * @returns The same value but typed as immutable
- */
-export declare function asReadonly<T>(value: T): Immutable<T>;
-/**
- * Makes an object or Map deeply immutable at runtime by freezing
- * @param value The value to freeze
- * @returns The frozen value
- */
-export declare function freeze<T>(value: T): Immutable<T>;

package/types/src/store/index.d.ts

@@ -1,10 +0,0 @@
-export * from './context-array';
-export * from './context-collection';
-export * from './context-create';
-export * from './context-object';
-export * from './filter-directive';
-export * from './selector-hook';
-export * from './selectors';
-export * from './storage-manager';
-export * from './store.class';
-export * from './types';

package/types/src/store/selector-hook.d.ts

@@ -1,46 +0,0 @@
-import { ICollectionStore, IStore } from './types';
-/**
- * Property descriptor interface
- */
-type PropertyDescriptor<T> = {
-    get?: () => T;
-    set?: (value: T) => void;
-    value?: T;
-    configurable?: boolean;
-    enumerable?: boolean;
-    writable?: boolean;
-};
-/**
- * Options for selecting from a store
- */
-interface SelectOptions {
-    /** If true, will wait for selector to emit a value (including null) before calling connectedCallback. Only undefined is considered "not ready". Default is true. */
-    required?: boolean;
-    /** If true, will only update the component and not set the property value */
-    updateOnly?: boolean;
-    /** If true, will use structuredClone to deeply clone values (prevents mutations) */
-    deepClone?: boolean;
-    /** Custom equality function to determine when to update */
-    equals?: (a: any, b: any) => boolean;
-    /** Debug mode - logs selector activity */
-    debug?: boolean;
-}
-/**
- * Selector decorator that connects a component property to a store selector
- * with improved memory management
- *
- * @param store The store to select from
- * @param selectorFn Optional function to transform the store state
- * @param options Additional options for the selector
- */
-export declare function select<T, R>(store: IStore<T> | ICollectionStore<T>, selectorFn?: (state: any) => R, options?: SelectOptions): (proto: Record<string, any>, propName: string, _descriptor?: PropertyDescriptor<R>) => void;
-/**
- * Creates a selector decorator that selects a specific item from a collection store
- * with improved memory management
- *
- * @param store The collection store
- * @param keyGetter Function that returns the key to select
- * @param options Additional options
- */
-export declare function selectItem<T>(store: ICollectionStore<T>, keyGetter: (component: any) => string, options?: SelectOptions): (proto: Record<string, any>, propName: string, _descriptor?: PropertyDescriptor<T | undefined>) => void;
-export {};

package/types/src/store/selectors.d.ts

@@ -1,90 +0,0 @@
-import { Observable } from 'rxjs';
-import { ICollectionStore, IStore } from './types';
-/**
- * Creates a selector that derives a value from store state
- *
- * @param store The store to observe
- * @param selectorFn Function that transforms the state
- * @returns An observable of the selected state that only emits when the derived value changes
- */
-export declare function createSelector<T, R>(store: IStore<T>, selectorFn: (state: T) => R): Observable<R>;
-/**
- * Creates a selector for collection stores that derives a value from the collection
- *
- * @param store The collection store to observe
- * @param selectorFn Function that transforms the collection
- * @returns An observable of the selected state that only emits when the derived value changes
- */
-export declare function createCollectionSelector<T, R>(store: ICollectionStore<T>, selectorFn: (state: Map<string, T>) => R): Observable<R>;
-/**
- * Creates a selector that returns all items from a collection as an array
- *
- * @param store The collection store
- * @returns An observable of all items as an array
- */
-export declare function createItemsSelector<T>(store: ICollectionStore<T>): Observable<T[]>;
-/**
- * Creates a selector that retrieves a single item from a collection
- *
- * @param store The collection store
- * @param itemKey The key of the item to select
- * @returns An observable of the selected item that emits when the item changes
- */
-export declare function createItemSelector<T>(store: ICollectionStore<T>, itemKey: string): Observable<T | undefined>;
-/**
- * Creates a selector that returns all keys from a collection
- */
-export declare function createKeysSelector<T>(store: ICollectionStore<T>): Observable<string[]>;
-/**
- * Creates a selector that returns entries (key-value pairs) from a collection
- */
-export declare function createEntriesSelector<T>(store: ICollectionStore<T>): Observable<[string, T][]>;
-/**
- * Creates a selector that sorts collection items
- */
-export declare function createSortSelector<T>(store: ICollectionStore<T>, compareFn: (a: T, b: T) => number): Observable<T[]>;
-/**
- * Creates a selector that finds the first item matching a predicate
- */
-export declare function createFindSelector<T>(store: ICollectionStore<T>, predicate: (item: T, key: string) => boolean): Observable<T | undefined>;
-/**
- * Creates a selector that filters items from a collection - OPTIMIZED
- *
- * @param store The collection store
- * @param filterFn Function that returns true for items to include
- * @returns An observable of filtered items as an array
- */
-export declare function createFilterSelector<T>(store: ICollectionStore<T>, filterFn: (item: T, key: string) => boolean): Observable<T[]>;
-/**
- * Creates a selector that maps collection values through a transform function - OPTIMIZED
- */
-export declare function createMapSelector<T, R>(store: ICollectionStore<T>, mapFn: (item: T, key: string) => R): Observable<R[]>;
-/**
- * Creates a selector that counts items in a collection, optionally filtered - OPTIMIZED
- *
- * @param store The collection store
- * @param filterFn Optional function to filter which items to count
- * @returns An observable of the count
- */
-export declare function createCountSelector<T>(store: ICollectionStore<T>, filterFn?: (item: T, key: string) => boolean): Observable<number>;
-/**
- * Optimized RxJS Pipeline - use share with reset on refCount zero for better memory management
- * in scenarios where selector subscriptions come and go
- *
- * @param store The store to observe
- * @param selectorFn Function that transforms the state
- * @returns An observable of the selected state with improved memory management
- */
-export declare function createOptimizedSelector<T, R>(store: IStore<T>, selectorFn: (state: T) => R): Observable<R>;
-/**
- * Creates a compound selector from multiple stores
- *
- * This function combines data from multiple stores to create a derived
- * state that's compatible with the @select decorator.
- *
- * @param stores Array of stores to derive state from
- * @param selectorFns Selector functions for each store
- * @param combinerFn Function that combines the selected values
- * @returns A store-compatible object to use with @select
- */
-export declare function createCompoundSelector<R>(stores: Array<IStore<any> | ICollectionStore<any>>, selectorFns: Array<(state: any) => any>, combinerFn: (...values: any[]) => R): IStore<R>;

package/types/src/store/storage-manager.d.ts

@@ -1,48 +0,0 @@
-import { IStorageManager, StorageType } from './types';
-/**
- * Memory storage manager implementation
- */
-export declare class MemoryStorageManager<T> implements IStorageManager<T> {
-    private data;
-    load(): Promise<T | null>;
-    save(state: T): Promise<void>;
-    clear(): Promise<void>;
-}
-/**
- * Local storage manager implementation
- */
-export declare class LocalStorageManager<T> implements IStorageManager<T> {
-    private key;
-    constructor(key: string);
-    load(): Promise<T | null>;
-    save(state: T): Promise<void>;
-    clear(): Promise<void>;
-}
-/**
- * Session storage manager implementation
- */
-export declare class SessionStorageManager<T> implements IStorageManager<T> {
-    private key;
-    constructor(key: string);
-    load(): Promise<T | null>;
-    save(state: T): Promise<void>;
-    clear(): Promise<void>;
-}
-/**
- * IndexedDB storage manager implementation with better error typing
- */
-export declare class IndexedDBStorageManager<T> implements IStorageManager<T> {
-    private key;
-    private static DB_NAME;
-    private static STORE_NAME;
-    private static DB_VERSION;
-    constructor(key: string);
-    private openDB;
-    load(): Promise<T | null>;
-    save(state: T): Promise<void>;
-    clear(): Promise<void>;
-}
-/**
- * Factory function to create the appropriate storage manager
- */
-export declare function createStorageManager<T>(type: StorageType, key: string): IStorageManager<T>;

package/types/src/store/store.class.d.ts

@@ -1,73 +0,0 @@
-import { immerable } from 'immer';
-import { BehaviorSubject, Subject } from 'rxjs';
-import { IStorageManager, StorageType, StoreError } from './types';
-/**
- * Base store class to handle common functionality between store types
- * Now with Immer integration for immutability
- */
-export declare abstract class BaseStore<T> {
-    protected storageType: StorageType;
-    protected key: string;
-    [immerable]: boolean;
-    protected _ready: boolean;
-    protected _destroy$: Subject<void>;
-    $: BehaviorSubject<T>;
-    error$: BehaviorSubject<StoreError<unknown>>;
-    readonly defaultValue: T;
-    protected storage: IStorageManager<T>;
-    /**
-     * Get store ready state
-     */
-    get ready(): boolean;
-    /**
-     * Set store ready state
-     */
-    set ready(value: boolean);
-    /**
-     * Get the current value
-     */
-    get value(): T;
-    /**
-     * Initialize the base store
-     * @param storageType Storage type to use
-     * @param key Unique key for the store
-     * @param defaultValue Default/initial value
-     */
-    constructor(storageType: StorageType, key: string, defaultValue: T);
-    /**
-     * Check if a value can be safely used with Immer's produce
-     */
-    protected isImmerDraftable(value: any): boolean;
-    /**
-     * Cleanup method for all store types
-     */
-    destroy(): void;
-    /**
-     * Replace the entire store state immutably
-     */
-    replace(newValue: T): void;
-    /**
-     * Reset to default value - to be implemented by subclasses
-     */
-    abstract clear(): void;
-    /**
-     * Update the state with proper error handling and immutability
-     */
-    protected updateState(newValue: T): void;
-    /**
-     * Initialize the store from persistent storage
-     */
-    protected initializeFromStorage(): Promise<void>;
-    /**
-     * Process stored value (can be overridden by subclasses)
-     */
-    protected processStoredValue(storedValue: T): T;
-    /**
-     * Persist state to storage
-     */
-    protected persistToStorage(state: T): Promise<void>;
-    /**
-     * Setup development tools
-     */
-    protected abstract setupDevTools(): void;
-}