Data Table Complete API reference

This reference includes every export reachable from the npm package public entry points and every declaration member in the inventory. Search names and signatures to find the exact import path and type contract.

comins-table@0.2.2438 / 284 / 374 / 707 / 68

export identities / unique exports / reachable contracts / members / CSS variables

Find on this page

Public exports 284Reachable contracts 374CSS variables 68

addCominsRows

value

comins-tablecomins-table/core

export declare function addCominsRows<TData>(state: CominsTableState<TData>, rows: readonly TData[]): CominsTableState<TData>;

dist/react/core-compat.d.ts:91 · dist/core/state/table.d.ts:26

applyCominsColumnLayout

value

comins-tablecomins-table/core

export declare function applyCominsColumnLayout<TData>(state: CominsTableState<TData>, layout: CominsColumnLayout): CominsTableState<TData>;

export declare function applyCominsColumnLayout<TData>(state: CominsTableState<TData>, layout: CominsColumnLayout): {
    columnGroups: CominsTableRuntimeColumnGroup[];
    columns: CominsTableRuntimeColumn<TData, unknown>[];
    getRowId: (row: TData, index: number) => import("../model").CominsRowId;
    pagination: import("../model").CominsPaginationState;
    rowIds: import("../model").CominsRowId[];
    rows: TData[];
    selection: import("../model").CominsSelectionState;
    showHeader: boolean;
    sort: import("../model").CominsSortState | null;
    sortModel: import("../model").CominsSortModel;
    columnOrder: string[];
    columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
    columnState: Record<string, CominsColumnRuntimeState>;
};

dist/react/core-compat.d.ts:18 · dist/core/layout/columns.d.ts:52

clearCominsCellRange

value

comins-tablecomins-table/corecomins-table/selection

export declare function clearCominsCellRange<TData>(state: CominsTableState<TData>): {
    columnOrder: string[];
    columnGroups: import("./core-compat").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("./core-compat").CominsColumnGroupRuntimeState>;
    columns: CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("./core-compat").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: CominsSortState | null;
    sortModel: CominsSortModel;
    theme: CominsTableTheme;
    selection: {
        cell: CominsCellAddress | null;
        cells?: CominsCellAddress[];
        rowIds: CominsRowId[];
        range: null;
    };
};

export declare function clearCominsCellRange<TData>(state: CominsTableState<TData>): {
    columnOrder: string[];
    columnGroups: import("../model").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("../model").CominsColumnGroupRuntimeState>;
    columns: import("../model").CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("../model").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: import("../model").CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: import("../model").CominsSortState | null;
    sortModel: import("../model").CominsSortModel;
    selection: {
        cell: CominsCellAddress | null;
        cells?: CominsCellAddress[];
        rowIds: CominsRowId[];
        range: null;
    };
};

dist/react/core-compat.d.ts:63 · dist/core/selection/state.d.ts:92

clearCominsSelection

value

comins-tablecomins-table/corecomins-table/selection

export declare function clearCominsSelection<TData>(state: CominsTableState<TData>): CominsTableState<TData>;

export declare function clearCominsSelection<TData>(state: CominsTableState<TData>): {
    columnOrder: string[];
    columnGroups: import("../model").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("../model").CominsColumnGroupRuntimeState>;
    columns: import("../model").CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("../model").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: import("../model").CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: import("../model").CominsSortState | null;
    sortModel: import("../model").CominsSortModel;
    selection: CominsSelectionState;
};

dist/react/core-compat.d.ts:84 · dist/core/selection/state.d.ts:112

clearCominsSortState

value

comins-tablecomins-table/core

export declare function clearCominsSortState<TData>(state: CominsTableState<TData>): CominsTableState<TData>;

dist/react/core-compat.d.ts:98 · dist/core/state/table.d.ts:64

CominsAfterDragRowPayload

type

comins-table

export type CominsAfterDragRowPayload<TData> = Omit<CominsBeforeRowDragPayload<TData>, "event"> & {
    event: PointerEvent | null;
    reason: CominsRowDragReason;
    result: CominsRowDragResult;
    target?: CominsRowDragTarget;
};

dist/index.d.ts:72

CominsAfterTreeRowDragPayload

type

comins-table

export type CominsAfterTreeRowDragPayload<T> = {
    event: PointerEvent | KeyboardEvent | null;
    row: CominsEventRow<T>;
    target?: CominsRowDragTarget;
    reason: CominsRowDragReason;
    result: CominsRowDragResult;
};

dist/tree-drag.d.ts:14

CominsBeforeRowDragPayload

type

comins-table

export type CominsBeforeRowDragPayload<TData> = {
    event: React.PointerEvent<HTMLElement>;
    row: CominsEventRow<TData>;
    sourceGroupId?: CominsRowId;
    sourceTableId?: string;
};

dist/index.d.ts:60

CominsBeforeTreeRowDragPayload

type

comins-table

export type CominsBeforeTreeRowDragPayload<T> = {
    event: React.PointerEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
    row: CominsEventRow<T>;
};

dist/tree-drag.d.ts:5

CominsButtonComponentConfig

type

comins-table

export type CominsButtonComponentConfig<TPayload> = {
    onClick?: (payload: TPayload & {
        event: React.MouseEvent<HTMLButtonElement>;
    }) => void;
    props?: CominsTableComponentProps<TPayload, React.ButtonHTMLAttributes<HTMLButtonElement>>;
    type: "button";
};

dist/react-types.d.ts:80

CominsCellAddress

type

comins-tablecomins-table/corecomins-table/selection

export type CominsCellAddress = {
    columnId: string;
    rowId: CominsRowId;
};

dist/model.d.ts:133

CominsCellComponent

type

comins-table

export type CominsCellComponent<TData, TValue = unknown> = CominsComponentPlacement & CominsCellComponentConfig<TData, TValue>;

dist/react-types.d.ts:192

CominsCellComponentConfig

type

comins-table

export type CominsCellComponentConfig<TData, TValue = unknown> = CominsButtonComponentConfig<CominsCellComponentPayload<TData, TValue>> | CominsInputComponentConfig<CominsCellComponentPayload<TData, TValue>> | CominsCheckboxComponentConfig<CominsCellComponentPayload<TData, TValue>> | CominsRadioComponentConfig<CominsCellComponentPayload<TData, TValue>> | CominsSelectComponentConfig<CominsCellComponentPayload<TData, TValue>> | CominsToggleComponentConfig<CominsCellComponentPayload<TData, TValue>> | CominsProgressComponentConfig<CominsCellComponentPayload<TData, TValue>> | CominsVirtualListComponentConfig<CominsCellComponentPayload<TData, TValue>>;

dist/react-types.d.ts:190

CominsCellComponentPayload

type

comins-tablecomins-table/core

export type CominsCellComponentPayload<TData, TValue = unknown> = {
    column: CominsComponentColumnPayload<TData, TValue>;
    row: CominsComponentRowPayload<TData>;
    selection: {
        selectedRowCount: number;
    };
    value: TValue;
};

dist/react-types.d.ts:47 · dist/core/model.d.ts:20

CominsCellEventPayload

type

comins-table

export type CominsCellEventPayload<TData, TValue = unknown, TEvent = React.MouseEvent<HTMLTableCellElement>> = {
    column: CominsEventColumn<TData, TValue>;
    event: TEvent;
    index: number;
    row: CominsEventRow<TData>;
    value: TValue;
};

dist/index.d.ts:83

CominsCellFormatParams

type

comins-tablecomins-table/core

export type CominsCellFormatParams<TData, TValue = unknown> = {
    column: CominsTableRuntimeColumn<TData, TValue>;
    row: TData;
    rowId: CominsRowId;
    value: TValue;
};

dist/react-types.d.ts:10 · dist/core/model.d.ts:6

CominsCellKeyboardEventPayload

type

comins-table

export type CominsCellKeyboardEventPayload<TData, TValue = unknown> = CominsCellEventPayload<TData, TValue, React.KeyboardEvent<HTMLTableCellElement>>;

dist/index.d.ts:91

CominsCellRange

type

comins-tablecomins-table/corecomins-table/selection

export type CominsCellRange = {
    anchor: CominsCellAddress;
    focus: CominsCellAddress;
};

dist/model.d.ts:137

CominsCellSelectionOptions

type

comins-tablecomins-table/corecomins-table/selection

export type CominsCellSelectionOptions = {
    multi?: boolean;
    toggle?: boolean;
};

dist/model.d.ts:156

CominsCheckboxComponentConfig

type

comins-table

export type CominsCheckboxComponentConfig<TPayload> = {
    onCheckedChange?: (payload: TPayload & {
        checked: boolean;
    }) => void;
    props?: CominsTableComponentProps<TPayload, React.InputHTMLAttributes<HTMLInputElement>>;
    type: "checkbox";
};

dist/react-types.d.ts:99

CominsClipboardGuard

type

comins-tablecomins-table/clipboardcomins-table/core

export type CominsClipboardGuard<TData, TValue = unknown> = boolean | ((params: CominsCellComponentPayload<TData, TValue>) => boolean);

dist/react-types.d.ts:68 · dist/core/model.d.ts:28

CominsColumnConditionFilterOperator

type

comins-tablecomins-table/core

export type CominsColumnConditionFilterOperator = "between" | "contains" | "endsWith" | "equals" | "greaterThan" | "greaterThanOrEqual" | "isEmpty" | "isNotEmpty" | "lessThan" | "lessThanOrEqual" | "notContains" | "notEquals" | "startsWith";

dist/core/rows/filtering.d.ts:6

CominsColumnConditionFilterRule

type

comins-tablecomins-table/core

export type CominsColumnConditionFilterRule = {
    columnId: string;
    operator: CominsColumnConditionFilterOperator;
    value?: CominsColumnFilterValue;
    valueTo?: null | number | string;
    values?: never;
};

dist/core/rows/filtering.d.ts:11

CominsColumnFilterConfig

type

comins-tablecomins-table/core

export type CominsColumnFilterConfig<TData, TValue = unknown> = Omit<CoreFilterConfig<TData, TValue>, "getValue"> & {
    mode?: "condition" | "values";
    trigger?: CominsValueFilterPart<CominsValueFilterTriggerRenderParams<TData>>;
    option?: CominsValueFilterPart<CominsValueFilterOptionRenderParams<TData>>;
    panel?: CominsValueFilterPart<CominsValueFilterPanelRenderParams<TData>>;
    getValue?: (params: CominsCellFormatParams<TData, TValue>) => unknown;
};

export type CominsColumnFilterConfig<TData, TValue = unknown> = {
    caseSensitive?: boolean;
    getOptionLabel?: (value: CominsColumnFilterValue) => string;
    getValue?: (params: CominsCellFormatParams<TData, TValue>) => unknown;
    kind: CominsColumnFilterKind;
};

dist/filtering.d.ts:12 · dist/core/model.d.ts:55

CominsColumnFilteringConfig

type

comins-tablecomins-table/core

export type CominsColumnFilteringConfig = {
    model: CominsColumnFilterModel;
    onChangeModel?: (model: CominsColumnFilterRule[]) => void;
    onChangeOpenColumnId?: (columnId: string | null) => void;
    openColumnId?: string | null;
};

dist/core/rows/filtering.d.ts:27

CominsColumnFilteringSourceRow

type

comins-table/core

export type CominsColumnFilteringSourceRow<TData> = {
    data: TData;
    dataIndex: number;
    id: CominsRowId;
};

dist/core/rows/filtering.d.ts:33

CominsColumnFilterKind

type

comins-tablecomins-table/core

export type CominsColumnFilterKind = "boolean" | "date" | "number" | "text";

dist/core/model.d.ts:54

CominsColumnFilterModel

type

comins-tablecomins-table/core

export type CominsColumnFilterModel = readonly CominsColumnFilterRule[];

dist/core/rows/filtering.d.ts:26

CominsColumnFilterOperator

type

comins-tablecomins-table/core

export type CominsColumnFilterOperator = CominsColumnConditionFilterOperator | "in";

dist/core/rows/filtering.d.ts:7

CominsColumnFilterOption

type

comins-tablecomins-table/core

export type CominsColumnFilterOption = {
    id: string;
    value: CominsColumnFilterValue;
    label: string;
    count: number;
    selected: boolean;
    present: boolean;
};

dist/core/rows/values-filter.d.ts:3

CominsColumnFilterOptionsInput

type

comins-tablecomins-table/core

export type CominsColumnFilterOptionsInput<TData> = Omit<CoreOptionsInput<TData>, "columns"> & {
    columns: readonly CominsTableRuntimeColumn<TData>[];
};

export type CominsColumnFilterOptionsInput<TData> = {
    columns: readonly CominsTableRuntimeColumn<TData>[];
    columnId: string;
    rows: readonly CominsColumnFilteringSourceRow<TData>[];
    model: CominsColumnFilterModel;
    query?: string;
};

dist/filtering.d.ts:24 · dist/core/rows/values-filter.d.ts:31

CominsColumnFilterOptionsResult

type

comins-tablecomins-table/core

export type CominsColumnFilterOptionsResult = {
    options: readonly CominsColumnFilterOption[];
    visibleOptions: readonly CominsColumnFilterOption[];
    selectionMode: "all" | "include";
    totalOptionCount: number;
    selectedOptionCount: number;
    visibleOptionCount: number;
    selectedVisibleOptionCount: number;
    visibleSelection: boolean | "mixed";
};

dist/core/rows/values-filter.d.ts:11

CominsColumnFilterRule

type

comins-tablecomins-table/core

export type CominsColumnFilterRule = CominsColumnConditionFilterRule | CominsColumnValueFilterRule;

dist/core/rows/filtering.d.ts:25

CominsColumnFilterValue

type

comins-tablecomins-table/core

export type CominsColumnFilterValue = boolean | null | number | string;

dist/core/model.d.ts:53

CominsColumnFilterValuesAction

type

comins-tablecomins-table/core

export type CominsColumnFilterValuesAction = {
    type: "setOption";
    id: string;
    checked: boolean;
} | {
    type: "setVisible";
    checked: boolean;
} | {
    type: "clear";
};

dist/core/rows/values-filter.d.ts:21

CominsColumnGroupRuntimeState

type

comins-tablecomins-table/core

export type CominsColumnGroupRuntimeState = {
    hidden?: boolean;
    pinned?: CominsColumnPinned;
};

dist/model.d.ts:31

CominsColumnLayout

type

comins-tablecomins-table/core

export type CominsColumnLayout = {
    columns: Record<string, CominsColumnRuntimeState>;
    groups?: Record<string, CominsColumnGroupRuntimeState>;
    order: string[];
};

dist/model.d.ts:35

CominsColumnPinned

type

comins-tablecomins-table/core

export type CominsColumnPinned = "left" | "right";

dist/column-pinning.d.ts:1

CominsColumnProps

type

comins-table

export type CominsColumnProps<TData, TValue = unknown> = {
    className?: string | ((params: CominsCellComponentPayload<TData, TValue>) => string | undefined);
    copyable?: CominsClipboardGuard<TData, TValue>;
    disabled?: CominsClipboardGuard<TData, TValue>;
    pasteable?: CominsClipboardGuard<TData, TValue>;
    style?: React.CSSProperties | ((params: CominsCellComponentPayload<TData, TValue>) => React.CSSProperties | undefined);
};

dist/react-types.d.ts:69

CominsColumnRuntimeState

type

comins-tablecomins-table/core

export type CominsColumnRuntimeState = {
    hidden?: boolean;
    pinned?: CominsColumnPinned;
    width?: number;
};

dist/model.d.ts:26

CominsColumnValueFilterRule

type

comins-tablecomins-table/core

export type CominsColumnValueFilterRule = {
    columnId: string;
    operator: "in";
    values: readonly CominsColumnFilterValue[];
    value?: never;
    valueTo?: never;
};

dist/core/rows/filtering.d.ts:18

CominsColumnValueResolver

type

comins-tablecomins-table/core

export type CominsColumnValueResolver<TData, TValue> = TValue | ((params: CominsCellFormatParams<TData, TValue>) => TValue);

dist/react-types.d.ts:16 · dist/core/model.d.ts:12

CominsComponentAlign

type

comins-tablecomins-table/core

export type CominsComponentAlign = "center" | "end" | "start";

dist/model.d.ts:11

CominsComponentColumnPayload

type

comins-tablecomins-table/core

export type CominsComponentColumnPayload<TData, TValue = unknown> = {
    definition: CominsTableRuntimeColumn<TData, TValue>;
    field: string;
    id: string;
    index: number;
    label: React.ReactNode;
};

export type CominsComponentColumnPayload<TData, TValue = unknown> = {
    definition: CominsTableRuntimeColumn<TData, TValue>;
    field: string;
    id: string;
    index: number;
    label: string;
};

dist/react-types.d.ts:40 · dist/core/model.d.ts:13

CominsComponentDirection

type

comins-tablecomins-table/core

export type CominsComponentDirection = "left" | "right";

dist/model.d.ts:12

CominsComponentPlacement

type

comins-tablecomins-table/core

export type CominsComponentPlacement = {
    align?: CominsComponentAlign;
    direction?: CominsComponentDirection;
    id?: string;
};

dist/model.d.ts:13

CominsComponentPrimitiveValue

type

comins-tablecomins-table/core

export type CominsComponentPrimitiveValue = string | number | boolean;

dist/model.d.ts:10

CominsComponentRowPayload

type

comins-tablecomins-table/core

export type CominsComponentRowPayload<TData> = {
    data: TData;
    dataIndex: number;
    disabled: boolean;
    id: CominsRowId;
    index: number;
    selected: boolean;
};

dist/model.d.ts:18

CominsCopiedCell

type

comins-tablecomins-table/clipboardcomins-table/core

export type CominsCopiedCell = {
    kind: "cell";
    text: string;
    value: unknown;
};

dist/model.d.ts:73

CominsCopiedCellRange

type

comins-tablecomins-table/clipboardcomins-table/core

export type CominsCopiedCellRange = {
    kind: "cell-range";
    rows: CominsCopiedCellRangeCell[][];
    text: string;
};

dist/model.d.ts:83

CominsCopiedCellRangeCell

type

comins-tablecomins-table/clipboardcomins-table/core

export type CominsCopiedCellRangeCell = {
    columnId: string;
    text: string;
    value: unknown;
} | null;

dist/model.d.ts:78

CominsCopiedRow

type

comins-tablecomins-table/clipboardcomins-table/core

export type CominsCopiedRow<TData> = {
    kind: "row";
    row: TData;
    text: string;
};

dist/model.d.ts:68

CominsCopyTarget

type

comins-table

export type CominsCopyTarget = "auto" | "cells" | "rows";

dist/selection-data.d.ts:6

CominsCsvImportOptions

type

comins-tablecomins-table/core

export type CominsCsvImportOptions<TData> = {
    text: string;
    mapRow: (row: CominsCsvImportRow) => TData;
    hasHeader?: boolean;
    maxCharacters?: number;
    maxCells?: number;
};

dist/model.d.ts:94

CominsCsvImportRow

type

comins-tablecomins-table/core

export type CominsCsvImportRow = {
    cells: readonly string[];
    headers: readonly string[] | null;
    rowIndex: number;
};

dist/model.d.ts:89

CominsEventColumn

type

comins-tablecomins-table/core

export type CominsEventColumn<TData, TValue = unknown> = {
    definition: CominsTableRuntimeColumn<TData, TValue>;
    field: string;
    id: string;
    index: number;
    label: React.ReactNode;
};

export type CominsEventColumn<TData, TValue = unknown> = CominsComponentColumnPayload<TData, TValue>;

dist/react-types.d.ts:250 · dist/core/model.d.ts:87

CominsEventRow

type

comins-table

export type CominsEventRow<TData> = {
    data: TData;
    dataIndex: number;
    id: CominsRowId;
    index: number;
};

dist/model.d.ts:164

CominsExportColumn

type

comins-tablecomins-table/core

export type CominsExportColumn<TData> = {
    format?: (row: TData, rowIndex: number) => unknown;
    id?: string;
    label?: string;
    value: (row: TData, rowIndex: number) => unknown;
};

dist/model.d.ts:102

CominsExportFormat

type

comins-tablecomins-table/core

export type CominsExportFormat = "csv" | "json";

dist/model.d.ts:88

CominsExportGroupedOptions

type

comins-tablecomins-table/core

export type CominsExportGroupedOptions<TData, TGroup> = Omit<CominsExportRowsOptions<TData>, "metadata"> & {
    groups: readonly TGroup[];
    getGroupId: (group: TGroup) => CominsRowId;
    getRowGroupId: (row: TData, sourceIndex: number) => CominsRowId;
    getRowId: (row: TData, sourceIndex: number) => CominsRowId;
};

dist/model.d.ts:127

CominsExportMetadata

type

comins-tablecomins-table/core

export type CominsExportMetadata<TData> = {
    __rowId?: (row: TData, rowIndex: number) => CominsRowId;
    __parentId?: (row: TData, rowIndex: number) => CominsRowId | null;
    __depth?: (row: TData, rowIndex: number) => number;
    __groupId?: (row: TData, rowIndex: number) => CominsRowId | null;
};

dist/model.d.ts:117

CominsExportRowsOptions

type

comins-tablecomins-table/core

export type CominsExportRowsOptions<TData> = {
    columnOrder?: string[];
    columns: Array<CominsExportColumn<TData>>;
    headerOverrides?: Record<string, string>;
    rows: readonly TData[];
    metadata?: CominsExportMetadata<TData>;
    valueSource?: CominsExportValueSource;
};

dist/model.d.ts:108

CominsExportTreeOptions

type

comins-tablecomins-table/core

export type CominsExportTreeOptions<TData> = Omit<CominsExportRowsOptions<TData>, "rows" | "metadata"> & {
    nodes: readonly import("./tree").CominsTreeNode<TData>[];
    getRowId: (row: TData, sourceIndex: number) => CominsRowId;
};

dist/model.d.ts:123

CominsExportValueSource

type

comins-tablecomins-table/core

export type CominsExportValueSource = "formatted" | "raw";

dist/model.d.ts:101

CominsFillCellRangeOptions

type

comins-tablecomins-table/clipboardcomins-table/core

export type CominsFillCellRangeOptions = {
    source: CominsCellAddress | CominsCellRange;
    target: CominsCellRange;
};

dist/model.d.ts:160

CominsFilterBinding

type

comins-table

export type CominsFilterBinding<TElement extends HTMLElement, TProps> = TProps & {
    ref: React.RefCallback<TElement>;
};

dist/react/value-filter-types.d.ts:15

CominsFilterButtonGetter

type

comins-table

export type CominsFilterButtonGetter = {
    (options?: CominsFilterNativeOptions<HTMLButtonElement, React.ButtonHTMLAttributes<HTMLButtonElement>>): CominsFilterBinding<HTMLButtonElement, React.ButtonHTMLAttributes<HTMLButtonElement>>;
    <TElement extends HTMLElement = HTMLElement>(options: CominsFilterCustomOptions<TElement>): CominsFilterBinding<TElement, React.HTMLAttributes<TElement>>;
};

dist/react/value-filter-types.d.ts:18

CominsFilterCheckboxGetter

type

comins-table

export type CominsFilterCheckboxGetter = {
    (options?: CominsFilterNativeOptions<HTMLInputElement, React.InputHTMLAttributes<HTMLInputElement>>): CominsFilterBinding<HTMLInputElement, React.InputHTMLAttributes<HTMLInputElement>>;
    <TElement extends HTMLElement = HTMLElement>(options: CominsFilterCustomOptions<TElement>): CominsFilterBinding<TElement, React.HTMLAttributes<TElement>>;
};

dist/react/value-filter-types.d.ts:22

CominsFilterCustomOptions

type

comins-table

export type CominsFilterCustomOptions<TElement extends HTMLElement> = {
    element: "custom";
    props?: Omit<React.HTMLAttributes<TElement>, Protected>;
    ref?: React.Ref<TElement>;
};

dist/react/value-filter-types.d.ts:10

CominsFilterNativeOptions

type

comins-table

export type CominsFilterNativeOptions<TElement extends HTMLElement, TProps> = {
    element?: "native";
    props?: Omit<TProps, Protected>;
    ref?: React.Ref<TElement>;
};

dist/react/value-filter-types.d.ts:5

CominsGroupBetweenTablesInput

type

comins-table

export type CominsGroupBetweenTablesInput<TData, TGroup> = {
    position?: CominsTableTransferDropPosition;
    resolveConflict?: CominsTableTransferConflictResolver<TData, TGroup>;
    source: CominsTableTransferEndpoint<TData, TGroup>;
    sourceGroupId: CominsRowId;
    target: CominsTableTransferEndpoint<TData, TGroup>;
    targetGroupId?: CominsRowId;
};

dist/core/transfer/policy.d.ts:105

CominsHeaderCell

type

comins-tablecomins-table/core

export type CominsHeaderCell<TData> = CominsHeaderColumnCell<TData> | CominsHeaderGroupCell;

dist/react-types.d.ts:300 · dist/core/model.d.ts:129

CominsHeaderColumnCell

type

comins-tablecomins-table/core

export type CominsHeaderColumnCell<TData> = {
    colSpan: 1;
    column: CominsTableRuntimeColumn<TData>;
    columnId: string;
    groupId?: string;
    kind: "column";
    rowSpan: 1 | 2;
};

dist/react-types.d.ts:285 · dist/core/model.d.ts:114

CominsHeaderComponent

type

comins-table

export type CominsHeaderComponent<TData, TValue = unknown> = CominsComponentPlacement & CominsHeaderComponentConfig<TData, TValue>;

dist/react-types.d.ts:191

CominsHeaderComponentConfig

type

comins-table

export type CominsHeaderComponentConfig<TData, TValue = unknown> = CominsButtonComponentConfig<CominsHeaderComponentPayload<TData, TValue>> | CominsInputComponentConfig<CominsHeaderComponentPayload<TData, TValue>> | CominsCheckboxComponentConfig<CominsHeaderComponentPayload<TData, TValue>> | CominsRadioComponentConfig<CominsHeaderComponentPayload<TData, TValue>> | CominsSelectComponentConfig<CominsHeaderComponentPayload<TData, TValue>> | CominsToggleComponentConfig<CominsHeaderComponentPayload<TData, TValue>> | CominsProgressComponentConfig<CominsHeaderComponentPayload<TData, TValue>> | CominsMenuComponentConfig<CominsHeaderComponentPayload<TData, TValue>>;

dist/react-types.d.ts:189

CominsHeaderComponentPayload

type

comins-tablecomins-table/core

export type CominsHeaderComponentPayload<TData, TValue = unknown> = {
    column: CominsComponentColumnPayload<TData, TValue>;
    layout: {
        hidden: boolean;
        width?: number;
    };
    sort: {
        count: number;
        direction: CominsSortDirection | null;
        enabled: boolean;
        priority: number | null;
    };
};

export type CominsHeaderComponentPayload<TData, TValue = unknown> = {
    column: CominsComponentColumnPayload<TData, TValue>;
    layout: {
        hidden: boolean;
        width?: number;
    };
    sort: {
        count: number;
        direction: CominsSortState["direction"] | null;
        enabled: boolean;
        priority: number | null;
    };
};

dist/react-types.d.ts:55 · dist/core/model.d.ts:29

CominsHeaderGroupCell

type

comins-tablecomins-table/core

export type CominsHeaderGroupCell = {
    colSpan: number;
    group: CominsTableRuntimeColumnGroup;
    groupId: string;
    kind: "group";
    rowSpan: 1;
};

dist/react-types.d.ts:293 · dist/core/model.d.ts:122

CominsInputCommitEvent

type

comins-table

export type CominsInputCommitEvent = React.ChangeEvent<HTMLInputElement> | React.FocusEvent<HTMLInputElement> | React.KeyboardEvent<HTMLInputElement>;

dist/react-types.d.ts:87

CominsInputComponentConfig

type

comins-table

export type CominsInputComponentConfig<TPayload> = {
    onChange?: (payload: TPayload & {
        event: CominsInputCommitEvent;
        value: string;
    }) => void;
    onValueChange?: (payload: TPayload & {
        value: string;
    }) => void;
    props?: CominsTableComponentProps<TPayload, React.InputHTMLAttributes<HTMLInputElement>>;
    type: "input";
};

dist/react-types.d.ts:88

CominsLazyLoadReason

type

comins-table

export type CominsLazyLoadReason = "initial" | "scroll" | "refresh";

dist/index.d.ts:129

CominsLazyLoadRequest

type

comins-table

export type CominsLazyLoadRequest = {
    limit: number;
    offset: number;
    reason: CominsLazyLoadReason;
    signal: AbortSignal;
};

dist/index.d.ts:130

CominsMenuComponentConfig

type

comins-table

export type CominsMenuComponentConfig<TPayload> = {
    items: CominsTableMenuItems<TPayload>;
    onBeforeChange?: (payload: TPayload & {
        event?: Event | React.SyntheticEvent;
        open: boolean;
    }) => boolean | void;
    onOpenChange?: (payload: TPayload & {
        event?: Event | React.SyntheticEvent;
        open: boolean;
    }) => void;
    onSelect?: (payload: TPayload & {
        event: React.MouseEvent<HTMLButtonElement>;
        item: Extract<CominsTableMenuItem, {
            value: CominsComponentPrimitiveValue;
        }>;
        value: CominsComponentPrimitiveValue;
    }) => void;
    props?: CominsTableComponentProps<TPayload, React.ButtonHTMLAttributes<HTMLButtonElement>>;
    type: "menu";
};

dist/react-types.d.ts:140

CominsNormalizedColumnFilterRule

type

comins-table/core

export type CominsNormalizedColumnFilterRule<TData> = {
    column: CominsTableRuntimeColumn<TData>;
    config: CominsColumnFilterConfig<TData>;
} & ({
    operator: CominsColumnConditionFilterOperator;
    value?: CominsNormalizedFilterValue;
    valueTo?: number;
    values?: never;
    keys?: never;
} | {
    operator: "in";
    values: readonly CominsColumnFilterValue[];
    keys: ReadonlySet<string>;
    value?: never;
    valueTo?: never;
});

dist/core/rows/filtering.d.ts:39

CominsPaginationState

type

comins-tablecomins-table/core

export type CominsPaginationState = {
    pageIndex: number;
    pageSize: number;
};

dist/model.d.ts:40

CominsPasteRowOptions

type

comins-tablecomins-table/clipboardcomins-table/core

export type CominsPasteRowOptions<TData> = {
    getNewRowId?: (row: TData) => CominsRowId;
    mode: "append";
} | {
    getPastedRowId?: (row: TData) => CominsRowId;
    mode: "insert-after";
    targetRowId: CominsRowId;
} | {
    mode: "overwrite" | "replace";
    targetRowId: CominsRowId;
};

dist/model.d.ts:141

CominsProgressComponentConfig

type

comins-table

export type CominsProgressComponentConfig<TPayload> = {
    props?: CominsTableComponentProps<TPayload, React.HTMLAttributes<HTMLDivElement> & {
        max?: number;
        value?: number;
    }>;
    type: "progress";
};

dist/react-types.d.ts:133

CominsRadioComponentConfig

type

comins-table

export type CominsRadioComponentConfig<TPayload> = {
    onValueChange?: (payload: TPayload & {
        value: string;
    }) => void;
    options: CominsTableOptions<TPayload>;
    props?: CominsTableComponentProps<TPayload, React.HTMLAttributes<HTMLDivElement> & {
        value?: CominsComponentPrimitiveValue;
    }>;
    type: "radio";
};

dist/react-types.d.ts:106

CominsRowBetweenTablesInput

type

comins-table

export type CominsRowBetweenTablesInput<TData, TGroup = never> = {
    resolveConflict?: CominsTableTransferConflictResolver<TData, TGroup>;
    source: CominsTableTransferEndpoint<TData, TGroup>;
    sourceRowId: CominsRowId;
    target: CominsTableTransferEndpoint<TData, TGroup>;
    targetGroupId?: CominsRowId;
    targetRowId?: CominsRowId;
};

dist/core/transfer/policy.d.ts:97

CominsRowDetailHeight

type

comins-table

export type CominsRowDetailHeight = number | "auto";

dist/index.d.ts:95

CominsRowDetailParams

type

comins-table

export type CominsRowDetailParams<TData> = {
    row: CominsEventRow<TData>;
};

dist/index.d.ts:92

CominsRowDetailProps

type

comins-table

export type CominsRowDetailProps<TData> = {
    estimatedRowDetailHeight?: number;
    expandedRowIds?: readonly CominsRowId[];
    getRowDetailHeight?: (params: CominsRowDetailParams<TData>) => CominsRowDetailHeight;
    isRowExpandable?: (params: CominsRowDetailParams<TData>) => boolean;
    onChangeExpandedRowIds?: (rowIds: CominsRowId[]) => void;
    rowDetail?: {
        render?: (params: CominsRowDetailParams<TData>) => React.ReactNode;
    };
    /** @deprecated Use rowDetail.render. Retained throughout 0.x; removal target: 1.0.0. */
    renderRowDetail?: (params: CominsRowDetailParams<TData>) => React.ReactNode;
};

dist/index.d.ts:96

CominsRowDragPayload

type

comins-table

export type CominsRowDragPayload<TData> = Omit<CominsBeforeRowDragPayload<TData>, "event"> & {
    event: PointerEvent;
    target: CominsRowDragTarget;
};

dist/index.d.ts:66

CominsRowDragReason

type

comins-table

export type CominsRowDragReason = "blur" | "drop" | "duplicate-id" | "escape" | "invalid-target" | "pointer-cancel" | "stale-target" | "unchanged";

dist/index.d.ts:71

CominsRowDragResult

type

comins-table

export type CominsRowDragResult = "cancelled" | "moved" | "rejected";

dist/index.d.ts:70

CominsRowDragTarget

type

comins-table

export type CominsRowDragTarget = {
    tree?: CominsTreeMoveDestination & {
        position: CominsTreeDropPosition;
    };
    dataIndex?: number;
    groupId?: CominsRowId;
    rowId?: CominsRowId;
    tableId?: string;
    valid: boolean;
};

dist/index.d.ts:50

CominsRowEventPayload

type

comins-table

export type CominsRowEventPayload<TData, TEvent = React.MouseEvent<HTMLTableRowElement>> = {
    event: TEvent;
    index: number;
    row: CominsEventRow<TData>;
};

dist/index.d.ts:78

CominsRowGroupAggregation

type

comins-table

export type CominsRowGroupAggregation = "avg" | "count" | "max" | "min" | "sum";

dist/grouping.d.ts:3

CominsRowGroupDropPosition

type

comins-table

export type CominsRowGroupDropPosition = "after" | "before";

dist/grouping.d.ts:4

CominsRowGroupingConfig

type

comins-table

export type CominsRowGroupingConfig<TData, TGroup = unknown> = {
    aggregations?: Readonly<Partial<Record<string, CominsRowGroupAggregation>>>;
    expandedGroupIds?: readonly CominsRowId[];
    getGroupId: (group: TGroup) => CominsRowId;
    label?: {
        render?: (group: TGroup) => React.ReactNode;
    };
    /** @deprecated Use label.render. Retained throughout 0.x; removal target: 1.0.0. */
    getGroupLabel?: (group: TGroup) => React.ReactNode;
    getGroupRowProps?: (params: CominsRowGroupRenderParams<TData, TGroup>) => CominsRowGroupProps | undefined;
    getRowGroupId: (row: TData, dataIndex: number) => CominsRowId;
    groupDraggable?: boolean;
    groups: readonly TGroup[];
    onChangeExpandedGroupIds?: (groupIds: CominsRowId[]) => void;
    onChangeGroups?: (groups: TGroup[], details: CominsRowGroupMoveDetails) => void;
    content?: {
        render?: (params: CominsRowGroupRenderParams<TData, TGroup>) => React.ReactNode;
    };
    /** @deprecated Use content.render. Retained throughout 0.x; removal target: 1.0.0. */
    renderGroupContent?: (params: CominsRowGroupRenderParams<TData, TGroup>) => React.ReactNode;
    setRowGroupId?: (params: CominsSetRowGroupIdParams<TData>) => TData;
};

dist/grouping.d.ts:31

CominsRowGroupingSourceRow

type

comins-table

export type CominsRowGroupingSourceRow<TData> = {
    data: TData;
    dataIndex: number;
    id: CominsRowId;
};

dist/grouping.d.ts:53

CominsRowGroupMoveDetails

type

comins-table

export type CominsRowGroupMoveDetails = {
    fromIndex: number;
    groupId: CominsRowId;
    reason: "move";
    targetGroupId: CominsRowId;
    toIndex: number;
};

dist/grouping.d.ts:5

CominsRowGroupMoveOptions

type

comins-tablecomins-table/core

export type CominsRowGroupMoveOptions<TData> = {
    getRowGroupId: (row: TData, dataIndex: number) => CominsRowId;
    setRowGroupId?: (params: {
        fromGroupId: CominsRowId;
        row: TData;
        rowId: CominsRowId;
        toGroupId: CominsRowId;
    }) => TData;
    sourceRowId: CominsRowId;
    targetGroupId: CominsRowId;
    targetRowId?: CominsRowId;
};

dist/core/state/table.d.ts:2

CominsRowGroupProps

type

comins-table

export type CominsRowGroupProps = {
    className?: string;
    style?: React.CSSProperties;
};

dist/grouping.d.ts:27

CominsRowGroupRenderParams

type

comins-table

export type CominsRowGroupRenderParams<TData, TGroup> = {
    aggregateValues: Readonly<Record<string, number | null>>;
    expanded: boolean;
    group: TGroup;
    groupId: CominsRowId;
    groupIndex: number;
    isEmpty: boolean;
    rowCount: number;
};

dist/grouping.d.ts:18

CominsRowHeight

type

comins-table

export type CominsRowHeight = number | "auto";

dist/core/layout/row-height.d.ts:2

CominsRowHeightParams

type

comins-table

export type CominsRowHeightParams<TData> = {
    row: CominsEventRow<TData>;
};

dist/core/layout/row-height.d.ts:3

CominsRowId

type

comins-tablecomins-table/core

export type CominsRowId = string | number;

dist/model.d.ts:2

CominsRowKeyboardEventPayload

type

comins-table

export type CominsRowKeyboardEventPayload<TData> = CominsRowEventPayload<TData, React.KeyboardEvent<HTMLTableRowElement>>;

dist/index.d.ts:90

CominsRowSelectionOptions

type

comins-tablecomins-table/corecomins-table/selection

export type CominsRowSelectionOptions = {
    multi?: boolean;
    toggle?: boolean;
};

dist/model.d.ts:152

CominsRowUpdate

type

comins-tablecomins-table/core

export type CominsRowUpdate<TData> = {
    id: CominsRowId;
    patch: Partial<TData> | ((row: TData) => TData);
};

dist/model.d.ts:50

CominsSelectComponentConfig

type

comins-table

export type CominsSelectComponentConfig<TPayload> = {
    onValueChange?: (payload: TPayload & {
        value: string;
    }) => void;
    options: CominsTableOptions<TPayload>;
    props?: CominsTableComponentProps<TPayload, React.SelectHTMLAttributes<HTMLSelectElement>>;
    type: "select";
};

dist/react-types.d.ts:116

CominsSelectedCell

type

comins-table

export type CominsSelectedCell = CominsCellAddress & {
    value: unknown;
};

dist/selection-data.d.ts:3

CominsSelectionCopy

type

comins-table

export type CominsSelectionCopy = {
    target: "cells" | "rows";
    text: string;
    data: CominsCopiedCellRange;
};

dist/selection-data.d.ts:7

CominsSelectionState

type

comins-tablecomins-table/corecomins-table/selection

export type CominsSelectionState = {
    cell: CominsCellAddress | null;
    cells?: CominsCellAddress[];
    range: CominsCellRange | null;
    rowIds: CominsRowId[];
};

dist/model.d.ts:44

CominsSetRowGroupIdParams

type

comins-table

export type CominsSetRowGroupIdParams<TData> = {
    fromGroupId: CominsRowId;
    row: TData;
    rowId: CominsRowId;
    toGroupId: CominsRowId;
};

dist/grouping.d.ts:12

CominsSortDirection

type

comins-tablecomins-table/core

export type CominsSortDirection = "asc" | "desc";

dist/model.d.ts:4

CominsSortModel

type

comins-tablecomins-table/core

export type CominsSortModel = readonly CominsSortState[];

dist/model.d.ts:9

CominsSortState

type

comins-tablecomins-table/core

export type CominsSortState = {
    columnId: string;
    direction: CominsSortDirection;
};

dist/model.d.ts:5

CominsSummaryAggregator

type

comins-table

export type CominsSummaryAggregator<TData> = (input: {
    column: CominsTableRuntimeColumn<TData>;
    rows: readonly TData[];
    values: readonly unknown[];
}) => React.ReactNode;

dist/summary.d.ts:4

CominsSummaryBuiltin

type

comins-table

export type CominsSummaryBuiltin = "avg" | "count" | "max" | "min" | "sum";

dist/summary.d.ts:3

CominsSummaryColumn

type

comins-table

export type CominsSummaryColumn<TData> = CominsSummaryBuiltin | CominsSummaryAggregator<TData> | CominsSummaryColumnConfig<TData>;

dist/summary.d.ts:27

CominsSummaryColumnConfig

type

comins-table

export type CominsSummaryColumnConfig<TData> = {
    aggregate: CominsSummaryBuiltin | CominsSummaryAggregator<TData>;
    className?: string;
    colSpan?: number;
    format?: (payload: CominsSummaryFormatPayload<TData>) => React.ReactNode;
    /** Render after aggregate/format; undefined keeps formattedValue, null hides content. */
    render?: (payload: CominsSummaryRenderPayload<TData>) => React.ReactNode;
    style?: React.CSSProperties;
};

dist/summary.d.ts:18

CominsSummaryFormatPayload

type

comins-table

export type CominsSummaryFormatPayload<TData> = {
    column: CominsTableRuntimeColumn<TData>;
    rows: readonly TData[];
    value: React.ReactNode;
    values: readonly unknown[];
};

dist/summary.d.ts:9

CominsSummaryRenderPayload

type

comins-table

export type CominsSummaryRenderPayload<TData> = CominsSummaryFormatPayload<TData> & {
    formattedValue: React.ReactNode;
};

dist/summary.d.ts:15

CominsTable

value

comins-table

CominsTable: <TData, TGroup = unknown>(props: (CominsTableProps<TData, TGroup> | CominsTreeTableProps<TData> | CominsViewportTableProps<TData>) & React.RefAttributes<CominsTableRef<TData>>) => React.ReactElement | null

dist/index.d.ts:341

CominsTableCellConfig

type

comins-table

export type CominsTableCellConfig<TData, TValue = unknown> = {
    parseClipboard?: (params: CominsCellComponentPayload<TData, TValue> & {
        text: string;
    }) => TValue;
    /** Validate a typed Fill candidate; false or a thrown error cancels the whole Fill. */
    validateFill?: (params: Omit<CominsCellComponentPayload<TData, TValue>, "value"> & {
        value: unknown;
    }) => boolean | void;
    components?: Array<CominsCellComponent<TData, TValue>>;
    format?: (params: CominsCellComponentPayload<TData, TValue>) => React.ReactNode;
    props?: CominsColumnProps<TData, TValue> | ((params: CominsCellComponentPayload<TData, TValue>) => CominsColumnProps<TData, TValue>);
    /** Return undefined for built-in content, or null to hide content. */
    render?: (params: CominsCellComponentPayload<TData, TValue>) => React.ReactNode;
    /** @deprecated Use cell.render. Retained throughout 0.x; removal target: 1.0.0. */
    renderer?: (params: CominsCellComponentPayload<TData, TValue>) => React.ReactNode;
    tooltip?: string | ((params: CominsCellComponentPayload<TData, TValue>) => React.ReactNode) | {
        /** Informational content shown on hover/focus. Interactive popovers are not supported. */
        render?: (params: CominsCellComponentPayload<TData, TValue>) => React.ReactNode;
    };
};

dist/react-types.d.ts:193

CominsTableColumn

type

comins-tablecomins-table/core

export type CominsTableColumn<TData, TValue = unknown> = {
    cell?: CominsTableCellConfig<TData, TValue>;
    field: string;
    filter?: CominsColumnFilterConfig<TData, TValue>;
    header?: CominsTableHeaderConfig<TData, TValue>;
    hidden?: boolean;
    id?: string;
    label: React.ReactNode;
    lockPosition?: boolean;
    maxWidth?: number;
    minWidth?: number;
    pinned?: CominsColumnPinned;
    sort?: boolean | ((left: TValue, right: TValue, leftRow: TData, rightRow: TData) => number);
    width?: number;
};

export type CominsTableColumn<TData, TValue = unknown> = {
    cell?: CoreCellDataConfig<TData, TValue>;
    field: string;
    filter?: CominsColumnFilterConfig<TData, TValue>;
    hidden?: boolean;
    id?: string;
    label: string;
    lockPosition?: boolean;
    maxWidth?: number;
    minWidth?: number;
    pinned?: CominsColumnPinned;
    sort?: boolean | ((left: TValue, right: TValue, leftRow: TData, rightRow: TData) => number);
    width?: number;
};

dist/react-types.d.ts:221 · dist/core/model.d.ts:61

CominsTableColumnGroup

type

comins-tablecomins-table/core

export type CominsTableColumnGroup = {
    children: string[];
    hidden?: boolean;
    id: string;
    label: React.ReactNode;
    lockPosition?: boolean;
    pinned?: CominsColumnPinned;
};

export type CominsTableColumnGroup = {
    children: string[];
    hidden?: boolean;
    id: string;
    label: string;
    lockPosition?: boolean;
    pinned?: CominsColumnPinned;
};

dist/react-types.d.ts:236 · dist/core/model.d.ts:75

CominsTableComponentOption

type

comins-table

export type CominsTableComponentOption = {
    disabled?: boolean;
    label: React.ReactNode;
    value: CominsComponentPrimitiveValue;
};

dist/react-types.d.ts:17

CominsTableComponentProps

type

comins-table

export type CominsTableComponentProps<TPayload, TProps> = TProps | ((payload: TPayload) => TProps);

dist/react-types.d.ts:76

CominsTableDensity

type

comins-tablecomins-table/core

export type CominsTableDensity = "comfortable" | "compact" | "spacious";

dist/model.d.ts:3

CominsTableGroupTransferDetails

type

comins-table

export type CominsTableGroupTransferDetails<TData, TGroup> = {
    conflicts: readonly CominsTableTransferResolvedConflict<TData, TGroup>[];
    kind: "group";
    position: CominsTableTransferDropPosition;
    sourceGroupId: CominsRowId;
    targetGroupId?: CominsRowId;
};

dist/core/transfer/policy.d.ts:83

CominsTableHeaderConfig

type

comins-table

export type CominsTableHeaderConfig<TData, TValue = unknown> = {
    components?: Array<CominsHeaderComponent<TData, TValue>>;
    props?: React.ThHTMLAttributes<HTMLTableCellElement>;
    /** Return undefined for built-in content, or null to hide content. */
    render?: (params: CominsHeaderComponentPayload<TData, TValue>) => React.ReactNode;
    /** @deprecated Use header.render. Retained throughout 0.x; removal target: 1.0.0. */
    renderer?: (params: CominsHeaderComponentPayload<TData, TValue>) => React.ReactNode;
};

dist/react-types.d.ts:213

CominsTableMenuItem

type

comins-table

export type CominsTableMenuItem = {
    disabled?: boolean;
    label: React.ReactNode;
    type?: "item";
    value: CominsComponentPrimitiveValue;
} | {
    label: React.ReactNode;
    type: "label";
} | {
    type: "divider";
};

dist/react-types.d.ts:29

CominsTableMenuItems

type

comins-table

export type CominsTableMenuItems<TPayload> = CominsTableMenuItem[] | ((payload: TPayload) => CominsTableMenuItem[]);

dist/react-types.d.ts:78

CominsTableOptions

type

comins-table

export type CominsTableOptions<TPayload> = CominsTableComponentOption[] | ((payload: TPayload) => CominsTableComponentOption[]);

dist/react-types.d.ts:77

cominsTablePackage

value

comins-table

cominsTablePackage = "comins-table"

dist/index.d.ts:342

CominsTableProps

type

comins-table

export type CominsTableProps<TData, TGroup = unknown> = (CominsFilteredGroupedTableProps<TData, TGroup> | CominsFilteredTableProps<TData> | CominsGroupedTableProps<TData, TGroup> | CominsUngroupedTableProps<TData>) & CominsRowDetailProps<TData>;

dist/index.d.ts:268

CominsTableRef

type

comins-table

export type CominsTableRef<TData = unknown> = {
    copySelection: (target?: CominsCopyTarget) => Promise<string | null>;
    fillSelection: (direction: "down" | "right") => boolean;
    getSelectedRows: () => TData[];
    getSelectedCells: () => CominsSelectedCell[];
    getSelection: () => CominsSelectionState;
    clearSort: () => void;
    expand: (nodeIds?: readonly CominsRowId[]) => void;
    expandGroups: (groupIds?: readonly CominsRowId[]) => void;
    fold: (nodeIds?: readonly CominsRowId[]) => void;
    foldGroups: (groupIds?: readonly CominsRowId[]) => void;
    getColumnLayout: () => CominsColumnLayout;
    getSortModel: () => CominsSortModel;
    getSortState: () => CominsSortState | null;
    setColumnLayout: (layout: CominsColumnLayout) => void;
    setMoveTargetRow: (targetIdx: number, sourceIdx: number) => void;
    setSelectedRow: (index: number) => void;
    setSelectedRows: (indexes: number[]) => void;
    setSortModel: (sortModel: CominsSortModel) => void;
    setSortState: (sort: CominsSortState | null) => void;
};

dist/index.d.ts:108

CominsTableRowProps

type

comins-table

export type CominsTableRowProps<TData> = {
    className?: CominsRowPropValue<TData, CominsClassValue>;
    disabled?: CominsRowPropValue<TData, boolean | undefined>;
    /** Row dragging is opt-in. False or undefined hides the drag handle. */
    draggable?: CominsRowPropValue<TData, boolean | undefined>;
    style?: CominsRowPropValue<TData, React.CSSProperties | undefined>;
};

dist/index.d.ts:43

CominsTableRowTransferDetails

type

comins-table

export type CominsTableRowTransferDetails<TData, TGroup> = {
    conflicts: readonly CominsTableTransferResolvedConflict<TData, TGroup>[];
    kind: "row";
    sourceRowId: CominsRowId;
    targetGroupId?: CominsRowId;
    targetRowId?: CominsRowId;
};

dist/core/transfer/policy.d.ts:76

CominsTableRuntimeColumn

type

comins-tablecomins-table/core

export type CominsTableRuntimeColumn<TData, TValue = unknown> = Omit<CominsTableColumn<TData, TValue>, "id"> & {
    id: string;
};

dist/react-types.d.ts:244 · dist/core/model.d.ts:83

CominsTableRuntimeColumnGroup

type

comins-tablecomins-table/core

export type CominsTableRuntimeColumnGroup = Omit<CominsTableColumnGroup, "children"> & {
    children: string[];
};

export type CominsTableRuntimeColumnGroup = CominsTableColumnGroup;

dist/react-types.d.ts:247 · dist/core/model.d.ts:86

CominsTableState

type

comins-tablecomins-table/core

export type CominsTableState<TData> = {
    columnOrder: string[];
    columnGroups: CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
    columns: Array<CominsTableRuntimeColumn<TData>>;
    columnState: Record<string, CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    selection: CominsSelectionState;
    showHeader: boolean;
    sort: CominsSortState | null;
    sortModel: CominsSortModel;
    theme: CominsTableTheme;
};

export type CominsTableState<TData> = {
    columnOrder: string[];
    columnGroups: CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
    columns: CominsTableRuntimeColumn<TData>[];
    columnState: Record<string, CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    selection: CominsSelectionState;
    showHeader: boolean;
    sort: CominsSortState | null;
    sortModel: CominsSortModel;
};

dist/react-types.d.ts:257 · dist/core/model.d.ts:88

CominsTableStateInput

type

comins-tablecomins-table/core

export type CominsTableStateInput<TData> = {
    columnLayout?: Partial<CominsColumnLayout>;
    columnGroups?: ReadonlyArray<CominsTableColumnGroup>;
    columns: ReadonlyArray<CominsTableColumn<TData>>;
    getRowId?: (row: TData, index: number) => CominsRowId;
    pagination?: Partial<CominsPaginationState>;
    rows: readonly TData[];
    showHeader?: boolean;
    sort?: CominsSortState | null;
    sortModel?: CominsSortModel;
    theme?: CominsTableTheme;
};

export type CominsTableStateInput<TData> = {
    columnLayout?: Partial<CominsColumnLayout>;
    columnGroups?: readonly CominsTableColumnGroup[];
    columns: readonly CominsTableColumn<TData>[];
    getRowId?: (row: TData, index: number) => CominsRowId;
    pagination?: Partial<CominsPaginationState>;
    rows: readonly TData[];
    showHeader?: boolean;
    sort?: CominsSortState | null;
    sortModel?: CominsSortModel;
};

dist/react-types.d.ts:273 · dist/core/model.d.ts:103

CominsTableSummaryConfig

type

comins-table

export type CominsTableSummaryConfig<TData> = {
    className?: string;
    columns: Partial<Record<string, CominsSummaryColumn<TData>>>;
    label?: React.ReactNode;
    style?: React.CSSProperties;
};

dist/summary.d.ts:28

CominsTableTheme

type

comins-table

export type CominsTableTheme = {
    className?: string;
    density?: CominsTableDensity;
    style?: React.CSSProperties;
};

dist/react-types.d.ts:5

CominsTableTransferConfig

type

comins-table

export type CominsTableTransferConfig<TData, TGroup = never> = {
    canTransfer?: (intent: CominsTableTransferIntent<TData, TGroup>) => boolean;
    coordinator: CominsTableTransferCoordinator<TData, TGroup>;
    rejectionFeedback?: false | CominsTableTransferRejectionFeedback<TData, TGroup>;
    resolveConflict?: CominsTableTransferConflictResolver<TData, TGroup>;
    scope: string;
    tableId: string;
};

dist/react/table-transfer.d.ts:20

CominsTableTransferConflict

type

comins-table

export type CominsTableTransferConflict<TData, TGroup> = {
    kind: "row";
    rowId: CominsRowId;
    source: CominsTableTransferRowEndpoint<TData>;
    target: CominsTableTransferRowEndpoint<TData>;
} | {
    groupId: CominsRowId;
    kind: "group";
    source: CominsTableTransferGroupEndpoint<TData, TGroup>;
    target: CominsTableTransferGroupEndpoint<TData, TGroup>;
};

dist/core/transfer/policy.d.ts:17

CominsTableTransferConflictPolicy

type

comins-table

export type CominsTableTransferConflictPolicy = "overwrite" | "reject";

dist/core/transfer/policy.d.ts:2

CominsTableTransferConflictResolver

type

comins-table

export type CominsTableTransferConflictResolver<TData, TGroup> = (conflict: CominsTableTransferConflict<TData, TGroup>) => CominsTableTransferConflictPolicy | undefined;

dist/core/transfer/policy.d.ts:32

CominsTableTransferCoordinator

type

comins-table

export type CominsTableTransferCoordinator<TData, TGroup = never> = {
    readonly [cominsTableTransferCoordinatorBrand]: (data: TData, group: TGroup) => [TData, TGroup];
};

dist/react/table-transfer.d.ts:13

CominsTableTransferCoordinatorOptions

type

comins-table

export type CominsTableTransferCoordinatorOptions<TData, TGroup = never> = {
    onTransfer: (result: CominsTableTransferResult<TData, TGroup>) => void;
    onTransferRejected?: (rejection: CominsTableTransferRejection<TData, TGroup>) => void;
};

dist/react/table-transfer.d.ts:16

CominsTableTransferDetails

type

comins-table

export type CominsTableTransferDetails<TData, TGroup> = CominsTableGroupTransferDetails<TData, TGroup> | CominsTableRowTransferDetails<TData, TGroup>;

dist/core/transfer/policy.d.ts:90

CominsTableTransferDropPosition

type

comins-table

export type CominsTableTransferDropPosition = "after" | "append" | "before";

dist/core/transfer/policy.d.ts:3

CominsTableTransferEndpoint

type

comins-table

export type CominsTableTransferEndpoint<TData, TGroup = never> = {
    data: readonly TData[];
    getGroupId?: (group: TGroup) => CominsRowId;
    getRowGroupId?: (row: TData, dataIndex: number) => CominsRowId;
    getRowId: (row: TData, dataIndex: number) => CominsRowId;
    groups?: readonly TGroup[];
    setRowGroupId?: (params: {
        fromGroupId: CominsRowId;
        row: TData;
        rowId: CominsRowId;
        toGroupId: CominsRowId;
    }) => TData;
    tableId: string;
};

dist/core/transfer/policy.d.ts:57

CominsTableTransferGroupEndpoint

type

comins-table

export type CominsTableTransferGroupEndpoint<TData, TGroup> = {
    group: TGroup;
    groupId: CominsRowId;
    groupIndex: number;
    rows: readonly CominsTableTransferRowEndpoint<TData>[];
    tableId: string;
};

dist/core/transfer/policy.d.ts:10

CominsTableTransferIntent

type

comins-table

export type CominsTableTransferIntent<TData, TGroup> = {
    kind: "row";
    row: TData;
    sourceRowId: CominsRowId;
    sourceTableId: string;
    targetGroupId?: CominsRowId;
    targetRowId?: CominsRowId;
    targetTableId: string;
} | {
    group: TGroup;
    kind: "group";
    rows: readonly TData[];
    sourceGroupId: CominsRowId;
    sourceTableId: string;
    targetGroupId?: CominsRowId;
    targetTableId: string;
};

dist/core/transfer/policy.d.ts:33

CominsTableTransferRejection

type

comins-table

export type CominsTableTransferRejection<TData, TGroup = never> = {
    conflict: CominsTableTransferConflict<TData, TGroup>;
    kind: "group" | "row";
    reason: "duplicate-id";
    sourceTableId: string;
    targetTableId: string;
};

dist/core/transfer/policy.d.ts:50

CominsTableTransferRejectionFeedback

type

comins-table

export type CominsTableTransferRejectionFeedback<TData, TGroup = never> = {
    duration?: number;
    tooltip?: {
        render?: (rejection: CominsTableTransferRejection<TData, TGroup>) => React.ReactNode;
    };
    /** @deprecated Use tooltip.render. Retained throughout 0.x; removal target: 1.0.0. */
    renderTooltip?: (rejection: CominsTableTransferRejection<TData, TGroup>) => React.ReactNode;
};

dist/react/table-transfer.d.ts:4

CominsTableTransferResolvedConflict

type

comins-table

export type CominsTableTransferResolvedConflict<TData, TGroup> = {
    conflict: CominsTableTransferConflict<TData, TGroup>;
    policy: CominsTableTransferConflictPolicy;
};

dist/core/transfer/policy.d.ts:28

CominsTableTransferResult

type

comins-table

export type CominsTableTransferResult<TData, TGroup = never> = {
    details: CominsTableTransferDetails<TData, TGroup>;
    kind: "group" | "row";
    source: CominsTableTransferNextEndpoint<TData, TGroup>;
    target: CominsTableTransferNextEndpoint<TData, TGroup>;
};

dist/core/transfer/policy.d.ts:91

CominsTableTransferRowEndpoint

type

comins-table

export type CominsTableTransferRowEndpoint<TData> = {
    dataIndex: number;
    row: TData;
    rowId: CominsRowId;
    tableId: string;
};

dist/core/transfer/policy.d.ts:4

CominsToggleComponentConfig

type

comins-table

export type CominsToggleComponentConfig<TPayload> = {
    onCheckedChange?: (payload: TPayload & {
        checked: boolean;
    }) => void;
    props?: CominsTableComponentProps<TPayload, React.ButtonHTMLAttributes<HTMLButtonElement> & {
        checked?: boolean;
    }>;
    type: "toggle";
};

dist/react-types.d.ts:124

CominsTreeDropContext

type

comins-table

export type CominsTreeDropContext<TItem> = {
    source: CominsVisibleTreeRow<TItem>;
    target: CominsVisibleTreeRow<TItem>;
    destination: CominsTreeMoveDestination;
    position: CominsTreeDropPosition;
};

dist/tree.d.ts:15

CominsTreeDropPosition

type

comins-table

export type CominsTreeDropPosition = "before" | "after" | "inside";

dist/tree.d.ts:14

CominsTreeExpansionOptions

type

comins-table

export type CominsTreeExpansionOptions = {
    defaultExpandAll?: boolean;
};

dist/tree.d.ts:7

CominsTreeMoveDestination

type

comins-table

export type CominsTreeMoveDestination = {
    parentId: CominsRowId | null;
    beforeRowId: CominsRowId | null;
};

dist/tree.d.ts:10

CominsTreeNode

type

comins-table

export type CominsTreeNode<TItem> = {
    children?: readonly CominsTreeNode<TItem>[];
    expand?: boolean;
    item: TItem;
};

dist/tree.d.ts:2

CominsTreeRowDragConfig

type

comins-table

export type CominsTreeRowDragConfig<TItem> = {
    allowReparent?: boolean;
    canDrop?: (context: CominsTreeDropContext<TItem>) => boolean;
};

dist/tree.d.ts:21

CominsTreeRowDragPayload

type

comins-table

export type CominsTreeRowDragPayload<T> = {
    event: PointerEvent | KeyboardEvent;
    row: CominsEventRow<T>;
    target: CominsRowDragTarget;
};

dist/tree-drag.d.ts:9

CominsTreeSlotParams

type

comins-table

export type CominsTreeSlotParams<TData> = CominsVisibleTreeRow<TData> & {
    defaultContent: React.ReactNode;
};

dist/index.d.ts:269

CominsTreeSlots

type

comins-table

export type CominsTreeSlots<TData> = {
    /** Prefer { render }. Direct callbacks remain in 0.x; removal target: 1.0.0. */
    leading?: ((params: CominsTreeSlotParams<TData>) => React.ReactNode) | {
        render?: (params: CominsTreeSlotParams<TData>) => React.ReactNode;
    };
    /** Prefer { render }. Direct callbacks remain in 0.x; removal target: 1.0.0. */
    content?: ((params: CominsTreeSlotParams<TData>) => React.ReactNode) | {
        render?: (params: CominsTreeSlotParams<TData>) => React.ReactNode;
    };
    /** Prefer { render }. Direct callbacks remain in 0.x; removal target: 1.0.0. */
    trailing?: ((params: CominsTreeSlotParams<TData>) => React.ReactNode) | {
        render?: (params: CominsTreeSlotParams<TData>) => React.ReactNode;
    };
};

dist/index.d.ts:272

CominsTreeTableProps

type

comins-table

export type CominsTreeTableProps<TData> = Omit<CominsFlatTableBaseProps<TData>, "data" | "columnFiltering" | "getRowId" | "hasMoreRows" | "infiniteScroll" | "infiniteScrollThreshold" | "lazyLoad" | "lazyLoadBatchSize" | "lazyLoadMode" | "lazyLoadThreshold" | "loadingMore" | "onChangeData" | "onLazyLoad" | "onLoadMore" | "onAfterDragRow" | "onBeforeRowDrag" | "onRowDrag" | "pagination" | "rowProps" | "rowGrouping" | "tableTransfer" | "estimatedRowDetailHeight" | "expandedRowIds" | "getRowDetailHeight" | "isRowExpandable" | "onChangeExpandedRowIds" | "renderRowDetail" | "rowDetail" | "tree" | "treeSlots"> & {
    data: readonly CominsTreeNode<TData>[];
    columnFiltering?: never;
    defaultExpandAll?: boolean;
    getRowId: (item: TData, index: number) => CominsRowId;
    hasMoreRows?: never;
    infiniteScroll?: never;
    infiniteScrollThreshold?: never;
    lazyLoad?: never;
    lazyLoadBatchSize?: never;
    lazyLoadMode?: never;
    lazyLoadThreshold?: never;
    loadingMore?: never;
    onChangeData?: (data: CominsTreeNode<TData>[]) => void;
    onLazyLoad?: never;
    onLoadMore?: never;
    onAfterDragRow?: (payload: CominsAfterTreeRowDragPayload<TData>) => void;
    onBeforeRowDrag?: (payload: CominsBeforeTreeRowDragPayload<TData>) => boolean | void;
    onRowDrag?: (payload: CominsTreeRowDragPayload<TData>) => void;
    pagination?: never;
    rowProps?: CominsTableRowProps<TData>;
    treeRowDrag?: CominsTreeRowDragConfig<TData>;
    treeSlots?: CominsTreeSlots<TData>;
    estimatedRowDetailHeight?: never;
    expandedRowIds?: never;
    getRowDetailHeight?: never;
    isRowExpandable?: never;
    onChangeExpandedRowIds?: never;
    renderRowDetail?: never;
    rowDetail?: never;
    rowGrouping?: never;
    tableTransfer?: never;
    tree: true;
};

dist/index.d.ts:286

CominsValueFilterActions

type

comins-table

export type CominsValueFilterActions = {
    setQuery: (query: string) => void;
    setOptionSelected: (id: string, checked: boolean) => void;
    setVisibleSelected: (checked: boolean) => void;
    clear: () => void;
    close: () => void;
};

dist/react/value-filter-types.d.ts:26

CominsValueFilterOptionRenderParams

type

comins-table

export type CominsValueFilterOptionRenderParams<TData> = {
    column: CominsTableRuntimeColumn<TData>;
    option: CominsColumnFilterOption;
    query: string;
    readOnly: boolean;
};

dist/react/value-filter-types.d.ts:33

CominsValueFilterPanelRenderParams

type

comins-table

export type CominsValueFilterPanelRenderParams<TData> = CominsColumnFilterOptionsResult & {
    column: CominsTableRuntimeColumn<TData>;
    query: string;
    readOnly: boolean;
    actions: CominsValueFilterActions;
    getSearchInputProps: (options?: CominsFilterNativeOptions<HTMLInputElement, React.InputHTMLAttributes<HTMLInputElement>>) => CominsFilterBinding<HTMLInputElement, React.InputHTMLAttributes<HTMLInputElement>>;
    getOptionProps: {
        (option: CominsColumnFilterOption, options?: CominsFilterNativeOptions<HTMLInputElement, React.InputHTMLAttributes<HTMLInputElement>>): CominsFilterBinding<HTMLInputElement, React.InputHTMLAttributes<HTMLInputElement>>;
        <TElement extends HTMLElement = HTMLElement>(option: CominsColumnFilterOption, options: CominsFilterCustomOptions<TElement>): CominsFilterBinding<TElement, React.HTMLAttributes<TElement>>;
    };
    getOptionContainerProps: (option: CominsColumnFilterOption, options?: {
        props?: React.HTMLAttributes<HTMLElement>;
    }) => React.HTMLAttributes<HTMLElement>;
    getSelectAllProps: CominsFilterCheckboxGetter;
    getClearProps: (options?: CominsFilterNativeOptions<HTMLButtonElement, React.ButtonHTMLAttributes<HTMLButtonElement>>) => CominsFilterBinding<HTMLButtonElement, React.ButtonHTMLAttributes<HTMLButtonElement>>;
    getCloseProps: CominsValueFilterPanelRenderParams<TData>["getClearProps"];
    renderOption: (option: CominsColumnFilterOption) => React.ReactNode;
};

dist/react/value-filter-types.d.ts:49

CominsValueFilterPart

type

comins-table

export type CominsValueFilterPart<TParams> = {
    /** undefined selects built-in content; null/false/empty string clears this render region. */
    render?: (params: TParams) => React.ReactNode;
    props?: {
        className?: string;
        style?: React.CSSProperties;
    } | ((params: TParams) => {
        className?: string;
        style?: React.CSSProperties;
    });
};

dist/react/value-filter-types.d.ts:67

CominsValueFilterTriggerRenderParams

type

comins-table

export type CominsValueFilterTriggerRenderParams<TData> = {
    column: CominsTableRuntimeColumn<TData>;
    columnLabel: string;
    open: boolean;
    active: boolean;
    readOnly: boolean;
    canOpen: boolean;
    selection?: CominsColumnFilterOptionsResult;
    getTriggerProps: CominsFilterButtonGetter;
};

dist/react/value-filter-types.d.ts:39

CominsViewportBlock

type

comins-table

export type CominsViewportBlock<T> = {
    startIndex: number;
    rows: readonly T[];
    version: number;
    touched: number;
};

dist/core/viewport/data.d.ts:11

CominsViewportData

type

comins-table

export type CominsViewportData<T> = {
    revision: CominsViewportRevision;
    rowCount: number;
    blockSize: number;
    cacheSize: number;
    blocks: readonly CominsViewportBlock<T>[];
    requests: readonly CominsViewportRequestState[];
    retainRange: CominsViewportRange;
    version: number;
    clock: number;
    changes: readonly CominsViewportPatch<T>[];
};

dist/core/viewport/data.d.ts:26

CominsViewportDataEvent

type

comins-table

export type CominsViewportDataEvent<T> = BrowserViewportDataEvent<T>;

dist/viewport-data.d.ts:7

CominsViewportDataOptions

type

comins-table

export type CominsViewportDataOptions = {
    revision: CominsViewportRevision;
    rowCount: number;
    blockSize?: number;
    cacheSize?: number;
};

dist/core/viewport/data.d.ts:38

CominsViewportDatasource

type

comins-table

export type CominsViewportDatasource = {
    revision: CominsViewportRevision;
    maxConcurrentRequests?: number;
    heightCacheSize?: number;
};

dist/use-viewport.d.ts:2

CominsViewportOptions

type

comins-table

export type CominsViewportOptions<T> = {
    rowCount: number;
    queryKey: CominsViewportRevision;
    getRows: (request: CominsViewportRequest) => readonly T[] | Promise<readonly T[]>;
    blockSize?: number;
    cacheSize?: number;
    maxConcurrentRequests?: number;
    heightCacheSize?: number;
    onEdit?: (changes: readonly CominsViewportPatch<T>[]) => void;
};

dist/use-viewport.d.ts:7

CominsViewportPatch

type

comins-table

export type CominsViewportPatch<T> = {
    index: number;
    row: T;
};

dist/core/viewport/data.d.ts:22

CominsViewportRange

type

comins-table

export type CominsViewportRange = {
    startIndex: number;
    endIndex: number;
};

dist/core/viewport/data.d.ts:2

CominsViewportRequest

type

comins-table

export type CominsViewportRequest = CoreViewportRequest & {
    signal: AbortSignal;
};

dist/browser/viewport-requests.d.ts:2

CominsViewportRequestState

type

comins-table

export type CominsViewportRequestState = CominsViewportRange & {
    requestId: string;
    status: "loading" | "error";
    version: number;
};

dist/core/viewport/data.d.ts:17

CominsViewportRevision

type

comins-table

export type CominsViewportRevision = string | number;

dist/core/viewport/data.d.ts:1

CominsViewportTableProps

type

comins-table

export type CominsViewportTableProps<TData> = Omit<CominsFlatTableBaseProps<TData>, "data" | "getRowId" | "onChangeData" | "viewportDatasource" | "virtualized" | "pagination" | "lazyLoad" | "infiniteScroll" | "hasMoreRows" | "loadingMore" | "onLazyLoad" | "onLoadMore" | "summary" | "onBeforeRowDrag" | "onRowDrag" | "onAfterDragRow"> & {
    data: CominsViewportData<TData>;
    viewportDatasource: CominsViewportDatasource;
    getRowId: (row: TData, index: number) => CominsRowId;
    onViewportRequest: (request: CominsViewportRequest) => void | Promise<void>;
    onChangeData?: (data: CominsViewportData<TData>) => void;
    virtualized?: true;
    pagination?: never;
    lazyLoad?: never;
    infiniteScroll?: never;
    hasMoreRows?: never;
    loadingMore?: never;
    onLazyLoad?: never;
    onLoadMore?: never;
    summary?: never;
    rowGrouping?: never;
    columnFiltering?: never;
    tableTransfer?: never;
    renderRowDetail?: never;
    rowDetail?: never;
};

dist/index.d.ts:320

CominsVirtualListComponentConfig

type

comins-table

export type CominsVirtualListComponentConfig<TPayload> = {
    items: CominsVirtualListItems<TPayload>;
    onClickItem?: (payload: TPayload & {
        event: React.MouseEvent<HTMLButtonElement> | React.KeyboardEvent<HTMLButtonElement>;
        item: CominsVirtualListItem;
        itemIndex: number;
        value: CominsComponentPrimitiveValue;
    }) => void;
    onContextMenuItem?: (payload: TPayload & {
        event: React.MouseEvent<HTMLButtonElement>;
        item: CominsVirtualListItem;
        itemIndex: number;
        value: CominsComponentPrimitiveValue;
    }) => void;
    props?: CominsTableComponentProps<TPayload, React.HTMLAttributes<HTMLDivElement> & {
        height?: number | string;
        itemHeight?: number;
        limit?: number;
        more?: boolean;
        searchable?: boolean;
    }>;
    searchFilter?: (payload: CominsVirtualListSearchFilterPayload) => boolean;
    type: "virtual-list";
};

dist/react-types.d.ts:165

CominsVirtualListItem

type

comins-table

export type CominsVirtualListItem<TItem = unknown> = {
    data?: TItem;
    disabled?: boolean;
    label: React.ReactNode;
    searchText?: string;
    value: CominsComponentPrimitiveValue;
};

dist/react-types.d.ts:22

CominsVirtualListItems

type

comins-table

export type CominsVirtualListItems<TPayload> = Array<CominsVirtualListItem> | ((payload: TPayload) => Array<CominsVirtualListItem>);

dist/react-types.d.ts:79

CominsVirtualListSearchFilterPayload

type

comins-table

export type CominsVirtualListSearchFilterPayload = {
    item: CominsVirtualListItem;
    itemIndex: number;
    value: string;
};

dist/react-types.d.ts:160

CominsVirtualRows

type

comins-tablecomins-table/core

export type CominsVirtualRows<TData> = {
    bottomSpacerHeight: number;
    endIndex: number;
    rows: TData[];
    startIndex: number;
    topSpacerHeight: number;
    totalHeight: number;
};

dist/model.d.ts:60

CominsVirtualRowsOptions

type

comins-tablecomins-table/core

export type CominsVirtualRowsOptions = {
    overscan?: number;
    rowHeight: number;
    scrollTop: number;
    viewportHeight: number;
};

dist/model.d.ts:54

CominsVisibleTreeRow

type

comins-table

export type CominsVisibleTreeRow<TItem> = {
    depth: number;
    expanded: boolean;
    hasChildren: boolean;
    item: TItem;
    path: readonly number[];
    rowId: CominsRowId;
};

dist/tree.d.ts:25

CominsXlsxCellStyle

type

comins-table/xlsx

export type CominsXlsxCellStyle = {
    fontFamily?: string;
    fontSize?: number;
    fontWeight?: "bold";
    fontStyle?: "italic";
    textColor?: string;
    backgroundColor?: string;
    borderColor?: string;
    borderStyle?: "thin" | "medium" | "thick";
    align?: "left" | "center" | "right";
    alignVertical?: "top" | "center" | "bottom";
    wrap?: boolean;
    format?: string;
};

dist/core/editing/xlsx-model.d.ts:23

CominsXlsxCellValue

type

comins-table/xlsx

export type CominsXlsxCellValue = string | number | boolean | null;

dist/core/editing/xlsx-model.d.ts:2

CominsXlsxError

value

comins-table/xlsx

export declare class CominsXlsxError extends Error {
    readonly code: CominsXlsxErrorCode;
    readonly sheetName?: string;
    readonly cellAddress?: string;
    readonly rowNumber?: number;
    readonly sheetNames?: readonly string[];
    constructor(code: CominsXlsxErrorCode, location?: XlsxErrorLocation);
}

dist/xlsx/errors.d.ts:3

CominsXlsxErrorCode

type

comins-table/xlsx

export type CominsXlsxErrorCode = "INVALID_OPTIONS" | "UNSUPPORTED_FILE" | "INVALID_WORKBOOK" | "LIMIT_EXCEEDED" | "SHEET_SELECTION_REQUIRED" | "SHEET_NOT_FOUND" | "MERGED_CELLS" | "MISSING_FORMULA_RESULT" | "CELL_ERROR" | "UNSUPPORTED_VALUE";

dist/core/editing/xlsx-model.d.ts:63

CominsXlsxExportOptions

type

comins-table/xlsx

export type CominsXlsxExportOptions<TData> = Omit<CominsExportRowsOptions<TData>, "metadata"> & {
    metadata?: never;
    sheetName?: string;
    maxCells?: number;
    styles?: CominsXlsxExportStyles;
};

dist/core/editing/xlsx-model.d.ts:50

CominsXlsxExportStyles

type

comins-table/xlsx

export type CominsXlsxExportStyles = {
    theme?: "comins" | "plain";
    header?: CominsXlsxCellStyle;
    body?: CominsXlsxCellStyle;
    headerHeight?: number;
    rowHeight?: number;
    /** Keys are column ids, independent of exported column order. Width is in characters. */
    columns?: Readonly<Record<string, {
        width?: number;
        header?: CominsXlsxCellStyle;
        body?: CominsXlsxCellStyle;
    }>>;
};

dist/core/editing/xlsx-model.d.ts:37

CominsXlsxImportLimits

type

comins-table/xlsx

export type CominsXlsxImportLimits = {
    maxBytes?: number;
    maxUncompressedBytes?: number;
    maxCells?: number;
};

dist/core/editing/xlsx-model.d.ts:9

CominsXlsxImportOptions

type

comins-table/xlsx

export type CominsXlsxImportOptions<TData> = {
    bytes: Uint8Array | ArrayBuffer;
    sheetName?: string;
    hasHeader?: boolean;
    limits?: CominsXlsxImportLimits;
    mapRow: (row: CominsXlsxImportRow) => TData;
};

dist/core/editing/xlsx-model.d.ts:14

CominsXlsxImportRow

type

comins-table/xlsx

export type CominsXlsxImportRow = {
    cells: readonly CominsXlsxCellValue[];
    headers: readonly string[] | null;
    rowIndex: number;
    sheetRowNumber: number;
};

dist/core/editing/xlsx-model.d.ts:3

CominsXlsxInspectOptions

type

comins-table/xlsx

export type CominsXlsxInspectOptions = Pick<CominsXlsxImportOptions<unknown>, "bytes" | "limits">;

dist/core/editing/xlsx-model.d.ts:21

CominsXlsxSheetInfo

type

comins-table/xlsx

export type CominsXlsxSheetInfo = {
    name: string;
    visibility: "visible" | "hidden" | "veryHidden";
};

dist/core/editing/xlsx-model.d.ts:56

CominsXlsxWorkbookInfo

type

comins-table/xlsx

export type CominsXlsxWorkbookInfo = {
    sheets: readonly CominsXlsxSheetInfo[];
};

dist/core/editing/xlsx-model.d.ts:60

copyCominsCell

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function copyCominsCell<TData>(state: CominsTableState<TData>, { columnId, rowId }: CominsCellAddress): CominsCopiedCell | null;

dist/react/core-compat.d.ts:135 · dist/core/editing/cells.d.ts:7

copyCominsCellRange

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function copyCominsCellRange<TData>(state: CominsTableState<TData>, range?: CominsCellRange | null, rowIds?: readonly CominsRowId[]): CominsCopiedCellRange | null;

dist/react/core-compat.d.ts:137 · dist/core/editing/clipboard.d.ts:4

copyCominsRow

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function copyCominsRow<TData>(state: CominsTableState<TData>, rowId: CominsRowId): CominsCopiedRow<TData>;

dist/react/core-compat.d.ts:133 · dist/core/editing/clipboard.d.ts:2

createCominsGroupedExportOptions

value

comins-tablecomins-table/core

export declare function createCominsGroupedExportOptions<TData, TGroup>({ rows, groups, getGroupId, getRowGroupId, getRowId, ...options }: CominsExportGroupedOptions<TData, TGroup>): CominsExportRowsOptions<TData>;

dist/core/editing/export-structure.d.ts:5

createCominsTableState

value

comins-tablecomins-table/core

export declare function createCominsTableState<TData>(input: CominsTableStateInput<TData>): CominsTableState<TData>;

export declare function createCominsTableState<TData>({ columnLayout, columnGroups, columns, getRowId, pagination, rows, showHeader, sort, sortModel, }: CominsTableStateInput<TData>): CominsTableState<TData>;

dist/react/core-compat.d.ts:106 · dist/core/state/table.d.ts:23

createCominsTableTransferCoordinator

value

comins-table

export declare function createCominsTableTransferCoordinator<TData, TGroup = never>(options: CominsTableTransferCoordinatorOptions<TData, TGroup>): CominsTableTransferCoordinator<TData, TGroup>;

dist/react/table-transfer.d.ts:38

createCominsTreeExportOptions

value

comins-tablecomins-table/core

export declare function createCominsTreeExportOptions<TData>({ nodes, getRowId, ...options }: CominsExportTreeOptions<TData>): CominsExportRowsOptions<TData>;

dist/core/editing/export-structure.d.ts:3

createCominsViewportData

value

comins-table

export declare function createCominsViewportData<T>(options: CominsViewportDataOptions): CominsViewportData<T>;

dist/core/viewport/data.d.ts:68

deleteCominsRows

value

comins-tablecomins-table/core

export declare function deleteCominsRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]): CominsTableState<TData>;

dist/react/core-compat.d.ts:93 · dist/core/state/table.d.ts:28

exportCominsRowsToCsv

value

comins-tablecomins-table/core

export declare function exportCominsRowsToCsv<TData>({ columnOrder, columns, headerOverrides, rows, metadata, valueSource, }: CominsExportRowsOptions<TData>): string;

dist/core/editing/export.d.ts:2

exportCominsRowsToJson

value

comins-tablecomins-table/core

export declare function exportCominsRowsToJson<TData>({ columnOrder, columns, headerOverrides, rows, metadata, valueSource, }: CominsExportRowsOptions<TData>): string;

dist/core/editing/export.d.ts:3

exportCominsRowsToXlsx

value

comins-table/xlsx

export declare function exportCominsRowsToXlsx<TData>(options: CominsXlsxExportOptions<TData>): Promise<Uint8Array>;

dist/xlsx.d.ts:6

fillCominsCellRange

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function fillCominsCellRange<TData>(state: CominsTableState<TData>, { source, target }: CominsFillCellRangeOptions, rowIds?: readonly CominsRowId[]): CominsTableState<TData>;

dist/react/core-compat.d.ts:140 · dist/core/editing/clipboard.d.ts:7

flattenCominsTree

value

comins-table

export declare function flattenCominsTree<TItem>(nodes: readonly CominsTreeNode<TItem>[], getRowId: (item: TItem, index: number) => CominsRowId, options?: CominsTreeExpansionOptions): CominsVisibleTreeRow<TItem>[];

dist/tree.d.ts:37

formatCominsCellValue

value

comins-table

export declare function formatCominsCellValue<TData>(state: CominsTableState<TData>, row: TData, rowId: CominsRowId, column: CominsTableRuntimeColumn<TData>): import("react").ReactNode;

dist/react/core-compat.d.ts:129

getCominsCellClassName

value

comins-table

export declare function getCominsCellClassName<TData>(state: CominsTableState<TData>, row: TData, rowId: CominsRowId, column: CominsTableRuntimeColumn<TData>): string | undefined;

dist/react/core-compat.d.ts:131

getCominsCellStyle

value

comins-table

export declare function getCominsCellStyle<TData>(state: CominsTableState<TData>, row: TData, rowId: CominsRowId, column: CominsTableRuntimeColumn<TData>): import("react").CSSProperties | undefined;

dist/react/core-compat.d.ts:132

getCominsCellValue

value

comins-tablecomins-table/core

export declare function getCominsCellValue<TData>(state: CominsTableState<TData>, row: TData, columnId: string): unknown;

export declare function getCominsCellValue<TData>(state: {
    columns: readonly {
        id: string;
        field: string;
    }[];
}, row: TData, columnId: string): unknown;

dist/react/core-compat.d.ts:105 · dist/core/state/table.d.ts:71

getCominsColumnFilterOperators

value

comins-table/core

export declare function getCominsColumnFilterOperators(kind: CominsColumnFilterKind): CominsColumnConditionFilterOperator[];

dist/core/rows/filtering.d.ts:55

getCominsColumnFilterOptions

value

comins-tablecomins-table/core

export declare function getCominsColumnFilterOptions<TData>(input: CominsColumnFilterOptionsInput<TData>): valuesCore.CominsColumnFilterOptionsResult | null;

export declare function getCominsColumnFilterOptions<TData>(input: CominsColumnFilterOptionsInput<TData>): CominsColumnFilterOptionsResult | null;

dist/filtering.d.ts:27 · dist/core/rows/values-filter.d.ts:41

getCominsFilteredRowIndexes

value

comins-table/core

export declare function getCominsFilteredRowIndexes<TData>({ columns, model, rows, }: {
    columns: readonly CominsTableRuntimeColumn<TData>[];
    model: unknown;
    rows: readonly CominsColumnFilteringSourceRow<TData>[];
}): number[];

dist/core/rows/filtering.d.ts:60

getCominsHeaderRows

value

comins-tablecomins-table/core

export declare function getCominsHeaderRows<TData>(state: CominsTableState<TData>): Array<Array<CominsHeaderCell<TData>>>;

dist/react/core-compat.d.ts:108 · dist/core/layout/columns.d.ts:68

getCominsPageRows

value

comins-tablecomins-table/core

export declare function getCominsPageRows<TData>(state: CominsTableState<TData>, pagination?: Partial<CominsPaginationState>): NonNullable<TData>[];

dist/react/core-compat.d.ts:101 · dist/core/state/table.d.ts:67

getCominsSelectedCellRange

value

comins-tablecomins-table/corecomins-table/selection

export declare function getCominsSelectedCellRange<TData>(state: CominsTableState<TData>, range?: CominsCellRange | null, rowIds?: readonly CominsRowId[]): CominsCellAddress[];

dist/react/core-compat.d.ts:87 · dist/core/selection/state.d.ts:129

getCominsSortedRowIndexes

value

comins-tablecomins-table/core

export declare function getCominsSortedRowIndexes<TData>(state: CominsTableState<TData>, sourceIndexes?: readonly number[]): number[];

dist/react/core-compat.d.ts:99 · dist/core/state/table.d.ts:65

getCominsSummaryValues

value

comins-table

export declare function getCominsSummaryValues<TData>(rows: readonly TData[], columns: readonly CominsTableRuntimeColumn<TData>[], summary: CominsTableSummaryConfig<TData>): Record<string, React.ReactNode>;

dist/summary.d.ts:38

getCominsTreeLeafItems

value

comins-table

export declare function getCominsTreeLeafItems<TItem>(nodes: readonly CominsTreeNode<TItem>[]): TItem[];

dist/tree.d.ts:38

getCominsVirtualRows

value

comins-tablecomins-table/core

export declare function getCominsVirtualRows<TData>(state: CominsTableState<TData>, { overscan, rowHeight, scrollTop, viewportHeight }: CominsVirtualRowsOptions): CominsVirtualRows<TData>;

dist/react/core-compat.d.ts:102 · dist/core/state/table.d.ts:68

getCominsVisibleColumns

value

comins-tablecomins-table/core

export declare function getCominsVisibleColumns<TData>(state: CominsTableState<TData>): CominsTableRuntimeColumn<TData, unknown>[];

export declare function getCominsVisibleColumns<TData>(state: CominsTableState<TData>): CominsTableRuntimeColumn<TData>[];

dist/react/core-compat.d.ts:107 · dist/core/layout/columns.d.ts:67

importCominsRowsFromCsv

value

comins-tablecomins-table/core

export declare function importCominsRowsFromCsv<TData>({ text, mapRow, hasHeader, maxCharacters, maxCells, }: CominsCsvImportOptions<TData>): TData[];

dist/core/editing/import.d.ts:3

importCominsRowsFromXlsx

value

comins-table/xlsx

export declare function importCominsRowsFromXlsx<TData>(options: CominsXlsxImportOptions<TData>): Promise<TData[]>;

dist/xlsx.d.ts:5

inspectCominsXlsx

value

comins-table/xlsx

export declare function inspectCominsXlsx(options: CominsXlsxInspectOptions): Promise<CominsXlsxWorkbookInfo>;

dist/xlsx.d.ts:4

isCominsCellDisabled

value

comins-tablecomins-table/core

export declare function isCominsCellDisabled<TData>(state: CominsTableState<TData>, row: TData, rowId: CominsRowId, column: CominsTableRuntimeColumn<TData>): boolean;

dist/react/core-compat.d.ts:130 · dist/core/editing/cells.d.ts:6

isCominsCellInSelectedRange

value

comins-tablecomins-table/corecomins-table/selection

export declare function isCominsCellInSelectedRange<TData>(state: CominsTableState<TData>, cell: CominsCellAddress, rowIds?: readonly CominsRowId[]): boolean;

dist/react/core-compat.d.ts:88 · dist/core/selection/state.d.ts:130

isCominsCellSelected

value

comins-tablecomins-table/corecomins-table/selection

export declare function isCominsCellSelected<TData>(state: CominsTableState<TData>, cell: CominsCellAddress): boolean;

export declare function isCominsCellSelected<TData>(state: Pick<CominsTableState<TData>, "selection">, cell: CominsCellAddress): boolean;

dist/react/core-compat.d.ts:86 · dist/core/selection/state.d.ts:128

isCominsRowSelected

value

comins-tablecomins-table/corecomins-table/selection

export declare function isCominsRowSelected<TData>(state: CominsTableState<TData>, rowId: CominsRowId): boolean;

export declare function isCominsRowSelected<TData>(state: Pick<CominsTableState<TData>, "selection">, rowId: CominsRowId): boolean;

dist/react/core-compat.d.ts:85 · dist/core/selection/state.d.ts:127

moveCominsColumn

value

comins-tablecomins-table/core

export declare function moveCominsColumn<TData>(state: CominsTableState<TData>, columnId: string, targetIndex: number): CominsTableState<TData>;

dist/react/core-compat.d.ts:15 · dist/core/layout/columns.d.ts:49

moveCominsColumnGroup

value

comins-tablecomins-table/core

export declare function moveCominsColumnGroup<TData>(state: CominsTableState<TData>, groupId: string, targetIndex: number): CominsTableState<TData>;

dist/react/core-compat.d.ts:16 · dist/core/layout/columns.d.ts:50

moveCominsRow

value

comins-tablecomins-table/core

export declare function moveCominsRow<TData>(state: CominsTableState<TData>, rowId: CominsRowId, targetIndex: number): CominsTableState<TData>;

dist/react/core-compat.d.ts:103 · dist/core/state/table.d.ts:69

moveCominsRowGroup

value

comins-table

export declare function moveCominsRowGroup<TGroup>(input: {
    getGroupId: (group: TGroup) => CominsRowId;
    groups: readonly TGroup[];
    position: CominsRowGroupDropPosition;
    sourceGroupId: CominsRowId;
    targetGroupId: CominsRowId;
}): TGroup[];

dist/core/rows/grouping.d.ts:90

moveCominsRowToGroup

value

comins-tablecomins-table/core

export declare function moveCominsRowToGroup<TData>(state: CominsTableState<TData>, options: CominsRowGroupMoveOptions<TData>): CominsTableState<TData>;

dist/react/core-compat.d.ts:104 · dist/core/state/table.d.ts:70

moveCominsTreeNode

value

comins-table

export declare function moveCominsTreeNode<TItem>(nodes: readonly CominsTreeNode<TItem>[], rowId: CominsRowId, destination: CominsTreeMoveDestination, getRowId: (item: TItem, index: number) => CominsRowId, options?: {
    allowReparent?: boolean;
}): readonly CominsTreeNode<TItem>[];

dist/tree.d.ts:34

normalizeCominsColumnFilterModel

value

comins-table/core

export declare function normalizeCominsColumnFilterModel<TData>({ columns, model, }: {
    columns: readonly CominsTableRuntimeColumn<TData>[];
    model: unknown;
}): CominsNormalizedColumnFilterRule<TData>[];

dist/core/rows/filtering.d.ts:56

parseCominsClipboardText

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function parseCominsClipboardText(text: string): string[][];

dist/clipboard-text.d.ts:4

pasteCominsCell

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function pasteCominsCell<TData>(state: CominsTableState<TData>, { columnId, rowId }: CominsCellAddress, copied: CominsCopiedCell | null): CominsTableState<TData>;

dist/react/core-compat.d.ts:136 · dist/core/editing/cells.d.ts:8

pasteCominsCellRange

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function pasteCominsCellRange<TData>(state: CominsTableState<TData>, target: CominsCellAddress, copied: CominsCopiedCellRange | null, rowIds?: readonly CominsRowId[]): CominsTableState<TData>;

dist/react/core-compat.d.ts:138 · dist/core/editing/clipboard.d.ts:5

pasteCominsRow

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function pasteCominsRow<TData>(state: CominsTableState<TData>, copied: CominsCopiedRow<TData>, options: CominsPasteRowOptions<TData>): CominsTableState<TData>;

dist/react/core-compat.d.ts:134 · dist/core/editing/clipboard.d.ts:3

pasteCominsText

value

comins-tablecomins-table/clipboardcomins-table/core

export declare function pasteCominsText<TData>(state: CominsTableState<TData>, target: CominsCellAddress, text: string, rowIds?: readonly CominsRowId[]): CominsTableState<TData>;

dist/react/core-compat.d.ts:139 · dist/core/editing/clipboard.d.ts:6

queryCominsRows

value

comins-tablecomins-table/core

export declare function queryCominsRows<TData>(state: CominsTableState<TData>, predicate?: (row: TData, index: number) => boolean): TData[];

export declare function queryCominsRows<TData>(state: Pick<CominsTableState<TData>, "rows">, predicate?: (row: TData, index: number) => boolean): TData[];

dist/react/core-compat.d.ts:89 · dist/core/state/table.d.ts:24

reduceCominsViewportData

value

comins-table

export declare function reduceCominsViewportData<T>(data: CominsViewportData<T>, event: CominsViewportDataEvent<T>): CominsViewportData<T>;

dist/viewport-data.d.ts:9

replaceCominsRows

value

comins-tablecomins-table/core

export declare function replaceCominsRows<TData>(state: CominsTableState<TData>, rows: readonly TData[]): CominsTableState<TData>;

dist/react/core-compat.d.ts:90 · dist/core/state/table.d.ts:25

selectCell

value

comins-tablecomins-table/corecomins-table/selection

export declare function selectCell<TData>(state: CominsTableState<TData>, cell: CominsCellAddress, options?: CominsCellSelectionOptions): {
    columnOrder: string[];
    columnGroups: import("./core-compat").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("./core-compat").CominsColumnGroupRuntimeState>;
    columns: CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("./core-compat").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: CominsSortState | null;
    sortModel: CominsSortModel;
    theme: CominsTableTheme;
    selection: {
        rowIds: CominsRowId[];
        cell: CominsCellAddress | null;
        cells: CominsCellAddress[];
        range: null;
    };
};

export declare function selectCell<TData>(state: CominsTableState<TData>, cell: CominsCellAddress, options?: CominsCellSelectionOptions): {
    columnOrder: string[];
    columnGroups: import("../model").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("../model").CominsColumnGroupRuntimeState>;
    columns: import("../model").CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("../model").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: import("../model").CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: import("../model").CominsSortState | null;
    sortModel: import("../model").CominsSortModel;
    selection: {
        rowIds: CominsRowId[];
        cell: CominsCellAddress | null;
        cells: CominsCellAddress[];
        range: null;
    };
};

dist/react/core-compat.d.ts:21 · dist/core/selection/state.d.ts:52

selectCellRange

value

comins-tablecomins-table/corecomins-table/selection

export declare function selectCellRange<TData>(state: CominsTableState<TData>, range: CominsCellRange): {
    columnOrder: string[];
    columnGroups: import("./core-compat").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("./core-compat").CominsColumnGroupRuntimeState>;
    columns: CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("./core-compat").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: CominsSortState | null;
    sortModel: CominsSortModel;
    theme: CominsTableTheme;
    selection: {
        rowIds: CominsRowId[];
        cell: CominsCellAddress;
        cells: never[];
        range: CominsCellRange;
    };
};

export declare function selectCellRange<TData>(state: CominsTableState<TData>, range: CominsCellRange): {
    columnOrder: string[];
    columnGroups: import("../model").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("../model").CominsColumnGroupRuntimeState>;
    columns: import("../model").CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("../model").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: import("../model").CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: import("../model").CominsSortState | null;
    sortModel: import("../model").CominsSortModel;
    selection: {
        rowIds: CominsRowId[];
        cell: CominsCellAddress;
        cells: never[];
        range: CominsCellRange;
    };
};

dist/react/core-compat.d.ts:42 · dist/core/selection/state.d.ts:72

selectRow

value

comins-tablecomins-table/corecomins-table/selection

export declare function selectRow<TData>(state: CominsTableState<TData>, rowId: CominsRowId, options?: CominsRowSelectionOptions): CominsTableState<TData>;

export declare function selectRow<TData>(state: CominsTableState<TData>, rowId: CominsRowId, options?: CominsRowSelectionOptions): {
    columnOrder: string[];
    columnGroups: import("../model").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("../model").CominsColumnGroupRuntimeState>;
    columns: import("../model").CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("../model").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: import("../model").CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: import("../model").CominsSortState | null;
    sortModel: import("../model").CominsSortModel;
    selection: {
        cell: CominsCellAddress | null;
        cells?: CominsCellAddress[];
        range: CominsCellRange | null;
        rowIds: CominsRowId[];
    };
};

dist/react/core-compat.d.ts:19 · dist/core/selection/state.d.ts:11

selectRows

value

comins-tablecomins-table/core

export declare function selectRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]): CominsTableState<TData>;

export declare function selectRows<TData>(state: CominsTableState<TData>, rowIds: readonly CominsRowId[]): {
    columnOrder: string[];
    columnGroups: import("../model").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("../model").CominsColumnGroupRuntimeState>;
    columns: import("../model").CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("../model").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: import("../model").CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    showHeader: boolean;
    sort: import("../model").CominsSortState | null;
    sortModel: import("../model").CominsSortModel;
    selection: {
        cell: CominsCellAddress | null;
        cells?: CominsCellAddress[];
        range: CominsCellRange | null;
        rowIds: CominsRowId[];
    };
};

dist/react/core-compat.d.ts:20 · dist/core/selection/state.d.ts:31

serializeCominsColumnLayout

value

comins-tablecomins-table/core

export declare function serializeCominsColumnLayout<TData>(state: CominsTableState<TData>): CominsColumnLayout;

dist/react/core-compat.d.ts:17 · dist/core/layout/columns.d.ts:51

setCominsColumnFilterValues

value

comins-tablecomins-table/core

export declare function setCominsColumnFilterValues<TData>(input: CominsColumnFilterOptionsInput<TData> & {
    action: CominsColumnFilterValuesAction;
}): core.CominsColumnFilterModel;

export declare function setCominsColumnFilterValues<TData>(input: CominsColumnFilterOptionsInput<TData> & {
    action: CominsColumnFilterValuesAction;
}): CominsColumnFilterModel;

dist/filtering.d.ts:28 · dist/core/rows/values-filter.d.ts:43

setCominsColumnGroupHidden

value

comins-tablecomins-table/core

export declare function setCominsColumnGroupHidden<TData>(state: CominsTableState<TData>, groupId: string, hidden: boolean): CominsTableState<TData>;

dist/react/core-compat.d.ts:13 · dist/core/layout/columns.d.ts:41

setCominsColumnGroupWidth

value

comins-tablecomins-table/core

export declare function setCominsColumnGroupWidth<TData>(state: CominsTableState<TData>, groupId: string, width: number): CominsTableState<TData>;

dist/react/core-compat.d.ts:14 · dist/core/layout/columns.d.ts:47

setCominsColumnHidden

value

comins-tablecomins-table/core

export declare function setCominsColumnHidden<TData>(state: CominsTableState<TData>, columnId: string, hidden: boolean): CominsTableState<TData>;

export declare function setCominsColumnHidden<TData>(state: CominsTableState<TData>, columnId: string, hidden: boolean): {
    columnOrder: string[];
    columnGroups: CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, CominsColumnGroupRuntimeState>;
    columns: CominsTableRuntimeColumn<TData, unknown>[];
    getRowId: (row: TData, index: number) => import("../model").CominsRowId;
    pagination: import("../model").CominsPaginationState;
    rowIds: import("../model").CominsRowId[];
    rows: TData[];
    selection: import("../model").CominsSelectionState;
    showHeader: boolean;
    sort: import("../model").CominsSortState | null;
    sortModel: import("../model").CominsSortModel;
    columnState: {
        [x: string]: CominsColumnRuntimeState | {
            pinned?: CominsColumnPinned;
            width?: number;
            hidden: boolean;
        };
    };
};

dist/react/core-compat.d.ts:12 · dist/core/layout/columns.d.ts:20

setCominsColumnWidth

value

comins-tablecomins-table/core

export declare function setCominsColumnWidth<TData>(state: CominsTableState<TData>, columnId: string, width: number): CominsTableState<TData>;

dist/react/core-compat.d.ts:11 · dist/core/layout/columns.d.ts:19

setCominsHeaderVisible

value

comins-tablecomins-table/core

export declare function setCominsHeaderVisible<TData>(state: CominsTableState<TData>, showHeader: boolean): CominsTableState<TData>;

export declare function setCominsHeaderVisible<TData>(state: CominsTableState<TData>, showHeader: boolean): {
    columnOrder: string[];
    columnGroups: import("../model").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("../model").CominsColumnGroupRuntimeState>;
    columns: CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("../model").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    selection: import("../model").CominsSelectionState;
    sort: CominsSortState | null;
    sortModel: CominsSortModel;
    showHeader: boolean;
};

dist/react/core-compat.d.ts:94 · dist/core/state/table.d.ts:29

setCominsPagination

value

comins-tablecomins-table/core

export declare function setCominsPagination<TData>(state: CominsTableState<TData>, pagination: Partial<CominsPaginationState>): CominsTableState<TData>;

export declare function setCominsPagination<TData>(state: CominsTableState<TData>, pagination: Partial<CominsPaginationState>): {
    columnOrder: string[];
    columnGroups: import("../model").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("../model").CominsColumnGroupRuntimeState>;
    columns: CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("../model").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    rowIds: CominsRowId[];
    rows: TData[];
    selection: import("../model").CominsSelectionState;
    showHeader: boolean;
    sort: CominsSortState | null;
    sortModel: CominsSortModel;
    pagination: {
        pageIndex: number;
        pageSize: number;
    };
};

dist/react/core-compat.d.ts:95 · dist/core/state/table.d.ts:44

setCominsSortModel

value

comins-tablecomins-table/core

export declare function setCominsSortModel<TData>(state: CominsTableState<TData>, sortModel: CominsSortModel): CominsTableState<TData>;

dist/react/core-compat.d.ts:97 · dist/core/state/table.d.ts:63

setCominsSortState

value

comins-tablecomins-table/core

export declare function setCominsSortState<TData>(state: CominsTableState<TData>, sort: CominsSortState | null): CominsTableState<TData>;

dist/react/core-compat.d.ts:96 · dist/core/state/table.d.ts:62

setCominsTableTheme

value

comins-table

export declare function setCominsTableTheme<TData>(state: CominsTableState<TData>, theme: CominsTableTheme): {
    columnOrder: string[];
    columnGroups: import("./core-compat").CominsTableRuntimeColumnGroup[];
    columnGroupState: Record<string, import("./core-compat").CominsColumnGroupRuntimeState>;
    columns: CominsTableRuntimeColumn<TData, unknown>[];
    columnState: Record<string, import("./core-compat").CominsColumnRuntimeState>;
    getRowId: (row: TData, index: number) => CominsRowId;
    pagination: CominsPaginationState;
    rowIds: CominsRowId[];
    rows: TData[];
    selection: import("./core-compat").CominsSelectionState;
    showHeader: boolean;
    sort: CominsSortState | null;
    sortModel: CominsSortModel;
    theme: {
        className?: string;
        density?: import("./core-compat").CominsTableDensity;
        style?: React.CSSProperties;
    };
};

dist/react/core-compat.d.ts:109

sortCominsRows

value

comins-tablecomins-table/core

export declare function sortCominsRows<TData>(state: CominsTableState<TData>, sort: CominsSortState | null): CominsTableState<TData>;

dist/react/core-compat.d.ts:100 · dist/core/state/table.d.ts:66

sortCominsTreeSiblings

value

comins-table

export declare function sortCominsTreeSiblings<TItem>(nodes: readonly CominsTreeNode<TItem>[], compare: (left: TItem, right: TItem) => number): CominsTreeNode<TItem>[];

dist/tree.d.ts:41

toggleCominsTreeNode

value

comins-table

export declare function toggleCominsTreeNode<TItem>(nodes: readonly CominsTreeNode<TItem>[], rowId: CominsRowId, getRowId: (item: TItem, index: number) => CominsRowId, options?: CominsTreeExpansionOptions): CominsTreeNode<TItem>[];

dist/tree.d.ts:39

transferCominsGroupBetweenTables

value

comins-table

export declare function transferCominsGroupBetweenTables<TData, TGroup>(input: CominsGroupBetweenTablesInput<TData, TGroup>): CominsTableTransferResult<TData, TGroup> | null;

dist/core/transfer/policy.d.ts:114

transferCominsRowBetweenTables

value

comins-table

export declare function transferCominsRowBetweenTables<TData, TGroup = never>(input: CominsRowBetweenTablesInput<TData, TGroup>): CominsTableTransferResult<TData, TGroup> | null;

dist/core/transfer/policy.d.ts:113

updateCominsRows

value

comins-tablecomins-table/core

export declare function updateCominsRows<TData>(state: CominsTableState<TData>, updates: ReadonlyArray<CominsRowUpdate<TData>>): CominsTableState<TData>;

dist/react/core-compat.d.ts:92 · dist/core/state/table.d.ts:27

updateCominsTreeItem

value

comins-table

export declare function updateCominsTreeItem<TItem>(nodes: readonly CominsTreeNode<TItem>[], rowId: CominsRowId, getRowId: (item: TItem, index: number) => CominsRowId, update: (item: TItem) => TItem): CominsTreeNode<TItem>[];

dist/tree.d.ts:40

useCominsViewport

value

comins-table

export declare function useCominsViewport<T>(options: CominsViewportOptions<T>): {
    data: CominsViewportData<T>;
    tableProps: {
        data: CominsViewportData<T>;
        onChangeData: (next: CominsViewportData<T>) => void;
        onViewportRequest: (request: CominsViewportRequest) => Promise<void>;
        viewportDatasource: CominsViewportDatasource;
        virtualized: true;
    };
};

dist/use-viewport.d.ts:18