@zboson/ui 0.0.0-stage → 0.0.1

package/dist/table/hooks/useSorter.js

@@ -0,0 +1,263 @@
+import InternalTooltip from "../../tooltip/index.js";
+import { getColumnKey, getColumnPos, renderColumnTitle, safeColumnTitle } from "../util.js";
+import { computed, createVNode, isVNode, shallowRef, unref } from "vue";
+import { clsx } from "@v-c/util";
+import { CaretDownOutlined, CaretUpOutlined } from "@zboson/icons";
+import KeyCode from "@v-c/util/dist/KeyCode";
+//#region src/table/hooks/useSorter.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const ASCEND = "ascend";
+const DESCEND = "descend";
+function getMultiplePriority(column) {
+	if (typeof column.sorter === "object" && typeof column.sorter.multiple === "number") return column.sorter.multiple;
+	return false;
+}
+function getSortFunction(sorter) {
+	if (typeof sorter === "function") return sorter;
+	if (sorter && typeof sorter === "object" && sorter.compare) return sorter.compare;
+	return false;
+}
+function nextSortDirection(sortDirections, current) {
+	if (!current) return sortDirections[0];
+	return sortDirections[sortDirections.indexOf(current) + 1];
+}
+function collectSortStates(columns, init, pos) {
+	let sortStates = [];
+	const pushState = (column, columnPos) => {
+		sortStates.push({
+			column,
+			key: getColumnKey(column, columnPos),
+			multiplePriority: getMultiplePriority(column),
+			sortOrder: column.sortOrder
+		});
+	};
+	(columns || []).forEach((column, index) => {
+		const columnPos = getColumnPos(index, pos);
+		if (column.children) {
+			if ("sortOrder" in column) pushState(column, columnPos);
+			sortStates = [...sortStates, ...collectSortStates(column.children, init, columnPos)];
+		} else if (column.sorter) {
+			if ("sortOrder" in column) pushState(column, columnPos);
+			else if (init && column.defaultSortOrder) sortStates.push({
+				column,
+				key: getColumnKey(column, columnPos),
+				multiplePriority: getMultiplePriority(column),
+				sortOrder: column.defaultSortOrder
+			});
+		}
+	});
+	return sortStates;
+}
+function injectSorter(prefixCls, columns, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, pos, a11yLocale) {
+	return (columns || []).map((column, index) => {
+		const columnPos = getColumnPos(index, pos);
+		let newColumn = column;
+		if (newColumn.sorter) {
+			const sortDirections = newColumn.sortDirections || defaultSortDirections;
+			const showSorterTooltip = newColumn.showSorterTooltip === void 0 ? tableShowSorterTooltip : newColumn.showSorterTooltip;
+			const columnKey = getColumnKey(newColumn, columnPos);
+			const sorterState = sorterStates.find(({ key }) => key === columnKey);
+			const sortOrder = sorterState ? sorterState.sortOrder : null;
+			const nextSortOrder = nextSortDirection(sortDirections, sortOrder);
+			const { cancelSort, triggerAsc, triggerDesc } = tableLocale || {};
+			let sortTip = cancelSort;
+			if (nextSortOrder === DESCEND) sortTip = triggerDesc;
+			else if (nextSortOrder === ASCEND) sortTip = triggerAsc;
+			const tooltipProps = typeof showSorterTooltip === "object" ? {
+				title: sortTip,
+				...showSorterTooltip
+			} : { title: sortTip };
+			newColumn = {
+				...newColumn,
+				className: clsx(newColumn.className, { [`${prefixCls}-column-sort`]: sortOrder }),
+				title: (renderProps) => {
+					let sorter;
+					if (column.sortIcon) sorter = column.sortIcon({ sortOrder });
+					else {
+						const upNode = sortDirections.includes(ASCEND) && createVNode(CaretUpOutlined, { "class": clsx(`${prefixCls}-column-sorter-up`, { active: sortOrder === ASCEND }) }, null);
+						const downNode = sortDirections.includes(DESCEND) && createVNode(CaretDownOutlined, { "class": clsx(`${prefixCls}-column-sorter-down`, { active: sortOrder === DESCEND }) }, null);
+						sorter = createVNode("span", { "class": clsx(`${prefixCls}-column-sorter`, { [`${prefixCls}-column-sorter-full`]: !!(upNode && downNode) }) }, [createVNode("span", {
+							"class": `${prefixCls}-column-sorter-inner`,
+							"aria-hidden": "true"
+						}, [upNode, downNode])]);
+					}
+					const columnSortersClass = `${prefixCls}-column-sorters`;
+					const renderColumnTitleWrapper = createVNode("span", { "class": `${prefixCls}-column-title` }, [renderColumnTitle(column.title, renderProps)]);
+					const renderSortTitle = createVNode("div", { "class": columnSortersClass }, [renderColumnTitleWrapper, sorter]);
+					if (showSorterTooltip) {
+						if (typeof showSorterTooltip !== "boolean" && showSorterTooltip?.target === "sorter-icon") return createVNode("div", { "class": clsx(columnSortersClass, `${columnSortersClass}-tooltip-target-sorter`) }, [renderColumnTitleWrapper, createVNode(InternalTooltip, tooltipProps, _isSlot(sorter) ? sorter : { default: () => [sorter] })]);
+						return createVNode(InternalTooltip, tooltipProps, _isSlot(renderSortTitle) ? renderSortTitle : { default: () => [renderSortTitle] });
+					}
+					return renderSortTitle;
+				},
+				onHeaderCell: (col) => {
+					const cell = column.onHeaderCell?.(col) || {};
+					const originOnClick = cell.onClick;
+					const originOnKeydown = cell.onKeydown || cell.onKeyDown;
+					cell.onClick = (event) => {
+						triggerSorter({
+							column,
+							key: columnKey,
+							sortOrder: nextSortOrder,
+							multiplePriority: getMultiplePriority(column)
+						});
+						originOnClick?.(event);
+					};
+					cell.onKeydown = (event) => {
+						if (event.keyCode === KeyCode.ENTER) triggerSorter({
+							column,
+							key: columnKey,
+							sortOrder: nextSortOrder,
+							multiplePriority: getMultiplePriority(column)
+						});
+						originOnKeydown?.(event);
+					};
+					const renderTitle = safeColumnTitle(column.title, {});
+					const displayTitle = renderTitle?.toString();
+					if (sortOrder) cell["aria-sort"] = sortOrder === "ascend" ? "ascending" : "descending";
+					cell["aria-description"] = a11yLocale?.sortable;
+					cell["aria-label"] = displayTitle || "";
+					cell.className = clsx(cell.className, `${prefixCls}-column-has-sorters`);
+					cell.tabIndex = 0;
+					if (column.ellipsis) cell.title = (renderTitle ?? "").toString();
+					return cell;
+				}
+			};
+		}
+		if ("children" in newColumn) newColumn = {
+			...newColumn,
+			children: injectSorter(prefixCls, newColumn.children, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, columnPos, a11yLocale)
+		};
+		return newColumn;
+	});
+}
+function stateToInfo(sorterState) {
+	const { column, sortOrder } = sorterState;
+	return {
+		column,
+		order: sortOrder,
+		field: column.dataIndex,
+		columnKey: column.key
+	};
+}
+function generateSorterInfo(sorterStates) {
+	const activeSorters = sorterStates.reduce((list, sorterState) => {
+		if (sorterState.sortOrder) list.push(stateToInfo(sorterState));
+		return list;
+	}, []);
+	if (activeSorters.length === 0 && sorterStates.length) return {
+		...stateToInfo(sorterStates[sorterStates.length - 1]),
+		column: void 0,
+		order: void 0,
+		field: void 0,
+		columnKey: void 0
+	};
+	if (activeSorters.length <= 1) return activeSorters[0] || {};
+	return activeSorters;
+}
+function getSortData(data, sortStates, childrenColumnName) {
+	const innerSorterStates = sortStates.slice().sort((a, b) => b.multiplePriority - a.multiplePriority);
+	const cloneData = data.slice();
+	const runningSorters = innerSorterStates.filter(({ column: { sorter }, sortOrder }) => getSortFunction(sorter) && sortOrder);
+	if (!runningSorters.length) return cloneData;
+	return cloneData.sort((record1, record2) => {
+		for (let i = 0; i < runningSorters.length; i += 1) {
+			const { column: { sorter }, sortOrder } = runningSorters[i];
+			const compareFn = getSortFunction(sorter);
+			if (compareFn && sortOrder) {
+				const compareResult = compareFn(record1, record2, sortOrder);
+				if (compareResult !== 0) return sortOrder === ASCEND ? compareResult : -compareResult;
+			}
+		}
+		return 0;
+	}).map((record) => {
+		const subRecords = record?.[childrenColumnName];
+		if (subRecords) return {
+			...record,
+			[childrenColumnName]: getSortData(subRecords, sortStates, childrenColumnName)
+		};
+		return record;
+	});
+}
+function useSorter(props) {
+	const { prefixCls: rawPrefixCls, mergedColumns: rawMergedColumns, baseColumns: rawBaseColumns, sortDirections: rawSortDirections, tableLocale: rawTableLocale, showSorterTooltip: rawShowSorterTooltip, onSorterChange, globalLocale: rawGlobalLocale } = props;
+	const prefixCls = computed(() => unref(rawPrefixCls));
+	const mergedColumns = computed(() => unref(rawMergedColumns));
+	const collectColumns = computed(() => unref(rawBaseColumns) ?? mergedColumns.value);
+	const sortDirections = computed(() => unref(rawSortDirections));
+	const tableLocale = computed(() => unref(rawTableLocale));
+	const showSorterTooltip = computed(() => unref(rawShowSorterTooltip));
+	const globalLocale = computed(() => unref(rawGlobalLocale));
+	const sortStates = shallowRef(collectSortStates(collectColumns.value, true));
+	const getColumnKeys = (columns, pos) => {
+		const newKeys = [];
+		columns.forEach((item, index) => {
+			const columnPos = getColumnPos(index, pos);
+			newKeys.push(getColumnKey(item, columnPos));
+			if (Array.isArray(item.children)) {
+				const childKeys = getColumnKeys(item.children, columnPos);
+				newKeys.push(...childKeys);
+			}
+		});
+		return newKeys;
+	};
+	const mergedSorterStates = computed(() => {
+		let validate = true;
+		const collectedStates = collectSortStates(collectColumns.value, false);
+		if (!collectedStates.length) {
+			const collectColumnsKeys = getColumnKeys(collectColumns.value);
+			return sortStates.value.filter(({ key }) => collectColumnsKeys.includes(key));
+		}
+		const validateStates = [];
+		function patchStates(state) {
+			if (validate) validateStates.push(state);
+			else validateStates.push({
+				...state,
+				sortOrder: null
+			});
+		}
+		let multipleMode = null;
+		collectedStates.forEach((state) => {
+			if (multipleMode === null) {
+				patchStates(state);
+				if (state.sortOrder) if (state.multiplePriority === false) validate = false;
+				else multipleMode = true;
+			} else if (multipleMode && state.multiplePriority !== false) patchStates(state);
+			else {
+				validate = false;
+				patchStates(state);
+			}
+		});
+		return validateStates;
+	});
+	const columnTitleSorterProps = computed(() => {
+		const sortColumns = mergedSorterStates.value.map(({ column, sortOrder }) => ({
+			column,
+			order: sortOrder
+		}));
+		return {
+			sortColumns,
+			sortColumn: sortColumns[0]?.column,
+			sortOrder: sortColumns[0]?.order
+		};
+	});
+	const triggerSorter = (sortState) => {
+		let newSorterStates;
+		if (sortState.multiplePriority === false || !mergedSorterStates.value.length || mergedSorterStates.value[0].multiplePriority === false) newSorterStates = [sortState];
+		else newSorterStates = [...mergedSorterStates.value.filter(({ key }) => key !== sortState.key), sortState];
+		sortStates.value = newSorterStates;
+		onSorterChange(generateSorterInfo(newSorterStates), newSorterStates);
+	};
+	const transformColumns = (innerColumns) => injectSorter(prefixCls.value, innerColumns, mergedSorterStates.value, triggerSorter, sortDirections.value, tableLocale.value, showSorterTooltip.value, void 0, globalLocale.value);
+	const getSorters = () => generateSorterInfo(mergedSorterStates.value);
+	return [
+		transformColumns,
+		mergedSorterStates,
+		columnTitleSorterProps,
+		getSorters
+	];
+}
+//#endregion
+export { useSorter as default, getSortData };

package/dist/table/hooks/useSpinProps.d.ts

@@ -0,0 +1,6 @@
+import { SpinProps } from "../../spin/index.js";
+import { ComputedRef, Ref } from "vue";
+//#region src/table/hooks/useSpinProps.d.ts
+declare function useSpinProps(loading: Ref<boolean | SpinProps | undefined>): ComputedRef<SpinProps>;
+//#endregion
+export { useSpinProps as default };

package/dist/table/hooks/useSpinProps.js

@@ -0,0 +1,14 @@
+import { computed } from "vue";
+//#region src/table/hooks/useSpinProps.ts
+function useSpinProps(loading) {
+	return computed(() => {
+		if (typeof loading.value === "boolean") return { spinning: loading.value };
+		if (typeof loading.value === "object" && loading.value !== null) return {
+			spinning: true,
+			...loading.value
+		};
+		return {};
+	});
+}
+//#endregion
+export { useSpinProps as default };

package/dist/table/hooks/useTitleColumns.d.ts

@@ -0,0 +1,6 @@
+import { AnyObject } from "../../_util/type.js";
+import { ColumnTitleProps, TransformColumns } from "../interface.js";
+//#region src/table/hooks/useTitleColumns.d.ts
+declare function useTitleColumns<RecordType extends AnyObject = AnyObject>(columnTitleProps: ColumnTitleProps<RecordType>): readonly [TransformColumns<RecordType>];
+//#endregion
+export { useTitleColumns as default };

package/dist/table/hooks/useTitleColumns.js

@@ -0,0 +1,16 @@
+import { renderColumnTitle } from "../util.js";
+//#region src/table/hooks/useTitleColumns.ts
+function fillTitle(columns, columnTitleProps) {
+	return columns.map((column) => {
+		const cloneColumn = { ...column };
+		cloneColumn.title = renderColumnTitle(column.title, columnTitleProps);
+		if ("children" in cloneColumn) cloneColumn.children = fillTitle(cloneColumn.children, columnTitleProps);
+		return cloneColumn;
+	});
+}
+function useTitleColumns(columnTitleProps) {
+	const filledColumns = (columns) => fillTitle(columns, columnTitleProps);
+	return [filledColumns];
+}
+//#endregion
+export { useTitleColumns as default };

package/dist/table/index.d.ts

@@ -0,0 +1,11 @@
+import { SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE } from "./hooks/useSelection.js";
+import { ColumnType, ColumnsType, ExpandType, FilterValue, SortOrder, SorterResult, TableLocale, TablePaginationConfig, TableRowSelection } from "./interface.js";
+import { TableClassNamesType, TableEmits, TableExpose, TableProps, TableSlots, TableStylesType } from "./InternalTable.js";
+import Column from "./Column.js";
+import ColumnGroup from "./ColumnGroup.js";
+import { ForwardTableType } from "./Table.js";
+import { DataIndex, EXPAND_COLUMN, Reference, Summary, SummaryCell, SummaryRow } from "@v-c/table";
+//#region src/table/index.d.ts
+declare const _default: ForwardTableType;
+//#endregion
+export { Column, ColumnGroup, type ColumnType, type ColumnsType, type DataIndex, EXPAND_COLUMN, type ExpandType, type FilterValue, type Reference, SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE, type SortOrder, type SorterResult, Summary, SummaryCell, SummaryRow, type TableClassNamesType, type ForwardTableType as TableConstructor, type TableEmits, type TableExpose, type TableLocale, type TablePaginationConfig, type TableProps, type TableRowSelection, type TableSlots, type TableStylesType, _default as default };

package/dist/table/index.js

@@ -0,0 +1,28 @@
+import Column from "./Column.js";
+import ColumnGroup from "./ColumnGroup.js";
+import { SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE } from "./hooks/useSelection.js";
+import ForwardTable from "./Table.js";
+import { EXPAND_COLUMN, Summary, SummaryCell, SummaryRow } from "@v-c/table";
+//#region src/table/index.tsx
+const InternalTable = ForwardTable;
+InternalTable.Column = Column;
+InternalTable.ColumnGroup = ColumnGroup;
+InternalTable.Summary = Summary;
+InternalTable.SummaryRow = SummaryRow;
+InternalTable.SummaryCell = SummaryCell;
+InternalTable.SELECTION_COLUMN = SELECTION_COLUMN;
+InternalTable.EXPAND_COLUMN = EXPAND_COLUMN;
+InternalTable.SELECTION_ALL = SELECTION_ALL;
+InternalTable.SELECTION_INVERT = SELECTION_INVERT;
+InternalTable.SELECTION_NONE = SELECTION_NONE;
+InternalTable.install = (app) => {
+	app.component(ForwardTable.name, ForwardTable);
+	app.component(Column.name, Column);
+	app.component(ColumnGroup.name, ColumnGroup);
+	app.component("ATableSummary", Summary);
+	app.component("ATableSummaryRow", SummaryRow);
+	app.component("ATableSummaryCell", SummaryCell);
+	return app;
+};
+//#endregion
+export { Column, ColumnGroup, EXPAND_COLUMN, SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE, Summary, SummaryCell, SummaryRow, InternalTable as default };

package/dist/table/interface.d.ts

@@ -0,0 +1,228 @@
+import { AnyObject, VueNode } from "../_util/type.js";
+import { Breakpoint } from "../_util/responsiveObserver.js";
+import { TooltipProps } from "../tooltip/index.js";
+import { PaginationEmits } from "../pagination/interface.js";
+import { PaginationProps } from "../pagination/index.js";
+import { CheckboxProps } from "../checkbox/Checkbox.js";
+import "../checkbox/index.js";
+import { DropdownProps } from "../dropdown/dropdown.js";
+import "../dropdown/index.js";
+import { INTERNAL_SELECTION_ITEM } from "./hooks/useSelection.js";
+import { ColumnType as ColumnType$1, ExpandableConfig, FixedType, GetComponentProps, GetRowKey, Reference, RenderedCell } from "@v-c/table";
+//#region src/table/interface.d.ts
+type Key = string | number;
+type SafeKey = Exclude<Key, bigint>;
+type RowSelectionType = 'checkbox' | 'radio';
+type SelectionItemSelectFn = (currentRowKeys: Key[]) => void;
+type ExpandType = null | 'row' | 'nest';
+interface TableLocale {
+  filterTitle?: VueNode;
+  filterConfirm?: VueNode;
+  filterReset?: VueNode;
+  filterEmptyText?: VueNode;
+  /**
+   * @deprecated Please use `filterCheckAll` instead.
+   */
+  filterCheckall?: VueNode;
+  filterCheckAll?: VueNode;
+  filterSearchPlaceholder?: string;
+  emptyText?: VueNode | (() => VueNode);
+  selectAll?: VueNode;
+  selectNone?: VueNode;
+  selectInvert?: VueNode;
+  selectionAll?: VueNode;
+  /** Accessible label for a selectable row. */
+  selectRow?: string;
+  /** Accessible label for a selected row. */
+  selectedRow?: string;
+  /** Accessible label for the custom selection menu trigger. */
+  selectionMenu?: string;
+  sortTitle?: string;
+  expand?: string;
+  collapse?: string;
+  expandAll?: string;
+  collapseAll?: string;
+  triggerDesc?: string;
+  triggerAsc?: string;
+  cancelSort?: string;
+}
+type SortOrder = 'descend' | 'ascend' | null;
+type SorterTooltipTarget = 'full-header' | 'sorter-icon';
+type SorterTooltipProps = TooltipProps & {
+  target?: SorterTooltipTarget;
+};
+declare const _TableActions: readonly ["paginate", "sort", "filter"];
+type TableAction = (typeof _TableActions)[number];
+type CompareFn<T = AnyObject> = (a: T, b: T, sortOrder?: SortOrder) => number;
+interface ColumnFilterItem {
+  text: VueNode;
+  value: Key | boolean;
+  children?: ColumnFilterItem[];
+}
+interface ColumnTitleProps<RecordType = AnyObject> {
+  /** @deprecated Will be remove in v7, Please use `sorterColumns` instead. */
+  sortOrder?: SortOrder;
+  /** @deprecated Will be remove in v7, Please use `sorterColumns` instead. */
+  sortColumn?: ColumnType<RecordType>;
+  sortColumns?: {
+    column: ColumnType<RecordType>;
+    order: SortOrder;
+  }[];
+  filters?: Record<string, FilterValue>;
+}
+type ColumnTitle<RecordType = AnyObject> = any | ((props: ColumnTitleProps<RecordType>) => any);
+type FilterValue = (Key | boolean)[];
+type FilterKey = (string | number)[] | null;
+type FilterSearchType<RecordType = AnyObject> = boolean | ((input: string, record: RecordType) => boolean);
+interface FilterConfirmProps {
+  closeDropdown: boolean;
+}
+interface FilterResetProps {
+  confirm?: boolean;
+  closeDropdown?: boolean;
+}
+/** @deprecated Please use `FilterResetProps` instead. */
+interface FilterRestProps extends FilterResetProps {}
+interface FilterDropdownProps {
+  prefixCls: string;
+  setSelectedKeys: (selectedKeys: Key[]) => void;
+  selectedKeys: Key[];
+  /**
+   * Confirm filter value, if you want to close dropdown before commit, you can call with
+   * {closeDropdown: true}
+   */
+  confirm: (param?: FilterConfirmProps) => void;
+  clearFilters?: (param?: FilterResetProps) => void;
+  filters?: ColumnFilterItem[];
+  /** Only close filterDropdown */
+  close: () => void;
+  visible: boolean;
+}
+interface CoverableDropdownProps extends DropdownProps {
+  onOpenChange?: (open: boolean) => void;
+}
+interface ColumnType<RecordType = AnyObject> extends Omit<ColumnType$1<RecordType>, 'title'> {
+  title?: ColumnTitle<RecordType>;
+  /**
+   * @version >= 1.5.5
+   * @nameZH 是否可以拖动调整列宽
+   * @nameEN Whether the column width can be resized
+   * @desc 在表头边缘拖动时显示代理线，松开后更新列宽并触发 `resizeColumn`；拖动下限为 `minWidth`（默认 40）。
+   * @descEN Shows a proxy line while dragging the header edge; on release the width is applied and `resizeColumn` fires. `minWidth` (default 40) is the lower bound.
+   */
+  resizable?: boolean;
+  sorter?: boolean | CompareFn<RecordType> | {
+    compare?: CompareFn<RecordType>;
+    /** Config multiple sorter order priority */
+    multiple?: number;
+  };
+  sortOrder?: SortOrder;
+  defaultSortOrder?: SortOrder;
+  sortDirections?: SortOrder[];
+  sortIcon?: (props: {
+    sortOrder: SortOrder;
+  }) => VueNode;
+  showSorterTooltip?: boolean | SorterTooltipProps;
+  filtered?: boolean;
+  filters?: ColumnFilterItem[];
+  filterDropdown?: VueNode | ((props: FilterDropdownProps) => VueNode);
+  filterOnClose?: boolean;
+  filterMultiple?: boolean;
+  filteredValue?: FilterValue | null;
+  defaultFilteredValue?: FilterValue | null;
+  filterIcon?: VueNode | ((filtered: boolean) => VueNode);
+  filterMode?: 'menu' | 'tree';
+  filterSearch?: FilterSearchType<ColumnFilterItem>;
+  onFilter?: (value: Key | boolean, record: RecordType) => boolean;
+  /**
+   * Can cover `<Dropdown>` props
+   */
+  filterDropdownProps?: CoverableDropdownProps;
+  filterResetToDefaultFilteredValue?: boolean;
+  responsive?: Breakpoint[];
+  /**
+   * @deprecated Please use `filterDropdownProps.open` instead.
+   */
+  filterDropdownOpen?: boolean;
+  /**
+   * @deprecated Please use `filterDropdownProps.onOpenChange` instead.
+   */
+  onFilterDropdownOpenChange?: (open: boolean) => void;
+}
+interface ColumnGroupType<RecordType = AnyObject> extends Omit<ColumnType<RecordType>, 'dataIndex'> {
+  children: ColumnsType<RecordType>;
+  /**
+   * A group column carries no `dataIndex`. Declaring it as `never` (rather than
+   * omitting it) keeps the property present across the `ColumnGroupType |
+   * ColumnType` union, so `column.dataIndex` stays directly accessible without
+   * narrowing (a group reads back as `undefined`), while still forbidding an
+   * actual value. Narrow to a group with `'children' in column`. See #673.
+   */
+  dataIndex?: never;
+  /** Group headers are not resizable; resize their leaf columns instead. Kept as `never` for the same reason as `dataIndex`. */
+  resizable?: never;
+}
+type ColumnsType<RecordType = AnyObject> = (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+interface SelectionItem {
+  key: string;
+  text: VueNode;
+  onSelect?: SelectionItemSelectFn;
+}
+type SelectionSelectFn<T = AnyObject> = (record: T, selected: boolean, selectedRows: T[], nativeEvent: Event) => void;
+type RowSelectMethod = 'all' | 'none' | 'invert' | 'single' | 'multiple';
+interface TableRowSelection<T = AnyObject> {
+  /** Keep the selection keys in list even the key not exist in `dataSource` anymore */
+  preserveSelectedRowKeys?: boolean;
+  type?: RowSelectionType;
+  selectedRowKeys?: Key[];
+  defaultSelectedRowKeys?: Key[];
+  onChange?: (selectedRowKeys: Key[], selectedRows: T[], info: {
+    type: RowSelectMethod;
+  }) => void;
+  getCheckboxProps?: (record: T) => Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked'>> & {
+    [key: `aria-${string}`]: any;
+  };
+  onSelect?: SelectionSelectFn<T>;
+  /** @deprecated This function will be remove in v7 and should use `onChange` instead */
+  onSelectMultiple?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+  /** @deprecated This function will be remove in v7 and should use `onChange` instead */
+  onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+  /** @deprecated This function will be remove in v7 and should use `onChange` instead */
+  onSelectInvert?: (selectedRowKeys: Key[]) => void;
+  /** @deprecated This function will be remove in v7 and should use `onChange` instead */
+  onSelectNone?: () => void;
+  selections?: INTERNAL_SELECTION_ITEM[] | boolean;
+  hideSelectAll?: boolean;
+  fixed?: FixedType;
+  columnWidth?: string | number;
+  columnTitle?: VueNode | ((checkboxNode: VueNode) => VueNode);
+  checkStrictly?: boolean;
+  /** Set the alignment of the selection column */
+  align?: 'left' | 'center' | 'right';
+  renderCell?: (value: boolean, record: T, index: number, originNode: VueNode) => VueNode | RenderedCell<T>;
+  onCell?: GetComponentProps<T>;
+  getTitleCheckboxProps?: () => Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked'>>;
+}
+type TransformColumns<RecordType = AnyObject> = (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>;
+interface TableCurrentDataSource<RecordType = AnyObject> {
+  currentDataSource: RecordType[];
+  action: TableAction;
+}
+interface SorterResult<RecordType = AnyObject> {
+  column?: ColumnType<RecordType>;
+  order?: SortOrder;
+  field?: Key | readonly Key[];
+  columnKey?: Key;
+}
+type GetPopupContainer = (triggerNode: HTMLElement) => HTMLElement;
+type TablePaginationPlacement = 'topStart' | 'topCenter' | 'topEnd' | 'bottomStart' | 'bottomCenter' | 'bottomEnd' | 'none';
+type TablePaginationPosition = 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'none';
+interface TablePaginationConfig extends PaginationProps {
+  placement?: TablePaginationPlacement[];
+  /** @deprecated please use `placement` instead */
+  position?: TablePaginationPosition[];
+  onChange?: PaginationEmits['change'];
+  onShowSizeChange?: PaginationEmits['showSizeChange'];
+}
+//#endregion
+export { ColumnFilterItem, ColumnGroupType, ColumnTitle, ColumnTitleProps, ColumnType, ColumnsType, CompareFn, CoverableDropdownProps, ExpandType, type ExpandableConfig, FilterConfirmProps, FilterDropdownProps, FilterKey, FilterResetProps, FilterRestProps, FilterSearchType, FilterValue, GetPopupContainer, type GetRowKey, Key, type Reference, RowSelectMethod, RowSelectionType, SafeKey, SelectionItem, SelectionItemSelectFn, SelectionSelectFn, SortOrder, SorterResult, SorterTooltipProps, SorterTooltipTarget, TableAction, TableCurrentDataSource, TableLocale, TablePaginationConfig, TablePaginationPlacement, TablePaginationPosition, TableRowSelection, TransformColumns };

package/dist/table/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/table/style/bordered.d.ts

@@ -0,0 +1,8 @@
+import { TableToken } from "./index.js";
+import { GenerateStyle } from "../../theme/interface/index.js";
+import "../../theme/internal.js";
+import { CSSObject } from "@antdv-next/cssinjs";
+//#region src/table/style/bordered.d.ts
+declare const genBorderedStyle: GenerateStyle<TableToken, CSSObject>;
+//#endregion
+export { genBorderedStyle as default };