add file

node_modules/vuetify/es5/components/VDataIterator/VDataFooter.js

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VDataIterator/VDataFooter.sass");
+
+var _VSelect = _interopRequireDefault(require("../VSelect/VSelect"));
+
+var _VIcon = _interopRequireDefault(require("../VIcon"));
+
+var _VBtn = _interopRequireDefault(require("../VBtn"));
+
+var _vue = _interopRequireDefault(require("vue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var _default2 = _vue.default.extend({
+  name: 'v-data-footer',
+  props: {
+    options: {
+      type: Object,
+      required: true
+    },
+    pagination: {
+      type: Object,
+      required: true
+    },
+    itemsPerPageOptions: {
+      type: Array,
+      default: function _default() {
+        return [5, 10, 15, -1];
+      }
+    },
+    prevIcon: {
+      type: String,
+      default: '$prev'
+    },
+    nextIcon: {
+      type: String,
+      default: '$next'
+    },
+    firstIcon: {
+      type: String,
+      default: '$first'
+    },
+    lastIcon: {
+      type: String,
+      default: '$last'
+    },
+    itemsPerPageText: {
+      type: String,
+      default: '$vuetify.dataFooter.itemsPerPageText'
+    },
+    itemsPerPageAllText: {
+      type: String,
+      default: '$vuetify.dataFooter.itemsPerPageAll'
+    },
+    showFirstLastPage: Boolean,
+    showCurrentPage: Boolean,
+    disablePagination: Boolean,
+    disableItemsPerPage: Boolean,
+    pageText: {
+      type: String,
+      default: '$vuetify.dataFooter.pageText'
+    }
+  },
+  computed: {
+    disableNextPageIcon: function disableNextPageIcon() {
+      return this.options.itemsPerPage <= 0 || this.options.page * this.options.itemsPerPage >= this.pagination.itemsLength || this.pagination.pageStop < 0;
+    },
+    computedDataItemsPerPageOptions: function computedDataItemsPerPageOptions() {
+      var _this = this;
+
+      return this.itemsPerPageOptions.map(function (option) {
+        if (_typeof(option) === 'object') return option;else return _this.genDataItemsPerPageOption(option);
+      });
+    }
+  },
+  methods: {
+    updateOptions: function updateOptions(obj) {
+      this.$emit('update:options', Object.assign({}, this.options, obj));
+    },
+    onFirstPage: function onFirstPage() {
+      this.updateOptions({
+        page: 1
+      });
+    },
+    onPreviousPage: function onPreviousPage() {
+      this.updateOptions({
+        page: this.options.page - 1
+      });
+    },
+    onNextPage: function onNextPage() {
+      this.updateOptions({
+        page: this.options.page + 1
+      });
+    },
+    onLastPage: function onLastPage() {
+      this.updateOptions({
+        page: this.pagination.pageCount
+      });
+    },
+    onChangeItemsPerPage: function onChangeItemsPerPage(itemsPerPage) {
+      this.updateOptions({
+        itemsPerPage: itemsPerPage,
+        page: 1
+      });
+    },
+    genDataItemsPerPageOption: function genDataItemsPerPageOption(option) {
+      return {
+        text: option === -1 ? this.$vuetify.lang.t(this.itemsPerPageAllText) : String(option),
+        value: option
+      };
+    },
+    genItemsPerPageSelect: function genItemsPerPageSelect() {
+      var value = this.options.itemsPerPage;
+      var computedIPPO = this.computedDataItemsPerPageOptions;
+      if (computedIPPO.length <= 1) return null;
+      if (!computedIPPO.find(function (ippo) {
+        return ippo.value === value;
+      })) value = computedIPPO[0];
+      return this.$createElement('div', {
+        staticClass: 'v-data-footer__select'
+      }, [this.$vuetify.lang.t(this.itemsPerPageText), this.$createElement(_VSelect.default, {
+        attrs: {
+          'aria-label': this.itemsPerPageText
+        },
+        props: {
+          disabled: this.disableItemsPerPage,
+          items: computedIPPO,
+          value: value,
+          hideDetails: true,
+          auto: true,
+          minWidth: '75px'
+        },
+        on: {
+          input: this.onChangeItemsPerPage
+        }
+      })]);
+    },
+    genPaginationInfo: function genPaginationInfo() {
+      var children = ['–'];
+
+      if (this.pagination.itemsLength && this.pagination.itemsPerPage) {
+        var itemsLength = this.pagination.itemsLength;
+        var pageStart = this.pagination.pageStart + 1;
+        var pageStop = itemsLength < this.pagination.pageStop || this.pagination.pageStop < 0 ? itemsLength : this.pagination.pageStop;
+        children = this.$scopedSlots['page-text'] ? [this.$scopedSlots['page-text']({
+          pageStart: pageStart,
+          pageStop: pageStop,
+          itemsLength: itemsLength
+        })] : [this.$vuetify.lang.t(this.pageText, pageStart, pageStop, itemsLength)];
+      }
+
+      return this.$createElement('div', {
+        class: 'v-data-footer__pagination'
+      }, children);
+    },
+    genIcon: function genIcon(click, disabled, label, icon) {
+      return this.$createElement(_VBtn.default, {
+        props: {
+          disabled: disabled || this.disablePagination,
+          icon: true,
+          text: true
+        },
+        on: {
+          click: click
+        },
+        attrs: {
+          'aria-label': label
+        }
+      }, [this.$createElement(_VIcon.default, icon)]);
+    },
+    genIcons: function genIcons() {
+      var before = [];
+      var after = [];
+      before.push(this.genIcon(this.onPreviousPage, this.options.page === 1, this.$vuetify.lang.t('$vuetify.dataFooter.prevPage'), this.$vuetify.rtl ? this.nextIcon : this.prevIcon));
+      after.push(this.genIcon(this.onNextPage, this.disableNextPageIcon, this.$vuetify.lang.t('$vuetify.dataFooter.nextPage'), this.$vuetify.rtl ? this.prevIcon : this.nextIcon));
+
+      if (this.showFirstLastPage) {
+        before.unshift(this.genIcon(this.onFirstPage, this.options.page === 1, this.$vuetify.lang.t('$vuetify.dataFooter.firstPage'), this.$vuetify.rtl ? this.lastIcon : this.firstIcon));
+        after.push(this.genIcon(this.onLastPage, this.options.page >= this.pagination.pageCount || this.options.itemsPerPage === -1, this.$vuetify.lang.t('$vuetify.dataFooter.lastPage'), this.$vuetify.rtl ? this.firstIcon : this.lastIcon));
+      }
+
+      return [this.$createElement('div', {
+        staticClass: 'v-data-footer__icons-before'
+      }, before), this.showCurrentPage && this.$createElement('span', [this.options.page.toString()]), this.$createElement('div', {
+        staticClass: 'v-data-footer__icons-after'
+      }, after)];
+    }
+  },
+  render: function render() {
+    return this.$createElement('div', {
+      staticClass: 'v-data-footer'
+    }, [this.genItemsPerPageSelect(), this.genPaginationInfo(), this.genIcons()]);
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=VDataFooter.js.map

node_modules/vuetify/es5/components/VDataIterator/VDataIterator.js

@@ -0,0 +1,369 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _VData = require("../VData");
+
+var _VDataFooter = _interopRequireDefault(require("./VDataFooter"));
+
+var _mobile = _interopRequireDefault(require("../../mixins/mobile"));
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+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 = (0, _mixins.default)(_mobile.default, _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 [];
+      }
+    },
+    mobileBreakpoint: _objectSpread({}, _mobile.default.options.props.mobileBreakpoint, {
+      default: 600
+    }),
+    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,
+    selectableKey: {
+      type: String,
+      default: 'isSelectable'
+    }
+  }),
+  data: function data() {
+    return {
+      selection: {},
+      expansion: {},
+      internalCurrentItems: []
+    };
+  },
+  computed: {
+    everyItem: function everyItem() {
+      var _this = this;
+
+      return !!this.selectableItems.length && this.selectableItems.every(function (i) {
+        return _this.isSelected(i);
+      });
+    },
+    someItems: function someItems() {
+      var _this2 = this;
+
+      return this.selectableItems.some(function (i) {
+        return _this2.isSelected(i);
+      });
+    },
+    sanitizedFooterProps: function sanitizedFooterProps() {
+      return (0, _helpers.camelizeObjectKeys)(this.footerProps);
+    },
+    selectableItems: function selectableItems() {
+      var _this3 = this;
+
+      return this.internalCurrentItems.filter(function (item) {
+        return _this3.isSelectable(item);
+      });
+    }
+  },
+  watch: {
+    value: {
+      handler: function handler(value) {
+        var _this4 = this;
+
+        this.selection = value.reduce(function (selection, item) {
+          selection[(0, _helpers.getObjectValueByPath)(item, _this4.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 _this5 = this;
+
+        this.expansion = value.reduce(function (expansion, item) {
+          expansion[(0, _helpers.getObjectValueByPath)(item, _this5.itemKey)] = true;
+          return expansion;
+        }, {});
+      },
+      immediate: true
+    },
+    expansion: function expansion(value, old) {
+      var _this6 = 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, _this6.itemKey)));
+      });
+      this.$emit('update:expanded', expanded);
+    }
+  },
+  created: function created() {
+    var _this7 = 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 (_this7.$attrs.hasOwnProperty(original)) (0, _console.breaking)(original, replacement, _this7);
+    });
+    var removedProps = ['expand', 'content-class', 'content-props', 'content-tag'];
+    /* istanbul ignore next */
+
+    removedProps.forEach(function (prop) {
+      if (_this7.$attrs.hasOwnProperty(prop)) (0, _console.removed)(prop);
+    });
+  },
+  methods: {
+    toggleSelectAll: function toggleSelectAll(value) {
+      var selection = Object.assign({}, this.selection);
+
+      for (var i = 0; i < this.selectableItems.length; i++) {
+        var item = this.selectableItems[i];
+        if (!this.isSelectable(item)) continue;
+        var key = (0, _helpers.getObjectValueByPath)(item, this.itemKey);
+        if (value) selection[key] = item;else delete selection[key];
+      }
+
+      this.selection = selection;
+      this.$emit('toggle-select-all', {
+        items: this.internalCurrentItems,
+        value: value
+      });
+    },
+    isSelectable: function isSelectable(item) {
+      return (0, _helpers.getObjectValueByPath)(item, this.selectableKey) !== false;
+    },
+    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;
+      if (!this.isSelectable(item)) return;
+      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];
+
+      if (this.singleSelect && emit) {
+        var keys = Object.keys(this.selection);
+        var old = keys.length && (0, _helpers.getObjectValueByPath)(this.selection[keys[0]], this.itemKey);
+        old && old !== key && this.$emit('item-selected', {
+          item: this.selection[old],
+          value: false
+        });
+      }
+
+      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;
+
+      return {
+        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),
+        isMobile: this.isMobile
+      };
+    },
+    genEmptyWrapper: function genEmptyWrapper(content) {
+      return this.$createElement('div', content);
+    },
+    genEmpty: function genEmpty(originalItemsLength, filteredItemsLength) {
+      if (originalItemsLength === 0 && this.loading) {
+        var loading = this.$slots['loading'] || this.$vuetify.lang.t(this.loadingText);
+        return this.genEmptyWrapper(loading);
+      } else if (originalItemsLength === 0) {
+        var noData = this.$slots['no-data'] || this.$vuetify.lang.t(this.noDataText);
+        return this.genEmptyWrapper(noData);
+      } else if (filteredItemsLength === 0) {
+        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.originalItemsLength, 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.sanitizedFooterProps, {
+          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);
+        },
+        'page-count': function pageCount(v) {
+          return _this10.$emit('page-count', v);
+        }
+      },
+      scopedSlots: {
+        default: this.genDefaultScopedSlot
+      }
+    });
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=VDataIterator.js.map

node_modules/vuetify/es5/components/VDataIterator/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VDataIterator", {
+  enumerable: true,
+  get: function get() {
+    return _VDataIterator.default;
+  }
+});
+Object.defineProperty(exports, "VDataFooter", {
+  enumerable: true,
+  get: function get() {
+    return _VDataFooter.default;
+  }
+});
+exports.default = void 0;
+
+var _VDataIterator = _interopRequireDefault(require("./VDataIterator"));
+
+var _VDataFooter = _interopRequireDefault(require("./VDataFooter"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = {
+  $_vuetify_subcomponents: {
+    VDataIterator: _VDataIterator.default,
+    VDataFooter: _VDataFooter.default
+  }
+};
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VDataIterator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VDataIterator/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;;AACA;;;;eAGe;AACb,EAAA,uBAAuB,EAAE;AACvB,IAAA,aAAa,EAAb,sBADuB;AAEvB,IAAA,WAAW,EAAX;AAFuB;AADZ,C","sourcesContent":["import VDataIterator from './VDataIterator'\nimport VDataFooter from './VDataFooter'\n\nexport { VDataIterator, VDataFooter }\nexport default {\n  $_vuetify_subcomponents: {\n    VDataIterator,\n    VDataFooter,\n  },\n}\n"],"sourceRoot":"","file":"index.js"}