Latest updates from IceHrmPro

web/node_modules/rc-tree/lib/utils/conductUtil.d.ts

@@ -0,0 +1,17 @@
+import { Key, DataEntity, DataNode } from '../interface';
+interface ConductReturnType {
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+}
+export declare function isCheckDisabled(node: DataNode): boolean;
+/**
+ * Conduct with keys.
+ * @param keyList current key list
+ * @param keyEntities key - dataEntity map
+ * @param mode `fill` to fill missing key, `clean` to remove useless key
+ */
+export declare function conductCheck(keyList: Key[], checked: true | {
+    checked: false;
+    halfCheckedKeys: Key[];
+}, keyEntities: Record<Key, DataEntity>): ConductReturnType;
+export {};

web/node_modules/rc-tree/lib/utils/conductUtil.js

@@ -0,0 +1,236 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isCheckDisabled = isCheckDisabled;
+exports.conductCheck = conductCheck;
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
+  var filteredKeys = new Set();
+  halfCheckedKeys.forEach(function (key) {
+    if (!checkedKeys.has(key)) {
+      filteredKeys.add(key);
+    }
+  });
+  return filteredKeys;
+}
+
+function isCheckDisabled(node) {
+  var _ref = node || {},
+      disabled = _ref.disabled,
+      disableCheckbox = _ref.disableCheckbox,
+      checkable = _ref.checkable;
+
+  return !!(disabled || disableCheckbox) || checkable === false;
+} // Fill miss keys
+
+
+function fillConductCheck(keys, levelEntities, maxLevel) {
+  var checkedKeys = new Set(keys);
+  var halfCheckedKeys = new Set(); // Add checked keys top to bottom
+
+  for (var level = 0; level <= maxLevel; level += 1) {
+    var entities = levelEntities.get(level) || new Set();
+    entities.forEach(function (entity) {
+      var key = entity.key,
+          node = entity.node,
+          _entity$children = entity.children,
+          children = _entity$children === void 0 ? [] : _entity$children;
+
+      if (checkedKeys.has(key) && !isCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !isCheckDisabled(childEntity.node);
+        }).forEach(function (childEntity) {
+          checkedKeys.add(childEntity.key);
+        });
+      }
+    });
+  } // Add checked keys from bottom to top
+
+
+  var visitedKeys = new Set();
+
+  for (var _level = maxLevel; _level >= 0; _level -= 1) {
+    var _entities = levelEntities.get(_level) || new Set();
+
+    _entities.forEach(function (entity) {
+      var parent = entity.parent,
+          node = entity.node; // Skip if no need to check
+
+      if (isCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      } // Skip if parent is disabled
+
+
+      if (isCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !isCheckDisabled(childEntity.node);
+      }).forEach(function (_ref2) {
+        var key = _ref2.key;
+        var checked = checkedKeys.has(key);
+
+        if (allChecked && !checked) {
+          allChecked = false;
+        }
+
+        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
+          partialChecked = true;
+        }
+      });
+
+      if (allChecked) {
+        checkedKeys.add(parent.key);
+      }
+
+      if (partialChecked) {
+        halfCheckedKeys.add(parent.key);
+      }
+
+      visitedKeys.add(parent.key);
+    });
+  }
+
+  return {
+    checkedKeys: Array.from(checkedKeys),
+    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
+  };
+} // Remove useless key
+
+
+function cleanConductCheck(keys, halfKeys, levelEntities, maxLevel) {
+  var checkedKeys = new Set(keys);
+  var halfCheckedKeys = new Set(halfKeys); // Remove checked keys from top to bottom
+
+  for (var level = 0; level <= maxLevel; level += 1) {
+    var entities = levelEntities.get(level) || new Set();
+    entities.forEach(function (entity) {
+      var key = entity.key,
+          node = entity.node,
+          _entity$children2 = entity.children,
+          children = _entity$children2 === void 0 ? [] : _entity$children2;
+
+      if (!checkedKeys.has(key) && !halfCheckedKeys.has(key) && !isCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !isCheckDisabled(childEntity.node);
+        }).forEach(function (childEntity) {
+          checkedKeys.delete(childEntity.key);
+        });
+      }
+    });
+  } // Remove checked keys form bottom to top
+
+
+  halfCheckedKeys = new Set();
+  var visitedKeys = new Set();
+
+  for (var _level2 = maxLevel; _level2 >= 0; _level2 -= 1) {
+    var _entities2 = levelEntities.get(_level2) || new Set();
+
+    _entities2.forEach(function (entity) {
+      var parent = entity.parent,
+          node = entity.node; // Skip if no need to check
+
+      if (isCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      } // Skip if parent is disabled
+
+
+      if (isCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !isCheckDisabled(childEntity.node);
+      }).forEach(function (_ref3) {
+        var key = _ref3.key;
+        var checked = checkedKeys.has(key);
+
+        if (allChecked && !checked) {
+          allChecked = false;
+        }
+
+        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
+          partialChecked = true;
+        }
+      });
+
+      if (!allChecked) {
+        checkedKeys.delete(parent.key);
+      }
+
+      if (partialChecked) {
+        halfCheckedKeys.add(parent.key);
+      }
+
+      visitedKeys.add(parent.key);
+    });
+  }
+
+  return {
+    checkedKeys: Array.from(checkedKeys),
+    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
+  };
+}
+/**
+ * Conduct with keys.
+ * @param keyList current key list
+ * @param keyEntities key - dataEntity map
+ * @param mode `fill` to fill missing key, `clean` to remove useless key
+ */
+
+
+function conductCheck(keyList, checked, keyEntities) {
+  var warningMissKeys = []; // We only handle exist keys
+
+  var keys = new Set(keyList.filter(function (key) {
+    var hasEntity = !!keyEntities[key];
+
+    if (!hasEntity) {
+      warningMissKeys.push(key);
+    }
+
+    return hasEntity;
+  }));
+  var levelEntities = new Map();
+  var maxLevel = 0; // Convert entities by level for calculation
+
+  Object.keys(keyEntities).forEach(function (key) {
+    var entity = keyEntities[key];
+    var level = entity.level;
+    var levelSet = levelEntities.get(level);
+
+    if (!levelSet) {
+      levelSet = new Set();
+      levelEntities.set(level, levelSet);
+    }
+
+    levelSet.add(entity);
+    maxLevel = Math.max(maxLevel, level);
+  });
+  (0, _warning.default)(!warningMissKeys.length, "Tree missing follow keys: ".concat(warningMissKeys.slice(0, 100).map(function (key) {
+    return "'".concat(key, "'");
+  }).join(', ')));
+  var result;
+
+  if (checked === true) {
+    result = fillConductCheck(keys, levelEntities, maxLevel);
+  } else {
+    result = cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, maxLevel);
+  }
+
+  return result;
+}

web/node_modules/rc-tree/lib/utils/diffUtil.d.ts

@@ -0,0 +1,6 @@
+import { Key, FlattenNode } from '../interface';
+export declare function findExpandedKeys(prev?: Key[], next?: Key[]): {
+    add: boolean;
+    key: string | number;
+};
+export declare function getExpandRange(shorter: FlattenNode[], longer: FlattenNode[], key: Key): FlattenNode[];

web/node_modules/rc-tree/lib/utils/diffUtil.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findExpandedKeys = findExpandedKeys;
+exports.getExpandRange = getExpandRange;
+
+function findExpandedKeys() {
+  var prev = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var next = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var prevLen = prev.length;
+  var nextLen = next.length;
+
+  if (Math.abs(prevLen - nextLen) !== 1) {
+    return {
+      add: false,
+      key: null
+    };
+  }
+
+  function find(shorter, longer) {
+    var cache = new Map();
+    shorter.forEach(function (key) {
+      cache.set(key, true);
+    });
+    var keys = longer.filter(function (key) {
+      return !cache.has(key);
+    });
+    return keys.length === 1 ? keys[0] : null;
+  }
+
+  if (prevLen < nextLen) {
+    return {
+      add: true,
+      key: find(prev, next)
+    };
+  }
+
+  return {
+    add: false,
+    key: find(next, prev)
+  };
+}
+
+function getExpandRange(shorter, longer, key) {
+  var shorterStartIndex = shorter.findIndex(function (_ref) {
+    var data = _ref.data;
+    return data.key === key;
+  });
+  var shorterEndNode = shorter[shorterStartIndex + 1];
+  var longerStartIndex = longer.findIndex(function (_ref2) {
+    var data = _ref2.data;
+    return data.key === key;
+  });
+
+  if (shorterEndNode) {
+    var longerEndIndex = longer.findIndex(function (_ref3) {
+      var data = _ref3.data;
+      return data.key === shorterEndNode.data.key;
+    });
+    return longer.slice(longerStartIndex + 1, longerEndIndex);
+  }
+
+  return longer.slice(longerStartIndex + 1);
+}

web/node_modules/rc-tree/lib/utils/treeUtil.d.ts

@@ -0,0 +1,75 @@
+import * as React from 'react';
+import { DataNode, FlattenNode, DataEntity, Key, EventDataNode } from '../interface';
+import { TreeNodeProps } from '../TreeNode';
+export declare function getKey(key: Key, pos: string): string | number;
+/**
+ * Warning if TreeNode do not provides key
+ */
+export declare function warningWithoutKey(treeData?: DataNode[]): 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(treeNodeList?: DataNode[], expandedKeys?: Key[] | true): FlattenNode[];
+/**
+ * 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;
+}) => void): void;
+interface Wrapper {
+    posEntities: Record<string, DataEntity>;
+    keyEntities: Record<Key, DataEntity>;
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+export declare function convertDataToEntities(dataNodes: DataNode[], { initWrapper, processEntity, onProcessFinished, }?: {
+    initWrapper?: (wrapper: Wrapper) => Wrapper;
+    processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
+    onProcessFinished?: (wrapper: Wrapper) => void;
+}): {
+    posEntities: {};
+    keyEntities: {};
+};
+export interface TreeNodeRequiredProps {
+    expandedKeys: Key[];
+    selectedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    keyEntities: Record<Key, DataEntity>;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+export declare function getTreeNodeProps(key: Key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities, }: TreeNodeRequiredProps): {
+    eventKey: string | number;
+    expanded: boolean;
+    selected: boolean;
+    loaded: boolean;
+    loading: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+};
+export declare function convertNodePropsToEventData(props: TreeNodeProps): EventDataNode;
+export {};

web/node_modules/rc-tree/lib/utils/treeUtil.js

@@ -0,0 +1,321 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getKey = getKey;
+exports.warningWithoutKey = warningWithoutKey;
+exports.convertTreeToData = convertTreeToData;
+exports.flattenTreeData = flattenTreeData;
+exports.traverseDataNodes = traverseDataNodes;
+exports.convertDataToEntities = convertDataToEntities;
+exports.getTreeNodeProps = getTreeNodeProps;
+exports.convertNodePropsToEventData = convertNodePropsToEventData;
+
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _util = require("../util");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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; }
+
+function getKey(key, pos) {
+  if (key !== null && key !== undefined) {
+    return key;
+  }
+
+  return pos;
+}
+/**
+ * Warning if TreeNode do not provides key
+ */
+
+
+function warningWithoutKey() {
+  var treeData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var keys = new Map();
+
+  function dig(list) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    (list || []).forEach(function (treeNode) {
+      var key = treeNode.key,
+          children = treeNode.children;
+      (0, _warning.default)(key !== null && key !== undefined, "Tree node must have a certain key: [".concat(path).concat(key, "]"));
+      var recordKey = String(key);
+      (0, _warning.default)(!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.
+ */
+
+
+function convertTreeToData(rootNodes) {
+  function dig(node) {
+    var treeNodes = (0, _toArray.default)(node);
+    return treeNodes.map(function (treeNode) {
+      // Filter invalidate node
+      if (!(0, _util.isTreeNode)(treeNode)) {
+        (0, _warning.default)(!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, ["children"]);
+
+      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`).
+ */
+
+
+function flattenTreeData() {
+  var treeNodeList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var expandedKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  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 = (0, _util.getPosition)(parent ? parent.pos : '0', index);
+      var mergedKey = getKey(treeNode.key, pos); // Add FlattenDataNode into list
+
+      var flattenNode = _objectSpread({}, treeNode, {
+        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.children || [], 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.
+ */
+
+
+function traverseDataNodes(dataNodes, callback) {
+  function processNode(node, index, parent) {
+    var children = node ? node.children : dataNodes;
+    var pos = node ? (0, _util.getPosition)(parent.pos, index) : '0'; // Process node if is not root
+
+    if (node) {
+      var data = {
+        node: node,
+        index: index,
+        pos: pos,
+        key: node.key !== null ? node.key : pos,
+        parentPos: parent.node ? parent.pos : null,
+        level: parent.level + 1
+      };
+      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
+        });
+      });
+    }
+  }
+
+  processNode(null);
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+
+
+function convertDataToEntities(dataNodes) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      initWrapper = _ref.initWrapper,
+      processEntity = _ref.processEntity,
+      onProcessFinished = _ref.onProcessFinished;
+
+  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;
+    var entity = {
+      node: node,
+      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);
+    }
+  });
+
+  if (onProcessFinished) {
+    onProcessFinished(wrapper);
+  }
+
+  return wrapper;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+
+
+function getTreeNodeProps(key, _ref2) {
+  var expandedKeys = _ref2.expandedKeys,
+      selectedKeys = _ref2.selectedKeys,
+      loadedKeys = _ref2.loadedKeys,
+      loadingKeys = _ref2.loadingKeys,
+      checkedKeys = _ref2.checkedKeys,
+      halfCheckedKeys = _ref2.halfCheckedKeys,
+      dragOverNodeKey = _ref2.dragOverNodeKey,
+      dropPosition = _ref2.dropPosition,
+      keyEntities = _ref2.keyEntities;
+  var entity = 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
+    dragOver: dragOverNodeKey === key && dropPosition === 0,
+    dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
+    dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1
+  };
+  return treeNodeProps;
+}
+
+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;
+
+  var eventData = _objectSpread({}, data, {
+    expanded: expanded,
+    selected: selected,
+    checked: checked,
+    loaded: loaded,
+    loading: loading,
+    halfChecked: halfChecked,
+    dragOver: dragOver,
+    dragOverGapTop: dragOverGapTop,
+    dragOverGapBottom: dragOverGapBottom,
+    pos: pos,
+    active: active
+  });
+
+  if (!('props' in eventData)) {
+    Object.defineProperty(eventData, 'props', {
+      get: function get() {
+        (0, _warning.default)(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;
+}