acud 1.0.21 → 1.0.23

package/lib/tree-select/src/OptionList.js

@@ -0,0 +1,366 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _KeyCode = _interopRequireDefault(require("rc-util/lib/KeyCode"));
+
+var _useMemo = _interopRequireDefault(require("rc-util/lib/hooks/useMemo"));
+
+var _rcSelect = require("rc-select");
+
+var _rcTree = _interopRequireDefault(require("rc-tree"));
+
+var _checkbox = _interopRequireDefault(require("../../checkbox"));
+
+var _LegacyContext = _interopRequireDefault(require("./LegacyContext"));
+
+var _TreeSelectContext = _interopRequireDefault(require("./TreeSelectContext"));
+
+var _valueUtil = require("./utils/valueUtil");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var HIDDEN_STYLE = {
+  width: 0,
+  height: 0,
+  display: 'flex',
+  overflow: 'hidden',
+  opacity: 0,
+  border: 0,
+  padding: 0,
+  margin: 0
+};
+
+var OptionList = function OptionList(_, ref) {
+  var _useBaseProps = (0, _rcSelect.useBaseProps)(),
+      prefixCls = _useBaseProps.prefixCls,
+      multiple = _useBaseProps.multiple,
+      searchValue = _useBaseProps.searchValue,
+      toggleOpen = _useBaseProps.toggleOpen,
+      open = _useBaseProps.open,
+      notFoundContent = _useBaseProps.notFoundContent;
+
+  var _React$useContext = React.useContext(_TreeSelectContext["default"]),
+      virtual = _React$useContext.virtual,
+      listHeight = _React$useContext.listHeight,
+      listItemHeight = _React$useContext.listItemHeight,
+      treeData = _React$useContext.treeData,
+      fieldNames = _React$useContext.fieldNames,
+      onSelect = _React$useContext.onSelect,
+      triggerChange = _React$useContext.triggerChange,
+      dropdownMatchSelectWidth = _React$useContext.dropdownMatchSelectWidth,
+      treeExpandAction = _React$useContext.treeExpandAction;
+
+  var _React$useContext2 = React.useContext(_LegacyContext["default"]),
+      checkable = _React$useContext2.checkable,
+      checkedKeys = _React$useContext2.checkedKeys,
+      halfCheckedKeys = _React$useContext2.halfCheckedKeys,
+      treeExpandedKeys = _React$useContext2.treeExpandedKeys,
+      treeDefaultExpandAll = _React$useContext2.treeDefaultExpandAll,
+      treeDefaultExpandedKeys = _React$useContext2.treeDefaultExpandedKeys,
+      onTreeExpand = _React$useContext2.onTreeExpand,
+      treeIcon = _React$useContext2.treeIcon,
+      showTreeIcon = _React$useContext2.showTreeIcon,
+      switcherIcon = _React$useContext2.switcherIcon,
+      treeLine = _React$useContext2.treeLine,
+      treeNodeFilterProp = _React$useContext2.treeNodeFilterProp,
+      loadData = _React$useContext2.loadData,
+      treeLoadedKeys = _React$useContext2.treeLoadedKeys,
+      treeMotion = _React$useContext2.treeMotion,
+      onTreeLoad = _React$useContext2.onTreeLoad,
+      keyEntities = _React$useContext2.keyEntities;
+
+  var treeRef = React.useRef();
+  var memoTreeData = (0, _useMemo["default"])(function () {
+    return treeData;
+  }, [open, treeData], function (prev, next) {
+    return next[0] && prev[1] !== next[1];
+  }); // ========================== Values ==========================
+
+  var mergedCheckedKeys = React.useMemo(function () {
+    if (!checkable) {
+      return null;
+    }
+
+    return {
+      checked: checkedKeys,
+      halfChecked: halfCheckedKeys
+    };
+  }, [checkable, checkedKeys, halfCheckedKeys]); // ========================== Scroll ==========================
+
+  React.useEffect(function () {
+    var _a; // Single mode should scroll to current key
+
+
+    if (open && !multiple && checkedKeys.length) {
+      (_a = treeRef.current) === null || _a === void 0 ? void 0 : _a.scrollTo({
+        key: checkedKeys[0]
+      });
+    }
+  }, [open]); // ========================== Search ==========================
+
+  var lowerSearchValue = String(searchValue).toLowerCase();
+
+  var filterTreeNode = function filterTreeNode(treeNode) {
+    if (!lowerSearchValue) {
+      return false;
+    }
+
+    return String(treeNode[treeNodeFilterProp]).toLowerCase().includes(lowerSearchValue);
+  }; // =========================== Keys ===========================
+
+
+  var _React$useState = React.useState(treeDefaultExpandedKeys),
+      _React$useState2 = (0, _slicedToArray2["default"])(_React$useState, 2),
+      expandedKeys = _React$useState2[0],
+      setExpandedKeys = _React$useState2[1];
+
+  var _React$useState3 = React.useState(null),
+      _React$useState4 = (0, _slicedToArray2["default"])(_React$useState3, 2),
+      searchExpandedKeys = _React$useState4[0],
+      setSearchExpandedKeys = _React$useState4[1];
+
+  var mergedExpandedKeys = React.useMemo(function () {
+    if (treeExpandedKeys) {
+      return (0, _toConsumableArray2["default"])(treeExpandedKeys);
+    }
+
+    return searchValue ? searchExpandedKeys : expandedKeys;
+  }, [expandedKeys, searchExpandedKeys, treeExpandedKeys, searchValue]);
+  var allKeys = React.useMemo(function () {
+    return (0, _valueUtil.getAllKeys)(treeData, fieldNames);
+  }, [treeData, fieldNames]);
+  React.useEffect(function () {
+    if (searchValue) {
+      setSearchExpandedKeys(allKeys);
+    }
+  }, [searchValue]);
+
+  var onInternalExpand = function onInternalExpand(keys) {
+    setExpandedKeys(keys);
+    setSearchExpandedKeys(keys);
+
+    if (onTreeExpand) {
+      onTreeExpand(keys);
+    }
+  }; // ========================== Events ==========================
+
+
+  var onListMouseDown = function onListMouseDown(event) {
+    event.preventDefault();
+  };
+
+  var onInternalSelect = function onInternalSelect(__, info) {
+    var node = info.node;
+
+    if (checkable && (0, _valueUtil.isCheckDisabled)(node)) {
+      return;
+    }
+
+    onSelect(node.key, {
+      selected: !checkedKeys.includes(node.key)
+    });
+
+    if (!multiple) {
+      toggleOpen(false);
+    }
+  }; // ========================= Keyboard =========================
+
+
+  var _React$useState5 = React.useState(null),
+      _React$useState6 = (0, _slicedToArray2["default"])(_React$useState5, 2),
+      activeKey = _React$useState6[0],
+      setActiveKey = _React$useState6[1];
+
+  var activeEntity = keyEntities[activeKey];
+  React.useImperativeHandle(ref, function () {
+    var _a;
+
+    return {
+      scrollTo: (_a = treeRef.current) === null || _a === void 0 ? void 0 : _a.scrollTo,
+      onKeyDown: function onKeyDown(event) {
+        var _a;
+
+        var which = event.which;
+
+        switch (which) {
+          // >>> Arrow keys
+          case _KeyCode["default"].UP:
+          case _KeyCode["default"].DOWN:
+          case _KeyCode["default"].LEFT:
+          case _KeyCode["default"].RIGHT:
+            (_a = treeRef.current) === null || _a === void 0 ? void 0 : _a.onKeyDown(event);
+            break;
+          // >>> Select item
+
+          case _KeyCode["default"].ENTER:
+            {
+              if (activeEntity) {
+                var _ref = (activeEntity === null || activeEntity === void 0 ? void 0 : activeEntity.node) || {},
+                    selectable = _ref.selectable,
+                    value = _ref.value;
+
+                if (selectable !== false) {
+                  onInternalSelect(null, {
+                    node: {
+                      key: activeKey
+                    },
+                    selected: !checkedKeys.includes(value)
+                  });
+                }
+              }
+
+              break;
+            }
+          // >>> Close
+
+          case _KeyCode["default"].ESC:
+            {
+              toggleOpen(false);
+            }
+        }
+      },
+      onKeyUp: function onKeyUp() {}
+    };
+  });
+  var treeProps = {
+    fieldNames: fieldNames
+  };
+
+  if (treeLoadedKeys) {
+    treeProps.loadedKeys = treeLoadedKeys;
+  }
+
+  if (mergedExpandedKeys) {
+    treeProps.expandedKeys = mergedExpandedKeys;
+  }
+
+  var allDisabledCheckedKeys = React.useMemo(function () {
+    var adcKeys = [];
+
+    var loopTreeData = function loopTreeData(arr) {
+      arr.forEach(function (data) {
+        if (data.disabled && checkedKeys.includes(data.key)) {
+          adcKeys.push(data.key);
+        }
+
+        if (data.children && Array.isArray(data.children)) {
+          loopTreeData(data.children);
+        }
+      });
+    };
+
+    loopTreeData(treeData);
+    return adcKeys;
+  }, [treeData, checkedKeys]);
+  var allAbleKeys = React.useMemo(function () {
+    var abKeys = [];
+
+    var loopTreeData = function loopTreeData(arr) {
+      arr.forEach(function (data) {
+        if (!data.disabled) {
+          abKeys.push(data.key);
+        }
+
+        if (data.children && Array.isArray(data.children)) {
+          loopTreeData(data.children);
+        }
+      });
+    };
+
+    loopTreeData(treeData);
+    return abKeys;
+  }, [treeData]);
+  var allAbleCheckedKeys = React.useMemo(function () {
+    return checkedKeys.filter(function (key) {
+      return allAbleKeys.includes(key);
+    });
+  }, [allAbleKeys, checkedKeys]);
+  var selectAllStatus = React.useMemo(function () {
+    return {
+      all: allAbleKeys.length === allAbleCheckedKeys.length,
+      indeterminate: allAbleCheckedKeys.length > 0 && allAbleCheckedKeys.length !== allAbleKeys.length
+    };
+  }, [allAbleCheckedKeys, allAbleKeys]);
+  var hanldeCheckAll = React.useCallback(function () {
+    if (selectAllStatus.all) {
+      triggerChange((0, _toConsumableArray2["default"])(allDisabledCheckedKeys));
+    } else {
+      triggerChange([].concat((0, _toConsumableArray2["default"])(allDisabledCheckedKeys), (0, _toConsumableArray2["default"])(allAbleKeys)));
+    }
+  }, [selectAllStatus, allAbleKeys, allDisabledCheckedKeys]); // ========================== Render ==========================
+
+  if (memoTreeData.length === 0) {
+    return /*#__PURE__*/React.createElement("div", {
+      role: "listbox",
+      className: "".concat(prefixCls, "-empty"),
+      onMouseDown: onListMouseDown
+    }, notFoundContent);
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    onMouseDown: onListMouseDown
+  }, activeEntity && open && /*#__PURE__*/React.createElement("span", {
+    style: HIDDEN_STYLE,
+    "aria-live": "assertive"
+  }, activeEntity.node.value), multiple && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-tree-select-all")
+  }, /*#__PURE__*/React.createElement(_checkbox["default"], {
+    checked: selectAllStatus.all,
+    indeterminate: selectAllStatus.indeterminate,
+    onClick: hanldeCheckAll
+  }, "\u5168\u9009")), /*#__PURE__*/React.createElement(_rcTree["default"], (0, _extends2["default"])({
+    ref: treeRef,
+    focusable: false,
+    prefixCls: "".concat(prefixCls, "-tree"),
+    treeData: memoTreeData,
+    height: listHeight,
+    itemHeight: listItemHeight,
+    virtual: virtual !== false && dropdownMatchSelectWidth !== false,
+    multiple: multiple,
+    icon: treeIcon,
+    showIcon: showTreeIcon,
+    switcherIcon: switcherIcon,
+    showLine: treeLine,
+    loadData: searchValue ? null : loadData,
+    motion: treeMotion,
+    activeKey: activeKey // We handle keys by out instead tree self
+    ,
+    checkable: checkable,
+    checkStrictly: true,
+    checkedKeys: mergedCheckedKeys,
+    selectedKeys: !checkable ? checkedKeys : [],
+    defaultExpandAll: treeDefaultExpandAll
+  }, treeProps, {
+    // Proxy event out
+    onActiveChange: setActiveKey,
+    onSelect: onInternalSelect,
+    onCheck: onInternalSelect,
+    onExpand: onInternalExpand,
+    onLoad: onTreeLoad,
+    filterTreeNode: filterTreeNode,
+    expandAction: treeExpandAction
+  })));
+};
+
+var RefOptionList = /*#__PURE__*/React.forwardRef(OptionList);
+RefOptionList.displayName = 'OptionList';
+var _default = RefOptionList;
+exports["default"] = _default;

package/lib/tree-select/src/TreeNode.d.ts

@@ -0,0 +1,9 @@
+import type * as React from 'react';
+import type { DataNode, Key } from './interface';
+export interface TreeNodeProps extends Omit<DataNode, 'children'> {
+    value: Key;
+    children?: React.ReactNode;
+}
+/** This is a placeholder, not real render in dom */
+declare const TreeNode: React.FC<TreeNodeProps>;
+export default TreeNode;

package/lib/tree-select/src/TreeNode.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+/** This is a placeholder, not real render in dom */
+var TreeNode = function TreeNode() {
+  return null;
+};
+
+var _default = TreeNode;
+exports["default"] = _default;

package/lib/tree-select/src/TreeSelect.d.ts

@@ -0,0 +1,122 @@
+import * as React from 'react';
+import type { IconType } from 'rc-tree/lib/interface';
+import type { ExpandAction } from 'rc-tree/lib/Tree';
+import type { BaseSelectRef, BaseSelectPropsWithoutPrivate, SelectProps } from 'rc-select';
+import TreeNode from './TreeNode';
+import { SHOW_ALL, SHOW_PARENT, SHOW_CHILD } from './utils/strategyUtil';
+import type { CheckedStrategy } from './utils/strategyUtil';
+export declare type OnInternalSelect = (value: RawValueType, info: {
+    selected: boolean;
+}) => void;
+export declare type RawValueType = string | number;
+export interface LabeledValueType {
+    key?: React.Key;
+    value?: RawValueType;
+    label?: React.ReactNode;
+    /** Only works on `treeCheckStrictly` */
+    halfChecked?: boolean;
+}
+export declare type SelectSource = 'option' | 'selection' | 'input' | 'clear';
+export declare type DraftValueType = RawValueType | LabeledValueType | (RawValueType | LabeledValueType)[];
+/** @deprecated This is only used for legacy compatible. Not works on new code. */
+export interface LegacyCheckedNode {
+    pos: string;
+    node: React.ReactElement;
+    children?: LegacyCheckedNode[];
+}
+export interface ChangeEventExtra {
+    /** @deprecated Please save prev value by control logic instead */
+    preValue: LabeledValueType[];
+    triggerValue: RawValueType;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    selected?: boolean;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    checked?: boolean;
+    /** @deprecated This prop not work as react node anymore. */
+    triggerNode: React.ReactElement;
+    /** @deprecated This prop not work as react node anymore. */
+    allCheckedNodes: LegacyCheckedNode[];
+}
+export interface FieldNames {
+    value?: string;
+    label?: string;
+    children?: string;
+}
+export interface InternalFieldName extends Omit<FieldNames, 'label'> {
+    _title: string[];
+}
+export interface SimpleModeConfig {
+    id?: React.Key;
+    pId?: React.Key;
+    rootPId?: React.Key;
+}
+export interface BaseOptionType {
+    disabled?: boolean;
+    checkable?: boolean;
+    disableCheckbox?: boolean;
+    children?: BaseOptionType[];
+    [name: string]: any;
+}
+export interface DefaultOptionType extends BaseOptionType {
+    value?: RawValueType;
+    title?: React.ReactNode;
+    label?: React.ReactNode;
+    key?: React.Key;
+    children?: DefaultOptionType[];
+}
+export interface LegacyDataNode extends DefaultOptionType {
+    props: any;
+}
+export interface TreeSelectProps<ValueType = any, OptionType extends BaseOptionType = DefaultOptionType> extends Omit<BaseSelectPropsWithoutPrivate, 'mode'> {
+    prefixCls?: string;
+    id?: string;
+    value?: ValueType;
+    defaultValue?: ValueType;
+    onChange?: (value: ValueType, labelList: React.ReactNode[], extra: ChangeEventExtra) => void;
+    searchValue?: string;
+    /** @deprecated Use `searchValue` instead */
+    inputValue?: string;
+    onSearch?: (value: string) => void;
+    autoClearSearchValue?: boolean;
+    filterTreeNode?: boolean | ((inputValue: string, treeNode: DefaultOptionType) => boolean);
+    treeNodeFilterProp?: string;
+    onSelect?: SelectProps<ValueType, OptionType>['onSelect'];
+    onDeselect?: SelectProps<ValueType, OptionType>['onDeselect'];
+    showCheckedStrategy?: CheckedStrategy;
+    treeNodeLabelProp?: string;
+    fieldNames?: FieldNames;
+    multiple?: boolean;
+    treeCheckable?: boolean | React.ReactNode;
+    treeCheckStrictly?: boolean;
+    labelInValue?: boolean;
+    treeData?: OptionType[];
+    treeDataSimpleMode?: boolean | SimpleModeConfig;
+    loadData?: (dataNode: LegacyDataNode) => Promise<unknown>;
+    treeLoadedKeys?: React.Key[];
+    onTreeLoad?: (loadedKeys: React.Key[]) => void;
+    treeDefaultExpandAll?: boolean;
+    treeExpandedKeys?: React.Key[];
+    treeDefaultExpandedKeys?: React.Key[];
+    onTreeExpand?: (expandedKeys: React.Key[]) => void;
+    treeExpandAction?: ExpandAction;
+    virtual?: boolean;
+    listHeight?: number;
+    listItemHeight?: number;
+    onDropdownVisibleChange?: (open: boolean) => void;
+    treeLine?: boolean;
+    treeIcon?: IconType;
+    showTreeIcon?: boolean;
+    switcherIcon?: IconType;
+    treeMotion?: any;
+}
+declare const GenericTreeSelect: (<ValueType = any, OptionType extends DefaultOptionType | BaseOptionType = DefaultOptionType>(props: TreeSelectProps<ValueType, OptionType> & {
+    children?: React.ReactNode;
+} & {
+    ref?: React.Ref<BaseSelectRef>;
+}) => React.ReactElement) & {
+    TreeNode: typeof TreeNode;
+    SHOW_ALL: typeof SHOW_ALL;
+    SHOW_PARENT: typeof SHOW_PARENT;
+    SHOW_CHILD: typeof SHOW_CHILD;
+};
+export default GenericTreeSelect;