"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.MotionEntity = exports.MOTION_KEY = void 0;
exports.getMinimumRangeTransitionRange = getMinimumRangeTransitionRange;

var _vue = require("vue");

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));

var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _vcVirtualList = _interopRequireDefault(require("../vc-virtual-list"));

var _MotionTreeNode = _interopRequireDefault(require("./MotionTreeNode"));

var _props = require("./props");

var _diffUtil = require("./utils/diffUtil");

var _treeUtil = require("./utils/treeUtil");

/**
 * Handle virtual list of the TreeNodes.
 */
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;
};

var HIDDEN_STYLE = {
  width: 0,
  height: 0,
  display: 'flex',
  overflow: 'hidden',
  opacity: 0,
  border: 0,
  padding: 0,
  margin: 0
};

var noop = function noop() {};

var MOTION_KEY = "RC_TREE_MOTION_".concat(Math.random());
exports.MOTION_KEY = MOTION_KEY;
var MotionNode = {
  key: MOTION_KEY
};
var MotionEntity = {
  key: MOTION_KEY,
  level: 0,
  index: 0,
  pos: '0',
  node: MotionNode
};
exports.MotionEntity = MotionEntity;
var MotionFlattenData = {
  parent: null,
  children: [],
  pos: MotionEntity.pos,
  data: MotionNode,
  title: null,
  key: MOTION_KEY,

  /** Hold empty list here since we do not use it */
  isStart: [],
  isEnd: []
};
/**
 * We only need get visible content items to play the animation.
 */

function getMinimumRangeTransitionRange(list, virtual, height, itemHeight) {
  if (virtual === false || !height) {
    return list;
  }

  return list.slice(0, Math.ceil(height / itemHeight) + 1);
}

function itemKey(item) {
  var key = item.key,
      pos = item.pos;
  return (0, _treeUtil.getKey)(key, pos);
}

function getAccessibilityPath(item) {
  var path = String(item.key);
  var current = item;

  while (current.parent) {
    current = current.parent;
    path = "".concat(current.key, " > ").concat(path);
  }

  return path;
}

var _default = (0, _vue.defineComponent)({
  name: 'NodeList',
  inheritAttrs: false,
  props: _props.nodeListProps,
  setup: function setup(props, _ref) {
    var expose = _ref.expose,
        attrs = _ref.attrs;
    // =============================== Ref ================================
    var listRef = (0, _vue.ref)();
    var indentMeasurerRef = (0, _vue.ref)();
    expose({
      scrollTo: function scrollTo(scroll) {
        listRef.value.scrollTo(scroll);
      },
      getIndentWidth: function getIndentWidth() {
        return indentMeasurerRef.value.offsetWidth;
      }
    }); // ============================== Motion ==============================

    var transitionData = (0, _vue.shallowRef)(props.data);
    var transitionRange = (0, _vue.shallowRef)([]);
    var motionType = (0, _vue.ref)(null);

    function onMotionEnd() {
      transitionData.value = props.data;
      transitionRange.value = [];
      motionType.value = null;
      props.onListChangeEnd();
    }

    (0, _vue.watch)([function () {
      return (0, _toConsumableArray2.default)(props.expandedKeys);
    }, function () {
      return props.data;
    }], function (_ref2, _ref3) {
      var _ref4 = (0, _slicedToArray2.default)(_ref2, 2),
          expandedKeys = _ref4[0],
          data = _ref4[1];

      var _ref5 = (0, _slicedToArray2.default)(_ref3, 2),
          prevExpandedKeys = _ref5[0],
          prevData = _ref5[1];

      var diffExpanded = (0, _diffUtil.findExpandedKeys)(prevExpandedKeys, expandedKeys);

      if (diffExpanded.key !== null) {
        var virtual = props.virtual,
            height = props.height,
            itemHeight = props.itemHeight;

        if (diffExpanded.add) {
          var keyIndex = prevData.findIndex(function (_ref6) {
            var key = _ref6.key;
            return key === diffExpanded.key;
          });
          var rangeNodes = getMinimumRangeTransitionRange((0, _diffUtil.getExpandRange)(prevData, data, diffExpanded.key), virtual, height, itemHeight);
          var newTransitionData = prevData.slice();
          newTransitionData.splice(keyIndex + 1, 0, MotionFlattenData);
          transitionData.value = newTransitionData;
          transitionRange.value = rangeNodes;
          motionType.value = 'show';
        } else {
          var _keyIndex = data.findIndex(function (_ref7) {
            var key = _ref7.key;
            return key === diffExpanded.key;
          });

          var _rangeNodes = getMinimumRangeTransitionRange((0, _diffUtil.getExpandRange)(data, prevData, diffExpanded.key), virtual, height, itemHeight);

          var _newTransitionData = data.slice();

          _newTransitionData.splice(_keyIndex + 1, 0, MotionFlattenData);

          transitionData.value = _newTransitionData;
          transitionRange.value = _rangeNodes;
          motionType.value = 'hide';
        }
      } else if (prevData !== data) {
        transitionData.value = data;
      }
    }); // We should clean up motion if is changed by dragging

    (0, _vue.watch)(function () {
      return props.dragging;
    }, function (dragging) {
      if (!dragging) {
        onMotionEnd();
      }
    });
    var mergedData = (0, _vue.computed)(function () {
      return props.motion === undefined ? transitionData.value : props.data;
    });
    return function () {
      var _a = (0, _extends2.default)((0, _extends2.default)({}, props), attrs),
          prefixCls = _a.prefixCls,
          data = _a.data,
          selectable = _a.selectable,
          checkable = _a.checkable,
          expandedKeys = _a.expandedKeys,
          selectedKeys = _a.selectedKeys,
          checkedKeys = _a.checkedKeys,
          loadedKeys = _a.loadedKeys,
          loadingKeys = _a.loadingKeys,
          halfCheckedKeys = _a.halfCheckedKeys,
          keyEntities = _a.keyEntities,
          disabled = _a.disabled,
          dragging = _a.dragging,
          dragOverNodeKey = _a.dragOverNodeKey,
          dropPosition = _a.dropPosition,
          motion = _a.motion,
          height = _a.height,
          itemHeight = _a.itemHeight,
          virtual = _a.virtual,
          focusable = _a.focusable,
          activeItem = _a.activeItem,
          focused = _a.focused,
          tabindex = _a.tabindex,
          onKeydown = _a.onKeydown,
          onFocus = _a.onFocus,
          onBlur = _a.onBlur,
          onActiveChange = _a.onActiveChange,
          onListChangeStart = _a.onListChangeStart,
          onListChangeEnd = _a.onListChangeEnd,
          domProps = __rest(_a, ["prefixCls", "data", "selectable", "checkable", "expandedKeys", "selectedKeys", "checkedKeys", "loadedKeys", "loadingKeys", "halfCheckedKeys", "keyEntities", "disabled", "dragging", "dragOverNodeKey", "dropPosition", "motion", "height", "itemHeight", "virtual", "focusable", "activeItem", "focused", "tabindex", "onKeydown", "onFocus", "onBlur", "onActiveChange", "onListChangeStart", "onListChangeEnd"]);

      var treeNodeRequiredProps = {
        expandedKeys: expandedKeys,
        selectedKeys: selectedKeys,
        loadedKeys: loadedKeys,
        loadingKeys: loadingKeys,
        checkedKeys: checkedKeys,
        halfCheckedKeys: halfCheckedKeys,
        dragOverNodeKey: dragOverNodeKey,
        dropPosition: dropPosition,
        keyEntities: keyEntities
      };
      return (0, _vue.createVNode)(_vue.Fragment, null, [focused && activeItem && (0, _vue.createVNode)("span", {
        "style": HIDDEN_STYLE,
        "aria-live": "assertive"
      }, [getAccessibilityPath(activeItem)]), (0, _vue.createVNode)("div", null, [(0, _vue.createVNode)("input", {
        "style": HIDDEN_STYLE,
        "disabled": focusable === false || disabled,
        "tabindex": focusable !== false ? tabindex : null,
        "onKeydown": onKeydown,
        "onFocus": onFocus,
        "onBlur": onBlur,
        "value": "",
        "onChange": noop,
        "aria-label": "for screen reader"
      }, null)]), (0, _vue.createVNode)("div", {
        "class": "".concat(prefixCls, "-treenode"),
        "aria-hidden": true,
        "style": {
          position: 'absolute',
          pointerEvents: 'none',
          visibility: 'hidden',
          height: 0,
          overflow: 'hidden'
        }
      }, [(0, _vue.createVNode)("div", {
        "class": "".concat(prefixCls, "-indent")
      }, [(0, _vue.createVNode)("div", {
        "ref": indentMeasurerRef,
        "class": "".concat(prefixCls, "-indent-unit")
      }, null)])]), (0, _vue.createVNode)(_vcVirtualList.default, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, domProps), {}, {
        "data": mergedData.value,
        "itemKey": itemKey,
        "height": height,
        "fullHeight": false,
        "virtual": virtual,
        "itemHeight": itemHeight,
        "prefixCls": "".concat(prefixCls, "-list"),
        "ref": listRef,
        "children": function children(treeNode) {
          var pos = treeNode.pos,
              restProps = __rest(treeNode.data, []),
              title = treeNode.title,
              key = treeNode.key,
              isStart = treeNode.isStart,
              isEnd = treeNode.isEnd;

          var mergedKey = (0, _treeUtil.getKey)(key, pos);
          delete restProps.key;
          delete restProps.children;
          var treeNodeProps = (0, _treeUtil.getTreeNodeProps)(mergedKey, treeNodeRequiredProps);
          return (0, _vue.createVNode)(_MotionTreeNode.default, (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, restProps), treeNodeProps), {}, {
            "title": title,
            "active": !!activeItem && key === activeItem.key,
            "pos": pos,
            "data": treeNode.data,
            "isStart": isStart,
            "isEnd": isEnd,
            "motion": motion,
            "motionNodes": key === MOTION_KEY ? transitionRange.value : null,
            "motionType": motionType.value,
            "onMotionStart": onListChangeStart,
            "onMotionEnd": onMotionEnd,
            "treeNodeRequiredProps": treeNodeRequiredProps,
            "onMousemove": function onMousemove() {
              onActiveChange(null);
            }
          }), null);
        }
      }), null)]);
    };
  }
});

exports.default = _default;