252 lines
7.9 KiB
JavaScript
252 lines
7.9 KiB
JavaScript
import { mergeProps as _mergeProps, createVNode as _createVNode, createElementVNode as _createElementVNode } from "vue";
|
|
// Components
|
|
import { makeDataTableProps } from "./VDataTable.js";
|
|
import { VDataTableHeaders } from "./VDataTableHeaders.js";
|
|
import { VDataTableRow } from "./VDataTableRow.js";
|
|
import { VDataTableRows } from "./VDataTableRows.js";
|
|
import { VTable } from "../VTable/index.js";
|
|
import { VVirtualScrollItem } from "../VVirtualScroll/VVirtualScrollItem.js"; // Composables
|
|
import { provideExpanded } from "./composables/expand.js";
|
|
import { createGroupBy, makeDataTableGroupProps, provideGroupBy, useGroupedItems } from "./composables/group.js";
|
|
import { createHeaders } from "./composables/headers.js";
|
|
import { useDataTableItems } from "./composables/items.js";
|
|
import { useOptions } from "./composables/options.js";
|
|
import { provideSelection } from "./composables/select.js";
|
|
import { createSort, provideSort, useSortedItems } from "./composables/sort.js";
|
|
import { provideDefaults } from "../../composables/defaults.js";
|
|
import { makeFilterProps, useFilter } from "../../composables/filter.js";
|
|
import { makeVirtualProps, useVirtual } from "../../composables/virtual.js"; // Utilities
|
|
import { computed, shallowRef, toRef, toRefs } from 'vue';
|
|
import { convertToUnit, genericComponent, omit, propsFactory, useRender } from "../../util/index.js"; // Types
|
|
export const makeVDataTableVirtualProps = propsFactory({
|
|
...omit(makeDataTableProps(), ['hideDefaultFooter']),
|
|
...makeDataTableGroupProps(),
|
|
...makeVirtualProps(),
|
|
...makeFilterProps()
|
|
}, 'VDataTableVirtual');
|
|
export const VDataTableVirtual = genericComponent()({
|
|
name: 'VDataTableVirtual',
|
|
props: makeVDataTableVirtualProps(),
|
|
emits: {
|
|
'update:modelValue': value => true,
|
|
'update:sortBy': value => true,
|
|
'update:options': value => true,
|
|
'update:groupBy': value => true,
|
|
'update:expanded': value => true
|
|
},
|
|
setup(props, {
|
|
attrs,
|
|
slots
|
|
}) {
|
|
const {
|
|
groupBy
|
|
} = createGroupBy(props);
|
|
const {
|
|
initialSortOrder,
|
|
sortBy,
|
|
multiSort,
|
|
mustSort
|
|
} = createSort(props);
|
|
const {
|
|
disableSort
|
|
} = toRefs(props);
|
|
const {
|
|
columns,
|
|
headers,
|
|
filterFunctions,
|
|
sortFunctions,
|
|
sortRawFunctions
|
|
} = createHeaders(props, {
|
|
groupBy,
|
|
showSelect: toRef(() => props.showSelect),
|
|
showExpand: toRef(() => props.showExpand)
|
|
});
|
|
const {
|
|
items
|
|
} = useDataTableItems(props, columns);
|
|
const search = toRef(() => props.search);
|
|
const {
|
|
filteredItems
|
|
} = useFilter(props, items, search, {
|
|
transform: item => item.columns,
|
|
customKeyFilter: filterFunctions
|
|
});
|
|
const {
|
|
toggleSort
|
|
} = provideSort({
|
|
initialSortOrder,
|
|
sortBy,
|
|
multiSort,
|
|
mustSort
|
|
});
|
|
const {
|
|
sortByWithGroups,
|
|
opened,
|
|
extractRows,
|
|
isGroupOpen,
|
|
toggleGroup
|
|
} = provideGroupBy({
|
|
groupBy,
|
|
sortBy,
|
|
disableSort
|
|
});
|
|
const {
|
|
sortedItems
|
|
} = useSortedItems(props, filteredItems, sortByWithGroups, {
|
|
transform: item => ({
|
|
...item.raw,
|
|
...item.columns
|
|
}),
|
|
sortFunctions,
|
|
sortRawFunctions
|
|
});
|
|
const {
|
|
flatItems
|
|
} = useGroupedItems(sortedItems, groupBy, opened, () => !!slots['group-summary']);
|
|
const allItems = computed(() => extractRows(flatItems.value));
|
|
const {
|
|
isSelected,
|
|
select,
|
|
selectAll,
|
|
toggleSelect,
|
|
someSelected,
|
|
allSelected
|
|
} = provideSelection(props, {
|
|
allItems,
|
|
currentPage: allItems
|
|
});
|
|
const {
|
|
isExpanded,
|
|
toggleExpand
|
|
} = provideExpanded(props);
|
|
const {
|
|
containerRef,
|
|
markerRef,
|
|
paddingTop,
|
|
paddingBottom,
|
|
computedItems,
|
|
handleItemResize,
|
|
handleScroll,
|
|
handleScrollend,
|
|
calculateVisibleItems,
|
|
scrollToIndex
|
|
} = useVirtual(props, flatItems);
|
|
const displayItems = computed(() => computedItems.value.map(item => ({
|
|
...item.raw,
|
|
virtualIndex: item.index
|
|
})));
|
|
useOptions({
|
|
sortBy,
|
|
page: shallowRef(1),
|
|
itemsPerPage: shallowRef(-1),
|
|
groupBy,
|
|
search
|
|
});
|
|
provideDefaults({
|
|
VDataTableRows: {
|
|
hideNoData: toRef(() => props.hideNoData),
|
|
noDataText: toRef(() => props.noDataText),
|
|
loading: toRef(() => props.loading),
|
|
loadingText: toRef(() => props.loadingText)
|
|
}
|
|
});
|
|
const slotProps = computed(() => ({
|
|
sortBy: sortBy.value,
|
|
toggleSort,
|
|
someSelected: someSelected.value,
|
|
allSelected: allSelected.value,
|
|
isSelected,
|
|
select,
|
|
selectAll,
|
|
toggleSelect,
|
|
isExpanded,
|
|
toggleExpand,
|
|
isGroupOpen,
|
|
toggleGroup,
|
|
items: allItems.value.map(item => item.raw),
|
|
internalItems: allItems.value,
|
|
groupedItems: flatItems.value,
|
|
columns: columns.value,
|
|
headers: headers.value
|
|
}));
|
|
useRender(() => {
|
|
const dataTableHeadersProps = VDataTableHeaders.filterProps(omit(props, ['multiSort']));
|
|
const dataTableRowsProps = VDataTableRows.filterProps(props);
|
|
const tableProps = VTable.filterProps(props);
|
|
return _createVNode(VTable, _mergeProps({
|
|
"class": ['v-data-table', {
|
|
'v-data-table--loading': props.loading
|
|
}, props.class],
|
|
"style": props.style
|
|
}, tableProps, {
|
|
"fixedHeader": props.fixedHeader || props.sticky
|
|
}), {
|
|
top: () => slots.top?.(slotProps.value),
|
|
wrapper: () => _createElementVNode("div", {
|
|
"ref": containerRef,
|
|
"onScrollPassive": handleScroll,
|
|
"onScrollend": handleScrollend,
|
|
"class": "v-table__wrapper",
|
|
"style": {
|
|
height: convertToUnit(props.height)
|
|
}
|
|
}, [_createElementVNode("table", null, [slots.colgroup?.(slotProps.value), !props.hideDefaultHeader && _createElementVNode("thead", {
|
|
"key": "thead"
|
|
}, [_createVNode(VDataTableHeaders, _mergeProps(dataTableHeadersProps, {
|
|
"multiSort": !!props.multiSort
|
|
}), slots)]), slots.thead?.(slotProps.value), !props.hideDefaultBody && _createElementVNode("tbody", {
|
|
"key": "tbody"
|
|
}, [_createElementVNode("tr", {
|
|
"ref": markerRef,
|
|
"style": {
|
|
height: convertToUnit(paddingTop.value),
|
|
border: 0
|
|
}
|
|
}, [_createElementVNode("td", {
|
|
"colspan": columns.value.length,
|
|
"style": {
|
|
height: 0,
|
|
border: 0
|
|
}
|
|
}, null)]), slots['body.prepend']?.(slotProps.value), _createVNode(VDataTableRows, _mergeProps(attrs, dataTableRowsProps, {
|
|
"items": displayItems.value
|
|
}), {
|
|
...slots,
|
|
item: itemSlotProps => _createVNode(VVirtualScrollItem, {
|
|
"key": itemSlotProps.internalItem.index,
|
|
"renderless": true,
|
|
"onUpdate:height": height => handleItemResize(itemSlotProps.internalItem.index, height)
|
|
}, {
|
|
default: ({
|
|
itemRef
|
|
}) => slots.item?.({
|
|
...itemSlotProps,
|
|
itemRef
|
|
}) ?? _createVNode(VDataTableRow, _mergeProps(itemSlotProps.props, {
|
|
"ref": itemRef,
|
|
"key": itemSlotProps.internalItem.index,
|
|
"index": itemSlotProps.index
|
|
}), slots)
|
|
})
|
|
}), slots['body.append']?.(slotProps.value), _createElementVNode("tr", {
|
|
"style": {
|
|
height: convertToUnit(paddingBottom.value),
|
|
border: 0
|
|
}
|
|
}, [_createElementVNode("td", {
|
|
"colspan": columns.value.length,
|
|
"style": {
|
|
height: 0,
|
|
border: 0
|
|
}
|
|
}, null)])]), slots.tbody?.(slotProps.value), slots.tfoot?.(slotProps.value)])]),
|
|
bottom: () => slots.bottom?.(slotProps.value)
|
|
});
|
|
});
|
|
return {
|
|
calculateVisibleItems,
|
|
scrollToIndex
|
|
};
|
|
}
|
|
});
|
|
//# sourceMappingURL=VDataTableVirtual.js.map
|