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

package/dist/locale/antd/transfer/style/index.js

@@ -0,0 +1,324 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _style = require("../../style");
+var _internal = require("../../theme/internal");
+const genTransferCustomizeStyle = token => {
+  const {
+    antCls,
+    componentCls,
+    listHeight,
+    controlHeightLG,
+    marginXXS,
+    margin
+  } = token;
+  const tableCls = `${antCls}-table`;
+  const inputCls = `${antCls}-input`;
+  return {
+    [`${componentCls}-customize-list`]: {
+      [`${componentCls}-list`]: {
+        flex: '1 1 50%',
+        width: 'auto',
+        height: 'auto',
+        minHeight: listHeight
+      },
+      // =================== Hook Components ===================
+      [`${tableCls}-wrapper`]: {
+        [`${tableCls}-small`]: {
+          border: 0,
+          borderRadius: 0,
+          [`${tableCls}-selection-column`]: {
+            width: controlHeightLG,
+            minWidth: controlHeightLG
+          }
+        },
+        [`${tableCls}-pagination${tableCls}-pagination`]: {
+          margin: `${margin}px 0 ${marginXXS}px`
+        }
+      },
+      [`${inputCls}[disabled]`]: {
+        backgroundColor: 'transparent'
+      }
+    }
+  };
+};
+const genTransferStatusColor = (token, color) => {
+  const {
+    componentCls,
+    colorBorder
+  } = token;
+  return {
+    [`${componentCls}-list`]: {
+      borderColor: color,
+      '&-search:not([disabled])': {
+        borderColor: colorBorder
+      }
+    }
+  };
+};
+const genTransferStatusStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`${componentCls}-status-error`]: Object.assign({}, genTransferStatusColor(token, token.colorError)),
+    [`${componentCls}-status-warning`]: Object.assign({}, genTransferStatusColor(token, token.colorWarning))
+  };
+};
+const genTransferListStyle = token => {
+  const {
+    componentCls,
+    colorBorder,
+    colorSplit,
+    lineWidth,
+    itemHeight,
+    headerHeight,
+    transferHeaderVerticalPadding,
+    itemPaddingBlock,
+    controlItemBgActive,
+    colorTextDisabled,
+    listHeight,
+    listWidth,
+    listWidthLG,
+    fontSizeIcon,
+    marginXS,
+    paddingSM,
+    lineType,
+    antCls,
+    iconCls,
+    motionDurationSlow,
+    controlItemBgHover,
+    borderRadiusLG,
+    colorBgContainer,
+    colorText,
+    controlItemBgActiveHover
+  } = token;
+  return {
+    display: 'flex',
+    flexDirection: 'column',
+    width: listWidth,
+    height: listHeight,
+    border: `${lineWidth}px ${lineType} ${colorBorder}`,
+    borderRadius: token.borderRadiusLG,
+    '&-with-pagination': {
+      width: listWidthLG,
+      height: 'auto'
+    },
+    '&-search': {
+      [`${iconCls}-search`]: {
+        color: colorTextDisabled
+      }
+    },
+    '&-header': {
+      display: 'flex',
+      flex: 'none',
+      alignItems: 'center',
+      height: headerHeight,
+      // border-top is on the transfer dom. We should minus 1px for this
+      padding: `${transferHeaderVerticalPadding - lineWidth}px ${paddingSM}px ${transferHeaderVerticalPadding}px`,
+      color: colorText,
+      background: colorBgContainer,
+      borderBottom: `${lineWidth}px ${lineType} ${colorSplit}`,
+      borderRadius: `${borderRadiusLG}px ${borderRadiusLG}px 0 0`,
+      '> *:not(:last-child)': {
+        marginInlineEnd: 4 // This is magic and fixed number, DO NOT use token since it may change.
+      },
+
+      '> *': {
+        flex: 'none'
+      },
+      '&-title': Object.assign(Object.assign({}, _style.textEllipsis), {
+        flex: 'auto',
+        textAlign: 'end'
+      }),
+      '&-dropdown': Object.assign(Object.assign({}, (0, _style.resetIcon)()), {
+        fontSize: fontSizeIcon,
+        transform: 'translateY(10%)',
+        cursor: 'pointer',
+        '&[disabled]': {
+          cursor: 'not-allowed'
+        }
+      })
+    },
+    '&-body': {
+      display: 'flex',
+      flex: 'auto',
+      flexDirection: 'column',
+      fontSize: token.fontSize,
+      // https://blog.csdn.net/qq449245884/article/details/107373672/
+      minHeight: 0,
+      '&-search-wrapper': {
+        position: 'relative',
+        flex: 'none',
+        padding: paddingSM
+      }
+    },
+    '&-content': {
+      flex: 'auto',
+      margin: 0,
+      padding: 0,
+      overflow: 'auto',
+      listStyle: 'none',
+      '&-item': {
+        display: 'flex',
+        alignItems: 'center',
+        minHeight: itemHeight,
+        padding: `${itemPaddingBlock}px ${paddingSM}px`,
+        transition: `all ${motionDurationSlow}`,
+        '> *:not(:last-child)': {
+          marginInlineEnd: marginXS
+        },
+        '> *': {
+          flex: 'none'
+        },
+        '&-text': Object.assign(Object.assign({}, _style.textEllipsis), {
+          flex: 'auto'
+        }),
+        '&-remove': {
+          position: 'relative',
+          color: colorBorder,
+          cursor: 'pointer',
+          transition: `all ${motionDurationSlow}`,
+          '&:hover': {
+            color: token.colorLinkHover
+          },
+          '&::after': {
+            position: 'absolute',
+            inset: `-${itemPaddingBlock}px -50%`,
+            content: '""'
+          }
+        },
+        [`&:not(${componentCls}-list-content-item-disabled)`]: {
+          '&:hover': {
+            backgroundColor: controlItemBgHover,
+            cursor: 'pointer'
+          },
+          [`&${componentCls}-list-content-item-checked:hover`]: {
+            backgroundColor: controlItemBgActiveHover
+          }
+        },
+        '&-checked': {
+          backgroundColor: controlItemBgActive
+        },
+        '&-disabled': {
+          color: colorTextDisabled,
+          cursor: 'not-allowed'
+        }
+      },
+      // Do not change hover style when `oneWay` mode
+      [`&-show-remove ${componentCls}-list-content-item:not(${componentCls}-list-content-item-disabled):hover`]: {
+        background: 'transparent',
+        cursor: 'default'
+      }
+    },
+    '&-pagination': {
+      padding: `${token.paddingXS}px 0`,
+      textAlign: 'end',
+      borderTop: `${lineWidth}px ${lineType} ${colorSplit}`,
+      [`${antCls}-pagination-options`]: {
+        paddingInlineEnd: token.paddingXS
+      }
+    },
+    '&-body-not-found': {
+      flex: 'none',
+      width: '100%',
+      margin: 'auto 0',
+      color: colorTextDisabled,
+      textAlign: 'center'
+    },
+    '&-footer': {
+      borderTop: `${lineWidth}px ${lineType} ${colorSplit}`
+    }
+  };
+};
+const genTransferStyle = token => {
+  const {
+    antCls,
+    iconCls,
+    componentCls,
+    headerHeight,
+    marginXS,
+    marginXXS,
+    fontSizeIcon,
+    fontSize,
+    lineHeight,
+    colorBgContainerDisabled
+  } = token;
+  return {
+    [componentCls]: Object.assign(Object.assign({}, (0, _style.resetComponent)(token)), {
+      position: 'relative',
+      display: 'flex',
+      alignItems: 'stretch',
+      [`${componentCls}-disabled`]: {
+        [`${componentCls}-list`]: {
+          background: colorBgContainerDisabled
+        }
+      },
+      [`${componentCls}-list`]: genTransferListStyle(token),
+      [`${componentCls}-operation`]: {
+        display: 'flex',
+        flex: 'none',
+        flexDirection: 'column',
+        alignSelf: 'center',
+        margin: `0 ${marginXS}px`,
+        verticalAlign: 'middle',
+        [`${antCls}-btn`]: {
+          display: 'block',
+          '&:first-child': {
+            marginBottom: marginXXS
+          },
+          [iconCls]: {
+            fontSize: fontSizeIcon
+          }
+        }
+      },
+      [`${antCls}-empty-image`]: {
+        maxHeight: headerHeight / 2 - Math.round(fontSize * lineHeight)
+      }
+    })
+  };
+};
+const genTransferRTLStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`${componentCls}-rtl`]: {
+      direction: 'rtl'
+    }
+  };
+};
+// ============================== Export ==============================
+var _default = (0, _internal.genComponentStyleHook)('Transfer', token => {
+  const {
+    fontSize,
+    lineHeight,
+    lineWidth,
+    controlHeightLG
+  } = token;
+  const fontHeight = Math.round(fontSize * lineHeight);
+  const transferToken = (0, _internal.mergeToken)(token, {
+    transferHeaderVerticalPadding: Math.ceil((controlHeightLG - lineWidth - fontHeight) / 2)
+  });
+  return [genTransferStyle(transferToken), genTransferCustomizeStyle(transferToken), genTransferStatusStyle(transferToken), genTransferRTLStyle(transferToken)];
+}, token => {
+  const {
+    fontSize,
+    lineHeight,
+    controlHeight,
+    controlHeightLG
+  } = token;
+  const fontHeight = Math.round(fontSize * lineHeight);
+  return {
+    listWidth: 180,
+    listHeight: 200,
+    listWidthLG: 250,
+    headerHeight: controlHeightLG,
+    itemHeight: controlHeight,
+    itemPaddingBlock: (controlHeight - fontHeight) / 2
+  };
+});
+exports.default = _default;

package/dist/locale/antd/tree/DirectoryTree.d.ts

@@ -0,0 +1,20 @@
+import type RcTree from 'rc-tree';
+import type { BasicDataNode } from 'rc-tree';
+import type { DataNode, Key } from 'rc-tree/lib/interface';
+import * as React from 'react';
+import type { TreeProps } from './Tree';
+export type ExpandAction = false | 'click' | 'doubleClick';
+export interface DirectoryTreeProps<T extends BasicDataNode = DataNode> extends TreeProps<T> {
+    expandAction?: ExpandAction;
+}
+type DirectoryTreeCompoundedComponent = (<T extends BasicDataNode | DataNode = DataNode>(props: React.PropsWithChildren<DirectoryTreeProps<T>> & {
+    ref?: React.Ref<RcTree>;
+}) => React.ReactElement) & {
+    displayName?: string;
+};
+export interface DirectoryTreeState {
+    expandedKeys?: Key[];
+    selectedKeys?: Key[];
+}
+declare const ForwardDirectoryTree: DirectoryTreeCompoundedComponent;
+export default ForwardDirectoryTree;

package/dist/locale/antd/tree/DirectoryTree.js

@@ -0,0 +1,175 @@
+"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 = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _FileOutlined = _interopRequireDefault(require("@ant-design/icons/FileOutlined"));
+var _FolderOpenOutlined = _interopRequireDefault(require("@ant-design/icons/FolderOpenOutlined"));
+var _FolderOutlined = _interopRequireDefault(require("@ant-design/icons/FolderOutlined"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _util = require("rc-tree/lib/util");
+var _treeUtil = require("rc-tree/lib/utils/treeUtil");
+var React = _interopRequireWildcard(require("react"));
+var _configProvider = require("../config-provider");
+var _Tree = _interopRequireDefault(require("./Tree"));
+var _dictUtil = require("./utils/dictUtil");
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+function getIcon(props) {
+  const {
+    isLeaf,
+    expanded
+  } = props;
+  if (isLeaf) {
+    return /*#__PURE__*/React.createElement(_FileOutlined.default, null);
+  }
+  return expanded ? /*#__PURE__*/React.createElement(_FolderOpenOutlined.default, null) : /*#__PURE__*/React.createElement(_FolderOutlined.default, null);
+}
+function getTreeData(_ref) {
+  let {
+    treeData,
+    children
+  } = _ref;
+  return treeData || (0, _treeUtil.convertTreeToData)(children);
+}
+const DirectoryTree = (_a, ref) => {
+  var {
+      defaultExpandAll,
+      defaultExpandParent,
+      defaultExpandedKeys
+    } = _a,
+    props = __rest(_a, ["defaultExpandAll", "defaultExpandParent", "defaultExpandedKeys"]);
+  // Shift click usage
+  const lastSelectedKey = React.useRef();
+  const cachedSelectedKeys = React.useRef();
+  const getInitExpandedKeys = () => {
+    const {
+      keyEntities
+    } = (0, _treeUtil.convertDataToEntities)(getTreeData(props));
+    let initExpandedKeys;
+    // Expanded keys
+    if (defaultExpandAll) {
+      initExpandedKeys = Object.keys(keyEntities);
+    } else if (defaultExpandParent) {
+      initExpandedKeys = (0, _util.conductExpandParent)(props.expandedKeys || defaultExpandedKeys || [], keyEntities);
+    } else {
+      initExpandedKeys = props.expandedKeys || defaultExpandedKeys;
+    }
+    return initExpandedKeys;
+  };
+  const [selectedKeys, setSelectedKeys] = React.useState(props.selectedKeys || props.defaultSelectedKeys || []);
+  const [expandedKeys, setExpandedKeys] = React.useState(() => getInitExpandedKeys());
+  React.useEffect(() => {
+    if ('selectedKeys' in props) {
+      setSelectedKeys(props.selectedKeys);
+    }
+  }, [props.selectedKeys]);
+  React.useEffect(() => {
+    if ('expandedKeys' in props) {
+      setExpandedKeys(props.expandedKeys);
+    }
+  }, [props.expandedKeys]);
+  const onExpand = (keys, info) => {
+    var _a;
+    if (!('expandedKeys' in props)) {
+      setExpandedKeys(keys);
+    }
+    // Call origin function
+    return (_a = props.onExpand) === null || _a === void 0 ? void 0 : _a.call(props, keys, info);
+  };
+  const onSelect = (keys, event) => {
+    var _a;
+    const {
+      multiple
+    } = props;
+    const {
+      node,
+      nativeEvent
+    } = event;
+    const {
+      key = ''
+    } = node;
+    const treeData = getTreeData(props);
+    // const newState: DirectoryTreeState = {};
+    // We need wrap this event since some value is not same
+    const newEvent = Object.assign(Object.assign({}, event), {
+      selected: true
+    });
+    // Windows / Mac single pick
+    const ctrlPick = (nativeEvent === null || nativeEvent === void 0 ? void 0 : nativeEvent.ctrlKey) || (nativeEvent === null || nativeEvent === void 0 ? void 0 : nativeEvent.metaKey);
+    const shiftPick = nativeEvent === null || nativeEvent === void 0 ? void 0 : nativeEvent.shiftKey;
+    // Generate new selected keys
+    let newSelectedKeys;
+    if (multiple && ctrlPick) {
+      // Control click
+      newSelectedKeys = keys;
+      lastSelectedKey.current = key;
+      cachedSelectedKeys.current = newSelectedKeys;
+      newEvent.selectedNodes = (0, _dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+    } else if (multiple && shiftPick) {
+      // Shift click
+      newSelectedKeys = Array.from(new Set([].concat((0, _toConsumableArray2.default)(cachedSelectedKeys.current || []), (0, _toConsumableArray2.default)((0, _dictUtil.calcRangeKeys)({
+        treeData,
+        expandedKeys,
+        startKey: key,
+        endKey: lastSelectedKey.current
+      })))));
+      newEvent.selectedNodes = (0, _dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+    } else {
+      // Single click
+      newSelectedKeys = [key];
+      lastSelectedKey.current = key;
+      cachedSelectedKeys.current = newSelectedKeys;
+      newEvent.selectedNodes = (0, _dictUtil.convertDirectoryKeysToNodes)(treeData, newSelectedKeys);
+    }
+    (_a = props.onSelect) === null || _a === void 0 ? void 0 : _a.call(props, newSelectedKeys, newEvent);
+    if (!('selectedKeys' in props)) {
+      setSelectedKeys(newSelectedKeys);
+    }
+  };
+  const {
+    getPrefixCls,
+    direction
+  } = React.useContext(_configProvider.ConfigContext);
+  const {
+      prefixCls: customizePrefixCls,
+      className,
+      showIcon = true,
+      expandAction = 'click'
+    } = props,
+    otherProps = __rest(props, ["prefixCls", "className", "showIcon", "expandAction"]);
+  const prefixCls = getPrefixCls('tree', customizePrefixCls);
+  const connectClassName = (0, _classnames.default)(`${prefixCls}-directory`, {
+    [`${prefixCls}-directory-rtl`]: direction === 'rtl'
+  }, className);
+  return /*#__PURE__*/React.createElement(_Tree.default, Object.assign({
+    icon: getIcon,
+    ref: ref,
+    blockNode: true
+  }, otherProps, {
+    showIcon: showIcon,
+    expandAction: expandAction,
+    prefixCls: prefixCls,
+    className: connectClassName,
+    expandedKeys: expandedKeys,
+    selectedKeys: selectedKeys,
+    onSelect: onSelect,
+    onExpand: onExpand
+  }));
+};
+const ForwardDirectoryTree = /*#__PURE__*/React.forwardRef(DirectoryTree);
+if (process.env.NODE_ENV !== 'production') {
+  ForwardDirectoryTree.displayName = 'DirectoryTree';
+}
+var _default = ForwardDirectoryTree;
+exports.default = _default;

package/dist/locale/antd/tree/Tree.d.ts

@@ -0,0 +1,134 @@
+import type { BasicDataNode, TreeProps as RcTreeProps } from 'rc-tree';
+import RcTree from 'rc-tree';
+import type { DataNode, Key } from 'rc-tree/lib/interface';
+import type { Component } from 'react';
+import React from 'react';
+export type SwitcherIcon = React.ReactNode | ((props: AntTreeNodeProps) => React.ReactNode);
+export type TreeLeafIcon = React.ReactNode | ((props: AntTreeNodeProps) => React.ReactNode);
+export interface AntdTreeNodeAttribute {
+    eventKey: string;
+    prefixCls: string;
+    className: string;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    children: React.ReactNode;
+    title: React.ReactNode;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+    isLeaf: boolean;
+    selectable: boolean;
+    disabled: boolean;
+    disableCheckbox: boolean;
+}
+export interface AntTreeNodeProps {
+    className?: string;
+    checkable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    title?: string | React.ReactNode;
+    key?: Key;
+    eventKey?: string;
+    isLeaf?: boolean;
+    checked?: boolean;
+    expanded?: boolean;
+    loading?: boolean;
+    selected?: boolean;
+    selectable?: boolean;
+    icon?: ((treeNode: AntdTreeNodeAttribute) => React.ReactNode) | React.ReactNode;
+    children?: React.ReactNode;
+    [customProp: string]: any;
+}
+export interface AntTreeNode extends Component<AntTreeNodeProps, {}> {
+}
+export interface AntTreeNodeBaseEvent {
+    node: AntTreeNode;
+    nativeEvent: MouseEvent;
+}
+export interface AntTreeNodeCheckedEvent extends AntTreeNodeBaseEvent {
+    event: 'check';
+    checked?: boolean;
+    checkedNodes?: AntTreeNode[];
+}
+export interface AntTreeNodeSelectedEvent extends AntTreeNodeBaseEvent {
+    event: 'select';
+    selected?: boolean;
+    selectedNodes?: DataNode[];
+}
+export interface AntTreeNodeExpandedEvent extends AntTreeNodeBaseEvent {
+    expanded?: boolean;
+}
+export interface AntTreeNodeMouseEvent {
+    node: AntTreeNode;
+    event: React.DragEvent<HTMLElement>;
+}
+export interface AntTreeNodeDragEnterEvent extends AntTreeNodeMouseEvent {
+    expandedKeys: Key[];
+}
+export interface AntTreeNodeDropEvent {
+    node: AntTreeNode;
+    dragNode: AntTreeNode;
+    dragNodesKeys: Key[];
+    dropPosition: number;
+    dropToGap?: boolean;
+    event: React.MouseEvent<HTMLElement>;
+}
+export type TreeNodeNormal = DataNode;
+type DraggableFn = (node: DataNode) => boolean;
+interface DraggableConfig {
+    icon?: React.ReactNode | false;
+    nodeDraggable?: DraggableFn;
+}
+export interface TreeProps<T extends BasicDataNode = DataNode> extends Omit<RcTreeProps<T>, 'prefixCls' | 'showLine' | 'direction' | 'draggable' | 'icon' | 'switcherIcon'> {
+    showLine?: boolean | {
+        showLeafIcon: boolean | TreeLeafIcon;
+    };
+    className?: string;
+    /** Whether to support multiple selection */
+    multiple?: boolean;
+    /** Whether to automatically expand the parent node */
+    autoExpandParent?: boolean;
+    /** Node selection in Checkable state is fully controlled (the selected state of parent and child nodes is no longer associated) */
+    checkStrictly?: boolean;
+    /** Whether to support selection */
+    checkable?: boolean;
+    /** whether to disable the tree */
+    disabled?: boolean;
+    /** Expand all tree nodes by default */
+    defaultExpandAll?: boolean;
+    /** Expand the corresponding tree node by default */
+    defaultExpandParent?: boolean;
+    /** Expand the specified tree node by default */
+    defaultExpandedKeys?: Key[];
+    /** (Controlled) Expand the specified tree node */
+    expandedKeys?: Key[];
+    /** (Controlled) Tree node with checked checkbox */
+    checkedKeys?: Key[] | {
+        checked: Key[];
+        halfChecked: Key[];
+    };
+    /** Tree node with checkbox checked by default */
+    defaultCheckedKeys?: Key[];
+    /** (Controlled) Set the selected tree node */
+    selectedKeys?: Key[];
+    /** Tree node selected by default */
+    defaultSelectedKeys?: Key[];
+    selectable?: boolean;
+    /** Click on the tree node to trigger */
+    filterAntTreeNode?: (node: AntTreeNode) => boolean;
+    loadedKeys?: Key[];
+    /** Set the node to be draggable (IE>8) */
+    draggable?: DraggableFn | boolean | DraggableConfig;
+    style?: React.CSSProperties;
+    showIcon?: boolean;
+    icon?: ((nodeProps: AntdTreeNodeAttribute) => React.ReactNode) | React.ReactNode | RcTreeProps<T>['icon'];
+    switcherIcon?: SwitcherIcon | RcTreeProps<T>['switcherIcon'];
+    prefixCls?: string;
+    children?: React.ReactNode;
+    blockNode?: boolean;
+}
+declare const Tree: React.ForwardRefExoticComponent<TreeProps<DataNode> & React.RefAttributes<RcTree<DataNode>>>;
+export default Tree;