@nocobase/plugin-client 0.13.0-alpha.1 → 0.13.0-alpha.2

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

@@ -1,351 +0,0 @@
-"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

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

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

@@ -1,23 +0,0 @@
-"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

@@ -1,6 +0,0 @@
-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

@@ -1,11 +0,0 @@
-"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

@@ -1,170 +0,0 @@
-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

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

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

@@ -1,5 +0,0 @@
-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;