kokotable 0.95.0

package/dist/core/src/client/groupRows.js

@@ -0,0 +1,145 @@
+import { pathKey } from "../types/grouping";
+import { createLabelResolver } from "../columns/labels";
+import { aggregateRows } from "./aggregate";
+import { getValue } from "../utils/getValue";
+import { compareValues } from "../utils/compare";
+/**
+ * 행을 그룹 트리로 묶는다.
+ *
+ * 그룹 순서는 **값 오름차순**이고 NULL 이 뒤로 간다 — 정렬 규칙(`applySorting`)과
+ * 같은 규약이라 그룹을 켰다 껐을 때 순서가 뒤집히지 않는다.
+ */
+export function groupRows(rows, options) {
+    const { grouping, aggregation, aggregations: registry } = options;
+    if (grouping.length === 0)
+        return [];
+    const resolveLabel = createLabelResolver(options.columns, options.labelOf);
+    const totalCount = rows.length;
+    const build = (subset, depth, parentPath) => {
+        const key = grouping[depth];
+        const buckets = new Map();
+        for (const row of subset) {
+            const value = getValue(row, key);
+            const bucketKey = String(value);
+            const bucket = buckets.get(bucketKey);
+            if (bucket)
+                bucket.rows.push(row);
+            else
+                buckets.set(bucketKey, { value, rows: [row] });
+        }
+        const nodes = [];
+        for (const bucket of buckets.values()) {
+            const path = [...parentPath, { key, value: bucket.value }];
+            const isLast = depth === grouping.length - 1;
+            nodes.push({
+                groupKey: key,
+                groupValue: bucket.value,
+                label: resolveLabel(key, bucket.value),
+                count: bucket.rows.length,
+                aggregates: aggregation ? aggregateRows(bucket.rows, aggregation, { totalCount }, registry) : undefined,
+                children: isLast ? undefined : build(bucket.rows, depth + 1, path),
+                rows: isLast ? bucket.rows : undefined,
+                path,
+                depth,
+            });
+        }
+        nodes.sort((a, b) => {
+            const aNull = a.groupValue === null || a.groupValue === undefined;
+            const bNull = b.groupValue === null || b.groupValue === undefined;
+            if (aNull || bNull)
+                return aNull && bNull ? 0 : aNull ? 1 : -1;
+            return compareValues(a.groupValue, b.groupValue);
+        });
+        return nodes;
+    };
+    return build(rows, 0, []);
+}
+/** 트리의 최대 깊이 (그룹 레벨 수) */
+export function groupDepth(nodes) {
+    let max = 0;
+    const walk = (list, depth) => {
+        if (list.length === 0)
+            return;
+        max = Math.max(max, depth + 1);
+        for (const node of list)
+            if (node.children)
+                walk(node.children, depth + 1);
+    };
+    walk(nodes, 0);
+    return max;
+}
+/**
+ * 트리를 화면 순서대로 평탄화한다. 접힌 그룹의 하위는 건너뛴다.
+ * 가상화 리스트가 그대로 소비할 수 있는 형태다.
+ */
+export function flattenGroups(nodes, options) {
+    const { expanded, includeLeaves = true } = options;
+    const items = [];
+    let leafIndex = 0;
+    const walk = (list, depth, parentIndex) => {
+        for (const node of list) {
+            const index = items.length;
+            items.push({ type: "group", node, depth, index, parentIndex });
+            if (!expanded.has(pathKey(node.path)))
+                continue;
+            if (node.children) {
+                walk(node.children, depth + 1, index);
+            }
+            else if (includeLeaves && node.rows) {
+                for (const row of node.rows) {
+                    items.push({
+                        type: "leaf",
+                        row,
+                        depth: depth + 1,
+                        index: items.length,
+                        parentIndex: index,
+                        leafIndex: leafIndex++,
+                    });
+                }
+            }
+            // 서버 그룹핑: 아직 못 받은 하위가 남아 있으면 "더 보기" 행을 둔다
+            if (node.hasMore) {
+                items.push({
+                    type: "loadMore",
+                    path: node.path,
+                    depth: depth + 1,
+                    index: items.length,
+                    parentIndex: index,
+                    loaded: node.loadedCount ?? (node.children?.length ?? node.rows?.length ?? 0),
+                    total: node.totalCount,
+                    isPending: node.isPending,
+                });
+            }
+        }
+    };
+    walk(nodes, 0);
+    return items;
+}
+/** 트리 전체의 경로 키 — expandAll 용 */
+export function allGroupPaths(nodes) {
+    const keys = [];
+    const walk = (list) => {
+        for (const node of list) {
+            keys.push(pathKey(node.path));
+            if (node.children)
+                walk(node.children);
+        }
+    };
+    walk(nodes);
+    return keys;
+}
+/** 특정 깊이까지의 경로 키 — 단계 펼치기 용 */
+export function pathsToDepth(nodes, depth) {
+    const keys = [];
+    const walk = (list, current) => {
+        if (current >= depth)
+            return;
+        for (const node of list) {
+            keys.push(pathKey(node.path));
+            if (node.children)
+                walk(node.children, current + 1);
+        }
+    };
+    walk(nodes, 0);
+    return keys;
+}

package/dist/core/src/client/runClientQuery.d.ts

@@ -0,0 +1,67 @@
+import type { RowData } from "@tanstack/react-table";
+import type { TableColumnDefs } from "../types/column";
+import type { Pagination, TableRequest } from "../types/request";
+import { type MatchContext } from "../filters/registry";
+import { DEFAULT_PAGE_SIZE } from "../defaults";
+export interface ClientQueryOptions<T extends RowData> extends MatchContext {
+    /**
+     * globalFilter 대상 필드. 미지정이면 **선언된 텍스트 계열 컬럼**의 경로를 쓴다
+     * (`defaultGlobalFilterFields` — enum/select/common_code 포함, number/date/boolean/
+     * 관계·선형·일정 제외).
+     *
+     * 서버는 모델의 varchar/text/enum 컬럼과 FK 대상 테이블의 텍스트 컬럼을 자동
+     * 탐색하므로(`GlobalFilterMixin._collect_auto_columns`), 화면에 선언하지 않은
+     * 컬럼까지 훑는다. 클라이언트는 선언된 컬럼만 볼 수 있어 이 지점만은 완전한
+     * 동치가 불가능하다 — 필요하면 여기에 명시적으로 넘긴다.
+     */
+    globalFilterFields?: string[];
+}
+export interface ClientQueryResult<T> {
+    /** 필터·정렬·페이지까지 적용된 행 */
+    rows: T[];
+    /** 페이지 적용 **전** 건수 — 서버 `meta.total_count` 에 대응 */
+    total: number;
+    /** 페이지 적용 전 전체 행 (집계·내보내기용) */
+    filtered: T[];
+}
+/** 컬럼 필터 적용 — 미입력 필터와 "전체" 선택은 건너뛴다 */
+export declare function applyColumnFilters<T extends RowData>(rows: T[], columns: TableColumnDefs<T>, request: TableRequest, ctx?: MatchContext): T[];
+/**
+ * globalFilter 기본 대상 — 선언된 컬럼 중 **텍스트 계열**(`resolveDataKind === "text"`).
+ *
+ * 서버 자동 탐색이 varchar/text/enum 만 보는 것과 맞춘 것이다. 숫자·날짜·boolean 을
+ * 문자열화해 검색하면 `"12"` 가 idx 나 `2024-12-31` 에 걸려 서버와 결과가 갈렸다.
+ * 관계·선형·일정 같은 가상 컬럼도 뺀다 (서버는 relationship 을 탐색하지 않는다).
+ */
+export declare function defaultGlobalFilterFields<T extends RowData>(columns: TableColumnDefs<T>): string[];
+/**
+ * globalFilter 적용 — 백엔드 fuzzy 와 같은 규칙(양쪽 공백 제거 + 소문자 부분일치).
+ */
+export declare function applyGlobalFilter<T extends RowData>(rows: T[], columns: TableColumnDefs<T>, request: TableRequest, options?: ClientQueryOptions<T>): T[];
+/**
+ * 정렬 — PostgreSQL 기본과 같은 NULL 위치를 쓴다 (ASC = NULLS LAST, DESC = NULLS FIRST).
+ * `sorting[].key` 가 있으면 그 필드로 정렬한다 (가상/통합 컬럼).
+ */
+export declare function applySorting<T extends RowData>(rows: T[], request: TableRequest): T[];
+/**
+ * 페이지 슬라이스 — 서버 `OFFSET/LIMIT` 과 같은 의미.
+ *
+ * "전체" 는 `pagination` 미지정 또는 `PAGE_SIZE_ALL` 로만 표현한다.
+ * `pageSize 0` 은 서버 `LIMIT 0` 이 그렇듯 **0건**이다 — 예전에는 이를 "전체" 로
+ * 해석해 client 모드에서만 전행이 나왔다.
+ */
+export declare function paginateRows<T>(rows: T[], pagination: Pagination | undefined): T[];
+export declare function applyPagination<T>(rows: T[], request: TableRequest): T[];
+/**
+ * 페이지 **앞** 단계 — 컬럼 필터 → 전역 필터 → 정렬.
+ *
+ * `runClientQuery` 에서 떼어 낸 이유: 훅이 이 결과를 따로 메모이즈해 두면 페이지
+ * 이동에는 슬라이스만 다시 하고, 50k 행 정렬을 매 페이지마다 반복하지 않는다.
+ */
+export declare function filterAndSortRows<T extends RowData>(rows: T[], columns: TableColumnDefs<T>, request: TableRequest, options?: ClientQueryOptions<T>): T[];
+/**
+ * 클라이언트 모드의 전체 파이프라인 — 서버 QueryBuilder 와 같은 순서로 적용한다.
+ * (컬럼 필터 → 전역 필터 → 정렬 → 페이지)
+ */
+export declare function runClientQuery<T extends RowData>(rows: T[], columns: TableColumnDefs<T>, request: TableRequest, options?: ClientQueryOptions<T>): ClientQueryResult<T>;
+export { DEFAULT_PAGE_SIZE };

package/dist/core/src/client/runClientQuery.js

@@ -0,0 +1,157 @@
+import { isValuelessOperator } from "../types/operators";
+import { columnKey } from "../columns/deriveOperators";
+import { isVirtualColumn, matchColumnFilter, resolveDataKind, } from "../filters/registry";
+import { compareValues, normalizeSearchText } from "../utils/compare";
+import { getValue, isUnsetFilterValue } from "../utils/getValue";
+import { ALL_FILTER_VALUE } from "../filters/list";
+import { DEFAULT_PAGE_SIZE, PAGE_SIZE_ALL } from "../defaults";
+function columnMap(columns) {
+    const map = new Map();
+    for (const column of columns) {
+        const key = columnKey(column);
+        if (key)
+            map.set(key, column);
+    }
+    return map;
+}
+/** 컬럼 필터 적용 — 미입력 필터와 "전체" 선택은 건너뛴다 */
+export function applyColumnFilters(rows, columns, request, ctx = {}) {
+    const filters = request.columnFilters ?? [];
+    if (filters.length === 0)
+        return rows;
+    const byId = columnMap(columns);
+    const operators = request.columnFilterFns ?? {};
+    let result = rows;
+    for (const filter of filters) {
+        if (!filter)
+            continue;
+        const operator = (operators[filter.id] ?? "fuzzy");
+        // 값을 안 쓰는 연산자(empty/isEmpty/hasChild …)는 미입력이어도 적용된다
+        if (!isValuelessOperator(operator) && isUnsetFilterValue(filter.value))
+            continue;
+        // "전체" 센티널 — 서버가 필터를 통째로 건너뛴다
+        if (filter.value === ALL_FILTER_VALUE)
+            continue;
+        if (Array.isArray(filter.value) && filter.value.includes(ALL_FILTER_VALUE))
+            continue;
+        const column = byId.get(filter.id);
+        result = result.filter((row) => matchColumnFilter(row, filter.id, filter.value, operator, column, ctx));
+    }
+    return result;
+}
+/**
+ * globalFilter 기본 대상 — 선언된 컬럼 중 **텍스트 계열**(`resolveDataKind === "text"`).
+ *
+ * 서버 자동 탐색이 varchar/text/enum 만 보는 것과 맞춘 것이다. 숫자·날짜·boolean 을
+ * 문자열화해 검색하면 `"12"` 가 idx 나 `2024-12-31` 에 걸려 서버와 결과가 갈렸다.
+ * 관계·선형·일정 같은 가상 컬럼도 뺀다 (서버는 relationship 을 탐색하지 않는다).
+ */
+export function defaultGlobalFilterFields(columns) {
+    const fields = [];
+    for (const column of columns) {
+        if (isVirtualColumn(column))
+            continue;
+        if (resolveDataKind(column) !== "text")
+            continue;
+        const key = columnKey(column);
+        if (key)
+            fields.push(key);
+    }
+    return fields;
+}
+/**
+ * globalFilter 적용 — 백엔드 fuzzy 와 같은 규칙(양쪽 공백 제거 + 소문자 부분일치).
+ */
+export function applyGlobalFilter(rows, columns, request, options = {}) {
+    const needle = normalizeSearchText(String(request.globalFilter ?? ""));
+    if (!needle)
+        return rows;
+    const fields = options.globalFilterFields ?? defaultGlobalFilterFields(columns);
+    if (fields.length === 0)
+        return rows;
+    return rows.filter((row) => fields.some((field) => {
+        const value = getValue(row, field);
+        if (value === null || value === undefined)
+            return false;
+        return normalizeSearchText(String(value)).includes(needle);
+    }));
+}
+/**
+ * 정렬 — PostgreSQL 기본과 같은 NULL 위치를 쓴다 (ASC = NULLS LAST, DESC = NULLS FIRST).
+ * `sorting[].key` 가 있으면 그 필드로 정렬한다 (가상/통합 컬럼).
+ */
+export function applySorting(rows, request) {
+    const sorting = request.sorting ?? [];
+    if (sorting.length === 0)
+        return rows;
+    const sorted = [...rows];
+    sorted.sort((a, b) => {
+        for (const sort of sorting) {
+            const path = sort.key ?? sort.id;
+            const av = getValue(a, path);
+            const bv = getValue(b, path);
+            const aNull = av === null || av === undefined;
+            const bNull = bv === null || bv === undefined;
+            if (aNull || bNull) {
+                if (aNull && bNull)
+                    continue;
+                // PostgreSQL 기본: ASC = NULLS LAST, DESC = NULLS FIRST
+                const nullGoesLast = !sort.desc;
+                if (aNull)
+                    return nullGoesLast ? 1 : -1;
+                return nullGoesLast ? -1 : 1;
+            }
+            const cmp = compareValues(av, bv);
+            if (cmp !== 0)
+                return sort.desc ? -cmp : cmp;
+        }
+        return 0;
+    });
+    return sorted;
+}
+/**
+ * 페이지 슬라이스 — 서버 `OFFSET/LIMIT` 과 같은 의미.
+ *
+ * "전체" 는 `pagination` 미지정 또는 `PAGE_SIZE_ALL` 로만 표현한다.
+ * `pageSize 0` 은 서버 `LIMIT 0` 이 그렇듯 **0건**이다 — 예전에는 이를 "전체" 로
+ * 해석해 client 모드에서만 전행이 나왔다.
+ */
+export function paginateRows(rows, pagination) {
+    if (!pagination)
+        return rows;
+    const { pageIndex, pageSize } = pagination;
+    if (!Number.isFinite(pageSize) || pageSize >= PAGE_SIZE_ALL)
+        return rows;
+    if (pageSize <= 0)
+        return [];
+    const start = Math.max(0, pageIndex) * pageSize;
+    return rows.slice(start, start + pageSize);
+}
+export function applyPagination(rows, request) {
+    return paginateRows(rows, request.pagination);
+}
+/**
+ * 페이지 **앞** 단계 — 컬럼 필터 → 전역 필터 → 정렬.
+ *
+ * `runClientQuery` 에서 떼어 낸 이유: 훅이 이 결과를 따로 메모이즈해 두면 페이지
+ * 이동에는 슬라이스만 다시 하고, 50k 행 정렬을 매 페이지마다 반복하지 않는다.
+ */
+export function filterAndSortRows(rows, columns, request, options = {}) {
+    const ctx = { now: options.now };
+    let result = applyColumnFilters(rows, columns, request, ctx);
+    result = applyGlobalFilter(result, columns, request, options);
+    return applySorting(result, request);
+}
+/**
+ * 클라이언트 모드의 전체 파이프라인 — 서버 QueryBuilder 와 같은 순서로 적용한다.
+ * (컬럼 필터 → 전역 필터 → 정렬 → 페이지)
+ */
+export function runClientQuery(rows, columns, request, options = {}) {
+    const filtered = filterAndSortRows(rows, columns, request, options);
+    return {
+        rows: applyPagination(filtered, request),
+        total: filtered.length,
+        filtered,
+    };
+}
+export { DEFAULT_PAGE_SIZE };

package/dist/core/src/columns/ColumnBuilder.d.ts

@@ -0,0 +1,121 @@
+import type { ReactNode } from "react";
+import type { RowData } from "@tanstack/react-table";
+import type { CellAlign, ColumnDataType, ColumnMeta, DateFilterMode, EditSpec, SelectOption, TableColumnDef } from "../types/column";
+import type { AnyFilterKind, FilterSpec, FilterSpecOf } from "../types/filter";
+import type { FilterOperator, FilterVariant } from "../types/operators";
+/** 셀 렌더러가 받는 값 — table·row 인스턴스가 아니라 순수 값이다. `V` 는 셀 값 타입(기본 `unknown`) */
+export interface CellRenderProps<T extends RowData, V = unknown> {
+    value: V;
+    row: T;
+    rowIndex: number;
+    columnId: string;
+    /** 기본 포맷터(또는 이전 렌더러)가 만든 결과 */
+    renderedValue: ReactNode;
+}
+export type CellRender<T extends RowData, V = unknown> = (props: CellRenderProps<T, V>) => ReactNode;
+/** 헤더 규칙 — `setHeaderRule` 이 `meta.headerTooltip` / `meta.align` / `meta.headerAlign` 으로 옮긴다 */
+export interface HeaderRule {
+    tooltip?: string;
+    align?: CellAlign;
+    headerAlign?: CellAlign;
+}
+export type { EditSpec };
+export interface SizingSpec {
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
+    grow?: boolean | number;
+    /** 좁은 컬럼에서 말줄임 */
+    ellipsis?: boolean;
+}
+/** `dataType` → 기본 필터 UI 종류 (`deriveOperators.inferVariant` 와 같은 표) */
+export declare const inferFilterVariant: (dataType: ColumnDataType) => FilterVariant;
+/** 기본 포맷터 — 순수 함수라 렌더러가 없어도 동작한다 (CSV·PDF 내보내기 공용) */
+export declare function formatByDataType(value: unknown, dataType: ColumnDataType): string;
+/**
+ * 컬럼 빌더 — 체이닝으로 컬럼 정의를 조립한다.
+ *
+ * 원본과 달리 **MUI 를 모른다.** 편집 입력·칩 같은 렌더 선언은 `meta.edit` 에
+ * 데이터로 남기고, 실제 컴포넌트는 렌더러 패키지가 읽어서 그린다. 그래야
+ * 같은 컬럼 정의로 테이블도, 카드도, 내보내기도 그릴 수 있다.
+ */
+export declare class ColumnBuilder<T extends RowData, V = any> {
+    column: TableColumnDef<T, V>;
+    readonly key: string;
+    dataType: ColumnDataType;
+    constructor(key: string, header: string, dataType?: ColumnDataType);
+    /**
+     * 점 표기 key 는 `accessorKey` 대신 `accessorFn` 으로 읽는다.
+     * TanStack 의 깊은 `accessorKey` 접근은 중간 객체가 없으면 행마다 경고를 낸다
+     * (확장 자식 행 등) — 안전 접근으로 대체해 조용히 undefined 를 돌려준다.
+     *
+     * 값은 **변환하지 않는다.** 필터·정렬·집계는 2층이 원값(`getValue`)으로 계산하므로
+     * 셀만 다른 값(boolean 문자열, NaN→0, Date 객체)을 보면 두 경로가 어긋난다.
+     * 표시 포맷은 `formatByDataType` 이 원값에서 만든다.
+     */
+    private applyAccessor;
+    private applyDefaultCell;
+    /** 필터 UI 종류 변경 — 연산자 후보와 내장 kind 도 함께 갈아끼운다 (`custom` 은 kind 없음) */
+    setVariant(variant: FilterVariant, operators?: readonly FilterOperator[]): this;
+    /**
+     * 필터 kind 지정 — 연산자·기본값이 kind 로 좁혀진다 (`filter: { kind }` 를 인라인으로 쓸 때와 달리
+     * 레지스트리에 등록하지 않은 kind 에도 연산자·기본값을 줄 수 있다).
+     * 연산자 후보는 `spec.operators` > kind 의 `offered` > 전체, variant 는 `spec.variant` > kind 의 힌트.
+     */
+    setFilterKind<K extends AnyFilterKind>(kind: K, spec?: Omit<FilterSpecOf<K>, "kind">): this;
+    /** 필터 선언 병합. 필터 값 타입은 셀 값 `V` 와 다를 수 있어 `FilterSpec<any>` 로 받는다 */
+    setFilter(spec: FilterSpec<any>): this;
+    setOperators(operators: readonly FilterOperator[], defaultOperator?: FilterOperator): this;
+    setDateFilterMode(mode: DateFilterMode): this;
+    setMeta(meta: Partial<ColumnMeta>): this;
+    setProps(props: Partial<TableColumnDef<T, any>>): this;
+    /**
+     * 소비 앱 확장 메타 (`meta.custom`) — 여러 번 부르면 얕게 병합된다.
+     * 읽는 쪽은 `columnMetaOf<Ext>(column)?.custom` 으로 타입을 살린다.
+     */
+    setCustom<E extends object>(ext: E): this;
+    /** 헤더 규칙 — 툴팁·셀 정렬·헤더 정렬. 렌더러가 `meta.headerTooltip` / `meta.align` / `meta.headerAlign` 을 읽는다 */
+    setHeaderRule(rule: HeaderRule): this;
+    setHeader(header: ReactNode): this;
+    /** 필터 패널에만 쓰는 라벨 (헤더가 ReactNode 일 때) */
+    setFilterLabel(label: ReactNode): this;
+    setSizing(options: SizingSpec): this;
+    /** TanStack 셀 컨텍스트 → 순수 값 props (setCell/setCellWrapper 공용) */
+    private toCellProps;
+    /** 셀 렌더러 교체 — `value` 는 셀 값 타입 `V` 로 온다 */
+    setCell(render: CellRender<T, V>): this;
+    /** 기존 렌더 결과를 감싼다 (링크·칩 등) */
+    setCellWrapper(wrap: (rendered: ReactNode, props: CellRenderProps<T, V>) => ReactNode): this;
+    /**
+     * 표시 여부.
+     *
+     * `forceHidden` 은 값 보관 전용 — 사용자 토글이나 프리셋 복원으로도 되살아나지
+     * 않는다. `isVisible: false` 는 "기본 숨김"일 뿐이라 되살아난다. 헤더가 없는
+     * 컬럼(통합 cascade 에 흡수된 레벨 등)은 반드시 `forceHidden` 을 쓴다.
+     */
+    setDisplay(options?: {
+        display?: boolean;
+        hideFilter?: boolean;
+        forceHidden?: boolean;
+    }): this;
+    setEditable(enabled?: boolean, onCommit?: (value: unknown, row: T) => void): this;
+    /**
+     * 선택 편집 — 선언만 남긴다. dropdown/chip/button 컴포넌트는 렌더러가 그린다.
+     */
+    setEditSelect(config: Omit<EditSpec<T>, "enabled" | "kind">): this;
+    setEdit(spec: EditSpec<T>): this;
+    /**
+     * 필터 선택지. 목록이 있는 컬럼은 자유 텍스트 입력 대상이 아니다 —
+     * 라벨과 저장값이 달라 드롭다운이 사라지면 화면의 라벨을 쳐서 조용히 0건이 된다.
+     */
+    setFilterOptions(options: SelectOption[], includeAll?: boolean): this;
+    /** 집계 활성 — 서버 집계 키와 클라이언트 그룹 집계에 함께 쓰인다 */
+    setAgg(enabled: boolean, aggregations?: string[]): this;
+    setFooter(footer: ReactNode | ((ctx: unknown) => ReactNode)): this;
+    /** 이 컬럼으로 정렬할 때 서버에 대신 보낼 실제 필드 (가상/통합 컬럼) */
+    setSortExpandsTo(fields: string[]): this;
+    getColumn(): TableColumnDef<T, V>;
+    build(): TableColumnDef<T, V>;
+}
+/** 빌더 배열을 컬럼 정의 배열로 */
+export declare function buildColumns<T extends RowData>(builders: Array<ColumnBuilder<T, any> | ColumnBuilder<T, any>[] | TableColumnDef<T, any>>): Array<TableColumnDef<T, any>>;