Package-level declarations

Reads a value from an original row.

Aggregation function for a grouped column. Receives the column id, the leaf rows of the group and the immediate child rows (or sub-aggregations when grouping deeper than one level), and returns the aggregated value.

Choice of aggregation function. Either "auto", the name of a built-in or registered fn (a String), or an AggregationFn value. Typed as Any? because Kotlin cannot model that mixed union.

Marker interface for a caller-registered set of aggregation functions.

Generic render signature accepting a component and its props. Provided for adapter layers that wire table-core into a UI framework.

Name of a built-in aggregation function. Modelled as String because Kotlin cannot express a closed union of string literals — the names accepted at runtime are the keys of aggregationFns.

Name of a built-in filter function. Modelled as String because Kotlin cannot express a closed union of string literals.

Name of a built-in sort function. Modelled as String because Kotlin cannot express a closed union of string literals — the names accepted at runtime are the keys of sortingFns.

A single cell in the table — the intersection of a Row and a Column. Combines the core cell members with the ColumnGrouping feature members (getIsAggregated/getIsGrouped/getIsPlaceholder).

Context object passed to cell renderers. Carries the cell, its column, row and owning table, plus value accessors. getValue returns the raw cell value, while renderValue returns the value or the configured renderFallbackValue when null.

A column in the table. Integer-typed depth, getIndex, getPinnedIndex, getSortIndex, getGroupedIndex and getFilterIndex use Int; sizing values (getSize, getStart, getAfter) use Double because resize math can produce fractional pixel values.

Definition of a column. Carries the identifier (id/header), the accessor (accessorKey or accessorFn), nested columns for group columns, plus the feature-specific configuration (enableSorting, filterFn, size, ...). All fields are nullable; which fields you set determines what kind of column you build.

A fully resolved column definition: structurally the same as ColumnDef with every field optional, plus the explicit accessorKey?: String carry. Aliased to ColumnDef since ColumnDef already exposes all fields as nullable.

Cell/header template. At runtime either a String or a (props) -> Any? renderer; consuming code (e.g. flexRender in the adapter layer) discriminates by runtime type.

The ColumnFaceting feature. Installs the per-column facet accessors on each Column when registered with the table.

One entry in ColumnFiltersState. id identifies the column; value is the raw filter value submitted by the caller (later normalised by the column's FilterFn.resolveFilterValue).

Returns true when a filter value should be auto-removed (typically because it has become empty).

The ColumnFiltering feature. Adds columnFilters state, the column- level filter accessors (getFilterFn, getIsFiltered, ...) and the table-level setColumnFilters / resetColumnFilters / getFilteredRowModel.

Ordered list of active per-column filter entries.

The ColumnGrouping feature. Adds grouping state, the column-level grouping accessors (toggleGrouping, getIsGrouped, ...) and the table-level setGrouping / resetGrouping / getGroupedRowModel.

Typed helper for building column defs. The accessor member accepts either an AccessorFn or an accessor-key String and produces the corresponding accessor column def; display and group are the identity for symmetry with the JS API.

Identifier shape on a column def — either IdIdentifier or StringHeaderIdentifier. Typed as Any? because Kotlin cannot express the union directly.

Marker interface for caller-supplied per-column metadata.

The ColumnOrdering feature. Adds columnOrder state, the table-level setter/reset, the per-column getIndex/getIsFirstColumn/ getIsLastColumn accessors, and the ordering function used to build leaf column lists.

Ordered list of column ids that drive table column order. Columns not mentioned here retain their natural order.

The ColumnPinning feature. Adds columnPinning state, the column- level pin/getIsPinned/getPinnedIndex accessors, and the row/table partitioning into left, center and right pinned sections.

Pinned position for a column. Either "left", "right", or the literal false (unpinned). Typed as Any? because Kotlin cannot express that mixed union directly.

Pinned-column ids partitioned by position. Both lists default to null (no columns pinned in that position).

Resize-direction hint: "ltr" or "rtl".

When the new column size is committed: "onChange" (live) or "onEnd" (on gesture end).

The ColumnSizing feature. Adds columnSizing / columnSizingInfo state, the column-level size/resize accessors, and the header-level resize handler.

Transient state captured during a column resize gesture. All fields are null when no resize is in progress; isResizingColumn holds the column id (or false) when one is.

Per-column rendered size in pixels, keyed by column id. Missing entries fall back to the column def's size.

One entry in SortingState. id identifies the column; desc is the direction (true for descending).

The ColumnVisibility feature. Adds columnVisibility state plus the column-, row- and table-level visibility members.

Caller-registered aggregation functions, keyed by name.

Caller-registered filter functions, keyed by name.

Caller-registered sort functions, keyed by name.

Defaults applied to columns that do not set their own sizing fields.

Expansion state. Either the literal true (every row expanded) or a Map of row-id to flag (most rows collapsed by default). Modelled as Any? because Kotlin cannot express that union directly; the feature code discriminates by runtime type.

Per-row expansion flags. An entry's value indicates whether the row is expanded; missing rows are collapsed.

Callable filter function for a column. invoke returns true to keep the row, false to filter it out, and may push per-row metadata via addMeta. Implementations may override autoRemove and resolveFilterValue when needed.

Choice of filter function. Either "auto", the name of a built-in or registered fn (a String), or a FilterFn value. Typed as Any? because Kotlin cannot model that mixed union.

The set of built-in filter functions. Supports both .includesString / .equals member access and filterFns[key] lookup. Returns null for an unknown key.

Marker interface for a caller-registered set of filter functions.

Marker interface for caller-supplied filter-side metadata.

Options accepted by getPaginationRowModel. Currently only initialSync is defined; it is reserved for future use and not read by the builder.

The GlobalFaceting feature. Wires the global facet accessors onto each Table when installed.

The GlobalFiltering feature. Adds global-filter state, options and the Table/Column accessors that drive it.

Where the grouped column appears in the table: "reorder", "remove", or null. Typed as Any? for the same reason as AggregationFnOption.

Ordered list of grouped column ids — primary grouping first.

A column header cell. Combines the core header members with the ColumnSizing feature members (getResizeHandler/getSize/getStart).

Context object passed to header renderers. Carries the column, header and owning table.

A row of Headers — one entry per level in the header tree. headers is mutated during construction by buildHeaderGroups.

Column-identifier shape: an explicit id with optional header template.

All-optional counterpart of TableState. Pass to options.initialState to seed the table; absent slices default to their TableState defaults.

Options bag for memo / memoWithArg.

Setter signature: accepts either a new value or a function (old) -> new.

Pagination state: zero-based pageIndex and the page size in rows.

A column filter resolved against its column — carries the column id, the resolved filter fn, and the post-FilterFn.resolveFilterValue value. Used internally by the filtering pipeline.

A row in the table. Integer-typed depth / index use Int; values read through getValue / getUniqueValues / renderValue are typed Any? because Kotlin cannot carry the original <TValue> per-call type argument.

Documentation alias for the row-data type parameter — unbounded in the Kotlin port, equivalent to Any?.

The RowExpanding feature. Adds expanded state, the row-level expansion accessors and the table-level setExpanded / toggleAllRowsExpanded / getExpandedRowModel.

A computed view of the table's rows.

The RowPagination feature. Adds pagination state, the page-navigation accessors (nextPage, previousPage, setPageIndex, setPageSize, ...) and the paginated row-model accessor.

The RowPinning feature. Adds rowPinning state, the row-level pin / getIsPinned / getCanPin / getPinnedIndex accessors, and the table-level partitioning into top, center and bottom rows.

Pinned position for a row. Either "top", "bottom", or the literal false (unpinned). Typed as Any? because Kotlin cannot express that mixed union directly.

Pinned-row ids partitioned by position. Both lists default to null (no rows pinned in that position).

The RowSelection feature. Adds rowSelection state, the row-level accessors (getIsSelected, toggleSelected, ...) and the table-level setRowSelection / toggleAllRowsSelected / getIsAllRowsSelected / getSelectedRowModel.

Per-row selection flags. An absent entry means "unselected".

Options accepted by Row.toggleSelected. selectChildren controls whether the toggle cascades to sub-rows; null leaves the default in place.

The RowSorting feature. Adds sorting state, the column-level sort accessors (getSortingFn, getIsSorted, toggleSorting, ...) and the table-level setSorting / resetSorting / getSortedRowModel.

Sort direction. One of "asc" or "desc" at runtime; modelled as String because Kotlin cannot express a closed union of string literals.

Comparator signature for sorting. Returns a negative number when rowA should come before rowB, zero for equal, positive otherwise. Built-in sort fns return -1 / 0 / 1.

Choice of sort function. Either "auto", the name of a built-in or registered fn (a String), or a SortingFn value. Typed as Any? because Kotlin cannot model that mixed union.

Marker interface for a caller-registered set of sort functions.

Ordered list of ColumnSort entries. Order is significant: entry 0 is the primary sort key.

Column-identifier shape: a string header with optional id.

Header template — a String or a (HeaderContext) -> Any? renderer.

The table instance — entry point to every accessor and setter. Build one with createTable(options); read state via getState() and the get*RowModel() family; mutate via the typed setters (setSorting, setColumnFilters, ...).

Extension point for table features. Each non-null member is invoked during the corresponding construction step:

Marker interface for caller-supplied table-wide metadata. Empty by design — implementors carry whatever payload their app needs.

Caller-facing alias for TableOptionsResolved. The two are structurally identical because every field on TableOptionsResolved is either nullable or carries a default, so a caller can construct one supplying only the options they care about.

The unified table-state container. Carries one field per feature slice (columnVisibility, columnOrder, columnPinning, ...). Each field defaults to its slice's canonical empty value; an immutable InitialTableState supplied by the caller overlays them at table construction time.

Normalises a raw filter value before the filter fn sees it.

Either a new value or a function (old) -> new that produces one. Resolved by functionalUpdate at the call site. Typed as Any? because Kotlin cannot express the underlying union.

Per-column visibility flags. An absent entry means "visible".

The set of built-in aggregation functions, keyed by name. Iteration order is preserved.

Case-insensitive alphanumeric comparator. Splits each value on digit runs, then compares pairwise: digit runs numerically, text runs lexicographically.

Case-sensitive variant of alphanumeric.

Tests whether the cell value (a list) contains filterValue.

Tests whether the cell value (a list) contains every element of filterValue.

Tests whether the cell value (a list) contains any element of filterValue.

Basic comparator: equal ->0, greater-than ->1, otherwise -1. No stringification — the raw values go straight in.

Returns the number of leaf rows.

Date/time comparator. Tolerates nullish values and supports any operand type that surfaces as a numeric epoch value or implements Comparable (an ISO date string, a platform date type that implements Comparable, ...). Opaque non-Comparable date objects cannot be ordered by this comparator — configure a custom sortingFn in that case.

Shared DefaultColumnSizing instance used by ColumnSizing and ColumnDef.fromDefaultSizing.

Strict equality between the cell value and filterValue using JavaScript === semantics (value-equal for primitives, reference-equal otherwise).

Case-insensitive whole-string equality.

Returns listOf(min, max) across child rows. Each entry is Double?, null when no numeric values were seen. NaN values are skipped.

Case-insensitive substring filter. Stringifies both the cell value and the filter value before comparing. A nullish cell value short-circuits to false.

Case-sensitive variant of includesString.

Range filter for numeric cell values. filterValue is a [min, max] pair; non-numeric / null bounds become -Infinity / +Infinity, and an inverted pair is swapped.

Returns the maximum numeric value across child rows, or null if no numeric values are present. NaN values are skipped.

Returns the arithmetic mean of numeric leaf-row values, or null if no numeric values are present. Non-numeric values coerce to NaN and are filtered out by the value >= value self-comparison.

Returns the median of numeric leaf-row values. Returns null for an empty input or when any value is non-numeric. For an even count, returns the average of the two middle elements.

Returns the minimum numeric value across child rows, or null if no numeric values are present. NaN values are skipped (matching the value >= value self-comparison guard).

Splits on digit runs, capturing the runs so they survive the split — used by the alphanumeric comparator below. The capturing group is significant: splitKeepingDelimiters relies on the same alternating-segment shape.

The set of built-in sort functions, keyed by name. Iteration order matches insertion order.

Sums numeric child-row aggregations. Non-numeric values contribute zero. Adds aggregations directly rather than walking leaf rows for speed.

Case-insensitive text comparator. More basic than alphanumeric (less numeric support) but much faster.

Case-sensitive variant of text.

Returns the distinct leaf-row values in first-insertion order.

Returns the count of distinct leaf-row values.

Loose equality between the cell value and filterValue using JavaScript == semantics (type coercion for cross-type primitive comparisons). ToPrimitive coercion of arbitrary objects is not reproduced — object operands fall back to reference equality.

Returns the visible leaf columns for position, where position is null / false (all visible columns), "center", "left" or "right". Modelled with Any? because the original union mixes the literal false with string literals.

Builds a TableState by first running applyDefaults on a fresh default-filled state, then overlaying every slice present on state.

Field-by-field shallow copy of options. Used by createTable to seed its defaults accumulator with the caller's required-field values before feature getDefaultOptions fragments are layered on.

Constructs a Cell for the given row/column pair, then runs every registered feature's createCell hook so features can attach their own members (getIsGrouped, getIsAggregated, ...).

Constructs a Column from columnDef. Resolves the def against the table's default column def (per-field merge — only non-null fields on columnDef override the defaults), derives an id from id/accessorKey/string header, builds an accessor function for accessor-key/-fn columns, installs the memoised getFlatColumns and getLeafColumns, and runs every registered feature's createColumn hook.

Creates a ColumnHelper for rows of TData. Use the helper's accessor / display / group factories to build ColumnDefs for a table.

Constructs a Row for the row at rowIndex in the data array, then runs every registered feature's createRow hook so features can attach their own members.

Returns a new RowModel whose rows walk every expanded sub-row inline with its parent, in source order.

Filters rows through filterRowImpl, producing a new RowModel.

Walks arr depth-first and returns every node together with each node's descendants. getChildren returns null (or an empty list) for leaf nodes.

Resolves an Updater against an input value.

Builds the core row-model factory. The returned function is invoked once per Table and produces a memoised getter for the core RowModel.

Builds the expanded row-model factory. The returned function is invoked once per Table and produces a memoised getter for the expanded RowModel. When no rows are expanded, or paginateExpandedRows is disabled, the pre-expanded model is returned unchanged.

Builds the per-column faceted-min/max-values factory. The returned function is invoked once per (table, columnId) pair and produces a memoised getter for (min, max) as a Pair of Doubles, or null when no numeric values are present.

Builds the per-column faceted-row-model factory. The returned function is invoked once per (table, columnId) pair and produces a memoised getter for that column's RowModel.

Builds the per-column faceted-unique-values factory. The returned function is invoked once per (table, columnId) pair and produces a memoised getter for a value -> count map. Iteration order matches the order each value was first seen.

Builds the table-level filtered row-model factory. The returned function is invoked once per Table and produces a memoised getter for the filtered RowModel.

Builds the grouped row-model factory. The returned function is invoked once per Table and produces a memoised getter for the grouped RowModel.

Builds a MemoOptions from a debug level ("debugAll", "debugCells", "debugTable", "debugColumns", "debugRows", "debugHeaders") and a memo key. The debug callback reports whether the relevant debug flag is enabled; debugAll takes priority over the per-area flag.

Builds the pagination row-model factory. The returned function is invoked once per Table and produces a memoised getter for the paginated RowModel.

Builds the sorted row-model factory. The returned function is invoked once per Table and produces a memoised getter for the sorted RowModel.

Returns true when d is a function value (any arity).

Returns true when d is a non-null list whose every element is a Number.

Returns a setter that updates one TableState field by key, applying functionalUpdate to merge new values. Used by feature getDefaultOptions implementations to wire onXxxChange callbacks to setState.

No-argument memoWithArg. Most table-core memoised computations have no runtime input and use this form.

Dependency-tracking memoiser with a thread-through argument.

Field-by-field merge of a and b, with b winning. Delegates to TableOptionsResolved.merge — see its KDoc for per-field semantics.

An intentionally empty function used where a callable no-op is required.

Returns _document when it is truthy, otherwise null. Mirrors the JavaScript helper that would fall back to the global document binding; commonMain has no such global, so the fallback always yields null.

Returns the ownerDocument of the event's target, when reachable. The required browser-DOM accessors are not available in commonMain, so this always returns null — the same value the original guard chain returns whenever the target or its ownerDocument is missing.

Returns true when a column filter should be auto-removed: when the filter fn's own autoRemove test says so, when the value is null, or when it is an empty string.

Materialises an InitialTableState into a TableState: every slice the caller supplied is copied across; missing slices fall back to the TableState defaults. A null receiver yields a fully-defaulted state.