devextreme
Version:
JavaScript/TypeScript Component Suite for Responsive Web Development
451 lines (448 loc) • 21.7 kB
JavaScript
/**
* DevExtreme (cjs/__internal/scheduler/workspaces/view_model/m_view_data_provider.js)
* Version: 25.2.7
* Build date: Tue May 05 2026
*
* Copyright (c) 2012 - 2026 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
*/
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _date = _interopRequireDefault(require("../../../../core/utils/date"));
var _date2 = require("../../../core/utils/date");
var _m_utils_time_zone = _interopRequireDefault(require("../../m_utils_time_zone"));
var _index = require("../../r1/utils/index");
var _m_date_header_data_generator = require("./m_date_header_data_generator");
var _m_grouped_data_map_provider = require("./m_grouped_data_map_provider");
var _m_time_panel_data_generator = require("./m_time_panel_data_generator");
var _view_provider_utils = require("./utils/view_provider_utils");
const _excluded = ["getResourceManager", "groupOrientation", "groupByDate", "isAllDayPanelVisible", "viewOffset"];
function _interopRequireDefault(e) {
return e && e.__esModule ? e : {
default: e
}
}
function _objectWithoutPropertiesLoose(r, e) {
if (null == r) {
return {}
}
var t = {};
for (var n in r) {
if ({}.hasOwnProperty.call(r, n)) {
if (-1 !== e.indexOf(n)) {
continue
}
t[n] = r[n]
}
}
return t
}
class ViewDataProvider {
constructor(viewType) {
this.viewType = viewType;
this.viewDataGenerator = (0, _view_provider_utils.getViewDataGeneratorByViewType)(viewType);
this.viewData = {};
this.completeViewDataMap = [];
this.completeDateHeaderMap = [];
this.viewDataMap = {
dateTableMap: [],
allDayPanelMap: []
};
this.groupedDataMapProvider = null
}
get groupedDataMap() {
return this.groupedDataMapProvider.groupedDataMap
}
get hiddenInterval() {
return this.viewDataGenerator.hiddenInterval
}
isSkippedDate(date) {
return this.viewDataGenerator.isSkippedDate(date)
}
update(options, isGenerateNewViewData) {
this.viewDataGenerator = (0, _view_provider_utils.getViewDataGeneratorByViewType)(options.viewType);
const {
viewDataGenerator: viewDataGenerator
} = this;
const dateHeaderDataGenerator = new _m_date_header_data_generator.DateHeaderDataGenerator(viewDataGenerator);
const timePanelDataGenerator = new _m_time_panel_data_generator.TimePanelDataGenerator(viewDataGenerator);
const renderOptions = this.transformRenderOptions(options);
this.options = renderOptions;
if (isGenerateNewViewData) {
this.completeViewDataMap = viewDataGenerator.getCompleteViewDataMap(renderOptions);
this.completeDateHeaderMap = dateHeaderDataGenerator.getCompleteDateHeaderMap(renderOptions, this.completeViewDataMap);
if (renderOptions.isGenerateTimePanelData) {
this.completeTimePanelMap = timePanelDataGenerator.getCompleteTimePanelMap(renderOptions, this.completeViewDataMap)
}
}
this.viewDataMap = viewDataGenerator.generateViewDataMap(this.completeViewDataMap, renderOptions);
this.updateViewData(renderOptions);
this.groupedDataMapProvider = new _m_grouped_data_map_provider.GroupedDataMapProvider(this.viewDataGenerator, this.viewDataMap, this.completeViewDataMap, {
isVerticalGrouping: renderOptions.isVerticalGrouping,
viewType: renderOptions.viewType,
viewOffset: options.viewOffset
});
this.dateHeaderData = dateHeaderDataGenerator.generateDateHeaderData(this.completeDateHeaderMap, this.completeViewDataMap, renderOptions);
if (renderOptions.isGenerateTimePanelData) {
this.timePanelData = timePanelDataGenerator.generateTimePanelData(this.completeTimePanelMap, renderOptions)
}
}
createGroupedDataMapProvider() {
this.groupedDataMapProvider = new _m_grouped_data_map_provider.GroupedDataMapProvider(this.viewDataGenerator, this.viewDataMap, this.completeViewDataMap, {
isVerticalGrouping: this.options.isVerticalGrouping,
viewType: this.options.viewType
})
}
updateViewData(options) {
const renderOptions = this.transformRenderOptions(options);
this.viewDataMapWithSelection = this.viewDataGenerator.markSelectedAndFocusedCells(this.viewDataMap, renderOptions);
this.viewData = this.viewDataGenerator.getViewDataFromMap(this.completeViewDataMap, this.viewDataMapWithSelection, renderOptions)
}
transformRenderOptions(renderOptions) {
const {
getResourceManager: getResourceManager,
groupOrientation: groupOrientation,
groupByDate: groupByDate,
isAllDayPanelVisible: isAllDayPanelVisible,
viewOffset: viewOffset
} = renderOptions, restOptions = _objectWithoutPropertiesLoose(renderOptions, _excluded);
const resourceManager = getResourceManager();
const groupCount = resourceManager.groupCount();
const interval = this.viewDataGenerator.getInterval(renderOptions.hoursInterval);
return Object.assign({}, restOptions, {
startViewDate: this.viewDataGenerator.getStartViewDate(renderOptions),
isVerticalGrouping: (0, _index.isVerticalGroupingApplied)(groupCount, groupOrientation),
isHorizontalGrouping: (0, _index.isHorizontalGroupingApplied)(groupCount, groupOrientation),
isGroupedByDate: (0, _index.isGroupingByDate)(groupCount, groupOrientation, groupByDate),
isGroupedAllDayPanel: (0, _index.calculateIsGroupedAllDayPanel)(groupCount, groupOrientation, isAllDayPanelVisible),
getResourceManager: getResourceManager,
groupOrientation: groupOrientation,
isAllDayPanelVisible: isAllDayPanelVisible,
viewOffset: viewOffset,
interval: interval
})
}
getGroupPanelData(options) {
const renderOptions = this.transformRenderOptions(options);
const groupResources = renderOptions.getResourceManager().groupResources();
if (groupResources.length > 0) {
const cellCount = this.getCellCount(renderOptions);
return (0, _index.getGroupPanelData)(groupResources, cellCount, renderOptions.isGroupedByDate, renderOptions.isGroupedByDate ? 1 : cellCount)
}
return
}
getGroupStartDate(groupIndex) {
return this.groupedDataMapProvider.getGroupStartDate(groupIndex)
}
getGroupEndDate(groupIndex) {
return this.groupedDataMapProvider.getGroupEndDate(groupIndex)
}
findGroupCellStartDate(groupIndex, startDate, endDate) {
let isFindByDate = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : false;
return this.groupedDataMapProvider.findGroupCellStartDate(groupIndex, startDate, endDate, isFindByDate)
}
findAllDayGroupCellStartDate(groupIndex) {
return this.groupedDataMapProvider.findAllDayGroupCellStartDate(groupIndex)
}
findCellPositionInMap(cellInfo) {
let isAppointmentRender = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : false;
return this.groupedDataMapProvider.findCellPositionInMap(cellInfo, isAppointmentRender)
}
getCellsGroup(groupIndex) {
return this.groupedDataMapProvider.getCellsGroup(groupIndex)
}
getCompletedGroupsInfo() {
return this.groupedDataMapProvider.getCompletedGroupsInfo()
}
getGroupIndices() {
return this.groupedDataMapProvider.getGroupIndices()
}
getLastGroupCellPosition(groupIndex) {
return this.groupedDataMapProvider.getLastGroupCellPosition(groupIndex)
}
getRowCountInGroup(groupIndex) {
return this.groupedDataMapProvider.getRowCountInGroup(groupIndex)
}
getCellData(rowIndex, columnIndex) {
let isAllDay = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : false;
let rtlEnabled = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : false;
const row = isAllDay && !this.options.isVerticalGrouping ? this.viewDataMap.allDayPanelMap : this.viewDataMap.dateTableMap[rowIndex];
const actualColumnIndex = !rtlEnabled ? columnIndex : row.length - 1 - columnIndex;
const {
cellData: cellData
} = row[actualColumnIndex];
return cellData
}
getCellsByGroupIndexAndAllDay(groupIndex, isAllDay) {
const rowsPerGroup = this.getRowCountWithAllDayRows();
const isShowAllDayPanel = this.options.isAllDayPanelVisible;
const firstRowInGroup = this.options.isVerticalGrouping ? groupIndex * rowsPerGroup : 0;
const lastRowInGroup = this.options.isVerticalGrouping ? (groupIndex + 1) * rowsPerGroup - 1 : rowsPerGroup;
const correctedFirstRow = isShowAllDayPanel && !isAllDay ? firstRowInGroup + 1 : firstRowInGroup;
const correctedLastRow = isAllDay ? correctedFirstRow : lastRowInGroup;
return this.completeViewDataMap.slice(correctedFirstRow, correctedLastRow + 1).map(row => row.filter(_ref => {
let {
groupIndex: currentGroupIndex
} = _ref;
return groupIndex === currentGroupIndex
}))
}
getCellCountWithGroup(groupIndex) {
let rowIndex = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
const {
dateTableGroupedMap: dateTableGroupedMap
} = this.groupedDataMap;
return dateTableGroupedMap.filter((_, index) => index <= groupIndex).reduce((previous, row) => previous + row[rowIndex].length, 0)
}
hasGroupAllDayPanel(groupIndex) {
var _this$groupedDataMap$2;
if (this.options.isVerticalGrouping) {
var _this$groupedDataMap$;
return Boolean(null === (_this$groupedDataMap$ = this.groupedDataMap.dateTableGroupedMap[groupIndex]) || void 0 === _this$groupedDataMap$ ? void 0 : _this$groupedDataMap$[0][0].cellData.allDay)
}
return (null === (_this$groupedDataMap$2 = this.groupedDataMap.allDayPanelGroupedMap[groupIndex]) || void 0 === _this$groupedDataMap$2 ? void 0 : _this$groupedDataMap$2.length) > 0
}
isGroupIntersectDateInterval(groupIndex, startDate, endDate) {
const groupStartDate = this.getGroupStartDate(groupIndex);
const groupEndDate = this.getGroupEndDate(groupIndex);
return startDate < groupEndDate && endDate > groupStartDate
}
findGlobalCellPosition(date) {
let groupIndex = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
let allDay = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : false;
let findClosest = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : false;
const {
completeViewDataMap: completeViewDataMap
} = this;
const showAllDayPanel = this.options.isAllDayPanelVisible;
let resultDiff = Number.MAX_VALUE;
let resultCellData;
let resultCellColumnIndex = -1;
let resultCellRowIndex = -1;
const getCellPosition = (columnIndex, rowIndex) => ({
columnIndex: columnIndex,
rowIndex: showAllDayPanel && !this.options.isVerticalGrouping ? rowIndex - 1 : rowIndex
});
for (let rowIndex = 0; rowIndex < completeViewDataMap.length; rowIndex += 1) {
const currentRow = completeViewDataMap[rowIndex];
for (let columnIndex = 0; columnIndex < currentRow.length; columnIndex += 1) {
const cellData = currentRow[columnIndex];
const {
startDate: cellStartDate,
endDate: cellEndDate,
groupIndex: cellGroupIndex,
allDay: cellAllDay
} = cellData;
if (groupIndex !== cellGroupIndex || allDay !== Boolean(cellAllDay)) {
continue
}
const isDateInCell = allDay ? _date.default.sameDate(date, cellStartDate) : date >= cellStartDate && date < cellEndDate;
if (isDateInCell) {
return {
position: getCellPosition(columnIndex, rowIndex),
cellData: cellData
}
}
const diff = Math.abs(date.getTime() - cellStartDate.getTime());
if (findClosest && diff < resultDiff) {
resultDiff = diff;
resultCellData = cellData;
resultCellColumnIndex = columnIndex;
resultCellRowIndex = rowIndex
}
}
}
return resultCellData ? {
position: getCellPosition(resultCellColumnIndex, resultCellRowIndex),
cellData: resultCellData
} : void 0
}
getSkippedDaysCount(groupIndex, startDate, endDate, daysCount) {
const {
dateTableGroupedMap: dateTableGroupedMap
} = this.groupedDataMapProvider.groupedDataMap;
const groupedData = dateTableGroupedMap[groupIndex];
let includedDays = 0;
for (let rowIndex = 0; rowIndex < groupedData.length; rowIndex += 1) {
for (let columnIndex = 0; columnIndex < groupedData[rowIndex].length; columnIndex += 1) {
const cell = groupedData[rowIndex][columnIndex].cellData;
if (startDate.getTime() < cell.endDate.getTime() && endDate.getTime() > cell.startDate.getTime()) {
includedDays += 1
}
}
}
const lastCell = groupedData[groupedData.length - 1][groupedData[0].length - 1].cellData;
const lastCellStart = _date.default.trimTime(lastCell.startDate);
const daysAfterView = Math.floor((endDate.getTime() - lastCellStart.getTime()) / _date.default.dateToMilliseconds("day"));
const deltaDays = daysAfterView > 0 ? daysAfterView : 0;
return daysCount - includedDays - deltaDays
}
getColumnsCount() {
const {
dateTableMap: dateTableMap
} = this.viewDataMap;
return dateTableMap ? dateTableMap[0].length : 0
}
getViewEdgeIndices(isAllDayPanel) {
if (isAllDayPanel) {
return {
firstColumnIndex: 0,
lastColumnIndex: this.viewDataMap.allDayPanelMap.length - 1,
firstRowIndex: 0,
lastRowIndex: 0
}
}
return {
firstColumnIndex: 0,
lastColumnIndex: this.viewDataMap.dateTableMap[0].length - 1,
firstRowIndex: 0,
lastRowIndex: this.viewDataMap.dateTableMap.length - 1
}
}
getGroupEdgeIndices(groupIndex, isAllDay) {
const groupedDataMap = this.groupedDataMap.dateTableGroupedMap[groupIndex];
const cellsCount = groupedDataMap[0].length;
const rowsCount = groupedDataMap.length;
const firstColumnIndex = groupedDataMap[0][0].position.columnIndex;
const lastColumnIndex = groupedDataMap[0][cellsCount - 1].position.columnIndex;
if (isAllDay) {
return {
firstColumnIndex: firstColumnIndex,
lastColumnIndex: lastColumnIndex,
firstRowIndex: 0,
lastRowIndex: 0
}
}
return {
firstColumnIndex: firstColumnIndex,
lastColumnIndex: lastColumnIndex,
firstRowIndex: groupedDataMap[0][0].position.rowIndex,
lastRowIndex: groupedDataMap[rowsCount - 1][0].position.rowIndex
}
}
isSameCell(firstCellData, secondCellData) {
const {
startDate: firstStartDate,
groupIndex: firstGroupIndex,
allDay: firstAllDay,
index: firstIndex
} = firstCellData;
const {
startDate: secondStartDate,
groupIndex: secondGroupIndex,
allDay: secondAllDay,
index: secondIndex
} = secondCellData;
return firstStartDate.getTime() === secondStartDate.getTime() && firstGroupIndex === secondGroupIndex && firstAllDay === secondAllDay && firstIndex === secondIndex
}
getLastViewDate() {
const {
completeViewDataMap: completeViewDataMap
} = this;
const rowsCount = completeViewDataMap.length - 1;
return completeViewDataMap[rowsCount][completeViewDataMap[rowsCount].length - 1].endDate
}
getStartViewDate() {
return this.options.startViewDate
}
getIntervalDuration(intervalCount) {
return this.viewDataGenerator._getIntervalDuration(intervalCount)
}
getLastCellEndDate() {
const lastEndDate = new Date(this.getLastViewDate().getTime() - _date.default.dateToMilliseconds("minute"));
return _date2.dateUtilsTs.addOffsets(lastEndDate, -this.options.viewOffset)
}
getLastViewDateByEndDayHour(endDayHour) {
const lastCellEndDate = this.getLastCellEndDate();
const endTime = _date.default.dateTimeFromDecimal(endDayHour);
const endDateOfLastViewCell = new Date(lastCellEndDate.setHours(endTime.hours, endTime.minutes));
return this.adjustEndDateByDaylightDiff(lastCellEndDate, endDateOfLastViewCell)
}
adjustEndDateByDaylightDiff(startDate, endDate) {
const daylightDiff = _m_utils_time_zone.default.getDaylightOffsetInMs(startDate, endDate);
const endDateOfLastViewCell = new Date(endDate.getTime() - daylightDiff);
return new Date(endDateOfLastViewCell.getTime() - _date.default.dateToMilliseconds("minute"))
}
getCellCountInDay(startDayHour, endDayHour, hoursInterval) {
return this.viewDataGenerator.getCellCountInDay(startDayHour, endDayHour, hoursInterval)
}
getCellCount(options) {
return this.viewDataGenerator.getCellCount(options)
}
getRowCount(options) {
return this.viewDataGenerator.getRowCount(options)
}
getVisibleDayDuration(startDayHour, endDayHour, hoursInterval) {
return this.viewDataGenerator.getVisibleDayDuration(startDayHour, endDayHour, hoursInterval)
}
getRowCountWithAllDayRows() {
const allDayRowCount = this.options.isAllDayPanelVisible ? 1 : 0;
return this.getRowCount(this.options) + allDayRowCount
}
getFirstDayOfWeek(firstDayOfWeekOption) {
return this.viewDataGenerator.getFirstDayOfWeek(firstDayOfWeekOption)
}
setViewOptions(options) {
this.options = this.transformRenderOptions(options)
}
getViewOptions() {
return this.options
}
getViewPortGroupCount() {
const {
dateTableGroupedMap: dateTableGroupedMap
} = this.groupedDataMap;
return (null === dateTableGroupedMap || void 0 === dateTableGroupedMap ? void 0 : dateTableGroupedMap.length) || 0
}
getCellsBetween(first, last) {
const [firstCell, lastCell] = this.normalizeCellsOrder(first, last);
const {
index: firstIdx
} = firstCell;
const {
index: lastIdx
} = lastCell;
const cellMatrix = this.getCellsByGroupIndexAndAllDay(firstCell.groupIndex ?? 0, lastCell.allDay ?? false);
return (0, _index.isHorizontalView)(this.viewType) ? this.getCellsBetweenHorizontalView(cellMatrix, firstIdx, lastIdx) : this.getCellsBetweenVerticalView(cellMatrix, firstIdx, lastIdx)
}
getCellsBetweenHorizontalView(cellMatrix, firstIdx, lastIdx) {
return cellMatrix.reduce((result, row) => result.concat(row.filter(_ref2 => {
let {
index: index
} = _ref2;
return firstIdx <= index && index <= lastIdx
})), [])
}
getCellsBetweenVerticalView(cellMatrix, firstIdx, lastIdx) {
var _cellMatrix$;
const result = [];
const matrixHeight = cellMatrix.length;
const matrixWidth = (null === (_cellMatrix$ = cellMatrix[0]) || void 0 === _cellMatrix$ ? void 0 : _cellMatrix$.length) ?? 0;
let inSegment = false;
for (let columnIdx = 0; columnIdx < matrixWidth; columnIdx += 1) {
for (let rowIdx = 0; rowIdx < matrixHeight; rowIdx += 1) {
const cell = cellMatrix[rowIdx][columnIdx];
const {
index: cellIdx
} = cell;
if (cellIdx === firstIdx) {
inSegment = true
}
if (inSegment) {
result.push(cell)
}
if (cellIdx === lastIdx) {
return result
}
}
}
return result
}
normalizeCellsOrder(firstSelectedCell, lastSelectedCell) {
return firstSelectedCell.startDate > lastSelectedCell.startDate ? [lastSelectedCell, firstSelectedCell] : [firstSelectedCell, lastSelectedCell]
}
}
exports.default = ViewDataProvider;