@sdata/web-vue 1.18.0 → 2.1.0

package/es/calendar/components/cell.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,813 @@
+import { _objectSpread2 } from "../../_virtual/_@oxc-project_runtime@0.133.0/helpers/esm/objectSpread2.js";
+import { _asyncToGenerator } from "../../_virtual/_@oxc-project_runtime@0.133.0/helpers/esm/asyncToGenerator.js";
+import { calendarInjectionKey } from "../context.js";
+import { minutesToPercentage, percentageToMinutes, pxToPercentage } from "../utils/conversions.js";
+import { months, weekdays } from "../core/config.js";
+import { clampDragCreateDayMinutes } from "../utils/special-hours-allow-events.js";
+import event_default from "./event.js";
+import { Fragment, TransitionGroup, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createTextVNode, defineComponent, inject, mergeProps, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, openBlock, reactive, ref, renderList, renderSlot, shallowRef, toDisplayString, toHandlers, unref, watch, withCtx } from "vue";
+//#region components/calendar/components/cell.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["data-start"];
+var _hoisted_2 = ["data-schedule"];
+var _hoisted_3 = ["title"];
+var cell_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "cell",
+	props: {
+		start: {
+			type: Date,
+			required: true
+		},
+		end: {
+			type: Date,
+			required: true
+		},
+		index: {
+			type: Number,
+			required: true
+		},
+		allDay: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const calendar = inject(calendarInjectionKey);
+		const { view, config, dateUtils, eventsManager, dnd, touch: globalTouchState } = calendar;
+		const prefixCls = calendar.prefixCls;
+		const isToday = computed(() => dateUtils.isToday(props.start));
+		const cellEl = ref(null);
+		const eventsDeleted = ref([]);
+		const transitioning = ref(false);
+		const onEventDelete = (e) => {
+			eventsDeleted.value.push(e.detail);
+			transitioning.value = true;
+		};
+		const afterDelete = () => setTimeout(() => transitioning.value = false, 300);
+		const touch = reactive({
+			dragging: false,
+			holding: false,
+			holdTimer: null,
+			thresholdPassed: false,
+			canTouchAndDrag: null,
+			touchAndDragTimer: null,
+			startX: 0,
+			startY: 0,
+			moveX: 0,
+			moveY: 0,
+			startPercentageX: 0,
+			startPercentageY: 0,
+			movePercentageX: 0,
+			movePercentageY: 0,
+			schedule: null
+		});
+		const awaitingEventCreation = ref(false);
+		let clickTimeout = null;
+		const overlappingEvents = ref({
+			cellOverlaps: {},
+			longestStreak: 0
+		});
+		const eventPlaceholder = computed(() => {
+			var _config$specialHoursD;
+			const isHzl = config.horizontal;
+			const startPercentageVal = isHzl ? touch.startPercentageX : touch.startPercentageY;
+			const movePercentageVal = isHzl ? touch.movePercentageX : touch.movePercentageY;
+			const anchorDayMinutes = percentageToMinutes(startPercentageVal, config);
+			const cursorDayMinutes = percentageToMinutes(movePercentageVal, config);
+			let startPercentage = Math.min(startPercentageVal, movePercentageVal);
+			let endPercentage = Math.max(startPercentageVal, movePercentageVal);
+			let startMinutes = percentageToMinutes(startPercentage, config);
+			let endMinutes = percentageToMinutes(endPercentage, config);
+			if (config.snapToInterval) {
+				startMinutes = dateUtils.snapToInterval(startMinutes, config.snapToInterval);
+				endMinutes = dateUtils.snapToInterval(endMinutes, config.snapToInterval);
+				startPercentage = minutesToPercentage(startMinutes, config);
+				endPercentage = minutesToPercentage(endMinutes, config);
+			}
+			if (config.time && ((_config$specialHoursD = config.specialHoursDisallowed) === null || _config$specialHoursD === void 0 ? void 0 : _config$specialHoursD.hasAny) && !props.allDay) {
+				const clamped = clampDragCreateDayMinutes({
+					anchorDayMinutes,
+					cursorDayMinutes,
+					snappedLow: startMinutes,
+					snappedHigh: endMinutes,
+					cellDate: props.start,
+					schedule: touch.schedule,
+					disallowed: config.specialHoursDisallowed,
+					hasSchedules: !!(config.schedules && config.schedules.length)
+				});
+				startMinutes = clamped.low;
+				endMinutes = clamped.high;
+				startPercentage = minutesToPercentage(startMinutes, config);
+				endPercentage = minutesToPercentage(endMinutes, config);
+			}
+			return _objectSpread2({
+				style: {
+					[isHzl ? "left" : "top"]: `${startPercentage}%`,
+					[isHzl ? "width" : "height"]: `${Math.abs(endPercentage - startPercentage)}%`
+				},
+				startMinutes,
+				endMinutes,
+				start: dateUtils.formatMinutes(startMinutes),
+				end: dateUtils.formatMinutes(endMinutes)
+			}, touch.schedule != null ? { schedule: touch.schedule } : {});
+		});
+		const isCreatingEvent = computed(() => {
+			const isCreating = config.editableEvents.create && (touch.dragging || awaitingEventCreation.value);
+			const hasPassedMinDrag = config.eventCreateMinDrag && touch.thresholdPassed || !config.eventCreateMinDrag;
+			const canCreateEvent = touch.canTouchAndDrag !== false;
+			return isCreating && hasPassedMinDrag && canCreateEvent;
+		});
+		const classes = computed(() => {
+			var _config$schedules;
+			const now = /* @__PURE__ */ new Date();
+			const viewYear = view.start.getFullYear();
+			const viewMonth = view.start.getMonth();
+			const y = props.start.getFullYear();
+			const m = props.start.getMonth();
+			return {
+				[`${prefixCls}__cell--${weekdays[props.start.getDay()]}`]: view.isDay || view.isDays || view.isWeek || view.isMonth,
+				[`${prefixCls}__cell--${months[m]}`]: view.isYear,
+				[`${prefixCls}__cell--${y}`]: view.isYears,
+				[`${prefixCls}__cell--today`]: isToday.value,
+				[`${prefixCls}__cell--current-month`]: view.isYear && y === now.getFullYear() && m === now.getMonth(),
+				[`${prefixCls}__cell--current-year`]: view.isYears && y === now.getFullYear(),
+				[`${prefixCls}__cell--out-of-range`]: view.isMonth && (y !== viewYear || m !== viewMonth),
+				[`${prefixCls}__cell--before-min`]: isDisabled.value && isBeforeMinDate.value,
+				[`${prefixCls}__cell--after-max`]: isDisabled.value && isAfterMaxDate.value,
+				[`${prefixCls}__cell--disabled`]: isDisabled.value,
+				[`${prefixCls}__cell--selected`]: view.selectedDate && view.selectedDate.getTime() >= props.start.getTime() && view.selectedDate.getTime() <= props.end.getTime(),
+				[`${prefixCls}__cell--has-schedules`]: (_config$schedules = config.schedules) === null || _config$schedules === void 0 ? void 0 : _config$schedules.length,
+				[`${prefixCls}__cell--dragging`]: touch.dragging,
+				[`${prefixCls}__cell--has-events`]: cellEvents.value.length
+			};
+		});
+		computed(() => dateUtils.formatDate(props.start));
+		const formattedCellDate = computed(() => {
+			switch (view.id) {
+				case "day": return "";
+				case "days":
+					if (config.availableViews.days.rows > 1) dateUtils.formatDate(props.start, "D");
+					return "";
+				case "week": return "";
+				case "month": return dateUtils.formatDate(props.start, "D");
+				case "year": return dateUtils.formatDate(props.start, config.xs ? "MMM" : "MMMM");
+				case "years": return dateUtils.formatDate(props.start, "YYYY");
+				default: return "";
+			}
+		});
+		const cellEvents = computed(() => {
+			if (config.datePicker) return [];
+			return eventsManager.getEventsInRange(props.start, props.end, _objectSpread2({ excludeIds: eventsDeleted.value }, config.allDayEvents ? { allDay: props.allDay } : {}));
+		});
+		const cellForegroundEvents = computed(() => cellEvents.value.filter((event) => !event.background));
+		/**
+		* Generates an object containing events grouped by schedule ID.
+		*
+		* @returns {Object} An object where keys are schedule IDs, and values are arrays of event IDs
+		*                   that correspond to each schedule.
+		*/
+		const cellEventsPerSchedule = computed(() => {
+			var _config$schedules2;
+			return (_config$schedules2 = config.schedules) === null || _config$schedules2 === void 0 ? void 0 : _config$schedules2.reduce((obj, schedule) => {
+				obj[schedule.id] = cellEvents.value.filter((event) => event.schedule === schedule.id);
+				return obj;
+			}, {});
+		});
+		const eventStyles = computed(() => {
+			if (view.isMonth || view.isYear || view.isYears || props.allDay || !config.time) return {};
+			const isRTL = typeof document !== "undefined" && document.documentElement.getAttribute("dir") === "rtl";
+			const isHzl = config.horizontal;
+			const styles = {};
+			for (const event of cellEvents.value) {
+				const eventId = event._.id;
+				const { maxConcurrent = 1, position = 0 } = overlappingEvents.value.cellOverlaps[eventId] || {};
+				const rightOrLeft = isRTL ? "right" : "left";
+				const widthOrHeight = isHzl ? "height" : "width";
+				styles[eventId] = { [isHzl ? "top" : rightOrLeft]: `${100 / maxConcurrent * position}%` };
+				if (config.stackEvents) styles[eventId][widthOrHeight] = `${100 / maxConcurrent + (position === maxConcurrent - 1 ? 0 : 15)}%`;
+				else styles[eventId][widthOrHeight] = `${100 / maxConcurrent}%`;
+			}
+			return styles;
+		});
+		/**
+		* Generates an object containing event classes based on the stack position and length.
+		* This lets the user style visually stacked events in full control.
+		*
+		* @returns {Object} An object where keys are event IDs, and values are strings
+		*                   representing the event class.
+		*/
+		const eventClasses = computed(() => {
+			const classes = {};
+			for (const event of cellEvents.value) {
+				const eventId = event._.id;
+				const { maxConcurrent = 1, position = 0 } = overlappingEvents.value.cellOverlaps[eventId] || {};
+				classes[eventId] = `${prefixCls}__event--stack-${position + 1}-${maxConcurrent}`;
+			}
+			return classes;
+		});
+		const showCellEventCount = computed(() => {
+			return config.showCellEventCount && cellForegroundEvents.value.length;
+		});
+		/**
+		* The special hours of the current cell day.
+		* returns an array if the view is day, days, week and the specialHours prop is set correctly.
+		*/
+		const getPositionedSpecialHours = (ranges) => {
+			const list = ranges || [];
+			const isHzl = config.horizontal;
+			const { timeFrom, timeTo } = config;
+			const positioned = [];
+			for (let i = 0; i < list.length; i++) {
+				let { from, to, class: classes, label } = list[i];
+				if (isNaN(from) || isNaN(to) || timeFrom >= to || timeTo <= from) continue;
+				from = Math.max(timeFrom, from);
+				to = Math.min(timeTo, to);
+				const start = minutesToPercentage(from, config);
+				const size = minutesToPercentage(to, config) - start;
+				positioned.push({
+					style: {
+						[isHzl ? "left" : "top"]: `${start}%`,
+						[isHzl ? "width" : "height"]: `${size}%`
+					},
+					label,
+					class: classes
+				});
+			}
+			return positioned;
+		};
+		const specialHours = computed(() => {
+			var _config$specialHours;
+			if (!config.specialHours || view.isMonth || view.isYear || view.isYears || props.allDay) return void 0;
+			const weekday = weekdays[props.start.getDay()];
+			let daySpecialHours = (_config$specialHours = config.specialHours) === null || _config$specialHours === void 0 ? void 0 : _config$specialHours[weekday];
+			if (!daySpecialHours) return void 0;
+			return {
+				default: getPositionedSpecialHours(daySpecialHours.default),
+				schedules: Object.entries(daySpecialHours.schedules || {}).reduce((obj, [scheduleId, ranges]) => {
+					obj[scheduleId] = getPositionedSpecialHours(ranges);
+					return obj;
+				}, {})
+			};
+		});
+		const schedulesWithCellSpecialHours = computed(() => {
+			const schedules = config.schedules;
+			if (!(schedules === null || schedules === void 0 ? void 0 : schedules.length)) return [];
+			const sh = specialHours.value;
+			if (!sh) return schedules.map((schedule) => ({
+				schedule,
+				ranges: []
+			}));
+			const { default: defaultRanges, schedules: byScheduleId } = sh;
+			return schedules.map((schedule) => {
+				const scheduleKey = String(schedule.id);
+				return {
+					schedule,
+					ranges: Object.prototype.hasOwnProperty.call(byScheduleId, scheduleKey) ? byScheduleId[scheduleKey] : defaultRanges
+				};
+			});
+		});
+		const isBeforeMinDate = computed(() => {
+			return config.minTimestamp !== null && config.minTimestamp > props.end.getTime();
+		});
+		const isAfterMaxDate = computed(() => {
+			return config.maxTimestamp && config.maxTimestamp < props.start.getTime();
+		});
+		const isDisabled = computed(() => {
+			const { disableDays } = config;
+			const isYearsOrYearView = view.isYear || view.isYears;
+			if (disableDays.length && disableDays.includes(dateUtils.formatDate(props.start)) && !isYearsOrYearView) return true;
+			return isBeforeMinDate.value || isAfterMaxDate.value;
+		});
+		const cellEventListeners = shallowRef({});
+		watch(() => [isDisabled.value, config.eventListeners.cell], () => {
+			if (isDisabled.value) {
+				cellEventListeners.value = {};
+				return;
+			}
+			const listeners = _objectSpread2({}, config.eventListeners.cell);
+			for (const [eventListener, handler] of Object.entries(listeners)) listeners[eventListener] = (e) => {
+				var _ref, _ref$closest, _e$e;
+				if ((_ref = e.target || ((_e$e = e.e) === null || _e$e === void 0 ? void 0 : _e$e.target)) === null || _ref === void 0 || (_ref$closest = _ref.closest) === null || _ref$closest === void 0 ? void 0 : _ref$closest.call(_ref, `.${prefixCls}__event`)) return;
+				handler(e.type ? {
+					e,
+					cell: cellInfo.value,
+					cursor: cursorInfo.value,
+					view
+				} : e);
+			};
+			const externalHandlers = _objectSpread2({}, listeners);
+			listeners.click = (e) => {
+				var _externalHandlers$cli;
+				onCellClick();
+				const cursor = getTimeAtCursor(e);
+				(_externalHandlers$cli = externalHandlers.click) === null || _externalHandlers$cli === void 0 || _externalHandlers$cli.call(externalHandlers, {
+					e,
+					cell: cellInfo.value,
+					cursor,
+					view
+				});
+				if (clickTimeout) clickTimeout = clearTimeout(clickTimeout);
+				else clickTimeout = setTimeout(() => {
+					var _externalHandlers$del;
+					clickTimeout = null;
+					(_externalHandlers$del = externalHandlers["delayed-click"]) === null || _externalHandlers$del === void 0 || _externalHandlers$del.call(externalHandlers, {
+						e,
+						cell: cellInfo.value,
+						cursor,
+						view
+					});
+				}, 400);
+			};
+			if (config.time && view.isDay || view.isDays || view.isWeek) {
+				listeners.touchstart = (e) => {
+					var _externalHandlers$tou;
+					onMousedown(e.e || e);
+					(_externalHandlers$tou = externalHandlers.touchstart) === null || _externalHandlers$tou === void 0 || _externalHandlers$tou.call(externalHandlers, {
+						e,
+						cell: cellInfo.value,
+						cursor: cursorInfo.value,
+						view
+					});
+				};
+				listeners.mousedown = (e) => {
+					var _externalHandlers$mou;
+					onMousedown(e.e || e);
+					(_externalHandlers$mou = externalHandlers.mousedown) === null || _externalHandlers$mou === void 0 || _externalHandlers$mou.call(externalHandlers, {
+						e,
+						cell: cellInfo.value,
+						cursor: cursorInfo.value,
+						view
+					});
+				};
+			}
+			if (externalHandlers.dblclick) listeners.dblclick = (e) => {
+				var _externalHandlers$dbl;
+				(_externalHandlers$dbl = externalHandlers.dblclick) === null || _externalHandlers$dbl === void 0 || _externalHandlers$dbl.call(externalHandlers, {
+					e,
+					cell: cellInfo.value,
+					cursor: getTimeAtCursor(e),
+					view
+				});
+			};
+			if (config.editableEvents.drag) {
+				listeners.dragenter = (e) => dnd.cellDragEnter(e, cellInfo.value);
+				listeners.dragover = (e) => {
+					e.preventDefault();
+					dnd.cellDragOver(e, cellInfo.value);
+				};
+				listeners.dragleave = (e) => dnd.cellDragLeave(e, cellInfo.value);
+				listeners.drop = (e) => dnd.cellDragDrop(e, cellInfo.value, props.allDay);
+			}
+			cellEventListeners.value = listeners;
+		}, { immediate: true });
+		const cellInfo = computed(() => _objectSpread2(_objectSpread2({
+			start: props.start,
+			end: props.end,
+			events: cellEvents,
+			today: isToday.value,
+			content: formattedCellDate.value
+		}, touch.schedule !== null ? { schedule: touch.schedule } : {}), {}, {
+			goNarrower: () => view.narrower(),
+			goBroader: () => view.broader(),
+			broader: view.broaderView,
+			narrower: view.narrowerView
+		}));
+		const scheduleEvents = (schedule) => {
+			return cellEventsPerSchedule.value[schedule.id] || [];
+		};
+		/**
+		* Get the time at the cursor position.
+		*
+		* @param {Event} e - The event object.
+		* @returns {Object} An object containing the cursor position in percentage and the associate date.
+		*/
+		const getTimeAtCursor = (e) => {
+			var _e$touches;
+			const isHzl = config.horizontal;
+			const { clientX, clientY } = ((_e$touches = e.touches) === null || _e$touches === void 0 ? void 0 : _e$touches[0]) || e;
+			if (!cellEl.value) return {
+				x: 0,
+				y: 0,
+				date: /* @__PURE__ */ new Date()
+			};
+			const { top, left } = cellEl.value.getBoundingClientRect();
+			const cursorPercent = isHzl ? (clientX - left) * 100 / cellEl.value.clientWidth : pxToPercentage(clientY - top, cellEl.value);
+			const date = new Date(props.start);
+			date.setMinutes(percentageToMinutes(cursorPercent, config));
+			return {
+				[isHzl ? "x" : "y"]: cursorPercent,
+				date
+			};
+		};
+		const cursorInfo = computed(() => {
+			const minutes = percentageToMinutes(config.horizontal ? touch.movePercentageX || touch.startPercentageX : touch.movePercentageY || touch.startPercentageY, config);
+			const date = new Date(props.start);
+			date.setMinutes(minutes);
+			return {
+				x: touch.movePercentageX || touch.startPercentageX,
+				y: touch.movePercentageY || touch.startPercentageY,
+				date
+			};
+		});
+		const onCellClick = () => {
+			view.updateSelectedDate(props.start);
+			if (config.clickToNavigate) {
+				if ((view.isMonth || view.isDays || view.isWeek) && config.availableViews.day) view.switch("day");
+				else if (view.isYear && config.availableViews.month) view.switch("month");
+				else if (view.isYears && config.availableViews.year) view.switch("year");
+			}
+			view.updateViewDate(props.start);
+		};
+		const onMousedown = (e) => {
+			var _e$target, _config$schedules3, _e$touches2, _e$touches3;
+			const isTouchEvent = e.type === "touchstart";
+			if (isTouchEvent) {
+				touch.canTouchAndDrag = false;
+				touch.touchAndDragTimer = setTimeout(() => {
+					touch.canTouchAndDrag = true;
+					if (touch.holding || touch.dragging) e.preventDefault();
+				}, 500);
+			} else touch.canTouchAndDrag = true;
+			const rawSchedule = (_e$target = e.target) === null || _e$target === void 0 || (_e$target = _e$target.closest("[data-schedule]")) === null || _e$target === void 0 || (_e$target = _e$target.dataset) === null || _e$target === void 0 ? void 0 : _e$target.schedule;
+			if (rawSchedule !== void 0 && ((_config$schedules3 = config.schedules) === null || _config$schedules3 === void 0 ? void 0 : _config$schedules3.length)) {
+				const match = config.schedules.find((s) => String(s.id) === String(rawSchedule));
+				touch.schedule = match ? match.id : rawSchedule;
+			} else touch.schedule = null;
+			if (!cellEl.value) return;
+			const rect = cellEl.value.getBoundingClientRect();
+			touch.startX = (((_e$touches2 = e.touches) === null || _e$touches2 === void 0 ? void 0 : _e$touches2[0]) || e).clientX - rect.left;
+			touch.startY = (((_e$touches3 = e.touches) === null || _e$touches3 === void 0 ? void 0 : _e$touches3[0]) || e).clientY - rect.top;
+			touch.startPercentageX = touch.startX * 100 / rect.width;
+			touch.startPercentageY = touch.startY * 100 / rect.height;
+			touch.thresholdPassed = false;
+			document.addEventListener(isTouchEvent ? "touchmove" : "mousemove", onDocMousemove, { passive: !isTouchEvent });
+			document.addEventListener(isTouchEvent ? "touchend" : "mouseup", onDocMouseup, { once: true });
+			touch.holdTimer = setTimeout(() => {
+				var _cellEventListeners$v, _cellEventListeners$v2;
+				touch.holding = true;
+				(_cellEventListeners$v = (_cellEventListeners$v2 = cellEventListeners.value).hold) === null || _cellEventListeners$v === void 0 || _cellEventListeners$v.call(_cellEventListeners$v2, {
+					e,
+					cell: cellInfo.value,
+					cursor: cursorInfo.value,
+					view
+				});
+			}, 1e3);
+		};
+		const onDocMousemove = (e) => {
+			var _e$touches4, _e$touches5, _cellEventListeners$v5, _cellEventListeners$v6;
+			const isTouchEvent = e.type === "touchmove";
+			const isHzl = config.horizontal;
+			if (isTouchEvent && !touch.canTouchAndDrag) {
+				if (touch.touchAndDragTimer) {
+					clearTimeout(touch.touchAndDragTimer);
+					touch.touchAndDragTimer = null;
+				}
+				onDocMouseup(e);
+				return;
+			}
+			if (isTouchEvent) e.preventDefault();
+			if (!touch.dragging) {
+				var _cellEventListeners$v3, _cellEventListeners$v4;
+				globalTouchState.isDraggingCell = true;
+				(_cellEventListeners$v3 = (_cellEventListeners$v4 = cellEventListeners.value)["drag-start"]) === null || _cellEventListeners$v3 === void 0 || _cellEventListeners$v3.call(_cellEventListeners$v4, {
+					e,
+					cell: cellInfo.value,
+					cursor: cursorInfo.value,
+					view
+				});
+			}
+			touch.dragging = true;
+			if (touch.holdTimer) touch.holdTimer = clearTimeout(touch.holdTimer);
+			touch.holding = false;
+			if (!cellEl.value) return;
+			const rect = cellEl.value.getBoundingClientRect();
+			touch.moveX = (((_e$touches4 = e.touches) === null || _e$touches4 === void 0 ? void 0 : _e$touches4[0]) || e).clientX - rect.left;
+			touch.moveY = (((_e$touches5 = e.touches) === null || _e$touches5 === void 0 ? void 0 : _e$touches5[0]) || e).clientY - rect.top;
+			touch.movePercentageX = touch.moveX * 100 / rect.width;
+			touch.movePercentageY = touch.moveY * 100 / rect.height;
+			const dragDelta = isHzl ? Math.abs(touch.startX - touch.moveX) : Math.abs(touch.startY - touch.moveY);
+			if (config.eventCreateMinDrag && dragDelta > config.eventCreateMinDrag) touch.thresholdPassed = true;
+			(_cellEventListeners$v5 = (_cellEventListeners$v6 = cellEventListeners.value).drag) === null || _cellEventListeners$v5 === void 0 || _cellEventListeners$v5.call(_cellEventListeners$v6, {
+				e,
+				cell: cellInfo.value,
+				cursor: cursorInfo.value,
+				view
+			});
+		};
+		const onDocMouseup = function() {
+			var _ref2 = _asyncToGenerator(function* (e) {
+				const isTouchEvent = e.type === "touchend";
+				document.removeEventListener(isTouchEvent ? "touchmove" : "mousemove", onDocMousemove);
+				if (touch.touchAndDragTimer) {
+					clearTimeout(touch.touchAndDragTimer);
+					touch.touchAndDragTimer = null;
+				}
+				if (touch.dragging) {
+					var _cellEventListeners$v7, _cellEventListeners$v8;
+					(_cellEventListeners$v7 = (_cellEventListeners$v8 = cellEventListeners.value)["drag-end"]) === null || _cellEventListeners$v7 === void 0 || _cellEventListeners$v7.call(_cellEventListeners$v8, {
+						e,
+						cell: cellInfo.value,
+						cursor: cursorInfo.value,
+						view
+					});
+					globalTouchState.isDraggingCell = false;
+					if (config.editableEvents.create && touch.canTouchAndDrag) {
+						awaitingEventCreation.value = true;
+						yield createEventIfAllowed(e);
+						awaitingEventCreation.value = false;
+					}
+				}
+				if (touch.holdTimer) touch.holdTimer = clearTimeout(touch.holdTimer);
+				touch.holding = false;
+				touch.dragging = false;
+				touch.startX = 0;
+				touch.startY = 0;
+				touch.moveX = 0;
+				touch.moveY = 0;
+				touch.startPercentageX = 0;
+				touch.startPercentageY = 0;
+				touch.movePercentageX = 0;
+				touch.movePercentageY = 0;
+				touch.thresholdPassed = false;
+				touch.schedule = null;
+				touch.canTouchAndDrag = null;
+			});
+			return function onDocMouseup(_x) {
+				return _ref2.apply(this, arguments);
+			};
+		}();
+		const createEventIfAllowed = function() {
+			var _ref3 = _asyncToGenerator(function* (e) {
+				var _navigator$vibrate, _navigator;
+				if (!isCreatingEvent.value) return;
+				let { start, end, startMinutes, endMinutes } = eventPlaceholder.value;
+				start = new Date(props.start);
+				start.setMinutes(startMinutes);
+				end = new Date(props.start);
+				end.setMinutes(endMinutes);
+				let eventToCreate = _objectSpread2(_objectSpread2({}, eventPlaceholder.value), {}, {
+					start,
+					end
+				});
+				const { create: createListener } = config.eventListeners.event;
+				if (typeof createListener === "function") {
+					const eventCopy = eventToCreate;
+					eventToCreate = yield new Promise((resolve) => createListener({
+						e,
+						event: eventToCreate,
+						cell: cellInfo.value,
+						resolve,
+						cursor: cursorInfo.value,
+						view
+					}));
+					if (eventToCreate && typeof eventToCreate === "object") view.createEvent(eventToCreate);
+					if (eventToCreate && typeof eventToCreate === "boolean") view.createEvent(eventCopy);
+				} else view.createEvent(eventToCreate);
+				(_navigator$vibrate = (_navigator = navigator).vibrate) === null || _navigator$vibrate === void 0 || _navigator$vibrate.call(_navigator, 200);
+			});
+			return function createEventIfAllowed(_x2) {
+				return _ref3.apply(this, arguments);
+			};
+		}();
+		const removeEventListeners = () => {
+			for (const event of Object.keys(cellEventListeners.value)) {
+				var _cellEl$value;
+				(_cellEl$value = cellEl.value) === null || _cellEl$value === void 0 || _cellEl$value.removeEventListener(event, cellEventListeners.value[event]);
+			}
+		};
+		const recalculateOverlaps = () => {
+			overlappingEvents.value = eventsManager.getCellOverlappingEvents(props.start, props.end, props.allDay);
+		};
+		watch(() => !view.isYears && !view.isYear && cellForegroundEvents.value.map((e) => `${e._.id}${e.start.getTime()}${e.end.getTime()}`).join(), _asyncToGenerator(function* () {
+			yield nextTick();
+			recalculateOverlaps();
+		}), {
+			immediate: true,
+			flush: "post"
+		});
+		onBeforeUnmount(_asyncToGenerator(function* () {
+			for (const eventId of eventsDeleted.value) eventsManager.deleteEvent(eventId, 3);
+			removeEventListeners();
+			if (clickTimeout) clickTimeout = clearTimeout(clickTimeout);
+			yield nextTick();
+		}));
+		return (_ctx, _cache) => {
+			var _specialHours$value, _unref$schedules;
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "cellEl",
+				ref: cellEl
+			}, toHandlers(cellEventListeners.value, true), {
+				"data-start": props.start.getTime(),
+				class: [`${unref(prefixCls)}__cell`, classes.value]
+			}), [
+				_ctx.$slots.cell ? renderSlot(_ctx.$slots, "cell", {
+					key: 0,
+					cell: cellInfo.value
+				}) : createCommentVNode("", true),
+				((_specialHours$value = specialHours.value) === null || _specialHours$value === void 0 || (_specialHours$value = _specialHours$value.default) === null || _specialHours$value === void 0 ? void 0 : _specialHours$value.length) && !((_unref$schedules = unref(config).schedules) === null || _unref$schedules === void 0 ? void 0 : _unref$schedules.length) ? (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(specialHours.value.default, (range, i) => {
+					return openBlock(), createElementBlock("div", {
+						style: normalizeStyle(range.style),
+						class: normalizeClass([`${unref(prefixCls)}__special-hours`, range.class])
+					}, [renderSlot(_ctx.$slots, "special-hours-label", { range }, () => [createTextVNode(toDisplayString(range.label), 1)])], 6);
+				}), 256)) : createCommentVNode("", true),
+				!_ctx.$slots.cell && unref(config).schedules ? (openBlock(true), createElementBlock(Fragment, { key: 2 }, renderList(schedulesWithCellSpecialHours.value, ({ schedule, ranges }) => {
+					return openBlock(), createElementBlock("div", {
+						key: schedule.id,
+						class: normalizeClass([
+							`${unref(prefixCls)}__schedule`,
+							`${unref(prefixCls)}__schedule--cell`,
+							schedule.class
+						]),
+						style: normalizeStyle(schedule.style || null),
+						"data-schedule": schedule.id
+					}, [
+						ranges.length ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(ranges, (range, i) => {
+							return openBlock(), createElementBlock("div", {
+								key: `${schedule.id}-${i}`,
+								style: normalizeStyle(range.style),
+								class: normalizeClass([`${unref(prefixCls)}__special-hours`, range.class])
+							}, [renderSlot(_ctx.$slots, "special-hours-label", {
+								range,
+								schedule
+							}, () => [createTextVNode(toDisplayString(range.label), 1)])], 6);
+						}), 128)) : createCommentVNode("", true),
+						formattedCellDate.value || _ctx.$slots["cell-date"] ? (openBlock(), createElementBlock("div", {
+							key: 1,
+							class: normalizeClass(`${unref(prefixCls)}__cell-date`)
+						}, [renderSlot(_ctx.$slots, "cell-date", {
+							cell: cellInfo.value,
+							view: unref(view),
+							schedule,
+							events: scheduleEvents(schedule)
+						}, () => [createTextVNode(toDisplayString(formattedCellDate.value), 1)])], 2)) : createCommentVNode("", true),
+						_ctx.$slots["cell-content"] ? (openBlock(), createElementBlock("div", {
+							key: 2,
+							class: normalizeClass(`${unref(prefixCls)}__cell-content`)
+						}, [renderSlot(_ctx.$slots, "cell-content", {
+							cell: cellInfo.value,
+							view: unref(view),
+							schedule,
+							events: scheduleEvents(schedule)
+						})], 2)) : createCommentVNode("", true),
+						_ctx.$slots["cell-events"] ? (openBlock(), createElementBlock("div", {
+							key: 3,
+							class: normalizeClass(`${unref(prefixCls)}__cell-events`)
+						}, [renderSlot(_ctx.$slots, "cell-events", {
+							cell: cellInfo.value,
+							view: unref(view),
+							schedule,
+							events: scheduleEvents(schedule)
+						})], 2)) : cellEvents.value.length || transitioning.value ? (openBlock(), createBlock(TransitionGroup, {
+							key: 4,
+							name: `${unref(prefixCls)}-event-delete`,
+							onBeforeLeave: _cache[0] || (_cache[0] = ($event) => transitioning.value = true),
+							onAfterLeave: afterDelete,
+							tag: "div",
+							class: normalizeClass(`${unref(prefixCls)}__cell-events`)
+						}, {
+							default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(cellEventsPerSchedule.value[schedule.id], (event) => {
+								return openBlock(), createBlock(event_default, {
+									key: event._.id,
+									event,
+									onEventDeleted: onEventDelete,
+									"in-all-day-bar": props.allDay,
+									"cell-start": props.start,
+									"cell-end": props.end,
+									style: normalizeStyle(eventStyles.value[event._.id])
+								}, createSlots({ _: 2 }, [
+									_ctx.$slots["event.all-day"] && props.allDay ? {
+										name: "event.all-day",
+										fn: withCtx((params) => [renderSlot(_ctx.$slots, "event.all-day", mergeProps({ ref_for: true }, params))]),
+										key: "0"
+									} : void 0,
+									_ctx.$slots[`event.${unref(view).id}`] ? {
+										name: `event.${unref(view).id}`,
+										fn: withCtx((params) => [renderSlot(_ctx.$slots, `event.${unref(view).id}`, mergeProps({ ref_for: true }, params))]),
+										key: "1"
+									} : void 0,
+									_ctx.$slots.event ? {
+										name: "event",
+										fn: withCtx((params) => [renderSlot(_ctx.$slots, "event", mergeProps({ ref_for: true }, params))]),
+										key: "2"
+									} : void 0,
+									_ctx.$slots["event-content"] ? {
+										name: "event-content",
+										fn: withCtx((params) => [renderSlot(_ctx.$slots, "event-content", mergeProps({ ref_for: true }, params))]),
+										key: "3"
+									} : void 0
+								]), 1032, [
+									"event",
+									"in-all-day-bar",
+									"cell-start",
+									"cell-end",
+									"style"
+								]);
+							}), 128))]),
+							_: 2
+						}, 1032, ["name", "class"])) : createCommentVNode("", true),
+						isCreatingEvent.value && touch.schedule === schedule.id && !props.allDay ? (openBlock(), createElementBlock("div", {
+							key: 5,
+							style: normalizeStyle(eventPlaceholder.value.style),
+							class: normalizeClass(`${unref(prefixCls)}__event-placeholder`)
+						}, toDisplayString(eventPlaceholder.value.start) + " - " + toDisplayString(eventPlaceholder.value.end), 7)) : createCommentVNode("", true)
+					], 14, _hoisted_2);
+				}), 128)) : createCommentVNode("", true),
+				!_ctx.$slots.cell && !unref(config).schedules ? (openBlock(), createElementBlock(Fragment, { key: 3 }, [
+					formattedCellDate.value || _ctx.$slots["cell-date"] ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						class: normalizeClass(`${unref(prefixCls)}__cell-date`)
+					}, [renderSlot(_ctx.$slots, "cell-date", {
+						cell: cellInfo.value,
+						view: unref(view)
+					}, () => [createTextVNode(toDisplayString(formattedCellDate.value), 1)])], 2)) : createCommentVNode("", true),
+					_ctx.$slots["cell-content"] ? (openBlock(), createElementBlock("div", {
+						key: 1,
+						class: normalizeClass(`${unref(prefixCls)}__cell-content`)
+					}, [renderSlot(_ctx.$slots, "cell-content", {
+						cell: cellInfo.value,
+						view: unref(view)
+					})], 2)) : createCommentVNode("", true),
+					_ctx.$slots["cell-events"] && cellEvents.value.length ? (openBlock(), createElementBlock("div", {
+						key: 2,
+						class: normalizeClass(`${unref(prefixCls)}__cell-events`)
+					}, [renderSlot(_ctx.$slots, "cell-events", {
+						cell: cellInfo.value,
+						view: unref(view)
+					})], 2)) : !(unref(view).isMonth && !unref(config).eventsOnMonthView) && !unref(view).isYear && !unref(view).isYears && (cellEvents.value.length || transitioning.value) ? (openBlock(), createBlock(TransitionGroup, {
+						key: 3,
+						name: `${unref(prefixCls)}-event-delete`,
+						onBeforeLeave: _cache[1] || (_cache[1] = ($event) => transitioning.value = true),
+						onAfterLeave: afterDelete,
+						tag: "div",
+						class: normalizeClass(`${unref(prefixCls)}__cell-events`)
+					}, {
+						default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(cellEvents.value, (event) => {
+							return openBlock(), createBlock(event_default, {
+								key: event._.id,
+								event,
+								onEventDeleted: onEventDelete,
+								"in-all-day-bar": props.allDay,
+								"cell-start": props.start,
+								"cell-end": props.end,
+								class: normalizeClass(eventClasses.value[event._.id]),
+								style: normalizeStyle(eventStyles.value[event._.id])
+							}, createSlots({ _: 2 }, [
+								_ctx.$slots["event.all-day"] && props.allDay ? {
+									name: "event.all-day",
+									fn: withCtx((params) => [renderSlot(_ctx.$slots, "event.all-day", mergeProps({ ref_for: true }, params))]),
+									key: "0"
+								} : void 0,
+								_ctx.$slots[`event.${unref(view).id}`] ? {
+									name: `event.${unref(view).id}`,
+									fn: withCtx((params) => [renderSlot(_ctx.$slots, `event.${unref(view).id}`, mergeProps({ ref_for: true }, params))]),
+									key: "1"
+								} : void 0,
+								_ctx.$slots.event ? {
+									name: "event",
+									fn: withCtx((params) => [renderSlot(_ctx.$slots, "event", mergeProps({ ref_for: true }, params))]),
+									key: "2"
+								} : void 0,
+								_ctx.$slots["event-content"] ? {
+									name: "event-content",
+									fn: withCtx((params) => [renderSlot(_ctx.$slots, "event-content", mergeProps({ ref_for: true }, params))]),
+									key: "3"
+								} : void 0
+							]), 1032, [
+								"event",
+								"in-all-day-bar",
+								"cell-start",
+								"cell-end",
+								"class",
+								"style"
+							]);
+						}), 128))]),
+						_: 3
+					}, 8, ["name", "class"])) : createCommentVNode("", true),
+					isCreatingEvent.value ? (openBlock(), createElementBlock("div", {
+						key: 4,
+						style: normalizeStyle(eventPlaceholder.value.style),
+						class: normalizeClass(`${unref(prefixCls)}__event-placeholder`)
+					}, toDisplayString(eventPlaceholder.value.start) + " - " + toDisplayString(eventPlaceholder.value.end), 7)) : createCommentVNode("", true)
+				], 64)) : createCommentVNode("", true),
+				_ctx.$slots["event-count"] ? renderSlot(_ctx.$slots, "event-count", {
+					key: 4,
+					events: cellForegroundEvents.value
+				}) : showCellEventCount.value ? (openBlock(), createElementBlock("div", {
+					key: 5,
+					class: normalizeClass(`${unref(prefixCls)}__cell-events-count`)
+				}, toDisplayString(cellForegroundEvents.value.length), 3)) : createCommentVNode("", true),
+				unref(view).nowLine.show && isToday.value && !__props.allDay ? (openBlock(), createElementBlock("div", {
+					key: 6,
+					style: normalizeStyle(unref(view).nowLine.style),
+					title: unref(view).nowLine.currentTime,
+					class: normalizeClass(`${unref(prefixCls)}__now-line`)
+				}, [renderSlot(_ctx.$slots, "now-line", {
+					now: unref(view).now,
+					timeFormatted: unref(view).nowLine.currentTime
+				}, () => [createElementVNode("span", null, toDisplayString(unref(view).nowLine.currentTime), 1)])], 14, _hoisted_3)) : createCommentVNode("", true)
+			], 16, _hoisted_1);
+		};
+	}
+});
+//#endregion
+export { cell_vue_vue_type_script_setup_true_lang_default as default };