@zengrid/shared 1.0.0 → 1.0.1

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":["../../../../../packages/shared/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"}

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":["../../../../../packages/shared/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,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,CAC5E,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/types/common.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Common types used across ZenGrid algorithms and data structures
+ */
+/**
+ * Comparator function for sorting and ordering
+ * @returns Negative if a < b, zero if a === b, positive if a > b
+ */
+export type Comparator<T> = (a: T, b: T) => number;
+/**
+ * Predicate function for filtering
+ * @returns true if the value matches the condition
+ */
+export type Predicate<T> = (value: T) => boolean;
+/**
+ * Equality function for comparing values
+ * @returns true if values are equal
+ */
+export type EqualityFn<T> = (a: T, b: T) => boolean;
+/**
+ * Hash function for creating keys from values
+ * @returns string representation of the value
+ */
+export type HashFn<T> = (value: T) => string;
+/**
+ * Generic range interface
+ */
+export interface Range {
+    start: number;
+    end: number;
+}
+/**
+ * 2D rectangle interface
+ */
+export interface Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * 2D point interface
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Bounding box interface
+ */
+export interface BoundingBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+//# sourceMappingURL=common.d.ts.map

package/dist/src/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../packages/shared/src/types/common.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAEnD;;;GAGG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAEjD;;;GAGG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAEpD;;;GAGG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd"}

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

@@ -0,0 +1,5 @@
+/**
+ * Shared types for ZenGrid
+ */
+export type { Comparator, Predicate, EqualityFn, HashFn, Range, Rectangle, Point, BoundingBox, } from './common';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/shared/src/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,YAAY,EACV,UAAU,EACV,SAAS,EACT,UAAU,EACV,MAAM,EACN,KAAK,EACL,SAAS,EACT,KAAK,EACL,WAAW,GACZ,MAAM,UAAU,CAAC"}

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

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Utility functions
+ * @module @zengrid/shared/utils
+ */
+export * from './timing';
+export * from './timing.interface';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/shared/src/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC"}

package/dist/src/utils/timing.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview Timing utilities for performance optimization
+ * @module @zengrid/shared/utils/timing
+ */
+import type { DebounceOptions, DebouncedFunction, ThrottleOptions, ThrottledFunction, RAFBatchScheduler } from './timing.interface';
+/**
+ * Creates a debounced function that delays invoking func until after wait milliseconds
+ * have elapsed since the last time the debounced function was invoked.
+ *
+ * @param func - The function to debounce
+ * @param wait - The number of milliseconds to delay
+ * @param options - Options object
+ * @returns Debounced function with cancel and flush methods
+ *
+ * @example
+ * ```typescript
+ * const handleResize = debounce(() => {
+ *   console.log('Window resized');
+ * }, 250);
+ *
+ * window.addEventListener('resize', handleResize);
+ *
+ * // Cancel pending invocations
+ * handleResize.cancel();
+ *
+ * // Immediately invoke
+ * handleResize.flush();
+ * ```
+ */
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number, options?: DebounceOptions): DebouncedFunction<T>;
+/**
+ * Creates a throttled function that only invokes func at most once per every wait milliseconds.
+ *
+ * @param func - The function to throttle
+ * @param wait - The number of milliseconds to throttle invocations to
+ * @param options - Options object
+ * @returns Throttled function with cancel method
+ *
+ * @example
+ * ```typescript
+ * const handleScroll = throttle(() => {
+ *   console.log('Scrolling');
+ * }, 100);
+ *
+ * window.addEventListener('scroll', handleScroll);
+ *
+ * // Cancel pending invocation
+ * handleScroll.cancel();
+ * ```
+ */
+export declare function throttle<T extends (...args: any[]) => any>(func: T, wait: number, options?: ThrottleOptions): ThrottledFunction<T>;
+/**
+ * Creates a RAF (RequestAnimationFrame) batch scheduler that coalesces multiple
+ * updates into a single animation frame.
+ *
+ * Useful for optimizing frequent DOM updates by batching them together.
+ *
+ * @returns RAF batch scheduler
+ *
+ * @example
+ * ```typescript
+ * const scheduler = createRAFBatchScheduler();
+ *
+ * // Multiple calls in same frame will be batched
+ * scheduler.schedule(() => console.log('Update 1'));
+ * scheduler.schedule(() => console.log('Update 2'));
+ * scheduler.schedule(() => console.log('Update 3'));
+ * // All three will run in the same animation frame
+ *
+ * // Cancel all pending
+ * scheduler.cancelAll();
+ * ```
+ */
+export declare function createRAFBatchScheduler(): RAFBatchScheduler;
+/**
+ * Delays execution for specified milliseconds. Returns a promise.
+ *
+ * @param ms - Milliseconds to delay
+ * @returns Promise that resolves after delay
+ *
+ * @example
+ * ```typescript
+ * await delay(1000); // Wait 1 second
+ * console.log('1 second later');
+ * ```
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Creates a timeout promise that rejects after specified milliseconds
+ *
+ * @param ms - Milliseconds before timeout
+ * @param message - Error message
+ * @returns Promise that rejects after timeout
+ *
+ * @example
+ * ```typescript
+ * const result = await Promise.race([
+ *   fetchData(),
+ *   timeout(5000, 'Request timeout')
+ * ]);
+ * ```
+ */
+export declare function timeout(ms: number, message?: string): Promise<never>;
+//# sourceMappingURL=timing.d.ts.map

package/dist/src/utils/timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../../../../packages/shared/src/utils/timing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,GAC5B,iBAAiB,CAAC,CAAC,CAAC,CA0HtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,GAC5B,iBAAiB,CAAC,CAAC,CAAC,CAQtB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,IAAI,iBAAiB,CAoD3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,SAAY,GAAG,OAAO,CAAC,KAAK,CAAC,CAIvE"}

package/dist/src/utils/timing.interface.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview Timing utilities interfaces for performance optimization
+ * @module @zengrid/shared/utils/timing
+ */
+/**
+ * Options for debounce function
+ */
+export interface DebounceOptions {
+    /**
+     * Call function on leading edge instead of trailing edge
+     * @default false
+     */
+    leading?: boolean;
+    /**
+     * Maximum time function is allowed to be delayed before it's invoked
+     */
+    maxWait?: number;
+    /**
+     * Call function on trailing edge
+     * @default true
+     */
+    trailing?: boolean;
+}
+/**
+ * Options for throttle function
+ */
+export interface ThrottleOptions {
+    /**
+     * Call function on leading edge
+     * @default true
+     */
+    leading?: boolean;
+    /**
+     * Call function on trailing edge
+     * @default true
+     */
+    trailing?: boolean;
+}
+/**
+ * A debounced function with cancel and flush methods
+ */
+export interface DebouncedFunction<T extends (...args: any[]) => any> {
+    /**
+     * Call the debounced function
+     */
+    (...args: Parameters<T>): void;
+    /**
+     * Cancel pending function invocations
+     */
+    cancel(): void;
+    /**
+     * Immediately invoke pending function calls
+     */
+    flush(): ReturnType<T> | undefined;
+    /**
+     * Check if there are pending invocations
+     */
+    pending(): boolean;
+}
+/**
+ * A throttled function with cancel method
+ */
+export interface ThrottledFunction<T extends (...args: any[]) => any> {
+    /**
+     * Call the throttled function
+     */
+    (...args: Parameters<T>): void;
+    /**
+     * Cancel pending function invocations
+     */
+    cancel(): void;
+    /**
+     * Check if there are pending invocations
+     */
+    pending(): boolean;
+}
+/**
+ * RAF batch scheduler for coalescing multiple updates
+ */
+export interface RAFBatchScheduler {
+    /**
+     * Schedule a callback to run in the next animation frame
+     * @param callback - Function to execute
+     * @returns Cancel function
+     */
+    schedule(callback: () => void): () => void;
+    /**
+     * Cancel all pending callbacks
+     */
+    cancelAll(): void;
+    /**
+     * Get number of pending callbacks
+     */
+    getPendingCount(): number;
+}
+//# sourceMappingURL=timing.interface.d.ts.map

package/dist/src/utils/timing.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.interface.d.ts","sourceRoot":"","sources":["../../../../../packages/shared/src/utils/timing.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG;IAClE;;OAEG;IACH,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE/B;;OAEG;IACH,MAAM,IAAI,IAAI,CAAC;IAEf;;OAEG;IACH,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAEnC;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG;IAClE;;OAEG;IACH,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE/B;;OAEG;IACH,MAAM,IAAI,IAAI,CAAC;IAEf;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAE3C;;OAEG;IACH,SAAS,IAAI,IAAI,CAAC;IAElB;;OAEG;IACH,eAAe,IAAI,MAAM,CAAC;CAC3B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zengrid/shared",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "14 advanced data structures and algorithms for high-performance grids",
   "main": "./dist/index.cjs",
   "module": "./dist/index.esm.js",