antdv-next 0.0.0 → 1.0.0-alpha.1

package/dist/table/hooks/useSorter.js

@@ -0,0 +1,263 @@
+import tooltip_default 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 "@antdv-next/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(tooltip_default, tooltipProps, _isSlot(sorter) ? sorter : { default: () => [sorter] })]);
+						return createVNode(tooltip_default, 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.filter(({ sortOrder }) => sortOrder).map(stateToInfo);
+	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, sortDirections: rawSortDirections, tableLocale: rawTableLocale, showSorterTooltip: rawShowSorterTooltip, onSorterChange, globalLocale: rawGlobalLocale } = props;
+	const prefixCls = computed(() => unref(rawPrefixCls));
+	const mergedColumns = computed(() => unref(rawMergedColumns));
+	const sortDirections = computed(() => unref(rawSortDirections));
+	const tableLocale = computed(() => unref(rawTableLocale));
+	const showSorterTooltip = computed(() => unref(rawShowSorterTooltip));
+	const globalLocale = computed(() => unref(rawGlobalLocale));
+	const sortStates = shallowRef(collectSortStates(mergedColumns.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(mergedColumns.value, false);
+		if (!collectedStates.length) {
+			const mergedColumnsKeys = getColumnKeys(mergedColumns.value);
+			return sortStates.value.filter(({ key }) => mergedColumnsKeys.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/useTitleColumns.js

@@ -0,0 +1,18 @@
+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,25 @@
+import { SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE } from "./hooks/useSelection.js";
+import { ColumnType, ColumnsType, FilterValue, SortOrder, SorterResult, TableLocale, TablePaginationConfig, TableRowSelection } from "./interface.js";
+import { Column } from "./Column.js";
+import { ColumnGroup } from "./ColumnGroup.js";
+import { TableClassNamesType, TableEmits, TableProps as TableProps$1, TableSlots, TableStylesType } from "./InternalTable.js";
+import { ForwardTable } from "./Table.js";
+import { App } from "vue";
+import { DataIndex, EXPAND_COLUMN as EXPAND_COLUMN$1, Summary as Summary$1, SummaryCell, SummaryRow } from "@v-c/table";
+
+//#region src/table/index.d.ts
+declare const InternalTable: typeof ForwardTable & {
+  install: (app: App) => void;
+  Column: typeof Column;
+  ColumnGroup: typeof ColumnGroup;
+  Summary: typeof Summary$1;
+  SummaryRow: typeof SummaryRow;
+  SummaryCell: typeof SummaryCell;
+  SELECTION_COLUMN: typeof SELECTION_COLUMN;
+  EXPAND_COLUMN: typeof EXPAND_COLUMN$1;
+  SELECTION_ALL: typeof SELECTION_ALL;
+  SELECTION_INVERT: typeof SELECTION_INVERT;
+  SELECTION_NONE: typeof SELECTION_NONE;
+};
+//#endregion
+export { type DataIndex, InternalTable, Summary$1 as Summary, SummaryCell, SummaryRow };

package/dist/table/index.js

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

package/dist/table/interface.d.ts

@@ -0,0 +1,199 @@
+import { Breakpoint } from "../_util/responsiveObserver.js";
+import { AnyObject, VueNode } from "../_util/type.js";
+import { TooltipProps } from "../tooltip/index.js";
+import { PaginationEmits, PaginationProps } from "../pagination/interface.js";
+import "../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 * as _v_c_table0 from "@v-c/table";
+import { FixedType, GetComponentProps, RenderedCell } from "@v-c/table";
+
+//#region src/table/interface.d.ts
+type Key = string | number;
+type RowSelectionType = 'checkbox' | 'radio';
+type SelectionItemSelectFn = (currentRowKeys: Key[]) => void;
+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;
+  sortTitle?: string;
+  expand?: string;
+  collapse?: 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 FilterSearchType<RecordType = AnyObject> = boolean | ((input: string, record: RecordType) => boolean);
+interface FilterConfirmProps {
+  closeDropdown: boolean;
+}
+interface FilterRestProps {
+  confirm?: boolean;
+  closeDropdown?: boolean;
+}
+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?: FilterRestProps) => void;
+  filters?: ColumnFilterItem[];
+  /** Only close filterDropdown */
+  close: () => void;
+  visible: boolean;
+}
+interface CoverableDropdownProps extends DropdownProps {
+  onOpenChange?: (open: boolean) => void;
+}
+interface ColumnType<RecordType = AnyObject> extends Omit<_v_c_table0.ColumnType<RecordType>, 'title'> {
+  title?: ColumnTitle<RecordType>;
+  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
+   * @since 5.22.0
+   */
+  filterDropdownProps?: CoverableDropdownProps;
+  filterResetToDefaultFilteredValue?: boolean;
+  responsive?: Breakpoint[];
+  /**
+   * @deprecated Please use `filterDropdownProps.open` instead.
+   * @since 4.23.0
+   */
+  filterDropdownOpen?: boolean;
+  /**
+   * @deprecated Please use `filterDropdownProps.onOpenChange` instead.
+   * @since 4.23.0
+   */
+  onFilterDropdownOpenChange?: (visible: boolean) => void;
+}
+interface ColumnGroupType<RecordType = AnyObject> extends Omit<ColumnType<RecordType>, 'dataIndex'> {
+  children: ColumnsType<RecordType>;
+}
+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'>>;
+  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'>>;
+}
+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 { ColumnType, ColumnsType, FilterDropdownProps, FilterValue, GetPopupContainer, Key, SelectionItem, SortOrder, SorterResult, SorterTooltipProps, TableCurrentDataSource, TableLocale, TablePaginationConfig, TableRowSelection };

package/dist/table/style/bordered.js

@@ -0,0 +1,81 @@
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/table/style/bordered.ts
+const genBorderedStyle = (token) => {
+	const { componentCls, lineWidth, lineType, tableBorderColor, tableHeaderBg, tablePaddingVertical, tablePaddingHorizontal, calc } = token;
+	const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+	const getSizeBorderStyle = (size, paddingVertical, paddingHorizontal) => ({ [`&${componentCls}-${size}`]: { [`> ${componentCls}-container`]: { [`> ${componentCls}-content, > ${componentCls}-body`]: { [`
+            > table > tbody > tr > th,
+            > table > tbody > tr > td
+          `]: { [`> ${componentCls}-expanded-row-fixed`]: { margin: `${unit(calc(paddingVertical).mul(-1).equal())}
+              ${unit(calc(calc(paddingHorizontal).add(lineWidth)).mul(-1).equal())}` } } } } } });
+	return { [`${componentCls}-wrapper`]: {
+		[`${componentCls}${componentCls}-bordered`]: {
+			[`> ${componentCls}-title`]: {
+				border: tableBorder,
+				borderBottom: 0
+			},
+			[`> ${componentCls}-container`]: {
+				borderInlineStart: tableBorder,
+				borderTop: tableBorder,
+				[`
+            > ${componentCls}-content,
+            > ${componentCls}-header,
+            > ${componentCls}-body,
+            > ${componentCls}-summary
+          `]: { "> table": {
+					[`
+                > thead > tr > th,
+                > thead > tr > td,
+                > tbody > tr > th,
+                > tbody > tr > td,
+                > tfoot > tr > th,
+                > tfoot > tr > td
+              `]: { borderInlineEnd: tableBorder },
+					"> thead": {
+						"> tr:not(:last-child) > th": { borderBottom: tableBorder },
+						"> tr > th::before": { backgroundColor: "transparent !important" }
+					},
+					[`
+                > thead > tr,
+                > tbody > tr,
+                > tfoot > tr
+              `]: { [`> ${componentCls}-cell-fix-right-first::after`]: { borderInlineEnd: tableBorder } },
+					[`
+                > tbody > tr > th,
+                > tbody > tr > td
+              `]: { [`> ${componentCls}-expanded-row-fixed`]: {
+						"margin": `${unit(calc(tablePaddingVertical).mul(-1).equal())} ${unit(calc(calc(tablePaddingHorizontal).add(lineWidth)).mul(-1).equal())}`,
+						"&::after": {
+							position: "absolute",
+							top: 0,
+							insetInlineEnd: lineWidth,
+							bottom: 0,
+							borderInlineEnd: tableBorder,
+							content: "\"\""
+						}
+					} }
+				} }
+			},
+			[`&${componentCls}-scroll-horizontal`]: { [`> ${componentCls}-container > ${componentCls}-body`]: { "> table > tbody": { [`
+                > tr${componentCls}-expanded-row,
+                > tr${componentCls}-placeholder
+              `]: { "> th, > td": { borderInlineEnd: 0 } } } } },
+			...getSizeBorderStyle("middle", token.tablePaddingVerticalMiddle, token.tablePaddingHorizontalMiddle),
+			...getSizeBorderStyle("small", token.tablePaddingVerticalSmall, token.tablePaddingHorizontalSmall),
+			[`> ${componentCls}-footer`]: {
+				border: tableBorder,
+				borderTop: 0
+			}
+		},
+		[`${componentCls}-cell`]: {
+			[`${componentCls}-container:first-child`]: { borderTop: 0 },
+			"&-scrollbar:not([rowspan])": { boxShadow: `0 ${unit(lineWidth)} 0 ${unit(lineWidth)} ${tableHeaderBg}` }
+		},
+		[`${componentCls}-bordered ${componentCls}-cell-scrollbar`]: { borderInlineEnd: tableBorder }
+	} };
+};
+var bordered_default = genBorderedStyle;
+
+//#endregion
+export { bordered_default as default };

package/dist/table/style/ellipsis.js

@@ -0,0 +1,28 @@
+import { textEllipsis } from "../../style/index.js";
+
+//#region src/table/style/ellipsis.ts
+const genEllipsisStyle = (token) => {
+	const { componentCls } = token;
+	return { [`${componentCls}-wrapper`]: { [`${componentCls}-cell-ellipsis`]: {
+		...textEllipsis,
+		wordBreak: "keep-all",
+		[`
+          &${componentCls}-cell-fix-start-shadow,
+          &${componentCls}-cell-fix-end-shadow
+        `]: {
+			overflow: "visible",
+			[`${componentCls}-cell-content`]: {
+				...textEllipsis,
+				display: "block"
+			}
+		},
+		[`${componentCls}-column-title`]: {
+			...textEllipsis,
+			wordBreak: "keep-all"
+		}
+	} } };
+};
+var ellipsis_default = genEllipsisStyle;
+
+//#endregion
+export { ellipsis_default as default };

package/dist/table/style/empty.js

@@ -0,0 +1,16 @@
+//#region src/table/style/empty.ts
+const genEmptyStyle = (token) => {
+	const { componentCls } = token;
+	return { [`${componentCls}-wrapper`]: { [`${componentCls}-tbody > tr${componentCls}-placeholder`]: {
+		textAlign: "center",
+		color: token.colorTextDisabled,
+		[`
+          &:hover > th,
+          &:hover > td,
+        `]: { background: token.colorBgContainer }
+	} } };
+};
+var empty_default = genEmptyStyle;
+
+//#endregion
+export { empty_default as default };