@zengrid/shared 1.0.3 → 1.1.0

package/dist/src/patterns/state-machine.d.ts

@@ -0,0 +1,122 @@
+/**
+ * State Machine Pattern
+ *
+ * Manages state transitions in a predictable way, ensuring
+ * only valid state transitions occur.
+ *
+ * @example
+ * ```typescript
+ * type GridState = 'idle' | 'loading' | 'scrolling' | 'editing';
+ * type GridEvent = 'load' | 'scroll' | 'edit' | 'done';
+ *
+ * const machine = new StateMachine<GridState, GridEvent>('idle');
+ *
+ * // Define valid transitions
+ * machine.addTransition('idle', 'load', 'loading');
+ * machine.addTransition('loading', 'done', 'idle');
+ * machine.addTransition('idle', 'scroll', 'scrolling');
+ * machine.addTransition('scrolling', 'done', 'idle');
+ * machine.addTransition('idle', 'edit', 'editing');
+ * machine.addTransition('editing', 'done', 'idle');
+ *
+ * // Listen to state changes
+ * machine.onTransition((from, event, to) => {
+ *   console.log(`${from} --[${event}]--> ${to}`);
+ * });
+ *
+ * // Trigger transitions
+ * machine.transition('load');    // idle -> loading
+ * machine.transition('done');    // loading -> idle
+ * machine.transition('invalid'); // Error: no valid transition
+ * ```
+ */
+export interface StateMachineOptions {
+    /** Enable strict mode (throw errors on invalid transitions) */
+    strict?: boolean;
+}
+export interface TransitionHandler<S, E> {
+    (from: S, event: E, to: S): void;
+}
+export interface IStateMachine<S, E> {
+    /** Get the current state */
+    readonly state: S;
+    /** Attempt a state transition */
+    transition(event: E): boolean;
+    /** Check if a state is the current state */
+    is(state: S): boolean;
+    /** Check if a transition is valid from the current state */
+    can(event: E): boolean;
+    /** Add a valid transition */
+    addTransition(from: S, event: E, to: S): void;
+    /** Remove a transition */
+    removeTransition(from: S, event: E): void;
+    /** Register a transition handler */
+    onTransition(handler: TransitionHandler<S, E>): () => void;
+    /** Reset to initial state */
+    reset(): void;
+}
+/**
+ * State machine implementation
+ *
+ * @typeParam S - State type (string literal union recommended)
+ * @typeParam E - Event type (string literal union recommended)
+ */
+export declare class StateMachine<S extends string = string, E extends string = string> implements IStateMachine<S, E> {
+    private currentState;
+    private readonly initialState;
+    private transitions;
+    private handlers;
+    private readonly strict;
+    constructor(initialState: S, options?: StateMachineOptions);
+    /**
+     * Get the current state
+     */
+    get state(): S;
+    /**
+     * Add a valid transition
+     *
+     * @param from - The state to transition from
+     * @param event - The event that triggers the transition
+     * @param to - The state to transition to
+     */
+    addTransition(from: S, event: E, to: S): void;
+    /**
+     * Remove a transition
+     */
+    removeTransition(from: S, event: E): void;
+    /**
+     * Attempt a state transition
+     *
+     * @param event - The event to trigger
+     * @returns true if the transition was successful, false otherwise
+     */
+    transition(event: E): boolean;
+    /**
+     * Check if the current state matches
+     */
+    is(state: S): boolean;
+    /**
+     * Check if a transition is valid from the current state
+     */
+    can(event: E): boolean;
+    /**
+     * Register a transition handler
+     *
+     * @param handler - Function called on each transition
+     * @returns Unsubscribe function
+     */
+    onTransition(handler: TransitionHandler<S, E>): () => void;
+    /**
+     * Reset to initial state
+     */
+    reset(): void;
+    /**
+     * Get all possible transitions from the current state
+     */
+    getAvailableTransitions(): E[];
+    /**
+     * Get a visual representation of the state machine
+     */
+    toGraphviz(): string;
+}
+//# sourceMappingURL=state-machine.d.ts.map

package/dist/src/patterns/state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-machine.d.ts","sourceRoot":"","sources":["../../../src/patterns/state-machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,WAAW,mBAAmB;IAClC,+DAA+D;IAC/D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC;IACrC,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,EAAE,CAAC;IACjC,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAElB,iCAAiC;IACjC,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAE9B,4CAA4C;IAC5C,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAEtB,4DAA4D;IAC5D,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IAEvB,6BAA6B;IAC7B,aAAa,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC;IAE9C,0BAA0B;IAC1B,gBAAgB,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAE1C,oCAAoC;IACpC,YAAY,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC;IAE3D,6BAA6B;IAC7B,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;GAKG;AACH,qBAAa,YAAY,CACvB,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,CAAC,SAAS,MAAM,GAAG,MAAM,CACzB,YAAW,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9B,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAI;IACjC,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,QAAQ,CAA2C;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;gBAErB,YAAY,EAAE,CAAC,EAAE,OAAO,GAAE,mBAAwB;IAM9D;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,CAEb;IAED;;;;;;OAMG;IACH,aAAa,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI;IAO7C;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAIzC;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IA2B7B;;OAEG;IACH,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAIrB;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAItB;;;;;OAKG;IACH,YAAY,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,IAAI;IAK1D;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,uBAAuB,IAAI,CAAC,EAAE;IAK9B;;OAEG;IACH,UAAU,IAAI,MAAM;CAYrB"}

package/dist/src/reactive/batch-processor.d.ts

@@ -0,0 +1,80 @@
+/**
+ * BatchProcessor - Batch processing for grouped operations
+ *
+ * @description
+ * Groups operations for single repaint (N updates = 1 repaint, 10x faster).
+ * Uses BatchQueue for queue management.
+ *
+ * @performance
+ * - Without: 100 column resizes = 100 reflows = 500ms
+ * - With: 100 column resizes = 1 reflow = 50ms (10x faster!)
+ *
+ * @example
+ * ```typescript
+ * const columnBatch = new BatchProcessor({
+ *   process: (updates) => {
+ *     updates.forEach(({ columnId, width }) => {
+ *       updateColumnWidthInDOM(columnId, width);
+ *     });
+ *   },
+ *   delay: 16, // One frame
+ * });
+ *
+ * // Queue multiple updates
+ * columnBatch.add({ columnId: 'col-1', width: 150 });
+ * columnBatch.add({ columnId: 'col-2', width: 200 });
+ * columnBatch.add({ columnId: 'col-3', width: 180 });
+ *
+ * // All processed together after 16ms
+ * ```
+ */
+export interface BatchProcessorOptions<T> {
+    process: (items: T[]) => void;
+    delay?: number;
+    maxBatchSize?: number;
+    deduplicate?: (items: T[]) => T[];
+}
+export declare class BatchProcessor<T> {
+    private queue;
+    private processor;
+    private delay;
+    private maxBatchSize?;
+    private timerId;
+    private isProcessing;
+    constructor(options: BatchProcessorOptions<T>);
+    /**
+     * Add item to batch queue
+     */
+    add(item: T): void;
+    /**
+     * Add multiple items to batch queue
+     */
+    addMany(items: T[]): void;
+    /**
+     * Schedule flush after delay
+     *
+     * @private
+     */
+    private scheduleFlush;
+    /**
+     * Flush queue immediately
+     */
+    flush(): void;
+    /**
+     * Clear queue without processing
+     */
+    clear(): void;
+    /**
+     * Get current queue size
+     */
+    size(): number;
+    /**
+     * Check if processor is idle
+     */
+    isIdle(): boolean;
+    /**
+     * Destroy batch processor
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=batch-processor.d.ts.map

package/dist/src/reactive/batch-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-processor.d.ts","sourceRoot":"","sources":["../../../src/reactive/batch-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;CACnC;AAED,qBAAa,cAAc,CAAC,CAAC;IAC3B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,YAAY,CAAS;gBAEjB,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC;IAO7C;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAWlB;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAUzB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,KAAK,IAAI,IAAI;IA6Bb;;OAEG;IACH,KAAK,IAAI,IAAI;IASb;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACH,OAAO,IAAI,IAAI;CAQhB"}

package/dist/src/reactive/core/batch-manager.d.ts

@@ -0,0 +1,48 @@
+/**
+ * BatchManager - Batch event handling
+ *
+ * @description
+ * Manages batching mode and event queuing.
+ * Extracted from ReactiveState for modularity.
+ * Implements IBatchManager for loose coupling.
+ */
+import type { IBatchManager } from '../interfaces';
+export declare class BatchManager<E> implements IBatchManager<E> {
+    private batchMode;
+    private batchedEvents;
+    /**
+     * Check if currently in batch mode
+     */
+    isBatching(): boolean;
+    /**
+     * Enter batch mode
+     */
+    enterBatch(): void;
+    /**
+     * Exit batch mode
+     */
+    exitBatch(): void;
+    /**
+     * Add event to batch queue
+     */
+    addEvent(key: string, event: E): void;
+    /**
+     * Get and clear batched events
+     */
+    flushEvents(): Array<{
+        key: string;
+        event: E;
+    }>;
+    /**
+     * Group events by key
+     */
+    groupEventsByKey(events: Array<{
+        key: string;
+        event: E;
+    }>): Map<string, E[]>;
+    /**
+     * Clear all batched events
+     */
+    clear(): void;
+}
+//# sourceMappingURL=batch-manager.d.ts.map

package/dist/src/reactive/core/batch-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-manager.d.ts","sourceRoot":"","sources":["../../../../src/reactive/core/batch-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,qBAAa,YAAY,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACtD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAAwC;IAE7D;;OAEG;IACH,UAAU,IAAI,OAAO;IAIrB;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,SAAS,IAAI,IAAI;IAIjB;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAIrC;;OAEG;IACH,WAAW,IAAI,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,CAAC;IAM/C;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;IAa5E;;OAEG;IACH,KAAK,IAAI,IAAI;CAId"}

package/dist/src/reactive/core/batch-queue.d.ts

@@ -0,0 +1,39 @@
+/**
+ * BatchQueue - Manages batching queue and deduplication
+ *
+ * @description
+ * Handles queueing items and optional deduplication.
+ * Extracted from BatchProcessor for modularity.
+ *
+ * @internal
+ */
+export declare class BatchQueue<T> {
+    private queue;
+    private deduplicate?;
+    constructor(deduplicate?: (items: T[]) => T[]);
+    /**
+     * Add item to queue
+     */
+    add(item: T): void;
+    /**
+     * Add multiple items to queue
+     */
+    addMany(items: T[]): void;
+    /**
+     * Get queue size
+     */
+    size(): number;
+    /**
+     * Check if queue is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Clear queue
+     */
+    clear(): void;
+    /**
+     * Flush queue (get and clear items)
+     */
+    flush(): T[];
+}
+//# sourceMappingURL=batch-queue.d.ts.map

package/dist/src/reactive/core/batch-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-queue.d.ts","sourceRoot":"","sources":["../../../../src/reactive/core/batch-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,qBAAa,UAAU,CAAC,CAAC;IACvB,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,WAAW,CAAC,CAAsB;gBAE9B,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE;IAI7C;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAIlB;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAIzB;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,KAAK,IAAI,CAAC,EAAE;CAWb"}

package/dist/src/reactive/core/event-handler-registry.d.ts

@@ -0,0 +1,52 @@
+/**
+ * EventHandlerRegistry - Manages element event handlers
+ *
+ * @description
+ * Storage and lookup for element event handlers.
+ * Extracted from EventDelegator for modularity.
+ *
+ * @internal
+ */
+export interface ElementEventHandlers {
+    onClick?: (event: MouseEvent) => void;
+    onDblClick?: (event: MouseEvent) => void;
+    onMouseDown?: (event: MouseEvent) => void;
+    onMouseUp?: (event: MouseEvent) => void;
+    onMouseEnter?: (event: MouseEvent) => void;
+    onMouseLeave?: (event: MouseEvent) => void;
+    onContextMenu?: (event: MouseEvent) => void;
+    onFocus?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+}
+export declare class EventHandlerRegistry {
+    private handlers;
+    /**
+     * Register handlers for element
+     */
+    register(elementId: string, handlers: ElementEventHandlers): void;
+    /**
+     * Unregister element handlers
+     */
+    unregister(elementId: string): void;
+    /**
+     * Update element handlers
+     */
+    update(elementId: string, handlers: ElementEventHandlers, merge: boolean): void;
+    /**
+     * Get handlers for element
+     */
+    get(elementId: string): ElementEventHandlers | undefined;
+    /**
+     * Get handler for specific event type
+     */
+    getHandler(elementId: string, handlerName: keyof ElementEventHandlers): ((event: any) => void) | undefined;
+    /**
+     * Get registry size (for monitoring)
+     */
+    size(): number;
+    /**
+     * Clear all handlers
+     */
+    clear(): void;
+}
+//# sourceMappingURL=event-handler-registry.d.ts.map

package/dist/src/reactive/core/event-handler-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handler-registry.d.ts","sourceRoot":"","sources":["../../../../src/reactive/core/event-handler-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACzC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC1C,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACxC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC3C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC3C,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CACtC;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAA2C;IAE3D;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAIjE;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAInC;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAS/E;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;IAIxD;;OAEG;IACH,UAAU,CACR,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,oBAAoB,GACtC,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,SAAS;IAKrC;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd"}

package/dist/src/reactive/core/event-mapper.d.ts

@@ -0,0 +1,37 @@
+/**
+ * EventMapper - Maps handler names to DOM event names
+ *
+ * @description
+ * Utility for converting handler names (onClick) to DOM events (click).
+ * Extracted from EventDelegator for modularity.
+ *
+ * @internal
+ */
+import type { ElementEventHandlers } from './event-handler-registry';
+/**
+ * Event configuration
+ */
+interface EventConfig {
+    domEvent: string;
+    useCapture: boolean;
+}
+export declare class EventMapper {
+    /**
+     * Get all supported handler names
+     */
+    static getHandlerNames(): Array<keyof ElementEventHandlers>;
+    /**
+     * Get DOM event name from handler name
+     */
+    static getDomEventName(handlerName: keyof ElementEventHandlers): string;
+    /**
+     * Check if event should use capture phase
+     */
+    static shouldUseCapture(handlerName: keyof ElementEventHandlers): boolean;
+    /**
+     * Get event config
+     */
+    static getEventConfig(handlerName: keyof ElementEventHandlers): EventConfig;
+}
+export {};
+//# sourceMappingURL=event-mapper.d.ts.map

package/dist/src/reactive/core/event-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-mapper.d.ts","sourceRoot":"","sources":["../../../../src/reactive/core/event-mapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;GAEG;AACH,UAAU,WAAW;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;CACrB;AAiBD,qBAAa,WAAW;IACtB;;OAEG;IACH,MAAM,CAAC,eAAe,IAAI,KAAK,CAAC,MAAM,oBAAoB,CAAC;IAI3D;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,MAAM,oBAAoB,GAAG,MAAM;IAIvE;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,MAAM,oBAAoB,GAAG,OAAO;IAIzE;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,WAAW,EAAE,MAAM,oBAAoB,GAAG,WAAW;CAG5E"}

package/dist/src/reactive/core/pool-stats.d.ts

@@ -0,0 +1,47 @@
+/**
+ * PoolStats - Object pool statistics tracking
+ *
+ * @description
+ * Tracks pool performance metrics.
+ * Extracted from ObjectPool for modularity.
+ *
+ * @internal
+ */
+export interface ObjectPoolStats {
+    available: number;
+    created: number;
+    acquired: number;
+    released: number;
+    hitRate: number;
+    maxSize: number;
+}
+export declare class PoolStatsTracker {
+    private createdCount;
+    private acquireCount;
+    private releaseCount;
+    /**
+     * Increment created count
+     */
+    incrementCreated(): void;
+    /**
+     * Increment acquired count
+     */
+    incrementAcquired(): void;
+    /**
+     * Increment released count
+     */
+    incrementReleased(): void;
+    /**
+     * Calculate hit rate (% of acquires from pool vs created)
+     */
+    calculateHitRate(): number;
+    /**
+     * Get statistics snapshot
+     */
+    getStats(availableCount: number, maxSize: number): ObjectPoolStats;
+    /**
+     * Reset all counters
+     */
+    reset(): void;
+}
+//# sourceMappingURL=pool-stats.d.ts.map

package/dist/src/reactive/core/pool-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-stats.d.ts","sourceRoot":"","sources":["../../../../src/reactive/core/pool-stats.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,YAAY,CAAK;IAEzB;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAIxB;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAIzB;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAIzB;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAQ1B;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,eAAe;IAWlE;;OAEG;IACH,KAAK,IAAI,IAAI;CAKd"}

package/dist/src/reactive/core/subscription-manager.d.ts

@@ -0,0 +1,46 @@
+/**
+ * SubscriptionManager - Manages targeted and global subscriptions
+ *
+ * @description
+ * Handles subscriber registration and notification with O(m) targeted approach.
+ * Extracted from ReactiveState for modularity.
+ * Implements ISubscriptionManager for loose coupling.
+ */
+import type { ISubscriptionManager, ISubscriber } from '../interfaces';
+export declare class SubscriptionManager<E> implements ISubscriptionManager<E> {
+    private keySubscribers;
+    private globalSubscribers;
+    /**
+     * Subscribe to specific key
+     */
+    subscribeToKey(key: string, subscriber: ISubscriber<E>): () => void;
+    /**
+     * Subscribe to all changes
+     */
+    subscribeGlobal(subscriber: ISubscriber<E>): () => void;
+    /**
+     * Notify subscribers for key (immediate)
+     */
+    notifyKey(key: string, event: E): void;
+    /**
+     * Notify subscribers with batched events
+     */
+    notifyBatch(eventsByKey: Map<string, E[]>): void;
+    /**
+     * Get subscriber count for key
+     */
+    getKeySubscriberCount(key: string): number;
+    /**
+     * Get global subscriber count
+     */
+    getGlobalSubscriberCount(): number;
+    /**
+     * Check if key has subscribers
+     */
+    hasKeySubscribers(key: string): boolean;
+    /**
+     * Clear all subscribers
+     */
+    clear(): void;
+}
+//# sourceMappingURL=subscription-manager.d.ts.map

package/dist/src/reactive/core/subscription-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-manager.d.ts","sourceRoot":"","sources":["../../../../src/reactive/core/subscription-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEvE,qBAAa,mBAAmB,CAAC,CAAC,CAAE,YAAW,oBAAoB,CAAC,CAAC,CAAC;IACpE,OAAO,CAAC,cAAc,CAA0C;IAChE,OAAO,CAAC,iBAAiB,CAA6B;IAEtD;;OAEG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAkBnE;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAKvD;;OAEG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAuBtC;;OAEG;IACH,WAAW,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI;IAoChD;;OAEG;IACH,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAI1C;;OAEG;IACH,wBAAwB,IAAI,MAAM;IAIlC;;OAEG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAKvC;;OAEG;IACH,KAAK,IAAI,IAAI;CAId"}

package/dist/src/reactive/event-delegator.d.ts

@@ -0,0 +1,84 @@
+/**
+ * EventDelegator - Event delegation for thousands of elements
+ *
+ * @description
+ * Single parent listener instead of per-element listeners (8 vs 8,000).
+ * Uses EventHandlerRegistry and EventMapper helpers.
+ *
+ * @performance
+ * - Traditional: 1000 cells × 8 events = 8,000 listeners
+ * - Delegation: 1 parent × 8 events = 8 listeners (1000x fewer!)
+ *
+ * @example
+ * ```typescript
+ * const delegator = new EventDelegator(gridContainer);
+ *
+ * // Register handlers (NO DOM listeners attached!)
+ * delegator.registerElement('cell-0-0', {
+ *   onClick: () => selectCell(0, 0),
+ *   onDblClick: () => startEditing(0, 0),
+ * });
+ *
+ * // Instant cleanup
+ * delegator.unregisterElement('cell-0-0');
+ * ```
+ */
+import { type ElementEventHandlers } from './core/event-handler-registry';
+export interface EventDelegatorOptions {
+    idAttribute?: string;
+}
+export declare class EventDelegator {
+    private container;
+    private registry;
+    private boundListeners;
+    private idAttribute;
+    constructor(container: HTMLElement, options?: EventDelegatorOptions);
+    /**
+     * Register element handlers (O(1), no DOM listeners)
+     */
+    registerElement(elementId: string, handlers: ElementEventHandlers): void;
+    /**
+     * Unregister element (O(1), instant cleanup)
+     */
+    unregisterElement(elementId: string): void;
+    /**
+     * Update element handlers
+     */
+    updateElement(elementId: string, handlers: ElementEventHandlers, merge?: boolean): void;
+    /**
+     * Attach delegated listeners to container
+     *
+     * @private
+     */
+    private attachDelegatedListeners;
+    /**
+     * Handle delegated event
+     *
+     * @private
+     */
+    private handleEvent;
+    /**
+     * Find element ID by bubbling up DOM tree
+     *
+     * @private
+     */
+    private findElementId;
+    /**
+     * Check if element is registered
+     */
+    isRegistered(elementId: string): boolean;
+    /**
+     * Get all registered element IDs
+     */
+    getAllRegisteredIds(): string[];
+    /**
+     * Get number of registered elements
+     */
+    getRegisteredCount(): number;
+    /**
+     * Cleanup all listeners and handlers
+     */
+    destroy(): void;
+}
+export type { ElementEventHandlers };
+//# sourceMappingURL=event-delegator.d.ts.map

package/dist/src/reactive/event-delegator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-delegator.d.ts","sourceRoot":"","sources":["../../../src/reactive/event-delegator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAwB,KAAK,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAGhG,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,WAAW,CAAS;gBAEhB,SAAS,EAAE,WAAW,EAAE,OAAO,GAAE,qBAA0B;IAMvE;;OAEG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAIxE;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI1C;;OAEG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,EAAE,KAAK,UAAO,GAAG,IAAI;IAIpF;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IAYhC;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAcnB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIxC;;OAEG;IACH,mBAAmB,IAAI,MAAM,EAAE;IAO/B;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;OAEG;IACH,OAAO,IAAI,IAAI;CAUhB;AAGD,YAAY,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/src/reactive/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module reactive
+ *
+ * Reusable reactive primitives for high-performance grid features
+ *
+ * @description
+ * This module provides scalable patterns for building features with
+ * thousands of interactive elements (cells, rows, columns) without
+ * performance degradation.
+ *
+ * Now with:
+ * - Interface abstractions for loose coupling
+ * - Dependency injection support
+ * - Exposed helpers for composition
+ * - Event history for debugging
+ *
+ * @performance
+ * Designed for grids with 1000+ cells:
+ * - Event listeners: O(1) not O(n)
+ * - Notifications: Targeted, not broadcast
+ * - Memory: Constant overhead, pooled resources
+ * - GC pressure: Minimal (object reuse)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   ReactiveState,
+ *   EventDelegator,
+ *   ObjectPool,
+ *   BatchProcessor
+ * } from '@zengrid/shared/reactive';
+ *
+ * // 1. Reactive state with event history (new!)
+ * const state = new ReactiveState(undefined, undefined, 100);  // 100 event history
+ *
+ * // 2. Composition with interfaces (new!)
+ * class ColumnModel {
+ *   constructor(private state: IReactiveState<ColumnState, ColumnEvent>) {}
+ * }
+ *
+ * // 3. Use exposed helpers directly (new!)
+ * import { SubscriptionManager } from '@zengrid/shared/reactive';
+ * const subs = new SubscriptionManager();
+ * ```
+ *
+ * @packageDocumentation
+ */
+export type { ISubscriber, IReactiveState, ISubscriptionManager, IBatchManager, IEventDelegator, IElementEventHandlers, IEventDelegatorOptions, IObjectPool, IObjectPoolOptions, IObjectPoolStats, IBatchProcessor, IBatchProcessorOptions, IEventHandlerRegistry, } from './interfaces';
+export { ReactiveState, type StateSubscriber, } from './reactive-state';
+export { EventDelegator, type ElementEventHandlers, // Backward compatible
+type EventDelegatorOptions, } from './event-delegator';
+export { ObjectPool, type ObjectPoolOptions, // Backward compatible
+type ObjectPoolStats, } from './object-pool';
+export { BatchProcessor, type BatchProcessorOptions, } from './batch-processor';
+export { SubscriptionManager } from './core/subscription-manager';
+export { BatchManager } from './core/batch-manager';
+export { EventHandlerRegistry } from './core/event-handler-registry';
+export { EventMapper } from './core/event-mapper';
+export { PoolStatsTracker } from './core/pool-stats';
+export { BatchQueue } from './core/batch-queue';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/reactive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reactive/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAMH,YAAY,EACV,WAAW,EACX,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AAMtB,OAAO,EACL,aAAa,EACb,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,EAAE,sBAAsB;AACjD,KAAK,qBAAqB,GAC3B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,EAAE,sBAAsB;AAC9C,KAAK,eAAe,GACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}