@vizejs/ui 0.426.3 → 0.427.0

package/dist/scheduler-6sLVhSSP.mjs

@@ -0,0 +1,1397 @@
+import { B as toUtcDate, I as startOfMonth, L as startOfWeek, T as isSameMonth, d as daysBetween, h as formatIsoDate, j as normalizePlainDate, m as endOfWeek, p as endOfMonth, r as addDays, s as compareDates, w as isSameDay } from "./plain-date-DHX8BIlm.mjs";
+import { c as minutesBetween, n as combineDateTime, r as compareDateTimes, t as addMinutes } from "./plain-date-time-BQrJLa0I.mjs";
+import { a as useDeterministicId, n as deriveDeterministicId } from "./deterministic-id-bMmJU5xD.mjs";
+import { createContext } from "./context.mjs";
+import { S as useLocaleValue, c as resolveLocale } from "./locale-runtime-SahmDKpf.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { n as normalizeWeekday, t as createCalendarFormatters } from "./calendar-locale-Cl5bvmuE.mjs";
+import { t as useToday } from "./calendar-today-jj5QcZGW.mjs";
+import { useControllableState } from "./controllable-state.mjs";
+import { n as useDragAndDrop } from "./drag-and-drop-C-nn7Yum.mjs";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, guardReactiveProps, mergeProps, nextTick, normalizeProps, normalizeStyle, onScopeDispose, openBlock, renderList, renderSlot, shallowRef, toDisplayString, toValue, unref, useTemplateRef, withCtx } from "vue";
+//#region src/families/date-time/scheduler/scheduler-context.ts
+const schedulerContext = createContext("Scheduler");
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-heading.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$7 = ["id"];
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-heading.vue
+var scheduler_heading_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "scheduler-heading",
+	setup(__props) {
+		const context = schedulerContext.use();
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("h2", {
+				id: unref(context).headingId.value,
+				"aria-live": "polite",
+				"aria-atomic": "true",
+				"data-vize-ui": "scheduler-heading",
+				part: "heading"
+			}, [renderSlot(_ctx.$slots, "default", { heading: unref(context).slotState.value.heading }, () => [createTextVNode(toDisplayString(unref(context).slotState.value.heading), 1)], true)], 8, _hoisted_1$7);
+		};
+	}
+}), [["__scopeId", "data-v-2ef52515"]]);
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-event.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$6 = [
+	"aria-label",
+	"aria-disabled",
+	"data-event-id",
+	"data-mode",
+	"data-all-day",
+	"data-continues-before",
+	"data-continues-after",
+	"data-dragging"
+];
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-event.vue
+var scheduler_event_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "scheduler-event",
+	props: {
+		event: {
+			type: Object,
+			required: true
+		},
+		placement: {
+			type: null,
+			required: false,
+			default: () => void 0
+		},
+		row: {
+			type: null,
+			required: false,
+			default: () => void 0
+		},
+		resizable: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	setup(__props) {
+		const context = schedulerContext.use();
+		const element = useTemplateRef("element");
+		const handle = useTemplateRef("handle");
+		const mode = computed(() => __props.placement ? "time" : "row");
+		const move = context.registerEventSource(() => __props.event.id, "move", element);
+		const resize = context.registerEventSource(() => __props.event.id, "resize", handle);
+		const label = computed(() => context.eventLabel(__props.event));
+		const locked = computed(() => context.slotState.value.readOnly || context.slotState.value.disabled);
+		const showHandle = computed(() => __props.resizable && __props.placement !== void 0 && !locked.value);
+		const style = computed(() => {
+			if (__props.placement) return {
+				"--vize-scheduler-top": `${__props.placement.top * 100}%`,
+				"--vize-scheduler-height": `${__props.placement.height * 100}%`,
+				"--vize-scheduler-column": String(__props.placement.column),
+				"--vize-scheduler-columns": String(__props.placement.columns),
+				"--vize-scheduler-span": String(__props.placement.span)
+			};
+			if (__props.row) return {
+				"--vize-scheduler-start": String(__props.row.startIndex + 1),
+				"--vize-scheduler-end": String(__props.row.endIndex + 2),
+				"--vize-scheduler-lane": String(__props.row.lane)
+			};
+			return {};
+		});
+		onScopeDispose(() => {
+			move.dispose();
+			resize.dispose();
+		});
+		function onClick(nativeEvent) {
+			context.onEventActivate(__props.event.id, nativeEvent);
+		}
+		function onKeydown(nativeEvent) {
+			context.onEventKeydown(__props.event.id, mode.value, nativeEvent);
+		}
+		function onPointerDown(nativeEvent) {
+			if (nativeEvent.currentTarget instanceof HTMLElement) context.onEventPointerDown(nativeEvent.clientY - nativeEvent.currentTarget.getBoundingClientRect().top);
+		}
+		function stop(nativeEvent) {
+			nativeEvent.stopPropagation();
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "element",
+				ref: element,
+				role: "button",
+				tabindex: "0",
+				"aria-label": label.value,
+				"aria-disabled": unref(context).slotState.value.disabled ? "true" : void 0,
+				"data-vize-ui": "scheduler-event",
+				part: "event",
+				"data-event-id": __props.event.id,
+				"data-mode": mode.value,
+				"data-all-day": __props.event.allDay ? "true" : void 0,
+				"data-continues-before": (__props.placement ?? __props.row)?.continuesBefore ? "true" : void 0,
+				"data-continues-after": (__props.placement ?? __props.row)?.continuesAfter ? "true" : void 0,
+				"data-dragging": unref(move).isDragging.value || unref(resize).isDragging.value ? "true" : void 0,
+				style: style.value
+			}, locked.value ? {} : unref(move).sourceProps, {
+				onClick,
+				onKeydown,
+				onPointerdown: onPointerDown
+			}), [renderSlot(_ctx.$slots, "default", {
+				event: __props.event,
+				placement: __props.placement,
+				row: __props.row,
+				label: label.value
+			}, () => [createTextVNode(toDisplayString(__props.event.title), 1)], true), showHandle.value ? (openBlock(), createElementBlock("span", mergeProps({
+				key: 0,
+				ref_key: "handle",
+				ref: handle,
+				"aria-hidden": "true",
+				"data-vize-ui": "scheduler-event-resize",
+				part: "resize-handle"
+			}, unref(resize).sourceProps, {
+				onPointerdown: stop,
+				onMousedown: stop,
+				onTouchstart: stop,
+				onClick: stop
+			}), null, 16)) : createCommentVNode("v-if", true)], 16, _hoisted_1$6);
+		};
+	}
+}), [["__scopeId", "data-v-eb688a9e"]]);
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-month-day.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$5 = [
+	"aria-current",
+	"data-date",
+	"data-outside-month",
+	"data-today",
+	"data-drop-target"
+];
+const _hoisted_2$3 = [
+	"tabindex",
+	"disabled",
+	"aria-label",
+	"data-date",
+	"data-focused"
+];
+const _hoisted_3$1 = ["data-count"];
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-month-day.vue
+var scheduler_month_day_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "scheduler-month-day",
+	props: {
+		week: {
+			type: Object,
+			required: true
+		},
+		index: {
+			type: Number,
+			required: true
+		}
+	},
+	setup(__props) {
+		const context = schedulerContext.use();
+		const element = useTemplateRef("element");
+		const day = computed(() => __props.week.days[__props.index] ?? null);
+		const target = context.registerDayTarget(() => day.value?.date ?? {
+			year: 1970,
+			month: 1,
+			day: 1
+		}, "day", element);
+		const placements = computed(() => __props.week.placements.filter((placement) => placement.lane < context.maxLanes.value && placement.startIndex === __props.index));
+		const overflow = computed(() => __props.week.overflow[__props.index] ?? 0);
+		const focused = computed(() => day.value !== null && day.value.iso === context.focusedIso.value);
+		onScopeDispose(() => target.dispose());
+		function onClick(event) {
+			if (day.value) context.onDayActivate(day.value.date, event);
+		}
+		function onKeydown(event) {
+			if (day.value) context.onDayKeydown(day.value.date, event);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("td", {
+				ref_key: "element",
+				ref: element,
+				"aria-current": day.value?.today ? "date" : void 0,
+				"data-vize-ui": "scheduler-month-cell",
+				part: "month-cell",
+				"data-date": day.value?.iso,
+				"data-outside-month": day.value?.outsideMonth ? "true" : void 0,
+				"data-today": day.value?.today ? "true" : void 0,
+				"data-drop-target": unref(target).isOver.value ? "true" : void 0
+			}, [
+				day.value ? (openBlock(), createElementBlock("button", {
+					key: 0,
+					type: "button",
+					tabindex: focused.value ? 0 : -1,
+					disabled: unref(context).slotState.value.disabled,
+					"aria-label": day.value.fullLabel,
+					"data-vize-ui": "scheduler-day",
+					part: "day",
+					"data-date": day.value.iso,
+					"data-focused": focused.value ? "true" : void 0,
+					onClick,
+					onKeydown
+				}, [renderSlot(_ctx.$slots, "day", normalizeProps(guardReactiveProps(day.value)), () => [createTextVNode(toDisplayString(day.value.dayLabel), 1)], true)], 40, _hoisted_2$3)) : createCommentVNode("v-if", true),
+				(openBlock(true), createElementBlock(Fragment, null, renderList(placements.value, (placement) => {
+					return openBlock(), createBlock(scheduler_event_default, {
+						key: placement.event.id,
+						event: placement.event,
+						row: placement
+					}, {
+						default: withCtx(() => [renderSlot(_ctx.$slots, "event", mergeProps({ ref_for: true }, placement), () => [createTextVNode(toDisplayString(placement.event.title), 1)], true)]),
+						_: 2
+					}, 1032, ["event", "row"]);
+				}), 128)),
+				overflow.value > 0 && day.value ? (openBlock(), createElementBlock("span", {
+					key: 1,
+					"data-vize-ui": "scheduler-more",
+					part: "more",
+					"data-count": overflow.value
+				}, [renderSlot(_ctx.$slots, "more", {
+					count: overflow.value,
+					day: day.value
+				}, () => [createTextVNode("+" + toDisplayString(overflow.value), 1)], true)], 8, _hoisted_3$1)) : createCommentVNode("v-if", true)
+			], 8, _hoisted_1$5);
+		};
+	}
+}), [["__scopeId", "data-v-df391d75"]]);
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-month-grid.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$4 = [
+	"aria-labelledby",
+	"aria-readonly",
+	"data-weeks"
+];
+const _hoisted_2$2 = {
+	"data-vize-ui": "scheduler-weekdays",
+	part: "weekdays"
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-month-grid.vue
+var scheduler_month_grid_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "scheduler-month-grid",
+	setup(__props) {
+		const context = schedulerContext.use();
+		const state = computed(() => context.slotState.value);
+		const headerDays = computed(() => state.value.weeks[0]?.days ?? []);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("table", {
+				role: "grid",
+				"aria-labelledby": unref(context).headingId.value,
+				"aria-readonly": state.value.readOnly ? "true" : void 0,
+				"data-vize-ui": "scheduler-month-grid",
+				part: "month-grid",
+				"data-weeks": state.value.weeks.length
+			}, [createElementVNode("thead", null, [createElementVNode("tr", _hoisted_2$2, [(openBlock(true), createElementBlock(Fragment, null, renderList(headerDays.value, (day) => {
+				return openBlock(), createElementBlock("th", {
+					key: day.iso,
+					scope: "col",
+					"data-vize-ui": "scheduler-weekday",
+					part: "weekday"
+				}, [renderSlot(_ctx.$slots, "weekday", mergeProps({ ref_for: true }, day), () => [createTextVNode(toDisplayString(day.weekdayLabel), 1)], true)]);
+			}), 128))])]), createElementVNode("tbody", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(state.value.weeks, (week, row) => {
+				return openBlock(), createElementBlock("tr", {
+					key: week.days[0]?.iso ?? row,
+					"data-vize-ui": "scheduler-week",
+					part: "week"
+				}, [(openBlock(true), createElementBlock(Fragment, null, renderList(week.days, (day, index) => {
+					return openBlock(), createBlock(scheduler_month_day_default, {
+						key: day.iso,
+						week,
+						index
+					}, {
+						day: withCtx((dayState) => [renderSlot(_ctx.$slots, "day", mergeProps({ ref_for: true }, dayState), () => [createTextVNode(toDisplayString(dayState.dayLabel), 1)], true)]),
+						event: withCtx((placement) => [renderSlot(_ctx.$slots, "event", mergeProps({ ref_for: true }, placement), () => [createTextVNode(toDisplayString(placement.event.title), 1)], true)]),
+						more: withCtx((more) => [renderSlot(_ctx.$slots, "more", mergeProps({ ref_for: true }, more), () => [createTextVNode("+" + toDisplayString(more.count), 1)], true)]),
+						_: 3
+					}, 8, ["week", "index"]);
+				}), 128))]);
+			}), 128))])], 8, _hoisted_1$4);
+		};
+	}
+}), [["__scopeId", "data-v-30c2ce1a"]]);
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-nav.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$3 = [
+	"disabled",
+	"aria-label",
+	"aria-controls",
+	"data-action"
+];
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-nav.vue
+var scheduler_nav_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "scheduler-nav",
+	props: {
+		action: {
+			type: String,
+			required: true
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		}
+	},
+	setup(__props) {
+		const context = schedulerContext.use();
+		const label = computed(() => __props.ariaLabel ?? {
+			previous: "Previous period",
+			next: "Next period",
+			today: "Today"
+		}[__props.action]);
+		function onClick() {
+			if (__props.action === "today") context.goToToday();
+			else context.navigate(__props.action === "previous" ? -1 : 1);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("button", {
+				type: "button",
+				disabled: !unref(context).canNavigate(),
+				"aria-label": label.value,
+				"aria-controls": unref(context).id.value,
+				"data-vize-ui": "scheduler-nav",
+				part: "nav",
+				"data-action": __props.action,
+				onClick
+			}, [renderSlot(_ctx.$slots, "default", { action: __props.action }, () => [createTextVNode(toDisplayString(__props.action === "previous" ? "‹" : __props.action === "next" ? "›" : label.value), 1)], true)], 8, _hoisted_1$3);
+		};
+	}
+}), [["__scopeId", "data-v-aa937aba"]]);
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-layout.ts
+/**
+* Pure, deterministic layout for scheduler views.
+*
+* Nothing here reads the clock, the DOM, or the host time zone: inputs are
+* plain dates and wall-clock date-times, so server and client compute
+* identical placements.
+*/
+function dayStart(day) {
+	return Object.freeze({
+		year: day.year,
+		month: day.month,
+		day: day.day,
+		hour: 0,
+		minute: 0,
+		second: 0
+	});
+}
+function sortEvents(left, right) {
+	return compareDateTimes(left.start, right.start) || compareDateTimes(right.end, left.end) || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+}
+/** Whether an event covers any part of `day` (all-day events cover whole days). */
+function eventTouchesDay(event, day) {
+	const start = dayStart(day);
+	const startOffset = minutesBetween(start, event.start);
+	const endOffset = minutesBetween(start, event.end);
+	if (endOffset <= startOffset) return startOffset >= 0 && startOffset < 1440;
+	return startOffset < 1440 && endOffset > 0;
+}
+/**
+* Lay out timed events for one day column.
+*
+* Events are sorted by start (longer first on ties), grouped into clusters of
+* transitively overlapping events, assigned the first free column, and then
+* widened to the right across columns that stay free for their whole span.
+*/
+function layoutTimeGrid(events, day, window = {}) {
+	const windowStart = Math.max(0, Math.trunc(window.startMinute ?? 0));
+	const windowEnd = Math.min(1440, Math.max(windowStart + 1, Math.trunc(window.endMinute ?? 1440)));
+	const minimum = Math.max(1, Math.trunc(window.minimumMinutes ?? 15));
+	const base = dayStart(day);
+	const items = events.filter((event) => event.allDay !== true && eventTouchesDay(event, day)).sort(sortEvents).flatMap((event) => {
+		const rawStart = minutesBetween(base, event.start);
+		const rawEnd = Math.max(rawStart, minutesBetween(base, event.end));
+		const startMinute = Math.max(windowStart, rawStart);
+		const endMinute = Math.min(windowEnd, Math.max(rawEnd, rawStart + minimum));
+		if (endMinute <= startMinute || startMinute >= windowEnd) return [];
+		return [{
+			event,
+			startMinute,
+			endMinute,
+			rawStart,
+			rawEnd,
+			column: 0
+		}];
+	});
+	const placements = [];
+	let cluster = [];
+	let clusterEnd = -1;
+	const flush = () => {
+		const columnEnds = [];
+		for (const item of cluster) {
+			let column = columnEnds.findIndex((end) => end <= item.startMinute);
+			if (column === -1) column = columnEnds.length;
+			columnEnds[column] = item.endMinute;
+			item.column = column;
+		}
+		const columns = Math.max(1, columnEnds.length);
+		for (const item of cluster) {
+			let span = 1;
+			while (item.column + span < columns) {
+				const next = item.column + span;
+				if (cluster.some((other) => other !== item && other.column === next && other.startMinute < item.endMinute && other.endMinute > item.startMinute)) break;
+				span += 1;
+			}
+			const size = windowEnd - windowStart;
+			placements.push(Object.freeze({
+				event: item.event,
+				day: formatIsoDate(day),
+				startMinute: item.startMinute,
+				endMinute: item.endMinute,
+				column: item.column,
+				columns,
+				span,
+				top: (item.startMinute - windowStart) / size,
+				height: (item.endMinute - item.startMinute) / size,
+				continuesBefore: item.rawStart < item.startMinute,
+				continuesAfter: item.rawEnd > item.endMinute
+			}));
+		}
+		cluster = [];
+		clusterEnd = -1;
+	};
+	for (const item of items) {
+		if (cluster.length > 0 && item.startMinute >= clusterEnd) flush();
+		cluster.push(item);
+		clusterEnd = Math.max(clusterEnd, item.endMinute);
+	}
+	if (cluster.length > 0) flush();
+	return placements;
+}
+/**
+* Stack events across a row of consecutive days into lanes.
+*
+* Used for all-day lanes above a time grid and for month-view week rows.
+* Longer events claim lower lanes first so bars stay aligned.
+*/
+function layoutRow(events, days, filter = () => true) {
+	const first = days[0];
+	const last = days.at(-1);
+	if (!first || !last) return [];
+	const spans = events.filter(filter).flatMap((event) => {
+		const indexes = days.flatMap((day, index) => eventTouchesDay(event, day) ? [index] : []);
+		const startIndex = indexes[0];
+		const endIndex = indexes.at(-1);
+		if (startIndex === void 0 || endIndex === void 0) return [];
+		return [{
+			event,
+			startIndex,
+			endIndex
+		}];
+	}).sort((left, right) => left.startIndex - right.startIndex || right.endIndex - right.startIndex - (left.endIndex - left.startIndex) || sortEvents(left.event, right.event));
+	const laneEnds = [];
+	return spans.map(({ event, startIndex, endIndex }) => {
+		let lane = laneEnds.findIndex((end) => end < startIndex);
+		if (lane === -1) lane = laneEnds.length;
+		laneEnds[lane] = endIndex;
+		return Object.freeze({
+			event,
+			startIndex,
+			endIndex,
+			lane,
+			continuesBefore: compareDates(event.start, first) < 0,
+			continuesAfter: minutesBetween(dayStart(addDays(last, 1)), event.end) > 0
+		});
+	});
+}
+/** Days rendered by a view anchored at `date`. */
+function visibleDays(view, date, weekStartsOn) {
+	if (view === "day") return [date];
+	if (view === "week") {
+		const start = startOfWeek(date, weekStartsOn);
+		return Array.from({ length: 7 }, (_, index) => addDays(start, index));
+	}
+	const start = startOfWeek(startOfMonth(date), weekStartsOn);
+	const end = endOfWeek(endOfMonth(date), weekStartsOn);
+	return Array.from({ length: daysBetween(start, end) + 1 }, (_, index) => addDays(start, index));
+}
+/** Split month-view days into week rows and flag days outside the anchor month. */
+function monthWeeks(days, anchor) {
+	const weeks = [];
+	days.forEach((date, index) => {
+		(weeks[Math.floor(index / 7)] ??= []).push({
+			date,
+			outsideMonth: !isSameMonth(date, anchor)
+		});
+	});
+	return weeks;
+}
+/** Move the view anchor by one period. */
+function shiftAnchor(view, date, step) {
+	if (view === "day") return addDays(date, step);
+	if (view === "week") return addDays(date, step * 7);
+	const shifted = {
+		year: date.year,
+		month: date.month + step,
+		day: 1
+	};
+	const year = shifted.year + Math.floor((shifted.month - 1) / 12);
+	const month = ((shifted.month - 1) % 12 + 12) % 12 + 1;
+	return Object.freeze({
+		year,
+		month,
+		day: Math.min(date.day, endOfMonth({
+			year,
+			month
+		}).day)
+	});
+}
+/** Snap a minute of day to a multiple of `step` inside `[min, max]`. */
+function snapMinute(minute, step, min, max) {
+	const size = Math.max(1, Math.trunc(step));
+	const snapped = Math.round(minute / size) * size;
+	return Math.min(max, Math.max(min, snapped));
+}
+/**
+* Minute of day under a client Y coordinate inside a day column rectangle,
+* snapped down to `step` inside the visible window.
+*/
+function minuteAtPoint(y, rect, window) {
+	const height = rect.bottom - rect.top;
+	const ratio = height > 0 ? (y - rect.top) / height : 0;
+	const minute = window.startMinute + ratio * (window.endMinute - window.startMinute);
+	const step = Math.max(1, Math.trunc(window.step));
+	const floored = Math.floor(minute / step) * step;
+	return Math.min(window.endMinute - step, Math.max(window.startMinute, floored));
+}
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-runtime.ts
+const dragKinds = {
+	move: "vize-scheduler-move",
+	resize: "vize-scheduler-resize"
+};
+function clampInteger(value, fallback, min, max) {
+	if (value === void 0 || !Number.isFinite(value)) return fallback;
+	return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+function dayDateTime(date, minute) {
+	return combineDateTime(date, {
+		hour: Math.floor(minute / 60),
+		minute: minute % 60,
+		second: 0
+	});
+}
+/**
+* Scheduler state machine: views, SSR-safe anchoring, pure layouts, roving
+* keyboard focus, and drag/keyboard move and resize requests. Must run in setup.
+*/
+function useScheduler(props, emit, root) {
+	const localeValue = useLocaleValue();
+	const id = useDeterministicId({
+		id: () => props.id,
+		hint: "scheduler"
+	});
+	const headingId = computed(() => deriveDeterministicId(id.value, "heading"));
+	const locale = computed(() => resolveLocale(props.locale ?? localeValue.value.locale));
+	const direction = computed(() => props.dir === "rtl" || props.dir === "ltr" ? props.dir : localeValue.value.direction);
+	const formatters = computed(() => createCalendarFormatters({
+		locale: locale.value,
+		calendar: localeValue.value.calendar
+	}));
+	const weekStartsOn = computed(() => normalizeWeekday(props.weekStartsOn, locale.value));
+	const disabled = computed(() => props.disabled === true);
+	const readOnly = computed(() => props.readOnly === true);
+	const windowStart = computed(() => clampInteger(props.dayStartHour, 0, 0, 23) * 60);
+	const windowEnd = computed(() => Math.max(windowStart.value + 60, clampInteger(props.dayEndHour, 24, 1, 24) * 60));
+	const slotMinutes = computed(() => clampInteger(props.slotMinutes, 30, 5, 240));
+	const snapMinutes = computed(() => clampInteger(props.snapMinutes, slotMinutes.value, 1, 240));
+	const maxLanes = computed(() => clampInteger(props.maxLanes, 3, 1, 50));
+	const today = useToday({
+		today: () => props.today,
+		now: () => props.now,
+		timeZone: () => props.timeZone
+	});
+	const viewState = useControllableState({
+		value: () => props.view,
+		defaultValue: () => props.defaultView ?? "week",
+		onChange: (value) => emit.view(value)
+	});
+	const internalDate = shallowRef(normalizePlainDate(props.defaultDate));
+	const anchor = computed(() => normalizePlainDate(props.date) ?? internalDate.value ?? today.value);
+	const view = computed(() => viewState.value.value);
+	const events = computed(() => props.events ?? []);
+	const focusedDate = shallowRef(null);
+	const focusedMinuteState = shallowRef(null);
+	const timeFormatter = computed(() => {
+		try {
+			return new Intl.DateTimeFormat(locale.value, {
+				timeStyle: "short",
+				timeZone: "UTC"
+			});
+		} catch {
+			return new Intl.DateTimeFormat("en-US", {
+				timeStyle: "short",
+				timeZone: "UTC"
+			});
+		}
+	});
+	const headerFormatter = computed(() => {
+		try {
+			return new Intl.DateTimeFormat(locale.value, {
+				weekday: "short",
+				day: "numeric",
+				timeZone: "UTC"
+			});
+		} catch {
+			return new Intl.DateTimeFormat("en-US", {
+				weekday: "short",
+				day: "numeric",
+				timeZone: "UTC"
+			});
+		}
+	});
+	const weekdayFormatter = computed(() => {
+		try {
+			return new Intl.DateTimeFormat(locale.value, {
+				weekday: "short",
+				timeZone: "UTC"
+			});
+		} catch {
+			return new Intl.DateTimeFormat("en-US", {
+				weekday: "short",
+				timeZone: "UTC"
+			});
+		}
+	});
+	const rangeFormatter = computed(() => {
+		const options = {
+			month: "short",
+			day: "numeric",
+			year: "numeric",
+			timeZone: "UTC"
+		};
+		try {
+			return new Intl.DateTimeFormat(locale.value, options);
+		} catch {
+			return new Intl.DateTimeFormat("en-US", options);
+		}
+	});
+	function timeLabel(minute) {
+		return timeFormatter.value.format(Date.UTC(2001, 0, 1, Math.floor(minute / 60), minute % 60));
+	}
+	const dates = computed(() => anchor.value ? visibleDays(view.value, anchor.value, weekStartsOn.value) : []);
+	function dayState(date, outsideMonth) {
+		const utc = toUtcDate(date);
+		return {
+			date,
+			iso: formatIsoDate(date),
+			label: headerFormatter.value.format(utc),
+			weekdayLabel: weekdayFormatter.value.format(utc),
+			fullLabel: formatters.value.fullDate(date),
+			dayLabel: formatters.value.day(date),
+			today: isSameDay(date, today.value),
+			outsideMonth
+		};
+	}
+	const days = computed(() => dates.value.map((date) => dayState(date, view.value === "month" && anchor.value !== null && date.month !== anchor.value.month)));
+	const slots = computed(() => {
+		const rows = [];
+		for (let minute = windowStart.value; minute < windowEnd.value; minute += slotMinutes.value) rows.push({
+			minute,
+			label: timeLabel(minute)
+		});
+		return rows;
+	});
+	const columns = computed(() => view.value === "month" ? [] : days.value.map((day) => ({
+		day,
+		placements: layoutTimeGrid(events.value, day.date, {
+			startMinute: windowStart.value,
+			endMinute: windowEnd.value,
+			minimumMinutes: props.minimumEventMinutes ?? 15
+		})
+	})));
+	const allDay = computed(() => view.value === "month" ? [] : layoutRow(events.value, dates.value, (event) => event.allDay === true));
+	const weeks = computed(() => {
+		if (view.value !== "month" || !anchor.value) return [];
+		return monthWeeks(dates.value, anchor.value).map((week) => {
+			const weekDays = week.map((entry) => dayState(entry.date, entry.outsideMonth));
+			const placements = layoutRow(events.value, week.map((entry) => entry.date));
+			return {
+				days: weekDays,
+				placements,
+				overflow: weekDays.map((_, index) => placements.filter((placement) => placement.lane >= maxLanes.value && placement.startIndex <= index && placement.endIndex >= index).length)
+			};
+		});
+	});
+	const heading = computed(() => {
+		const first = dates.value[0];
+		const last = dates.value.at(-1);
+		const current = anchor.value;
+		if (!first || !last || !current) return "";
+		if (view.value === "day") return formatters.value.fullDate(current);
+		if (view.value === "month") return formatters.value.monthYear(current);
+		return rangeFormatter.value.formatRange(toUtcDate(first), toUtcDate(last));
+	});
+	const pending = computed(() => anchor.value === null);
+	const state = computed(() => {
+		if (disabled.value) return "disabled";
+		if (pending.value) return "pending";
+		return readOnly.value ? "readonly" : "ready";
+	});
+	const focusedIso = computed(() => {
+		const visible = dates.value;
+		const candidate = focusedDate.value ?? anchor.value;
+		const fallback = (candidate ? visible.find((date) => isSameDay(date, candidate)) : void 0) ?? visible.find((date) => view.value !== "month" || date.month === anchor.value?.month);
+		return fallback ? formatIsoDate(fallback) : null;
+	});
+	const focusedMinute = computed(() => {
+		const minute = focusedMinuteState.value ?? windowStart.value;
+		const lastSlot = slots.value.at(-1)?.minute ?? windowStart.value;
+		return Math.min(lastSlot, Math.max(windowStart.value, minute));
+	});
+	const slotState = computed(() => ({
+		view: view.value,
+		date: anchor.value,
+		today: today.value,
+		heading: heading.value,
+		days: days.value,
+		slots: slots.value,
+		columns: columns.value,
+		allDay: allDay.value,
+		weeks: weeks.value,
+		locale: locale.value,
+		direction: direction.value,
+		disabled: disabled.value,
+		readOnly: readOnly.value,
+		pending: pending.value,
+		state: state.value
+	}));
+	function setDate(date) {
+		const normalized = normalizePlainDate(date);
+		if (!normalized) return;
+		internalDate.value = normalized;
+		emit.date(normalized);
+	}
+	function navigate(step) {
+		const current = anchor.value;
+		if (!current || disabled.value) return false;
+		const next = shiftAnchor(view.value, current, step);
+		focusedDate.value = focusedDate.value ? shiftAnchor(view.value, focusedDate.value, step) : next;
+		setDate(next);
+		return true;
+	}
+	function goToToday() {
+		const current = today.value;
+		if (!current || disabled.value || isSameDay(current, anchor.value)) return false;
+		focusedDate.value = current;
+		setDate(current);
+		return true;
+	}
+	function focusCell() {
+		const iso = focusedIso.value;
+		if (!iso || !root.value) return false;
+		const selector = view.value === "month" ? `[data-vize-ui="scheduler-day"][data-date="${iso}"]` : `[data-vize-ui="scheduler-slot"][data-date="${iso}"][data-minute="${focusedMinute.value}"]`;
+		const element = root.value.querySelector(selector);
+		if (!(element instanceof HTMLElement)) return false;
+		element.focus();
+		return true;
+	}
+	function moveFocus(date, minute) {
+		focusedDate.value = date;
+		if (minute !== null) focusedMinuteState.value = minute;
+		const visible = dates.value;
+		const first = visible[0];
+		const last = visible.at(-1);
+		const current = anchor.value;
+		if (view.value === "month" && current !== null && (date.month !== current.month || date.year !== current.year) || first && last && (daysBetween(first, date) < 0 || daysBetween(last, date) > 0)) setDate(date);
+		nextTick(() => focusCell());
+	}
+	function horizontal(event) {
+		const sign = direction.value === "rtl" ? -1 : 1;
+		return event.key === "ArrowRight" ? sign : -sign;
+	}
+	function onSlotKeydown(date, minute, event) {
+		if (disabled.value) return;
+		const lastSlot = slots.value.at(-1)?.minute ?? windowStart.value;
+		switch (event.key) {
+			case "ArrowUp":
+				moveFocus(date, Math.max(windowStart.value, minute - slotMinutes.value));
+				break;
+			case "ArrowDown":
+				moveFocus(date, Math.min(lastSlot, minute + slotMinutes.value));
+				break;
+			case "ArrowLeft":
+			case "ArrowRight":
+				moveFocus(addDays(date, horizontal(event)), minute);
+				break;
+			case "Home":
+				moveFocus(date, windowStart.value);
+				break;
+			case "End":
+				moveFocus(date, lastSlot);
+				break;
+			case "PageUp":
+			case "PageDown":
+				moveFocus(shiftAnchor(view.value, date, event.key === "PageUp" ? -1 : 1), minute);
+				break;
+			case "Enter":
+			case " ":
+				onSlotActivate(date, minute, event);
+				break;
+			default: return;
+		}
+		event.preventDefault();
+	}
+	function onSlotActivate(date, minute, event) {
+		if (disabled.value) return;
+		focusedDate.value = date;
+		focusedMinuteState.value = minute;
+		const start = dayDateTime(date, minute);
+		emit.slotActivate({
+			start,
+			end: addMinutes(start, slotMinutes.value)
+		}, event);
+	}
+	function onDayKeydown(date, event) {
+		if (disabled.value) return;
+		switch (event.key) {
+			case "ArrowUp":
+				moveFocus(addDays(date, -7), null);
+				break;
+			case "ArrowDown":
+				moveFocus(addDays(date, 7), null);
+				break;
+			case "ArrowLeft":
+			case "ArrowRight":
+				moveFocus(addDays(date, horizontal(event)), null);
+				break;
+			case "Home":
+				moveFocus(startOfWeek(date, weekStartsOn.value), null);
+				break;
+			case "End":
+				moveFocus(endOfWeek(date, weekStartsOn.value), null);
+				break;
+			case "PageUp":
+			case "PageDown":
+				moveFocus(shiftAnchor("month", date, event.key === "PageUp" ? -1 : 1), null);
+				break;
+			case "Enter":
+			case " ":
+				onDayActivate(date, event);
+				break;
+			default: return;
+		}
+		event.preventDefault();
+	}
+	function onDayActivate(date, event) {
+		if (disabled.value) return;
+		focusedDate.value = date;
+		emit.dayActivate(date, event);
+	}
+	function findEvent(eventId) {
+		return events.value.find((candidate) => candidate.id === eventId);
+	}
+	function onEventActivate(eventId, event) {
+		const found = findEvent(eventId);
+		if (found && !disabled.value) emit.eventActivate(found, event);
+	}
+	function requestMove(found, start, event) {
+		const duration = Math.max(0, minutesBetween(found.start, found.end));
+		emit.eventMove({
+			event: found,
+			start,
+			end: addMinutes(start, duration)
+		}, event);
+	}
+	function requestResize(found, end, event) {
+		const minimumEnd = addMinutes(found.start, snapMinutes.value);
+		const next = minutesBetween(minimumEnd, end) < 0 ? minimumEnd : end;
+		emit.eventResize({
+			event: found,
+			start: found.start,
+			end: next
+		}, event);
+	}
+	function onEventKeydown(eventId, mode, event) {
+		if (event.key === "Enter" || event.key === " ") {
+			event.preventDefault();
+			onEventActivate(eventId, event);
+			return;
+		}
+		if (!event.altKey || disabled.value || readOnly.value) return;
+		const found = findEvent(eventId);
+		if (!found) return;
+		const vertical = mode === "time" ? snapMinutes.value : 7 * 1440;
+		let delta = 0;
+		if (event.key === "ArrowUp") delta = -vertical;
+		else if (event.key === "ArrowDown") delta = vertical;
+		else if (event.key === "ArrowLeft" || event.key === "ArrowRight") delta = horizontal(event) * 1440;
+		else return;
+		event.preventDefault();
+		if (event.shiftKey && mode === "time" && (event.key === "ArrowUp" || event.key === "ArrowDown")) {
+			requestResize(found, addMinutes(found.end, delta), event);
+			return;
+		}
+		requestMove(found, addMinutes(found.start, delta), event);
+	}
+	let grabOffset = 0;
+	const dragAndDrop = useDragAndDrop({ isDisabled: () => disabled.value || readOnly.value });
+	function onEventPointerDown(offset) {
+		grabOffset = Number.isFinite(offset) ? offset : 0;
+	}
+	function registerEventSource(eventId, kind, element) {
+		const key = `${kind}:${toValue(eventId)}`;
+		return dragAndDrop.registerSource({
+			key,
+			element,
+			keyboard: false,
+			payload: () => ({
+				kind: dragKinds[kind],
+				data: { eventId: toValue(eventId) }
+			}),
+			label: () => findEvent(toValue(eventId))?.title ?? toValue(eventId)
+		});
+	}
+	function registerDayTarget(date, mode, element) {
+		const target = () => toValue(date);
+		return dragAndDrop.registerTarget({
+			key: `${mode}:${formatIsoDate(target())}`,
+			element,
+			accepts: (payload) => payload !== null && (payload.kind === dragKinds.move || mode === "time" && payload.kind === dragKinds.resize),
+			onDrop: (event) => {
+				const payload = event.payload;
+				const found = payload ? findEvent(payload.data.eventId) : void 0;
+				if (!payload || !found) return;
+				const day = target();
+				if (mode === "day") {
+					const offset = daysBetween(found.start, day);
+					requestMove(found, addMinutes(found.start, offset * 1440), event.originalEvent);
+					return;
+				}
+				const rect = element.value?.getBoundingClientRect();
+				if (!rect || event.y === null) return;
+				const pixelsPerMinute = (rect.bottom - rect.top) / (windowEnd.value - windowStart.value);
+				const grabMinutes = pixelsPerMinute > 0 ? grabOffset / pixelsPerMinute : 0;
+				const pointerMinute = minuteAtPoint(event.y, rect, {
+					startMinute: windowStart.value,
+					endMinute: windowEnd.value,
+					step: snapMinutes.value
+				});
+				if (payload.kind === dragKinds.resize) {
+					requestResize(found, dayDateTime(day, pointerMinute + snapMinutes.value), event.originalEvent);
+					return;
+				}
+				requestMove(found, dayDateTime(day, Math.max(windowStart.value, Math.round((pointerMinute - grabMinutes) / snapMinutes.value) * snapMinutes.value)), event.originalEvent);
+			}
+		});
+	}
+	function eventLabel(event) {
+		if (event.allDay === true) return event.title;
+		const start = timeLabel(event.start.hour * 60 + event.start.minute);
+		const end = timeLabel(event.end.hour * 60 + event.end.minute);
+		return `${event.title}, ${start} – ${end}`;
+	}
+	return {
+		context: schedulerContext.provide({
+			id,
+			headingId,
+			root,
+			slotState,
+			focusedIso,
+			focusedMinute,
+			windowStart,
+			windowEnd,
+			slotMinutes,
+			maxLanes,
+			eventLabel,
+			canNavigate: () => anchor.value !== null && !disabled.value,
+			navigate,
+			goToToday,
+			onSlotKeydown,
+			onSlotActivate,
+			onDayKeydown,
+			onDayActivate,
+			onEventActivate,
+			onEventKeydown,
+			onEventPointerDown,
+			registerEventSource,
+			registerDayTarget
+		}),
+		exposed: {
+			root,
+			view,
+			date: anchor,
+			today,
+			heading,
+			days,
+			slots,
+			columns,
+			allDay,
+			weeks,
+			locale,
+			direction,
+			disabled,
+			readOnly,
+			pending,
+			state,
+			navigate,
+			goToToday,
+			setView: (next) => {
+				viewState.set(next);
+			},
+			setDate,
+			focus: () => focusCell()
+		},
+		id,
+		headingId,
+		slotState,
+		direction,
+		dragAndDrop
+	};
+}
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-day-column.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$2 = [
+	"aria-label",
+	"data-date",
+	"data-today",
+	"data-drop-target"
+];
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-day-column.vue
+var scheduler_day_column_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "scheduler-day-column",
+	props: { column: {
+		type: Object,
+		required: true
+	} },
+	setup(__props) {
+		const context = schedulerContext.use();
+		const element = useTemplateRef("element");
+		const target = context.registerDayTarget(() => __props.column.day.date, "time", element);
+		onScopeDispose(() => target.dispose());
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "element",
+				ref: element,
+				role: "group",
+				"aria-label": __props.column.day.fullLabel,
+				"data-vize-ui": "scheduler-day-column",
+				part: "day-column",
+				"data-date": __props.column.day.iso,
+				"data-today": __props.column.day.today ? "true" : void 0,
+				"data-drop-target": unref(target).isOver.value ? "true" : void 0
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.column.placements, (placement) => {
+				return openBlock(), createBlock(scheduler_event_default, {
+					key: placement.event.id,
+					event: placement.event,
+					placement
+				}, {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "event", mergeProps({ ref_for: true }, placement), () => [createTextVNode(toDisplayString(placement.event.title), 1)], true)]),
+					_: 2
+				}, 1032, ["event", "placement"]);
+			}), 128))], 8, _hoisted_1$2);
+		};
+	}
+}), [["__scopeId", "data-v-19c5c2c6"]]);
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-time-grid.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1$1 = ["data-view", "data-pending"];
+const _hoisted_2$1 = ["aria-labelledby", "aria-readonly"];
+const _hoisted_3 = {
+	"data-vize-ui": "scheduler-day-headers",
+	part: "day-headers"
+};
+const _hoisted_4 = {
+	scope: "col",
+	"data-vize-ui": "scheduler-corner",
+	part: "corner"
+};
+const _hoisted_5 = [
+	"abbr",
+	"aria-current",
+	"data-date",
+	"data-today"
+];
+const _hoisted_6 = ["data-minute"];
+const _hoisted_7 = {
+	scope: "row",
+	"data-vize-ui": "scheduler-time",
+	part: "time"
+};
+const _hoisted_8 = [
+	"tabindex",
+	"disabled",
+	"aria-label",
+	"data-date",
+	"data-minute",
+	"data-today",
+	"data-focused",
+	"onClick",
+	"onKeydown"
+];
+const _hoisted_9 = ["aria-label"];
+const _hoisted_10 = {
+	"data-vize-ui": "scheduler-event-layer",
+	part: "event-layer"
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-time-grid.vue
+var scheduler_time_grid_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "scheduler-time-grid",
+	props: {
+		timeHeader: {
+			type: String,
+			required: false,
+			default: "Time"
+		},
+		allDayLabel: {
+			type: String,
+			required: false,
+			default: "All day"
+		}
+	},
+	setup(__props) {
+		const context = schedulerContext.use();
+		const state = computed(() => context.slotState.value);
+		const gridStyle = computed(() => ({
+			"--vize-scheduler-days": String(state.value.days.length),
+			"--vize-scheduler-slots": String(state.value.slots.length)
+		}));
+		function isFocused(day, slot) {
+			return day.iso === context.focusedIso.value && slot.minute === context.focusedMinute.value;
+		}
+		function onSlotClick(day, slot, event) {
+			context.onSlotActivate(day.date, slot.minute, event);
+		}
+		function onSlotKeydown(day, slot, event) {
+			context.onSlotKeydown(day.date, slot.minute, event);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-vize-ui": "scheduler-time-grid",
+				part: "time-grid",
+				"data-view": state.value.view,
+				"data-pending": state.value.pending ? "true" : void 0,
+				style: normalizeStyle(gridStyle.value)
+			}, [
+				createElementVNode("table", {
+					role: "grid",
+					"aria-labelledby": unref(context).headingId.value,
+					"aria-readonly": state.value.readOnly ? "true" : void 0,
+					"data-vize-ui": "scheduler-slot-grid",
+					part: "slot-grid"
+				}, [createElementVNode("thead", null, [createElementVNode("tr", _hoisted_3, [createElementVNode("th", _hoisted_4, toDisplayString(__props.timeHeader), 1), (openBlock(true), createElementBlock(Fragment, null, renderList(state.value.days, (day) => {
+					return openBlock(), createElementBlock("th", {
+						key: day.iso,
+						scope: "col",
+						abbr: day.fullLabel,
+						"aria-current": day.today ? "date" : void 0,
+						"data-vize-ui": "scheduler-day-header",
+						part: "day-header",
+						"data-date": day.iso,
+						"data-today": day.today ? "true" : void 0
+					}, [renderSlot(_ctx.$slots, "dayHeader", mergeProps({ ref_for: true }, day), () => [createTextVNode(toDisplayString(day.label), 1)], true)], 8, _hoisted_5);
+				}), 128))])]), createElementVNode("tbody", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(state.value.slots, (slot) => {
+					return openBlock(), createElementBlock("tr", {
+						key: slot.minute,
+						"data-vize-ui": "scheduler-slot-row",
+						part: "slot-row",
+						"data-minute": slot.minute
+					}, [createElementVNode("th", _hoisted_7, [renderSlot(_ctx.$slots, "time", mergeProps({ ref_for: true }, slot), () => [createTextVNode(toDisplayString(slot.label), 1)], true)]), (openBlock(true), createElementBlock(Fragment, null, renderList(state.value.days, (day) => {
+						return openBlock(), createElementBlock("td", {
+							key: day.iso,
+							"data-vize-ui": "scheduler-slot-cell",
+							part: "slot-cell"
+						}, [createElementVNode("button", {
+							type: "button",
+							tabindex: isFocused(day, slot) ? 0 : -1,
+							disabled: state.value.disabled,
+							"aria-label": `${day.fullLabel} ${slot.label}`,
+							"data-vize-ui": "scheduler-slot",
+							part: "slot",
+							"data-date": day.iso,
+							"data-minute": slot.minute,
+							"data-today": day.today ? "true" : void 0,
+							"data-focused": isFocused(day, slot) ? "true" : void 0,
+							onClick: (event) => onSlotClick(day, slot, event),
+							onKeydown: (event) => onSlotKeydown(day, slot, event)
+						}, null, 40, _hoisted_8)]);
+					}), 128))], 8, _hoisted_6);
+				}), 128))])], 8, _hoisted_2$1),
+				state.value.allDay.length > 0 ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					role: "group",
+					"aria-label": __props.allDayLabel,
+					"data-vize-ui": "scheduler-all-day",
+					part: "all-day"
+				}, [(openBlock(true), createElementBlock(Fragment, null, renderList(state.value.allDay, (row) => {
+					return openBlock(), createBlock(scheduler_event_default, {
+						key: row.event.id,
+						event: row.event,
+						row
+					}, {
+						default: withCtx(() => [renderSlot(_ctx.$slots, "allDayEvent", mergeProps({ ref_for: true }, row), () => [createTextVNode(toDisplayString(row.event.title), 1)], true)]),
+						_: 2
+					}, 1032, ["event", "row"]);
+				}), 128))], 8, _hoisted_9)) : createCommentVNode("v-if", true),
+				createElementVNode("div", _hoisted_10, [(openBlock(true), createElementBlock(Fragment, null, renderList(state.value.columns, (column) => {
+					return openBlock(), createBlock(scheduler_day_column_default, {
+						key: column.day.iso,
+						column
+					}, {
+						event: withCtx((placement) => [renderSlot(_ctx.$slots, "event", mergeProps({ ref_for: true }, placement), () => [createTextVNode(toDisplayString(placement.event.title), 1)], true)]),
+						_: 3
+					}, 8, ["column"]);
+				}), 128))])
+			], 12, _hoisted_1$1);
+		};
+	}
+}), [["__scopeId", "data-v-22c4397d"]]);
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-root.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"id",
+	"dir",
+	"aria-label",
+	"data-state",
+	"data-view",
+	"data-dir",
+	"data-disabled",
+	"data-readonly",
+	"data-pending"
+];
+const _hoisted_2 = {
+	"data-vize-ui": "scheduler-header",
+	part: "header"
+};
+//#endregion
+//#region src/families/date-time/scheduler/scheduler-root.vue
+var scheduler_root_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "scheduler-root",
+	props: {
+		id: {
+			type: null,
+			required: false
+		},
+		events: {
+			type: null,
+			required: false
+		},
+		view: {
+			type: null,
+			required: false
+		},
+		defaultView: {
+			type: null,
+			required: false
+		},
+		date: {
+			type: null,
+			required: false
+		},
+		defaultDate: {
+			type: null,
+			required: false
+		},
+		today: {
+			type: null,
+			required: false
+		},
+		now: {
+			type: Function,
+			required: false,
+			skipCheck: true
+		},
+		timeZone: {
+			type: null,
+			required: false
+		},
+		locale: {
+			type: null,
+			required: false
+		},
+		dir: {
+			type: null,
+			required: false
+		},
+		weekStartsOn: {
+			type: null,
+			required: false
+		},
+		dayStartHour: {
+			type: null,
+			required: false
+		},
+		dayEndHour: {
+			type: null,
+			required: false
+		},
+		slotMinutes: {
+			type: null,
+			required: false
+		},
+		snapMinutes: {
+			type: null,
+			required: false
+		},
+		minimumEventMinutes: {
+			type: null,
+			required: false
+		},
+		maxLanes: {
+			type: null,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			skipCheck: true
+		},
+		readOnly: {
+			type: Boolean,
+			required: false,
+			skipCheck: true
+		},
+		ariaLabel: {
+			type: null,
+			required: false
+		}
+	},
+	emits: [
+		"update:view",
+		"update:date",
+		"event-activate",
+		"slot-activate",
+		"day-activate",
+		"event-move",
+		"event-resize"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const root = useTemplateRef("root");
+		const { id, slotState, direction, exposed } = useScheduler(props, {
+			view: (view) => emit("update:view", view),
+			date: (date) => emit("update:date", date),
+			eventActivate: (event, nativeEvent) => emit("event-activate", event, nativeEvent),
+			slotActivate: (range, nativeEvent) => emit("slot-activate", range, nativeEvent),
+			dayActivate: (date, nativeEvent) => emit("day-activate", date, nativeEvent),
+			eventMove: (change, nativeEvent) => emit("event-move", change, nativeEvent),
+			eventResize: (change, nativeEvent) => emit("event-resize", change, nativeEvent)
+		}, root);
+		__expose(exposed);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				id: unref(id),
+				ref_key: "root",
+				ref: root,
+				part: "root",
+				role: "region",
+				dir: unref(direction),
+				"aria-label": props.ariaLabel,
+				"aria-roledescription": "scheduler",
+				"data-vize-ui": "scheduler",
+				"data-state": unref(slotState).state,
+				"data-view": unref(slotState).view,
+				"data-dir": unref(direction),
+				"data-disabled": unref(slotState).disabled ? "true" : void 0,
+				"data-readonly": unref(slotState).readOnly ? "true" : void 0,
+				"data-pending": unref(slotState).pending ? "true" : void 0
+			}, [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(slotState))), () => [createElementVNode("div", _hoisted_2, [
+				createVNode(scheduler_nav_default, { action: "previous" }),
+				createVNode(scheduler_nav_default, { action: "today" }),
+				createVNode(scheduler_nav_default, { action: "next" }),
+				createVNode(scheduler_heading_default)
+			]), unref(slotState).view === "month" ? (openBlock(), createBlock(scheduler_month_grid_default, { key: 0 })) : (openBlock(), createBlock(scheduler_time_grid_default, { key: 1 }))], true)], 8, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-426cc9a9"]]);
+//#endregion
+export { layoutRow as a, monthWeeks as c, visibleDays as d, scheduler_nav_default as f, scheduler_heading_default as g, scheduler_event_default as h, eventTouchesDay as i, shiftAnchor as l, scheduler_month_day_default as m, scheduler_time_grid_default as n, layoutTimeGrid as o, scheduler_month_grid_default as p, scheduler_day_column_default as r, minuteAtPoint as s, scheduler_root_default as t, snapMinute as u };