comins-table 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Comins Table
 
+## Unreleased
+
+## 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`.
+- Added Tree Grid `defaultExpandAll` and array-based `CominsTableRef.expand(nodeIds?)` / `fold(nodeIds?)` controls.
+- Added dedicated Summary Row and expanded Tree Grid Playground examples, including component and renderer cells plus exactly 10000 virtualized nodes.
+
 ## 0.1.1
 
 - Prepared a privacy-safe metadata release candidate pending npm account email verification.

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 AG Grid, MUI X, TanStack Table, or another table/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 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,17 @@ 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.
 
-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.
+Selection, column layout, and sort are internal view state. `onChangeSelection`, `onChangeColumnLayout`, and `onChangeSort` 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.
 
-The root export includes `CominsTable`, public types, and core helpers. Narrower helper sets are also available from stable subpaths.
+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. `getColumnLayout` and `getSortState` read the current layout and sort state.
+
+## Package Entry Points
 
 | Import | Purpose |
 | --- | --- |
@@ -103,66 +113,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, including leaf-only totals in Tree Grid.
-- Controlled Tree Grid data with `{ item, expand, children }`, existing item-based columns, 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 by column. Tree Grid aggregates leaf items only. |
-| `tree` | Opts into controlled `{ item, expand, children }` data. 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
 
@@ -177,15 +178,13 @@ tableRef.current?.clearSort();
 tableRef.current?.setSelectedRow(0);
 tableRef.current?.setSelectedRows([0, 1]);
 tableRef.current?.setMoveTargetRow(3, 1);
+tableRef.current?.expand(["department-1", "team-1-1"]);
+tableRef.current?.fold(["team-1-1"]);
+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.
-
-## Documentation
-
-English user documentation starts at `docs/user/01-quick-start.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`, 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
 
@@ -193,7 +192,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, Tree Grid, built-in components, selection, clipboard, context menu, and export helpers.
+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
 
@@ -203,17 +214,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

@@ -401,11 +401,6 @@ export declare function addCominsRows<TData>(state: CominsTableState<TData>, row
 export declare function updateCominsRows<TData>(state: CominsTableState<TData>, updates: ReadonlyArray<CominsRowUpdate<TData>>): CominsTableState<TData>;
 export declare function deleteCominsRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]): CominsTableState<TData>;
 export declare function setCominsTableTheme<TData>(state: CominsTableState<TData>, theme: CominsTableTheme): {
-    theme: {
-        className?: string;
-        density?: CominsTableDensity;
-        style?: React.CSSProperties;
-    };
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -418,9 +413,13 @@ export declare function setCominsTableTheme<TData>(state: CominsTableState<TData
     selection: CominsSelectionState;
     showHeader: boolean;
     sort: CominsSortState | null;
+    theme: {
+        className?: string;
+        density?: CominsTableDensity;
+        style?: React.CSSProperties;
+    };
 };
 export declare function setCominsHeaderVisible<TData>(state: CominsTableState<TData>, showHeader: boolean): {
-    showHeader: boolean;
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -433,12 +432,9 @@ export declare function setCominsHeaderVisible<TData>(state: CominsTableState<TD
     selection: CominsSelectionState;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
+    showHeader: boolean;
 };
 export declare function setCominsPagination<TData>(state: CominsTableState<TData>, pagination: Partial<CominsPaginationState>): {
-    pagination: {
-        pageIndex: number;
-        pageSize: number;
-    };
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -451,9 +447,12 @@ export declare function setCominsPagination<TData>(state: CominsTableState<TData
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
+    pagination: {
+        pageIndex: number;
+        pageSize: number;
+    };
 };
 export declare function setCominsSortState<TData>(state: CominsTableState<TData>, sort: CominsSortState | null): {
-    sort: CominsSortState | null;
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -466,9 +465,9 @@ export declare function setCominsSortState<TData>(state: CominsTableState<TData>
     selection: CominsSelectionState;
     showHeader: boolean;
     theme: CominsTableTheme;
+    sort: CominsSortState | null;
 };
 export declare function clearCominsSortState<TData>(state: CominsTableState<TData>): {
-    sort: CominsSortState | null;
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -481,14 +480,9 @@ export declare function clearCominsSortState<TData>(state: CominsTableState<TDat
     selection: CominsSelectionState;
     showHeader: boolean;
     theme: CominsTableTheme;
+    sort: CominsSortState | null;
 };
 export declare function setCominsColumnWidth<TData>(state: CominsTableState<TData>, columnId: string, width: number): {
-    columnState: {
-        [x: string]: CominsColumnRuntimeState | {
-            width: number;
-            hidden?: boolean;
-        };
-    };
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -501,14 +495,14 @@ export declare function setCominsColumnWidth<TData>(state: CominsTableState<TDat
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
-};
-export declare function setCominsColumnHidden<TData>(state: CominsTableState<TData>, columnId: string, hidden: boolean): {
     columnState: {
         [x: string]: CominsColumnRuntimeState | {
-            hidden: boolean;
-            width?: number;
+            hidden?: boolean;
+            width: number;
         };
     };
+};
+export declare function setCominsColumnHidden<TData>(state: CominsTableState<TData>, columnId: string, hidden: boolean): {
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -521,6 +515,12 @@ export declare function setCominsColumnHidden<TData>(state: CominsTableState<TDa
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
+    columnState: {
+        [x: string]: CominsColumnRuntimeState | {
+            width?: number;
+            hidden: boolean;
+        };
+    };
 };
 export declare function setCominsColumnGroupHidden<TData>(state: CominsTableState<TData>, groupId: string, hidden: boolean): CominsTableState<TData>;
 export declare function setCominsColumnGroupWidth<TData>(state: CominsTableState<TData>, groupId: string, width: number): CominsTableState<TData>;
@@ -528,9 +528,6 @@ export declare function moveCominsColumn<TData>(state: CominsTableState<TData>,
 export declare function moveCominsColumnGroup<TData>(state: CominsTableState<TData>, groupId: string, targetIndex: number): CominsTableState<TData>;
 export declare function serializeCominsColumnLayout<TData>(state: CominsTableState<TData>): CominsColumnLayout;
 export declare function applyCominsColumnLayout<TData>(state: CominsTableState<TData>, layout: CominsColumnLayout): {
-    columnOrder: string[];
-    columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
-    columnState: Record<string, CominsColumnRuntimeState>;
     columnGroups: CominsTableRuntimeColumnGroup[];
     columns: CominsTableRuntimeColumn<TData, unknown>[];
     getRowId: (row: TData, index: number) => CominsRowId;
@@ -541,13 +538,11 @@ export declare function applyCominsColumnLayout<TData>(state: CominsTableState<T
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
+    columnOrder: string[];
+    columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
+    columnState: Record<string, CominsColumnRuntimeState>;
 };
 export declare function selectRow<TData>(state: CominsTableState<TData>, rowId: CominsRowId, options?: CominsRowSelectionOptions): {
-    selection: {
-        rowIds: CominsRowId[];
-        cell: CominsCellAddress | null;
-        range: CominsCellRange | null;
-    };
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -560,13 +555,13 @@ export declare function selectRow<TData>(state: CominsTableState<TData>, rowId:
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
-};
-export declare function selectRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]): {
     selection: {
-        rowIds: CominsRowId[];
         cell: CominsCellAddress | null;
         range: CominsCellRange | null;
+        rowIds: CominsRowId[];
     };
+};
+export declare function selectRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]): {
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -579,13 +574,13 @@ export declare function selectRows<TData>(state: CominsTableState<TData>, rowIds
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
-};
-export declare function selectCell<TData>(state: CominsTableState<TData>, cell: CominsCellAddress): {
     selection: {
-        cell: CominsCellAddress;
-        range: null;
+        cell: CominsCellAddress | null;
+        range: CominsCellRange | null;
         rowIds: CominsRowId[];
     };
+};
+export declare function selectCell<TData>(state: CominsTableState<TData>, cell: CominsCellAddress): {
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -598,13 +593,13 @@ export declare function selectCell<TData>(state: CominsTableState<TData>, cell:
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
-};
-export declare function selectCellRange<TData>(state: CominsTableState<TData>, range: CominsCellRange): {
     selection: {
-        cell: CominsCellAddress;
-        range: CominsCellRange;
         rowIds: CominsRowId[];
+        cell: CominsCellAddress;
+        range: null;
     };
+};
+export declare function selectCellRange<TData>(state: CominsTableState<TData>, range: CominsCellRange): {
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -617,13 +612,13 @@ export declare function selectCellRange<TData>(state: CominsTableState<TData>, r
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
-};
-export declare function clearCominsCellRange<TData>(state: CominsTableState<TData>): {
     selection: {
-        range: null;
-        cell: CominsCellAddress | null;
         rowIds: CominsRowId[];
+        cell: CominsCellAddress;
+        range: CominsCellRange;
     };
+};
+export declare function clearCominsCellRange<TData>(state: CominsTableState<TData>): {
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -636,9 +631,13 @@ export declare function clearCominsCellRange<TData>(state: CominsTableState<TDat
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
+    selection: {
+        cell: CominsCellAddress | null;
+        rowIds: CominsRowId[];
+        range: null;
+    };
 };
 export declare function clearCominsSelection<TData>(state: CominsTableState<TData>): {
-    selection: CominsSelectionState;
     columnOrder: string[];
     columnGroups: CominsTableRuntimeColumnGroup[];
     columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
@@ -651,6 +650,7 @@ export declare function clearCominsSelection<TData>(state: CominsTableState<TDat
     showHeader: boolean;
     sort: CominsSortState | null;
     theme: CominsTableTheme;
+    selection: CominsSelectionState;
 };
 export declare function isCominsRowSelected<TData>(state: CominsTableState<TData>, rowId: CominsRowId): boolean;
 export declare function isCominsCellSelected<TData>(state: CominsTableState<TData>, cell: CominsCellAddress): boolean;