ezux 1.0.0

package/dist/components/EzTable/hooks/useDialogStateInitialization.d.ts

@@ -0,0 +1,8 @@
+interface UseDialogStateInitializationOptions {
+    dialogState: any;
+    isDialogMode: boolean;
+    rows: any[];
+    table: any;
+}
+export declare const useDialogStateInitialization: ({ dialogState, isDialogMode, rows, table }: UseDialogStateInitializationOptions) => void;
+export default useDialogStateInitialization;

package/dist/components/EzTable/hooks/useFilterSelection.d.ts

@@ -0,0 +1,12 @@
+/**
+ * useFilterSelection - Shared hook for managing multi-select sets in filters.
+ * Handles "(Select All)", individual selection, and bulk selection.
+ */
+export declare function useFilterSelection(initialValues: any[] | null, allAvailableValues: any[]): {
+    selectedValues: Set<any> | null;
+    isAllSelected: boolean;
+    handleSelectAll: (checked: boolean) => void;
+    handleSelect: (value: any, checked: boolean) => void;
+    handleBulkSelect: (values: any[], checked: boolean) => void;
+    clearSelection: () => void;
+};

package/dist/components/EzTable/hooks/useTableFiltering.d.ts

@@ -0,0 +1,23 @@
+import { Table } from '@tanstack/react-table';
+import { EzTableProps } from '../EzTable.types';
+/**
+ * Handles filtering and search logic for EzTable.
+ * Integrates with useTransition for performance and fires legacy/modern events.
+ *
+ * @param props - Table properties of type {@link EzTableProps}
+ * @param table - The TanStack Table instance
+ * @returns Filtering state and handlers
+ * @group Hooks
+ */
+export declare const useTableFiltering: <TData extends object>(props: EzTableProps<TData>, table: Table<TData>) => {
+    /** Whether a filter/search transition is in progress. @group State */
+    isFiltering: boolean;
+    /** Handler for column filter changes. @group Events */
+    handleColumnFiltersChange: (updater: any) => void;
+    /** Handler for global filter changes. @group Events */
+    handleGlobalFilterChange: (updater: any) => void;
+    /** Programmatically set the filter model. @group Methods */
+    setFilterModel: (updater: import('@tanstack/table-core').Updater<import('@tanstack/table-core').ColumnFiltersState>) => void;
+    /** Programmatically set the global filter. @group Methods */
+    setGlobalFilter: (updater: import('@tanstack/table-core').Updater<any>) => void;
+};

package/dist/components/EzTable/hooks/useTableHistory.d.ts

@@ -0,0 +1,87 @@
+import { SetStateAction } from 'react';
+/**
+ * Supported action types for table history tracking.
+ */
+export type TableActionType = 'ADD_ROW' | 'DELETE_ROW' | 'EDIT_CELL';
+/**
+ * Represents a single action in the table history.
+ * @group Models
+ */
+export interface TableAction<TData> {
+    /** Type of action performed. @group Properties */
+    type: TableActionType;
+    /** Metadata about the action (row, column, values). @group Properties */
+    payload: {
+        rowIndex?: number;
+        rowId?: string | number;
+        columnId?: string;
+        oldValue?: any;
+        newValue?: any;
+        row?: TData;
+    };
+    /** Execution timestamp. @group Properties */
+    timestamp: number;
+}
+/**
+ * State container for undo/redo history.
+ * @group Models
+ */
+export interface HistoryState<TData> {
+    /** List of past actions (undo stack). @group Properties */
+    past: TableAction<TData>[];
+    /** List of future actions (redo stack). @group Properties */
+    future: TableAction<TData>[];
+}
+/**
+ * Internal state structure for the history hook.
+ * @group Models
+ */
+export interface TableHistoryState<TData> {
+    /** Current table data. @group Properties */
+    data: TData[];
+    /** History stacks. @group Properties */
+    history: HistoryState<TData>;
+}
+/**
+ * Optimized hook for managing table data with undo/redo capabilities.
+ * Tracks added, edited, and deleted rows relative to the initial dataset.
+ *
+ * @param initialData - The baseline data for the table
+ * @param idField - Field name used as a unique identifier (default: 'id')
+ * @returns State and methods for data manipulation and history tracking
+ * @group Hooks
+ */
+export declare const useTableHistory: <TData extends object>(initialData: TData[], idField?: string) => {
+    /** Current table data including uncommitted changes. @group State */
+    data: TData[];
+    /** Programmatically set the table data. @group Methods */
+    setData: (action: SetStateAction<TData[]>) => void;
+    /** Perform a cell edit at a specific coordinate. @group Methods */
+    performEdit: (rowIndex: number, columnId: string, newValue: any) => void;
+    /** Add a new row to the data. @group Methods */
+    addRow: (newRow: TData, index?: number) => void;
+    /** Delete one or more rows by index. @group Methods */
+    deleteRows: (rowIndices: number[]) => void;
+    /** Undo the last recorded action. @group Methods */
+    undo: () => void;
+    /** Redo the last undone action. @group Methods */
+    redo: () => void;
+    /** Whether undo is currently available. @group State */
+    canUndo: boolean;
+    /** Whether redo is currently available. @group State */
+    canRedo: boolean;
+    /** Dictionary of change counts (added, edited, deleted) relative to initialData. @group State */
+    changes: {
+        added: number;
+        edited: number;
+        deleted: number;
+    };
+    /** Detailed lists of added, changed, and deleted records. @group State */
+    batchChanges: {
+        addedRecords: TData[];
+        changedRecords: TData[];
+        deletedRecords: TData[];
+    };
+    /** Reset all changes back to the initial state. @group Methods */
+    resetData: () => void;
+};

package/dist/components/EzTable/hooks/useTableImperative.d.ts

@@ -0,0 +1,42 @@
+import { Table } from '@tanstack/react-table';
+import { EzTableProps, EzTableRef } from '../EzTable.types';
+/**
+ * Consolidates the massive imperative API for EzTable using shared factory utilities.
+ * Reduces boilerplate and ensures consistent naming conventions.
+ */
+export declare const useTableImperative: <TData extends object>(props: EzTableProps<TData>, table: Table<TData>, data: TData[], methods: {
+    refresh: () => void;
+    setData: React.Dispatch<React.SetStateAction<TData[]>>;
+    performEdit: (rowIndex: number, columnId: string, value: unknown) => void;
+    showSpinner: () => void;
+    hideSpinner: () => void;
+    scrollToIndex: (index: number) => void;
+    toggleRowEditing: (rowIndex: number, editing?: boolean) => void;
+    forceUpdate: () => void;
+    resetData: () => void;
+    setPagerMessage: (msg: string | undefined) => void;
+    batchChanges: {
+        addedRecords: TData[];
+        changedRecords: TData[];
+        deletedRecords: TData[];
+    };
+    changes: {
+        added: number;
+        edited: number;
+        deleted: number;
+    };
+    addRow: (row: TData, index?: number) => void;
+    deleteRows: (indices: number[]) => void;
+    setFocusedCell: (cell: {
+        r: number;
+        c: number;
+    } | null) => void;
+    autoFitColumn: (columnId: string, options?: {
+        onlyVisible?: boolean;
+        maxWidth?: number;
+    }) => void;
+    addMutation?: any;
+    updateMutation?: any;
+    deleteMutation?: any;
+    service?: any;
+}, ref: React.Ref<EzTableRef<TData>>, extraApi?: any) => EzTableRef<TData>;

package/dist/components/EzTable/hooks/useTableSelection.d.ts

@@ -0,0 +1,32 @@
+import { Table } from '@tanstack/react-table';
+import { EzTableProps } from '../EzTable.types';
+/**
+ * Handles selection logic for EzTable, including range selection.
+ * Integrates with TanStack table's selection state for row selection.
+ *
+ * @param props - Table properties of type {@link EzTableProps}
+ * @param table - The TanStack Table instance
+ * @returns Selection state and event handlers
+ * @group Hooks
+ */
+export declare const useTableSelection: <TData extends object>(props: EzTableProps<TData>, table: Table<TData>) => {
+    /** Cell-based range selection state. @group State */
+    rangeSelection: {
+        start: {
+            r: number;
+            c: number;
+        };
+        end: {
+            r: number;
+            c: number;
+        };
+    } | null;
+    /** Handler for mouse down event on a cell. @group Events */
+    onCellMouseDown: (rowIndex: number, colIndex: number) => void;
+    /** Handler for mouse enter event on a cell. @group Events */
+    onCellMouseEnter: (rowIndex: number, colIndex: number) => void;
+    /** Imperatively select a range of rows. @group Methods */
+    selectRowByRange: (startIndex: number, endIndex: number) => void;
+    /** Whether a selection operation is currently active. @group State */
+    isSelecting: boolean;
+};

package/dist/components/EzTable/hooks/useTableState.d.ts

@@ -0,0 +1,31 @@
+import { SortingState, ColumnFiltersState, PaginationState, RowSelectionState, GroupingState, ExpandedState, RowPinningState, ColumnPinningState, Table } from '@tanstack/react-table';
+import { EzTableProps, EzGlobalFilterState } from '../EzTable.types';
+/**
+ * Core state and TanStack table instance initialization for EzTable.
+ * Handles persistence and basic state synchronization via unified useComponentState.
+ */
+export declare const useTableState: <TData extends object>(props: EzTableProps<TData>, currentData: TData[]) => {
+    table: Table<TData>;
+    states: {
+        sorting: SortingState;
+        setSorting: (updater: any) => void;
+        columnFilters: ColumnFiltersState;
+        setColumnFilters: (updater: any) => void;
+        globalFilter: EzGlobalFilterState;
+        setGlobalFilter: (updater: any) => void;
+        rowSelection: RowSelectionState;
+        setRowSelection: (updater: any) => void;
+        paginationState: PaginationState;
+        setPaginationState: (updater: any) => void;
+        grouping: GroupingState;
+        setGrouping: (updater: any) => void;
+        expanded: ExpandedState;
+        setExpanded: (updater: any) => void;
+        rowPinning: RowPinningState;
+        setRowPinning: (updater: any) => void;
+        columnPinning: ColumnPinningState;
+        setColumnPinning: (updater: any) => void;
+        columnVisibility: Record<string, boolean>;
+        setColumnVisibility: (updater: any) => void;
+    };
+};

package/dist/components/EzTable/hooks/useTableVirtualization.d.ts

@@ -0,0 +1,33 @@
+import { Table } from '@tanstack/react-table';
+import { EzTableProps } from '../EzTable.types';
+/**
+ * Handles table virtualization using the shared useVirtualization hook.
+ * Maps table density and column sizes to virtualization parameters.
+ *
+ * @param props - Table properties of type {@link EzTableProps}
+ * @param table - The TanStack Table instance
+ * @returns Virtualization state and scroll methods
+ * @group Hooks
+ */
+export declare const useTableVirtualization: <TData extends object>(props: EzTableProps<TData>, table: Table<TData>, dir?: "ltr" | "rtl") => {
+    /** Reference to the scrollable container. @group Properties */
+    parentRef: import('react').RefObject<HTMLDivElement | null>;
+    /** Row virtualizer instance. @group Properties */
+    rowVirtualizer: import('@tanstack/virtual-core').Virtualizer<HTMLDivElement, Element>;
+    /** Column virtualizer instance (if enabled). @group Properties */
+    columnVirtualizer: import('@tanstack/virtual-core').Virtualizer<HTMLDivElement, Element> | undefined;
+    /** Scroll to a specific item index. @group Methods */
+    scrollToIndex: (index: number, options?: {
+        align?: "start" | "center" | "end" | "auto";
+    }) => void;
+    /** Scroll to a specific row. @group Methods */
+    scrollToRow: (index: number, options?: {
+        align?: "start" | "center" | "end" | "auto";
+    }) => void;
+    /** Scroll to a specific column. @group Methods */
+    scrollToColumn: ((index: number, options?: {
+        align?: "start" | "center" | "end" | "auto";
+    }) => void) | undefined;
+    /** Calculated row height based on density or props. @group Properties */
+    effectiveRowHeight: number;
+};

package/dist/components/EzTable/index.d.ts

@@ -0,0 +1,50 @@
+import { default as React } from 'react';
+import { EzTableProps, EzTableRef } from './EzTable.types';
+/**
+ * EzTable is a high-performance, enterprise-grade data grid engine.
+ * Built on TanStack Table v8, it combines lightweight core logic with powerful
+ * features like virtualization, advanced filtering, and modular editing.
+ *
+
+ * ### Core Capabilities
+ * - **Superior Performance**: Row and column virtualization for smooth handling of 100k+ records.
+ * - **Smart Data Fetching**: Support for infinite scroll, server-side pagination, and caching via React Query.
+ * - **Flexible Editing**: Choose between `Normal` (inline), `Dialog` (form-based), or `Batch` editing modes.
+ * - **Advanced Interactivity**: Range selection, drag-and-drop column reordering, and context menus.
+ * - **Data Intelligence**: Built-in export (Excel/CSV/PDF), column pinning, and grouping.
+ *
+ * ### Minimal Example
+ * ```tsx
+ * <EzTable
+ *   data={employees}
+ *   columns={[
+ *     { accessorKey: 'name', header: 'Name' },
+ *     { accessorKey: 'role', header: 'Role' }
+ *   ]}
+ *   pagination
+ *   enableFiltering
+ * />
+ * ```
+ *
+ * ### Advanced Config: Editing & Persistence
+ * ```tsx
+ * <EzTable
+ *   data={data}
+ *   columns={columns}
+ *   editSettings={{
+ *     allowEditing: true,
+ *     mode: 'Batch',
+ *     primaryKey: 'id'
+ *   }}
+ *   enablePersistence
+ *   persistenceKey="user-table-grid"
+ *   onBatchSave={(changes) => saveToDatabase(changes)}
+ * />
+ * ```
+ *
+ * @group Core Components
+ */
+export declare const EzTable: <TData extends object>(props: EzTableProps<TData> & {
+    ref?: React.ForwardedRef<EzTableRef<TData>>;
+}) => React.ReactElement;
+export * from './context/EzTableContext';

package/dist/components/EzTable/renderers/index.d.ts

@@ -0,0 +1,6 @@
+export * from '../../../shared/components/BaseCell';
+export * from '../../../shared/components/PrimitiveRenderer';
+export * from '../../../shared/components/BooleanRenderer';
+export * from '../../../shared/components/SelectRenderer';
+export * from '../../../shared/components/ChartRenderer';
+export * from '../../../shared/components/SearchableSelect';

package/dist/components/EzTable/services/TableService.d.ts

@@ -0,0 +1,26 @@
+import { RowData } from '@tanstack/react-table';
+import { ITableService, TableParams } from '../EzTable.types';
+/**
+ * TableService implementation following the ServiceRegistry pattern.
+ * Provides mock server-side operations like sorting, filtering, and pagination.
+ */
+export declare class TableService<T extends RowData = any> implements ITableService<T> {
+    name: string;
+    init(): Promise<void>;
+    cleanup(): Promise<void>;
+    /**
+     * Seeds the mock database with initial data.
+     */
+    initializeWithData(data: T[]): void;
+    /**
+     * Simulates fetching data from a server with support for sorting, filtering, and pagination.
+     */
+    getData(params: TableParams): Promise<{
+        data: T[];
+        totalCount: number;
+    }>;
+    createRow(row: Partial<T>): Promise<T>;
+    updateRow(id: string | number, updates: Partial<T>): Promise<T>;
+    deleteRow(id: string | number): Promise<void>;
+    private simulateLatency;
+}

package/dist/components/EzTable/useEzTable.d.ts

@@ -0,0 +1,17 @@
+import { EzTableProps, EzTableRef } from './EzTable.types';
+/**
+ * Main hook for EzTable that coordinates specialized sub-hooks.
+ * Centrally managed via useBaseComponent and modular sub-hooks.
+ *
+ * Responsibilities:
+ * - Data fetching and synchronization
+ * - State management (pagination, sorting, filtering)
+ * - History tracking (undo/redo)
+ * - Editing state and validation
+ * - Virtualization setup
+ *
+ * @param props - Table properties
+ * @param ref - Forwarded ref for imperative API
+ * @param extraApi - Additional imperative methods
+ */
+export declare const useEzTable: <TData extends object>(props: EzTableProps<TData>, ref?: React.Ref<EzTableRef<TData>>, extraApi?: any) => any;

package/dist/components/EzTable/utils/TextMeasurer.d.ts

@@ -0,0 +1 @@
+export declare const getTextWidth: (text: string, font?: string) => number;

package/dist/components/EzTable/utils/TruncatedTooltip.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface TruncatedTooltipProps {
+    children: React.ReactNode;
+    text?: string;
+}
+export declare const TruncatedTooltip: ({ children, text }: TruncatedTooltipProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/EzTable/utils/columnTypeDetector.d.ts

@@ -0,0 +1,5 @@
+export type ColumnType = 'text' | 'longtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'multiselect' | 'chart';
+/**
+ * detectColumnType - Utility to infer column type from a sample of data
+ */
+export declare function detectColumnType(values: any[]): ColumnType;

package/dist/components/EzTable/utils/filterTypeGuards.d.ts

@@ -0,0 +1,3 @@
+import { FilterGroup, FilterRule } from '../EzTable.types';
+export declare const isFilterGroup: (item: any) => item is FilterGroup;
+export declare const isFilterRule: (item: any) => item is FilterRule;

package/dist/components/EzTable/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './columnTypeDetector';