@mhmo91/schmancy 0.2.139 → 0.2.142

package/types/src/notification/notification-audio.d.ts

@@ -0,0 +1,70 @@
+import { NotificationType } from './notification';
+/**
+ * Audio service for playing notification sounds.
+ * Uses Web Audio API with fallback to HTML5 Audio.
+ */
+export declare class NotificationAudioService {
+    private audioContext;
+    private soundBuffers;
+    private volume;
+    private muted;
+    private soundGenerator;
+    private soundUrls;
+    constructor();
+    /**
+     * Initialize audio files - generate programmatically if needed
+     */
+    private initializeAudioFiles;
+    /**
+     * Lazy-initialize the audio context
+     */
+    private getAudioContext;
+    /**
+     * Preload all notification sounds
+     */
+    private preloadSounds;
+    /**
+     * Load a sound file and decode it
+     */
+    private loadSound;
+    /**
+     * Play a notification sound
+     */
+    playSound(type: NotificationType): Promise<void>;
+    /**
+     * Play a directly generated sound when other methods fail
+     */
+    private playDirectGeneratedSound;
+    /**
+     * Play sound using HTML5 Audio as a fallback
+     */
+    private playFallbackSound;
+    /**
+     * Set volume for notification sounds (0.0 to 1.0)
+     */
+    setVolume(volume: number): void;
+    /**
+     * Get current volume level
+     */
+    getVolume(): number;
+    /**
+     * Mute notification sounds
+     */
+    mute(): void;
+    /**
+     * Unmute notification sounds
+     */
+    unmute(): void;
+    /**
+     * Check if notification sounds are muted
+     */
+    isMuted(): boolean;
+    /**
+     * Set custom sound URL for a notification type
+     */
+    setSoundUrl(type: NotificationType, url: string): void;
+    /**
+     * Get the current sound URL for a notification type
+     */
+    getSoundUrl(type: NotificationType): string;
+}

package/types/src/notification/notification-container.d.ts

@@ -0,0 +1,44 @@
+import { NotificationType } from './notification';
+export interface NotificationItem {
+    id: string;
+    title: string;
+    message: string;
+    type: NotificationType;
+    duration: number;
+    closable: boolean;
+    playSound: boolean;
+}
+export interface NotificationOptions {
+    id?: string;
+    title?: string;
+    message: string;
+    type?: NotificationType;
+    duration?: number;
+    closable?: boolean;
+    playSound?: boolean;
+}
+declare const SchmancyNotificationContainer_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * Container component for displaying stacked notifications.
+ *
+ * @element sch-notification-container
+ */
+export default class SchmancyNotificationContainer extends SchmancyNotificationContainer_base {
+    position: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
+    maxVisibleNotifications: number;
+    playSound: boolean;
+    audioVolume: number;
+    private _notifications;
+    private _audioService;
+    connectedCallback(): void;
+    addNotification(options: NotificationOptions): string;
+    removeNotification(id: string): void;
+    private _handleClose;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sch-notification-container': SchmancyNotificationContainer;
+    }
+}
+export {};

package/types/src/notification/notification-service.d.ts

@@ -0,0 +1,60 @@
+import { NotificationOptions } from './notification-container';
+/**
+ * Notification service for centralized notification management.
+ * Provides a simple API for showing notifications.
+ */
+export declare class NotificationService {
+    private static instance;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): NotificationService;
+    /**
+     * Show a notification
+     * @returns The ID of the created notification
+     */
+    notify(options: NotificationOptions): string;
+    /**
+     * Show an info notification
+     */
+    info(message: string, options?: Partial<Omit<NotificationOptions, 'message' | 'type'>>): string;
+    /**
+     * Show a success notification
+     */
+    success(message: string, options?: Partial<Omit<NotificationOptions, 'message' | 'type'>>): string;
+    /**
+     * Show a warning notification
+     */
+    warning(message: string, options?: Partial<Omit<NotificationOptions, 'message' | 'type'>>): string;
+    /**
+     * Show an error notification
+     */
+    error(message: string, options?: Partial<Omit<NotificationOptions, 'message' | 'type'>>): string;
+}
+/**
+ * Global notification utility - provides a quick way to show notifications
+ */
+export declare const $notify: {
+    /**
+     * Show a notification
+     */
+    show: (options: NotificationOptions) => string;
+    /**
+     * Show an info notification
+     */
+    info: (message: string, options?: Partial<Omit<NotificationOptions, "message" | "type">>) => string;
+    /**
+     * Show a success notification
+     */
+    success: (message: string, options?: Partial<Omit<NotificationOptions, "message" | "type">>) => string;
+    /**
+     * Show a warning notification
+     */
+    warning: (message: string, options?: Partial<Omit<NotificationOptions, "message" | "type">>) => string;
+    /**
+     * Show an error notification
+     */
+    error: (message: string, options?: Partial<Omit<NotificationOptions, "message" | "type">>) => string;
+};
+export default NotificationService;

package/types/src/notification/notification.d.ts

@@ -1,11 +1,40 @@
-declare const SchmancyNotification_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
-export declare class SchmancyNotification extends SchmancyNotification_base {
-    type: 'success' | 'error' | 'warning' | 'info';
+import { PropertyValues } from 'lit';
+export type NotificationType = 'info' | 'success' | 'warning' | 'error';
+declare const SchmancyNotification_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * @fires close - When notification is closed
+ */
+export default class SchmancyNotification extends SchmancyNotification_base {
+    title: string;
+    message: string;
+    type: NotificationType;
+    closable: boolean;
+    duration: number;
+    id: string;
+    playSound: boolean;
+    private _visible;
+    private _progress;
+    private _hovered;
+    private _closing;
+    private _autoCloseTimer?;
+    private _progressTimer?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProps: PropertyValues): void;
+    private _startAutoCloseTimer;
+    private _clearTimers;
+    private _pauseTimers;
+    private _resumeTimers;
+    private _playSound;
+    private _handleMouseEnter;
+    private _handleMouseLeave;
+    close(): void;
     render(): import("lit-html").TemplateResult<1>;
+    private _getTypeStyles;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'schmancy-notification': SchmancyNotification;
+        'sch-notification': SchmancyNotification;
     }
 }
 export {};

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

@@ -0,0 +1,83 @@
+import { Draft } from 'immer';
+import { BaseStore } from './store.class';
+import { IArrayStore, StorageType } from './types';
+/**
+ * Enhanced array store with TypeScript support and immutability
+ * Extends BaseStore for common functionality
+ */
+export declare class SchmancyArrayStore<T = any> extends BaseStore<T[]> implements IArrayStore<T> {
+    static type: string;
+    private static instances;
+    /**
+     * Static method to get or create an instance with proper typing
+     */
+    static getInstance<T = any>(storage: StorageType, key: string, defaultValue?: T[]): SchmancyArrayStore<T>;
+    /**
+     * Constructor extension to set up persistence
+     */
+    constructor(storageType: StorageType, key: string, defaultValue?: T[]);
+    /**
+     * Set up persistence to storage with throttling
+     */
+    private setupPersistence;
+    /**
+     * Add an item to the end of the array
+     */
+    push(...items: T[]): void;
+    /**
+     * Remove and return the last item from the array
+     */
+    pop(): T | undefined;
+    /**
+     * Add item(s) to the beginning of the array
+     */
+    unshift(...items: T[]): void;
+    /**
+     * Remove and return the first item from the array
+     */
+    shift(): T | undefined;
+    /**
+     * Update an item at a specific index
+     */
+    set(index: number, value: T): void;
+    /**
+     * Get item at a specific index
+     */
+    get(index: number): T | undefined;
+    /**
+     * Remove items from the array
+     */
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    /**
+     * Remove an item by value (first occurrence)
+     */
+    remove(item: T, compareFn?: (a: T, b: T) => boolean): boolean;
+    /**
+     * Replace entire array
+     */
+    replace(newArray: T[]): void;
+    /**
+     * Filter items in the array
+     */
+    filter(predicate: (value: T, index: number, array: T[]) => boolean): void;
+    /**
+     * Map over the array and transform items
+     */
+    map<U>(mapper: (value: T, index: number, array: T[]) => U): U[];
+    /**
+     * Sort the array in place
+     */
+    sort(compareFn?: (a: T, b: T) => number): void;
+    /**
+     * Update a specific item using a callback function
+     */
+    update(index: number, updater: (item: Draft<T>) => void): void;
+    /**
+     * Clear the array
+     */
+    clear(): void;
+    /**
+     * Setup development tools for debugging
+     */
+    protected setupDevTools(): void;
+}

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

@@ -1,71 +1,50 @@
-import { BehaviorSubject } from 'rxjs';
-import { ICollectionStore, StorageType, StoreError } from './types';
+import { BaseStore } from './store.class';
+import { ICollectionStore, StorageType } from './types';
+import { Draft } from 'immer';
 /**
- * Enhanced collection store with better TypeScript support
+ * Enhanced collection store with better TypeScript support and immutability
+ * Now extends BaseStore for common functionality
  */
-export default class SchmancyCollectionStore<V = any> implements ICollectionStore<V> {
-    private storageType;
-    private key;
+export default class SchmancyCollectionStore<V = any> extends BaseStore<Map<string, V>> implements ICollectionStore<V> {
     static type: string;
     private static instances;
-    private _ready;
-    private _destroy$;
-    $: BehaviorSubject<Map<string, V>>;
-    error$: BehaviorSubject<StoreError<unknown>>;
-    readonly defaultValue: Map<string, V>;
-    private storage;
-    /**
-     * Get ready state
-     */
-    get ready(): boolean;
-    /**
-     * Set ready state
-     */
-    set ready(value: boolean);
-    private constructor();
     /**
      * 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>;
     /**
-     * Get the current value
-     */
-    get value(): Map<string, V>;
-    /**
-     * Set a value in the collection with proper typing
+     * Set a value in the collection with proper typing and immutability
      */
     set<T = V>(key: string, value: T): void;
     /**
-     * Delete a value from the collection
+     * Delete a value from the collection immutably
      */
     delete(key: string): void;
     /**
-     * Clear the collection
+     * Clear the collection immutably
      */
     clear(): void;
-    replace(newValue: Map<string, V>): void;
     /**
-     * Update the state with error handling
+     * Batch update multiple items in the collection
+     * @param updates Object with keys and values to update
      */
-    private updateState;
+    batchUpdate(updates: Record<string, V>): void;
     /**
-     * Initialize from persistent storage
+     * 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
      */
-    private initializeFromStorage;
+    update(key: string, updater: (currentValue: Draft<V>) => void): void;
     /**
-     * Load data from IndexedDB with better typing
+     * Constructor extension to set up persistence
      */
-    private loadFromIndexedDB;
+    constructor(storageType: StorageType, key: string, defaultValue: Map<string, V>);
     /**
-     * Set up persistence to storage
+     * Set up persistence to storage with throttling
      */
     private setupPersistence;
     /**
      * Setup development tools for debugging
      */
-    private setupDevTools;
-    /**
-     * Clean up resources
-     */
-    destroy(): void;
+    protected setupDevTools(): void;
 }

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

@@ -1,21 +1,43 @@
 import SchmancyCollectionStore from './context-collection';
 import { SchmancyStoreObject } from './context-object';
-import { ICollectionStore, IStore, StorageType } from './types';
+import { SchmancyArrayStore } from './context-array';
+import { ICollectionStore, IStore, IArrayStore, StorageType } from './types';
 /**
- * Creates a context for managing state with better type safety
- * Overload for object stores
+ * 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 state with better type safety
- * Overload for collection stores
+ * 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 with type inference, simplifying common patterns
+ * 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 createObjectContext<T extends Record<string, any>>(initialData: T, key: string, storage?: StorageType): IStore<T> & SchmancyStoreObject<T>;
+export declare function createContext<T>(initialData: T[], storage: StorageType, key: string): IArrayStore<T> & SchmancyArrayStore<T>;
 /**
- * Creates a collection context with type inference
+ * 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 createCollectionContext<V>(initialData: Map<string, V> | V[], key: string, storage?: StorageType): ICollectionStore<V> & SchmancyCollectionStore<V>;
+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,41 +1,18 @@
-import { BehaviorSubject } from 'rxjs';
-import { IStore, StorageType, StoreError } from './types';
+import { BaseStore } from './store.class';
+import { IStore, StorageType } from './types';
 /**
- * Enhanced store object with better TypeScript support
+ * 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>> implements IStore<T> {
-    private storageType;
-    private key;
+export declare class SchmancyStoreObject<T extends Record<string, any>> extends BaseStore<T> implements IStore<T> {
     static type: string;
     private static instances;
-    private _ready;
-    private _destroy$;
-    $: BehaviorSubject<T>;
-    error$: BehaviorSubject<StoreError<unknown>>;
-    readonly defaultValue: T;
-    private storage;
-    /**
-     * Get store ready state
-     */
-    get ready(): boolean;
-    /**
-     * Set store ready state
-     */
-    set ready(value: boolean);
-    /**
-     * Private constructor to enforce singleton pattern
-     */
-    private constructor();
     /**
      * 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>;
     /**
-     * Get the current value from the store
-     */
-    get value(): T;
-    /**
-     * Set state with proper typing
+     * Set state with proper typing and immutability using Immer
      */
     set(value: Partial<T>, merge?: boolean): void;
     /**
@@ -43,27 +20,21 @@ export declare class SchmancyStoreObject<T extends Record<string, any>> implemen
      */
     clear(): void;
     /**
-     * Replace the store with a new value
-     */
-    replace(newValue: T): void;
-    /**
-     * Delete a specific key from the store with type checking
+     * Delete a specific key from the store with type checking and immutability
      */
     delete<K extends keyof T>(key: K): void;
     /**
-     * Update the state with proper error handling
+     * 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
      */
-    private updateState;
+    setPath(path: string, value: any): void;
     /**
-     * Initialize the store from persistent storage
+     * Process stored value by merging with default value
      */
-    private initializeFromStorage;
+    protected processStoredValue(storedValue: T): T;
     /**
      * Setup development tools for debugging
      */
-    private setupDevTools;
-    /**
-     * Clean up resources
-     */
-    destroy(): void;
+    protected setupDevTools(): void;
 }

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

@@ -29,11 +29,6 @@ export interface ScoredItem<T> {
  * 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;
-/**
- * Compare two values based on a comparison operator.
- * For non-fuzzy operators, this returns a boolean.
- */
-export declare function compareValues(op: ComparisonOperator, actual: unknown, expected: unknown): boolean;
 /**
  * Filter a Map of items given an array of query conditions.
  * For each query condition:
@@ -55,5 +50,67 @@ export declare function filterMapItems<T extends Record<string, any>>(items: Map
  * 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

@@ -0,0 +1,60 @@
+import { Draft, castDraft, castImmutable, Immutable } from 'immer';
+/**
+ * Type-safe wrapper functions for immutable operations with Immer
+ *
+ * Re-export useful Immer types and utilities
+ */
+export { Draft, castDraft, castImmutable, Immutable };
+/**
+ * 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>;