|
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