|
1 | 1 | /*!
|
2 |
| - * vue-virtual-draglist v3.3.7 |
| 2 | + * vue-virtual-draglist v3.3.8 |
3 | 3 | * open source under the MIT license
|
4 | 4 | * https://github.com/mfuu/vue3-virtual-drag-list#readme
|
5 | 5 | */
|
|
911 | 911 | _classCallCheck(this, Sortable);
|
912 | 912 | this.el = el;
|
913 | 913 | this.options = options;
|
914 |
| - this.reRendered = false; |
| 914 | + this.rangeChanged = false; |
915 | 915 | this.installSortable();
|
916 | 916 | }
|
917 | 917 | return _createClass(Sortable, [{
|
918 | 918 | key: "destroy",
|
919 | 919 | value: function destroy() {
|
920 | 920 | this.sortable.destroy();
|
921 |
| - this.reRendered = false; |
| 921 | + this.rangeChanged = false; |
922 | 922 | }
|
923 | 923 | }, {
|
924 | 924 | key: "option",
|
|
1011 | 1011 | this.handleDropEvent(event, params, index);
|
1012 | 1012 | }
|
1013 | 1013 | this.dispatchEvent('onDrop', params);
|
1014 |
| - if (event.from === this.el && this.reRendered) { |
| 1014 | + if (event.from === this.el && this.rangeChanged) { |
1015 | 1015 | (_b = Dnd.dragged) === null || _b === void 0 ? void 0 : _b.remove();
|
1016 | 1016 | }
|
1017 | 1017 | if (event.from !== event.to) {
|
1018 | 1018 | (_c = Dnd.clone) === null || _c === void 0 ? void 0 : _c.remove();
|
1019 | 1019 | }
|
1020 |
| - this.reRendered = false; |
| 1020 | + this.rangeChanged = false; |
1021 | 1021 | }
|
1022 | 1022 | }, {
|
1023 | 1023 | key: "handleDropEvent",
|
|
1110 | 1110 | start: 0,
|
1111 | 1111 | end: 0,
|
1112 | 1112 | front: 0,
|
1113 |
| - behind: 0, |
1114 |
| - total: 0 |
| 1113 | + behind: 0 |
1115 | 1114 | };
|
1116 | 1115 | this.offset = 0;
|
1117 | 1116 | this.direction = 'STATIONARY';
|
|
1278 | 1277 | eventFn(scroller, 'touchmove', this.preventDefault);
|
1279 | 1278 | eventFn(scroller, 'keydown', this.preventDefaultForKeyDown);
|
1280 | 1279 | }
|
1281 |
| - // ========================================= Properties ========================================= |
1282 | 1280 | }, {
|
1283 | 1281 | key: "preventDefault",
|
1284 | 1282 | value: function preventDefault(e) {
|
|
1423 | 1421 | this.range.end = this.getEndByStart(start);
|
1424 | 1422 | this.range.front = this.getFrontOffset();
|
1425 | 1423 | this.range.behind = this.getBehindOffset();
|
1426 |
| - this.range.total = this.getTotalOffset(); |
1427 | 1424 | this.options.onUpdate(Object.assign({}, this.range));
|
1428 | 1425 | }
|
1429 |
| - }, { |
1430 |
| - key: "getTotalOffset", |
1431 |
| - value: function getTotalOffset() { |
1432 |
| - var offset = this.range.front + this.range.behind; |
1433 |
| - offset += this.getOffsetByRange(this.range.start, this.range.end + 1); |
1434 |
| - return offset; |
1435 |
| - } |
1436 | 1426 | }, {
|
1437 | 1427 | key: "getFrontOffset",
|
1438 | 1428 | value: function getFrontOffset() {
|
|
1504 | 1494 | }();
|
1505 | 1495 |
|
1506 | 1496 | var VirtualProps = {
|
1507 |
| - dataSource: {}, |
1508 | 1497 | modelValue: {},
|
1509 | 1498 | dataKey: {
|
1510 | 1499 | type: String,
|
|
1528 | 1517 | "default": true
|
1529 | 1518 | },
|
1530 | 1519 | handle: {
|
1531 |
| - type: [Function, String] |
| 1520 | + type: [Function, String], |
| 1521 | + "default": undefined |
1532 | 1522 | },
|
1533 | 1523 | group: {
|
1534 |
| - type: [Object, String] |
| 1524 | + type: [Object, String], |
| 1525 | + "default": undefined |
1535 | 1526 | },
|
1536 | 1527 | scroller: {
|
1537 |
| - type: [Document, HTMLElement] |
| 1528 | + type: [Document, HTMLElement], |
| 1529 | + "default": undefined |
1538 | 1530 | },
|
1539 | 1531 | lockAxis: {
|
1540 | 1532 | type: String,
|
|
1549 | 1541 | "default": 30
|
1550 | 1542 | },
|
1551 | 1543 | size: {
|
1552 |
| - type: Number |
| 1544 | + type: Number, |
| 1545 | + "default": undefined |
1553 | 1546 | },
|
1554 | 1547 | debounceTime: {
|
1555 | 1548 | type: Number,
|
|
1639 | 1632 | };
|
1640 | 1633 | var ItemProps = {
|
1641 | 1634 | dataKey: {
|
1642 |
| - type: [String, Number] |
| 1635 | + type: [String, Number], |
| 1636 | + "default": undefined |
1643 | 1637 | },
|
1644 | 1638 | sizeKey: {
|
1645 | 1639 | type: String,
|
1646 | 1640 | "default": 'offsetHeight'
|
1647 | 1641 | },
|
1648 | 1642 | itemClass: {
|
1649 |
| - type: String |
| 1643 | + type: String, |
| 1644 | + "default": undefined |
1650 | 1645 | }
|
1651 | 1646 | };
|
1652 | 1647 |
|
|
1730 | 1725 | };
|
1731 | 1726 | var VirtualList = vue.defineComponent({
|
1732 | 1727 | props: VirtualProps,
|
1733 |
| - emits: ['update:dataSource', 'update:modelValue', 'top', 'bottom', 'drag', 'drop', 'rangeChange'], |
| 1728 | + emits: ['update:modelValue', 'top', 'bottom', 'drag', 'drop', 'rangeChange'], |
1734 | 1729 | setup: function setup(props, _ref) {
|
1735 | 1730 | var emit = _ref.emit,
|
1736 | 1731 | slots = _ref.slots,
|
1737 | 1732 | expose = _ref.expose;
|
| 1733 | + var list = vue.ref([]); |
1738 | 1734 | var range = vue.ref({
|
1739 | 1735 | start: 0,
|
1740 | 1736 | end: props.keeps - 1,
|
1741 | 1737 | front: 0,
|
1742 |
| - behind: 0, |
1743 |
| - total: 0 |
| 1738 | + behind: 0 |
1744 | 1739 | });
|
1745 | 1740 | var horizontal = vue.computed(function () {
|
1746 | 1741 | return props.direction !== 'vertical';
|
1747 | 1742 | });
|
1748 |
| - var rootRef = vue.ref(null); |
1749 |
| - var wrapRef = vue.ref(null); |
1750 |
| - var listRef = vue.ref([]); |
| 1743 | + var rootRef = vue.ref(); |
| 1744 | + var wrapRef = vue.ref(); |
1751 | 1745 | function getSize(key) {
|
1752 | 1746 | return virtual.getSize(key);
|
1753 | 1747 | }
|
|
1791 | 1785 | });
|
1792 | 1786 | // ========================================== model change ==========================================
|
1793 | 1787 | vue.watch(function () {
|
1794 |
| - return [props.dataSource, props.modelValue]; |
| 1788 | + return [props.modelValue]; |
1795 | 1789 | }, function () {
|
1796 | 1790 | onModelUpdate();
|
1797 | 1791 | }, {
|
|
1820 | 1814 | var uniqueKeys = [];
|
1821 | 1815 | var topLoadLength = 0;
|
1822 | 1816 | var onModelUpdate = function onModelUpdate() {
|
1823 |
| - var list = getList(props.modelValue || props.dataSource); |
1824 |
| - if (!list) return; |
1825 |
| - listRef.value = list; |
| 1817 | + var data = getList(props.modelValue); |
| 1818 | + if (!data) return; |
| 1819 | + list.value = data; |
1826 | 1820 | updateUniqueKeys();
|
1827 |
| - updateRange(lastList, list); |
1828 |
| - sortable === null || sortable === void 0 ? void 0 : sortable.option('list', list); |
| 1821 | + updateRange(lastList, data); |
| 1822 | + sortable === null || sortable === void 0 ? void 0 : sortable.option('list', data); |
1829 | 1823 | // if auto scroll to the last offset
|
1830 | 1824 | if (topLoadLength && props.keepOffset) {
|
1831 |
| - var index = list.length - topLoadLength; |
| 1825 | + var index = data.length - topLoadLength; |
1832 | 1826 | if (index > 0) {
|
1833 | 1827 | scrollToIndex(index);
|
1834 | 1828 | }
|
1835 | 1829 | topLoadLength = 0;
|
1836 | 1830 | }
|
1837 |
| - lastList = _toConsumableArray(listRef.value); |
| 1831 | + lastList = _toConsumableArray(list.value); |
1838 | 1832 | };
|
1839 | 1833 | var updateUniqueKeys = function updateUniqueKeys() {
|
1840 |
| - uniqueKeys = listRef.value.map(function (item) { |
| 1834 | + uniqueKeys = list.value.map(function (item) { |
1841 | 1835 | return getDataKey(item, props.dataKey);
|
1842 | 1836 | });
|
1843 | 1837 | virtual === null || virtual === void 0 ? void 0 : virtual.option('uniqueKeys', uniqueKeys);
|
|
1850 | 1844 | if (oldList.length === newList.length) {
|
1851 | 1845 | return;
|
1852 | 1846 | }
|
1853 |
| - var _range = Object.assign({}, range.value); |
1854 |
| - if (newList.length > oldList.length && _range.end === oldList.length - 1 && scrolledToBottom()) { |
1855 |
| - _range.start++; |
| 1847 | + var newRange = Object.assign({}, range.value); |
| 1848 | + if (oldList.length > props.keeps && newList.length > oldList.length && newRange.end === oldList.length - 1 && scrolledToBottom()) { |
| 1849 | + newRange.start++; |
1856 | 1850 | }
|
1857 |
| - virtual === null || virtual === void 0 ? void 0 : virtual.updateRange(_range); |
| 1851 | + virtual === null || virtual === void 0 ? void 0 : virtual.updateRange(newRange); |
1858 | 1852 | };
|
1859 | 1853 | var scrolledToBottom = function scrolledToBottom() {
|
1860 | 1854 | var offset = getOffset();
|
|
1881 | 1875 | }
|
1882 | 1876 | });
|
1883 | 1877 | var handleToTop = throttle(function () {
|
1884 |
| - topLoadLength = listRef.value.length; |
| 1878 | + topLoadLength = list.value.length; |
1885 | 1879 | emit('top');
|
1886 | 1880 | }, 50);
|
1887 | 1881 | var handleToBottom = throttle(function () {
|
1888 | 1882 | emit('bottom');
|
1889 | 1883 | }, 50);
|
1890 | 1884 | var onScroll = function onScroll(event) {
|
1891 | 1885 | topLoadLength = 0;
|
1892 |
| - if (!!listRef.value.length && event.top) { |
| 1886 | + if (!!list.value.length && event.top) { |
1893 | 1887 | handleToTop();
|
1894 | 1888 | } else if (event.bottom) {
|
1895 | 1889 | handleToBottom();
|
1896 | 1890 | }
|
1897 | 1891 | };
|
1898 | 1892 | var onUpdate = function onUpdate(newRange) {
|
1899 | 1893 | var rangeChanged = newRange.start !== range.value.start;
|
1900 |
| - if (dragging.value && rangeChanged) { |
1901 |
| - sortable && (sortable.reRendered = true); |
| 1894 | + if (dragging.value && rangeChanged && sortable) { |
| 1895 | + sortable.rangeChanged = true; |
1902 | 1896 | }
|
1903 | 1897 | range.value = newRange;
|
1904 | 1898 | rangeChanged && emit('rangeChange', newRange);
|
|
1919 | 1913 | return;
|
1920 | 1914 | }
|
1921 | 1915 | var sizes = virtual.sizes.size;
|
1922 |
| - var renders = Math.min(props.keeps, listRef.value.length); |
| 1916 | + var renders = Math.min(props.keeps, list.value.length); |
1923 | 1917 | virtual.onItemResized(key, size);
|
1924 | 1918 | if (sizes === renders - 1) {
|
1925 | 1919 | virtual.updateRange(range.value);
|
|
1960 | 1954 | virtual.enableScroll(true);
|
1961 | 1955 | sortable.option('autoScroll', props.autoScroll);
|
1962 | 1956 | if (event.changed) {
|
1963 |
| - emit('update:dataSource', event.list); |
1964 | 1957 | emit('update:modelValue', event.list);
|
1965 | 1958 | }
|
1966 | 1959 | emit('drop', event);
|
1967 | 1960 | };
|
1968 | 1961 | var installSortable = function installSortable() {
|
1969 | 1962 | sortable = new Sortable(rootRef.value, Object.assign(Object.assign({}, sortableAttributes.value), {
|
1970 |
| - list: listRef.value, |
| 1963 | + list: list.value, |
1971 | 1964 | uniqueKeys: uniqueKeys,
|
1972 | 1965 | onDrag: onDrag,
|
1973 | 1966 | onDrop: onDrop,
|
|
1999 | 1992 | var sizeKey = horizontal.value ? 'offsetWidth' : 'offsetHeight';
|
2000 | 1993 | renders.push(renderSpacer(front));
|
2001 | 1994 | var _loop = function _loop(index) {
|
2002 |
| - var record = listRef.value[index]; |
| 1995 | + var record = list.value[index]; |
2003 | 1996 | if (record) {
|
2004 | 1997 | var dataKey = getDataKey(record, props.dataKey);
|
2005 | 1998 | var isChosen = isSameValue(dataKey, chosenKey.value);
|
|
0 commit comments