@nocobase/plugin-client 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/locale/antd/table/hooks/useSorter.js

@@ -0,0 +1,351 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useFilterSorter;
+exports.getSortData = getSortData;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _CaretDownOutlined = _interopRequireDefault(require("@ant-design/icons/CaretDownOutlined"));
+var _CaretUpOutlined = _interopRequireDefault(require("@ant-design/icons/CaretUpOutlined"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _KeyCode = _interopRequireDefault(require("rc-util/lib/KeyCode"));
+var React = _interopRequireWildcard(require("react"));
+var _tooltip = _interopRequireDefault(require("../../tooltip"));
+var _util = require("../util");
+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 = [];
+  function pushState(column, columnPos) {
+    sortStates.push({
+      column,
+      key: (0, _util.getColumnKey)(column, columnPos),
+      multiplePriority: getMultiplePriority(column),
+      sortOrder: column.sortOrder
+    });
+  }
+  (columns || []).forEach((column, index) => {
+    const columnPos = (0, _util.getColumnPos)(index, pos);
+    if (column.children) {
+      if ('sortOrder' in column) {
+        // Controlled
+        pushState(column, columnPos);
+      }
+      sortStates = [].concat((0, _toConsumableArray2.default)(sortStates), (0, _toConsumableArray2.default)(collectSortStates(column.children, init, columnPos)));
+    } else if (column.sorter) {
+      if ('sortOrder' in column) {
+        // Controlled
+        pushState(column, columnPos);
+      } else if (init && column.defaultSortOrder) {
+        // Default sorter
+        sortStates.push({
+          column,
+          key: (0, _util.getColumnKey)(column, columnPos),
+          multiplePriority: getMultiplePriority(column),
+          sortOrder: column.defaultSortOrder
+        });
+      }
+    }
+  });
+  return sortStates;
+}
+function injectSorter(prefixCls, columns, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, pos) {
+  return (columns || []).map((column, index) => {
+    const columnPos = (0, _util.getColumnPos)(index, pos);
+    let newColumn = column;
+    if (newColumn.sorter) {
+      const sortDirections = newColumn.sortDirections || defaultSortDirections;
+      const showSorterTooltip = newColumn.showSorterTooltip === undefined ? tableShowSorterTooltip : newColumn.showSorterTooltip;
+      const columnKey = (0, _util.getColumnKey)(newColumn, columnPos);
+      const sorterState = sorterStates.find(_ref => {
+        let {
+          key
+        } = _ref;
+        return key === columnKey;
+      });
+      const sortOrder = sorterState ? sorterState.sortOrder : null;
+      const nextSortOrder = nextSortDirection(sortDirections, sortOrder);
+      let sorter;
+      if (column.sortIcon) {
+        sorter = column.sortIcon({
+          sortOrder
+        });
+      } else {
+        const upNode = sortDirections.includes(ASCEND) && /*#__PURE__*/React.createElement(_CaretUpOutlined.default, {
+          className: (0, _classnames.default)(`${prefixCls}-column-sorter-up`, {
+            active: sortOrder === ASCEND
+          })
+        });
+        const downNode = sortDirections.includes(DESCEND) && /*#__PURE__*/React.createElement(_CaretDownOutlined.default, {
+          className: (0, _classnames.default)(`${prefixCls}-column-sorter-down`, {
+            active: sortOrder === DESCEND
+          })
+        });
+        sorter = /*#__PURE__*/React.createElement("span", {
+          className: (0, _classnames.default)(`${prefixCls}-column-sorter`, {
+            [`${prefixCls}-column-sorter-full`]: !!(upNode && downNode)
+          })
+        }, /*#__PURE__*/React.createElement("span", {
+          className: `${prefixCls}-column-sorter-inner`,
+          "aria-hidden": "true"
+        }, upNode, downNode));
+      }
+      const {
+        cancelSort,
+        triggerAsc,
+        triggerDesc
+      } = tableLocale || {};
+      let sortTip = cancelSort;
+      if (nextSortOrder === DESCEND) {
+        sortTip = triggerDesc;
+      } else if (nextSortOrder === ASCEND) {
+        sortTip = triggerAsc;
+      }
+      const tooltipProps = typeof showSorterTooltip === 'object' ? showSorterTooltip : {
+        title: sortTip
+      };
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        className: (0, _classnames.default)(newColumn.className, {
+          [`${prefixCls}-column-sort`]: sortOrder
+        }),
+        title: renderProps => {
+          const renderSortTitle = /*#__PURE__*/React.createElement("div", {
+            className: `${prefixCls}-column-sorters`
+          }, /*#__PURE__*/React.createElement("span", {
+            className: `${prefixCls}-column-title`
+          }, (0, _util.renderColumnTitle)(column.title, renderProps)), sorter);
+          return showSorterTooltip ? /*#__PURE__*/React.createElement(_tooltip.default, Object.assign({}, tooltipProps), renderSortTitle) : renderSortTitle;
+        },
+        onHeaderCell: col => {
+          const cell = column.onHeaderCell && column.onHeaderCell(col) || {};
+          const originOnClick = cell.onClick;
+          const originOKeyDown = cell.onKeyDown;
+          cell.onClick = event => {
+            triggerSorter({
+              column,
+              key: columnKey,
+              sortOrder: nextSortOrder,
+              multiplePriority: getMultiplePriority(column)
+            });
+            originOnClick === null || originOnClick === void 0 ? void 0 : originOnClick(event);
+          };
+          cell.onKeyDown = event => {
+            if (event.keyCode === _KeyCode.default.ENTER) {
+              triggerSorter({
+                column,
+                key: columnKey,
+                sortOrder: nextSortOrder,
+                multiplePriority: getMultiplePriority(column)
+              });
+              originOKeyDown === null || originOKeyDown === void 0 ? void 0 : originOKeyDown(event);
+            }
+          };
+          const renderTitle = (0, _util.safeColumnTitle)(column.title, {});
+          const displayTitle = renderTitle === null || renderTitle === void 0 ? void 0 : renderTitle.toString();
+          // Inform the screen-reader so it can tell the visually impaired user which column is sorted
+          if (sortOrder) {
+            cell['aria-sort'] = sortOrder === 'ascend' ? 'ascending' : 'descending';
+          } else {
+            cell['aria-label'] = displayTitle || '';
+          }
+          cell.className = (0, _classnames.default)(cell.className, `${prefixCls}-column-has-sorters`);
+          cell.tabIndex = 0;
+          if (column.ellipsis) {
+            cell.title = (renderTitle !== null && renderTitle !== void 0 ? renderTitle : '').toString();
+          }
+          return cell;
+        }
+      });
+    }
+    if ('children' in newColumn) {
+      newColumn = Object.assign(Object.assign({}, newColumn), {
+        children: injectSorter(prefixCls, newColumn.children, sorterStates, triggerSorter, defaultSortDirections, tableLocale, tableShowSorterTooltip, columnPos)
+      });
+    }
+    return newColumn;
+  });
+}
+function stateToInfo(sorterStates) {
+  const {
+    column,
+    sortOrder
+  } = sorterStates;
+  return {
+    column,
+    order: sortOrder,
+    field: column.dataIndex,
+    columnKey: column.key
+  };
+}
+function generateSorterInfo(sorterStates) {
+  const list = sorterStates.filter(_ref2 => {
+    let {
+      sortOrder
+    } = _ref2;
+    return sortOrder;
+  }).map(stateToInfo);
+  // =========== Legacy compatible support ===========
+  // https://github.com/ant-design/ant-design/pull/19226
+  if (list.length === 0 && sorterStates.length) {
+    return Object.assign(Object.assign({}, stateToInfo(sorterStates[sorterStates.length - 1])), {
+      column: undefined
+    });
+  }
+  if (list.length <= 1) {
+    return list[0] || {};
+  }
+  return list;
+}
+function getSortData(data, sortStates, childrenColumnName) {
+  const innerSorterStates = sortStates.slice().sort((a, b) => b.multiplePriority - a.multiplePriority);
+  const cloneData = data.slice();
+  const runningSorters = innerSorterStates.filter(_ref3 => {
+    let {
+      column: {
+        sorter
+      },
+      sortOrder
+    } = _ref3;
+    return getSortFunction(sorter) && sortOrder;
+  });
+  // Skip if no sorter needed
+  if (!runningSorters.length) {
+    return cloneData;
+  }
+  return cloneData.sort((record1, record2) => {
+    for (let i = 0; i < runningSorters.length; i += 1) {
+      const sorterState = runningSorters[i];
+      const {
+        column: {
+          sorter
+        },
+        sortOrder
+      } = sorterState;
+      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 Object.assign(Object.assign({}, record), {
+        [childrenColumnName]: getSortData(subRecords, sortStates, childrenColumnName)
+      });
+    }
+    return record;
+  });
+}
+function useFilterSorter(_ref4) {
+  let {
+    prefixCls,
+    mergedColumns,
+    onSorterChange,
+    sortDirections,
+    tableLocale,
+    showSorterTooltip
+  } = _ref4;
+  const [sortStates, setSortStates] = React.useState(collectSortStates(mergedColumns, true));
+  const mergedSorterStates = React.useMemo(() => {
+    let validate = true;
+    const collectedStates = collectSortStates(mergedColumns, false);
+    // Return if not controlled
+    if (!collectedStates.length) {
+      return sortStates;
+    }
+    const validateStates = [];
+    function patchStates(state) {
+      if (validate) {
+        validateStates.push(state);
+      } else {
+        validateStates.push(Object.assign(Object.assign({}, 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;
+  }, [mergedColumns, sortStates]);
+  // Get render columns title required props
+  const columnTitleSorterProps = React.useMemo(() => {
+    const sortColumns = mergedSorterStates.map(_ref5 => {
+      let {
+        column,
+        sortOrder
+      } = _ref5;
+      return {
+        column,
+        order: sortOrder
+      };
+    });
+    return {
+      sortColumns,
+      // Legacy
+      sortColumn: sortColumns[0] && sortColumns[0].column,
+      sortOrder: sortColumns[0] && sortColumns[0].order
+    };
+  }, [mergedSorterStates]);
+  function triggerSorter(sortState) {
+    let newSorterStates;
+    if (sortState.multiplePriority === false || !mergedSorterStates.length || mergedSorterStates[0].multiplePriority === false) {
+      newSorterStates = [sortState];
+    } else {
+      newSorterStates = [].concat((0, _toConsumableArray2.default)(mergedSorterStates.filter(_ref6 => {
+        let {
+          key
+        } = _ref6;
+        return key !== sortState.key;
+      })), [sortState]);
+    }
+    setSortStates(newSorterStates);
+    onSorterChange(generateSorterInfo(newSorterStates), newSorterStates);
+  }
+  const transformColumns = innerColumns => injectSorter(prefixCls, innerColumns, mergedSorterStates, triggerSorter, sortDirections, tableLocale, showSorterTooltip);
+  const getSorters = () => generateSorterInfo(mergedSorterStates);
+  return [transformColumns, mergedSorterStates, columnTitleSorterProps, getSorters];
+}

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

@@ -0,0 +1,2 @@
+import type { ColumnTitleProps, TransformColumns } from '../interface';
+export default function useTitleColumns<RecordType>(columnTitleProps: ColumnTitleProps<RecordType>): [TransformColumns<RecordType>];

package/dist/locale/antd/table/hooks/useTitleColumns.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useTitleColumns;
+var React = _interopRequireWildcard(require("react"));
+var _util = require("../util");
+function fillTitle(columns, columnTitleProps) {
+  return columns.map(column => {
+    const cloneColumn = Object.assign({}, column);
+    cloneColumn.title = (0, _util.renderColumnTitle)(column.title, columnTitleProps);
+    if ('children' in cloneColumn) {
+      cloneColumn.children = fillTitle(cloneColumn.children, columnTitleProps);
+    }
+    return cloneColumn;
+  });
+}
+function useTitleColumns(columnTitleProps) {
+  const filledColumns = React.useCallback(columns => fillTitle(columns, columnTitleProps), [columnTitleProps]);
+  return [filledColumns];
+}

package/dist/locale/antd/table/index.d.ts

@@ -0,0 +1,6 @@
+import { type TablePaginationConfig, type TableProps } from './InternalTable';
+import Table from './Table';
+export type { ColumnProps } from './Column';
+export type { ColumnGroupType, ColumnType, ColumnsType } from './interface';
+export type { TablePaginationConfig, TableProps };
+export default Table;

package/dist/locale/antd/table/index.js

@@ -0,0 +1,11 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Table = _interopRequireDefault(require("./Table"));
+var _default = _Table.default;
+exports.default = _default;

package/dist/locale/antd/table/interface.d.ts

@@ -0,0 +1,170 @@
+import type { FixedType, GetComponentProps, ColumnType as RcColumnType, RenderedCell as RcRenderedCell } from 'rc-table/lib/interface';
+import { ExpandableConfig, GetRowKey } from 'rc-table/lib/interface';
+import type * as React from 'react';
+import type { Breakpoint } from '../_util/responsiveObserver';
+import type { AnyObject } from '../_util/type';
+import type { CheckboxProps } from '../checkbox';
+import type { PaginationProps } from '../pagination';
+import type { TooltipProps } from '../tooltip';
+import type { InternalTableProps, TableProps } from './InternalTable';
+import type { INTERNAL_SELECTION_ITEM } from './hooks/useSelection';
+export type RefTable = <RecordType extends AnyObject = AnyObject>(props: React.PropsWithChildren<TableProps<RecordType>> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;
+export type RefInternalTable = <RecordType extends AnyObject = AnyObject>(props: React.PropsWithChildren<InternalTableProps<RecordType>> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;
+export { ExpandableConfig, GetRowKey };
+export type Key = React.Key;
+export type RowSelectionType = 'checkbox' | 'radio';
+export type SelectionItemSelectFn = (currentRowKeys: Key[]) => void;
+export type ExpandType = null | 'row' | 'nest';
+export interface TableLocale {
+    filterTitle?: string;
+    filterConfirm?: React.ReactNode;
+    filterReset?: React.ReactNode;
+    filterEmptyText?: React.ReactNode;
+    filterCheckall?: React.ReactNode;
+    filterSearchPlaceholder?: string;
+    emptyText?: React.ReactNode | (() => React.ReactNode);
+    selectAll?: React.ReactNode;
+    selectNone?: React.ReactNode;
+    selectInvert?: React.ReactNode;
+    selectionAll?: React.ReactNode;
+    sortTitle?: string;
+    expand?: string;
+    collapse?: string;
+    triggerDesc?: string;
+    triggerAsc?: string;
+    cancelSort?: string;
+}
+export type SortOrder = 'descend' | 'ascend' | null;
+declare const TableActions: readonly ["paginate", "sort", "filter"];
+export type TableAction = (typeof TableActions)[number];
+export type CompareFn<T> = (a: T, b: T, sortOrder?: SortOrder) => number;
+export interface ColumnFilterItem {
+    text: React.ReactNode;
+    value: string | number | boolean;
+    children?: ColumnFilterItem[];
+}
+export interface ColumnTitleProps<RecordType> {
+    /** @deprecated Please use `sorterColumns` instead. */
+    sortOrder?: SortOrder;
+    /** @deprecated Please use `sorterColumns` instead. */
+    sortColumn?: ColumnType<RecordType>;
+    sortColumns?: {
+        column: ColumnType<RecordType>;
+        order: SortOrder;
+    }[];
+    filters?: Record<string, FilterValue>;
+}
+export type ColumnTitle<RecordType> = React.ReactNode | ((props: ColumnTitleProps<RecordType>) => React.ReactNode);
+export type FilterValue = (Key | boolean)[];
+export type FilterKey = Key[] | null;
+export type FilterSearchType<RecordType = AnyObject> = boolean | ((input: string, record: RecordType) => boolean);
+export interface FilterConfirmProps {
+    closeDropdown: boolean;
+}
+export interface FilterDropdownProps {
+    prefixCls: string;
+    setSelectedKeys: (selectedKeys: React.Key[]) => void;
+    selectedKeys: React.Key[];
+    /**
+     * Confirm filter value, if you want to close dropdown before commit, you can call with
+     * {closeDropdown: true}
+     */
+    confirm: (param?: FilterConfirmProps) => void;
+    clearFilters?: () => void;
+    filters?: ColumnFilterItem[];
+    /** Only close filterDropdown */
+    close: () => void;
+    visible: boolean;
+}
+export interface ColumnType<RecordType> extends Omit<RcColumnType<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;
+    }) => React.ReactNode;
+    showSorterTooltip?: boolean | TooltipProps;
+    filtered?: boolean;
+    filters?: ColumnFilterItem[];
+    filterDropdown?: React.ReactNode | ((props: FilterDropdownProps) => React.ReactNode);
+    filterMultiple?: boolean;
+    filteredValue?: FilterValue | null;
+    defaultFilteredValue?: FilterValue | null;
+    filterIcon?: React.ReactNode | ((filtered: boolean) => React.ReactNode);
+    filterMode?: 'menu' | 'tree';
+    filterSearch?: FilterSearchType<ColumnFilterItem>;
+    onFilter?: (value: string | number | boolean, record: RecordType) => boolean;
+    filterDropdownOpen?: boolean;
+    onFilterDropdownOpenChange?: (visible: boolean) => void;
+    filterResetToDefaultFilteredValue?: boolean;
+    responsive?: Breakpoint[];
+    /** @deprecated Please use `filterDropdownOpen` instead */
+    filterDropdownVisible?: boolean;
+    /** @deprecated Please use `onFilterDropdownOpenChange` instead */
+    onFilterDropdownVisibleChange?: (visible: boolean) => void;
+}
+export interface ColumnGroupType<RecordType> extends Omit<ColumnType<RecordType>, 'dataIndex'> {
+    children: ColumnsType<RecordType>;
+}
+export type ColumnsType<RecordType = unknown> = (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export interface SelectionItem {
+    key: string;
+    text: React.ReactNode;
+    onSelect?: SelectionItemSelectFn;
+}
+export type SelectionSelectFn<T> = (record: T, selected: boolean, selectedRows: T[], nativeEvent: Event) => void;
+export type RowSelectMethod = 'all' | 'none' | 'invert' | 'single' | 'multiple';
+export interface TableRowSelection<T> {
+    /** 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 is deprecated and should use `onChange` instead */
+    onSelectMultiple?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectInvert?: (selectedRowKeys: Key[]) => void;
+    /** @deprecated This function is deprecated and should use `onChange` instead */
+    onSelectNone?: () => void;
+    selections?: INTERNAL_SELECTION_ITEM[] | boolean;
+    hideSelectAll?: boolean;
+    fixed?: FixedType;
+    columnWidth?: string | number;
+    columnTitle?: string | React.ReactNode;
+    checkStrictly?: boolean;
+    renderCell?: (value: boolean, record: T, index: number, originNode: React.ReactNode) => React.ReactNode | RcRenderedCell<T>;
+    onCell?: GetComponentProps<T>;
+}
+export type TransformColumns<RecordType> = (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>;
+export interface TableCurrentDataSource<RecordType> {
+    currentDataSource: RecordType[];
+    action: TableAction;
+}
+export interface SorterResult<RecordType> {
+    column?: ColumnType<RecordType>;
+    order?: SortOrder;
+    field?: Key | readonly Key[];
+    columnKey?: Key;
+}
+export type GetPopupContainer = (triggerNode: HTMLElement) => HTMLElement;
+type TablePaginationPosition = 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight';
+export interface TablePaginationConfig extends PaginationProps {
+    position?: TablePaginationPosition[];
+}

package/dist/locale/antd/table/interface.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const TableActions = ['paginate', 'sort', 'filter'];

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

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { GenerateStyle } from '../../theme/internal';
+import type { TableToken } from './index';
+declare const genBorderedStyle: GenerateStyle<TableToken, CSSObject>;
+export default genBorderedStyle;