@nu-grid/nuxt 0.1.1

package/dist/runtime/types/_internal/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @internal
+ */
+export type { NuGridPresetOptions } from '../props.js';
+export type { NuGridActionMenuButton, NuGridActionMenuColumnDef, NuGridActionMenuColumnMeta, } from './action-menu.js';
+export type { NuGridCellEditing, NuGridEditingCell, NuGridEditorConfig, NuGridEditorRenderContext, NuGridRowValidationError, } from './cell-editing.js';
+export type { UseNuGridActionMenuReturn, UseNuGridColumnsReturn, UseNuGridRowSelectionReturn, } from './composable-returns.js';
+export type { NuGridConfig, NuGridUISlots } from './config.js';
+export * from './contexts/index.js';
+export type { NuGridAddRowContext, NuGridAddRowPosition, NuGridAddRowState, } from './contexts/add-row.js';
+export type { NuGridAnimationContext } from './contexts/animation.js';
+export type { NuGridCoreContext } from './contexts/core.js';
+export type { NuGridDragContext } from './contexts/drag.js';
+export type { NuGridFocusContext } from './contexts/focus.js';
+export type { NuGridGroupingContext } from './contexts/grouping.js';
+export type { NuGridInteractionRouterContext } from './contexts/interaction-router.js';
+export type { NuGridMultiRowContext } from './contexts/multi-row.js';
+export type { NuGridPagingContext } from './contexts/paging.js';
+export type { NuGridPerformanceContext } from './contexts/performance.js';
+export type { NuGridResizeContext } from './contexts/resize.js';
+export type { NuGridRowInteractionsContext } from './contexts/row-interactions.js';
+export type { NuGridScrollStateContext } from './contexts/scroll-state.js';
+export type { NuGridUIConfigContext } from './contexts/ui-config.js';
+export type { NuGridVirtualizationContext } from './contexts/virtualization.js';
+export type { NuGridColumnDragDrop, NuGridRowDragDrop } from './drag-drop.js';
+export type { NuGridFocus, NuGridFocusedCell } from './focus.js';
+export type { NuGridGroupingFns } from './grouping.js';
+export type { EventMetadata, NuGridCellClickContext, NuGridHoverContext, NuGridHoverHandler, NuGridInteractionHandler, NuGridInteractionRouter, NuGridInteractionRouteResult, NuGridKeyboardConfig, NuGridKeyboardContext, NuGridKeyboardHandler, NuGridPointerContext, NuGridPointerHandler, NuGridWheelContext, NuGridWheelHandler, } from './interaction-router.js';
+export { getEventFlag, hasEventFlag, ROUTER_PRIORITIES, setEventFlag } from './interaction-router.js';
+export type { NuGridCreateConfigOptions, NuGridPreset } from './props.js';
+export type { NuGridColumnResize, PinnableHeader } from './resize.js';
+export type { NuGridRowInteractions } from './row-interactions.js';
+export type { NuGridRowSelectionMode, NuGridSelectionColumnDef, NuGridSelectionColumnMeta, } from './row-selection.js';
+export type { NuGridStates } from './states.js';
+export type { NuGridStickyHeaderClasses } from './sticky-headers.js';
+export type { NuGridResolvedValidation, NuGridRowValidationResult, NuGridRowValidationRule, NuGridValidationContext, } from './validation.js';
+export type { GroupingVirtualRowHeights, GroupVirtualRowItem, GroupVirtualRowType, NuGridVirtualItemStyle, NuGridVirtualizer, NuGridVirtualizerOptions, OverscanSetting, ResolvedNuGridVirtualizeOptions, } from './virtualization.js';

package/dist/runtime/types/_internal/index.js

@@ -0,0 +1,2 @@
+export * from "./contexts/index.js";
+export { getEventFlag, hasEventFlag, ROUTER_PRIORITIES, setEventFlag } from "./interaction-router.js";

package/dist/runtime/types/_internal/interaction-router.d.ts

@@ -0,0 +1,176 @@
+import type { TableData } from '@nuxt/ui';
+import type { Cell, Row, Table } from '@tanstack/vue-table';
+import type { NuGridCellEditing } from './cell-editing.js';
+import type { NuGridFocus, NuGridFocusedCell } from './focus.js';
+/**
+ * Priority ranges for interaction router handlers
+ * Lower numbers execute first
+ */
+export declare const ROUTER_PRIORITIES: {
+    /** Guards - veto events early (0-9) */
+    readonly GUARD_MIN: 0;
+    readonly GUARD_MAX: 9;
+    /** Focus management (10-19) */
+    readonly FOCUS_MIN: 10;
+    readonly FOCUS: 10;
+    readonly FOCUS_MAX: 19;
+    /** Editing (20-29) */
+    readonly EDITING_MIN: 20;
+    readonly EDITING: 20;
+    readonly EDITING_OUTSIDE: 25;
+    readonly EDITING_MAX: 29;
+    /** Actions (30-99) */
+    readonly ACTION_MIN: 30;
+    readonly ACTION_MAX: 99;
+    /** Low priority - tooltips, etc (100+) */
+    readonly LOW_PRIORITY: 100;
+    /** Keyboard: Cell type handlers (15) - before editing triggers */
+    readonly KEYBOARD_CELL_TYPE: 15;
+    /** Keyboard: Editing triggers - F2, Enter, Backspace, alphanumeric (20) */
+    readonly KEYBOARD_EDITING_TRIGGERS: 20;
+    /** Keyboard: Paging - PageUp/PageDown, Cmd+Up/Down when paging enabled (25) */
+    readonly KEYBOARD_PAGING: 25;
+    /** Keyboard: Navigation - arrows, tab, page up/down, etc. (30) */
+    readonly KEYBOARD_NAVIGATION: 30;
+};
+/**
+ * Event metadata storage - replaces magic event properties
+ */
+export interface EventMetadata {
+    addRowFinalizing?: boolean;
+    addRowCellTransition?: boolean;
+    addRowUneditableClick?: boolean;
+    [key: string]: any;
+}
+/**
+ * Set metadata flag on an event
+ */
+export declare function setEventFlag(event: Event, key: string, value: any): void;
+/**
+ * Get metadata flag from an event
+ */
+export declare function getEventFlag<T = any>(event: Event, key: string, defaultValue?: T): T;
+/**
+ * Check if event has a metadata flag
+ */
+export declare function hasEventFlag(event: Event, key: string): boolean;
+export interface NuGridCellClickContext<T extends TableData = TableData> {
+    event: MouseEvent;
+    row: Row<T>;
+    cell: Cell<T, any>;
+    cellIndex: number;
+}
+export interface NuGridInteractionRouteResult {
+    handled?: boolean;
+    stop?: boolean;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+}
+export interface NuGridInteractionHandler<T extends TableData = TableData> {
+    id: string;
+    priority: number;
+    when?: (context: NuGridCellClickContext<T>) => boolean;
+    handle: (context: NuGridCellClickContext<T>) => NuGridInteractionRouteResult | void;
+}
+export interface NuGridPointerContext {
+    event: PointerEvent | MouseEvent;
+}
+export interface NuGridPointerHandler {
+    id: string;
+    priority: number;
+    when?: (context: NuGridPointerContext) => boolean;
+    handle: (context: NuGridPointerContext) => NuGridInteractionRouteResult | void;
+}
+export interface NuGridHoverContext {
+    event: MouseEvent;
+    target: HTMLElement;
+    type: 'enter' | 'leave' | 'move';
+}
+export interface NuGridHoverHandler {
+    id: string;
+    priority: number;
+    when?: (context: NuGridHoverContext) => boolean;
+    handle: (context: NuGridHoverContext) => NuGridInteractionRouteResult | void;
+}
+export interface NuGridWheelContext<T extends TableData = TableData> {
+    event: WheelEvent;
+    row: Row<T>;
+    cell: Cell<T, any>;
+    cellIndex: number;
+}
+export interface NuGridWheelHandler<T extends TableData = TableData> {
+    id: string;
+    priority: number;
+    when?: (context: NuGridWheelContext<T>) => boolean;
+    handle: (context: NuGridWheelContext<T>) => NuGridInteractionRouteResult | void;
+}
+/**
+ * Keyboard context passed to keyboard handlers
+ */
+export interface NuGridKeyboardContext<T extends TableData = TableData> {
+    /** The keyboard event */
+    event: KeyboardEvent;
+    /** Current focused cell position (null if no cell focused) */
+    focusedCell: NuGridFocusedCell | null;
+    /** The focused row instance (if focused) */
+    focusedRow: Row<T> | null;
+    /** The focused cell instance (if focused) */
+    cell: Cell<T, any> | null;
+    /** Cell index within the row */
+    cellIndex: number;
+    /** Whether a cell is currently being edited */
+    isEditing: boolean;
+    /** Focus mode from props ('none' | 'cell' | 'row') */
+    focusMode: 'none' | 'cell' | 'row';
+    /** Whether editing is enabled */
+    editingEnabled: boolean;
+    /** TanStack table API */
+    tableApi: Table<T>;
+    /** Focus functions for navigation */
+    focusFns: NuGridFocus<T>;
+    /** Cell editing functions */
+    cellEditingFns: NuGridCellEditing<T>;
+}
+/**
+ * Keyboard handler definition - follows NuGridInteractionHandler pattern
+ */
+export interface NuGridKeyboardHandler<T extends TableData = TableData> {
+    id: string;
+    priority: number;
+    /** Optional condition - handler only runs if when() returns true */
+    when?: (context: NuGridKeyboardContext<T>) => boolean;
+    /** Handle the keyboard event */
+    handle: (context: NuGridKeyboardContext<T>) => NuGridInteractionRouteResult | void;
+    /**
+     * Request document-level keyboard listening.
+     * Use this when the handler needs to capture events on elements outside the grid
+     * (e.g., teleported dropdowns, modals).
+     * Document-level handlers receive a minimal context (event + editing state).
+     */
+    documentLevel?: boolean;
+}
+/**
+ * Configuration for keyboard event handling
+ */
+export interface NuGridKeyboardConfig<T extends TableData = TableData> {
+    /** Whether to attach listener to document (true) or grid root (false) */
+    retainFocus: boolean;
+    /** Build context for a keyboard event. Return null to skip routing. */
+    buildContext: (event: KeyboardEvent) => NuGridKeyboardContext<T> | null;
+}
+export interface NuGridInteractionRouter<T extends TableData = TableData> {
+    registerCellClickHandler: (handler: NuGridInteractionHandler<T>) => () => void;
+    routeCellClick: (context: NuGridCellClickContext<T>) => void;
+    registerCellDoubleClickHandler: (handler: NuGridInteractionHandler<T>) => () => void;
+    routeCellDoubleClick: (context: NuGridCellClickContext<T>) => void;
+    registerContextMenuHandler: (handler: NuGridInteractionHandler<T>) => () => void;
+    routeContextMenu: (context: NuGridCellClickContext<T>) => void;
+    registerWheelHandler: (handler: NuGridWheelHandler<T>) => () => void;
+    routeWheel: (context: NuGridWheelContext<T>) => void;
+    registerGlobalPointerHandler: (handler: NuGridPointerHandler) => () => void;
+    registerHoverHandler: (handler: NuGridHoverHandler) => () => void;
+    registerKeyboardHandler: (handler: NuGridKeyboardHandler<T>) => () => void;
+    routeKeyboard: (context: NuGridKeyboardContext<T>) => void;
+    setKeyboardConfig: (config: NuGridKeyboardConfig<T> | null) => void;
+    setGridRoot: (el: HTMLElement | null) => void;
+}

package/dist/runtime/types/_internal/interaction-router.js

@@ -0,0 +1,39 @@
+export const ROUTER_PRIORITIES = {
+  /** Guards - veto events early (0-9) */
+  GUARD_MIN: 0,
+  GUARD_MAX: 9,
+  /** Focus management (10-19) */
+  FOCUS_MIN: 10,
+  FOCUS: 10,
+  FOCUS_MAX: 19,
+  /** Editing (20-29) */
+  EDITING_MIN: 20,
+  EDITING: 20,
+  EDITING_OUTSIDE: 25,
+  EDITING_MAX: 29,
+  /** Actions (30-99) */
+  ACTION_MIN: 30,
+  ACTION_MAX: 99,
+  /** Low priority - tooltips, etc (100+) */
+  LOW_PRIORITY: 100,
+  /** Keyboard: Cell type handlers (15) - before editing triggers */
+  KEYBOARD_CELL_TYPE: 15,
+  /** Keyboard: Editing triggers - F2, Enter, Backspace, alphanumeric (20) */
+  KEYBOARD_EDITING_TRIGGERS: 20,
+  /** Keyboard: Paging - PageUp/PageDown, Cmd+Up/Down when paging enabled (25) */
+  KEYBOARD_PAGING: 25,
+  /** Keyboard: Navigation - arrows, tab, page up/down, etc. (30) */
+  KEYBOARD_NAVIGATION: 30
+};
+const eventMetadata = /* @__PURE__ */ new WeakMap();
+export function setEventFlag(event, key, value) {
+  const meta = eventMetadata.get(event) ?? {};
+  meta[key] = value;
+  eventMetadata.set(event, meta);
+}
+export function getEventFlag(event, key, defaultValue) {
+  return eventMetadata.get(event)?.[key] ?? defaultValue;
+}
+export function hasEventFlag(event, key) {
+  return eventMetadata.has(event) && key in (eventMetadata.get(event) ?? {});
+}

package/dist/runtime/types/_internal/props.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @internal
+ */
+import type { TableData } from '@nuxt/ui';
+import type { NuGridProps } from '../props.js';
+/**
+ * Available NuGrid preset configurations
+ * - 'readOnly': Read-only grid with basic navigation
+ * - 'editable': Editable grid with validation and editing features
+ * - 'kanban': Kanban-style grid with drag-and-drop
+ * - 'forms': Form-like grid optimized for data entry
+ * - 'analytics': Analytics-focused grid with virtualization
+ * @internal
+ */
+export type NuGridPreset = 'readOnly' | 'editable' | 'kanban' | 'forms' | 'analytics';
+/**
+ * Preset options configuration
+ * @internal
+ */
+export type { NuGridPresetOptions } from '../props.js';
+/**
+ * Options for creating NuGrid configuration
+ * @internal
+ */
+export interface NuGridCreateConfigOptions<T extends TableData = TableData> {
+    preset?: NuGridPreset;
+    config?: Partial<NuGridProps<T>>;
+}

package/dist/runtime/types/_internal/resize.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @internal
+ */
+import type { TableData } from '@nuxt/ui';
+import type { Header } from '@tanstack/vue-table';
+import type { Ref } from 'vue';
+/**
+ * Type for nugrid-resizefns injection
+ * Provides column resize functionality
+ * @internal
+ */
+export interface NuGridColumnResize<T extends TableData = TableData> {
+    handleResizeStart: (event: MouseEvent | TouchEvent, header: Header<T, any>) => void;
+    handleGroupResizeStart: (event: MouseEvent | TouchEvent, header: Header<T, any>) => void;
+    handleResizeEnd: () => void;
+    resizingGroupId: Ref<string | null>;
+    resizingColumnId: Ref<string | null>;
+}
+/**
+ * Header type used for pinning calculations.
+ * @internal
+ */
+export interface PinnableHeader {
+    colSpan: number;
+    column: {
+        getIsPinned: () => false | 'left' | 'right';
+        getStart: (position: 'left') => number;
+        getAfter: (position: 'right') => number;
+    };
+    getLeafHeaders: () => Array<{
+        column: {
+            getIsPinned: () => false | 'left' | 'right';
+            getStart: (position: 'left') => number;
+            getAfter: (position: 'right') => number;
+        };
+    }>;
+}

package/dist/runtime/types/_internal/row-interactions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @internal
+ */
+import type { TableData } from '@nuxt/ui';
+import type { Row } from '@tanstack/vue-table';
+/**
+ * Type for nugrid-rowinteractions injection
+ * Provides row interaction handlers
+ * @internal
+ */
+export interface NuGridRowInteractions<T extends TableData = TableData> {
+    onRowSelect: (e: Event, row: Row<T>) => void;
+    onRowHover: (e: Event, row: Row<T> | null) => void;
+    onRowContextmenu: (e: Event, row: Row<T>) => void;
+}

package/dist/runtime/types/_internal/row-selection.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @internal
+ */
+import type { TableColumn, TableData } from '@nuxt/ui';
+import type { Row } from '@tanstack/vue-table';
+import type { Ref } from 'vue';
+import type { NuGridRowSelectOptions } from '../row-selection.js';
+/**
+ * Column definition overrides for the selection column
+ * Excludes properties that are required for the selection column to function correctly
+ * @internal
+ */
+export type NuGridSelectionColumnDef<T extends TableData = TableData> = Partial<Omit<TableColumn<T>, 'id' | 'header' | 'cell' | 'accessorFn' | 'meta' | 'cellDataType'>>;
+/**
+ * Meta data stored on the selection column
+ * @internal
+ */
+export interface NuGridSelectionColumnMeta<T extends TableData = TableData> {
+    selectionEnabled: boolean;
+    enabledRef?: Ref<boolean>;
+    rowSelectionEnabledRef?: Ref<((row: Row<T>) => boolean) | undefined>;
+}
+/**
+ * Row selection mode type - supports legacy boolean/'single'/'multi' or new options object
+ * @internal
+ */
+export type NuGridRowSelectionMode<T extends TableData = TableData> = boolean | 'single' | 'multi' | NuGridRowSelectOptions<T> | undefined;

package/dist/runtime/types/_internal/states.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @internal
+ */
+import type { ColumnFiltersState, ColumnOrderState, ColumnPinningState, ColumnSizingInfoState, ColumnSizingState, ExpandedState, GroupingState, PaginationState, RowPinningState, RowSelectionState, SortingState, VisibilityState } from '@tanstack/vue-table';
+import type { Ref } from 'vue';
+/**
+ * Grid state refs container
+ * @internal
+ */
+export interface NuGridStates {
+    globalFilterState: Ref<string>;
+    columnFiltersState: Ref<ColumnFiltersState>;
+    columnOrderState: Ref<ColumnOrderState>;
+    columnVisibilityState: Ref<VisibilityState>;
+    columnPinningState: Ref<ColumnPinningState>;
+    columnSizingState: Ref<ColumnSizingState>;
+    columnSizingInfoState: Ref<ColumnSizingInfoState>;
+    rowSelectionState: Ref<RowSelectionState>;
+    rowPinningState: Ref<RowPinningState>;
+    sortingState: Ref<SortingState>;
+    groupingState: Ref<GroupingState>;
+    expandedState: Ref<ExpandedState>;
+    paginationState: Ref<PaginationState>;
+}

package/dist/runtime/types/_internal/sticky-headers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @internal
+ */
+import type { ComputedRef } from 'vue';
+/**
+ * Type for nugrid-stickyheaderclasses injection
+ * Provides sticky header CSS classes
+ * @internal
+ */
+export type NuGridStickyHeaderClasses = ComputedRef<string[]>;

package/dist/runtime/types/_internal/validation.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @internal
+ */
+import type { TableData } from '@nuxt/ui';
+import type { Ref } from 'vue';
+import type { StandardSchemaV1 } from '../../utils/standardSchema.js';
+import type { NuGridOnInvalid, NuGridShowErrors, NuGridValidateOn } from '../validation.js';
+/**
+ * Result of a row validation rule
+ * @internal
+ */
+export interface NuGridRowValidationResult {
+    /**
+     * Whether the row is valid
+     */
+    valid: boolean;
+    /**
+     * Error message to display
+     */
+    message?: string;
+    /**
+     * The field(s) that caused the validation failure
+     * These cells will be highlighted with error styling
+     * If not specified, all cells in the row will show error styling
+     */
+    failedFields?: string[];
+}
+/**
+ * A row-level validation rule
+ * Returns validation result based on the entire row data
+ * @internal
+ */
+export type NuGridRowValidationRule<T extends TableData = TableData> = (row: T) => NuGridRowValidationResult;
+/**
+ * Normalized validation options resolved internally
+ * @internal
+ */
+export interface NuGridResolvedValidation<T extends TableData = TableData> {
+    schema: StandardSchemaV1<T> | null;
+    rowRules: NuGridRowValidationRule<T>[];
+    validateOn: NuGridValidateOn;
+    showErrors: NuGridShowErrors;
+    icon: string;
+    onInvalid: NuGridOnInvalid;
+    validateOnAddRow: boolean;
+}
+/**
+ * Validation context provided to cell editors
+ * @internal
+ */
+export interface NuGridValidationContext {
+    showErrors?: Ref<NuGridShowErrors>;
+    icon?: Ref<string>;
+}

package/dist/runtime/types/_internal/virtualization.d.ts

@@ -0,0 +1,114 @@
+import type { TableData } from '@nuxt/ui';
+import type { Row } from '@tanstack/vue-table';
+import type { Virtualizer, VirtualizerOptions } from '@tanstack/vue-virtual';
+import type { ComputedRef } from 'vue';
+/**
+ * Configuration for virtual row heights in grouped grid mode.
+ * These heights are used by useNuGridGrouping for virtualization calculations.
+ */
+export interface GroupingVirtualRowHeights {
+    /**
+     * Height of group header rows (in pixels)
+     * @defaultValue 50
+     */
+    groupHeader?: number;
+    /**
+     * Height of a single column header row (in pixels)
+     * @defaultValue 50
+     */
+    columnHeader?: number;
+    /**
+     * Height of data rows (in pixels)
+     * @defaultValue 80
+     */
+    dataRow?: number;
+    /**
+     * Height of footer rows (in pixels)
+     * @defaultValue 45
+     */
+    footer?: number;
+}
+/**
+ * Type of virtual row in grouped grid mode
+ */
+export type GroupVirtualRowType = 'group-header' | 'column-headers' | 'data' | 'footer';
+/**
+ * Virtual row item for grouped grid virtualization
+ */
+export interface GroupVirtualRowItem<T extends TableData = TableData> {
+    type: GroupVirtualRowType;
+    height: number;
+    groupId?: string;
+    groupRow?: Row<T>;
+    dataRow?: Row<T>;
+    index: number;
+    depth?: number;
+}
+/**
+ * Keys to omit from base VirtualizerOptions as they are managed internally.
+ */
+type OmittedVirtualizerKeys = 'getScrollElement' | 'count' | 'estimateSize' | 'overscan';
+export type OverscanSetting = number | Record<string, number>;
+/**
+ * Extended virtualization options for NuGrid.
+ * Includes standard TanStack Virtual options plus NuGrid-specific row heights.
+ */
+export type NuGridVirtualizerOptions = Partial<Omit<VirtualizerOptions<Element, Element>, OmittedVirtualizerKeys>> & {
+    /**
+     * Toggle virtualization. If omitted, treated as enabled when the object is provided.
+     */
+    enabled?: boolean;
+    /**
+     * Number of items rendered outside the visible area
+     * - number: uniform overscan
+     * - record: overscan per breakpoint key (uses `default` when no match)
+     * @defaultValue 12 (with breakpoint defaults stored in nuGridDefaults)
+     */
+    overscan?: OverscanSetting;
+    /**
+     * Explicit map for breakpoint-based overscan overrides. Takes precedence over `overscan` when set.
+     */
+    overscanByBreakpoint?: Record<string, number>;
+    /**
+     * Estimated size (in px) of each item
+     * @defaultValue 65
+     */
+    estimateSize?: number;
+    /**
+     * Custom heights for virtual row types used in grouped grid mode.
+     * Only applicable when grouped layouts are active.
+     */
+    rowHeights?: GroupingVirtualRowHeights;
+    /**
+     * Enable dynamic row height measurement. See docs for default behavior.
+     */
+    dynamicRowHeights?: boolean;
+};
+export type ResolvedNuGridVirtualizeOptions = Omit<NuGridVirtualizerOptions, 'enabled' | 'overscan' | 'estimateSize' | 'dynamicRowHeights' | 'rowHeights'> & {
+    enabled: boolean;
+    overscan: number;
+    overscanByBreakpoint?: Record<string, number>;
+    estimateSize: number;
+    dynamicRowHeights: boolean;
+    rowHeights: Required<GroupingVirtualRowHeights>;
+};
+export interface NuGridVirtualizer<TScrollElement extends Element = Element, TItemElement extends Element = Element> extends Virtualizer<TScrollElement, TItemElement> {
+    props: ComputedRef<ResolvedNuGridVirtualizeOptions>;
+    dynamicRowHeightsEnabled: ComputedRef<boolean>;
+}
+/**
+ * CSS style object for virtualized grid items.
+ * Used by getVirtualItemStyle functions in NuGridBase, NuGridGroup, and NuGridSplitGroup.
+ */
+export type NuGridVirtualItemStyle = {
+    position: 'sticky' | 'absolute';
+    top: string | number;
+    width: string | number;
+    left?: number;
+    zIndex?: number;
+    height?: string;
+    transform?: string;
+    backgroundColor?: string;
+    boxShadow?: string;
+} & Record<string, string | number | undefined>;
+export {};

package/dist/runtime/types/action-menu.d.ts

@@ -0,0 +1,62 @@
+import type { Row } from '@tanstack/vue-table';
+import type { NuGridActionMenuButton, NuGridActionMenuColumnDef } from './_internal/index.js';
+/**
+ * Action menu item type - compatible with UDropdownMenu items
+ */
+export type NuGridActionMenuItem = {
+    type?: 'label' | 'separator';
+    label?: string;
+} | {
+    label: string;
+    icon?: string;
+    color?: 'error' | 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'neutral';
+    disabled?: boolean;
+    onSelect?: (event?: Event) => void;
+};
+/**
+ * Action menu options for configuring the action menu column
+ */
+export interface NuGridActionMenuOptions<T = any> {
+    /**
+     * Whether actions column is enabled
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Function that returns menu items for a specific row
+     * @param row - The row data
+     * @returns Array of menu items
+     */
+    getActions?: (row: Row<T>) => NuGridActionMenuItem[];
+    /**
+     * Function that determines if the action menu is enabled for a specific row
+     * @param row - The row data
+     * @returns Whether the action menu should be enabled
+     * @default () => true
+     */
+    isRowEnabled?: (row: Row<T>) => boolean;
+    /**
+     * Button configuration for the action menu trigger
+     * @default { icon: 'i-lucide-ellipsis-vertical', color: 'neutral', variant: 'ghost', class: 'ml-auto' }
+     */
+    button?: NuGridActionMenuButton;
+    /**
+     * Whether the action menu column should be hidden (but still in columns collection)
+     * @default false
+     */
+    hidden?: boolean;
+    /**
+     * Column definition overrides for the action menu column
+     * Allows customizing properties like size, enableResizing, enableReordering, etc.
+     * @example
+     * // Allow resizing and reordering the action menu column
+     * columnDef: {
+     *   enableResizing: true,
+     *   enableReordering: true,
+     *   size: 80,
+     *   minSize: 50,
+     *   maxSize: 120
+     * }
+     */
+    columnDef?: NuGridActionMenuColumnDef;
+}

package/dist/runtime/types/autosize.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Type for nugrid-autosizefns injection
+ * Provides column autosize functionality
+ */
+export interface NuGridAutosize {
+    autoSizeColumns: (mode?: 'fitCell' | 'fitGrid') => void;
+    autoSizeColumn: (columnId: string) => void;
+}