@chelone/vue 0.6.0 → 0.9.0

package/dist/components/admin/list/calendar-list.vue.d.ts

@@ -1,38 +1,17 @@
-/**
- * `<CalendarList>` — the records of the ambient `<List>` as events in a month
- * grid, or in a week of hour rows, or in an agenda. The Vue analog of `@chelone/react`'s `list/calendar-list.tsx`. It asks
- * the list for the visible range (and `perPage` records), so moving to another
- * month refetches; it removes that filter and restores `perPage` when it
- * unmounts. The filters the user set stay.
- *
- * Emits `select-event` with the record when an event is activated; with no
- * listener attached, the event navigates to the record's edit or show page.
- * Emits `select-slot` with `{ startISO, endISO, allDay }` when an empty part of
- * a day is clicked. With a `drop` listener attached, month-view events can be
- * dragged to another day; `drop` carries the record and its new `{ start, end? }`
- * as ISO strings and the list is not updated. A promise the listener returns is
- * the caller's to handle. The `#event` slot replaces an event and the `#header` slot
- * the title and navigation.
- *
- * @example
- * <List>
- *   <CalendarList start-source="starts_at" end-source="ends_at" title-source="name" />
- * </List>
- */
-import { type LooseRecord } from "@chelone/core";
+import { type VNode } from "vue";
 import { type CalendarEventSlotProps, type CalendarDrop, type CalendarSlot } from "./calendar-month-view.vue.js";
-import type { CalendarRange, CalendarView, CalendarWeekStart, SourceProp } from "@chelone/core";
+import type { CalendarRange, CalendarView, CalendarWeekStart, LooseRecord, ResourceRecord, SourceProp } from "@chelone/core";
 import type { CalendarNavigateDirection } from "./calendar-header.vue.js";
 /** Props for {@link CalendarList}. */
-export interface CalendarListProps {
+export interface CalendarListProps<TRecord extends ResourceRecord = LooseRecord> {
     /** The field holding the start of an event; a dotted path reads a nested value. */
-    startSource: SourceProp;
+    startSource: SourceProp<TRecord>;
     /** The field holding the end. An event with none, or one before its start, covers its start day only. */
-    endSource?: SourceProp;
+    endSource?: SourceProp<TRecord>;
     /** The string field shown as the event title; the record representation otherwise. */
-    titleSource?: SourceProp;
+    titleSource?: SourceProp<TRecord>;
     /** The field whose value picks a color from `colorMap`. */
-    colorSource?: SourceProp;
+    colorSource?: SourceProp<TRecord>;
     colorMap?: Record<string, string>;
     /** The view shown first. Default `month`. */
     defaultView?: CalendarView;
@@ -71,34 +50,30 @@ export interface CalendarHeaderSlotProps {
     onNavigate: (direction: CalendarNavigateDirection) => void;
     onViewChange: (view: CalendarView) => void;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CalendarListProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    drop: (record: LooseRecord, range: CalendarDrop) => any;
-    selectEvent: (record: LooseRecord) => any;
-    selectSlot: (slot: CalendarSlot) => any;
-}, string, import("vue").PublicProps, Readonly<CalendarListProps> & Readonly<{
-    onDrop?: ((record: LooseRecord, range: CalendarDrop) => any) | undefined;
-    onSelectEvent?: ((record: LooseRecord) => any) | undefined;
-    onSelectSlot?: ((slot: CalendarSlot) => any) | undefined;
-}>, {
-    perPage: number;
-    linkType: "edit" | "show" | false;
-    views: CalendarView[];
-    endSource: SourceProp;
-    titleSource: SourceProp;
-    colorSource: SourceProp;
-    colorMap: Record<string, string>;
-    defaultView: CalendarView;
-    weekStartsOn: CalendarWeekStart;
-    rangeFilter: (range: CalendarRange) => Record<string, unknown>;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    /** Replaces an event in its day cell. */
-    event?(props: CalendarEventSlotProps): unknown;
-    /** Replaces the title and the navigation. */
-    header?(props: CalendarHeaderSlotProps): unknown;
-}>;
+declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
+declare const __VLS_export: <TRecord extends ResourceRecord = LooseRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<CalendarListProps<TRecord> & {
+        onDrop?: ((record: TRecord, range: CalendarDrop) => any) | undefined;
+        onSelectEvent?: ((record: TRecord) => any) | undefined;
+        onSelectSlot?: ((slot: CalendarSlot) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        /** Replaces an event in its day cell. */
+        event?(props: CalendarEventSlotProps<TRecord>): VNode[];
+        /** Replaces the title and the navigation. */
+        header?(props: CalendarHeaderSlotProps): VNode[];
     };
+    emit: ((evt: "drop", record: TRecord, range: CalendarDrop) => void) & ((evt: "selectEvent", record: TRecord) => void) & ((evt: "selectSlot", slot: CalendarSlot) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/admin/list/calendar-list.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,257 @@
+import { useResourceDefinition } from "../../../admin/resource-registry.js";
+import { useLocale } from "../../../i18n/use-locale.js";
+import { useGetRecordRepresentation } from "../../../label/use-get-record-representation.js";
+import { cn } from "../../../lib/utils.js";
+import { useListContext } from "../../../list/list-context.js";
+import { useResourceContext } from "../../../resource-context.js";
+import { useCreatePath, useNavigate } from "../../../router/nav-composables.js";
+import calendar_agenda_view_default from "./calendar-agenda-view.js";
+import calendar_header_default from "./calendar-header.js";
+import calendar_month_view_default from "./calendar-month-view.js";
+import calendar_week_view_default from "./calendar-week-view.js";
+import { computed, createBlock, createElementBlock, createSlots, defineComponent, getCurrentInstance, guardReactiveProps, normalizeClass, normalizeProps, onBeforeUnmount, openBlock, ref, renderSlot, unref, watch, withCtx } from "vue";
+import { DEFAULT_PER_PAGE, calendarDays, calendarLabels, calendarRange, calendarRangeFilter, shiftCalendarAnchor, staleCalendarRangeKeys, toCalendarEvents } from "@chelone/core";
+// src/components/admin/list/calendar-list.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["aria-busy"];
+var calendar_list_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "calendar-list",
+	props: {
+		startSource: {},
+		endSource: { default: void 0 },
+		titleSource: { default: void 0 },
+		colorSource: { default: void 0 },
+		colorMap: { default: void 0 },
+		defaultView: { default: "month" },
+		views: { default: () => [
+			"month",
+			"week",
+			"agenda"
+		] },
+		weekStartsOn: { default: 0 },
+		perPage: { default: 1e3 },
+		rangeFilter: {
+			type: Function,
+			default: void 0
+		},
+		linkType: {
+			type: [String, Boolean],
+			default: void 0
+		},
+		class: {}
+	},
+	emits: [
+		"selectEvent",
+		"selectSlot",
+		"drop"
+	],
+	setup(__props, { emit: __emit }) {
+		/**
+		* `<CalendarList>` — the records of the ambient `<List>` as events in a month
+		* grid, or in a week of hour rows, or in an agenda. The Vue analog of `@chelone/react`'s `list/calendar-list.tsx`. It asks
+		* the list for the visible range (and `perPage` records), so moving to another
+		* month refetches; it removes that filter and restores `perPage` when it
+		* unmounts. The filters the user set stay.
+		*
+		* Emits `select-event` with the record when an event is activated; with no
+		* listener attached, the event navigates to the record's edit or show page.
+		* Emits `select-slot` with `{ startISO, endISO, allDay }` when an empty part of
+		* a day is clicked. With a `drop` listener attached, month-view events can be
+		* dragged to another day; `drop` carries the record and its new `{ start, end? }`
+		* as ISO strings and the list is not updated. A promise the listener returns is
+		* the caller's to handle. The `#event` slot replaces an event and the `#header` slot
+		* the title and navigation.
+		*
+		* @example
+		* <List>
+		*   <CalendarList start-source="starts_at" end-source="ends_at" title-source="name" />
+		* </List>
+		*/
+		const props = __props;
+		const emit = __emit;
+		const list = useListContext();
+		const resource = useResourceContext();
+		const getRepresentation = useGetRecordRepresentation(resource);
+		const navigate = useNavigate();
+		const createPath = useCreatePath();
+		const definition = useResourceDefinition(() => ({ resource }));
+		const locale = useLocale();
+		const instance = getCurrentInstance();
+		const hasListener = () => {
+			const listeners = instance?.vnode.props;
+			return !!(listeners?.onSelectEvent || listeners?.onSelectEventOnce);
+		};
+		const hasDropListener = () => {
+			const listeners = instance?.vnode.props;
+			return !!(listeners?.onDrop || listeners?.onDropOnce);
+		};
+		const VIEWS = [
+			"month",
+			"week",
+			"agenda"
+		];
+		const available = computed(() => {
+			const offered = props.views.filter((name, at) => VIEWS.includes(name) && props.views.indexOf(name) === at);
+			return offered.length > 0 ? offered : ["month"];
+		});
+		const view = ref(available.value.includes(props.defaultView) ? props.defaultView : available.value[0] ?? props.defaultView);
+		function onViewChange(next) {
+			if (available.value.includes(next)) view.value = next;
+		}
+		watch(available, (offered) => {
+			if (!offered.includes(view.value)) view.value = offered[0] ?? props.defaultView;
+		});
+		const anchor = ref(/* @__PURE__ */ new Date());
+		const range = computed(() => calendarRange(view.value, anchor.value, props.weekStartsOn));
+		const days = computed(() => calendarDays(range.value));
+		function onNavigate(direction) {
+			anchor.value = direction === "today" ? /* @__PURE__ */ new Date() : shiftCalendarAnchor(view.value, anchor.value, direction === "next" ? 1 : -1);
+		}
+		const labels = computed(() => calendarLabels(locale.value));
+		const title = computed(() => labels.value.title(view.value, anchor.value, range.value));
+		const weekdays = computed(() => days.value.slice(0, 7).map((day) => labels.value.weekday(day)));
+		const pathOf = (source) => {
+			return source;
+		};
+		const pathOfOptional = (source) => source === void 0 ? void 0 : pathOf(source);
+		const events = computed(() => toCalendarEvents(list.data ?? [], {
+			startSource: pathOf(props.startSource),
+			endSource: pathOfOptional(props.endSource),
+			titleSource: pathOfOptional(props.titleSource),
+			colorSource: pathOfOptional(props.colorSource),
+			colorMap: props.colorMap,
+			getTitle: getRepresentation
+		}));
+		const rangeValue = computed(() => props.rangeFilter ? props.rangeFilter(range.value) : calendarRangeFilter(props.startSource, range.value, props.endSource));
+		const rangeStartISO = computed(() => range.value.start.toISOString());
+		const rangeEndISO = computed(() => range.value.end.toISOString());
+		const originalPerPage = list.perPage === props.perPage ? list.defaultPerPage ?? DEFAULT_PER_PAGE : list.perPage;
+		let appliedKeys = [];
+		const without = (filter, keys) => Object.fromEntries(Object.entries(filter).filter(([key]) => !keys.includes(key)));
+		const staleKeys = computed(() => props.rangeFilter ? [] : staleCalendarRangeKeys(props.startSource, props.endSource));
+		const inSync = computed(() => list.perPage === props.perPage && staleKeys.value.every((key) => !(key in list.filter)) && Object.entries(rangeValue.value).every(([key, value]) => list.filter[key] === value));
+		watch([
+			rangeStartISO,
+			rangeEndISO,
+			() => props.startSource,
+			() => props.endSource,
+			() => props.perPage,
+			inSync
+		], () => {
+			if (inSync.value) return;
+			const next = rangeValue.value;
+			list.setParams({
+				filter: {
+					...without(list.filter, [...appliedKeys, ...staleKeys.value]),
+					...next
+				},
+				perPage: props.perPage
+			});
+			appliedKeys = Object.keys(next);
+		}, { immediate: true });
+		onBeforeUnmount(() => {
+			list.setParams({
+				filter: without(list.filter, appliedKeys),
+				perPage: originalPerPage
+			});
+		});
+		const type = computed(() => props.linkType ?? (definition.value.hasEdit ? "edit" : definition.value.hasShow ? "show" : false));
+		const linkTo = (record) => !resource || type.value === false ? void 0 : createPath({
+			resource,
+			id: record.id,
+			type: type.value
+		});
+		const hrefFor = (record) => hasListener() ? void 0 : linkTo(record);
+		const isSelectable = (record) => hasListener() || linkTo(record) !== void 0;
+		function onSelectEvent(record) {
+			if (hasListener()) return emit("selectEvent", record);
+			const to = linkTo(record);
+			if (to) navigate(to);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				"data-slot": "calendar-list",
+				"aria-busy": unref(list).isFetching ? "true" : void 0,
+				class: normalizeClass(unref(cn)("flex flex-col gap-3", props.class))
+			}, [_ctx.$slots.header ? renderSlot(_ctx.$slots, "header", {
+				range: range.value,
+				anchor: anchor.value,
+				view: view.value,
+				onNavigate,
+				onViewChange
+			}, void 0, void 0, 0) : (openBlock(), createBlock(calendar_header_default, {
+				key: 1,
+				title: title.value,
+				view: view.value,
+				views: available.value,
+				onNavigate,
+				onViewChange
+			}, null, 8, [
+				"title",
+				"view",
+				"views"
+			])), view.value === "month" ? (openBlock(), createBlock(calendar_month_view_default, {
+				key: 2,
+				days: days.value,
+				anchor: anchor.value,
+				weekdays: weekdays.value,
+				label: title.value,
+				events: events.value,
+				"href-for": hrefFor,
+				"is-selectable": isSelectable,
+				draggable: hasDropListener(),
+				onSelectEvent,
+				onSelectSlot: _cache[0] || (_cache[0] = ($event) => emit("selectSlot", $event)),
+				onDrop: _cache[1] || (_cache[1] = (record, moved) => emit("drop", record, moved))
+			}, createSlots({ _: 2 }, [_ctx.$slots.event ? {
+				name: "event",
+				fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, "event", normalizeProps(guardReactiveProps(slotProps)))]),
+				key: "0"
+			} : void 0]), 1032, [
+				"days",
+				"anchor",
+				"weekdays",
+				"label",
+				"events",
+				"draggable"
+			])) : view.value === "week" ? (openBlock(), createBlock(calendar_week_view_default, {
+				key: 3,
+				days: days.value,
+				labels: labels.value,
+				label: title.value,
+				events: events.value,
+				"href-for": hrefFor,
+				"is-selectable": isSelectable,
+				onSelectEvent,
+				onSelectSlot: _cache[2] || (_cache[2] = ($event) => emit("selectSlot", $event))
+			}, createSlots({ _: 2 }, [_ctx.$slots.event ? {
+				name: "event",
+				fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, "event", normalizeProps(guardReactiveProps(slotProps)))]),
+				key: "0"
+			} : void 0]), 1032, [
+				"days",
+				"labels",
+				"label",
+				"events"
+			])) : (openBlock(), createBlock(calendar_agenda_view_default, {
+				key: 4,
+				range: range.value,
+				labels: labels.value,
+				label: title.value,
+				events: events.value,
+				"href-for": hrefFor,
+				"is-selectable": isSelectable,
+				onSelectEvent
+			}, createSlots({ _: 2 }, [_ctx.$slots.event ? {
+				name: "event",
+				fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, "event", normalizeProps(guardReactiveProps(slotProps)))]),
+				key: "0"
+			} : void 0]), 1032, [
+				"range",
+				"labels",
+				"label",
+				"events"
+			]))], 10, _hoisted_1);
+		};
+	}
+});
+export { calendar_list_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/list/calendar-month-view.js

@@ -0,0 +1,4 @@
+import calendar_month_view_vue_vue_type_script_setup_true_lang_default from "./calendar-month-view.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/list/calendar-month-view.vue
+var calendar_month_view_default = calendar_month_view_vue_vue_type_script_setup_true_lang_default;
+export { calendar_month_view_default as default };

package/dist/components/admin/list/calendar-month-view.vue.d.ts

@@ -1,6 +1,7 @@
-import type { CalendarEvent, LooseRecord } from "@chelone/core";
+import { type VNode } from "vue";
+import type { CalendarEvent, LooseRecord, ResourceRecord } from "@chelone/core";
 /** What the `#event` slot of a `<CalendarList>` receives: the event and the day cell it renders in. */
-export interface CalendarEventSlotProps extends CalendarEvent<LooseRecord> {
+export interface CalendarEventSlotProps<TRecord extends ResourceRecord = LooseRecord> extends CalendarEvent<TRecord> {
     day: Date;
 }
 /** The time span `select-slot` reports. */
@@ -15,7 +16,7 @@ export interface CalendarDrop {
     end?: string;
 }
 /** Props for {@link CalendarMonthView}. */
-export interface CalendarMonthViewProps {
+export interface CalendarMonthViewProps<TRecord extends ResourceRecord = LooseRecord> {
     /** Every day of the grid, whole weeks, in order. */
     days: Date[];
     /** Its month decides which days are outside the month. */
@@ -24,28 +25,35 @@ export interface CalendarMonthViewProps {
     weekdays: string[];
     /** The label of the grid. */
     label: string;
-    events: CalendarEvent<LooseRecord>[];
+    events: CalendarEvent<TRecord>[];
     /** The link an event is, when it navigates. */
-    hrefFor: (record: LooseRecord) => string | undefined;
+    hrefFor: (record: TRecord) => string | undefined;
     /** Whether activating the event does anything: it is inert otherwise. */
-    isSelectable: (record: LooseRecord) => boolean;
+    isSelectable: (record: TRecord) => boolean;
     /** Whether events can be dragged to another day. */
     draggable?: boolean;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CalendarMonthViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    drop: (record: LooseRecord, range: CalendarDrop) => any;
-    selectEvent: (record: LooseRecord) => any;
-    selectSlot: (slot: CalendarSlot) => any;
-}, string, import("vue").PublicProps, Readonly<CalendarMonthViewProps> & Readonly<{
-    onDrop?: ((record: LooseRecord, range: CalendarDrop) => any) | undefined;
-    onSelectEvent?: ((record: LooseRecord) => any) | undefined;
-    onSelectSlot?: ((slot: CalendarSlot) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    event?(props: CalendarEventSlotProps): unknown;
-}>;
+declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
+declare const __VLS_export: <TRecord extends ResourceRecord = LooseRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<CalendarMonthViewProps<TRecord> & {
+        onDrop?: ((record: TRecord, range: CalendarDrop) => any) | undefined;
+        onSelectEvent?: ((record: TRecord) => any) | undefined;
+        onSelectSlot?: ((slot: CalendarSlot) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        event?(props: CalendarEventSlotProps<TRecord>): VNode[];
     };
+    emit: ((evt: "drop", record: TRecord, range: CalendarDrop) => void) & ((evt: "selectEvent", record: TRecord) => void) & ((evt: "selectSlot", slot: CalendarSlot) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/admin/list/calendar-month-view.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,188 @@
+import { cn } from "../../../lib/utils.js";
+import { Fragment, computed, createBlock, createElementBlock, createElementVNode, createTextVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onBeforeUnmount, openBlock, ref, renderList, renderSlot, resolveDynamicComponent, shallowRef, toDisplayString, unref, withCtx, withModifiers } from "vue";
+import { calendarDayKey, calendarDaySlot, calendarEventsOnDay, moveCalendarEvent } from "@chelone/core";
+// src/components/admin/list/calendar-month-view.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["aria-label"];
+var _hoisted_2 = {
+	role: "row",
+	class: "grid grid-cols-7"
+};
+var _hoisted_3 = [
+	"data-date",
+	"data-outside-month",
+	"data-today",
+	"aria-current",
+	"onClick"
+];
+var _hoisted_4 = {
+	"data-slot": "calendar-day-number",
+	class: "text-xs tabular-nums"
+};
+var _hoisted_5 = { class: "mt-1 flex flex-col gap-1" };
+var calendar_month_view_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "calendar-month-view",
+	props: {
+		days: {},
+		anchor: {},
+		weekdays: {},
+		label: {},
+		events: {},
+		hrefFor: { type: Function },
+		isSelectable: { type: Function },
+		draggable: { type: Boolean }
+	},
+	emits: [
+		"selectEvent",
+		"selectSlot",
+		"drop"
+	],
+	setup(__props, { emit: __emit }) {
+		/**
+		* `<CalendarMonthView>` — a grid of whole weeks with the events of each day in
+		* its cell. An event that spans days shows in every cell it covers. Emits
+		* `select-event` with the record and `select-slot` when an empty part of a cell
+		* is clicked; a click on an event never reaches the cell. With `draggable`, an
+		* event can be dragged to another day, which emits `drop` with the record and
+		* its moved range, whether it renders as the default element or in the `#event`
+		* slot; dropping on the day it was dragged from emits nothing.
+		*/
+		const props = __props;
+		const emit = __emit;
+		const weeks = computed(() => {
+			const rows = [];
+			for (let at = 0; at < props.days.length; at += 7) rows.push(props.days.slice(at, at + 7));
+			return rows;
+		});
+		const todayKey = ref(calendarDayKey(/* @__PURE__ */ new Date()));
+		let midnightTimer;
+		function scheduleMidnight() {
+			const now = /* @__PURE__ */ new Date();
+			const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+			midnightTimer = setTimeout(() => {
+				todayKey.value = calendarDayKey(/* @__PURE__ */ new Date());
+				scheduleMidnight();
+			}, midnight.getTime() - now.getTime());
+		}
+		scheduleMidnight();
+		onBeforeUnmount(() => clearTimeout(midnightTimer));
+		const eventsOn = (day) => calendarEventsOnDay(props.events, day);
+		function selectSlot(day) {
+			emit("selectSlot", calendarDaySlot(day));
+		}
+		function onEventClick(event, record) {
+			if (!props.isSelectable(record)) return;
+			const plain = event.button === 0 && !(event.metaKey || event.ctrlKey || event.shiftKey || event.altKey);
+			if (event.currentTarget instanceof HTMLAnchorElement && !plain) return;
+			event.preventDefault();
+			emit("selectEvent", record);
+		}
+		const dragged = shallowRef();
+		const overKey = ref();
+		function onDragStart(event, calendarEvent, from) {
+			const transfer = event.dataTransfer;
+			if (transfer) {
+				transfer.effectAllowed = "move";
+				transfer.setData("text/plain", String(calendarEvent.record.id ?? ""));
+			}
+			dragged.value = {
+				event: calendarEvent,
+				from
+			};
+		}
+		function clearDrag() {
+			dragged.value = void 0;
+			overKey.value = void 0;
+		}
+		function onDragOver(event, day) {
+			if (!dragged.value) return;
+			event.preventDefault();
+			if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+			overKey.value = calendarDayKey(day);
+		}
+		function onDragLeave(event, day) {
+			const into = event.relatedTarget;
+			const cell = event.currentTarget;
+			if (into instanceof Node && cell instanceof Node && cell.contains(into)) return;
+			if (overKey.value === calendarDayKey(day)) overKey.value = void 0;
+		}
+		function onDrop(event, day) {
+			const current = dragged.value;
+			if (!current) return;
+			event.preventDefault();
+			clearDrag();
+			if (calendarDayKey(day) === calendarDayKey(current.from)) return;
+			const moved = moveCalendarEvent(current.event, current.from, day);
+			emit("drop", current.event.record, {
+				start: moved.start.toISOString(),
+				...moved.end ? { end: moved.end.toISOString() } : {}
+			});
+		}
+		const cellDragProps = (day) => props.draggable ? {
+			"data-over": overKey.value === calendarDayKey(day) ? "" : void 0,
+			onDragover: (event) => onDragOver(event, day),
+			onDragleave: (event) => onDragLeave(event, day),
+			onDrop: (event) => onDrop(event, day)
+		} : {};
+		const eventDragProps = (calendarEvent, day) => props.draggable ? {
+			draggable: true,
+			"data-dragging": dragged.value?.event === calendarEvent && calendarDayKey(dragged.value.from) === calendarDayKey(day) ? "" : void 0,
+			onDragstart: (event) => onDragStart(event, calendarEvent, day),
+			onDragend: clearDrag
+		} : {};
+		const tagFor = (event) => props.hrefFor(event.record) ? "a" : props.isSelectable(event.record) ? "button" : "span";
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				role: "grid",
+				"aria-label": __props.label,
+				"aria-colcount": "7",
+				"data-slot": "calendar-month"
+			}, [createElementVNode("div", _hoisted_2, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.weekdays, (weekday, column) => {
+				return openBlock(), createElementBlock("div", {
+					key: column,
+					role: "columnheader",
+					class: "px-2 py-1 text-center text-xs font-medium text-muted-foreground"
+				}, toDisplayString(weekday), 1);
+			}), 128))]), (openBlock(true), createElementBlock(Fragment, null, renderList(weeks.value, (week) => {
+				return openBlock(), createElementBlock("div", {
+					key: unref(calendarDayKey)(week[0]),
+					role: "row",
+					class: "grid grid-cols-7"
+				}, [(openBlock(true), createElementBlock(Fragment, null, renderList(week, (day) => {
+					return openBlock(), createElementBlock("div", mergeProps({
+						key: unref(calendarDayKey)(day),
+						role: "gridcell",
+						"data-date": unref(calendarDayKey)(day),
+						"data-outside-month": day.getMonth() !== __props.anchor.getMonth() ? "" : void 0,
+						"data-today": unref(calendarDayKey)(day) === todayKey.value ? "" : void 0,
+						"aria-current": unref(calendarDayKey)(day) === todayKey.value ? "date" : void 0,
+						class: unref(cn)("min-h-24 border-t border-l p-1 text-sm", day.getMonth() !== __props.anchor.getMonth() && "bg-muted/40 text-muted-foreground")
+					}, { ref_for: true }, cellDragProps(day), { onClick: ($event) => selectSlot(day) }), [createElementVNode("span", _hoisted_4, toDisplayString(day.getDate()), 1), createElementVNode("ul", _hoisted_5, [(openBlock(true), createElementBlock(Fragment, null, renderList(eventsOn(day), (event, index) => {
+						return openBlock(), createElementBlock("li", mergeProps({ key: index }, { ref_for: true }, eventDragProps(event, day), { onClick: _cache[0] || (_cache[0] = withModifiers(() => {}, ["stop"])) }), [renderSlot(_ctx.$slots, "event", mergeProps({ ref_for: true }, {
+							...event,
+							day
+						}), () => [(openBlock(), createBlock(resolveDynamicComponent(tagFor(event)), {
+							"data-slot": "calendar-event",
+							"data-color": event.color,
+							href: __props.hrefFor(event.record),
+							type: tagFor(event) === "button" ? "button" : void 0,
+							style: normalizeStyle(event.color ? { backgroundColor: event.color } : void 0),
+							class: normalizeClass(["block w-full truncate rounded px-1.5 py-0.5 text-left text-xs", event.color ? "text-white" : "bg-primary text-primary-foreground"]),
+							onClick: ($event) => onEventClick($event, event.record)
+						}, {
+							default: withCtx(() => [createTextVNode(toDisplayString(event.title), 1)]),
+							_: 2
+						}, 1032, [
+							"data-color",
+							"href",
+							"type",
+							"style",
+							"class",
+							"onClick"
+						]))])], 16);
+					}), 128))])], 16, _hoisted_3);
+				}), 128))]);
+			}), 128))], 8, _hoisted_1);
+		};
+	}
+});
+export { calendar_month_view_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/admin/list/calendar-week-view.js

@@ -0,0 +1,4 @@
+import calendar_week_view_vue_vue_type_script_setup_true_lang_default from "./calendar-week-view.vue_vue_type_script_setup_true_lang.js";
+// src/components/admin/list/calendar-week-view.vue
+var calendar_week_view_default = calendar_week_view_vue_vue_type_script_setup_true_lang_default;
+export { calendar_week_view_default as default };