comins-table 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 0.1.4 - 2026-07-23
+
+- Added opt-in priority-based multi-column sorting for flat and Tree Grid data, including Shift-assisted Header input, sort-model callbacks and Ref methods, accessibility metadata, documentation, and a runnable Playground example.
+
+## 0.1.3 - 2026-07-22
+
+- Added 6-pixel mouse Header reorder activation with source placeholder, ghost, target marker, vertical-intent cancellation, and preserved non-mouse long-press compatibility.
+- Connected Virtual List Item and More activation to owning Row selection, preserved More keyboard focus, and suppressed invalid column-layout callback emissions.
+- Added a consumer-first README and real-product animated preview covering sorting, column reorder, Virtual List selection, Summary Row, and Tree Grid interaction.
+- Expanded focused browser and documentation regression coverage for the shipped interaction and README contracts.
+
 ## 0.1.2 - 2026-07-22
 
 - Extended Summary Row with descriptor-based `colSpan`, aggregate output `format`, and row or cell `className` and `style`.

package/README.md

@@ -1,14 +1,38 @@
 # Comins Table
 
-Comins Table is a controlled React data table for data-heavy application screens. It provides a reusable table component, framework-independent core helpers, virtualized rendering, selection, clipboard helpers, pagination, sorting, two-level headers, summary rows, controlled Tree Grid rendering, lazy loading, infinite scrolling, loading states, and CSS-variable based theming.
+Comins Table is a controlled React data table for data-heavy application screens, with virtualized rendering, precise selection, movable headers, Summary Row aggregation, Tree Grid data, built-in component cells, and framework-independent core helpers.
 
-Comins Table is built as a standalone open-source package. It does not wrap another table or grid implementation.
+[![npm version](https://img.shields.io/npm/v/comins-table)](https://www.npmjs.com/package/comins-table)
+[![TypeScript declarations](https://img.shields.io/npm/types/comins-table)](https://www.npmjs.com/package/comins-table)
+[![Verify](https://github.com/kim1124/comins-table/actions/workflows/verify.yml/badge.svg?branch=main)](https://github.com/kim1124/comins-table/actions/workflows/verify.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-## Repository Scope
+![Comins Table sorting, column reorder, Row selection, Summary Row, and Tree Grid demo](https://raw.githubusercontent.com/kim1124/comins-table/main/docs/assets/comins-table-demo.gif)
 
-Comins Table is maintained as an independent repository. This repository is the source of truth for the library, Playground, public documentation, tests, and releases.
+## Why Comins Table
 
-Run development and verification commands from this repository root. Comins Table is not managed as a workspace package, so commands do not require an `npm --workspace` prefix. Future feature work and releases belong in this repository.
+| Area | Shipped capabilities |
+| --- | --- |
+| Controlled data | Application-owned `data`, CRUD helpers, `onChangeData`, pagination, sorting, and layout callbacks |
+| Rendering and scale | Fixed-height virtualization with a tested 100,000-row route, infinite scroll, append-mode lazy loading, loading, and empty states |
+| Interaction | Accessible single and opt-in multi-column Header sorting, resize, 6-pixel horizontal column reorder with source placeholder, Row and Cell selection, ranges, clipboard, and context menu callbacks |
+| Data structure | Summary Row count/sum/avg/min/max/custom aggregation, `colSpan`, `format`, style/class hooks, and controlled Tree Grid expand/fold |
+| Custom UI | Cell/Header renderers, built-in button/input/checkbox/radio/select/toggle/progress/menu/Virtual List components, and CSS-variable themes |
+
+Comins Table is standalone and does not wrap another table or grid implementation.
+
+## Support
+
+| Surface | Support |
+| --- | --- |
+| React | `>=18.0.0 <20.0.0` |
+| React DOM | `>=18.0.0 <20.0.0` |
+| TypeScript | Declarations bundled with every JavaScript entry point; CSS available through the stylesheet export |
+| Chrome and Edge | Current stable Chromium-based releases |
+| Automated browser gate | Playwright-bundled Chromium |
+| Firefox and Safari | Outside the supported contract until Firefox and WebKit projects are added |
+| SSR | Client boundary required; server rendering is not currently supported |
+| Runtime network behavior | No package-owned requests, remote assets, telemetry, or error reporting |
 
 ## Installation
 
@@ -21,27 +45,7 @@ import { CominsTable, type CominsTableColumn } from "comins-table";
 import "comins-table/styles.css";
 ```
 
-React and React DOM are peer dependencies:
-
-| Package | Version |
-| --- | --- |
-| `react` | `>=18.0.0 <20.0.0` |
-| `react-dom` | `>=18.0.0 <20.0.0` |
-
-## Runtime Boundary
-
-Comins Table is browser UI. Its package source does not make network requests, load remote assets, collect telemetry, or send error reports. Server rendering is not yet a supported integration contract; use an application client boundary where SSR is present.
-
-## Supported Platforms
-
-| Surface | Support |
-| --- | --- |
-| React | `>=18.0.0 <20.0.0` |
-| React DOM | `>=18.0.0 <20.0.0` |
-| Chrome and Edge | Current stable Chromium-based releases |
-| Automated browser gate | Playwright-bundled Chromium |
-| Firefox and Safari | Not in the supported contract until Firefox and WebKit projects are added |
-| SSR | Client boundary required; server rendering is not currently supported |
+React and React DOM are peer dependencies. Import `comins-table/styles.css` when the default table shell, themes, and built-in component skin are required.
 
 ## Quick Start
 
@@ -73,7 +77,7 @@ const columns: Array<CominsTableColumn<UserRow>> = [
 
 export function UsersTable() {
   const [data, setData] = useState<UserRow[]>([
-    { active: true, age: 31, id: "u-1", name: "Kim", role: "Admin" },
+    { active: true, age: 31, id: "u-1", name: "Example user", role: "Admin" },
   ]);
 
   return (
@@ -89,11 +93,32 @@ export function UsersTable() {
 }
 ```
 
-## Core Model
+## Controlled Model
+
+Comins Table is a CSR-focused controlled component for application-owned data. The application owns the `data` array.
+
+Only `onChangeData` requires application write-back. It emits the next flat Row array or Tree Grid node array after table-owned mutations; pass that array back through `data` to retain the change.
+
+Selection, column layout, and sort are internal view state. `onChangeSelection`, `onChangeColumnLayout`, `onChangeSort`, and `onChangeSortModel` observe those changes so an application can coordinate or persist them externally; the table updates the corresponding view state even when a callback is omitted.
+
+Where restoration is supported, use the supported Ref API: `setSelectedRow` and `setSelectedRows` restore Row selection by visible index, `setColumnLayout` restores layout, and `setSortState` and `clearSort` restore or clear sorting. `setSortModel` restores the complete ordered model; `getColumnLayout`, `getSortState`, and `getSortModel` read the current layout and sort state.
 
-Comins Table is a CSR-focused controlled component. The application owns the `data` array. Table operations such as row movement, paste, and selection emit callbacks like `onChangeData`, `onChangeSelection`, `onChangeColumnLayout`, and `onChangeSort`; the application then writes the next state back into the component.
+### Multi-column Sort
 
-The root export includes `CominsTable`, public types, and core helpers. Narrower helper sets are also available from stable subpaths.
+Set `multiSort` to opt into ordered multi-column sorting. Normal Header click or `Enter`/`Space` keeps single sorting; hold `Shift` while using the same input to add, update, or remove one rule without replacing the others. Active Headers display their 1-based priority.
+
+```tsx
+<CominsTable
+  columns={columns}
+  data={data}
+  multiSort
+  onChangeSortModel={(model) => saveSortModel(model)}
+/>
+```
+
+`getSortModel()` and `setSortModel(model)` read and restore the full model. The existing `getSortState()`, `setSortState(rule)`, and `onChangeSort` APIs remain the single-rule compatibility surface. Two-level child Columns and Tree Grid sibling sets use the same ordered comparison rules.
+
+## Package Entry Points
 
 | Import | Purpose |
 | --- | --- |
@@ -103,66 +128,57 @@ The root export includes `CominsTable`, public types, and core helpers. Narrower
 | `comins-table/selection` | Selection helper subset |
 | `comins-table/styles.css` | Optional table shell, theme, and built-in component skin |
 
-```ts
-import {
-  addCominsRows,
-  applyCominsColumnLayout,
-  copyCominsCellRange,
-  createCominsTableState,
-  deleteCominsRows,
-  exportCominsRowsToCsv,
-  exportCominsRowsToJson,
-  fillCominsCellRange,
-  pasteCominsCellRange,
-  queryCominsRows,
-  selectCell,
-  selectCellRange,
-  selectRow,
-  serializeCominsColumnLayout,
-  setCominsPagination,
-  setCominsSortState,
-  updateCominsRows,
-} from "comins-table/core";
-```
+## Header And Layout
 
-## Features
-
-- Controlled `data` and `onChangeData` flow for application-owned state.
-- Column definitions with `field`, `id`, `label`, `sort`, width constraints, row/cell `props`, header configuration, and cell configuration.
-- Header visibility, keyboard sorting, `aria-sort`, resize, long-press column reorder, and layout persistence.
-- Two-level headers through `columnGroups`.
-- Row click, double click, keyboard callbacks, context menu callbacks, row selection, row drag reorder, row copy, and row paste.
-- Cell formatting, custom renderer, cell events, single-cell selection, range selection, and drag range selection.
-- Clipboard helpers with `props.copyable`, `props.pasteable`, and disabled guard support.
-- Pagination, loading and empty states, virtualized rendering, infinite scroll, and append-mode lazy loading.
-- Configurable Summary Row aggregation with `count`, `sum`, `avg`, `min`, `max`, custom aggregators, visible-column `colSpan`, output `format`, and row/cell styling.
-- Controlled Tree Grid data with `{ item, expand, children }`, initial `defaultExpandAll`, array-based ref expansion, existing component/renderer cells, recursive sibling sorting, and accessible expanders.
-- CSS-variable based themes, including `comins-table-theme--basic`, `--dark`, `--skyblue`, `--mint`, `--gray`, and `--orange`.
-- Built-in header and cell controls: `button`, `input`, `checkbox`, `radio`, `select`, `toggle`, `progress`, header `menu`, and cell `virtual-list`.
-- CSV and JSON export helpers.
-
-## Props And Events
-
-| Prop | Purpose |
-| --- | --- |
-| `data` | Controlled row array. Replace it with a new array when the source data changes. |
-| `columns` | Leaf column definitions. `field` supports nested paths. |
-| `columnGroups` | Optional two-level parent header definitions. |
-| `getRowId` | Stable row id resolver used by selection, movement, and callbacks. |
-| `onChangeData` | Receives data changes from paste and row movement. |
-| `onChangeSelection` | Receives row, cell, and range selection changes. |
-| `onChangeColumnLayout` | Receives column width, order, and visibility changes. |
-| `onChangeSort` | Receives sort state changes. |
-| `onClickCell` / `onClickRow` | Receives click payloads for cell and row interactions. |
-| `pagination` | Controls `pageIndex` and `pageSize`. |
-| `loading`, `emptyComponent`, `skeletonRowCount` | Control skeleton rows, refetch overlay, and empty state content. |
-| `virtualized`, `"buffer-size"`, `rowHeight` | Enable and tune virtualized row rendering. |
-| `infiniteScroll`, `infiniteScrollThreshold`, `hasMoreRows`, `loadingMore`, `onLoadMore` | Control append loading when the body viewport nears the bottom. |
-| `lazyLoad`, `lazyLoadBatchSize`, `lazyLoadMode`, `lazyLoadThreshold`, `onLazyLoad` | Control async append-mode data loading with `AbortSignal`. |
-| `summary` | Configures fixed footer aggregates, `colSpan`, `format`, `className`, and `style` by column. Tree Grid aggregates leaf items only. |
-| `tree`, `defaultExpandAll` | Opt into controlled `{ item, expand, children }` data and set the initial fallback expansion state. `defaultExpandAll` defaults to `true`; explicit node state wins. Tree Grid does not support pagination, lazy loading, infinite scrolling, row drag, or row-level copy/paste in V1. |
-| `theme` | Supplies optional `className`, inline `style`, and density settings. |
-| `rowProps` | Supplies row class, style, disabled, and `rowProps.draggable` behavior. |
+Sortable headers support pointer and keyboard activation and expose `aria-sort`. Columns support width constraints and resize interactions.
+
+A left-button mouse interaction activates column movement after a 6-pixel horizontal drag, provided horizontal movement remains greater than vertical movement. The source becomes a source placeholder while a ghost and target marker show the proposed move. Pointer Up commits only over a valid target; vertical intent, pointer cancellation, `Escape`, and window blur cancel the pending move. Non-mouse pointers retain one-second long-press compatibility. Parent header groups move their children as one block.
+
+Use `getColumnLayout()` and `setColumnLayout()` through the Ref API, or `serializeCominsColumnLayout()` and `applyCominsColumnLayout()` from `comins-table/core`, to persist and restore order, widths, and visibility.
+
+## Rows, Cells, And Selection
+
+Rows expose click, double-click, keyboard, and context-menu callbacks. Cells expose the corresponding Cell callbacks plus `format`, `renderer`, and props hooks.
+
+A normal Row interaction selects one Row, `Ctrl`/`Cmd` toggles a Row, and `Shift` extends the visible Row range from the selection anchor. Cell selection supports a single Cell, `Ctrl`/`Cmd` multi-selection, and `Shift` or pointer-drag ranges. Built-in component interactions remain isolated from `onClickCell` and `onClickRow` callback payloads so component actions do not also trigger the owning Cell or Row action.
+
+## Virtualization And Loading
+
+Set `virtualized`, `rowHeight`, and `"buffer-size"` for fixed-height windowed rendering. The performance Playground includes a tested 100,000-row route while keeping only the current window and buffer mounted.
+
+`infiniteScroll` requests application-owned append loading near the body viewport boundary. `lazyLoad` supports asynchronous append-mode batches with an `AbortSignal`. When `loading` is true, an empty table renders skeleton Rows and a populated table keeps its Rows visible under a loading overlay. `emptyComponent` controls the no-data content.
+
+## Summary Row
+
+See the [Summary Row guide](https://github.com/kim1124/comins-table/blob/main/docs/user/18-summary-row.md) and run the [`/examples/summary-row`](http://127.0.0.1:4002/examples/summary-row) Playground route.
+
+Configure `summary.columns` with built-in `count`, `sum`, `avg`, `min`, and `max` aggregation or a custom aggregator. The object form supports visible-column `colSpan`, post-aggregation `format`, and per-cell `className` and `style`; `summary.className` and `summary.style` apply to the footer Row.
+
+## Tree Grid
+
+See the [Tree Grid guide](https://github.com/kim1124/comins-table/blob/main/docs/user/17-tree-grid.md) and run the [`/examples/tree-grid`](http://127.0.0.1:4002/examples/tree-grid) Playground route.
+
+Set `tree` and provide controlled `{ item, expand, children }` nodes. `defaultExpandAll` supplies the initial fallback expansion state and defaults to `true`; explicit node state wins. `expand(nodeIds?)` and `fold(nodeIds?)` update multiple node ids, while an omitted argument targets every branch and an empty array is a no-op. Descendant-only expansion is blocked while an ancestor remains folded unless both ids are included in the same call.
+
+Tree Grid reuses `cell.components` and `cell.renderer`, so component cells and custom React renderers work against each node's `item`. The Tree Grid Playground includes an exactly 10,000-node virtual example.
+
+## Components And Renderers
+
+Cell components include `button`, `input`, `checkbox`, `radio`, `select`, `toggle`, `progress`, and `virtual-list`; Header components also support `menu`. Use `cell.renderer` or `header.renderer` when the built-in component types are not sufficient.
+
+Virtual List Item activation follows the normal Row selection modifiers. More selects its owning Row exclusively before expanding the virtualized list. Search is available only while exactly one Row is selected. Keyboard activation keeps the More button focused after expansion. Item and More actions remain isolated from the Row and Cell click callbacks.
+
+## Clipboard And Export
+
+`copyCominsRow`, `copyCominsCell`, and `copyCominsCellRange` read Row or Cell selections. `pasteCominsRow`, `pasteCominsCell`, and `pasteCominsCellRange` apply clipboard data while respecting `props.copyable`, `props.pasteable`, and disabled guards. `fillCominsCellRange` remains a framework-independent core helper; no visual fill handle is presented as shipped UI.
+
+Use `exportCominsRowsToCsv` and `exportCominsRowsToJson` with the exact rows and export columns the application wants to serialize. Export remains independent of visible pagination, filtering, and selection unless the application passes those rows.
+
+## Styling And Themes
+
+The package stylesheet exposes module-local `--comins-table-*` CSS variables and does not apply a global reset. The six shipped theme classes are `comins-table-theme--basic`, `comins-table-theme--dark`, `comins-table-theme--skyblue`, `comins-table-theme--mint`, `comins-table-theme--gray`, and `comins-table-theme--orange`.
+
+Use `theme.className`, `theme.style`, Row class/style hooks, Cell props, and renderer output for application-specific presentation. Keep virtualized `rowHeight` aligned with `--comins-table-row-height` when overriding height tokens.
 
 ## Ref API
 
@@ -173,6 +189,11 @@ tableRef.current?.getColumnLayout();
 tableRef.current?.setColumnLayout(savedLayout);
 tableRef.current?.getSortState();
 tableRef.current?.setSortState({ columnId: "age", direction: "desc" });
+tableRef.current?.getSortModel();
+tableRef.current?.setSortModel([
+  { columnId: "team", direction: "asc" },
+  { columnId: "age", direction: "desc" },
+]);
 tableRef.current?.clearSort();
 tableRef.current?.setSelectedRow(0);
 tableRef.current?.setSelectedRows([0, 1]);
@@ -183,14 +204,7 @@ tableRef.current?.expand(); // all Tree Grid branches
 tableRef.current?.fold(); // all Tree Grid branches
 ```
 
-`setSelectedRow`, `setSelectedRows`, and `setMoveTargetRow` use the visible row index after current sorting and pagination are applied.
-`expand(nodeIds?)` and `fold(nodeIds?)` accept readonly Tree Grid node-id arrays. Omitting the array targets every branch; an empty array is a no-op. A folded ancestor blocks descendant-only expansion unless both ids are included in the same call. Flat tables ignore these methods.
-
-## Documentation
-
-English user documentation starts at `docs/user/01-quick-start.md`. Detailed Tree Grid and Summary Row contracts are in `docs/user/17-tree-grid.md` and `docs/user/18-summary-row.md`.
-
-The previous Korean documentation is preserved under `docs/ko/` as secondary documentation while the public package moves to English-first docs.
+`setSelectedRow`, `setSelectedRows`, and `setMoveTargetRow` use the visible Row index after current sorting and pagination. `getColumnLayout`, `setColumnLayout`, `getSortState`, `setSortState`, `getSortModel`, `setSortModel`, and `clearSort` read and update the current Header view state. `expand(nodeIds?)` and `fold(nodeIds?)` accept readonly Tree Grid node-id arrays; flat tables ignore them.
 
 ## Playground
 
@@ -198,7 +212,19 @@ The previous Korean documentation is preserved under `docs/ko/` as secondary doc
 npm run dev
 ```
 
-The playground starts at `/docs/getting-started` and includes examples for CRUD, sizing, theme, loading and empty states, headers, column groups, pagination, infinite scroll, lazy load, virtualization, cells, rows, Summary Row, Tree Grid, built-in components, selection, clipboard, context menu, and export helpers. The Tree Grid route includes a 30-node baseline and an exactly 10000-node virtualized example.
+The local Playground starts at [`/docs/getting-started`](http://127.0.0.1:4002/docs/getting-started). Key routes include [`/examples/summary-row`](http://127.0.0.1:4002/examples/summary-row), [`/examples/tree-grid`](http://127.0.0.1:4002/examples/tree-grid), [`/examples/component`](http://127.0.0.1:4002/examples/component), and [`/performance/virtualization`](http://127.0.0.1:4002/performance/virtualization).
+
+## Documentation
+
+Start with the [English Quick Start](https://github.com/kim1124/comins-table/blob/main/docs/user/01-quick-start.md), then browse [all English feature guides](https://github.com/kim1124/comins-table/tree/main/docs/user). The detailed [Tree Grid](https://github.com/kim1124/comins-table/blob/main/docs/user/17-tree-grid.md) and [Summary Row](https://github.com/kim1124/comins-table/blob/main/docs/user/18-summary-row.md) contracts include runnable examples and edge cases. [Korean guides](https://github.com/kim1124/comins-table/tree/main/docs/ko) are retained as secondary documentation.
+
+Use the [source repository](https://github.com/kim1124/comins-table) for development context, review the [changelog](https://github.com/kim1124/comins-table/blob/main/CHANGELOG.md) for version history, and follow the [security policy](https://github.com/kim1124/comins-table/blob/main/SECURITY.md) for vulnerability reporting.
+
+## Current Boundaries
+
+Comins Table currently ships a CSR controlled data model. Server-side Row models, Row grouping, pivoting, charts, AI assistance, remote Tree loading, hierarchy pagination, Tree Row drag, Tree Row copy/paste, Firefox, Safari, and SSR are not shipped or supported. Flat Row Expand details and master/detail layouts also remain outside the current package contract.
+
+The visual fill handle is not shipped or supported. `fillCominsCellRange` remains available as a core helper without a drag-handle UI.
 
 ## Development
 
@@ -208,17 +234,13 @@ npm run test:run
 npm run build
 npm run test:e2e
 npm run test:perf -- --workers=1
-npm pack --dry-run --json
+npm run test:consumer
+npm run verify
+npm run docs:readme-gif
 ```
 
-## Release Bootstrap
-
-`comins-table` does not yet exist on the npm registry. npm cannot register trusted or staged publishing for a brand-new package, so the first public version must be published interactively by the maintainer with npm 2FA and without an automation token.
-
-After that bootstrap publication, register `kim1124/comins-table`, `publish.yml`, and the `npm` environment as the trusted publisher. Allow only `npm stage publish`, disallow token publishing, and require maintainer 2FA approval for every staged version. The repository workflow is intentionally manual and refuses non-`main` refs, mismatched versions, and missing bootstrap packages.
-
-## Current Scope
+`npm run docs:readme-gif` is a maintainer command that captures the real hidden Playground fixture and regenerates the checked-in README animation.
 
-Comins Table currently ships CSR table rendering, controlled data updates, row/cell selection, clipboard helpers, pagination, sorting, layout helpers, two-level headers, built-in controls, virtualized rendering, Summary Row aggregation, controlled Tree Grid rendering, loading and empty states, CSV/JSON export helpers, controlled infinite scrolling, and append-mode lazy loading.
+## Trusted Publishing
 
-It does not currently ship server-side row models, row grouping, pivoting, flat Row Expand detail areas, master/detail, charts integration, an AI assistant, or a drag-handle UI for Excel-like visual fill. Tree Grid V1 deliberately excludes remote tree loading, hierarchy pagination, row drag, and row-level copy/paste. The `fillCominsCellRange` core helper exists, but the drag UX remains outside the first public release.
+The package bootstrap is complete. Trusted publishing for later versions uses the manual `publish.yml` OIDC trusted publisher and `npm stage publish` through the protected `npm` environment. The workflow builds one exact package artifact, verifies and scans that artifact before staging, and requires maintainer approval before public publication. Token-based publication is not part of this release path.

package/dist/column-pointer.d.ts

@@ -0,0 +1,9 @@
+export declare const COMINS_COLUMN_MOUSE_DRAG_THRESHOLD = 6;
+export type CominsColumnMouseIntent = "activate" | "cancel" | "pending";
+export declare function getCominsColumnMouseIntent({ clientX, clientY, startX, startY, }: {
+    clientX: number;
+    clientY: number;
+    startX: number;
+    startY: number;
+}): CominsColumnMouseIntent;
+//# sourceMappingURL=column-pointer.d.ts.map

package/dist/column-pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-pointer.d.ts","sourceRoot":"","sources":["../src/column-pointer.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kCAAkC,IAAI,CAAC;AAEpD,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExE,wBAAgB,0BAA0B,CAAC,EACzC,OAAO,EACP,OAAO,EACP,MAAM,EACN,MAAM,GACP,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,uBAAuB,CAa1B"}

package/dist/component-renderer.d.ts

@@ -1,5 +1,11 @@
 import type React from "react";
 import type { CominsCellComponentConfig, CominsCellComponentPayload, CominsHeaderComponentConfig, CominsHeaderComponentPayload } from "./core";
-export declare function renderCominsBuiltInComponent<TData, TValue>(component: CominsCellComponentConfig<TData, TValue>, payload: CominsCellComponentPayload<TData, TValue>): React.ReactNode;
-export declare function renderCominsBuiltInComponent<TData, TValue>(component: CominsHeaderComponentConfig<TData, TValue>, payload: CominsHeaderComponentPayload<TData, TValue>): React.ReactNode;
+export type CominsBuiltInComponentInteraction = {
+    requestRowSelection?: (request: {
+        event: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement>;
+        mode: "exclusive" | "row-click";
+    }) => boolean;
+};
+export declare function renderCominsBuiltInComponent<TData, TValue>(component: CominsCellComponentConfig<TData, TValue>, payload: CominsCellComponentPayload<TData, TValue>, interaction?: CominsBuiltInComponentInteraction): React.ReactNode;
+export declare function renderCominsBuiltInComponent<TData, TValue>(component: CominsHeaderComponentConfig<TData, TValue>, payload: CominsHeaderComponentPayload<TData, TValue>, interaction?: CominsBuiltInComponentInteraction): React.ReactNode;
 //# sourceMappingURL=component-renderer.d.ts.map

package/dist/component-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-renderer.d.ts","sourceRoot":"","sources":["../src/component-renderer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAG1B,2BAA2B,EAC3B,4BAA4B,EAE7B,MAAM,QAAQ,CAAC;AAivBhB,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EACxD,SAAS,EAAE,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,EACnD,OAAO,EAAE,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,GACjD,KAAK,CAAC,SAAS,CAAC;AACnB,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EACxD,SAAS,EAAE,2BAA2B,CAAC,KAAK,EAAE,MAAM,CAAC,EACrD,OAAO,EAAE,4BAA4B,CAAC,KAAK,EAAE,MAAM,CAAC,GACnD,KAAK,CAAC,SAAS,CAAC"}
+{"version":3,"file":"component-renderer.d.ts","sourceRoot":"","sources":["../src/component-renderer.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAG1B,2BAA2B,EAC3B,4BAA4B,EAE7B,MAAM,QAAQ,CAAC;AA4vBhB,MAAM,MAAM,iCAAiC,GAAG;IAC9C,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC9B,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,iBAAiB,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;QACpF,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;KACjC,KAAK,OAAO,CAAC;CACf,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EACxD,SAAS,EAAE,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,EACnD,OAAO,EAAE,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,EAClD,WAAW,CAAC,EAAE,iCAAiC,GAC9C,KAAK,CAAC,SAAS,CAAC;AACnB,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,EACxD,SAAS,EAAE,2BAA2B,CAAC,KAAK,EAAE,MAAM,CAAC,EACrD,OAAO,EAAE,4BAA4B,CAAC,KAAK,EAAE,MAAM,CAAC,EACpD,WAAW,CAAC,EAAE,iCAAiC,GAC9C,KAAK,CAAC,SAAS,CAAC"}

package/dist/core.d.ts

@@ -11,6 +11,7 @@ export type CominsSortState = {
     columnId: string;
     direction: CominsSortDirection;
 };
+export type CominsSortModel = readonly CominsSortState[];
 export type CominsCellFormatParams<TData, TValue = unknown> = {
     column: CominsTableRuntimeColumn<TData, TValue>;
     row: TData;
@@ -79,8 +80,10 @@ export type CominsHeaderComponentPayload<TData, TValue = unknown> = {
         width?: number;
     };
     sort: {
+        count: number;
         direction: CominsSortDirection | null;
         enabled: boolean;
+        priority: number | null;
     };
 };
 export type CominsClipboardGuard<TData, TValue = unknown> = boolean | ((params: CominsCellComponentPayload<TData, TValue>) => boolean);
@@ -285,6 +288,7 @@ export type CominsTableState<TData> = {
     selection: CominsSelectionState;
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
 };
 export type CominsTableStateInput<TData> = {
@@ -296,6 +300,7 @@ export type CominsTableStateInput<TData> = {
     rows: readonly TData[];
     showHeader?: boolean;
     sort?: CominsSortState | null;
+    sortModel?: CominsSortModel;
     theme?: CominsTableTheme;
 };
 export type CominsRowUpdate<TData> = {
@@ -394,7 +399,7 @@ export type CominsFillCellRangeOptions = {
     source: CominsCellAddress;
     target: CominsCellRange;
 };
-export declare function createCominsTableState<TData>({ columnLayout, columnGroups, columns, getRowId, pagination, rows, showHeader, sort, theme, }: CominsTableStateInput<TData>): CominsTableState<TData>;
+export declare function createCominsTableState<TData>({ columnLayout, columnGroups, columns, getRowId, pagination, rows, showHeader, sort, sortModel, theme, }: CominsTableStateInput<TData>): CominsTableState<TData>;
 export declare function queryCominsRows<TData>(state: CominsTableState<TData>, predicate?: (row: TData, index: number) => boolean): TData[];
 export declare function replaceCominsRows<TData>(state: CominsTableState<TData>, rows: readonly TData[]): CominsTableState<TData>;
 export declare function addCominsRows<TData>(state: CominsTableState<TData>, rows: readonly TData[]): CominsTableState<TData>;
@@ -413,6 +418,7 @@ export declare function setCominsTableTheme<TData>(state: CominsTableState<TData
     selection: CominsSelectionState;
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: {
         className?: string;
         density?: CominsTableDensity;
@@ -431,6 +437,7 @@ export declare function setCominsHeaderVisible<TData>(state: CominsTableState<TD
     rows: TData[];
     selection: CominsSelectionState;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     showHeader: boolean;
 };
@@ -446,42 +453,16 @@ export declare function setCominsPagination<TData>(state: CominsTableState<TData
     selection: CominsSelectionState;
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     pagination: {
         pageIndex: number;
         pageSize: number;
     };
 };
-export declare function setCominsSortState<TData>(state: CominsTableState<TData>, sort: CominsSortState | null): {
-    columnOrder: string[];
-    columnGroups: CominsTableRuntimeColumnGroup[];
-    columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
-    columns: CominsTableRuntimeColumn<TData, unknown>[];
-    columnState: Record<string, CominsColumnRuntimeState>;
-    getRowId: (row: TData, index: number) => CominsRowId;
-    pagination: CominsPaginationState;
-    rowIds: CominsRowId[];
-    rows: TData[];
-    selection: CominsSelectionState;
-    showHeader: boolean;
-    theme: CominsTableTheme;
-    sort: CominsSortState | null;
-};
-export declare function clearCominsSortState<TData>(state: CominsTableState<TData>): {
-    columnOrder: string[];
-    columnGroups: CominsTableRuntimeColumnGroup[];
-    columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
-    columns: CominsTableRuntimeColumn<TData, unknown>[];
-    columnState: Record<string, CominsColumnRuntimeState>;
-    getRowId: (row: TData, index: number) => CominsRowId;
-    pagination: CominsPaginationState;
-    rowIds: CominsRowId[];
-    rows: TData[];
-    selection: CominsSelectionState;
-    showHeader: boolean;
-    theme: CominsTableTheme;
-    sort: CominsSortState | null;
-};
+export declare function setCominsSortState<TData>(state: CominsTableState<TData>, sort: CominsSortState | null): CominsTableState<TData>;
+export declare function setCominsSortModel<TData>(state: CominsTableState<TData>, sortModel: CominsSortModel): CominsTableState<TData>;
+export declare function clearCominsSortState<TData>(state: CominsTableState<TData>): CominsTableState<TData>;
 export declare function setCominsColumnWidth<TData>(state: CominsTableState<TData>, columnId: string, width: number): {
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
@@ -494,6 +475,7 @@ export declare function setCominsColumnWidth<TData>(state: CominsTableState<TDat
     selection: CominsSelectionState;
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     columnState: {
         [x: string]: CominsColumnRuntimeState | {
@@ -514,6 +496,7 @@ export declare function setCominsColumnHidden<TData>(state: CominsTableState<TDa
     selection: CominsSelectionState;
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     columnState: {
         [x: string]: CominsColumnRuntimeState | {
@@ -537,6 +520,7 @@ export declare function applyCominsColumnLayout<TData>(state: CominsTableState<T
     selection: CominsSelectionState;
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     columnOrder: string[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -554,6 +538,7 @@ export declare function selectRow<TData>(state: CominsTableState<TData>, rowId:
     rows: TData[];
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     selection: {
         cell: CominsCellAddress | null;
@@ -573,6 +558,7 @@ export declare function selectRows<TData>(state: CominsTableState<TData>, rowIds
     rows: TData[];
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     selection: {
         cell: CominsCellAddress | null;
@@ -592,6 +578,7 @@ export declare function selectCell<TData>(state: CominsTableState<TData>, cell:
     rows: TData[];
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     selection: {
         rowIds: CominsRowId[];
@@ -611,6 +598,7 @@ export declare function selectCellRange<TData>(state: CominsTableState<TData>, r
     rows: TData[];
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     selection: {
         rowIds: CominsRowId[];
@@ -630,6 +618,7 @@ export declare function clearCominsCellRange<TData>(state: CominsTableState<TDat
     rows: TData[];
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     selection: {
         cell: CominsCellAddress | null;
@@ -649,6 +638,7 @@ export declare function clearCominsSelection<TData>(state: CominsTableState<TDat
     rows: TData[];
     showHeader: boolean;
     sort: CominsSortState | null;
+    sortModel: CominsSortModel;
     theme: CominsTableTheme;
     selection: CominsSelectionState;
 };