@nu-grid/nuxt 0.1.1

package/dist/runtime/components/_internal/NuGridSplitGroup.vue.d.ts

@@ -0,0 +1,20 @@
+import type { TableData, TableSlots } from '@nuxt/ui';
+import type { NuGridProps } from '../../types/index.js';
+declare const __VLS_export: <T extends TableData>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<NuGridProps<T>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: TableSlots<T>;
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/components/_internal/NuGridTooltip.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/_internal/NuGridTooltip.vue

@@ -0,0 +1,36 @@
+<script setup>
+import theme from "#build/ui/tooltip";
+import { tv } from "@nuxt/ui/utils/tv";
+import { Presence } from "reka-ui";
+import { computed } from "vue";
+import { useNuGridTooltip } from "../../composables/_internal/useNuGridTooltip";
+const { tooltipState } = useNuGridTooltip();
+const appConfig = useAppConfig();
+const ui = computed(
+  () => tv({ extend: tv(theme), ...appConfig.ui?.tooltip || {} })({
+    side: "top"
+  })
+);
+const isOpen = computed(() => !!tooltipState.value);
+</script>
+
+<template>
+  <Teleport to="body">
+    <Presence :present="isOpen">
+      <div
+        v-if="tooltipState"
+        :data-state="isOpen ? 'delayed-open' : 'closed'"
+        data-slot="content"
+        class="pointer-events-none fixed z-50 -translate-x-1/2 -translate-y-full"
+        :class="ui.content()"
+        :style="{
+  'left': `${tooltipState.x}px`,
+  'top': `${tooltipState.y - 8}px`,
+  '--reka-tooltip-content-transform-origin': 'bottom center'
+}"
+      >
+        <span data-slot="text" class="truncate" :class="ui.text()">{{ tooltipState.text }}</span>
+      </div>
+    </Presence>
+  </Teleport>
+</template>

package/dist/runtime/components/_internal/NuGridTooltip.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,31 @@
+/**
+ * @internal
+ */
+export * from './keyboard-handlers/index.js';
+export * from './useNuGridActionMenu.js';
+export * from './useNuGridAddRow.js';
+export * from './useNuGridAnimation.js';
+export * from './useNuGridAutosize.js';
+export * from './useNuGridCellEditing.js';
+export * from './useNuGridColumnDragDrop.js';
+export * from './useNuGridColumnPinning.js';
+export * from './useNuGridColumnResize.js';
+export * from './useNuGridCore.js';
+export * from './useNuGridExcel.js';
+export * from './useNuGridFocus.js';
+export * from './useNuGridGrouping.js';
+export * from './useNuGridGroupSelection.js';
+export * from './useNuGridInteractionRouter.js';
+export * from './useNuGridInteractions.js';
+export * from './useNuGridKeyboardNavigation.js';
+export * from './useNuGridPaging.js';
+export * from './useNuGridRowDragDrop.js';
+export * from './useNuGridRowSelection.js';
+export * from './useNuGridScroll.js';
+export * from './useNuGridScrollbars.js';
+export * from './useNuGridScrollState.js';
+export * from './useNuGridStatePersistence.js';
+export * from './useNuGridTooltip.js';
+export * from './useNuGridUI.js';
+export * from './useNuGridVirtualization.js';
+export * from './useNuGridWheelSmoothing.js';

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

@@ -0,0 +1,28 @@
+export * from "./keyboard-handlers/index.js";
+export * from "./useNuGridActionMenu.js";
+export * from "./useNuGridAddRow.js";
+export * from "./useNuGridAnimation.js";
+export * from "./useNuGridAutosize.js";
+export * from "./useNuGridCellEditing.js";
+export * from "./useNuGridColumnDragDrop.js";
+export * from "./useNuGridColumnPinning.js";
+export * from "./useNuGridColumnResize.js";
+export * from "./useNuGridCore.js";
+export * from "./useNuGridExcel.js";
+export * from "./useNuGridFocus.js";
+export * from "./useNuGridGrouping.js";
+export * from "./useNuGridGroupSelection.js";
+export * from "./useNuGridInteractionRouter.js";
+export * from "./useNuGridInteractions.js";
+export * from "./useNuGridKeyboardNavigation.js";
+export * from "./useNuGridPaging.js";
+export * from "./useNuGridRowDragDrop.js";
+export * from "./useNuGridRowSelection.js";
+export * from "./useNuGridScroll.js";
+export * from "./useNuGridScrollbars.js";
+export * from "./useNuGridScrollState.js";
+export * from "./useNuGridStatePersistence.js";
+export * from "./useNuGridTooltip.js";
+export * from "./useNuGridUI.js";
+export * from "./useNuGridVirtualization.js";
+export * from "./useNuGridWheelSmoothing.js";

package/dist/runtime/composables/_internal/keyboard-handlers/index.d.ts

@@ -0,0 +1,5 @@
+export { type CellTypeDispatchOptions, createCellTypeDispatchHandler, } from './useKeyboardCellTypeDispatch.js';
+export { createEditingTriggersHandler, type EditingTriggersOptions, type StartKeyOption, type StartKeysConfig, } from './useKeyboardEditingTriggers.js';
+export { createNavigationHandler } from './useKeyboardNavigation.js';
+export { type KeyboardSetupOptions, useKeyboardSetup } from './useKeyboardSetup.js';
+export { createPagingKeyboardHandler } from './usePagingKeyboard.js';

package/dist/runtime/composables/_internal/keyboard-handlers/index.js

@@ -0,0 +1,9 @@
+export {
+  createCellTypeDispatchHandler
+} from "./useKeyboardCellTypeDispatch.js";
+export {
+  createEditingTriggersHandler
+} from "./useKeyboardEditingTriggers.js";
+export { createNavigationHandler } from "./useKeyboardNavigation.js";
+export { useKeyboardSetup } from "./useKeyboardSetup.js";
+export { createPagingKeyboardHandler } from "./usePagingKeyboard.js";

package/dist/runtime/composables/_internal/keyboard-handlers/useKeyboardCellTypeDispatch.d.ts

@@ -0,0 +1,18 @@
+import type { TableData } from '@nuxt/ui';
+import type { Ref } from 'vue';
+import type { NuGridKeyboardHandler } from '../../../types/_internal/index.js';
+export interface CellTypeDispatchOptions<T extends TableData> {
+    cellTypes?: Ref<any[] | undefined>;
+    data: Ref<T[]>;
+    emit: (payload: {
+        row: any;
+        column: any;
+        oldValue: any;
+        newValue: any;
+    }) => void;
+}
+/**
+ * Creates a keyboard handler that dispatches to cell type keyboard handlers
+ * Priority 15 - runs before editing triggers
+ */
+export declare function createCellTypeDispatchHandler<T extends TableData>(options: CellTypeDispatchOptions<T>): NuGridKeyboardHandler<T>;

package/dist/runtime/composables/_internal/keyboard-handlers/useKeyboardCellTypeDispatch.js

@@ -0,0 +1,53 @@
+import { ROUTER_PRIORITIES } from "../../../types/_internal/index.js";
+import { useNuGridCellTypeRegistry } from "../../useNuGridCellTypeRegistry.js";
+export function createCellTypeDispatchHandler(options) {
+  const typeRegistry = useNuGridCellTypeRegistry(options.cellTypes);
+  return {
+    id: "keyboard-cell-type-dispatch",
+    priority: ROUTER_PRIORITIES.KEYBOARD_CELL_TYPE,
+    when: (ctx) => {
+      return !ctx.isEditing && ctx.cell !== null && ctx.focusedCell !== null;
+    },
+    handle: (ctx) => {
+      const { cell, focusedRow: row, event, cellEditingFns, tableApi, focusFns, cellIndex } = ctx;
+      if (!cell || !row) return { handled: false };
+      const columnDef = cell.column.columnDef;
+      const cellDataType = columnDef.cellDataType || "text";
+      const keyboardHandler = typeRegistry.getKeyboardHandler(cellDataType);
+      if (!keyboardHandler) {
+        return { handled: false };
+      }
+      const isFocused = focusFns.shouldCellHandleKeydown(row, cellIndex);
+      const canEdit = cellEditingFns.isCellEditable(row, cell);
+      const pluginContext = {
+        cell,
+        row,
+        columnDef,
+        column: cell.column,
+        getValue: () => cell.getValue(),
+        isFocused,
+        canEdit,
+        data: options.data.value,
+        tableApi,
+        startEditing: (initialValue) => cellEditingFns.startEditing(row, cell, initialValue),
+        stopEditing: (newValue, moveDirection) => {
+          cellEditingFns.stopEditing(row, cell, newValue, moveDirection);
+        },
+        emitChange: (oldValue, newValue) => {
+          options.emit({
+            row,
+            column: cell.column,
+            oldValue,
+            newValue
+          });
+        }
+      };
+      const result = keyboardHandler(event, pluginContext);
+      return {
+        handled: result.handled,
+        preventDefault: result.preventDefault,
+        stopPropagation: result.stopPropagation
+      };
+    }
+  };
+}

package/dist/runtime/composables/_internal/keyboard-handlers/useKeyboardEditingTriggers.d.ts

@@ -0,0 +1,12 @@
+import type { TableData } from '@nuxt/ui';
+import type { NuGridKeyboardHandler } from '../../../types/_internal/index.js';
+export type StartKeyOption = 'enter' | 'f2' | 'bs' | 'alpha' | 'numeric';
+export type StartKeysConfig = 'all' | 'minimal' | 'none' | StartKeyOption[];
+export interface EditingTriggersOptions {
+    getStartKeys: () => StartKeysConfig;
+}
+/**
+ * Creates a keyboard handler for editing triggers (F2, Enter, Backspace, alphanumeric)
+ * Priority 20 - runs after cell type handlers
+ */
+export declare function createEditingTriggersHandler<T extends TableData>(options: EditingTriggersOptions): NuGridKeyboardHandler<T>;

package/dist/runtime/composables/_internal/keyboard-handlers/useKeyboardEditingTriggers.js

@@ -0,0 +1,53 @@
+import { ROUTER_PRIORITIES } from "../../../types/_internal/index.js";
+function parseStartKeys(config) {
+  if (config === "all") {
+    return ["enter", "f2", "bs", "alpha", "numeric"];
+  }
+  if (config === "minimal") {
+    return ["enter", "f2"];
+  }
+  if (config === "none") {
+    return [];
+  }
+  return config;
+}
+export function createEditingTriggersHandler(options) {
+  return {
+    id: "keyboard-editing-triggers",
+    priority: ROUTER_PRIORITIES.KEYBOARD_EDITING_TRIGGERS,
+    when: (ctx) => {
+      if (ctx.isEditing || !ctx.editingEnabled) return false;
+      if (!ctx.cell || !ctx.focusedRow) return false;
+      return ctx.cellEditingFns.isCellEditable(ctx.focusedRow, ctx.cell);
+    },
+    handle: (ctx) => {
+      const { event, cell, focusedRow: row, cellEditingFns } = ctx;
+      if (!cell || !row) return { handled: false };
+      const enabledKeys = parseStartKeys(options.getStartKeys());
+      if (enabledKeys.length === 0) {
+        return { handled: false };
+      }
+      if (event.key === "F2" && enabledKeys.includes("f2")) {
+        cellEditingFns.startEditing(row, cell);
+        return { handled: true, preventDefault: true, stopPropagation: true };
+      }
+      if ((event.key === "Backspace" || event.key === "Delete") && enabledKeys.includes("bs")) {
+        cellEditingFns.startEditing(row, cell, "");
+        return { handled: true, preventDefault: true, stopPropagation: true };
+      }
+      if (event.key === "Enter" && enabledKeys.includes("enter")) {
+        cellEditingFns.startEditing(row, cell);
+        return { handled: true, preventDefault: true, stopPropagation: true };
+      }
+      if (event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey && event.key !== " ") {
+        const isAlpha = /[a-z]/i.test(event.key);
+        const isNumeric = /\d/.test(event.key);
+        if (isAlpha && enabledKeys.includes("alpha") || isNumeric && enabledKeys.includes("numeric")) {
+          cellEditingFns.startEditing(row, cell, event.key);
+          return { handled: true, preventDefault: true, stopPropagation: true };
+        }
+      }
+      return { handled: false };
+    }
+  };
+}

package/dist/runtime/composables/_internal/keyboard-handlers/useKeyboardNavigation.d.ts

@@ -0,0 +1,9 @@
+import type { TableData } from '@nuxt/ui';
+import type { NuGridKeyboardHandler } from '../../../types/_internal/index.js';
+/**
+ * Creates a keyboard handler for navigation keys
+ * Priority 30 - runs after cell type and editing handlers
+ *
+ * Delegates to the focus system's onCellKeyDown for actual navigation logic
+ */
+export declare function createNavigationHandler<T extends TableData>(): NuGridKeyboardHandler<T>;

package/dist/runtime/composables/_internal/keyboard-handlers/useKeyboardNavigation.js

@@ -0,0 +1,35 @@
+import { ROUTER_PRIORITIES } from "../../../types/_internal/index.js";
+const NAVIGATION_KEYS = [
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "Tab",
+  " "
+  // Space key for row selection toggle
+];
+export function createNavigationHandler() {
+  return {
+    id: "keyboard-navigation",
+    priority: ROUTER_PRIORITIES.KEYBOARD_NAVIGATION,
+    when: (ctx) => {
+      return !ctx.isEditing && ctx.focusedCell !== null;
+    },
+    handle: (ctx) => {
+      const { event, focusFns } = ctx;
+      if (!NAVIGATION_KEYS.includes(event.key)) {
+        return { handled: false };
+      }
+      focusFns.onCellKeyDown(event);
+      return {
+        handled: event.defaultPrevented || event.cancelBubble,
+        preventDefault: event.defaultPrevented,
+        stopPropagation: event.cancelBubble
+      };
+    }
+  };
+}

package/dist/runtime/composables/_internal/keyboard-handlers/useKeyboardSetup.d.ts

@@ -0,0 +1,33 @@
+import type { TableData } from '@nuxt/ui';
+import type { Row, Table } from '@tanstack/vue-table';
+import type { ComputedRef, Ref } from 'vue';
+import type { NuGridCellEditing, NuGridFocus, NuGridInteractionRouter } from '../../../types/_internal/index.js';
+export interface KeyboardSetupOptions<T extends TableData> {
+    interactionRouter: NuGridInteractionRouter<T>;
+    focusFns: NuGridFocus<T>;
+    cellEditingFns: NuGridCellEditing<T>;
+    tableApi: Table<T>;
+    resolvedRows: ComputedRef<Row<T>[]>;
+    rootRef: Ref<{
+        $el: HTMLElement | undefined;
+    } | undefined>;
+    focusModeRef: ComputedRef<'none' | 'cell' | 'row'>;
+    retainFocusRef: ComputedRef<boolean>;
+    editingEnabledRef: ComputedRef<boolean>;
+    startKeysRef: ComputedRef<any>;
+    cellTypes?: ComputedRef<any[] | undefined>;
+    data: Ref<T[]>;
+    emitCellValueChanged: (payload: {
+        row: any;
+        column: any;
+        oldValue: any;
+        newValue: any;
+    }) => void;
+}
+/**
+ * Sets up keyboard handling for NuGrid
+ * - Configures the interaction router with keyboard context builder
+ * - Registers built-in keyboard handlers
+ * - Manages lifecycle cleanup
+ */
+export declare function useKeyboardSetup<T extends TableData>(options: KeyboardSetupOptions<T>): void;

package/dist/runtime/composables/_internal/keyboard-handlers/useKeyboardSetup.js

@@ -0,0 +1,111 @@
+import { onMounted, onUnmounted, watch } from "vue";
+import {
+  createCellTypeDispatchHandler,
+  createEditingTriggersHandler,
+  createNavigationHandler
+} from "./index.js";
+const INTERACTIVE_SELECTORS = ["input", "textarea", "select", '[contenteditable="true"]', "button"];
+const NAVIGATION_KEYS = /* @__PURE__ */ new Set([
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "Tab",
+  " "
+  // Space key for row selection toggle
+]);
+export function useKeyboardSetup(options) {
+  const {
+    interactionRouter,
+    focusFns,
+    cellEditingFns,
+    tableApi,
+    resolvedRows,
+    rootRef,
+    focusModeRef,
+    retainFocusRef,
+    editingEnabledRef,
+    startKeysRef,
+    cellTypes,
+    data,
+    emitCellValueChanged
+  } = options;
+  function isInteractiveElement(target) {
+    if (!target || !(target instanceof HTMLElement)) return false;
+    return INTERACTIVE_SELECTORS.some((s) => target.matches(s) || target.closest(s));
+  }
+  function isEventTargetInGrid(target) {
+    if (!target || !(target instanceof HTMLElement)) return false;
+    const rootEl = rootRef.value?.$el;
+    return rootEl?.contains(target) ?? false;
+  }
+  function buildKeyboardContext(event) {
+    if (focusModeRef.value === "none") return null;
+    const isEditing = !!cellEditingFns.editingCell.value;
+    const focusedCell = focusFns.focusedCell.value;
+    if (!isEditing && !focusedCell) return null;
+    if (!isEditing) {
+      const isInteractive = isInteractiveElement(event.target);
+      const isNavigationKey = NAVIGATION_KEYS.has(event.key);
+      if (retainFocusRef.value && !isEventTargetInGrid(event.target)) {
+        const target = event.target;
+        const isTextInput = target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable);
+        if (isTextInput && isNavigationKey) return null;
+        if (isInteractive && !isNavigationKey) return null;
+      } else if (isInteractive && !isNavigationKey) {
+        return null;
+      }
+    }
+    const rowsList = resolvedRows.value;
+    const focusedRow = focusedCell ? rowsList[focusedCell.rowIndex] ?? null : null;
+    const cellIndex = focusedCell?.columnIndex ?? 0;
+    const cell = focusedRow?.getVisibleCells()[cellIndex] ?? null;
+    return {
+      event,
+      focusedCell,
+      focusedRow,
+      cell,
+      cellIndex,
+      isEditing,
+      focusMode: focusModeRef.value,
+      editingEnabled: editingEnabledRef.value,
+      tableApi,
+      focusFns,
+      cellEditingFns
+    };
+  }
+  interactionRouter.setKeyboardConfig({
+    retainFocus: retainFocusRef.value,
+    buildContext: buildKeyboardContext
+  });
+  watch(retainFocusRef, (newRetainFocus) => {
+    interactionRouter.setKeyboardConfig({
+      retainFocus: newRetainFocus,
+      buildContext: buildKeyboardContext
+    });
+  });
+  const keyboardUnregisterFns = [];
+  onMounted(() => {
+    const cellTypeHandler = createCellTypeDispatchHandler({
+      cellTypes,
+      data,
+      emit: emitCellValueChanged
+    });
+    keyboardUnregisterFns.push(interactionRouter.registerKeyboardHandler(cellTypeHandler));
+    const editingHandler = createEditingTriggersHandler({
+      getStartKeys: () => startKeysRef.value
+    });
+    keyboardUnregisterFns.push(interactionRouter.registerKeyboardHandler(editingHandler));
+    const navHandler = createNavigationHandler();
+    keyboardUnregisterFns.push(interactionRouter.registerKeyboardHandler(navHandler));
+  });
+  onUnmounted(() => {
+    keyboardUnregisterFns.forEach((unregister) => unregister());
+    keyboardUnregisterFns.length = 0;
+    interactionRouter.setKeyboardConfig(null);
+  });
+}

package/dist/runtime/composables/_internal/keyboard-handlers/usePagingKeyboard.d.ts

@@ -0,0 +1,11 @@
+import type { TableData } from '@nuxt/ui';
+import type { NuGridKeyboardHandler, NuGridPagingContext } from '../../../types/_internal/index.js';
+/**
+ * Creates a keyboard handler for paging navigation
+ * Priority 25 - runs before regular navigation handler
+ *
+ * When paging is enabled:
+ * - PageUp/PageDown: Navigate to previous/next page
+ * - Cmd/Ctrl + Up/Down: Navigate to previous/next page
+ */
+export declare function createPagingKeyboardHandler<T extends TableData>(pagingContext: NuGridPagingContext): NuGridKeyboardHandler<T>;

package/dist/runtime/composables/_internal/keyboard-handlers/usePagingKeyboard.js

@@ -0,0 +1,67 @@
+import { nextTick } from "vue";
+import { ROUTER_PRIORITIES } from "../../../types/_internal/index.js";
+export function createPagingKeyboardHandler(pagingContext) {
+  return {
+    id: "keyboard-paging",
+    priority: ROUTER_PRIORITIES.KEYBOARD_PAGING,
+    when: (ctx) => {
+      if (!pagingContext.enabled.value) return false;
+      if (ctx.isEditing) return false;
+      const { event } = ctx;
+      const key = event.key;
+      if (key === "PageUp" || key === "PageDown") {
+        return true;
+      }
+      if ((event.metaKey || event.ctrlKey) && (key === "ArrowUp" || key === "ArrowDown")) {
+        return true;
+      }
+      return false;
+    },
+    handle: (ctx) => {
+      const { event, focusFns, focusedCell } = ctx;
+      const key = event.key;
+      let direction = null;
+      if (key === "PageUp" || (event.metaKey || event.ctrlKey) && key === "ArrowUp") {
+        direction = "prev";
+      } else if (key === "PageDown" || (event.metaKey || event.ctrlKey) && key === "ArrowDown") {
+        direction = "next";
+      }
+      if (!direction) {
+        return { handled: false };
+      }
+      const currentPage = pagingContext.pageIndex.value;
+      const totalPages = pagingContext.totalPages.value;
+      const currentRowIndex = focusedCell?.rowIndex ?? 0;
+      const currentColumnIndex = focusedCell?.columnIndex ?? 0;
+      const restoreFocus = () => {
+        nextTick(() => {
+          focusFns.focusedCell.value = {
+            rowIndex: currentRowIndex,
+            columnIndex: currentColumnIndex
+          };
+          nextTick(() => {
+            const rows = ctx.tableApi.getRowModel().rows;
+            const targetRow = rows[currentRowIndex];
+            if (targetRow) {
+              const cellElement = focusFns.getCellElement(targetRow.id, currentColumnIndex);
+              if (cellElement) {
+                cellElement.focus();
+              }
+            }
+          });
+        });
+      };
+      if (direction === "prev" && currentPage > 0) {
+        pagingContext.setPageIndex(currentPage - 1);
+        restoreFocus();
+        return { handled: true, preventDefault: true, stopPropagation: true };
+      }
+      if (direction === "next" && currentPage < totalPages - 1) {
+        pagingContext.setPageIndex(currentPage + 1);
+        restoreFocus();
+        return { handled: true, preventDefault: true, stopPropagation: true };
+      }
+      return { handled: true, preventDefault: true };
+    }
+  };
+}

package/dist/runtime/composables/_internal/useNuGridActionMenu.d.ts

@@ -0,0 +1,15 @@
+import type { TableData } from '@nuxt/ui';
+import type { VisibilityState } from '@tanstack/vue-table';
+import type { Ref } from 'vue';
+import type { NuGridActionMenuOptions } from '../../types/index.js';
+import type { UseNuGridActionMenuReturn } from '../../types/_internal/index.js';
+/**
+ * Composable for managing action menu column in NuGrid.
+ * Handles creating the action menu column for row actions.
+ *
+ * IMPORTANT: The action menu column is created at instantiation and cannot be added later.
+ * If actionMenu is initially false/undefined and later changed to enabled,
+ * an error will be thrown. To start with a hidden action menu column, use:
+ * { getActions: fn, hidden: true }
+ */
+export declare function useNuGridActionMenu<T extends TableData>(actionMenuOptions: Ref<NuGridActionMenuOptions<T> | undefined | false>, columnVisibilityState?: Ref<VisibilityState>): UseNuGridActionMenuReturn<T>;