@svar-ui/calendar-store 2.6.0

package/dist/index.mjs

@@ -0,0 +1,1245 @@
+import { DataRouter, EventBus, Store, tempID } from "@svar-ui/lib-state";
+
+//#region package.json
+var version$1 = "2.6.0";
+
+//#endregion
+//#region src/events_store.ts
+var EventsStore = class {
+	events = [];
+	constructor(initialEvents) {
+		if (initialEvents) for (const ev of initialEvents) this.addEvent(ev);
+	}
+	addEvent(event) {
+		const id = event.id ?? tempID();
+		const full = {
+			...event,
+			id
+		};
+		this.events.push(full);
+		return full;
+	}
+	updateEvent(id, updates, _mode, _originalDate) {
+		const idx = this.events.findIndex((e) => e.id === id);
+		if (idx === -1) return null;
+		const existing = this.events[idx];
+		const updated = {
+			...existing,
+			...updates,
+			id: existing.id
+		};
+		this.events[idx] = updated;
+		return updated;
+	}
+	removeEvent(id) {
+		const idx = this.events.findIndex((e) => e.id === id);
+		if (idx === -1) return false;
+		this.events.splice(idx, 1);
+		return true;
+	}
+	getEvent(id) {
+		return this.events.find((e) => e.id === id);
+	}
+	getEvents(start, end) {
+		if (!start && !end) return [...this.events];
+		return this.events.filter((e) => {
+			if (start && !(e.end > start)) return false;
+			if (end && !(e.start < end)) return false;
+			return true;
+		});
+	}
+	clear() {
+		this.events = [];
+	}
+	getCount() {
+		return this.events.length;
+	}
+};
+
+//#endregion
+//#region src/models/helpers/scales.ts
+const DAY_MS$1 = 1440 * 60 * 1e3;
+function midnight(date) {
+	const d = new Date(date);
+	d.setHours(0, 0, 0, 0);
+	return d;
+}
+var LinearScale = class {
+	rangeStart;
+	rangeEnd;
+	stepMs;
+	snapStepMs;
+	unitCount;
+	units;
+	discrete;
+	constructor(rangeStart, rangeEnd, unitCount, stepMs, format, ui, discrete, snapStepMs) {
+		this.rangeStart = rangeStart;
+		this.rangeEnd = rangeEnd;
+		this.unitCount = unitCount;
+		this.stepMs = stepMs;
+		this.snapStepMs = snapStepMs ?? stepMs;
+		this.discrete = discrete ?? false;
+		const size = 100 / unitCount;
+		this.units = [];
+		const stepDays = stepMs >= DAY_MS$1 ? Math.round(stepMs / DAY_MS$1) : 0;
+		const markWeekend = stepMs === DAY_MS$1 && unitCount > 1;
+		for (let i = 0; i < unitCount; i++) {
+			let unitStart;
+			if (stepDays > 0) {
+				unitStart = new Date(rangeStart);
+				unitStart.setDate(unitStart.getDate() + i * stepDays);
+			} else unitStart = new Date(rangeStart.getTime() + i * stepMs);
+			const unit = {
+				id: this.formatId(unitStart),
+				label: format(unitStart),
+				position: i * size,
+				size,
+				ui: {
+					...ui,
+					date: unitStart
+				}
+			};
+			if (markWeekend) {
+				const dow = unitStart.getDay();
+				unit.weekend = dow === 0 || dow === 6;
+			}
+			this.units.push(unit);
+		}
+	}
+	formatId(date) {
+		if (this.stepMs >= DAY_MS$1) return date.toISOString().slice(0, 10);
+		return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+	}
+	get count() {
+		return this.unitCount;
+	}
+	eventToPosition(event) {
+		const range = this.rangeEnd.getTime() - this.rangeStart.getTime();
+		return {
+			start: (event.start.getTime() - this.rangeStart.getTime()) / range * 100,
+			end: (event.end.getTime() - this.rangeStart.getTime()) / range * 100
+		};
+	}
+	contains(date) {
+		return date >= this.rangeStart && date < this.rangeEnd;
+	}
+	positionToValue(position) {
+		if (this.discrete) {
+			const raw = position / (100 / this.unitCount);
+			const idx = Math.max(0, Math.min(Math.floor(raw + 1e-9), this.unitCount - 1));
+			return new Date(this.rangeStart.getTime() + idx * this.stepMs);
+		}
+		const range = this.rangeEnd.getTime() - this.rangeStart.getTime();
+		return new Date(this.rangeStart.getTime() + position / 100 * range);
+	}
+	getHeaders() {
+		return [this.units];
+	}
+};
+var DiscreteScale = class {
+	items;
+	accessor;
+	boxSize;
+	units;
+	constructor(items, accessor, ui) {
+		this.items = items;
+		this.accessor = accessor;
+		this.boxSize = 100 / items.length;
+		this.units = items.map((item, i) => ({
+			id: item.id,
+			label: item.label,
+			position: i * this.boxSize,
+			size: this.boxSize,
+			ui
+		}));
+	}
+	get count() {
+		return this.items.length;
+	}
+	eventToPosition(event) {
+		const id = this.accessor.get(event);
+		const idx = this.items.findIndex((item) => item.id === id);
+		if (idx === -1) return {
+			start: -1,
+			end: -1
+		};
+		return {
+			start: idx * this.boxSize,
+			end: (idx + 1) * this.boxSize
+		};
+	}
+	contains() {
+		return true;
+	}
+	positionToValue(position) {
+		const idx = Math.max(0, Math.min(Math.floor(position / this.boxSize), this.items.length - 1));
+		return this.items[idx].id;
+	}
+	getHeaders() {
+		return [this.units];
+	}
+};
+function resolveAccessor(accessor) {
+	if (typeof accessor === "string") return {
+		get: (event) => event[accessor],
+		set: (event, id) => ({
+			...event,
+			[accessor]: id
+		})
+	};
+	return accessor;
+}
+function createScale(config, startDate, fmt) {
+	switch (config.type) {
+		case "date": {
+			const c = config;
+			const step = c.step ?? 1;
+			const rangeStart = midnight(startDate);
+			const rangeEnd = new Date(rangeStart.getTime() + c.length * step * DAY_MS$1);
+			const stepMs = step * DAY_MS$1;
+			const snapStepMs = c.snapStep === false ? false : (c.snapStep ?? step) * DAY_MS$1;
+			const format = c.format && fmt ? fmt(c.format) : (d) => d.toLocaleDateString("en-US", { weekday: "short" });
+			return new LinearScale(rangeStart, rangeEnd, c.length, stepMs, format, c.ui, c.discrete, snapStepMs);
+		}
+		case "time": {
+			const c = config;
+			if (c.segments) throw new Error("SegmentedScale not implemented");
+			const startHour = c.startHour ?? 0;
+			const endHour = c.endHour ?? 24;
+			const stepMin = c.step ?? 60;
+			const rangeStart = new Date(startDate);
+			rangeStart.setHours(startHour, 0, 0, 0);
+			const rangeEnd = new Date(startDate);
+			rangeEnd.setHours(endHour, 0, 0, 0);
+			const stepMs = stepMin * 60 * 1e3;
+			const snapStepMs = c.snapStep === false ? false : (c.snapStep ?? stepMin) * 60 * 1e3;
+			return new LinearScale(rangeStart, rangeEnd, (endHour - startHour) * 60 / stepMin, stepMs, c.format && fmt ? fmt(c.format) : (d) => d.toLocaleTimeString("en-US", {
+				hour: "2-digit",
+				minute: "2-digit"
+			}), c.ui, void 0, snapStepMs);
+		}
+		case "unit": {
+			const c = config;
+			return new DiscreteScale(c.items, resolveAccessor(c.accessor), c.ui);
+		}
+		case "combined":
+		case "stacked": throw new Error(`${config.type} scale not implemented`);
+		default: throw new Error(`Unknown scale type`);
+	}
+}
+
+//#endregion
+//#region src/models/helpers/layout.ts
+function layoutBars(primitives) {
+	const valid = primitives.filter((p) => p.width > 0);
+	if (valid.length === 0) return {
+		primitives: [],
+		totalLanes: 0
+	};
+	const lanes = [];
+	const result = [];
+	for (const p of valid) {
+		let assigned = -1;
+		for (let i = 0; i < lanes.length; i++) if (lanes[i] <= p.x + 1e-9) {
+			assigned = i;
+			break;
+		}
+		if (assigned === -1) {
+			assigned = lanes.length;
+			lanes.push(0);
+		}
+		lanes[assigned] = p.x + p.width;
+		result.push({
+			...p,
+			lane: assigned,
+			totalLanes: 0
+		});
+	}
+	const totalLanes = lanes.length;
+	for (const p of result) p.totalLanes = totalLanes;
+	return {
+		primitives: result,
+		totalLanes
+	};
+}
+function layoutBoxes(primitives) {
+	const valid = primitives.filter((p) => p.height > 0);
+	if (valid.length === 0) return { primitives: [] };
+	const groups = [];
+	let currentGroup = [];
+	let groupEnd = -Infinity;
+	for (const p of valid) if (currentGroup.length === 0 || p.y < groupEnd) {
+		currentGroup.push(p);
+		groupEnd = Math.max(groupEnd, p.y + p.height);
+	} else {
+		groups.push(currentGroup);
+		currentGroup = [p];
+		groupEnd = p.y + p.height;
+	}
+	if (currentGroup.length > 0) groups.push(currentGroup);
+	const result = [];
+	for (const group of groups) {
+		const slots = [];
+		for (const p of group) {
+			let assigned = -1;
+			for (let i = 0; i < slots.length; i++) if (slots[i] <= p.y) {
+				assigned = i;
+				break;
+			}
+			if (assigned === -1) {
+				assigned = slots.length;
+				slots.push(0);
+			}
+			slots[assigned] = p.y + p.height;
+			result.push({
+				...p,
+				slot: assigned,
+				maxConcurrency: 0
+			});
+		}
+		const maxConcurrency = slots.length;
+		for (let i = result.length - group.length; i < result.length; i++) result[i].maxConcurrency = maxConcurrency;
+	}
+	return { primitives: result };
+}
+
+//#endregion
+//#region src/models/helpers/filters.ts
+function isMultiDay(event) {
+	if (event.allDay) return true;
+	const s = event.start;
+	const e = event.end;
+	return s.getFullYear() !== e.getFullYear() || s.getMonth() !== e.getMonth() || s.getDate() !== e.getDate();
+}
+
+//#endregion
+//#region src/models/model.ts
+var ViewModel = class {
+	render;
+	weekStartDay = 1;
+	fmt = () => (d) => d.toLocaleDateString();
+	startDate;
+	endDate;
+	cachedSections = [];
+	_sectionOverrides;
+	configure(sections) {
+		this._sectionOverrides = sections;
+	}
+	setRange(date) {
+		this.startDate = this.rangeStart(date);
+		this.endDate = this.addRange(this.startDate, 1);
+		return [this.startDate, this.endDate];
+	}
+	process(events) {
+		let sections = this.getSections();
+		if (this._sectionOverrides) sections = sections.map((s) => {
+			const ov = this._sectionOverrides[s.name];
+			return ov ? deepMerge(s, ov) : s;
+		});
+		this.cachedSections = [];
+		const results = [];
+		for (const section of sections) {
+			const result = this.processSection(section, events, true);
+			results.push(result);
+		}
+		return results;
+	}
+	toPositionStart(sectionName, x, y, ev, snap) {
+		return this.resolvePosition(sectionName, x, y, "start", ev, snap);
+	}
+	toPositionEnd(sectionName, x, y, ev, snap) {
+		return this.resolvePosition(sectionName, x, y, "end", ev, snap);
+	}
+	resolvePosition(sectionName, x, y, target, ev, snap) {
+		const cached = this.cachedSections.find((c) => c.section.name === sectionName);
+		if (!cached) return ev ? { ...ev } : {};
+		const { section } = cached;
+		const primaryAxis = this.getPrimaryAxis(section);
+		const primaryPos = primaryAxis === "x" ? x : y;
+		const secondaryPos = primaryAxis === "x" ? y : x;
+		const result = ev ? { ...ev } : {};
+		const primaryVal = cached.primaryScale.positionToValue(primaryPos);
+		const unitIdx = this.findUnitForPosition(cached.primaryScale, primaryPos);
+		const unit = cached.primaryScale.units[unitIdx];
+		let secScale = cached.secondaryScales.get(unitIdx);
+		if (!secScale) {
+			const secondaryConfig = primaryAxis === "x" ? section.yScale : section.xScale;
+			const groupStartVal = cached.primaryScale.positionToValue(unit.position);
+			secScale = createScale(secondaryConfig, groupStartVal instanceof Date ? groupStartVal : this.startDate);
+			cached.secondaryScales.set(unitIdx, secScale);
+		}
+		const secondaryVal = secScale.positionToValue(secondaryPos);
+		if (primaryVal instanceof Date && secondaryVal instanceof Date) {
+			const secStepMs = secScale.stepMs || 3600 * 1e3;
+			if (secStepMs >= DAY_MS) {
+				const combined = new Date(secondaryVal);
+				const src = ev?.[target];
+				if (src instanceof Date) combined.setHours(src.getHours(), src.getMinutes(), src.getSeconds(), src.getMilliseconds());
+				result[target] = combined;
+			} else {
+				const combined = new Date(primaryVal);
+				combined.setHours(secondaryVal.getHours(), secondaryVal.getMinutes(), secondaryVal.getSeconds(), secondaryVal.getMilliseconds());
+				const snapMs = secScale.snapStepMs ?? secStepMs;
+				if (snap && snapMs !== false) {
+					const ms = combined.getTime();
+					const base = secScale.rangeStart?.getTime() || 0;
+					const snapped = base + Math.round((ms - base) / snapMs) * snapMs;
+					result[target] = new Date(snapped);
+				} else result[target] = combined;
+			}
+		} else if (primaryVal instanceof Date) {
+			if (snap) {
+				const rawStep = cached.primaryScale.snapStepMs ?? cached.primaryScale.stepMs ?? DAY_MS;
+				const base = cached.primaryScale.rangeStart?.getTime();
+				if (rawStep !== false && base != null) {
+					const snapped = base + Math.round((primaryVal.getTime() - base) / rawStep) * rawStep;
+					result[target] = new Date(snapped);
+				} else result[target] = primaryVal;
+			} else result[target] = primaryVal;
+			const src = ev?.[target];
+			if (src instanceof Date) result[target].setHours(src.getHours(), src.getMinutes(), src.getSeconds(), src.getMilliseconds());
+			if (typeof secondaryVal !== "object") {
+				const acc = secScale.accessor;
+				if (acc?.set) Object.assign(result, acc.set(result, secondaryVal));
+			}
+		} else if (secondaryVal instanceof Date) {
+			result[target] = secondaryVal;
+			const acc = cached.primaryScale.accessor;
+			if (acc?.set) Object.assign(result, acc.set(result, primaryVal));
+		}
+		return result;
+	}
+	processSection(section, events, doLayout) {
+		const primaryAxis = this.getPrimaryAxis(section);
+		const primaryConfig = primaryAxis === "x" ? section.xScale : section.yScale;
+		const secondaryConfig = primaryAxis === "x" ? section.yScale : section.xScale;
+		const primaryScale = createScale(primaryConfig, this.startDate, this.fmt);
+		const filtered = section.filter ? events.filter(section.filter) : events;
+		const allChunks = [];
+		for (const event of filtered) {
+			const chunks = this.splitEvent(event, primaryScale, primaryConfig);
+			allChunks.push(...chunks);
+		}
+		const secondaryScales = /* @__PURE__ */ new Map();
+		const allPrimitives = [];
+		const unitGroups = /* @__PURE__ */ new Map();
+		for (const chunk of allChunks) {
+			const unitIdx = this.findUnitIndex(primaryScale, {
+				...chunk.event,
+				start: chunk.start,
+				end: chunk.end
+			});
+			if (unitIdx === -1) continue;
+			let group = unitGroups.get(unitIdx);
+			if (!group) {
+				group = [];
+				unitGroups.set(unitIdx, group);
+			}
+			group.push(chunk);
+		}
+		for (const [unitIdx, chunks] of unitGroups) {
+			const unit = primaryScale.units[unitIdx];
+			const groupStartVal = primaryScale.positionToValue(unit.position);
+			const secScale = createScale(secondaryConfig, groupStartVal instanceof Date ? groupStartVal : this.startDate, this.fmt);
+			secondaryScales.set(unitIdx, secScale);
+			const primitives = [];
+			for (const chunk of chunks) {
+				const prim = this.mapToPrimitive(chunk, unit, secScale, primaryAxis);
+				if (prim) primitives.push(prim);
+			}
+			if (doLayout && primitives.length > 0) {
+				this.sortBeforeLayout(primitives, section.mode);
+				if (section.mode === "bars" || section.mode === "grid") {
+					const laid = layoutBars(primitives);
+					allPrimitives.push(...laid.primitives);
+				} else {
+					const laid = layoutBoxes(primitives);
+					allPrimitives.push(...laid.primitives);
+				}
+			} else allPrimitives.push(...primitives);
+		}
+		if (secondaryScales.size === 0) {
+			const fallbackStart = primaryScale.units.length > 0 ? primaryScale.positionToValue(primaryScale.units[0].position) : this.startDate;
+			const groupStart = fallbackStart instanceof Date ? fallbackStart : this.startDate;
+			secondaryScales.set(0, createScale(secondaryConfig, groupStart, this.fmt));
+		}
+		const xScale = primaryAxis === "x" ? primaryScale : secondaryScales.values().next().value;
+		const yScale = primaryAxis === "y" ? primaryScale : secondaryScales.values().next().value;
+		const xHeaders = xScale ? xScale.getHeaders() : null;
+		const yHeaders = yScale ? yScale.getHeaders() : null;
+		const cells = section.mode === "grid" ? this.buildCells(xScale, yScale) : void 0;
+		this.cachedSections.push({
+			section,
+			primaryScale,
+			secondaryScales,
+			xHeaders,
+			yHeaders,
+			cells
+		});
+		const ui = {
+			drag: section.mode === "boxes" || section.mode === "bars" || section.mode === "grid",
+			dragCreate: section.mode === "boxes" || section.mode === "bars" || section.mode === "grid",
+			...section.mode === "boxes" ? { boxLayout: section.boxLayout ?? "split" } : {},
+			...section.ui
+		};
+		return {
+			name: section.name,
+			mode: section.mode,
+			size: section.size ?? 1,
+			primitives: allPrimitives,
+			xHeaders,
+			yHeaders,
+			xVisible: section.xScale.visible,
+			yVisible: section.yScale.visible,
+			cells,
+			ui
+		};
+	}
+	buildCells(_xScale, _yScale) {
+		return [];
+	}
+	sortBeforeLayout(primitives, mode) {
+		if (mode === "bars" || mode === "grid") primitives.sort((a, b) => a.x - b.x);
+		else primitives.sort((a, b) => a.y - b.y);
+	}
+	getPrimaryAxis(section) {
+		if (section.primaryScale) return section.primaryScale;
+		return section.mode === "boxes" ? "x" : "y";
+	}
+	splitEvent(event, primaryScale, _config) {
+		const units = primaryScale.units;
+		if (units.length <= 1) return [{
+			id: event.id,
+			event,
+			start: event.start,
+			end: event.end
+		}];
+		const chunks = [];
+		const boundaries = [];
+		for (let i = 1; i < units.length; i++) {
+			const d = primaryScale.positionToValue(units[i].position);
+			if (d instanceof Date) boundaries.push(d);
+		}
+		let currentStart = event.start;
+		for (const boundary of boundaries) {
+			if (boundary <= currentStart) continue;
+			if (boundary >= event.end) break;
+			chunks.push({
+				id: event.id,
+				event,
+				start: currentStart,
+				end: boundary
+			});
+			currentStart = boundary;
+		}
+		chunks.push({
+			id: event.id,
+			event,
+			start: currentStart,
+			end: event.end
+		});
+		if (chunks.length > 1) for (let i = 0; i < chunks.length; i++) chunks[i].id = (typeof event.id === "string" ? ":" : "") + `${event.id}#${i}`;
+		return chunks;
+	}
+	findUnitIndex(scale, event) {
+		const units = scale.units;
+		if (units.length === 0) return -1;
+		if (units.length === 1) return 0;
+		const pos = scale.eventToPosition(event);
+		if (pos.start < 0 && pos.end < 0) return -1;
+		for (let i = units.length - 1; i >= 0; i--) if (pos.start >= units[i].position - .001) return i;
+		return 0;
+	}
+	findUnitForPosition(scale, position) {
+		const units = scale.units;
+		for (let i = units.length - 1; i >= 0; i--) if (position >= units[i].position - .001) return i;
+		return 0;
+	}
+	mapToPrimitive(chunk, primaryUnit, secondaryScale, primaryAxis) {
+		const secPos = secondaryScale.eventToPosition({
+			...chunk.event,
+			start: chunk.start,
+			end: chunk.end
+		});
+		const s0 = Math.max(0, secPos.start);
+		const s1 = Math.min(100, secPos.end);
+		if (s1 <= s0) return null;
+		if (primaryAxis === "x") return {
+			id: chunk.id,
+			event: chunk.event,
+			x: primaryUnit.position,
+			width: primaryUnit.size,
+			y: s0,
+			height: s1 - s0
+		};
+		else return {
+			id: chunk.id,
+			event: chunk.event,
+			y: primaryUnit.position,
+			height: primaryUnit.size,
+			x: s0,
+			width: s1 - s0
+		};
+	}
+};
+const DAY_MS = 1440 * 60 * 1e3;
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const sv = source[key];
+		const tv = result[key];
+		if (sv != null && typeof sv === "object" && !Array.isArray(sv) && typeof sv !== "function" && !(sv instanceof Date) && tv != null && typeof tv === "object" && !Array.isArray(tv) && typeof tv !== "function" && !(tv instanceof Date)) result[key] = deepMerge(tv, sv);
+		else result[key] = sv;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/models/week_view.ts
+var WeekViewModel = class extends ViewModel {
+	getSections() {
+		return [{
+			name: "multiday",
+			mode: "bars",
+			xScale: {
+				type: "date",
+				length: 7,
+				format: "weekScaleFormat"
+			},
+			yScale: {
+				type: "unit",
+				items: [{
+					id: "all",
+					label: ""
+				}],
+				accessor: "_",
+				visible: false
+			},
+			filter: (event) => isMultiDay(event),
+			size: "content-optional",
+			ui: { clipDrag: false }
+		}, {
+			name: "timeGrid",
+			mode: "boxes",
+			xScale: {
+				type: "date",
+				length: 7,
+				format: "weekScaleFormat"
+			},
+			yScale: {
+				type: "time",
+				startHour: 8,
+				endHour: 18,
+				step: 60,
+				snapStep: 15,
+				ui: { minUnitHeight: 100 },
+				format: "timeScaleFormat"
+			},
+			filter: (event) => !isMultiDay(event),
+			size: 1
+		}];
+	}
+	getRangeLabel() {
+		const start = this.startDate;
+		const end = /* @__PURE__ */ new Date(this.endDate.getTime() - 1);
+		return `${this.fmt("titleWeekFormatStart")(start)}–${this.fmt("titleWeekFormatEnd")(end)}`;
+	}
+	rangeStart(date) {
+		const d = new Date(date);
+		d.setHours(0, 0, 0, 0);
+		const diff = ((d.getDay() - this.weekStartDay) % 7 + 7) % 7;
+		d.setDate(d.getDate() - diff);
+		return d;
+	}
+	addRange(date, n) {
+		const d = new Date(date);
+		d.setDate(d.getDate() + n * 7);
+		return d;
+	}
+};
+
+//#endregion
+//#region src/models/day_view.ts
+var DayViewModel = class extends ViewModel {
+	getSections() {
+		return [{
+			name: "multiday",
+			mode: "bars",
+			xScale: {
+				type: "date",
+				length: 1,
+				visible: false
+			},
+			yScale: {
+				type: "unit",
+				items: [{
+					id: "all",
+					label: ""
+				}],
+				accessor: "_",
+				visible: false
+			},
+			filter: (event) => isMultiDay(event),
+			size: "content-optional",
+			ui: {
+				drag: false,
+				dragCreate: false
+			}
+		}, {
+			name: "timeGrid",
+			mode: "boxes",
+			xScale: {
+				type: "date",
+				length: 1,
+				visible: false
+			},
+			yScale: {
+				type: "time",
+				startHour: 8,
+				endHour: 18,
+				step: 60,
+				snapStep: 15,
+				ui: { minUnitHeight: 100 },
+				format: "timeScaleFormat"
+			},
+			filter: (event) => !isMultiDay(event),
+			size: 1
+		}];
+	}
+	getRangeLabel() {
+		return this.fmt("titleDayFormat")(this.startDate);
+	}
+	rangeStart(date) {
+		const d = new Date(date);
+		d.setHours(0, 0, 0, 0);
+		return d;
+	}
+	addRange(date, n) {
+		const d = new Date(date);
+		d.setDate(d.getDate() + n);
+		return d;
+	}
+};
+
+//#endregion
+//#region src/models/month_view.ts
+var MonthViewModel = class extends ViewModel {
+	snapToCell = false;
+	getSections() {
+		return [{
+			name: "month",
+			mode: "grid",
+			xScale: {
+				type: "date",
+				length: 7,
+				discrete: true,
+				format: "monthScaleFormat"
+			},
+			yScale: {
+				type: "date",
+				length: this.getWeekCount(),
+				step: 7,
+				discrete: true,
+				visible: false
+			},
+			size: 1,
+			ui: { clipDrag: false }
+		}];
+	}
+	getRangeLabel() {
+		const target = this.getTargetMonth(this.startDate);
+		return this.fmt("titleMonthFormat")(target);
+	}
+	setRange(date) {
+		this.startDate = this.rangeStart(date);
+		const weekCount = this.getWeekCount();
+		this.endDate = new Date(this.startDate);
+		this.endDate.setDate(this.endDate.getDate() + weekCount * 7);
+		return [this.startDate, this.endDate];
+	}
+	rangeStart(date) {
+		const first = new Date(date);
+		first.setDate(1);
+		first.setHours(0, 0, 0, 0);
+		const diff = ((first.getDay() - this.weekStartDay) % 7 + 7) % 7;
+		first.setDate(first.getDate() - diff);
+		return first;
+	}
+	addRange(date, n) {
+		const d = new Date(date);
+		d.setDate(1);
+		d.setMonth(d.getMonth() + n);
+		return d;
+	}
+	sortBeforeLayout(primitives, _mode) {
+		primitives.sort((a, b) => {
+			const dx = a.x - b.x;
+			if (dx !== 0) return dx;
+			return (a.isMultiDay ? 0 : 1) - (b.isMultiDay ? 0 : 1);
+		});
+	}
+	mapToPrimitive(chunk, primaryUnit, secondaryScale, primaryAxis) {
+		const prim = super.mapToPrimitive(chunk, primaryUnit, secondaryScale, primaryAxis);
+		if (!prim) return null;
+		const isMultiDay = chunk.event.allDay || !isSameDay(chunk.event.start, chunk.event.end);
+		prim.isMultiDay = isMultiDay;
+		if (!isMultiDay || this.snapToCell) {
+			const startUnitIdx = this.findUnitIndex(secondaryScale, {
+				...chunk.event,
+				start: chunk.start,
+				end: chunk.end
+			});
+			if (startUnitIdx === -1) return null;
+			const startUnit = secondaryScale.units[startUnitIdx];
+			let endUnit = startUnit;
+			if (isMultiDay) {
+				const endDate = /* @__PURE__ */ new Date(chunk.end.getTime() - 1);
+				const endUnitIdx = this.findUnitIndex(secondaryScale, {
+					...chunk.event,
+					start: endDate,
+					end: endDate
+				});
+				if (endUnitIdx !== -1) endUnit = secondaryScale.units[endUnitIdx];
+			}
+			if (primaryAxis === "x") {
+				prim.y = startUnit.position;
+				prim.height = endUnit.position + endUnit.size - startUnit.position;
+			} else {
+				prim.x = startUnit.position;
+				prim.width = endUnit.position + endUnit.size - startUnit.position;
+			}
+		}
+		return prim;
+	}
+	buildCells(xScale, yScale) {
+		const targetMonth = this.getTargetMonth(this.startDate).getMonth();
+		const today = /* @__PURE__ */ new Date();
+		today.setHours(0, 0, 0, 0);
+		const todayTime = today.getTime();
+		const cells = [];
+		const xUnits = xScale.units;
+		const yUnits = yScale.units;
+		for (let row = 0; row < yUnits.length; row++) for (let col = 0; col < xUnits.length; col++) {
+			const date = new Date(this.startDate);
+			date.setDate(date.getDate() + row * 7 + col);
+			date.setHours(0, 0, 0, 0);
+			const dow = date.getDay();
+			cells.push({
+				date,
+				day: date.getDate(),
+				inMonth: date.getMonth() === targetMonth,
+				today: date.getTime() === todayTime,
+				weekend: dow === 0 || dow === 6,
+				x: xUnits[col].position,
+				y: yUnits[row].position,
+				width: xUnits[col].size,
+				height: yUnits[row].size
+			});
+		}
+		return cells;
+	}
+	getTargetMonth(date) {
+		const d = new Date(date);
+		d.setDate(d.getDate() + 7);
+		return new Date(d.getFullYear(), d.getMonth(), 1);
+	}
+	getWeekCount() {
+		const target = this.getTargetMonth(this.startDate);
+		const lastDay = new Date(target.getFullYear(), target.getMonth() + 1, 0);
+		lastDay.setHours(0, 0, 0, 0);
+		const dow = lastDay.getDay();
+		const daysUntilNextStart = ((this.weekStartDay - dow) % 7 + 7) % 7 || 7;
+		const gridEnd = new Date(lastDay);
+		gridEnd.setDate(gridEnd.getDate() + daysUntilNextStart);
+		const diffMs = gridEnd.getTime() - this.startDate.getTime();
+		return Math.round(diffMs / (1440 * 60 * 1e3)) / 7;
+	}
+};
+function isSameDay(a, b) {
+	return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+
+//#endregion
+//#region src/constants.ts
+function getMenuOptions() {
+	return [{
+		id: "edit-event",
+		text: "Edit event",
+		icon: "wxi-edit"
+	}, {
+		id: "delete-event",
+		text: "Delete event",
+		icon: "wxi-delete"
+	}];
+}
+function getToolbarItems() {
+	return [
+		{
+			id: "nav",
+			comp: "dateNav"
+		},
+		{
+			id: "today",
+			comp: "todayButton"
+		},
+		{ comp: "spacer" },
+		{
+			id: "title",
+			comp: "dateLabel"
+		},
+		{ comp: "spacer" },
+		{
+			id: "modes",
+			comp: "richselect"
+		},
+		{
+			id: "add-event",
+			comp: "addEventButton"
+		}
+	];
+}
+
+//#endregion
+//#region src/registry.ts
+const registry = /* @__PURE__ */ new Map();
+function registerCalendarView(id, viewClass) {
+	registry.set(id, viewClass);
+}
+function getRegisteredViews() {
+	return registry;
+}
+
+//#endregion
+//#region src/actions/navigate-to.ts
+function navigateTo(store, action) {
+	const updates = {};
+	if (action.date) updates.currentDate = action.date;
+	if (action.view && store.getView(action.view)) updates.currentView = action.view;
+	if (Object.keys(updates).length) store.setState(updates);
+}
+
+//#endregion
+//#region src/actions/navigate-time.ts
+function navigateTime(store, bus, action) {
+	const { _view, currentDate } = store.getState();
+	let date;
+	switch (action.direction) {
+		case "next":
+			date = _view.addRange(currentDate, 1);
+			break;
+		case "previous":
+			date = _view.addRange(currentDate, -1);
+			break;
+		case "now":
+			date = /* @__PURE__ */ new Date();
+			break;
+	}
+	bus.exec("navigate-to", { date });
+}
+
+//#endregion
+//#region src/actions/filter-events.ts
+function filterEvents(store, action) {
+	const { filter, tag } = action;
+	const prev = store.getState().filters;
+	if (!filter) {
+		if (!tag) store.setState({ filters: /* @__PURE__ */ new Map() });
+		else if (prev.has(tag)) {
+			const next = new Map(prev);
+			next.delete(tag);
+			store.setState({ filters: next });
+		}
+	} else {
+		const next = new Map(prev);
+		next.set(tag || "_default", filter);
+		store.setState({ filters: next });
+	}
+}
+
+//#endregion
+//#region src/helpers/allDay.ts
+function startOfLocalDay(date) {
+	const d = new Date(date);
+	d.setHours(0, 0, 0, 0);
+	return d;
+}
+function nextLocalDay(date) {
+	const d = startOfLocalDay(date);
+	d.setDate(d.getDate() + 1);
+	return d;
+}
+function isLocalMidnight(date) {
+	return date.getHours() === 0 && date.getMinutes() === 0 && date.getSeconds() === 0 && date.getMilliseconds() === 0;
+}
+function isSameLocalDay(a, b) {
+	return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function normalizeAllDayEnd(start, end) {
+	const startDay = startOfLocalDay(start);
+	if (!(end instanceof Date)) return nextLocalDay(startDay);
+	if (end <= startDay || isSameLocalDay(startDay, end)) return nextLocalDay(startDay);
+	if (isLocalMidnight(end)) return new Date(end);
+	return nextLocalDay(end);
+}
+function normalizeAllDayEvent(event) {
+	if (event.allDay !== true || !(event.start instanceof Date)) return event;
+	const start = startOfLocalDay(event.start);
+	const end = normalizeAllDayEnd(start, event.end);
+	return {
+		...event,
+		start,
+		end
+	};
+}
+function normalizeAllDayUpdate(updates, existing) {
+	const merged = existing ? {
+		...existing,
+		...updates
+	} : updates;
+	if (merged.allDay !== true || !(merged.start instanceof Date)) return updates;
+	const normalized = normalizeAllDayEvent(merged);
+	return {
+		...updates,
+		start: normalized.start,
+		end: normalized.end
+	};
+}
+
+//#endregion
+//#region src/actions/update-event.ts
+function updateEvent(store, action) {
+	const { events } = store.getState();
+	const event = normalizeAllDayUpdate(action.event, events.getEvent(action.id));
+	action.event = event;
+	if (events.updateEvent(action.id, event, action.mode, action.originalDate)) store.setState({ events });
+}
+
+//#endregion
+//#region src/actions/add-event.ts
+function hasTimeScale(store) {
+	const { _view } = store.getState();
+	return _view.getSections().some((s) => s.xScale.type === "time" || s.yScale.type === "time");
+}
+function roundToNextHour(date) {
+	const d = new Date(date);
+	if (d.getMinutes() > 0 || d.getSeconds() > 0 || d.getMilliseconds() > 0) d.setHours(d.getHours() + 1, 0, 0, 0);
+	return d;
+}
+function applyDefaults(event, store) {
+	if (event.start && event.end) return event;
+	const { currentDate } = store.getState();
+	if (hasTimeScale(store)) {
+		const start = event.start ?? roundToNextHour(/* @__PURE__ */ new Date());
+		const end = event.end ?? new Date(new Date(start).getTime() + 3600 * 1e3);
+		return {
+			...event,
+			start,
+			end
+		};
+	} else {
+		const start = event.start ?? new Date(new Date(currentDate).setHours(0, 0, 0, 0));
+		const end = event.end ?? new Date(new Date(start).getTime() + 1440 * 60 * 1e3);
+		return {
+			...event,
+			allDay: event.allDay ?? true,
+			start,
+			end
+		};
+	}
+}
+function addEvent(store, action) {
+	const filled = normalizeAllDayEvent(applyDefaults(action.event, store));
+	const { events } = store.getState();
+	const full = events.addEvent(filled);
+	action.event = { ...full };
+	action.id = full.id;
+	const updates = { events };
+	if (action.edit) updates.editorData = { ...full };
+	store.setState(updates);
+}
+
+//#endregion
+//#region src/actions/select-event.ts
+function selectEvent(store, params) {
+	if (params.id == null) {
+		store.setState({ editorData: null });
+		return;
+	}
+	const { events } = store.getState();
+	const event = events.getEvent(params.id);
+	if (event) store.setState({ editorData: { ...event } });
+}
+
+//#endregion
+//#region src/actions/delete-event.ts
+function deleteEvent(store, params) {
+	const { events, editorData } = store.getState();
+	events.removeEvent(params.id);
+	const updates = { events };
+	if (editorData?.id === params.id) updates.editorData = null;
+	store.setState(updates);
+}
+
+//#endregion
+//#region src/actions/index.ts
+function init(inBus, store) {
+	inBus.on("navigate-to", (params) => navigateTo(store, params));
+	inBus.on("navigate-time", (params) => navigateTime(store, inBus, params));
+	inBus.on("filter-events", (params) => filterEvents(store, params));
+	inBus.on("update-event", (params) => updateEvent(store, params));
+	inBus.on("add-event", (params) => addEvent(store, params));
+	inBus.on("select-event", (params) => selectEvent(store, params));
+	inBus.on("delete-event", (params) => deleteEvent(store, params));
+}
+
+//#endregion
+//#region src/calendar_reactive.ts
+function reactive(store) {
+	return [
+		{
+			in: ["currentDate", "currentView"],
+			out: ["rangeLabel", "visibleDateRange"],
+			exec: (ctx) => {
+				const { currentView, currentDate } = store.getState();
+				const view = store.getView(currentView);
+				const [start, end] = view.setRange(currentDate);
+				store.setState({
+					rangeLabel: view.getRangeLabel(),
+					visibleDateRange: {
+						start,
+						end
+					}
+				}, ctx);
+			}
+		},
+		{
+			in: ["currentView"],
+			out: ["_view"],
+			exec: (ctx) => {
+				const { currentView } = store.getState();
+				const view = store.getView(currentView);
+				store.setState({ _view: view }, ctx);
+			}
+		},
+		{
+			in: [
+				"events",
+				"currentDate",
+				"currentView",
+				"_view",
+				"filters"
+			],
+			out: ["viewData"],
+			exec: (ctx) => {
+				const { _view, currentDate, events, filters } = store.getState();
+				const [startDate, endDate] = _view.setRange(currentDate);
+				let evs = events.getEvents(startDate, endDate);
+				for (const fn of filters.values()) evs = evs.filter(fn);
+				const viewData = _view.process(evs);
+				store.setState({ viewData }, ctx);
+			}
+		}
+	];
+}
+
+//#endregion
+//#region src/calendar_store.ts
+registerCalendarView("week", WeekViewModel);
+registerCalendarView("day", DayViewModel);
+registerCalendarView("month", MonthViewModel);
+var CalendarStore = class extends Store {
+	in;
+	_router;
+	_views = {};
+	_weekStartDay;
+	_dateFormat;
+	constructor(w, options) {
+		options?.recurring;
+		let EventsClass = EventsStore;
+		const defaultState = {
+			currentDate: /* @__PURE__ */ new Date(),
+			currentView: "",
+			rangeLabel: "",
+			visibleDateRange: {
+				start: /* @__PURE__ */ new Date(),
+				end: /* @__PURE__ */ new Date()
+			},
+			events: new EventsClass(),
+			viewData: {},
+			filters: /* @__PURE__ */ new Map(),
+			editorData: null,
+			_view: new WeekViewModel()
+		};
+		super({
+			writable: w,
+			async: false
+		});
+		this._weekStartDay = options?.weekStart ?? 1;
+		this._dateFormat = options?.dateFormat ?? (() => (d) => d.toLocaleDateString());
+		this.configureViews();
+		super.setState(defaultState);
+		this._router = new DataRouter(super.setState.bind(this), reactive(this), { events: (v) => new EventsClass(v) });
+		init(this.in = new EventBus(), this);
+	}
+	configureViews(views) {
+		const registered = getRegisteredViews();
+		this._views = {};
+		if (!views) for (const [id, ViewClass] of registered) {
+			const instance = new ViewClass();
+			this.applyViewConfig(instance);
+			this._views[id] = instance;
+		}
+		else {
+			for (const v of views) {
+				const id = typeof v === "string" ? v : v.id;
+				const ViewClass = registered.get(id);
+				if (!ViewClass) continue;
+				const instance = new ViewClass();
+				this.applyViewConfig(instance);
+				if (typeof v !== "string" && v.sections) instance.configure(v.sections);
+				this._views[id] = instance;
+			}
+			const cv = this.getState().currentView;
+			if (cv && this._views[cv]) this.setState({ _view: this._views[cv] });
+		}
+	}
+	init(state) {
+		this._router.init({ ...state });
+	}
+	applyViewConfig(instance) {
+		instance.weekStartDay = this._weekStartDay;
+		instance.fmt = this._dateFormat;
+	}
+	getView(name) {
+		return this._views[name];
+	}
+	getEvents(start, end) {
+		return this.getState().events.getEvents(start, end);
+	}
+	getEvent(id) {
+		if (typeof id === "string") {
+			const isString = id.startsWith(":");
+			const start = isString ? 1 : 0;
+			let idx = id.indexOf("#", start);
+			if (idx === -1 && isString) idx = id.length;
+			if (idx !== -1) {
+				id = id.substring(start, idx);
+				if (!isString) id = parseInt(id);
+			}
+		}
+		return this.getState().events.getEvent(id);
+	}
+	getBrandmark() {
+		return null;
+	}
+	setState(state, ctx) {
+		return this._router.setState(state, ctx);
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const version = version$1;
+
+//#endregion
+export { CalendarStore, DayViewModel, DiscreteScale, EventsStore, LinearScale, MonthViewModel, ViewModel, WeekViewModel, createScale, getMenuOptions, getToolbarItems, isMultiDay, layoutBars, layoutBoxes, registerCalendarView, version };