@zengrid/shared 1.0.3 → 1.1.0

package/dist/src/patterns/factory.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Factory Pattern
+ *
+ * Provides an interface for creating objects, allowing subclasses
+ * to decide which class to instantiate.
+ *
+ * @example
+ * ```typescript
+ * interface Renderer {
+ *   render(value: any): string;
+ * }
+ *
+ * const rendererFactory = new Factory<Renderer>();
+ *
+ * // Register factories
+ * rendererFactory.register('text', () => ({
+ *   render: (v) => String(v)
+ * }));
+ *
+ * rendererFactory.register('number', () => ({
+ *   render: (v) => v.toLocaleString()
+ * }));
+ *
+ * // Create instances
+ * const textRenderer = rendererFactory.create('text');
+ * const numberRenderer = rendererFactory.create('number');
+ * ```
+ */
+export interface IFactory<T, K = string> {
+    /** Register a creator function for a key */
+    register(key: K, creator: () => T): void;
+    /** Create an instance using the registered creator */
+    create(key: K): T | undefined;
+    /** Check if a creator is registered */
+    has(key: K): boolean;
+    /** Unregister a creator */
+    unregister(key: K): boolean;
+    /** Get all registered keys */
+    keys(): K[];
+}
+/**
+ * Factory implementation
+ *
+ * @typeParam T - The type of objects to create
+ * @typeParam K - The type of keys (defaults to string)
+ */
+export declare class Factory<T, K = string> implements IFactory<T, K> {
+    private creators;
+    /**
+     * Register a creator function
+     *
+     * @param key - Unique identifier for this creator
+     * @param creator - Function that creates instances
+     */
+    register(key: K, creator: () => T): void;
+    /**
+     * Create an instance
+     *
+     * @param key - The key of the creator to use
+     * @returns A new instance, or undefined if key not found
+     */
+    create(key: K): T | undefined;
+    /**
+     * Check if a creator is registered
+     */
+    has(key: K): boolean;
+    /**
+     * Unregister a creator
+     *
+     * @returns true if the creator was removed, false if it didn't exist
+     */
+    unregister(key: K): boolean;
+    /**
+     * Get all registered keys
+     */
+    keys(): K[];
+    /**
+     * Clear all registered creators
+     */
+    clear(): void;
+    /**
+     * Get the number of registered creators
+     */
+    get size(): number;
+}
+/**
+ * Singleton Factory
+ *
+ * Creates a single instance per key and reuses it on subsequent calls.
+ *
+ * @example
+ * ```typescript
+ * const singletonFactory = new SingletonFactory<Renderer>();
+ *
+ * singletonFactory.register('text', () => new TextRenderer());
+ *
+ * const r1 = singletonFactory.create('text');
+ * const r2 = singletonFactory.create('text');
+ * console.log(r1 === r2); // true - same instance
+ * ```
+ */
+export declare class SingletonFactory<T, K = string> implements IFactory<T, K> {
+    private creators;
+    private instances;
+    register(key: K, creator: () => T): void;
+    create(key: K): T | undefined;
+    has(key: K): boolean;
+    unregister(key: K): boolean;
+    keys(): K[];
+    /**
+     * Clear all instances but keep creators
+     */
+    clearInstances(): void;
+    /**
+     * Clear everything
+     */
+    clear(): void;
+    get size(): number;
+}
+//# sourceMappingURL=factory.d.ts.map

package/dist/src/patterns/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/patterns/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,WAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM;IACrC,4CAA4C;IAC5C,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAEzC,sDAAsD;IACtD,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE9B,uCAAuC;IACvC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAErB,2BAA2B;IAC3B,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAE5B,8BAA8B;IAC9B,IAAI,IAAI,CAAC,EAAE,CAAC;CACb;AAED;;;;;GAKG;AACH,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAE,YAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;IAC3D,OAAO,CAAC,QAAQ,CAAyB;IAEzC;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI;IAOxC;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAe7B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAI3B;;OAEG;IACH,IAAI,IAAI,CAAC,EAAE;IAIX;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,gBAAgB,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAE,YAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;IACpE,OAAO,CAAC,QAAQ,CAAyB;IACzC,OAAO,CAAC,SAAS,CAAmB;IAEpC,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI;IASxC,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAsB7B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAK3B,IAAI,IAAI,CAAC,EAAE;IAIX;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

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

@@ -0,0 +1,21 @@
+/**
+ * Common design patterns
+ * @packageDocumentation
+ */
+export { EventEmitter } from './event-emitter';
+export type { IEventEmitter } from './event-emitter';
+export { Subject } from './observer';
+export type { IObserver, ISubject } from './observer';
+export { StateMachine } from './state-machine';
+export type { IStateMachine, StateMachineOptions, TransitionHandler } from './state-machine';
+export { BaseCoordinator } from './coordinator';
+export type { ICoordinator } from './coordinator';
+export { Factory, SingletonFactory } from './factory';
+export type { IFactory } from './factory';
+export { Mediator, MediatedComponent, EventMediator } from './mediator';
+export type { IMediator } from './mediator';
+export { ObjectPool, KeyedObjectPool } from './object-pool';
+export type { IObjectPool, ObjectPoolOptions, ObjectPoolStats } from './object-pool';
+export { resolveOperationMode, OperationModeManager } from './operation-mode';
+export type { OperationMode, ResolvedOperationMode, OperationModeConfig } from './operation-mode';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/patterns/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAG7F,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACtD,YAAY,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAG1C,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACxE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAC5D,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrF,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/src/patterns/mediator.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Mediator Pattern
+ *
+ * Defines an object that encapsulates how a set of objects interact.
+ * Promotes loose coupling by keeping objects from referring to each other explicitly.
+ *
+ * @example
+ * ```typescript
+ * class GridMediator extends Mediator {
+ *   constructor(
+ *     private viewport: ViewportManager,
+ *     private renderer: RenderCoordinator,
+ *     private sortManager: SortManager
+ *   ) {
+ *     super();
+ *   }
+ *
+ *   notify(sender: any, event: string, data?: any): void {
+ *     if (sender === this.viewport && event === 'scroll') {
+ *       // Viewport scrolled -> update renderer
+ *       this.renderer.update(data);
+ *     }
+ *
+ *     if (sender === this.sortManager && event === 'sorted') {
+ *       // Data sorted -> refresh renderer
+ *       this.renderer.refresh();
+ *     }
+ *   }
+ * }
+ *
+ * // Components notify mediator instead of each other
+ * viewport.setMediator(mediator);
+ * sortManager.setMediator(mediator);
+ * ```
+ */
+export interface IMediator {
+    /**
+     * Handle notifications from components
+     *
+     * @param sender - The component sending the notification
+     * @param event - The event name
+     * @param data - Optional event data
+     */
+    notify(sender: any, event: string, data?: any): void;
+}
+/**
+ * Base mediator class
+ */
+export declare abstract class Mediator implements IMediator {
+    /**
+     * Handle component notifications
+     *
+     * Subclasses should override this to implement mediation logic.
+     */
+    abstract notify(sender: any, event: string, data?: any): void;
+}
+/**
+ * Component that can interact with a mediator
+ */
+export declare abstract class MediatedComponent {
+    protected mediator?: IMediator;
+    /**
+     * Set the mediator for this component
+     */
+    setMediator(mediator: IMediator | undefined): void;
+    /**
+     * Notify the mediator of an event
+     */
+    protected notifyMediator(event: string, data?: any): void;
+}
+/**
+ * Event-based mediator
+ *
+ * Routes events between components without them knowing about each other.
+ *
+ * @example
+ * ```typescript
+ * const mediator = new EventMediator();
+ *
+ * // Register handlers
+ * mediator.on('scroll', (data) => {
+ *   console.log('Scroll event:', data);
+ * });
+ *
+ * // Send events
+ * mediator.notify(viewport, 'scroll', { top: 100 });
+ * ```
+ */
+export declare class EventMediator extends Mediator {
+    private handlers;
+    /**
+     * Register an event handler
+     *
+     * @param event - Event name to listen for
+     * @param handler - Handler function
+     * @returns Unsubscribe function
+     */
+    on(event: string, handler: (data?: any) => void): () => void;
+    /**
+     * Unregister an event handler
+     */
+    off(event: string, handler: (data?: any) => void): void;
+    /**
+     * Notify all handlers for an event
+     */
+    notify(_sender: any, event: string, data?: any): void;
+    /**
+     * Clear all handlers
+     */
+    clear(): void;
+    /**
+     * Clear handlers for a specific event
+     */
+    clearEvent(event: string): void;
+}
+//# sourceMappingURL=mediator.d.ts.map

package/dist/src/patterns/mediator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediator.d.ts","sourceRoot":"","sources":["../../../src/patterns/mediator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,MAAM,WAAW,SAAS;IACxB;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;CACtD;AAED;;GAEG;AACH,8BAAsB,QAAS,YAAW,SAAS;IACjD;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;CAC9D;AAED;;GAEG;AACH,8BAAsB,iBAAiB;IACrC,SAAS,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;IAE/B;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;IAIlD;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;CAG1D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAc,SAAQ,QAAQ;IACzC,OAAO,CAAC,QAAQ,CAAgD;IAEhE;;;;;;OAMG;IACH,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,MAAM,IAAI;IAU5D;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI;IAIvD;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAarD;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAGhC"}

package/dist/src/patterns/object-pool.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Generic Object Pooling Pattern
+ *
+ * Maintains a pool of reusable objects to avoid expensive creation/destruction.
+ * Useful for any frequently created/destroyed objects (DOM elements, data structures, etc.)
+ *
+ * @example
+ * ```typescript
+ * // Example 1: DOM Element Pool
+ * const divPool = new ObjectPool(
+ *   () => document.createElement('div'),
+ *   (div) => {
+ *     div.innerHTML = '';
+ *     div.className = '';
+ *     div.removeAttribute('style');
+ *   },
+ *   { initialSize: 50, maxSize: 200 }
+ * );
+ *
+ * const div = divPool.acquire();
+ * div.textContent = 'Hello';
+ * // ... use div ...
+ * divPool.release(div);
+ *
+ * // Example 2: Data Structure Pool
+ * const arrayPool = new ObjectPool(
+ *   () => [],
+ *   (arr) => arr.length = 0,  // Reset
+ *   { initialSize: 10, maxSize: 100 }
+ * );
+ *
+ * const arr = arrayPool.acquire();
+ * arr.push(1, 2, 3);
+ * // ... use arr ...
+ * arrayPool.release(arr);
+ * ```
+ */
+export interface ObjectPoolOptions {
+    /** Initial number of objects to create */
+    initialSize?: number;
+    /** Maximum number of objects to keep in pool */
+    maxSize?: number;
+}
+export interface ObjectPoolStats {
+    /** Number of objects currently in use */
+    active: number;
+    /** Number of objects available in pool */
+    available: number;
+    /** Total objects created (active + available) */
+    total: number;
+    /** Maximum pool size */
+    maxSize: number;
+}
+export interface IObjectPool<T> {
+    /** Acquire an object from the pool */
+    acquire(): T;
+    /** Release an object back to the pool */
+    release(obj: T): void;
+    /** Release all objects back to the pool */
+    releaseAll(): void;
+    /** Clear the pool and destroy all objects */
+    clear(): void;
+    /** Get pool statistics */
+    readonly stats: ObjectPoolStats;
+}
+/**
+ * Generic object pool implementation
+ *
+ * @typeParam T - The type of objects to pool
+ */
+export declare class ObjectPool<T> implements IObjectPool<T> {
+    private available;
+    private active;
+    private readonly maxSize;
+    private readonly factory;
+    private readonly reset;
+    private readonly destroy?;
+    /**
+     * Create a new object pool
+     *
+     * @param factory - Function to create new objects
+     * @param reset - Function to reset objects before releasing back to pool
+     * @param options - Pool configuration options
+     * @param destroy - Optional function to clean up objects when pool is cleared
+     */
+    constructor(factory: () => T, reset: (obj: T) => void, options?: ObjectPoolOptions, destroy?: (obj: T) => void);
+    /**
+     * Acquire an object from the pool
+     *
+     * If the pool is empty, a new object will be created.
+     *
+     * @returns An object from the pool
+     */
+    acquire(): T;
+    /**
+     * Release an object back to the pool
+     *
+     * The object will be reset before being returned to the pool.
+     * If the pool is at max capacity, the object will be destroyed.
+     *
+     * @param obj - The object to release
+     */
+    release(obj: T): void;
+    /**
+     * Release all active objects back to the pool
+     */
+    releaseAll(): void;
+    /**
+     * Clear the pool and destroy all objects
+     */
+    clear(): void;
+    /**
+     * Get pool statistics
+     */
+    get stats(): ObjectPoolStats;
+}
+/**
+ * Keyed object pool - maintains mapping of keys to pooled objects
+ *
+ * Useful when you need to track objects by a unique identifier.
+ *
+ * @example
+ * ```typescript
+ * const cellPool = new KeyedObjectPool(
+ *   () => document.createElement('div'),
+ *   (div) => { div.innerHTML = ''; },
+ *   { maxSize: 200 }
+ * );
+ *
+ * const cell = cellPool.acquire('cell-0-0');
+ * // ... use cell ...
+ * cellPool.release('cell-0-0');
+ * ```
+ */
+export declare class KeyedObjectPool<T, K = string> {
+    private pool;
+    private keyMap;
+    constructor(factory: () => T, reset: (obj: T) => void, options?: ObjectPoolOptions, destroy?: (obj: T) => void);
+    /**
+     * Acquire an object by key
+     *
+     * If an object with this key already exists, it will be returned.
+     * Otherwise, a new object will be acquired from the pool.
+     *
+     * @param key - Unique identifier for the object
+     * @returns The object associated with this key
+     */
+    acquire(key: K): T;
+    /**
+     * Release an object by key
+     *
+     * @param key - The key of the object to release
+     */
+    release(key: K): void;
+    /**
+     * Release all objects except those with the specified keys
+     *
+     * @param activeKeys - Set of keys to keep active
+     */
+    releaseExcept(activeKeys: Set<K>): void;
+    /**
+     * Check if a key exists in the active set
+     */
+    has(key: K): boolean;
+    /**
+     * Get an object by key without acquiring
+     */
+    get(key: K): T | undefined;
+    /**
+     * Get pool statistics
+     */
+    get stats(): ObjectPoolStats;
+    /**
+     * Clear the pool
+     */
+    clear(): void;
+}
+//# sourceMappingURL=object-pool.d.ts.map

package/dist/src/patterns/object-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-pool.d.ts","sourceRoot":"","sources":["../../../src/patterns/object-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,sCAAsC;IACtC,OAAO,IAAI,CAAC,CAAC;IACb,yCAAyC;IACzC,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;IACtB,2CAA2C;IAC3C,UAAU,IAAI,IAAI,CAAC;IACnB,6CAA6C;IAC7C,KAAK,IAAI,IAAI,CAAC;IACd,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;CACjC;AAED;;;;GAIG;AACH,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IAClD,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAmB;IAE5C;;;;;;;OAOG;gBAED,OAAO,EAAE,MAAM,CAAC,EAChB,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,EACvB,OAAO,GAAE,iBAAsB,EAC/B,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI;IAc5B;;;;;;OAMG;IACH,OAAO,IAAI,CAAC;IAWZ;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;IAoBrB;;OAEG;IACH,UAAU,IAAI,IAAI;IAOlB;;OAEG;IACH,KAAK,IAAI,IAAI;IAcb;;OAEG;IACH,IAAI,KAAK,IAAI,eAAe,CAO3B;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM;IACxC,OAAO,CAAC,IAAI,CAAgB;IAC5B,OAAO,CAAC,MAAM,CAAmB;gBAG/B,OAAO,EAAE,MAAM,CAAC,EAChB,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,EACvB,OAAO,GAAE,iBAAsB,EAC/B,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI;IAK5B;;;;;;;;OAQG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;IAYlB;;;;OAIG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;IAQrB;;;;OAIG;IACH,aAAa,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI;IAcvC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAI1B;;OAEG;IACH,IAAI,KAAK,IAAI,eAAe,CAE3B;IAED;;OAEG;IACH,KAAK,IAAI,IAAI;CAId"}

package/dist/src/patterns/observer.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Observer Pattern
+ *
+ * Defines a one-to-many dependency between objects so that when one object changes state,
+ * all its dependents are notified and updated automatically.
+ *
+ * @example
+ * ```typescript
+ * interface DataUpdate {
+ *   type: 'add' | 'update' | 'delete';
+ *   data: any;
+ * }
+ *
+ * // Create a subject
+ * class DataModel extends Subject<DataUpdate> {
+ *   updateData(data: any): void {
+ *     // Update internal state
+ *     // Notify observers
+ *     this.notify({ type: 'update', data });
+ *   }
+ * }
+ *
+ * // Create an observer
+ * class DataView implements IObserver<DataUpdate> {
+ *   update(data: DataUpdate): void {
+ *     console.log('Data changed:', data);
+ *     // Update UI
+ *   }
+ * }
+ *
+ * // Use it
+ * const model = new DataModel();
+ * const view = new DataView();
+ *
+ * model.attach(view);
+ * model.updateData({ id: 1, name: 'Test' }); // view.update() is called
+ * ```
+ */
+export interface IObserver<T> {
+    /**
+     * Called when the subject's state changes
+     * @param data - The data from the subject
+     */
+    update(data: T): void;
+}
+export interface ISubject<T> {
+    /**
+     * Attach an observer to this subject
+     * @param observer - The observer to attach
+     */
+    attach(observer: IObserver<T>): void;
+    /**
+     * Detach an observer from this subject
+     * @param observer - The observer to detach
+     */
+    detach(observer: IObserver<T>): void;
+    /**
+     * Notify all attached observers
+     * @param data - The data to send to observers
+     */
+    notify(data: T): void;
+}
+/**
+ * Base implementation of the Subject interface
+ */
+export declare class Subject<T> implements ISubject<T> {
+    private observers;
+    /**
+     * Attach an observer to this subject
+     */
+    attach(observer: IObserver<T>): void;
+    /**
+     * Detach an observer from this subject
+     */
+    detach(observer: IObserver<T>): void;
+    /**
+     * Notify all attached observers
+     */
+    notify(data: T): void;
+    /**
+     * Get the number of attached observers
+     */
+    protected getObserverCount(): number;
+    /**
+     * Clear all observers
+     */
+    protected clearObservers(): void;
+}
+//# sourceMappingURL=observer.d.ts.map

package/dist/src/patterns/observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer.d.ts","sourceRoot":"","sources":["../../../src/patterns/observer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAErC;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAErC;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;CACvB;AAED;;GAEG;AACH,qBAAa,OAAO,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IAC5C,OAAO,CAAC,SAAS,CAA2B;IAE5C;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI;IAIpC;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI;IAIpC;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAUrB;;OAEG;IACH,SAAS,CAAC,gBAAgB,IAAI,MAAM;IAIpC;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;CAGjC"}

package/dist/src/patterns/operation-mode.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Operation Mode Pattern
+ *
+ * Shared pattern for frontend/backend operation modes across grid features.
+ * Used for data loading, sorting, filtering, and other operations that can
+ * be executed either in-memory (frontend) or delegated to server (backend).
+ */
+/**
+ * Operation mode type
+ * - 'frontend': Execute operation in-memory (fast, suitable for loaded data)
+ * - 'backend': Delegate operation to server (ideal for large datasets, pagination)
+ * - 'auto': Automatically choose based on callback presence
+ */
+export type OperationMode = 'frontend' | 'backend' | 'auto';
+/**
+ * Resolved operation mode (auto is resolved to frontend or backend)
+ */
+export type ResolvedOperationMode = 'frontend' | 'backend';
+/**
+ * Operation mode configuration
+ */
+export interface OperationModeConfig<TCallback = any> {
+    /**
+     * Operation mode
+     * @default 'frontend'
+     */
+    mode?: OperationMode;
+    /**
+     * Callback for backend operations
+     * If provided with mode='auto', backend mode is used
+     */
+    callback?: TCallback;
+    /**
+     * Threshold for auto mode decision (optional)
+     * E.g., if rowCount > threshold, use backend mode
+     */
+    autoThreshold?: number;
+}
+/**
+ * Resolve operation mode from configuration
+ *
+ * @param config - Operation mode configuration
+ * @param context - Optional context for auto mode decisions (e.g., rowCount)
+ * @returns Resolved mode ('frontend' or 'backend')
+ */
+export declare function resolveOperationMode<TCallback = any>(config: OperationModeConfig<TCallback>, context?: {
+    rowCount?: number;
+}): ResolvedOperationMode;
+/**
+ * Operation mode manager - Base class for feature-specific managers
+ */
+export declare abstract class OperationModeManager<TCallback = any> {
+    protected mode: ResolvedOperationMode;
+    protected callback?: TCallback;
+    constructor(config: OperationModeConfig<TCallback>, context?: {
+        rowCount?: number;
+    });
+    /**
+     * Get current operation mode
+     */
+    getMode(): ResolvedOperationMode;
+    /**
+     * Check if in frontend mode
+     */
+    isFrontendMode(): boolean;
+    /**
+     * Check if in backend mode
+     */
+    isBackendMode(): boolean;
+    /**
+     * Execute operation based on mode
+     */
+    protected executeOperation<TResult>(frontendOperation: () => TResult | Promise<TResult>, backendOperation: () => TResult | Promise<TResult>): Promise<TResult>;
+}
+//# sourceMappingURL=operation-mode.d.ts.map

package/dist/src/patterns/operation-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-mode.d.ts","sourceRoot":"","sources":["../../../src/patterns/operation-mode.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,SAAS,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAC,SAAS,GAAG,GAAG;IAClD;;;OAGG;IACH,IAAI,CAAC,EAAE,aAAa,CAAC;IAErB;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IAErB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,GAAG,GAAG,EAClD,MAAM,EAAE,mBAAmB,CAAC,SAAS,CAAC,EACtC,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9B,qBAAqB,CAmBvB;AAED;;GAEG;AACH,8BAAsB,oBAAoB,CAAC,SAAS,GAAG,GAAG;IACxD,SAAS,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACtC,SAAS,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;gBAEnB,MAAM,EAAE,mBAAmB,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAKnF;;OAEG;IACH,OAAO,IAAI,qBAAqB;IAIhC;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;cACa,gBAAgB,CAAC,OAAO,EACtC,iBAAiB,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACnD,gBAAgB,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACjD,OAAO,CAAC,OAAO,CAAC;CAOpB"}