@inandu-solutions/grid-vue 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Inandu SAS (https://inandu.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,196 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# inandu-grid-vue
+
+**A lightweight Vue 3 data grid with the essentials other grids gate behind a paid enterprise
+licence — row grouping, aggregates, inline editing and Excel-compatible export — fully MIT.** The
+Vue port of [`@inandu-solutions/grid-angular`](https://github.com/inandusolutions/inandu-grid),
+kept in sync feature-for-feature by hand (and with its React sibling,
+[`@inandu-solutions/grid-react`](https://github.com/inandusolutions/inandu-grid-react)).
+
+[![npm](https://img.shields.io/npm/v/@inandu-solutions/grid-vue.svg)](https://www.npmjs.com/package/@inandu-solutions/grid-vue)
+[![CI](https://github.com/inandusolutions/inandu-grid-vue/actions/workflows/ci.yml/badge.svg)](https://github.com/inandusolutions/inandu-grid-vue/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/@inandu-solutions/grid-vue.svg)](LICENSE)
+![Vue](https://img.shields.io/badge/Vue-3.4%2B-42b883)
+[![live demo](https://img.shields.io/badge/demo-live-1a8fae)](https://inandusolutions.github.io/inandu-grid-vue/)
+[![Open in StackBlitz](https://img.shields.io/badge/StackBlitz-open%20example-1389FD?logo=stackblitz&logoColor=white)](https://stackblitz.com/github/inandusolutions/inandu-grid-vue/tree/main/examples/stackblitz)
+
+## Try it in 30 seconds
+
+```bash
+npm install @inandu-solutions/grid-vue
+```
+
+```vue
+<script setup lang="ts">
+import { InanduGrid, type InanduGridColumn } from '@inandu-solutions/grid-vue';
+import '@inandu-solutions/grid-vue/style.css';
+
+const rows = [{ name: 'Ada', age: 36 }, { name: 'Alan', age: 41 }];
+const columns: InanduGridColumn[] = [{ field: 'name', headerText: 'Name' }, { field: 'age', headerText: 'Age', type: 'number' }];
+</script>
+
+<template>
+  <!-- sorting + filtering are on by default -->
+  <InanduGrid :rows="rows" :columns="columns" :page-size="25" />
+</template>
+```
+
+- **▶️ [Live demo](https://inandusolutions.github.io/inandu-grid-vue/)** — try every feature in the browser.
+- **⚡ [Edit in StackBlitz](https://stackblitz.com/github/inandusolutions/inandu-grid-vue/tree/main/examples/stackblitz)** —
+  installs `@inandu-solutions/grid-vue` from npm; edit `src/App.vue` and it updates live ([source](examples/stackblitz)).
+- **📦 [`@inandu-solutions/grid-vue` on npm](https://www.npmjs.com/package/@inandu-solutions/grid-vue)**
+  (MIT) — `0.x` while the API settles; expect breaking changes between minors until `1.0.0`.
+
+## Who is this for?
+
+- **CRUD / business apps** that need sortable, filterable, editable tables without pulling in a
+  full enterprise grid framework.
+- **Admin dashboards** that need grouping, aggregates and CSV/Excel/PDF export out of the box.
+- **Data-heavy Vue apps** that need virtual scroll, or server-side sort / filter / paging against a
+  backend (see [Server-side data](#server-side-data)), without the bundle size of a kitchen-sink grid.
+
+**When not to use it:** if you need pivot tables or integrated charting built into the grid itself,
+this isn't that — see [Not included](#not-included) below.
+
+## Angular and React versions
+
+[`inandu-grid`](https://github.com/inandusolutions/inandu-grid) is the original, feature-complete,
+MIT-licensed Angular grid this repo is ported from, and
+[`inandu-grid-react`](https://github.com/inandusolutions/inandu-grid-react) is its React port — same
+feature set, same core logic, adapted for Vue's composition API (`computed`/`shallowRef`, SFCs,
+scoped slots, emitted events) instead of Angular signals or React hooks.
+
+## Not included
+
+Deliberately *not* a kitchen sink: no pivoting and no integrated charts — those stay out of scope
+so the core stays small and auditable. Everything else on this page (grouping, aggregates, editing,
+export, virtual scroll, paged server-side mode) is included, free, no enterprise tier.
+
+## Commercial add-ons
+
+`@inandu-solutions/grid-pro-vue` *(private, paid, not released yet)* — the Vue port of
+`@inandu-solutions/grid-pro`, depends on this package the same way grid-pro depends on grid-angular.
+
+## Features
+
+**Feature-complete with grid-angular and grid-react.** The framework-agnostic core (sorting,
+filtering, aggregation, export, i18n) is ported from grid-angular's
+[`core/`](https://github.com/inandusolutions/inandu-grid/tree/main/projects/inandu-grid/src/lib/core)
+folder and kept in sync by hand across the three repos. The Vue-specific layer — the
+[`<InanduGrid>`](#api-shape) component and the [`useInanduGrid()`](#api-shape) headless
+composable — covers:
+
+- Sorting — single-column, or multi-column via shift-click
+- Free-text search and per-column filtering, plus an `extra-row-filter` escape hatch for your own predicates
+- Pagination, single-column grouping with aggregates, row selection
+- CSV / Excel (`.xls`) / PDF export, and print
+- i18n — 5 built-in languages via a `lang` prop
+- Inline row editing, creation and deletion, with validation (required / min / max / pattern / custom / async)
+- Excel-style Ctrl+C / Ctrl+V clipboard copy/paste
+- Runtime column show/hide, sticky (pinned left/right) columns, drag-reorder
+- Column resize (drag a header's handle) and autosize (double-click it to fit content)
+- Row drag-reorder
+- Tree data (`tree-children-key`) — display and expand only, no inline editing/drag/clipboard on
+  tree rows, same restriction as grid-angular
+- Master-detail — a `#detail="{ row }"` slot (or a `renderDetail` render-function prop)
+- Custom cell / header / edit-control rendering per column — `#cell-<field>`, `#header-<field>` and
+  `#editor-<field>` scoped slots, or `renderCell` / `renderHeader` / `renderEditor` render functions
+  on the column definition — without losing sorting, resizing, or validation
+- Excel-style cell range selection (`cell-range-selection`, `multi-range`) — click-and-drag or
+  shift-click across cells to select a rectangular block; `Ctrl+C` copies the whole range as TSV
+  when `clipboard` is also on
+- Row virtualization (`virtual-scroll`) for large datasets
+- Server-side sort / search / filter / paging (`server-side` + `useInanduGridServer`) — paged only;
+  grid-angular's server-side infinite scroll isn't ported. See [Server-side data](#server-side-data)
+
+Two things work slightly differently from grid-angular because they need a real browser layout
+engine that a unit-test environment can't provide: virtual scroll's row height isn't
+auto-measured — pass `virtual-row-height` explicitly — and autosize's content measurement itself is
+trusted (ported verbatim, same DOM APIs) rather than end-to-end tested; see
+[`measureColumn.ts`](src/utils/measureColumn.ts)'s doc comment for exactly what its test suite does
+and doesn't cover.
+
+## API shape
+
+```vue
+<script setup lang="ts">
+import { useTemplateRef } from 'vue';
+import { InanduGrid, useInanduGrid, type InanduGridRowSave } from '@inandu-solutions/grid-vue';
+import '@inandu-solutions/grid-vue/style.css'; // optional default styling — skip it and bring your own
+
+// Component: batteries-included table. The grid never mutates `rows` — events hand you the change.
+function onRowSave({ row, values }: InanduGridRowSave) {
+  rows.value = rows.value.map(r => (r === row ? { ...r, ...values } : r));
+}
+
+// Its headless engine is exposed on a template ref, for programmatic control.
+const gridRef = useTemplateRef('grid');
+const sortByName = () => gridRef.value?.grid.toggleSort('name');
+
+// Composable: headless — bring your own markup. Pass a getter to follow reactive data; every
+// piece of state is a reactive getter (`headless.visibleRows`, no `.value`).
+const headless = useInanduGrid(() => ({ rows: rows.value, columns, pageSize: 25 }));
+</script>
+
+<template>
+  <InanduGrid ref="grid" :rows="rows" :columns="columns" selectable @row-save="onRowSave" @selection-change="selected = $event">
+    <template #cell-status="{ value }"><StatusBadge :status="value" /></template>
+    <template #detail="{ row }"><OrderLines :order="row" /></template>
+  </InanduGrid>
+</template>
+```
+
+Events: `selection-change`, `row-save`, `row-create`, `row-delete`, `rows-delete`, `cells-paste`,
+`row-order-change`, `cell-range-change`, `cell-ranges-change`.
+
+## Server-side data
+
+For tables too big to load whole, let the backend sort, filter and page, and keep the grid's UI
+unchanged:
+
+```vue
+<script setup lang="ts">
+import { InanduGrid, useInanduGridServer } from '@inandu-solutions/grid-vue';
+
+const server = useInanduGridServer({ url: '/api/products' });
+</script>
+
+<template>
+  <InanduGrid
+    :rows="server.rows.value"
+    :columns="columns"
+    :page-size="25"
+    :server-side="{ totalItems: server.total.value }"
+    @query-change="server.setQuery"
+  />
+</template>
+```
+
+`useInanduGridServer` turns the grid's page / sort / search / column filters into a query string
+(`?page=2&pageSize=25&sort=-price&q=cable&price_gte=20`), aborts superseded requests, debounces typing,
+and keeps the previous page on screen while the next loads. It expects `{ data: [...], total: n }`.
+That is exactly what [`Inandu.Grid.Extensions`](https://github.com/inandusolutions/inandu-grid-extensions)
+(.NET / EF Core) returns from one `ToInanduGrid()` call — [request contract](https://github.com/inandusolutions/inandu-grid-extensions/blob/main/docs/request-contract.md) —
+but any backend that speaks the same params works. Runnable example: [`examples/server-side`](examples/server-side).
+
+In `serverSide` mode grouping, tree data, virtual scroll, `extraRowFilter` and column aggregate
+totals are off (they would only ever see one page), and a column's Excel-style value checklist lists
+the values on the current page. Use `buildInanduGridQuery(query)` if you'd rather do the fetching
+yourself, and `fetcher` / `init` on the composable for auth headers or a custom client.
+
+## Development
+
+```bash
+npm install
+npm test           # Vitest + Vue Testing Library
+npm run typecheck  # vue-tsc --noEmit
+npm run build      # library build (dist/)
+```
+
+## Contributing
+
+Issues and PRs welcome. Please read [`CONTRIBUTING.md`](CONTRIBUTING.md) first, and note the
+[Code of Conduct](.github/CODE_OF_CONDUCT.md). Security reports: [`.github/SECURITY.md`](.github/SECURITY.md).
+
+## License
+
+MIT © [Inandu SAS](https://www.inandu.com/)

package/dist/components/DataRow.vue.d.ts

@@ -0,0 +1,34 @@
+import { InanduGridRow } from '../core';
+import { RowContext } from './internal';
+/** One data row — its own read-only cells, or (while it's the row being edited) `editableColumns` as controls bound to the shared draft, plus a trailing Edit/Save/Cancel/Delete actions cell when `hasRowActions`. */
+type __VLS_Props = {
+    ctx: RowContext;
+    row: InanduGridRow;
+    rowIndex: number;
+    /** Adds a leading drag-handle `<td>` and wires the whole row for drag-and-drop reordering — only in the flat, non-grouped render path, same restriction grid-angular's `rowReorder` has. */
+    hasRowDragHandle?: boolean;
+    isDragOverRow?: boolean;
+    /** Adds a leading expand/collapse toggle `<td>` and (while expanded) a full-width detail row right below — only in the flat, non-grouped render path, same restriction grid-angular's `hasMasterDetail` has. */
+    hasMasterDetail?: boolean;
+    isRowExpanded?: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    rowDragStart: () => any;
+    rowDragOver: () => any;
+    rowDragLeave: () => any;
+    rowDrop: () => any;
+    toggleExpanded: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRowDragStart?: (() => any) | undefined;
+    onRowDragOver?: (() => any) | undefined;
+    onRowDragLeave?: (() => any) | undefined;
+    onRowDrop?: (() => any) | undefined;
+    onToggleExpanded?: (() => any) | undefined;
+}>, {
+    hasRowDragHandle: boolean;
+    isDragOverRow: boolean;
+    hasMasterDetail: boolean;
+    isRowExpanded: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/EditCell.vue.d.ts

@@ -0,0 +1,16 @@
+import { InanduGridColumn } from '../composables/useInanduGrid';
+import { Translator } from './internal';
+/** One editable cell's control, bound to the shared row draft in the same *raw control* shape `parseDraftValue()` expects (a string for text/number/date, a boolean for the checkbox) — plus its inline validation message, if any. */
+type __VLS_Props = {
+    column: InanduGridColumn;
+    value: unknown;
+    error: string | undefined;
+    t: Translator;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((value: unknown) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/FilterControl.vue.d.ts

@@ -0,0 +1,16 @@
+import { InanduGridColumnFilterValue } from '../core';
+import { InanduGridColumn } from '../composables/useInanduGrid';
+import { Translator } from './internal';
+/** One filter control per column type, all working off the same `InanduGridColumnFilterValue` shape the core understands. */
+type __VLS_Props = {
+    column: InanduGridColumn;
+    value: InanduGridColumnFilterValue | undefined;
+    t: Translator;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (patch: Partial<InanduGridColumnFilterValue>) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((patch: Partial<InanduGridColumnFilterValue>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/InanduGrid.vue.d.ts

@@ -0,0 +1,231 @@
+import { VNodeChild } from 'vue';
+import { InanduGridColumnFilterValue, InanduGridRow } from '../core';
+import { InanduCellRenderContext, InanduEditRenderContext, InanduGridCellPaste, InanduGridColumn, InanduGridRowSave, InanduGridServerQuery, InanduHeaderRenderContext } from '../composables/useInanduGrid';
+import { InanduGridCellRangeSelection } from './types';
+type __VLS_Props = {
+    rows: InanduGridRow[];
+    columns: InanduGridColumn[];
+    /** Drives number/date formatting (`Intl`-based). Default: 'en'. */
+    locale?: string;
+    /** Drives built-in UI string translation (one of `INANDU_GRID_TRANSLATIONS`'s keys). Default: `locale`'s primary subtag. */
+    lang?: string;
+    /** 0 (default) disables pagination — every filtered/sorted row renders. Ignored while grouped. */
+    pageSize?: number;
+    /** Adds a checkbox column with row + select-all selection. Default: false. */
+    selectable?: boolean;
+    /** Adds a CSV/Excel/PDF export toolbar above the table. Default: false. */
+    exportable?: boolean;
+    /** Base filename (without extension) for exports. Default: 'inandu-grid'. */
+    exportFilenameBase?: string;
+    /** Adds a per-row "Delete" button. Default: false. */
+    deletable?: boolean;
+    /** `window.confirm()`-gates a single row's delete. Unset: deletes immediately. */
+    deleteConfirmMessage?: string;
+    /** `window.confirm()`-gates the "Delete selected" bulk action (shown when `selectable && deletable` with at least one row selected). Unset: deletes immediately. */
+    bulkDeleteConfirmMessage?: string;
+    /** Adds an "Add row" trigger with a blank draft row. Default: false. Has no effect unless at least one column is `editable`. */
+    creatable?: boolean;
+    /** Opts into `Ctrl+C`/`Ctrl+V` cell copy/paste (Excel-style TSV). Default: false. */
+    clipboard?: boolean;
+    /**
+     * Opt-in Excel-style range selection — click-and-drag (or shift-click, without dragging) across
+     * cells in the flat, non-grouped, non-tree, non-virtualized render path (same restriction
+     * `rowReorder`/`clipboard` already document) selects a rectangular block of cells, highlighted via
+     * `.inandu-cell-range-selected`. Off by default. When `clipboard` is *also* on, `Ctrl+C` copies
+     * the *entire* selected range as TSV instead of just the focused cell — otherwise this is purely a
+     * selection/highlight feature with no built-in side effect; the `cell-range-change`/
+     * `cell-ranges-change` events are how a consumer observes what's currently selected.
+     */
+    cellRangeSelection?: boolean;
+    /**
+     * Lets a Ctrl/Cmd-drag (or Ctrl/Cmd-click) *add* another rectangle to the selection instead of
+     * replacing it, the same convention spreadsheets use. A plain click still resets to one
+     * rectangle. Only meaningful with `cellRangeSelection` on. `cell-range-change` keeps reporting
+     * the *active* (last) rectangle; `cell-ranges-change` reports the whole list. `Ctrl+C` copies
+     * only the active rectangle. Default: false.
+     */
+    multiRange?: boolean;
+    /** Adds a "Columns" toolbar button + popup letting the user show/hide individual columns at runtime. Default: false. */
+    columnToggle?: boolean;
+    /** Adds a per-row drag handle to reorder rows. Default: false. Auto-disabled while grouped, same as grid-angular. */
+    rowReorder?: boolean;
+    /**
+     * Turns on tree mode: the field on each row holding its child rows (a nested array of the same
+     * shape). `rows` is then the root rows. Auto-disabled while grouped. Tree rows are display +
+     * expand only — inline editing, drag-reorder and clipboard don't apply to them, same as
+     * grid-angular.
+     */
+    treeChildrenKey?: string;
+    /** Initial expand state for tree mode. Default: `'none'`. */
+    treeDefaultExpanded?: 'none' | 'all' | number;
+    /**
+     * Enables master-detail as a render function: renders a leading expand/collapse toggle per row,
+     * and (while expanded) a full-width detail row right below it, with whatever this returns. The
+     * `#detail="{ row }"` slot does the same template-side (and wins when both are set). Auto-disabled
+     * while grouped, same as grid-angular's `detailTemplate`/`hasMasterDetail`. Unset (default): off.
+     */
+    renderDetail?: (row: InanduGridRow) => VNodeChild;
+    /** Collapses any other expanded row first, accordion-style, when a new one expands. Off (any number of rows can be expanded at once) by default. */
+    singleDetailExpand?: boolean;
+    /** An extra per-row predicate ANDed onto the free-text + column filters — same as grid-angular's `extraRowFilter`. Lets a caller layer its own filtering (e.g. an advanced-filter query) on top of the grid's own. Unset: no extra filtering. */
+    extraRowFilter?: (row: InanduGridRow) => boolean;
+    /** Server-side mode: `rows` is the current page as sorted/filtered/paged by the server and `totalItems` is the full match count. See `useInanduGridServer`. Needs `pageSize` > 0. */
+    serverSide?: {
+        totalItems: number;
+    };
+    /**
+     * Opt-in row virtualization for large datasets — only rows scrolled into view (plus a small
+     * overscan runway) are actually mounted. Bypasses pagination entirely, same as grouping.
+     * Auto-disabled while grouped (this port doesn't interleave group headers into the virtualized
+     * window the way grid-angular does); also disables master-detail, row drag-reorder, tree data,
+     * and the totals `<tfoot>`, same restrictions grid-angular's `virtualScroll` has. Default: false.
+     */
+    virtualScroll?: boolean;
+    /**
+     * Fixed row height (px) the virtualization math uses to compute scroll position and how many
+     * rows to render. Unlike grid-angular, this port doesn't auto-measure a rendered row's real
+     * height — pass the actual rendered row height for correct scrolling. Default: 40.
+     */
+    virtualRowHeight?: number;
+    /** The scrollable viewport's own height (px) — only used while `virtualScroll`. Default: 400. */
+    height?: number;
+    /** Extra rows rendered above/below the visible window, so a fast scroll doesn't flash empty space before the next render catches up. Default: 4. */
+    overscan?: number;
+    /**
+     * Double-click a column's resize handle to fit its width to its widest currently-rendered value
+     * (header included). Measures real rendered text width via the DOM (`measureColumnContentWidth`)
+     * — like grid-angular's own autosize, this only measures what's actually mounted (one page, or
+     * the virtual window), not the full dataset. Default: false.
+     */
+    autosize?: boolean;
+};
+type __VLS_Slots = {
+    /** Custom cell content for column `<field>`: `#cell-name="{ value, row, field }"`. */
+    [key: `cell-${string}`]: (ctx: InanduCellRenderContext) => VNodeChild;
+    /** Custom header label for column `<field>`: `#header-name="{ title, field }"`. */
+    [key: `header-${string}`]: (ctx: InanduHeaderRenderContext) => VNodeChild;
+    /** Custom editor for editable column `<field>`: `#editor-name="{ value, setValue, error, row, field }"`. */
+    [key: `editor-${string}`]: (ctx: InanduEditRenderContext) => VNodeChild;
+    /** Master-detail content for an expanded row — its presence turns master-detail on. */
+    detail?: (ctx: {
+        row: InanduGridRow;
+    }) => VNodeChild;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    grid: {
+        readonly visibleColumns: InanduGridColumn[];
+        readonly allColumns: InanduGridColumn[];
+        stickyOffset: (field: string) => number;
+        stickyOffsetRight: (field: string) => number;
+        columnPinnedSide: (field: string) => import('..').InanduColumnStickySide | undefined;
+        setColumnPinned: (field: string, side: import('..').InanduColumnStickySide | undefined) => void;
+        readonly hideableColumns: InanduGridColumn[];
+        isColumnHidden: (field: string) => boolean;
+        toggleColumnVisibility: (field: string) => void;
+        setColumnOrder: (fields: readonly string[]) => void;
+        readonly draggingField: string | undefined;
+        onColumnDragStart: (field: string) => void;
+        onColumnDrop: (targetField: string) => void;
+        effectiveWidth: (field: string) => number;
+        isColumnResized: (field: string) => boolean;
+        setColumnWidth: (field: string, width: number) => void;
+        readonly draggingRow: InanduGridRow | undefined;
+        onRowDragStart: (row: InanduGridRow) => void;
+        onRowDrop: (targetRow: InanduGridRow) => void;
+        readonly hasTreeData: boolean;
+        readonly treeRows: import('..').TreeVisibleRow<InanduGridRow>[];
+        isTreeRowExpanded: (row: InanduGridRow) => boolean;
+        toggleTreeRow: (row: InanduGridRow) => void;
+        setAllTreeRowsExpanded: (expanded: boolean) => void;
+        isRowExpanded: (row: InanduGridRow) => boolean;
+        toggleRowExpanded: (row: InanduGridRow) => void;
+        readonly hasVirtualScroll: boolean;
+        readonly visibleRows: InanduGridRow[];
+        readonly exportRows: InanduGridRow[];
+        readonly sortedRows: InanduGridRow[];
+        readonly filteredRowCount: number;
+        readonly locale: string;
+        readonly sortCriteria: import('..').InanduGridSort[];
+        setSort: (criteria: import('..').InanduGridSort[]) => void;
+        toggleSort: (field: string, additive?: boolean) => void;
+        sortDirectionFor: (field: string) => "asc" | "desc" | undefined;
+        sortPriorityFor: (field: string) => number | undefined;
+        readonly filterValues: Record<string, InanduGridColumnFilterValue>;
+        setFilterValue: (field: string, value: InanduGridColumnFilterValue) => void;
+        clearAllFilters: () => void;
+        readonly filterQuery: string;
+        setFilterQuery: (query: string) => void;
+        readonly page: number;
+        setPage: (next: number) => void;
+        readonly pageCount: number;
+        readonly groupByField: string | undefined;
+        setGroupByField: (field: string | undefined) => void;
+        readonly groups: import('..').InanduGridGroup[] | null;
+        readonly totals: Record<string, number>;
+        readonly selectedRows: Set<InanduGridRow>;
+        isRowSelected: (row: InanduGridRow) => boolean;
+        toggleRowSelection: (row: InanduGridRow) => void;
+        readonly allSelected: boolean;
+        readonly someSelected: boolean;
+        toggleSelectAll: () => void;
+        clearSelection: () => void;
+        readonly editableColumns: InanduGridColumn[];
+        readonly editingRow: InanduGridRow | undefined;
+        readonly isAddingRow: boolean;
+        readonly rowDraft: Record<string, unknown>;
+        readonly fieldErrors: Record<string, string>;
+        readonly isValidating: boolean;
+        isEditingRow: (row: InanduGridRow) => boolean;
+        isAnotherRowEditing: (row: InanduGridRow) => boolean;
+        startEditingRow: (row: InanduGridRow) => void;
+        cancelRowEdit: () => void;
+        setRowDraftValue: (field: string, value: unknown) => void;
+        saveRow: (row: InanduGridRow) => Promise<void>;
+        deleteRow: (row: InanduGridRow) => void;
+        deleteSelectedRows: () => void;
+        startAddingRow: () => void;
+        cancelAddRow: () => void;
+        saveNewRow: () => Promise<void>;
+        validateCell: (column: InanduGridColumn, value: unknown, row?: Record<string, unknown>) => string | null;
+        copyCellText: (rowIndex: number, field: string) => string;
+        pasteAt: (anchorRowIndex: number, anchorField: string, text: string) => void;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    queryChange: (query: InanduGridServerQuery) => any;
+    selectionChange: (selectedRows: InanduGridRow[]) => any;
+    rowSave: (event: InanduGridRowSave) => any;
+    rowCreate: (values: Record<string, unknown>) => any;
+    rowDelete: (row: InanduGridRow) => any;
+    rowsDelete: (rows: InanduGridRow[]) => any;
+    cellsPaste: (updates: InanduGridCellPaste[]) => any;
+    cellRangeChange: (selection: InanduGridCellRangeSelection | undefined) => any;
+    cellRangesChange: (selections: InanduGridCellRangeSelection[]) => any;
+    rowOrderChange: (rows: InanduGridRow[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onQueryChange?: ((query: InanduGridServerQuery) => any) | undefined;
+    onSelectionChange?: ((selectedRows: InanduGridRow[]) => any) | undefined;
+    onRowSave?: ((event: InanduGridRowSave) => any) | undefined;
+    onRowCreate?: ((values: Record<string, unknown>) => any) | undefined;
+    onRowDelete?: ((row: InanduGridRow) => any) | undefined;
+    onRowsDelete?: ((rows: InanduGridRow[]) => any) | undefined;
+    onCellsPaste?: ((updates: InanduGridCellPaste[]) => any) | undefined;
+    onCellRangeChange?: ((selection: InanduGridCellRangeSelection | undefined) => any) | undefined;
+    onCellRangesChange?: ((selections: InanduGridCellRangeSelection[]) => any) | undefined;
+    onRowOrderChange?: ((rows: InanduGridRow[]) => any) | undefined;
+}>, {
+    locale: string;
+    pageSize: number;
+    treeDefaultExpanded: number | "none" | "all";
+    exportFilenameBase: string;
+    virtualRowHeight: number;
+    height: number;
+    overscan: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/internal.d.ts

@@ -0,0 +1,60 @@
+import { CSSProperties, PropType, VNodeChild } from 'vue';
+import { InanduGridRow } from '../core';
+import { InanduGridColumn } from '../composables/useInanduGrid';
+import { InanduGridMessageKey } from '../utils/translate';
+export type Translator = (key: InanduGridMessageKey, params?: Record<string, string | number>) => string;
+/** Renders whatever VNode children it's handed — how a slot or a column's `renderCell`/`renderHeader`/`renderEditor` result is mounted from inside a template. */
+export declare const RenderNodes: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    nodes: {
+        type: PropType<VNodeChild>;
+        default: null;
+    };
+}>, () => never, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    nodes: {
+        type: PropType<VNodeChild>;
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    nodes: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+/**
+ * Everything a `<DataRow>` needs from the grid, bundled into one prop rather than ~30 — the Vue
+ * counterpart of the React port's spread `rowProps`. Built once per render by `<InanduGrid>`.
+ */
+export interface RowContext {
+    columns: InanduGridColumn[];
+    t: Translator;
+    selectable: boolean;
+    selectColumnStyle: CSSProperties | undefined;
+    columnStyle: (column: InanduGridColumn) => CSSProperties;
+    isRowSelected: (row: InanduGridRow) => boolean;
+    toggleRowSelection: (row: InanduGridRow) => void;
+    hasRowActions: boolean;
+    editableColumnCount: number;
+    isEditingRow: (row: InanduGridRow) => boolean;
+    isAnotherRowEditing: (row: InanduGridRow) => boolean;
+    startEditingRow: (row: InanduGridRow) => void;
+    cancelRowEdit: () => void;
+    saveRow: (row: InanduGridRow) => void;
+    deleteRow: (row: InanduGridRow) => void;
+    deletable: boolean;
+    rowDraft: Record<string, unknown>;
+    fieldErrors: Record<string, string>;
+    isValidating: boolean;
+    setRowDraftValue: (field: string, value: unknown) => void;
+    /** A cell's display content: the `#cell-<field>` slot, else the column's `renderCell`, else the formatted value. */
+    cellContent: (column: InanduGridColumn, row: InanduGridRow) => VNodeChild;
+    /** A custom editor (`#editor-<field>` slot or `renderEditor`), or `undefined` to fall back to the built-in `<EditCell>`. */
+    editorContent: (column: InanduGridColumn, row: InanduGridRow) => VNodeChild | undefined;
+    /** Master-detail content for an expanded row (`#detail` slot or `renderDetail`). */
+    detailContent: (row: InanduGridRow) => VNodeChild;
+    /** Adds the `tabindex` `onTableKeyDown` resolves a Ctrl+C/Ctrl+V onto — `data-row-index`/`data-field` are always present (flat, non-grouped render path only), same as grid-angular. */
+    clipboard: boolean;
+    /** Marks cells `.inandu-cell-range-selected` and wires the drag/shift-click gesture — only in the flat, non-grouped, non-tree, non-virtualized render path, same restriction grid-angular's `cellRangeSelection` has. */
+    cellRangeSelection: boolean;
+    isCellInRange: (rowIndex: number, colIndex: number) => boolean;
+    onCellRangeMouseDown: (event: MouseEvent, rowIndex: number, colIndex: number) => void;
+    onCellRangeMouseEnter: (rowIndex: number, colIndex: number) => void;
+    /** Column count a full-width row (`colspan`) must span: `columns.length` plus every leading/trailing extra column. */
+    extraColumnCount: number;
+}

package/dist/components/types.d.ts

@@ -0,0 +1,6 @@
+import { InanduGridRow } from '../core';
+/** The currently selected cell range — see `<InanduGrid cell-range-selection>` and its `cell-range-change` event. `rows`/`fields` are the full row objects and field names spanning the selected rectangle, in `visibleRows`/`visibleColumns` order. */
+export interface InanduGridCellRangeSelection {
+    rows: InanduGridRow[];
+    fields: string[];
+}