@shival99/z-ui 1.9.12 → 1.9.14

package/types/shival99-z-ui-components-z-table.d.ts

@@ -1,11 +1,11 @@
-import * as _shival99_angular_virtual from '@shival99/angular-virtual';
 import * as _tanstack_angular_table from '@tanstack/angular-table';
-import { RowData, SortingState, ColumnFiltersState, PaginationState, RowSelectionState, ExpandedState, HeaderContext, CellContext, FlexRenderComponent, Row, ColumnPinningState, RowPinningState, VisibilityState, ColumnOrderState, createAngularTable, Column, Table, ColumnDef } from '@tanstack/angular-table';
+import { RowData, SortingState, ColumnFiltersState, PaginationState, RowSelectionState, ExpandedState, HeaderContext, CellContext, FlexRenderComponent, Row, ColumnPinningState, RowPinningState, VisibilityState, ColumnOrderState, Column, createAngularTable, Table, ColumnDef } from '@tanstack/angular-table';
+import * as _shival99_angular_virtual from '@shival99/angular-virtual';
 import * as _shival99_z_ui_components_z_input from '@shival99/z-ui/components/z-input';
 import { ZInputSize } from '@shival99/z-ui/components/z-input';
 import * as _angular_core from '@angular/core';
 import { TemplateRef, Type, AfterViewInit, ElementRef, OnDestroy, OnInit } from '@angular/core';
-import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { CdkDragDrop, CdkDragEnd } from '@angular/cdk/drag-drop';
 import { ClassValue } from 'clsx';
 import { NgScrollbar } from 'ngx-scrollbar';
 import { ZAutocompleteType, ZAutocompleteOption } from '@shival99/z-ui/components/z-autocomplete';
@@ -19,12 +19,33 @@ import * as _shival99_z_ui_components_z_table from '@shival99/z-ui/components/z-
 import { ZDateRange } from '@shival99/z-ui/components/z-calendar';
 import { ZDropdownMenuItem } from '@shival99/z-ui/components/z-dropdown-menu';
 
+/**
+ * Z-Table Type Definitions
+ *
+ * Central type file for the z-table component. Contains:
+ * - Default constants (row heights, sizing, debounce timers)
+ * - Column configuration types (header, body, footer)
+ * - Sort/filter/edit configuration interfaces
+ * - Event contracts for parent-component communication
+ * - Unified change event discriminated union
+ * - Virtual scrolling configuration
+ * - Settings persistence types
+ * - TanStack Table module augmentation for custom table meta
+ */
+
+/**
+ * A virtual group represents one or more consecutive rows that must be
+ * rendered together (e.g. rows sharing a rowSpan). The virtualizer operates
+ * on groups rather than individual rows to keep merged cells intact.
+ */
 interface ZVirtualGroup {
     startIndex: number;
     endIndex: number;
     rowCount: number;
+    /** null when dynamicSize is enabled — height is measured after render */
     height: number | null;
 }
+/** Parsed segment from the `[icon:name|size:16|class:text-red]` inline icon syntax */
 interface ZTableIconPart {
     type: 'text' | 'icon';
     value: string;
@@ -33,18 +54,35 @@ interface ZTableIconPart {
     strokeWidth?: number;
 }
 type ZTableAlign = 'left' | 'center' | 'right';
+/**
+ * Body cell content — supports static values, Angular templates/components,
+ * or a function that receives the cell context and returns dynamic content.
+ */
 type ZTableCellContent<T> = string | number | TemplateRef<{
     $implicit: CellContext<T, unknown>;
 }> | Type<unknown> | FlexRenderComponent<unknown> | ((info: CellContext<T, unknown>) => string | number | TemplateRef<unknown> | FlexRenderComponent<unknown>);
+/** Header/footer cell content — similar to body but uses HeaderContext */
 type ZTableHeaderContent<T> = string | TemplateRef<unknown> | Type<unknown> | (() => string) | ((info: HeaderContext<T, unknown>) => string);
+/** Alias for ZTableColumnConfig — kept for backward compatibility */
 type ZTableColumn<T = unknown> = ZTableColumnConfig<T>;
+/** Available column filter input types */
 type ZTableFilterType = 'text' | 'number' | 'select' | 'multi-select' | 'date' | 'date-range' | 'range' | 'tags';
+/** Available inline cell edit input types */
 type ZTableEditType = 'text' | 'number' | 'select' | 'date' | 'checkbox' | 'textarea' | 'toggle' | 'autocomplete';
+/**
+ * Table operation mode:
+ * - 'local': data is fully client-side (sort/filter/paginate handled by TanStack)
+ * - 'server': parent handles data fetching; table emits change events for server calls
+ */
 type ZTableMode = 'local' | 'server';
+/** Per-column sort configuration; mode controls local vs server-side sorting */
 interface ZTableSortConfig<T> {
     enabled?: boolean;
+    /** 'local' = TanStack sorts in-memory; 'server' = emits event for API call */
     mode?: ZTableMode;
+    /** Custom key sent with server-side sort events (defaults to column id) */
     sortKey?: string;
+    /** Custom comparator for local sorting */
     sortFn?: (rowA: Row<T>, rowB: Row<T>, columnId: string) => number;
 }
 type ZTableBuiltInFilterFn = 'equalsString' | 'includesString' | 'includesStringSensitive' | 'arrIncludes' | 'arrIncludesAll' | 'arrIncludesSome' | 'equals' | 'weakEquals' | 'inNumberRange';
@@ -110,10 +148,16 @@ interface ZTableEditConfig<T = unknown> {
     /** Allow typing custom values when no options match. Default: false */
     autocompleteAllowCustomValue?: boolean;
 }
+/** Minimal column info stored alongside saved config for cache invalidation */
 interface ZTableSavedColumnInfo {
     id: string;
     accessorKey?: string;
 }
+/**
+ * Shape of the persisted table configuration (via ZCacheService).
+ * Restored when a table with matching zKey re-mounts.
+ * columnInfo is used to detect schema changes and invalidate stale caches.
+ */
 interface ZTableSavedConfig {
     columnOrder: string[];
     columnSizing: Record<string, number>;
@@ -127,6 +171,11 @@ interface ZTableSavedConfig {
     showHorizontalBorder: boolean;
     showVerticalBorder: boolean;
 }
+/**
+ * Imperative control handle emitted via `zControl` output.
+ * Allows parent components to programmatically manipulate table state
+ * (add/update/delete items, reset filters, toggle settings, etc.).
+ */
 interface ZTableControl<T> {
     updateConfig: (config: Partial<ZTableConfig<T>>) => void;
     toggleSettings: () => void;
@@ -138,6 +187,7 @@ interface ZTableControl<T> {
     getItems: () => T[];
     setColumnVisibility: (columnIds: string | string[], visible: boolean) => void;
 }
+/** Header cell configuration — applied to the <th> in the table header row */
 interface ZTableHeaderColumnConfig<T> {
     content?: ZTableHeaderContent<T>;
     class?: string;
@@ -145,22 +195,31 @@ interface ZTableHeaderColumnConfig<T> {
     align?: ZTableAlign;
     rowSpan?: number;
     colSpan?: number;
+    /** Class applied to the inner content wrapper, not the <th> itself */
     contentClass?: string | ((info: HeaderContext<T, unknown>) => string);
     contentStyle?: Record<string, string> | ((info: HeaderContext<T, unknown>) => Record<string, string>);
     tooltip?: string | ZTooltipConfig;
 }
+/**
+ * Body cell configuration — most properties accept a static value or
+ * a function receiving CellContext for per-row dynamic behavior.
+ */
 interface ZTableBodyColumnConfig<T> {
     content?: ZTableCellContent<T>;
     class?: string | ((info: CellContext<T, unknown>) => string);
     style?: Record<string, string> | ((info: CellContext<T, unknown>) => Record<string, string>);
     align?: ZTableAlign;
+    /** Static rowSpan or function returning 0 to hide the cell (merged into neighbor) */
     rowSpan?: number | ((info: CellContext<T, unknown>) => number);
     colSpan?: number | ((info: CellContext<T, unknown>) => number);
     contentClass?: string | ((info: CellContext<T, unknown>) => string);
     contentStyle?: Record<string, string> | ((info: CellContext<T, unknown>) => Record<string, string>);
     tooltip?: string | ZTooltipConfig | ((info: CellContext<T, unknown>) => string | ZTooltipConfig);
+    /** Action buttons rendered inside this cell */
     actions?: ZTableActionColumnConfig<T>;
+    /** When true, clicking the cell emits a cellClick event */
     enabledClick?: boolean;
+    /** Enable inline editing — true uses defaults, or pass full config */
     edit?: ZTableEditConfig<T> | boolean;
     /** Control cell content visibility. When false, the cell is rendered but content is hidden. */
     visible?: boolean | ((info: CellContext<T, unknown>) => boolean);
@@ -176,10 +235,23 @@ interface ZTableFooterColumnConfig<T> {
     contentStyle?: Record<string, string> | ((info: HeaderContext<T, unknown>) => Record<string, string>);
     tooltip?: string | ZTooltipConfig;
 }
+/**
+ * Primary column definition — the consumer-facing API.
+ * Converted to TanStack ColumnDef internally via `columnConfigToColumnDef()`.
+ *
+ * Shorthand: header/body/footer accept either a full config object or
+ * just the content directly (string/template/function).
+ *
+ * Nested columns: use `columns` for multi-level header groups.
+ */
 interface ZTableColumnConfig<T> {
+    /** Unique column identifier — must be stable across re-renders */
     id: string;
+    /** Pre-filter visibility — unlike columnVisibility, this removes the column entirely */
     visible?: boolean | (() => boolean);
+    /** Object property key for simple accessor — mutually exclusive with accessorFn */
     accessorKey?: keyof T & string;
+    /** Custom accessor function for derived/computed cell values */
     accessorFn?: (row: T) => unknown;
     header?: ZTableHeaderColumnConfig<T> | ZTableHeaderContent<T>;
     body?: ZTableBodyColumnConfig<T> | ZTableCellContent<T>;
@@ -188,13 +260,17 @@ interface ZTableColumnConfig<T> {
     minSize?: number;
     maxSize?: number;
     width?: string;
+    /** true = local sort with defaults; object = full config */
     sort?: ZTableSortConfig<T> | boolean;
+    /** true = local filter with defaults; object = full config */
     filter?: ZTableFilterConfig<T> | boolean;
     enableResizing?: boolean;
     enablePinning?: boolean;
     enableHiding?: boolean;
     enableOrdering?: boolean;
+    /** Initial pin position — applied on first render */
     pinned?: 'left' | 'right' | false;
+    /** Child columns for multi-level header grouping */
     columns?: ZTableColumnConfig<T>[];
 }
 interface ZTablePaginationConfig {
@@ -208,6 +284,7 @@ interface ZTablePaginationConfig {
     totalLabel?: string;
     disabled?: boolean;
 }
+/** Distinguishes user-triggered vs programmatic pagination changes */
 type ZTableEmitType = 'user' | 'auto';
 interface ZTablePageChangeEvent {
     pageIndex: number;
@@ -245,6 +322,13 @@ interface ZTableCellEditEvent<T> {
     oldValue: unknown;
     newValue: unknown;
 }
+interface ZTableRowDragEvent<T> {
+    row: T;
+    rowId: string;
+    previousIndex: number;
+    currentIndex: number;
+    data: T[];
+}
 interface ZTableSortChangeEvent {
     sorting: SortingState;
 }
@@ -290,7 +374,8 @@ interface ZTableActionColumnConfig<T = unknown> {
     actions: ZTableActionItem<T>[] | ((row: T) => ZTableActionItem<T>[]);
     maxVisible?: number;
 }
-type ZTableChangeType = 'page' | 'sort' | 'filter' | 'search' | 'select' | 'expand' | 'rowSelect' | 'rowSelectAll' | 'rowExpand' | 'cellClick' | 'cellEdit' | 'action';
+/** All possible change event types — used as discriminant in ZTableChangeEvent */
+type ZTableChangeType = 'page' | 'sort' | 'filter' | 'search' | 'select' | 'expand' | 'rowSelect' | 'rowSelectAll' | 'rowExpand' | 'rowDrag' | 'cellClick' | 'cellEdit' | 'action';
 interface ZTableChangeEventBase {
     type: ZTableChangeType;
 }
@@ -318,6 +403,10 @@ interface ZTableRowExpandChange<T> extends ZTableChangeEventBase {
     type: 'rowExpand';
     data: ZTableRowExpandEvent<T>;
 }
+interface ZTableRowDragChange<T> extends ZTableChangeEventBase {
+    type: 'rowDrag';
+    data: ZTableRowDragEvent<T>;
+}
 interface ZTableCellClickChange<T> extends ZTableChangeEventBase {
     type: 'cellClick';
     data: ZTableCellClickEvent<T>;
@@ -346,7 +435,21 @@ interface ZTableCellEditChange<T> extends ZTableChangeEventBase {
     type: 'cellEdit';
     data: ZTableCellEditEvent<T>;
 }
-type ZTableChangeEvent<T> = ZTablePageChange | ZTableSortChange | ZTableFilterChange | ZTableSearchChange | ZTableSelectChange | ZTableExpandChange | ZTableRowSelectChange<T> | ZTableRowSelectAllChange<T> | ZTableRowExpandChange<T> | ZTableCellClickChange<T> | ZTableCellEditChange<T> | ZTableActionChange<T>;
+/**
+ * Unified change event emitted via `zChange` output.
+ * Parent components can use `event.type` to narrow the discriminated union.
+ *
+ * Example:
+ * ```ts
+ * onTableChange(event: ZTableChangeEvent<MyRow>) {
+ *   if (event.type === 'page') {
+ *     // event.data is ZTablePageChangeEvent
+ *   }
+ * }
+ * ```
+ */
+type ZTableChangeEvent<T> = ZTablePageChange | ZTableSortChange | ZTableFilterChange | ZTableSearchChange | ZTableSelectChange | ZTableExpandChange | ZTableRowSelectChange<T> | ZTableRowSelectAllChange<T> | ZTableRowExpandChange<T> | ZTableRowDragChange<T> | ZTableCellClickChange<T> | ZTableCellEditChange<T> | ZTableActionChange<T>;
+/** Initial table state — applied on first render, before any cached config is loaded */
 interface ZTableInitialState {
     columnPinning?: ColumnPinningState;
     rowPinning?: RowPinningState;
@@ -425,22 +528,47 @@ interface ZTableSearchConfig {
     width?: string;
     size?: ZInputSize;
 }
+interface ZTableVirtualColumnConfig {
+    /** Enable horizontal column virtualization for center columns only */
+    enabled: boolean;
+    /** Number of columns to render outside the visible range */
+    overscan?: number;
+}
+/**
+ * Top-level configuration passed via `[zConfig]` input.
+ * This is the primary API surface for consumers of z-table.
+ */
 interface ZTableConfig<T> {
+    /** 'local' = client-side operations; 'server' = parent handles data fetching */
     mode?: ZTableMode;
+    /** Row data array — for server mode, this is the current page's data */
     data: T[];
+    /** Enables drag-and-drop row reordering for compatible local-table states */
+    enableRowDragging?: boolean;
+    /** Total row count for server-side pagination (aliased as totalRows) */
     totalCount?: number;
+    /** Column definitions */
     columns: ZTableColumnConfig<T>[];
+    /** Custom row ID generator — critical for selection/expansion state stability */
     getRowId?: (row: T, index: number, parent: T | undefined, data: T[]) => string;
+    /** Sub-row accessor for tree/hierarchical data */
     getSubRows?: (row: T, index: number, parent: T | undefined, data: T[]) => T[] | undefined;
+    /** @deprecated Use totalCount instead */
     totalRows?: number;
+    /** true = enable with defaults; object = full virtual scroll config */
     virtual?: ZTableVirtualConfig | boolean;
+    /** true = enable with defaults; object = full horizontal column virtualization config */
+    virtualColumns?: ZTableVirtualColumnConfig | boolean;
     showHorizontalBorder?: boolean;
     showVerticalBorder?: boolean;
     showHeaderShadow?: boolean;
     showFooterShadow?: boolean;
+    /** Show the settings drawer toggle button */
     enableSettings?: boolean;
     enableColumnResizing?: boolean;
+    /** When true, shift-click sorting is simulated automatically */
     enableMultiSort?: boolean;
+    /** true = enable with defaults; object = full search bar config */
     search?: ZTableSearchConfig | boolean;
     enableRowPinning?: boolean;
     enableColumnPinning?: boolean;
@@ -449,15 +577,20 @@ interface ZTableConfig<T> {
     pagination?: ZTablePaginationConfig;
     initialState?: ZTableInitialState;
     loading?: boolean;
+    /** Template rendered when a row is expanded */
     expandedRowTemplate?: TemplateRef<{
         $implicit: Row<T>;
     }>;
+    /** Template rendered when no data matches */
     emptyTemplate?: TemplateRef<void>;
+    /** Template rendered during loading state */
     loadingTemplate?: TemplateRef<void>;
     getRowCanExpand?: (row: Row<T>) => boolean;
     maxHeight?: string;
     minHeight?: string;
+    /** Debounce time (ms) for async state updates; defaults to Z_DEFAULT_DEBOUNCE_TIME */
     debounceTime?: number;
+    /** Use skeleton rows instead of loading spinner */
     useSkeleton?: boolean;
 }
 interface ZTableEditCellChangeEvent<T = unknown> {
@@ -478,6 +611,10 @@ interface ZResolvedEditConfig {
     disabled: boolean;
     readonly: boolean;
 }
+/**
+ * Extends TanStack's TableMeta to add a custom `updateData` callback.
+ * This is used by inline edit cells to notify the table of value changes.
+ */
 declare module '@tanstack/angular-table' {
     interface TableMeta<TData extends RowData> {
         updateData?: (rowIndex: number, columnId: string, value: unknown) => void;
@@ -485,22 +622,37 @@ declare module '@tanstack/angular-table' {
 }
 
 declare class ZTableComponent<T> implements AfterViewInit {
+    /** Unified change event — parent listens to this for all table interactions */
     readonly zChange: _angular_core.OutputEmitterRef<ZTableChangeEvent<T>>;
+    /** Emits an imperative control handle for programmatic table manipulation */
     readonly zControl: _angular_core.OutputEmitterRef<ZTableControl<T>>;
+    /** Extra CSS classes merged onto the table container */
     readonly zClass: _angular_core.InputSignal<ClassValue>;
+    /** Main configuration — data, columns, mode, features */
     readonly zConfig: _angular_core.InputSignal<ZTableConfig<T>>;
+    /** External loading state (complementary to config.loading) */
     readonly zLoading: _angular_core.InputSignal<boolean>;
+    /** Cache key for persisting column settings; no persistence when empty */
     readonly zKey: _angular_core.InputSignal<string>;
+    /** Visual variant: 'default' has card shadow, 'borderless' has no container border */
     readonly zVariant: _angular_core.InputSignal<"default" | "borderless">;
     private readonly _destroy$;
     private readonly _zTranslate;
+    /** Prevents recursive scroll sync between thead/tbody/tfoot */
     private readonly _isSyncingScroll;
+    /** Preserves horizontal scroll position across loading states */
     private readonly _savedScrollLeft;
+    /** Observes tbody container height changes for skeleton row count calculation */
     private _resizeObserver;
+    /** Debounces rapid settings changes (visibility/pin toggles) */
     private _settingsDebounceTimeout;
+    /** Debounces filter change emissions to server */
     private _filterEmitDebounceTimeout;
+    /** Merged loading state from both zLoading input and config.loading */
     protected readonly isLoading: _angular_core.Signal<boolean>;
+    /** True during debounced async state transitions (sort/filter processing) */
     protected readonly isProcessing: _angular_core.WritableSignal<boolean>;
+    protected readonly isDraggingRow: _angular_core.WritableSignal<boolean>;
     protected readonly theadWrapper: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
     protected readonly tbodyContainer: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
     protected readonly tbodyWrapper: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
@@ -516,38 +668,65 @@ declare class ZTableComponent<T> implements AfterViewInit {
     protected readonly rowPinning: _angular_core.WritableSignal<RowPinningState>;
     protected readonly columnFilters: _angular_core.WritableSignal<ColumnFiltersState>;
     protected readonly globalFilter: _angular_core.WritableSignal<string>;
+    /** Note: pageIndex is 1-based here; converted to 0-based for TanStack via _tanstackPagination */
     protected readonly pagination: _angular_core.WritableSignal<PaginationState>;
     protected readonly sorting: _angular_core.WritableSignal<SortingState>;
+    /**
+     * Caches the last server-provided total to avoid flickering to 0
+     * during loading transitions in server-side pagination mode.
+     */
     private readonly _serverPaginationTotal;
+    /** Container CSS classes combining variant + user-provided classes */
     protected readonly classTable: _angular_core.Signal<string>;
+    /** Convert 1-based pagination to TanStack's 0-based pageIndex */
     private readonly _tanstackPagination;
     private readonly _configPagination;
     protected readonly paginationTotal: _angular_core.Signal<number>;
     protected readonly hasVerticalScroll: _angular_core.WritableSignal<boolean>;
     protected readonly hasHorizontalScroll: _angular_core.WritableSignal<boolean>;
+    /** True when the last row touches or extends past the container bottom (no gap) */
     protected readonly lastRowTouchesBottom: _angular_core.WritableSignal<boolean>;
     protected readonly showSettingsDrawer: _angular_core.WritableSignal<boolean>;
     protected readonly showHorizontalBorder: _angular_core.WritableSignal<boolean>;
     protected readonly showVerticalBorder: _angular_core.WritableSignal<boolean>;
     protected readonly showHeaderFooterShadow: _angular_core.WritableSignal<boolean>;
+    /** True when table body is scrolled away from left edge (shows left pin shadow) */
     protected readonly hasScrollLeft: _angular_core.WritableSignal<boolean>;
+    /** True when table has right-pinned columns and body isn't scrolled to the end */
     protected readonly hasScrollRight: _angular_core.WritableSignal<boolean>;
+    /** Maps row IDs to measured DOM heights for pinned row offset calculations */
     protected readonly pinnedRowHeights: _angular_core.WritableSignal<Record<string, number>>;
+    /** Bumped to force recomputation of pinned column IDs after programmatic pin changes */
     private readonly _columnPinVersion;
+    /** Bumped to trigger data refresh (e.g., after addItem/deleteItem via control API) */
     private readonly _dataForceUpdate;
+    /** Stores a temporary locally reordered dataset until parent pushes a new data reference */
+    private readonly _rowDragDataOverride;
+    /** Tracks the latest external data array reference to detect parent-driven refreshes */
+    private _lastExternalDataRef;
+    /** Set when a single row is updated via control API (for targeted re-render) */
     protected readonly _rowUpdate: _angular_core.WritableSignal<{
         rowId: string;
         updates: Record<string, unknown>;
     } | null>;
+    /**
+     * Column config lookup cache — cleared when column reference changes.
+     * Avoids repeated recursive searches during render cycles.
+     */
     private _columnConfigCache;
     private _lastColumnsRef;
     protected readonly pinnedColumnIds: _angular_core.Signal<string[]>;
     protected readonly pendingVisibleColumns: _angular_core.WritableSignal<string[]>;
     protected readonly pendingColumnOrder: _angular_core.WritableSignal<string[]>;
     protected readonly pendingShowHeaderFooterShadow: _angular_core.WritableSignal<boolean>;
+    /** True if ANY body column uses rowSpan — affects virtual grouping and expand column behavior */
     protected readonly hasBodyRowSpan: _angular_core.Signal<boolean>;
     protected readonly hasSelectColumn: _angular_core.Signal<boolean>;
     protected readonly hasExpandColumn: _angular_core.Signal<boolean>;
+    protected readonly hasRowDragColumn: _angular_core.Signal<boolean>;
+    protected readonly canUseRowDrag: _angular_core.Signal<boolean>;
+    protected readonly isVirtualRowDragEnabled: _angular_core.Signal<boolean>;
+    protected readonly isRowDragEnabled: _angular_core.Signal<boolean>;
     protected readonly actionColumnInfo: _angular_core.Signal<{
         columnId: string;
         config: ZTableActionColumnConfig<T>;
@@ -568,21 +747,49 @@ declare class ZTableComponent<T> implements AfterViewInit {
         size: _shival99_z_ui_components_z_input.ZInputSize;
     } | null>;
     protected readonly isSearchEnabled: _angular_core.Signal<boolean>;
+    /** Data signal with force-update support for control API mutations */
     private readonly _data;
+    /**
+     * Converts ZTableColumnConfig[] into TanStack ColumnDef[].
+     * Handles special columns (select, expand, actionRowPin), action column sizing,
+     * and rowSpan/expand compatibility (expand column is removed when rowSpan is used).
+     */
     private readonly _columns;
     protected readonly isVirtual: _angular_core.Signal<boolean>;
+    /** Normalized virtual config with defaults applied */
     private readonly _virtualConfig;
     protected readonly virtualRowHeight: _angular_core.Signal<number>;
     protected readonly dynamicSize: _angular_core.Signal<boolean>;
+    private readonly _virtualColumnsConfig;
     protected readonly groupSize: _angular_core.Signal<number>;
     protected readonly groupHeight: _angular_core.Signal<number>;
     private readonly _dynamicGroupsVersion;
+    /**
+     * Groups rows for virtual scrolling. When rowSpan is used, rows that share
+     * a merged cell are grouped together so the virtualizer treats them as
+     * a single unit, preserving the visual merge across scroll boundaries.
+     */
     protected readonly dynamicGroups: _angular_core.Signal<ZVirtualGroup[]>;
     protected readonly hasFooter: _angular_core.Signal<boolean>;
     protected readonly isEmpty: _angular_core.Signal<boolean>;
     protected readonly isEmptyData: _angular_core.Signal<boolean>;
     protected readonly isNoSearchResults: _angular_core.Signal<boolean>;
-    protected readonly orderedLeafColumns: _angular_core.Signal<_tanstack_angular_table.Column<T, unknown>[]>;
+    protected readonly leftLeafColumns: _angular_core.Signal<Column<T, unknown>[]>;
+    protected readonly centerLeafColumns: _angular_core.Signal<Column<T, unknown>[]>;
+    protected readonly rightLeafColumns: _angular_core.Signal<Column<T, unknown>[]>;
+    protected readonly hasComplexColumnLayout: _angular_core.Signal<boolean>;
+    protected readonly canUseVirtualColumns: _angular_core.Signal<boolean>;
+    protected readonly columnVirtualizer: _shival99_angular_virtual.AngularVirtualizer<HTMLDivElement, Element>;
+    protected readonly virtualCenterColumnItems: _angular_core.Signal<_shival99_angular_virtual.VirtualItem[]>;
+    protected readonly virtualCenterColumns: _angular_core.Signal<Column<T, unknown>[]>;
+    protected readonly virtualCenterColumnVisibilityMap: _angular_core.Signal<Record<string, boolean>>;
+    protected readonly firstVirtualCenterColumnId: _angular_core.Signal<string>;
+    protected readonly lastVirtualCenterColumnId: _angular_core.Signal<string>;
+    protected readonly virtualLeftSpacerWidth: _angular_core.Signal<number>;
+    protected readonly virtualCenterTotalWidth: _angular_core.Signal<number>;
+    protected readonly virtualRightSpacerWidth: _angular_core.Signal<number>;
+    protected readonly renderedColumnCount: _angular_core.Signal<number>;
+    protected readonly orderedLeafColumns: _angular_core.Signal<Column<T, unknown>[]>;
     protected readonly orderedHeaderGroups: _angular_core.Signal<{
         id: string;
         headers: _tanstack_angular_table.Header<T, unknown>[];
@@ -593,6 +800,14 @@ declare class ZTableComponent<T> implements AfterViewInit {
         headers: _tanstack_angular_table.Header<T, unknown>[];
     }[]>;
     protected readonly bottomRowsReversed: _angular_core.Signal<Row<T>[]>;
+    protected readonly leftHeaderRow: _angular_core.Signal<_tanstack_angular_table.Header<T, unknown>[]>;
+    protected readonly centerHeaderRow: _angular_core.Signal<_tanstack_angular_table.Header<T, unknown>[]>;
+    protected readonly rightHeaderRow: _angular_core.Signal<_tanstack_angular_table.Header<T, unknown>[]>;
+    protected readonly leftFooterRow: _angular_core.Signal<_tanstack_angular_table.Header<T, unknown>[]>;
+    protected readonly centerFooterRow: _angular_core.Signal<_tanstack_angular_table.Header<T, unknown>[]>;
+    protected readonly rightFooterRow: _angular_core.Signal<_tanstack_angular_table.Header<T, unknown>[]>;
+    protected readonly virtualCenterHeaderRow: _angular_core.Signal<_tanstack_angular_table.Header<T, unknown>[]>;
+    protected readonly virtualCenterFooterRow: _angular_core.Signal<_tanstack_angular_table.Header<T, unknown>[]>;
     protected readonly totalWidth: _angular_core.Signal<number>;
     protected readonly shouldHeaderShowShadow: _angular_core.Signal<boolean>;
     protected readonly shouldFooterShowShadow: _angular_core.Signal<boolean>;
@@ -608,11 +823,22 @@ declare class ZTableComponent<T> implements AfterViewInit {
     protected readonly columnSizeVars: _angular_core.Signal<Record<string, number>>;
     protected readonly table: ReturnType<typeof createAngularTable<T>>;
     private readonly _virtualGroupCount;
+    /** Virtualizer instance — operates on groups rather than individual rows */
     protected readonly virtualizer: _shival99_angular_virtual.AngularVirtualizer<HTMLDivElement, Element>;
     private readonly _measureVirtualItems;
     constructor();
     ngAfterViewInit(): void;
+    /**
+     * Syncs parent row selection state based on children.
+     * If all children are selected, the parent is auto-selected;
+     * if no children are selected, the parent is deselected.
+     */
     private _handleRowSelectionWithParents;
+    /**
+     * Wraps state mutations with a debounced processing indicator.
+     * Shows a brief loading state to prevent UI flicker during
+     * filter/sort recomputation on large datasets.
+     */
     private _runAsyncStateUpdate;
     private _emitFilterChangeDebounced;
     private _checkScrollState;
@@ -624,8 +850,13 @@ declare class ZTableComponent<T> implements AfterViewInit {
     hasRightPinnedColumns(): boolean;
     onTbodyScroll(event: Event): void;
     private _syncScrollLeft;
+    /** Handles sort click; auto-adds shiftKey for multi-sort when enabled */
     handleSort(event: Event, handler?: (event: unknown) => void): void;
     onColumnDrop(event: CdkDragDrop<string[]>): void;
+    onRowDragStarted(): void;
+    onRowDragEnded(_event: CdkDragEnd<Row<T>>): void;
+    onRowDrop(event: CdkDragDrop<Row<T>[]>): void;
+    private _resolveRowDragDropIndex;
     onToggleAllColumns(): void;
     onPageChange(event: {
         pageIndex: number;
@@ -646,9 +877,16 @@ declare class ZTableComponent<T> implements AfterViewInit {
     moveColumnRight(columnId: string): void;
     isFirstMovableColumn(columnId: string): boolean;
     isLastMovableColumn(columnId: string): boolean;
+    /** Saves current column layout, sizing, pinning, and visibility to ZCacheService */
     private _saveConfig;
     private _collectColumnInfo;
+    /** Loads cached config from ZCacheService; validates schema compatibility first */
     private _loadConfigCache;
+    /**
+     * Validates cached column info against current config.
+     * Returns false if columns have been added/removed/renamed since cache was saved,
+     * which triggers cache invalidation.
+     */
     private _isColumnConfigValid;
     private _getChangedFilterColumnIds;
     private _getChangedSortColumnIds;
@@ -656,6 +894,10 @@ declare class ZTableComponent<T> implements AfterViewInit {
     private _isColumnSortModeLocal;
     private _filterServerModeColumnFilters;
     private _filterServerModeSorting;
+    /**
+     * Recursively finds a column config by ID with caching.
+     * Cache is invalidated when the column array reference changes.
+     */
     private _findColumnConfig;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZTableComponent<any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTableComponent<any>, "z-table", ["zTable"], { "zClass": { "alias": "zClass"; "required": false; "isSignal": true; }; "zConfig": { "alias": "zConfig"; "required": false; "isSignal": true; }; "zLoading": { "alias": "zLoading"; "required": false; "isSignal": true; }; "zKey": { "alias": "zKey"; "required": false; "isSignal": true; }; "zVariant": { "alias": "zVariant"; "required": false; "isSignal": true; }; }, { "zChange": "zChange"; "zControl": "zControl"; }, never, never, true, never>;
@@ -771,9 +1013,13 @@ declare class ZTableEditCellComponent<T = unknown> implements OnInit {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZTableEditCellComponent<any>, "z-table-edit-cell", never, { "zRow": { "alias": "zRow"; "required": true; "isSignal": true; }; "zRowId": { "alias": "zRowId"; "required": true; "isSignal": true; }; "zRowIndex": { "alias": "zRowIndex"; "required": true; "isSignal": true; }; "zColumnId": { "alias": "zColumnId"; "required": true; "isSignal": true; }; "zValue": { "alias": "zValue"; "required": false; "isSignal": true; }; "zEditConfig": { "alias": "zEditConfig"; "required": false; "isSignal": true; }; "zRowUpdate": { "alias": "zRowUpdate"; "required": false; "isSignal": true; }; }, { "zChange": "zChange"; }, never, never, true, never>;
 }
 
+/** Type guard: is this a full header config object (not just content shorthand)? */
 declare const isHeaderConfig: <T>(config: ZTableHeaderColumnConfig<T> | ZTableHeaderContent<T> | undefined) => config is ZTableHeaderColumnConfig<T>;
+/** Type guard: is this a full body config object (not just content shorthand)? */
 declare const isBodyConfig: <T>(config: ZTableBodyColumnConfig<T> | ZTableCellContent<T> | undefined) => config is ZTableBodyColumnConfig<T>;
+/** Type guard: is this a full footer config object (not just content shorthand)? */
 declare const isFooterConfig: <T>(config: ZTableFooterColumnConfig<T> | ZTableHeaderContent<T> | undefined) => config is ZTableFooterColumnConfig<T>;
+/** Extract and normalize header config from a column definition */
 declare const getHeaderConfig: <T>(col: ZTableColumnConfig<T> | undefined) => {
     content: ZTableHeaderContent<T> | undefined;
     class: string | undefined;
@@ -795,6 +1041,10 @@ declare const getHeaderConfig: <T>(col: ZTableColumnConfig<T> | undefined) => {
     contentClass: string | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => string) | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => string) | undefined;
     contentStyle: Record<string, string> | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => Record<string, string>) | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => Record<string, string>) | undefined;
 };
+/**
+ * Extract and normalize body config from a column definition.
+ * Resolves dynamic properties (class, style, rowSpan, etc.) when CellContext is provided.
+ */
 declare const getBodyConfig: <T>(col: ZTableColumnConfig<T> | undefined, ctx?: CellContext<T, unknown>) => {
     content: ZTableCellContent<T> | undefined;
     class: string | undefined;
@@ -837,7 +1087,19 @@ declare const getFooterConfig: <T>(col: ZTableColumnConfig<T> | undefined) => {
     contentClass: string | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => string) | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => string) | undefined;
     contentStyle: Record<string, string> | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => Record<string, string>) | ((info: _tanstack_angular_table.HeaderContext<T, unknown>) => Record<string, string>) | undefined;
 };
+/** Recursively search for a column config by ID within a (possibly nested) column array */
 declare const findColumnConfig: <T>(columnId: string, columns: ZTableColumnConfig<T>[]) => ZTableColumnConfig<T> | undefined;
+/**
+ * Converts the consumer-facing ZTableColumnConfig into a TanStack ColumnDef.
+ * This is the bridge between the z-table API and TanStack Table internals.
+ *
+ * Handles:
+ * - Accessor mapping (accessorKey / accessorFn)
+ * - Header/body/footer content resolution
+ * - Sort and filter function wiring (local vs server mode)
+ * - Built-in filter functions for each filter type
+ * - Recursive nested column conversion
+ */
 declare function columnConfigToColumnDef<T>(config: ZTableColumnConfig<T>): ColumnDef<T>;
 
 export { ZTableActionsComponent, ZTableComponent, ZTableEditCellComponent, ZTableFilterComponent, ZTableIconTextComponent, columnConfigToColumnDef, findColumnConfig, getBodyConfig, getFooterConfig, getHeaderConfig, isBodyConfig, isFooterConfig, isHeaderConfig };

package/types/shival99-z-ui-components-z-tabs.d.ts

@@ -20,7 +20,7 @@ interface ZTab {
     badge?: string | number;
     template?: TemplateRef<unknown>;
 }
-type ZTabsType = 'line' | 'enclosed' | 'enclosed-solid' | 'soft' | 'pill' | 'solid' | 'underline';
+type ZTabsType = 'line' | 'enclosed' | 'enclosed-solid' | 'soft' | 'pill' | 'solid' | 'underline' | 'code-line';
 type ZTabsSize = 'sm' | 'default' | 'lg';
 type ZTabsOrientation = 'horizontal' | 'vertical';
 
@@ -62,11 +62,11 @@ declare class ZTabsComponent implements AfterViewInit, OnDestroy {
 }
 
 declare const zTabsVariants: (props?: ({
-    zType?: "line" | "enclosed" | "enclosed-solid" | "soft" | "pill" | "solid" | "underline" | null | undefined;
+    zType?: "line" | "enclosed" | "enclosed-solid" | "soft" | "pill" | "solid" | "underline" | "code-line" | null | undefined;
     zOrientation?: "horizontal" | "vertical" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const zTabItemVariants: (props?: ({
-    zType?: "line" | "enclosed" | "enclosed-solid" | "soft" | "pill" | "solid" | "underline" | null | undefined;
+    zType?: "line" | "enclosed" | "enclosed-solid" | "soft" | "pill" | "solid" | "underline" | "code-line" | null | undefined;
     zSize?: "sm" | "default" | "lg" | null | undefined;
     zOrientation?: "horizontal" | "vertical" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;