"use strict";

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

var _VData = require("../VData");

var _VDataFooter = _interopRequireDefault(require("./VDataFooter"));

var _themeable = _interopRequireDefault(require("../../mixins/themeable"));

var _helpers = require("../../util/helpers");

var _console = require("../../util/console");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

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(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(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; }

/* @vue/component */
var _default2 = _themeable.default.extend({
  name: 'v-data-iterator',
  props: _objectSpread({}, _VData.VData.options.props, {
    itemKey: {
      type: String,
      default: 'id'
    },
    value: {
      type: Array,
      default: function _default() {
        return [];
      }
    },
    singleSelect: Boolean,
    expanded: {
      type: Array,
      default: function _default() {
        return [];
      }
    },
    singleExpand: Boolean,
    loading: [Boolean, String],
    noResultsText: {
      type: String,
      default: '$vuetify.dataIterator.noResultsText'
    },
    noDataText: {
      type: String,
      default: '$vuetify.noDataText'
    },
    loadingText: {
      type: String,
      default: '$vuetify.dataIterator.loadingText'
    },
    hideDefaultFooter: Boolean,
    footerProps: Object
  }),
  data: function data() {
    return {
      selection: {},
      expansion: {},
      internalCurrentItems: []
    };
  },
  computed: {
    everyItem: function everyItem() {
      var _this = this;

      return !!this.internalCurrentItems.length && this.internalCurrentItems.every(function (i) {
        return _this.isSelected(i);
      });
    },
    someItems: function someItems() {
      var _this2 = this;

      return this.internalCurrentItems.some(function (i) {
        return _this2.isSelected(i);
      });
    }
  },
  watch: {
    value: {
      handler: function handler(value) {
        var _this3 = this;

        this.selection = value.reduce(function (selection, item) {
          selection[(0, _helpers.getObjectValueByPath)(item, _this3.itemKey)] = item;
          return selection;
        }, {});
      },
      immediate: true
    },
    selection: function selection(value, old) {
      if ((0, _helpers.deepEqual)(Object.keys(value), Object.keys(old))) return;
      this.$emit('input', Object.values(value));
    },
    expanded: {
      handler: function handler(value) {
        var _this4 = this;

        this.expansion = value.reduce(function (expansion, item) {
          expansion[(0, _helpers.getObjectValueByPath)(item, _this4.itemKey)] = true;
          return expansion;
        }, {});
      },
      immediate: true
    },
    expansion: function expansion(value, old) {
      var _this5 = this;

      if ((0, _helpers.deepEqual)(value, old)) return;
      var keys = Object.keys(value).filter(function (k) {
        return value[k];
      });
      var expanded = !keys.length ? [] : this.items.filter(function (i) {
        return keys.includes(String((0, _helpers.getObjectValueByPath)(i, _this5.itemKey)));
      });
      this.$emit('update:expanded', expanded);
    }
  },
  created: function created() {
    var _this6 = this;

    var breakingProps = [['disable-initial-sort', 'sort-by'], ['filter', 'custom-filter'], ['pagination', 'options'], ['total-items', 'server-items-length'], ['hide-actions', 'hide-default-footer'], ['rows-per-page-items', 'footer-props.items-per-page-options'], ['rows-per-page-text', 'footer-props.items-per-page-text'], ['prev-icon', 'footer-props.prev-icon'], ['next-icon', 'footer-props.next-icon']];
    /* istanbul ignore next */

    breakingProps.forEach(function (_ref) {
      var _ref2 = _slicedToArray(_ref, 2),
          original = _ref2[0],
          replacement = _ref2[1];

      if (_this6.$attrs.hasOwnProperty(original)) (0, _console.breaking)(original, replacement, _this6);
    });
    var removedProps = ['expand', 'content-class', 'content-props', 'content-tag'];
    /* istanbul ignore next */

    removedProps.forEach(function (prop) {
      if (_this6.$attrs.hasOwnProperty(prop)) (0, _console.removed)(prop);
    });
  },
  methods: {
    toggleSelectAll: function toggleSelectAll(value) {
      var _this7 = this;

      var selection = Object.assign({}, this.selection);
      this.internalCurrentItems.forEach(function (item) {
        var key = (0, _helpers.getObjectValueByPath)(item, _this7.itemKey);
        if (value) selection[key] = item;else delete selection[key];
      });
      this.selection = selection;
    },
    isSelected: function isSelected(item) {
      return !!this.selection[(0, _helpers.getObjectValueByPath)(item, this.itemKey)] || false;
    },
    select: function select(item) {
      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
      var emit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
      var selection = this.singleSelect ? {} : Object.assign({}, this.selection);
      var key = (0, _helpers.getObjectValueByPath)(item, this.itemKey);
      if (value) selection[key] = item;else delete selection[key];
      this.selection = selection;
      emit && this.$emit('item-selected', {
        item: item,
        value: value
      });
    },
    isExpanded: function isExpanded(item) {
      return this.expansion[(0, _helpers.getObjectValueByPath)(item, this.itemKey)] || false;
    },
    expand: function expand(item) {
      var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
      var expansion = this.singleExpand ? {} : Object.assign({}, this.expansion);
      var key = (0, _helpers.getObjectValueByPath)(item, this.itemKey);
      if (value) expansion[key] = true;else delete expansion[key];
      this.expansion = expansion;
      this.$emit('item-expanded', {
        item: item,
        value: value
      });
    },
    createItemProps: function createItemProps(item) {
      var _this8 = this;

      var props = {
        item: item,
        select: function select(v) {
          return _this8.select(item, v);
        },
        isSelected: this.isSelected(item),
        expand: function expand(v) {
          return _this8.expand(item, v);
        },
        isExpanded: this.isExpanded(item)
      };
      return props;
    },
    genEmptyWrapper: function genEmptyWrapper(content) {
      return this.$createElement('div', content);
    },
    genEmpty: function genEmpty(itemsLength) {
      if (itemsLength <= 0 && this.loading) {
        var loading = this.$slots['loading'] || this.$vuetify.lang.t(this.loadingText);
        return this.genEmptyWrapper(loading);
      } else if (itemsLength <= 0 && !this.items.length) {
        var noData = this.$slots['no-data'] || this.$vuetify.lang.t(this.noDataText);
        return this.genEmptyWrapper(noData);
      } else if (itemsLength <= 0 && this.search) {
        var noResults = this.$slots['no-results'] || this.$vuetify.lang.t(this.noResultsText);
        return this.genEmptyWrapper(noResults);
      }

      return null;
    },
    genItems: function genItems(props) {
      var _this9 = this;

      var empty = this.genEmpty(props.pagination.itemsLength);
      if (empty) return [empty];

      if (this.$scopedSlots.default) {
        return this.$scopedSlots.default(_objectSpread({}, props, {
          isSelected: this.isSelected,
          select: this.select,
          isExpanded: this.isExpanded,
          expand: this.expand
        }));
      }

      if (this.$scopedSlots.item) {
        return props.items.map(function (item) {
          return _this9.$scopedSlots.item(_this9.createItemProps(item));
        });
      }

      return [];
    },
    genFooter: function genFooter(props) {
      if (this.hideDefaultFooter) return null;
      var data = {
        props: _objectSpread({}, this.footerProps, {
          options: props.options,
          pagination: props.pagination
        }),
        on: {
          'update:options': function updateOptions(value) {
            return props.updateOptions(value);
          }
        }
      };
      var scopedSlots = (0, _helpers.getPrefixedScopedSlots)('footer.', this.$scopedSlots);
      return this.$createElement(_VDataFooter.default, _objectSpread({
        scopedSlots: scopedSlots
      }, data));
    },
    genDefaultScopedSlot: function genDefaultScopedSlot(props) {
      var outerProps = _objectSpread({}, props, {
        someItems: this.someItems,
        everyItem: this.everyItem,
        toggleSelectAll: this.toggleSelectAll
      });

      return this.$createElement('div', {
        staticClass: 'v-data-iterator'
      }, [(0, _helpers.getSlot)(this, 'header', outerProps, true), this.genItems(props), this.genFooter(props), (0, _helpers.getSlot)(this, 'footer', outerProps, true)]);
    }
  },
  render: function render() {
    var _this10 = this;

    return this.$createElement(_VData.VData, {
      props: this.$props,
      on: {
        'update:options': function updateOptions(v, old) {
          return !(0, _helpers.deepEqual)(v, old) && _this10.$emit('update:options', v);
        },
        'update:page': function updatePage(v) {
          return _this10.$emit('update:page', v);
        },
        'update:items-per-page': function updateItemsPerPage(v) {
          return _this10.$emit('update:items-per-page', v);
        },
        'update:sort-by': function updateSortBy(v) {
          return _this10.$emit('update:sort-by', v);
        },
        'update:sort-desc': function updateSortDesc(v) {
          return _this10.$emit('update:sort-desc', v);
        },
        'update:group-by': function updateGroupBy(v) {
          return _this10.$emit('update:group-by', v);
        },
        'update:group-desc': function updateGroupDesc(v) {
          return _this10.$emit('update:group-desc', v);
        },
        pagination: function pagination(v, old) {
          return !(0, _helpers.deepEqual)(v, old) && _this10.$emit('pagination', v);
        },
        'current-items': function currentItems(v) {
          _this10.internalCurrentItems = v;

          _this10.$emit('current-items', v);
        }
      },
      scopedSlots: {
        default: this.genDefaultScopedSlot
      }
    });
  }
});

exports.default = _default2;
//# sourceMappingURL=VDataIterator.js.map