Data Table 전체 API 레퍼런스

npm 패키지의 공개 진입점에서 접근할 수 있는 모든 export와 선언 멤버를 수록했습니다. 이름과 시그니처를 검색하여 정확한 import 경로와 타입 계약을 확인할 수 있습니다.

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

export 엔트리 / 고유 export / 도달 계약 / 멤버 / CSS 변수

이 페이지에서 찾기

공개 export 284도달 계약 374CSS 변수 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