@qsxy/element-plus-react 1.0.1 → 1.0.3

package/dist/Tree/utils/treeUtil.d.ts

@@ -1,86 +0,0 @@
-import * as React from 'react';
-import type { BasicDataNode, DataEntity, DataNode, EventDataNode, FieldNames, FlattenNode, GetKey, Key, KeyEntities, NodeElement, TreeNodeProps } from '../typings';
-export declare function getPosition(level: string | number, index: number): string;
-export declare function isTreeNode(node: NodeElement): boolean;
-export declare function getKey(key: Key, pos: string): React.Key;
-export declare function fillFieldNames(fieldNames?: FieldNames): Required<FieldNames>;
-/**
- * Warning if TreeNode do not provides key
- */
-export declare function warningWithoutKey(treeData: DataNode[], fieldNames: FieldNames): void;
-/**
- * Convert `children` of Tree into `treeData` structure.
- */
-export declare function convertTreeToData(rootNodes: React.ReactNode): DataNode[];
-/**
- * Flat nest tree data into flatten list. This is used for virtual list render.
- * @param treeNodeList Origin data node list
- * @param expandedKeys
- * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
- */
-export declare function flattenTreeData<TreeDataType extends BasicDataNode = DataNode>(treeNodeList: TreeDataType[], expandedKeys: Key[] | true, fieldNames: FieldNames): FlattenNode<TreeDataType>[];
-type ExternalGetKey = GetKey<DataNode> | string;
-interface TraverseDataNodesConfig {
-    childrenPropName?: string;
-    externalGetKey?: ExternalGetKey;
-    fieldNames?: FieldNames;
-}
-/**
- * Traverse all the data by `treeData`.
- * Please not use it out of the `rc-tree` since we may refactor this code.
- */
-export declare function traverseDataNodes(dataNodes: DataNode[], callback: (data: {
-    node: DataNode;
-    index: number;
-    pos: string;
-    key: Key;
-    parentPos: string | number;
-    level: number;
-    nodes: DataNode[];
-}) => void, config?: TraverseDataNodesConfig | string): void;
-interface Wrapper {
-    posEntities: Record<string, DataEntity>;
-    keyEntities: KeyEntities;
-}
-/**
- * Convert `treeData` into entity records.
- */
-export declare function convertDataToEntities(dataNodes: DataNode[], { initWrapper, processEntity, onProcessFinished, externalGetKey, childrenPropName, fieldNames, }?: {
-    initWrapper?: (wrapper: Wrapper) => Wrapper;
-    processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
-    onProcessFinished?: (wrapper: Wrapper) => void;
-    externalGetKey?: ExternalGetKey;
-    childrenPropName?: string;
-    fieldNames?: FieldNames;
-}, 
-/** @deprecated Use `config.externalGetKey` instead */
-legacyExternalGetKey?: ExternalGetKey): Wrapper;
-export interface TreeNodeRequiredProps<TreeDataType extends BasicDataNode = DataNode> {
-    expandedKeys: Key[];
-    selectedKeys: Key[];
-    loadedKeys: Key[];
-    loadingKeys: Key[];
-    checkedKeys: Key[];
-    halfCheckedKeys: Key[];
-    dragOverNodeKey: Key;
-    dropPosition: number;
-    keyEntities: KeyEntities<TreeDataType>;
-}
-/**
- * Get TreeNode props with Tree props.
- */
-export declare function getTreeNodeProps<TreeDataType extends BasicDataNode = DataNode>(key: Key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities }: TreeNodeRequiredProps<TreeDataType>): {
-    eventKey: React.Key;
-    expanded: boolean;
-    selected: boolean;
-    loaded: boolean;
-    loading: boolean;
-    checked: boolean;
-    halfChecked: boolean;
-    pos: string;
-    dragOver: boolean;
-    dragOverGapTop: boolean;
-    dragOverGapBottom: boolean;
-};
-export declare function convertNodePropsToEventData<TreeDataType extends BasicDataNode = DataNode>(props: TreeNodeProps<TreeDataType>): EventDataNode<TreeDataType>;
-export {};

package/dist/Tree/utils/treeUtil.js

@@ -1,364 +0,0 @@
-var _excluded = ["children"];
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-import toArray from 'rc-util/lib/Children/toArray';
-import omit from 'rc-util/lib/omit';
-import warning from 'rc-util/lib/warning';
-import getEntity from "./keyUtil";
-export function getPosition(level, index) {
-  return "".concat(level, "-").concat(index);
-}
-export function isTreeNode(node) {
-  return node && node.type && node.type.isTreeNode;
-}
-export function getKey(key, pos) {
-  if (key !== null && key !== undefined) {
-    return key;
-  }
-  return pos;
-}
-export function fillFieldNames(fieldNames) {
-  var _ref = fieldNames || {},
-    title = _ref.title,
-    _title = _ref._title,
-    key = _ref.key,
-    children = _ref.children;
-  var mergedTitle = title || 'title';
-  return {
-    title: mergedTitle,
-    _title: _title || [mergedTitle],
-    key: key || 'key',
-    children: children || 'children'
-  };
-}
-
-/**
- * Warning if TreeNode do not provides key
- */
-export function warningWithoutKey(treeData, fieldNames) {
-  var keys = new Map();
-  function dig(list) {
-    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-    (list || []).forEach(function (treeNode) {
-      var key = treeNode[fieldNames.key];
-      var children = treeNode[fieldNames.children];
-      warning(key !== null && key !== undefined, "Tree node must have a certain key: [".concat(path).concat(key, "]"));
-      var recordKey = String(key);
-      warning(!keys.has(recordKey) || key === null || key === undefined, "Same 'key' exist in the Tree: ".concat(recordKey));
-      keys.set(recordKey, true);
-      dig(children, "".concat(path).concat(recordKey, " > "));
-    });
-  }
-  dig(treeData);
-}
-
-/**
- * Convert `children` of Tree into `treeData` structure.
- */
-export function convertTreeToData(rootNodes) {
-  function dig(node) {
-    var treeNodes = toArray(node);
-    return treeNodes.map(function (treeNode) {
-      // Filter invalidate node
-      if (!isTreeNode(treeNode)) {
-        warning(!treeNode, 'Tree/TreeNode can only accept TreeNode as children.');
-        return null;
-      }
-      var key = treeNode.key;
-      var _treeNode$props = treeNode.props,
-        children = _treeNode$props.children,
-        rest = _objectWithoutProperties(_treeNode$props, _excluded);
-      var dataNode = _objectSpread({
-        key: key
-      }, rest);
-      var parsedChildren = dig(children);
-      if (parsedChildren.length) {
-        dataNode.children = parsedChildren;
-      }
-      return dataNode;
-    }).filter(function (dataNode) {
-      return dataNode;
-    });
-  }
-  return dig(rootNodes);
-}
-
-/**
- * Flat nest tree data into flatten list. This is used for virtual list render.
- * @param treeNodeList Origin data node list
- * @param expandedKeys
- * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
- */
-export function flattenTreeData(treeNodeList, expandedKeys, fieldNames) {
-  var _fillFieldNames = fillFieldNames(fieldNames),
-    fieldTitles = _fillFieldNames._title,
-    fieldKey = _fillFieldNames.key,
-    fieldChildren = _fillFieldNames.children;
-  var expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
-  var flattenList = [];
-  function dig(list) {
-    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    return list.map(function (treeNode, index) {
-      var pos = getPosition(parent ? parent.pos : '0', index);
-      var mergedKey = getKey(treeNode[fieldKey], pos);
-
-      // Pick matched title in field title list
-      var mergedTitle;
-      for (var i = 0; i < fieldTitles.length; i += 1) {
-        var fieldTitle = fieldTitles[i];
-        if (treeNode[fieldTitle] !== undefined) {
-          mergedTitle = treeNode[fieldTitle];
-          break;
-        }
-      }
-
-      // Add FlattenDataNode into list
-      // We use `Object.assign` here to save perf since babel's `objectSpread` has perf issue
-      var flattenNode = Object.assign(omit(treeNode, [].concat(_toConsumableArray(fieldTitles), [fieldKey, fieldChildren])), {
-        title: mergedTitle,
-        key: mergedKey,
-        parent: parent,
-        pos: pos,
-        children: null,
-        data: treeNode,
-        isStart: [].concat(_toConsumableArray(parent ? parent.isStart : []), [index === 0]),
-        isEnd: [].concat(_toConsumableArray(parent ? parent.isEnd : []), [index === list.length - 1])
-      });
-      flattenList.push(flattenNode);
-
-      // Loop treeNode children
-      if (expandedKeys === true || expandedKeySet.has(mergedKey)) {
-        flattenNode.children = dig(treeNode[fieldChildren] || [], flattenNode);
-      } else {
-        flattenNode.children = [];
-      }
-      return flattenNode;
-    });
-  }
-  dig(treeNodeList);
-  return flattenList;
-}
-/**
- * Traverse all the data by `treeData`.
- * Please not use it out of the `rc-tree` since we may refactor this code.
- */
-export function traverseDataNodes(dataNodes, callback,
-// To avoid too many params, let use config instead of origin param
-config) {
-  var mergedConfig = {};
-  if (_typeof(config) === 'object') {
-    mergedConfig = config;
-  } else {
-    mergedConfig = {
-      externalGetKey: config
-    };
-  }
-  mergedConfig = mergedConfig || {};
-
-  // Init config
-  var _mergedConfig = mergedConfig,
-    childrenPropName = _mergedConfig.childrenPropName,
-    externalGetKey = _mergedConfig.externalGetKey,
-    fieldNames = _mergedConfig.fieldNames;
-  var _fillFieldNames2 = fillFieldNames(fieldNames),
-    fieldKey = _fillFieldNames2.key,
-    fieldChildren = _fillFieldNames2.children;
-  var mergeChildrenPropName = childrenPropName || fieldChildren;
-
-  // Get keys
-  var syntheticGetKey;
-  if (externalGetKey) {
-    if (typeof externalGetKey === 'string') {
-      syntheticGetKey = function syntheticGetKey(node) {
-        return node[externalGetKey];
-      };
-    } else if (typeof externalGetKey === 'function') {
-      syntheticGetKey = function syntheticGetKey(node) {
-        return externalGetKey(node);
-      };
-    }
-  } else {
-    syntheticGetKey = function syntheticGetKey(node, pos) {
-      return getKey(node[fieldKey], pos);
-    };
-  }
-
-  // Process
-  function processNode(node, index, parent, pathNodes) {
-    var children = node ? node[mergeChildrenPropName] : dataNodes;
-    var pos = node ? getPosition(parent.pos, index) : '0';
-    var connectNodes = node ? [].concat(_toConsumableArray(pathNodes), [node]) : [];
-
-    // Process node if is not root
-    if (node) {
-      var key = syntheticGetKey(node, pos);
-      var _data = {
-        node: node,
-        index: index,
-        pos: pos,
-        key: key,
-        parentPos: parent.node ? parent.pos : null,
-        level: parent.level + 1,
-        nodes: connectNodes
-      };
-      callback(_data);
-    }
-
-    // Process children node
-    if (children) {
-      children.forEach(function (subNode, subIndex) {
-        processNode(subNode, subIndex, {
-          node: node,
-          pos: pos,
-          level: parent ? parent.level + 1 : -1
-        }, connectNodes);
-      });
-    }
-  }
-  processNode(null);
-}
-/**
- * Convert `treeData` into entity records.
- */
-export function convertDataToEntities(dataNodes) {
-  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-    initWrapper = _ref2.initWrapper,
-    processEntity = _ref2.processEntity,
-    onProcessFinished = _ref2.onProcessFinished,
-    externalGetKey = _ref2.externalGetKey,
-    childrenPropName = _ref2.childrenPropName,
-    fieldNames = _ref2.fieldNames;
-  var /** @deprecated Use `config.externalGetKey` instead */
-  legacyExternalGetKey = arguments.length > 2 ? arguments[2] : undefined;
-  // Init config
-  var mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
-  var posEntities = {};
-  var keyEntities = {};
-  var wrapper = {
-    posEntities: posEntities,
-    keyEntities: keyEntities
-  };
-  if (initWrapper) {
-    wrapper = initWrapper(wrapper) || wrapper;
-  }
-  traverseDataNodes(dataNodes, function (item) {
-    var node = item.node,
-      index = item.index,
-      pos = item.pos,
-      key = item.key,
-      parentPos = item.parentPos,
-      level = item.level,
-      nodes = item.nodes;
-    var entity = {
-      node: node,
-      nodes: nodes,
-      index: index,
-      key: key,
-      pos: pos,
-      level: level
-    };
-    var mergedKey = getKey(key, pos);
-    posEntities[pos] = entity;
-    keyEntities[mergedKey] = entity;
-
-    // Fill children
-    entity.parent = posEntities[parentPos];
-    if (entity.parent) {
-      entity.parent.children = entity.parent.children || [];
-      entity.parent.children.push(entity);
-    }
-    if (processEntity) {
-      processEntity(entity, wrapper);
-    }
-  }, {
-    externalGetKey: mergedExternalGetKey,
-    childrenPropName: childrenPropName,
-    fieldNames: fieldNames
-  });
-  if (onProcessFinished) {
-    onProcessFinished(wrapper);
-  }
-  return wrapper;
-}
-/**
- * Get TreeNode props with Tree props.
- */
-export function getTreeNodeProps(key, _ref3) {
-  var expandedKeys = _ref3.expandedKeys,
-    selectedKeys = _ref3.selectedKeys,
-    loadedKeys = _ref3.loadedKeys,
-    loadingKeys = _ref3.loadingKeys,
-    checkedKeys = _ref3.checkedKeys,
-    halfCheckedKeys = _ref3.halfCheckedKeys,
-    dragOverNodeKey = _ref3.dragOverNodeKey,
-    dropPosition = _ref3.dropPosition,
-    keyEntities = _ref3.keyEntities;
-  var entity = getEntity(keyEntities, key);
-  var treeNodeProps = {
-    eventKey: key,
-    expanded: expandedKeys.indexOf(key) !== -1,
-    selected: selectedKeys.indexOf(key) !== -1,
-    loaded: loadedKeys.indexOf(key) !== -1,
-    loading: loadingKeys.indexOf(key) !== -1,
-    checked: checkedKeys.indexOf(key) !== -1,
-    halfChecked: halfCheckedKeys.indexOf(key) !== -1,
-    pos: String(entity ? entity.pos : ''),
-    // [Legacy] Drag props
-    // Since the interaction of drag is changed, the semantic of the props are
-    // not accuracy, I think it should be finally removed
-    dragOver: dragOverNodeKey === key && dropPosition === 0,
-    dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
-    dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1
-  };
-  return treeNodeProps;
-}
-export function convertNodePropsToEventData(props) {
-  var data = props.data,
-    expanded = props.expanded,
-    selected = props.selected,
-    checked = props.checked,
-    loaded = props.loaded,
-    loading = props.loading,
-    halfChecked = props.halfChecked,
-    dragOver = props.dragOver,
-    dragOverGapTop = props.dragOverGapTop,
-    dragOverGapBottom = props.dragOverGapBottom,
-    pos = props.pos,
-    active = props.active,
-    eventKey = props.eventKey;
-  var eventData = _objectSpread(_objectSpread({}, data), {}, {
-    expanded: expanded,
-    selected: selected,
-    checked: checked,
-    loaded: loaded,
-    loading: loading,
-    halfChecked: halfChecked,
-    dragOver: dragOver,
-    dragOverGapTop: dragOverGapTop,
-    dragOverGapBottom: dragOverGapBottom,
-    pos: pos,
-    active: active,
-    key: eventKey
-  });
-  if (!('props' in eventData)) {
-    Object.defineProperty(eventData, 'props', {
-      get: function get() {
-        warning(false, 'Second param return from event is node data instead of TreeNode instance. Please read value directly instead of reading from `props`.');
-        return props;
-      }
-    });
-  }
-  return eventData;
-}

package/dist/TreeSelect/Utils.d.ts

@@ -1,3 +0,0 @@
-import { DataNode } from '../Tree';
-/** 单选不可选父级 */
-export declare const parentNotSelectable: (treeData?: DataNode[]) => DataNode[];

package/dist/TreeSelect/Utils.js

@@ -1,20 +0,0 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/** 单选不可选父级 */
-export var parentNotSelectable = function parentNotSelectable() {
-  var treeData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  return treeData.map(function (node) {
-    var _node$children;
-    if ((node === null || node === void 0 || (_node$children = node.children) === null || _node$children === void 0 ? void 0 : _node$children.length) > 0) {
-      node.children = parentNotSelectable(node.children);
-      return _objectSpread(_objectSpread({}, node), {}, {
-        selectable: false
-      });
-    }
-    return node;
-  });
-};