@alaarab/ogrid-vue 2.0.2

package/dist/types/composables/useColumnResize.d.ts

@@ -0,0 +1,21 @@
+import { type Ref } from 'vue';
+import type { IColumnDef } from '../types';
+export interface UseColumnResizeParams {
+    columnSizingOverrides: Ref<Record<string, {
+        widthPx: number;
+    }>>;
+    setColumnSizingOverrides: (value: Record<string, {
+        widthPx: number;
+    }>) => void;
+    minWidth?: number;
+    defaultWidth?: number;
+    onColumnResized?: (columnId: string, width: number) => void;
+}
+export interface UseColumnResizeResult<T> {
+    handleResizeStart: (e: MouseEvent, col: IColumnDef<T>) => void;
+    getColumnWidth: (col: IColumnDef<T>) => number;
+}
+/**
+ * Manages column resize drag interactions with RAF-throttled state updates.
+ */
+export declare function useColumnResize<T>(params: UseColumnResizeParams): UseColumnResizeResult<T>;

package/dist/types/composables/useContextMenu.d.ts

@@ -0,0 +1,19 @@
+import { type Ref } from 'vue';
+export interface ContextMenuPosition {
+    x: number;
+    y: number;
+}
+export interface UseContextMenuResult {
+    contextMenuPosition: Ref<ContextMenuPosition | null>;
+    setContextMenuPosition: (pos: ContextMenuPosition | null) => void;
+    handleCellContextMenu: (e: {
+        clientX: number;
+        clientY: number;
+        preventDefault?: () => void;
+    }) => void;
+    closeContextMenu: () => void;
+}
+/**
+ * Manages context menu position state for right-click menus.
+ */
+export declare function useContextMenu(): UseContextMenuResult;

package/dist/types/composables/useDataGridState.d.ts

@@ -0,0 +1,129 @@
+import { type Ref, type ShallowRef } from 'vue';
+import type { RowId, IOGridDataGridProps, IStatusBarProps, IColumnDef } from '../types';
+import type { HeaderFilterConfigInput, CellRenderDescriptorInput } from '../utils';
+export interface UseDataGridStateParams<T> {
+    props: Ref<IOGridDataGridProps<T>>;
+    wrapperRef: Ref<HTMLDivElement | null> | ShallowRef<HTMLDivElement | null>;
+}
+export interface DataGridLayoutState<T> {
+    flatColumns: IColumnDef<T>[];
+    visibleCols: IColumnDef<T>[];
+    visibleColumnCount: number;
+    totalColCount: number;
+    colOffset: number;
+    hasCheckboxCol: boolean;
+    rowIndexByRowId: Map<RowId, number>;
+    containerWidth: number;
+    minTableWidth: number;
+    desiredTableWidth: number;
+    columnSizingOverrides: Record<string, {
+        widthPx: number;
+    }>;
+    setColumnSizingOverrides: (value: Record<string, {
+        widthPx: number;
+    }>) => void;
+    onColumnResized?: (columnId: string, width: number) => void;
+}
+export interface DataGridRowSelectionState {
+    selectedRowIds: Set<RowId>;
+    updateSelection: (newSelectedIds: Set<RowId>) => void;
+    handleRowCheckboxChange: (rowId: RowId, checked: boolean, rowIndex: number, shiftKey: boolean) => void;
+    handleSelectAll: (checked: boolean) => void;
+    allSelected: boolean;
+    someSelected: boolean;
+}
+export interface DataGridEditingState<T> {
+    editingCell: {
+        rowId: RowId;
+        columnId: string;
+    } | null;
+    setEditingCell: (cell: {
+        rowId: RowId;
+        columnId: string;
+    } | null) => void;
+    pendingEditorValue: unknown;
+    setPendingEditorValue: (value: unknown) => void;
+    commitCellEdit: (item: T, columnId: string, oldValue: unknown, newValue: unknown, rowIndex: number, globalColIndex: number) => void;
+    cancelPopoverEdit: () => void;
+    popoverAnchorEl: HTMLElement | null;
+    setPopoverAnchorEl: (el: HTMLElement | null) => void;
+}
+export interface DataGridCellInteractionState {
+    activeCell: {
+        rowIndex: number;
+        columnIndex: number;
+    } | null;
+    setActiveCell: (cell: {
+        rowIndex: number;
+        columnIndex: number;
+    } | null) => void;
+    selectionRange: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    } | null;
+    setSelectionRange: (range: DataGridCellInteractionState['selectionRange']) => void;
+    handleCellMouseDown: (e: MouseEvent, rowIndex: number, globalColIndex: number) => void;
+    handleSelectAllCells: () => void;
+    hasCellSelection: boolean;
+    handleGridKeyDown: (e: KeyboardEvent) => void;
+    handleFillHandleMouseDown: (e: MouseEvent) => void;
+    handleCopy: () => void;
+    handleCut: () => void;
+    handlePaste: () => Promise<void>;
+    cutRange: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    } | null;
+    copyRange: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    } | null;
+    clearClipboardRanges: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo?: () => void;
+    onRedo?: () => void;
+    isDragging: boolean;
+}
+export interface DataGridContextMenuState {
+    menuPosition: {
+        x: number;
+        y: number;
+    } | null;
+    setMenuPosition: (pos: {
+        x: number;
+        y: number;
+    } | null) => void;
+    handleCellContextMenu: (e: {
+        clientX: number;
+        clientY: number;
+        preventDefault?: () => void;
+    }) => void;
+    closeContextMenu: () => void;
+}
+export interface DataGridViewModelState<T> {
+    headerFilterInput: HeaderFilterConfigInput;
+    cellDescriptorInput: CellRenderDescriptorInput<T>;
+    statusBarConfig: IStatusBarProps | null;
+    showEmptyInGrid: boolean;
+    onCellError?: (error: Error, info: unknown) => void;
+}
+export interface UseDataGridStateResult<T> {
+    layout: Ref<DataGridLayoutState<T>>;
+    rowSelection: Ref<DataGridRowSelectionState>;
+    editing: Ref<DataGridEditingState<T>>;
+    interaction: Ref<DataGridCellInteractionState>;
+    contextMenu: Ref<DataGridContextMenuState>;
+    viewModels: Ref<DataGridViewModelState<T>>;
+}
+/**
+ * Single orchestration composable for DataGridTable. Takes grid props and wrapper ref,
+ * returns all derived state and handlers so UI packages can be thin view layers.
+ */
+export declare function useDataGridState<T>(params: UseDataGridStateParams<T>): UseDataGridStateResult<T>;

package/dist/types/composables/useDateFilterState.d.ts

@@ -0,0 +1,16 @@
+import { ref } from 'vue';
+import type { IDateFilterValue } from '../types';
+export interface UseDateFilterStateParams {
+    dateValue?: IDateFilterValue;
+    onDateChange?: (value: IDateFilterValue | undefined) => void;
+    isFilterOpen: () => boolean;
+}
+export interface UseDateFilterStateResult {
+    tempDateFrom: ReturnType<typeof ref<string>>;
+    setTempDateFrom: (v: string) => void;
+    tempDateTo: ReturnType<typeof ref<string>>;
+    setTempDateTo: (v: string) => void;
+    handleDateApply: () => void;
+    handleDateClear: () => void;
+}
+export declare function useDateFilterState(params: UseDateFilterStateParams): UseDateFilterStateResult;

package/dist/types/composables/useDebounce.d.ts

@@ -0,0 +1,10 @@
+import { type Ref } from 'vue';
+/**
+ * Returns a debounced ref that updates after the specified delay when the source value changes.
+ */
+export declare function useDebounce<T>(value: Ref<T>, delayMs: number): Ref<T>;
+/**
+ * Returns a stable callback that invokes the given function after the specified delay.
+ * Each new call resets the timer.
+ */
+export declare function useDebouncedCallback<T extends (...args: unknown[]) => void>(fn: T, delayMs: number): T;

package/dist/types/composables/useFillHandle.d.ts

@@ -0,0 +1,30 @@
+import { type Ref, type ShallowRef } from 'vue';
+import type { ISelectionRange, IActiveCell, IColumnDef, ICellValueChangedEvent } from '../types';
+export interface UseFillHandleParams<T> {
+    items: Ref<T[]>;
+    visibleCols: Ref<IColumnDef<T>[]>;
+    editable: Ref<boolean | undefined>;
+    onCellValueChanged: Ref<((event: ICellValueChangedEvent<T>) => void) | undefined>;
+    selectionRange: Ref<ISelectionRange | null>;
+    setSelectionRange: (range: ISelectionRange | null) => void;
+    setActiveCell: (cell: IActiveCell | null) => void;
+    colOffset: number;
+    wrapperRef: Ref<HTMLElement | null> | ShallowRef<HTMLElement | null>;
+    beginBatch?: () => void;
+    endBatch?: () => void;
+}
+export interface UseFillHandleResult {
+    fillDrag: Ref<{
+        startRow: number;
+        startCol: number;
+    } | null>;
+    setFillDrag: (value: {
+        startRow: number;
+        startCol: number;
+    } | null) => void;
+    handleFillHandleMouseDown: (e: MouseEvent) => void;
+}
+/**
+ * Manages Excel-style fill handle drag-to-fill for cell ranges.
+ */
+export declare function useFillHandle<T>(params: UseFillHandleParams<T>): UseFillHandleResult;

package/dist/types/composables/useFilterOptions.d.ts

@@ -0,0 +1,15 @@
+import { type Ref } from 'vue';
+import type { IDataSource } from '../types';
+export interface UseFilterOptionsResult {
+    filterOptions: Ref<Record<string, string[]>>;
+    loadingOptions: Ref<Record<string, boolean>>;
+}
+/** Accepted data source shapes for useFilterOptions. */
+type FilterOptionsSource = IDataSource<unknown> | {
+    fetchFilterOptions?: (field: string) => Promise<string[]>;
+};
+/**
+ * Load filter options for the given fields from a data source.
+ */
+export declare function useFilterOptions(dataSource: Ref<FilterOptionsSource>, fields: Ref<string[]>): UseFilterOptionsResult;
+export {};

package/dist/types/composables/useInlineCellEditorState.d.ts

@@ -0,0 +1,20 @@
+import { ref } from 'vue';
+export type InlineCellEditorType = 'text' | 'select' | 'checkbox' | 'richSelect' | 'date';
+export interface UseInlineCellEditorStateParams {
+    value: unknown;
+    editorType: InlineCellEditorType;
+    onCommit: (value: unknown) => void;
+    onCancel: () => void;
+}
+export interface UseInlineCellEditorStateResult {
+    localValue: ReturnType<typeof ref<string>>;
+    setLocalValue: (value: string) => void;
+    handleKeyDown: (e: KeyboardEvent) => void;
+    handleBlur: () => void;
+    commit: (value: unknown) => void;
+    cancel: () => void;
+}
+/**
+ * Returns localValue/setLocalValue, handleKeyDown, handleBlur, commit, cancel.
+ */
+export declare function useInlineCellEditorState(params: UseInlineCellEditorStateParams): UseInlineCellEditorStateResult;

package/dist/types/composables/useKeyboardNavigation.d.ts

@@ -0,0 +1,46 @@
+import { type Ref, type ShallowRef } from 'vue';
+import type { RowId, IActiveCell, ISelectionRange, IColumnDef, ICellValueChangedEvent, RowSelectionMode } from '../types';
+import type { EditingCell } from './useCellEditing';
+import type { ContextMenuPosition } from './useContextMenu';
+export interface UseKeyboardNavigationParams<T> {
+    data: {
+        items: Ref<T[]>;
+        visibleCols: Ref<IColumnDef<T>[]>;
+        colOffset: number;
+        hasCheckboxCol: Ref<boolean>;
+        visibleColumnCount: Ref<number>;
+        getRowId: (item: T) => RowId;
+    };
+    state: {
+        activeCell: Ref<IActiveCell | null>;
+        selectionRange: Ref<ISelectionRange | null>;
+        editingCell: Ref<EditingCell | null>;
+        selectedRowIds: Ref<Set<RowId>>;
+    };
+    handlers: {
+        setActiveCell: (cell: IActiveCell | null) => void;
+        setSelectionRange: (range: ISelectionRange | null) => void;
+        setEditingCell: (cell: EditingCell | null) => void;
+        handleRowCheckboxChange: (rowId: RowId, checked: boolean, rowIndex: number, shiftKey: boolean) => void;
+        handleCopy: () => void;
+        handleCut: () => void;
+        handlePaste: () => Promise<void>;
+        setContextMenu: (pos: ContextMenuPosition | null) => void;
+        onUndo?: () => void;
+        onRedo?: () => void;
+        clearClipboardRanges?: () => void;
+    };
+    features: {
+        editable: Ref<boolean | undefined>;
+        onCellValueChanged: Ref<((event: ICellValueChangedEvent<T>) => void) | undefined>;
+        rowSelection: Ref<RowSelectionMode>;
+        wrapperRef: Ref<HTMLElement | null> | ShallowRef<HTMLElement | null>;
+    };
+}
+export interface UseKeyboardNavigationResult {
+    handleGridKeyDown: (e: KeyboardEvent) => void;
+}
+/**
+ * Handles all keyboard navigation, shortcuts, and cell editing triggers for the grid.
+ */
+export declare function useKeyboardNavigation<T>(params: UseKeyboardNavigationParams<T>): UseKeyboardNavigationResult;

package/dist/types/composables/useMultiSelectFilterState.d.ts

@@ -0,0 +1,20 @@
+import { type Ref } from 'vue';
+export interface UseMultiSelectFilterStateParams {
+    selectedValues?: string[];
+    onFilterChange?: (values: string[]) => void;
+    options?: string[];
+    isFilterOpen: () => boolean;
+}
+export interface UseMultiSelectFilterStateResult {
+    tempSelected: Ref<Set<string>>;
+    setTempSelected: (v: Set<string>) => void;
+    searchText: Ref<string>;
+    setSearchText: (v: string) => void;
+    debouncedSearchText: Ref<string>;
+    filteredOptions: Ref<string[]>;
+    handleCheckboxChange: (option: string, checked: boolean) => void;
+    handleSelectAll: () => void;
+    handleClearSelection: () => void;
+    handleApplyMultiSelect: () => void;
+}
+export declare function useMultiSelectFilterState(params: UseMultiSelectFilterStateParams): UseMultiSelectFilterStateResult;

package/dist/types/composables/useOGrid.d.ts

@@ -0,0 +1,52 @@
+import { type Ref } from 'vue';
+import type { SideBarProps } from '../components/SideBar';
+import type { IOGridProps, IOGridDataGridProps, IOGridApi, IFilters, IColumnDefinition } from '../types';
+/** Resolved column chooser placement. */
+export type ColumnChooserPlacement = 'toolbar' | 'sidebar' | 'none';
+/** Pagination state and handlers. */
+export interface UseOGridPagination {
+    page: number;
+    pageSize: number;
+    displayTotalCount: number;
+    setPage: (p: number) => void;
+    setPageSize: (size: number) => void;
+    pageSizeOptions?: number[];
+    entityLabelPlural: string;
+}
+/** Column chooser state and handlers. */
+export interface UseOGridColumnChooser {
+    columns: IColumnDefinition[];
+    visibleColumns: Set<string>;
+    onVisibilityChange: (columnKey: string, isVisible: boolean) => void;
+    placement: ColumnChooserPlacement;
+}
+/** Layout / chrome configuration. */
+export interface UseOGridLayout {
+    toolbar: unknown;
+    toolbarBelow: unknown;
+    className?: string;
+    emptyState?: {
+        message?: unknown;
+        render?: () => unknown;
+    };
+    sideBarProps: SideBarProps | null;
+}
+/** Filter state. */
+export interface UseOGridFilters {
+    hasActiveFilters: boolean;
+    setFilters: (f: IFilters) => void;
+}
+export interface UseOGridResult<T> {
+    dataGridProps: Ref<IOGridDataGridProps<T>>;
+    pagination: Ref<UseOGridPagination>;
+    columnChooser: Ref<UseOGridColumnChooser>;
+    layout: Ref<UseOGridLayout>;
+    filters: Ref<UseOGridFilters>;
+    /** Imperative API object for programmatic grid control. */
+    api: Ref<IOGridApi<T>>;
+}
+/**
+ * Top-level orchestration composable for OGrid: manages pagination, sorting, filtering,
+ * column visibility, and sidebar.
+ */
+export declare function useOGrid<T>(props: Ref<IOGridProps<T>>): UseOGridResult<T>;

package/dist/types/composables/usePeopleFilterState.d.ts

@@ -0,0 +1,20 @@
+import { type Ref } from 'vue';
+import type { UserLike } from '../types';
+import type { ColumnFilterType } from '../types';
+export interface UsePeopleFilterStateParams {
+    selectedUser?: UserLike;
+    onUserChange?: (user: UserLike | undefined) => void;
+    peopleSearch?: (query: string) => Promise<UserLike[]>;
+    isFilterOpen: () => boolean;
+    filterType: ColumnFilterType;
+}
+export interface UsePeopleFilterStateResult {
+    peopleSuggestions: Ref<UserLike[]>;
+    isPeopleLoading: Ref<boolean>;
+    peopleSearchText: Ref<string>;
+    setPeopleSearchText: (v: string) => void;
+    peopleInputRef: Ref<HTMLInputElement | null>;
+    handleUserSelect: (user: UserLike) => void;
+    handleClearUser: () => void;
+}
+export declare function usePeopleFilterState(params: UsePeopleFilterStateParams): UsePeopleFilterStateResult;

package/dist/types/composables/useRichSelectState.d.ts

@@ -0,0 +1,21 @@
+import { type Ref } from 'vue';
+export interface UseRichSelectStateParams {
+    values: unknown[];
+    formatValue?: (value: unknown) => string;
+    initialValue: unknown;
+    onCommit: (value: unknown) => void;
+    onCancel: () => void;
+}
+export interface UseRichSelectStateResult {
+    searchText: Ref<string>;
+    setSearchText: (text: string) => void;
+    filteredValues: Ref<unknown[]>;
+    highlightedIndex: Ref<number>;
+    handleKeyDown: (e: KeyboardEvent) => void;
+    selectValue: (value: unknown) => void;
+    getDisplayText: (value: unknown) => string;
+}
+/**
+ * Manages searchable rich select editor state with keyboard navigation.
+ */
+export declare function useRichSelectState(params: UseRichSelectStateParams): UseRichSelectStateResult;

package/dist/types/composables/useRowSelection.d.ts

@@ -0,0 +1,21 @@
+import { type Ref } from 'vue';
+import type { RowId, RowSelectionMode, IRowSelectionChangeEvent } from '../types';
+export interface UseRowSelectionParams<T> {
+    items: Ref<T[]>;
+    getRowId: (item: T) => RowId;
+    rowSelection: Ref<RowSelectionMode>;
+    controlledSelectedRows: Ref<Set<RowId> | undefined>;
+    onSelectionChange: ((event: IRowSelectionChangeEvent<T>) => void) | undefined;
+}
+export interface UseRowSelectionResult {
+    selectedRowIds: Ref<Set<RowId>>;
+    updateSelection: (newSelectedIds: Set<RowId>) => void;
+    handleRowCheckboxChange: (rowId: RowId, checked: boolean, rowIndex: number, shiftKey: boolean) => void;
+    handleSelectAll: (checked: boolean) => void;
+    allSelected: Ref<boolean>;
+    someSelected: Ref<boolean>;
+}
+/**
+ * Manages row selection state for single or multiple selection modes with shift-click range support.
+ */
+export declare function useRowSelection<T>(params: UseRowSelectionParams<T>): UseRowSelectionResult;

package/dist/types/composables/useSideBarState.d.ts

@@ -0,0 +1,19 @@
+import { type Ref } from 'vue';
+import type { SideBarPanelId, ISideBarDef } from '../types';
+export interface UseSideBarStateParams {
+    config: boolean | ISideBarDef | undefined;
+}
+export interface UseSideBarStateResult {
+    isEnabled: boolean;
+    activePanel: Ref<SideBarPanelId | null>;
+    setActivePanel: (panel: SideBarPanelId | null) => void;
+    panels: SideBarPanelId[];
+    position: 'left' | 'right';
+    isOpen: Ref<boolean>;
+    toggle: (panel: SideBarPanelId) => void;
+    close: () => void;
+}
+/**
+ * Manages side bar panel state: enabled panels, active panel, position, and toggle/close handlers.
+ */
+export declare function useSideBarState(params: UseSideBarStateParams): UseSideBarStateResult;

package/dist/types/composables/useTableLayout.d.ts

@@ -0,0 +1,27 @@
+import { type Ref, type ShallowRef } from 'vue';
+import type { IColumnDef } from '../types';
+export interface UseTableLayoutParams<T> {
+    wrapperRef: Ref<HTMLElement | null> | ShallowRef<HTMLElement | null>;
+    visibleCols: Ref<IColumnDef<T>[]>;
+    flatColumns: Ref<IColumnDef<T>[]>;
+    hasCheckboxCol: Ref<boolean>;
+    initialColumnWidths?: Record<string, number>;
+    onColumnResized?: (columnId: string, width: number) => void;
+}
+export interface UseTableLayoutResult {
+    containerWidth: Ref<number>;
+    minTableWidth: Ref<number>;
+    desiredTableWidth: Ref<number>;
+    columnSizingOverrides: Ref<Record<string, {
+        widthPx: number;
+    }>>;
+    setColumnSizingOverrides: (value: Record<string, {
+        widthPx: number;
+    }>) => void;
+    onColumnResized?: (columnId: string, width: number) => void;
+}
+/**
+ * Manages table layout: container width measurement, column sizing overrides,
+ * min/desired table width calculations.
+ */
+export declare function useTableLayout<T>(params: UseTableLayoutParams<T>): UseTableLayoutResult;

package/dist/types/composables/useTextFilterState.d.ts

@@ -0,0 +1,13 @@
+import { ref } from 'vue';
+export interface UseTextFilterStateParams {
+    textValue?: string;
+    onTextChange?: (value: string) => void;
+    isFilterOpen: () => boolean;
+}
+export interface UseTextFilterStateResult {
+    tempTextValue: ReturnType<typeof ref<string>>;
+    setTempTextValue: (v: string) => void;
+    handleTextApply: () => void;
+    handleTextClear: () => void;
+}
+export declare function useTextFilterState(params: UseTextFilterStateParams): UseTextFilterStateResult;

package/dist/types/composables/useUndoRedo.d.ts

@@ -0,0 +1,21 @@
+import { type Ref } from 'vue';
+import type { ICellValueChangedEvent } from '../types';
+export interface UseUndoRedoParams<T> {
+    onCellValueChanged: ((event: ICellValueChangedEvent<T>) => void) | undefined;
+    maxUndoDepth?: number;
+}
+export interface UseUndoRedoResult<T> {
+    onCellValueChanged: ((event: ICellValueChangedEvent<T>) => void) | undefined;
+    undo: () => void;
+    redo: () => void;
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+    beginBatch: () => void;
+    endBatch: () => void;
+    maxUndoDepth: number;
+}
+/**
+ * Wraps onCellValueChanged with an undo/redo history stack.
+ * Supports batch operations: changes between beginBatch/endBatch are one undo step.
+ */
+export declare function useUndoRedo<T>(params: UseUndoRedoParams<T>): UseUndoRedoResult<T>;

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from '@alaarab/ogrid-core';
+export type { IColumnDef, ICellEditorProps, IOGridProps, IOGridClientProps, IOGridServerProps, IOGridDataGridProps, } from './types';
+export type { ColumnFilterType, IColumnFilterDef, IColumnMeta, IColumnGroupDef, IColumnDefinition, ICellValueChangedEvent, CellEditorParams, IValueParserParams, IDateFilterValue, HeaderCell, HeaderRow, RowId, UserLike, UserLikeInput, FilterValue, IFilters, IFetchParams, IPageResult, IDataSource, IGridColumnState, IOGridApi, RowSelectionMode, IRowSelectionChangeEvent, StatusBarPanel, IStatusBarProps, IActiveCell, ISelectionRange, SideBarPanelId, ISideBarDef, } from './types';
+export { toUserLike, isInSelectionRange, normalizeSelectionRange } from './types';
+export { useOGrid, useDataGridState, useActiveCell, useCellEditing, useCellSelection, useClipboard, useRowSelection, useKeyboardNavigation, useFillHandle, useUndoRedo, useContextMenu, useColumnResize, useFilterOptions, useDebounce, useDebouncedCallback, useTableLayout, useColumnHeaderFilterState, useTextFilterState, useMultiSelectFilterState, usePeopleFilterState, useDateFilterState, useColumnChooserState, useInlineCellEditorState, useRichSelectState, useSideBarState, } from './composables';
+export type { UseOGridResult, UseOGridPagination, UseOGridColumnChooser, UseOGridLayout, UseOGridFilters, ColumnChooserPlacement, UseDataGridStateParams, UseDataGridStateResult, DataGridLayoutState, DataGridRowSelectionState, DataGridEditingState, DataGridCellInteractionState, DataGridContextMenuState, DataGridViewModelState, UseActiveCellResult, EditingCell, UseCellEditingResult, UseCellSelectionParams, UseCellSelectionResult, UseClipboardParams, UseClipboardResult, UseRowSelectionParams, UseRowSelectionResult, UseKeyboardNavigationParams, UseKeyboardNavigationResult, UseFillHandleParams, UseFillHandleResult, UseUndoRedoParams, UseUndoRedoResult, ContextMenuPosition, UseContextMenuResult, UseColumnResizeParams, UseColumnResizeResult, UseFilterOptionsResult, UseTableLayoutParams, UseTableLayoutResult, UseColumnHeaderFilterStateParams, UseColumnHeaderFilterStateResult, UseTextFilterStateParams, UseTextFilterStateResult, UseMultiSelectFilterStateParams, UseMultiSelectFilterStateResult, UsePeopleFilterStateParams, UsePeopleFilterStateResult, UseDateFilterStateParams, UseDateFilterStateResult, UseColumnChooserStateParams, UseColumnChooserStateResult, InlineCellEditorType, UseInlineCellEditorStateParams, UseInlineCellEditorStateResult, UseRichSelectStateParams, UseRichSelectStateResult, UseSideBarStateParams, UseSideBarStateResult, } from './composables';
+export { getHeaderFilterConfig, getCellRenderDescriptor, resolveCellDisplayContent, resolveCellStyle, buildInlineEditorProps, buildPopoverEditorProps, getCellInteractionProps, } from './utils';
+export type { HeaderFilterConfigInput, HeaderFilterConfig, CellRenderDescriptorInput, CellRenderDescriptor, CellRenderMode, CellInteractionHandlers, CellInteractionProps, } from './utils';
+export type { SideBarProps, SideBarFilterColumn } from './components/SideBar';

package/dist/types/types/columnTypes.d.ts

@@ -0,0 +1,25 @@
+import type { Component } from 'vue';
+import type { IColumnDef as ICoreColumnDef, CellEditorParams } from '@alaarab/ogrid-core';
+export type { ColumnFilterType, IDateFilterValue, IColumnFilterDef, IColumnMeta, IValueParserParams, ICellValueChangedEvent, CellEditorParams, IColumnGroupDef, HeaderCell, HeaderRow, IColumnDefinition, } from '@alaarab/ogrid-core';
+/** Props passed to custom cell editor components. */
+export interface ICellEditorProps<T = unknown> {
+    value: unknown;
+    onValueChange: (value: unknown) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+    item: T;
+    column: IColumnDef<T>;
+    cellEditorParams?: CellEditorParams;
+}
+/**
+ * Vue-specific column definition. Extends core's framework-agnostic IColumnDef
+ * with renderCell, cellStyle, and a narrowed cellEditor type.
+ */
+export interface IColumnDef<T = unknown> extends ICoreColumnDef<T> {
+    /** Custom cell renderer (Vue-specific). Returns any renderable content. */
+    renderCell?: (item: T) => unknown;
+    /** Static or per-row cell inline styles (Vue-specific). */
+    cellStyle?: Record<string, string> | ((item: T) => Record<string, string>);
+    /** Built-in editor type or custom Vue component. */
+    cellEditor?: 'text' | 'select' | 'checkbox' | 'richSelect' | 'date' | Component;
+}