acud 1.0.21 → 1.0.23

package/es/tree-select/src/hooks/useFilterTreeData.js

@@ -0,0 +1,49 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { fillLegacyProps } from '../utils/legacyUtil';
+export default (function (treeData, searchValue, _ref) {
+  var treeNodeFilterProp = _ref.treeNodeFilterProp,
+      filterTreeNode = _ref.filterTreeNode,
+      fieldNames = _ref.fieldNames;
+  var fieldChildren = fieldNames.children;
+  return React.useMemo(function () {
+    if (!searchValue || filterTreeNode === false) {
+      return treeData;
+    }
+
+    var filterOptionFunc;
+
+    if (typeof filterTreeNode === 'function') {
+      filterOptionFunc = filterTreeNode;
+    } else {
+      var upperStr = searchValue.toUpperCase();
+
+      filterOptionFunc = function filterOptionFunc(_, dataNode) {
+        var value = dataNode[treeNodeFilterProp];
+        return String(value).toUpperCase().includes(upperStr);
+      };
+    }
+
+    function dig(list) {
+      var keepAll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      return list.map(function (dataNode) {
+        var children = dataNode[fieldChildren];
+        var match = keepAll || filterOptionFunc(searchValue, fillLegacyProps(dataNode));
+        var childList = dig(children || [], match);
+
+        if (match || childList.length) {
+          return _extends(_extends({}, dataNode), _defineProperty({
+            isLeaf: undefined
+          }, fieldChildren, childList));
+        }
+
+        return null;
+      }).filter(function (node) {
+        return node;
+      });
+    }
+
+    return dig(treeData);
+  }, [treeData, searchValue, fieldChildren, treeNodeFilterProp, filterTreeNode]);
+});

package/es/tree-select/src/hooks/useRefFunc.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Same as `React.useCallback` but always return a memoized function
+ * but redirect to real function.
+ */
+export default function useRefFunc<T extends (...args: any[]) => any>(callback: T): T;

package/es/tree-select/src/hooks/useRefFunc.js

@@ -0,0 +1,14 @@
+import * as React from 'react';
+/**
+ * Same as `React.useCallback` but always return a memoized function
+ * but redirect to real function.
+ */
+
+export default function useRefFunc(callback) {
+  var funcRef = React.useRef();
+  funcRef.current = callback;
+  var cacheFn = React.useCallback(function () {
+    return funcRef.current.apply(funcRef, arguments);
+  }, []);
+  return cacheFn;
+}

package/es/tree-select/src/hooks/useTreeData.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import type { DataNode, SimpleModeConfig } from '../interface';
+import type { DefaultOptionType } from '../TreeSelect';
+/**
+ * Convert `treeData` or `children` into formatted `treeData`.
+ * Will not re-calculate if `treeData` or `children` not change.
+ */
+export default function useTreeData(treeData: DataNode[], children: React.ReactNode, simpleMode: boolean | SimpleModeConfig): DefaultOptionType[];

package/es/tree-select/src/hooks/useTreeData.js

@@ -0,0 +1,55 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { convertChildrenToData } from '../utils/legacyUtil';
+
+function parseSimpleTreeData(treeData, _ref) {
+  var id = _ref.id,
+      pId = _ref.pId,
+      rootPId = _ref.rootPId;
+  var keyNodes = {};
+  var rootNodeList = []; // Fill in the map
+
+  var nodeList = treeData.map(function (node) {
+    var clone = _extends({}, node);
+
+    var key = clone[id];
+    keyNodes[key] = clone;
+    clone.key = clone.key || key;
+    return clone;
+  }); // Connect tree
+
+  nodeList.forEach(function (node) {
+    var parentKey = node[pId];
+    var parent = keyNodes[parentKey]; // Fill parent
+
+    if (parent) {
+      parent.children = parent.children || [];
+      parent.children.push(node);
+    } // Fill root tree node
+
+
+    if (parentKey === rootPId || !parent && rootPId === null) {
+      rootNodeList.push(node);
+    }
+  });
+  return rootNodeList;
+}
+/**
+ * Convert `treeData` or `children` into formatted `treeData`.
+ * Will not re-calculate if `treeData` or `children` not change.
+ */
+
+
+export default function useTreeData(treeData, children, simpleMode) {
+  return React.useMemo(function () {
+    if (treeData) {
+      return simpleMode ? parseSimpleTreeData(treeData, _extends({
+        id: 'id',
+        pId: 'pId',
+        rootPId: null
+      }, simpleMode !== true ? simpleMode : {})) : treeData;
+    }
+
+    return convertChildrenToData(children);
+  }, [children, simpleMode, treeData]);
+}

package/es/tree-select/src/index.d.ts

@@ -0,0 +1,7 @@
+import TreeSelect from './TreeSelect';
+import type { TreeSelectProps } from './TreeSelect';
+import TreeNode from './TreeNode';
+import { SHOW_ALL, SHOW_CHILD, SHOW_PARENT } from './utils/strategyUtil';
+export { TreeNode, SHOW_ALL, SHOW_CHILD, SHOW_PARENT };
+export type { TreeSelectProps };
+export default TreeSelect;

package/es/tree-select/src/index.js

@@ -0,0 +1,9 @@
+/*
+ * tree-select
+ * update by zhousheng
+ */
+import TreeSelect from './TreeSelect';
+import TreeNode from './TreeNode';
+import { SHOW_ALL, SHOW_CHILD, SHOW_PARENT } from './utils/strategyUtil';
+export { TreeNode, SHOW_ALL, SHOW_CHILD, SHOW_PARENT };
+export default TreeSelect;

package/es/tree-select/src/interface.d.ts

@@ -0,0 +1,77 @@
+import type * as React from 'react';
+export declare type SelectSource = 'option' | 'selection' | 'input' | 'clear';
+export declare type Key = string | number;
+export declare type RawValueType = string | number;
+export interface LabelValueType {
+    key?: Key;
+    value?: RawValueType;
+    label?: React.ReactNode;
+    /** Only works on `treeCheckStrictly` */
+    halfChecked?: boolean;
+}
+export declare type DefaultValueType = RawValueType | RawValueType[] | LabelValueType | LabelValueType[];
+export interface DataNode {
+    value?: RawValueType;
+    title?: React.ReactNode;
+    label?: React.ReactNode;
+    key?: Key;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    checkable?: boolean;
+    children?: DataNode[];
+    /** Customize data info */
+    [prop: string]: any;
+}
+export interface InternalDataEntity {
+    key: Key;
+    value: RawValueType;
+    title?: React.ReactNode;
+    disableCheckbox?: boolean;
+    disabled?: boolean;
+    children?: InternalDataEntity[];
+    /** Origin DataNode */
+    node: DataNode;
+}
+export interface LegacyDataNode extends DataNode {
+    props: any;
+}
+export interface TreeDataNode extends DataNode {
+    key: Key;
+    children?: TreeDataNode[];
+}
+export interface FlattenDataNode {
+    data: InternalDataEntity;
+    key: Key;
+    value: RawValueType;
+    level: number;
+    parent?: FlattenDataNode;
+}
+export interface SimpleModeConfig {
+    id?: Key;
+    pId?: Key;
+    rootPId?: Key;
+}
+/** @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: LabelValueType[];
+    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;
+}

package/es/tree-select/src/interface.js

@@ -0,0 +1 @@
+export {};

package/es/tree-select/src/utils/legacyUtil.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import type { DataNode, ChangeEventExtra, RawValueType } from '../interface';
+import type { DefaultOptionType, FieldNames } from '../TreeSelect';
+export declare function convertChildrenToData(nodes: React.ReactNode): DataNode[];
+export declare function fillLegacyProps(dataNode: DataNode): any;
+export declare function fillAdditionalInfo(extra: ChangeEventExtra, triggerValue: RawValueType, checkedValues: RawValueType[], treeData: DefaultOptionType[], showPosition: boolean, fieldNames: FieldNames): void;

package/es/tree-select/src/utils/legacyUtil.js

@@ -0,0 +1,144 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+
+var __rest = this && this.__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;
+};
+
+import * as React from 'react';
+import toArray from "rc-util/es/Children/toArray";
+import warning from "rc-util/es/warning";
+import TreeNode from '../TreeNode';
+export function convertChildrenToData(nodes) {
+  return toArray(nodes).map(function (node) {
+    if (! /*#__PURE__*/React.isValidElement(node) || !node.type) {
+      return null;
+    }
+
+    var _a = node,
+        key = _a.key,
+        _b = _a.props,
+        children = _b.children,
+        value = _b.value,
+        restProps = __rest(_b, ["children", "value"]);
+
+    var data = _extends({
+      key: key,
+      value: value
+    }, restProps);
+
+    var childData = convertChildrenToData(children);
+
+    if (childData.length) {
+      data.children = childData;
+    }
+
+    return data;
+  }).filter(function (data) {
+    return data;
+  });
+}
+export function fillLegacyProps(dataNode) {
+  if (!dataNode) {
+    return dataNode;
+  }
+
+  var cloneNode = _extends({}, dataNode);
+
+  if (!('props' in cloneNode)) {
+    Object.defineProperty(cloneNode, 'props', {
+      get: function get() {
+        warning(false, 'New `rc-tree-select` not support return node instance as argument anymore. Please consider to remove `props` access.');
+        return cloneNode;
+      }
+    });
+  }
+
+  return cloneNode;
+}
+export function fillAdditionalInfo(extra, triggerValue, checkedValues, treeData, showPosition, fieldNames) {
+  var triggerNode = null;
+  var nodeList = null;
+
+  function generateMap() {
+    function dig(list) {
+      var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '0';
+      var parentIncluded = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      return list.map(function (option, index) {
+        var pos = "".concat(level, "-").concat(index);
+        var value = option[fieldNames.value];
+        var included = checkedValues.includes(value);
+        var children = dig(option[fieldNames.children] || [], pos, included);
+        var node = /*#__PURE__*/React.createElement(TreeNode, option, children.map(function (child) {
+          return child.node;
+        })); // Link with trigger node
+
+        if (triggerValue === value) {
+          triggerNode = node;
+        }
+
+        if (included) {
+          var checkedNode = {
+            pos: pos,
+            node: node,
+            children: children
+          };
+
+          if (!parentIncluded) {
+            nodeList.push(checkedNode);
+          }
+
+          return checkedNode;
+        }
+
+        return null;
+      }).filter(function (node) {
+        return node;
+      });
+    }
+
+    if (!nodeList) {
+      nodeList = [];
+      dig(treeData); // Sort to keep the checked node length
+
+      nodeList.sort(function (_ref, _ref2) {
+        var val1 = _ref.node.props.value;
+        var val2 = _ref2.node.props.value;
+        var index1 = checkedValues.indexOf(val1);
+        var index2 = checkedValues.indexOf(val2);
+        return index1 - index2;
+      });
+    }
+  }
+
+  Object.defineProperty(extra, 'triggerNode', {
+    get: function get() {
+      warning(false, '`triggerNode` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+      return triggerNode;
+    }
+  });
+  Object.defineProperty(extra, 'allCheckedNodes', {
+    get: function get() {
+      warning(false, '`allCheckedNodes` is deprecated. Please consider decoupling data with node.');
+      generateMap();
+
+      if (showPosition) {
+        return nodeList;
+      }
+
+      return nodeList.map(function (_ref3) {
+        var node = _ref3.node;
+        return node;
+      });
+    }
+  });
+}

package/es/tree-select/src/utils/strategyUtil.d.ts

@@ -0,0 +1,9 @@
+import type * as React from 'react';
+import type { InternalFieldName } from '../TreeSelect';
+import type { DataEntity } from 'rc-tree/lib/interface';
+import type { RawValueType, Key } from '../interface';
+export declare const SHOW_ALL = "SHOW_ALL";
+export declare const SHOW_PARENT = "SHOW_PARENT";
+export declare const SHOW_CHILD = "SHOW_CHILD";
+export declare type CheckedStrategy = typeof SHOW_ALL | typeof SHOW_PARENT | typeof SHOW_CHILD;
+export declare function formatStrategyValues(values: React.Key[], strategy: CheckedStrategy, keyEntities: Record<Key, DataEntity>, fieldNames: InternalFieldName): RawValueType[];

package/es/tree-select/src/utils/strategyUtil.js

@@ -0,0 +1,40 @@
+import { isCheckDisabled } from './valueUtil';
+export var SHOW_ALL = 'SHOW_ALL';
+export var SHOW_PARENT = 'SHOW_PARENT';
+export var SHOW_CHILD = 'SHOW_CHILD';
+export function formatStrategyValues(values, strategy, keyEntities, fieldNames) {
+  var valueSet = new Set(values);
+
+  if (strategy === SHOW_CHILD) {
+    return values.filter(function (key) {
+      var entity = keyEntities[key];
+
+      if (entity && entity.children && entity.children.some(function (_ref) {
+        var node = _ref.node;
+        return valueSet.has(node[fieldNames.value]);
+      }) && entity.children.every(function (_ref2) {
+        var node = _ref2.node;
+        return isCheckDisabled(node) || valueSet.has(node[fieldNames.value]);
+      })) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  if (strategy === SHOW_PARENT) {
+    return values.filter(function (key) {
+      var entity = keyEntities[key];
+      var parent = entity ? entity.parent : null;
+
+      if (parent && !isCheckDisabled(parent.node) && valueSet.has(parent.key)) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  return values;
+}

package/es/tree-select/src/utils/valueUtil.d.ts

@@ -0,0 +1,14 @@
+import type * as React from 'react';
+import type { DataNode, FieldNames } from '../interface';
+import type { DefaultOptionType, InternalFieldName } from '../TreeSelect';
+export declare function toArray<T>(value: T | T[]): T[];
+export declare function fillFieldNames(fieldNames?: FieldNames): {
+    _title: string[];
+    value: string;
+    key: string;
+    children: string;
+};
+export declare function isCheckDisabled(node: DataNode): boolean;
+/** Loop fetch all the keys exist in the tree */
+export declare function getAllKeys(treeData: DefaultOptionType[], fieldNames: InternalFieldName): React.Key[];
+export declare function isNil(val: any): boolean;

package/es/tree-select/src/utils/valueUtil.js

@@ -0,0 +1,46 @@
+export function toArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+
+  return value !== undefined ? [value] : [];
+}
+export function fillFieldNames(fieldNames) {
+  var _ref = fieldNames || {},
+      label = _ref.label,
+      value = _ref.value,
+      children = _ref.children;
+
+  var mergedValue = value || 'value';
+  return {
+    _title: label ? [label] : ['title', 'label'],
+    value: mergedValue,
+    key: mergedValue,
+    children: children || 'children'
+  };
+}
+export function isCheckDisabled(node) {
+  return !node || node.disabled || node.disableCheckbox || node.checkable === false;
+}
+/** Loop fetch all the keys exist in the tree */
+
+export function getAllKeys(treeData, fieldNames) {
+  var keys = [];
+
+  function dig(list) {
+    list.forEach(function (item) {
+      keys.push(item[fieldNames.value]);
+      var children = item[fieldNames.children];
+
+      if (children) {
+        dig(children);
+      }
+    });
+  }
+
+  dig(treeData);
+  return keys;
+}
+export function isNil(val) {
+  return val === null || val === undefined;
+}

package/es/tree-select/src/utils/warningPropsUtil.d.ts

@@ -0,0 +1,5 @@
+import type { TreeSelectProps } from '../TreeSelect';
+declare function warningProps(props: TreeSelectProps & {
+    searchPlaceholder?: string;
+}): void;
+export default warningProps;

package/es/tree-select/src/utils/warningPropsUtil.js

@@ -0,0 +1,31 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import warning from "rc-util/es/warning";
+import { toArray } from './valueUtil';
+
+function warningProps(props) {
+  var searchPlaceholder = props.searchPlaceholder,
+      treeCheckStrictly = props.treeCheckStrictly,
+      treeCheckable = props.treeCheckable,
+      labelInValue = props.labelInValue,
+      value = props.value,
+      multiple = props.multiple;
+  warning(!searchPlaceholder, '`searchPlaceholder` has been removed.');
+
+  if (treeCheckStrictly && labelInValue === false) {
+    warning(false, '`treeCheckStrictly` will force set `labelInValue` to `true`.');
+  }
+
+  if (labelInValue || treeCheckStrictly) {
+    warning(toArray(value).every(function (val) {
+      return val && _typeof(val) === 'object' && 'value' in val;
+    }), 'Invalid prop `value` supplied to `TreeSelect`. You should use { label: string, value: string | number } or [{ label: string, value: string | number }] instead.');
+  }
+
+  if (treeCheckStrictly || multiple || treeCheckable) {
+    warning(!value || Array.isArray(value), '`value` should be an array when `TreeSelect` is checkable or multiple.');
+  } else {
+    warning(!Array.isArray(value), '`value` should not be array when `TreeSelect` is single mode.');
+  }
+}
+
+export default warningProps;

package/es/tree-select/style/index.css

@@ -222,6 +222,10 @@
 .acud-tree-select-dropdown .acud-select-tree-list-holder-inner .acud-select-tree-treenode .acud-select-tree-node-content-wrapper {
   flex: auto;
 }
+.acud-tree-select-dropdown .acud-select-tree-select-all {
+  line-height: 22px;
+  padding: 0 0 4px 0;
+}
 .acud-select-tree-checkbox-inner::after {
   top: 43%;
   left: 24%;
@@ -492,3 +496,9 @@
 .acud-tree-select-dropdown-rtl .acud-select-tree .acud-select-tree-switcher-loading-icon {
   transform: scaleY(-1);
 }
+.acud-select-tree-checkbox-inner::after {
+  opacity: 0;
+}
+.acud-select-tree-checkbox-checked .acud-select-tree-checkbox-inner::after {
+  opacity: 1;
+}

package/es/tree-select/style/index.less

@@ -29,6 +29,11 @@
                     }
                 }
             }
+
+            &-select-all {
+                line-height: 22px;
+                padding: 0 0 4px 0;
+            }
         }
     }
 }
@@ -55,3 +60,9 @@
         }
     }
 }
+.@{select-tree-prefix-cls}-checkbox-inner::after {
+    opacity: 0;
+}
+.@{select-tree-prefix-cls}-checkbox-checked .@{select-tree-prefix-cls}-checkbox-inner::after {
+    opacity: 1;
+}

package/lib/avatar/SizeContext.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ScreenSizeMap } from '../_util/responsiveObserve';
+export declare type AvatarSize = 'large' | 'small' | 'default' | number | ScreenSizeMap;
+declare const SizeContext: React.Context<AvatarSize>;
+export interface SizeContextProps {
+    size?: AvatarSize;
+    children?: React.ReactNode;
+}
+export declare const SizeContextProvider: React.FC<SizeContextProps>;
+export default SizeContext;

package/lib/avatar/SizeContext.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.SizeContextProvider = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var SizeContext = /*#__PURE__*/_react["default"].createContext('default');
+
+var SizeContextProvider = function SizeContextProvider(_ref) {
+  var children = _ref.children,
+      size = _ref.size;
+  return /*#__PURE__*/_react["default"].createElement(SizeContext.Consumer, null, function (originSize) {
+    return /*#__PURE__*/_react["default"].createElement(SizeContext.Provider, {
+      value: size || originSize
+    }, children);
+  });
+};
+
+exports.SizeContextProvider = SizeContextProvider;
+var _default = SizeContext;
+exports["default"] = _default;

package/lib/avatar/avatar.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { AvatarSize } from './SizeContext';
+export interface AvatarProps {
+    /** Shape of avatar, options: `circle`, `square` */
+    shape?: 'circle' | 'square';
+    size?: AvatarSize;
+    gap?: number;
+    /** Src of image avatar */
+    src?: React.ReactNode;
+    /** Srcset of image avatar */
+    srcSet?: string;
+    draggable?: boolean;
+    /** Icon to be used in avatar */
+    icon?: React.ReactNode;
+    style?: React.CSSProperties;
+    prefixCls?: string;
+    className?: string;
+    children?: React.ReactNode;
+    alt?: string;
+    crossOrigin?: '' | 'anonymous' | 'use-credentials';
+    onClick?: (e?: React.MouseEvent<HTMLElement>) => void;
+    onError?: () => boolean;
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<unknown>>;
+export default Avatar;