@nomideusz/svelte-calendar 0.20.1 → 1.0.0

package/dist/views/planner/PlannerWeek.svelte

@@ -19,8 +19,8 @@ import { useCalendarContext } from "../shared/context.svelte.js";
 import EventContent from "../shared/EventContent.svelte";
 import { createClock } from "../../core/clock.svelte.js";
 import { fitParts } from "../../text-fit.js";
-import { DAY_MS, HOUR_MS, sod, addDaysMs } from "../../core/time.js";
-import { startOfWeek as sowFn, isAllDay, isMultiDay, segmentForDay } from "../../core/time.js";
+import { HOUR_MS, sod, addDaysMs, diffDays } from "../../core/time.js";
+import { startOfWeek as sowFn, isAllDay, segmentForDay } from "../../core/time.js";
 import { fmtH, fmtTime, fmtDuration, weekdayShort, weekdayLong } from "../../core/locale.js";
 let { mode = "week", mondayStart = true, locale, height = 520, events = [], style = "", focusDate, oneventclick, oneventcreate, onexternaldrop, selectedEventId = null, readOnly = false, visibleHours } = $props();
 // ── Context ────────────────────────────────────────
@@ -41,6 +41,42 @@ const autoHeight = $derived(ctx.autoHeight);
 const oneventhover = $derived(ctx.oneventhover);
 const disabledSet = $derived(ctx.disabledSet);
 const SNAP_MS = $derived(ctx.snapInterval * 6e4);
+// ── Wall-clock time axis ───────────────────────────
+// The grid is 24 wall-clock rows per day. A DST day is 23 or 25 hours
+// long, so `dayMs + h * HOUR_MS` lands an hour off after the change:
+// every hour ↔ instant conversion goes through the local calendar instead.
+/** Fractional wall-clock hour `hour` on the day starting at `dayMs` → epoch ms. */
+function atHour(dayMs, hour) {
+	// MakeTime sums the fields in local time before converting, so the
+	// milliseconds may exceed a day (24 → next midnight) or be negative.
+	return new Date(dayMs).setHours(0, 0, 0, Math.round(hour * HOUR_MS));
+}
+/** Epoch ms → fractional wall-clock hour counted from the day at `dayMs`
+*  (24 = the next midnight; calendar days, not 24 h steps). */
+function hourOf(ms, dayMs) {
+	const d = new Date(ms);
+	return diffDays(ms, dayMs) * 24 + d.getHours() + d.getMinutes() / 60 + d.getSeconds() / 3600 + d.getMilliseconds() / HOUR_MS;
+}
+/** Snap a fractional hour to the snap interval, in wall-clock minutes of
+*  the local day (not UTC multiples — those are off in +05:30 zones). */
+function snapHour(hour, how) {
+	const step = Math.max(1, ctx.snapInterval);
+	// Epsilon: 10:15 must not floor to 10:00 through float noise.
+	const units = hour * 60 / step;
+	const n = how === "floor" ? Math.floor(units + 1e-9) : Math.round(units);
+	return n * step / 60;
+}
+/** Snap an instant, relative to its own local day. */
+function snapMs(ms, how) {
+	const day = sod(ms);
+	return atHour(day, snapHour(hourOf(ms, day), how));
+}
+/** Timed events at least a (wall-clock) day long, and all-day ones, sit in
+*  the all-day strip; a shorter overnight event is drawn as a clamped
+*  segment on each day it touches. */
+function inAllDayStrip(ev) {
+	return isAllDay(ev) || ev.end.getTime() >= addDaysMs(ev.start.getTime(), 1);
+}
 // ── Config ─────────────────────────────────────────
 const HOUR_H = 48;
 const GUTTER_W = 48;
@@ -97,8 +133,8 @@ const innerMinWidth = $derived(GUTTER_W + dayCols.length * MIN_COL_W);
 // ── Load range: visible week ±7 days ───────────────
 $effect(() => {
 	if (!loadRangeCtx) return;
-	const rangeStart = new Date(weekStartMs - 7 * DAY_MS);
-	const rangeEnd = new Date(weekEndMs + 7 * DAY_MS);
+	const rangeStart = new Date(addDaysMs(weekStartMs, -7));
+	const rangeEnd = new Date(addDaysMs(weekEndMs, 7));
 	loadRangeCtx.set({
 		start: rangeStart,
 		end: rangeEnd
@@ -111,7 +147,7 @@ const allDayByDay = $derived.by(() => {
 	for (const day of dayCols) {
 		const segs = [];
 		for (const ev of events) {
-			if (!isAllDay(ev) && !isMultiDay(ev)) continue;
+			if (!inAllDayStrip(ev)) continue;
 			const seg = segmentForDay(ev, day.ms);
 			if (seg) segs.push(seg);
 		}
@@ -131,12 +167,12 @@ const layoutByDay = $derived.by(() => {
 	const rsP = drag?.active && (drag.mode === "resize-start" || drag.mode === "resize-end") ? drag.payload : null;
 	const map = new Map();
 	for (const day of dayCols) {
-		const dayEnd = day.ms + DAY_MS;
-		const bandStart = day.ms + startHour * HOUR_MS;
-		const bandEnd = day.ms + endHour * HOUR_MS;
+		const dayEnd = addDaysMs(day.ms, 1);
+		const bandStart = atHour(day.ms, startHour);
+		const bandEnd = atHour(day.ms, endHour);
 		const infos = [];
 		for (const ev of events) {
-			if (isAllDay(ev) || isMultiDay(ev)) continue;
+			if (inAllDayStrip(ev)) continue;
 			// The event being moved stays laned at its ORIGINAL slot, dimmed:
 			// the ghost shows where it is going, the faded block where it came
 			// from, and neither the drop target nor its neighbours re-lane
@@ -144,15 +180,44 @@ const layoutByDay = $derived.by(() => {
 			const isResizing = rsP?.eventId === ev.id;
 			const s0 = isResizing ? rsP.start.getTime() : ev.start.getTime();
 			const e0 = isResizing ? rsP.end.getTime() : ev.end.getTime();
+			// Inverted events are bad data; skip them.
+			if (e0 < s0) continue;
+			const hasStart = s0 >= day.ms && s0 < dayEnd;
+			const hasEnd = e0 > day.ms && e0 <= dayEnd;
+			if (e0 === s0) {
+				// Zero-length (a deadline, a marker): drawn at its start with the
+				// minimum block height, when that start is inside the band.
+				if (!hasStart || s0 < bandStart || s0 >= bandEnd) continue;
+				const laneEnd = Math.min(bandEnd, s0 + HOUR_MS / 2);
+				infos.push({
+					ev,
+					startMs: s0,
+					endMs: laneEnd,
+					drawEndMs: s0,
+					hasStart,
+					hasEnd: true,
+					isResizing,
+					isMoving: ev.id === movingId,
+					col: 0,
+					totalCols: 1
+				});
+				continue;
+			}
 			if (s0 >= dayEnd || e0 <= day.ms) continue;
 			const sMs = Math.max(s0, bandStart);
 			const eMs = Math.min(e0, bandEnd);
 			// Entirely outside the visible hour band — skip, don't paint a sliver
 			if (eMs <= sMs) continue;
+			// A grip only where the event really starts / ends: an edge cut by the
+			// visible band (a 21:00–22:30 class in a 6–22 grid) is not its end,
+			// and dragging it would rewrite the class's length to the band.
 			infos.push({
 				ev,
 				startMs: sMs,
 				endMs: eMs,
+				drawEndMs: eMs,
+				hasStart: hasStart && s0 >= bandStart,
+				hasEnd: hasEnd && e0 <= bandEnd,
 				isResizing,
 				isMoving: ev.id === movingId,
 				col: 0,
@@ -201,12 +266,14 @@ const layoutByDay = $derived.by(() => {
 		}
 		map.set(day.ms, infos.map((inf) => ({
 			ev: inf.ev,
-			top: ((inf.startMs - day.ms) / HOUR_MS - startHour) * HOUR_H,
-			height: Math.max(24, (inf.endMs - inf.startMs) / HOUR_MS * HOUR_H),
+			top: (hourOf(inf.startMs, day.ms) - startHour) * HOUR_H,
+			height: Math.max(24, (hourOf(inf.drawEndMs, day.ms) - hourOf(inf.startMs, day.ms)) * HOUR_H),
 			col: inf.col,
 			totalCols: inf.totalCols,
 			isResizing: inf.isResizing,
-			isMoving: inf.isMoving
+			isMoving: inf.isMoving,
+			hasStart: inf.hasStart,
+			hasEnd: inf.hasEnd
 		})));
 	}
 	return map;
@@ -220,7 +287,7 @@ const nowIds = $derived.by(() => {
 	}
 	return s;
 });
-const nowFracHour = $derived((clock.tick - clock.today) / HOUR_MS);
+const nowFracHour = $derived(hourOf(clock.tick, clock.today));
 /** Y offset of the now-line, or null when outside visibleHours */
 const nowY = $derived.by(() => {
 	if (nowFracHour < startHour || nowFracHour > endHour) return null;
@@ -291,13 +358,18 @@ function cancelFrame() {
 function colsRect() {
 	return rectCache ?? colsEl.getBoundingClientRect();
 }
-/** Pointer X → index into dayCols (clamped) */
+/** Pointer X → index into dayCols (clamped). Under `dir="rtl"` the flex
+*  row runs right-to-left, so the first day is the rightmost column. */
 function pointerDayIndex(clientX) {
 	const r = colsRect();
 	const n = dayCols.length;
 	if (n === 0) return 0;
 	const w = r.width / n;
-	return Math.max(0, Math.min(n - 1, Math.floor((clientX - r.left) / w)));
+	const i = Math.max(0, Math.min(n - 1, Math.floor((clientX - r.left) / w)));
+	return isRtl() ? n - 1 - i : i;
+}
+function isRtl() {
+	return !!colsEl && getComputedStyle(colsEl).direction === "rtl";
 }
 /** Pointer Y → fractional hour (unclamped) */
 function pointerHour(clientY) {
@@ -307,11 +379,11 @@ function pointerHour(clientY) {
 function pointerTimeMs(clientX, clientY) {
 	const dayMs = dayCols[pointerDayIndex(clientX)]?.ms ?? weekStartMs;
 	const hour = Math.min(Math.max(pointerHour(clientY), startHour), endHour);
-	return dayMs + hour * HOUR_MS;
+	return atHour(dayMs, hour);
 }
 /** Clamp a timestamp into the visible band of a specific day */
 function clampToDayBand(ms, dayMs) {
-	return Math.max(dayMs + startHour * HOUR_MS, Math.min(dayMs + endHour * HOUR_MS, ms));
+	return Math.max(atHour(dayMs, startHour), Math.min(atHour(dayMs, endHour), ms));
 }
 // ── Blocked slot helpers ───────────────────────────
 function isBlockedAt(dayMs, hour) {
@@ -324,7 +396,7 @@ function isBlockedAt(dayMs, hour) {
 	});
 }
 function blockedRangeLabel(dayMs, slotStart, slotEnd) {
-	return `${fmtTime(new Date(dayMs + slotStart * HOUR_MS), locale)} – ${fmtTime(new Date(dayMs + slotEnd * HOUR_MS), locale)}`;
+	return `${fmtTime(new Date(atHour(dayMs, slotStart)), locale)} – ${fmtTime(new Date(atHour(dayMs, slotEnd)), locale)}`;
 }
 // ── Status label (aria) ────────────────────────────
 // ─── Block parts ────────────────────────────────
@@ -374,14 +446,16 @@ function ghostForDay(dayMs) {
 	if (mode !== "move" && mode !== "create") return null;
 	const s = drag.payload.start.getTime();
 	const e = drag.payload.end.getTime();
-	const bandS = dayMs + startHour * HOUR_MS;
-	const bandE = dayMs + endHour * HOUR_MS;
+	const bandS = atHour(dayMs, startHour);
+	const bandE = atHour(dayMs, endHour);
 	const cs = Math.max(s, bandS);
 	const ce = Math.min(e, bandE);
-	if (ce <= cs) return null;
+	// A zero-length event (moved marker) shows at its start, like its block
+	const zero = e === s;
+	if (zero ? s < bandS || s >= bandE : ce <= cs) return null;
 	return {
-		top: ((cs - dayMs) / HOUR_MS - startHour) * HOUR_H,
-		height: Math.max(12, (ce - cs) / HOUR_MS * HOUR_H),
+		top: (hourOf(cs, dayMs) - startHour) * HOUR_H,
+		height: Math.max(zero ? 24 : 12, (hourOf(ce, dayMs) - hourOf(cs, dayMs)) * HOUR_H),
 		start: drag.payload.start,
 		end: drag.payload.end,
 		create: mode === "create",
@@ -393,7 +467,7 @@ function ghostForDay(dayMs) {
 const axisGhost = $derived.by(() => {
 	if (!drag?.active || !drag.payload) return null;
 	const s = drag.payload.start.getTime();
-	const day = dayCols.find((d) => s >= d.ms && s < d.ms + 24 * HOUR_MS);
+	const day = dayCols.find((d) => s >= d.ms && s < addDaysMs(d.ms, 1));
 	return day ? ghostForDay(day.ms) : null;
 });
 // ── Drag-to-create (mouse: sweep; touch: long-press) ──
@@ -407,6 +481,8 @@ let suppressColsClick = false;
 let crStartX = 0;
 let crStartY = 0;
 let crAnchorMs = 0;
+/** The press's wall-clock hour (clamped into the band) — snapped on start. */
+let crAnchorHour = 0;
 let crDayMs = 0;
 let crStarted = false;
 let longPressTimer = null;
@@ -430,7 +506,7 @@ function clearLongPress() {
 function startColsCreate() {
 	if (!drag) return;
 	crStarted = true;
-	crAnchorMs = clampToDayBand(Math.floor(crAnchorMs / SNAP_MS) * SNAP_MS, crDayMs);
+	crAnchorMs = clampToDayBand(atHour(crDayMs, snapHour(crAnchorHour, "floor")), crDayMs);
 	drag.beginCreate(new Date(crAnchorMs), new Date(crAnchorMs + SNAP_MS));
 	addTouchScrollBlock();
 }
@@ -447,8 +523,8 @@ function onColsDrop(e) {
 	const day = dayCols[pointerDayIndex(e.clientX)];
 	if (!day || day.isDisabled) return;
 	e.preventDefault();
-	const raw = clampToDayBand(day.ms + pointerHour(e.clientY) * HOUR_MS, day.ms);
-	const snapped = day.ms + Math.floor((raw - day.ms) / SNAP_MS) * SNAP_MS;
+	const hour = Math.min(Math.max(pointerHour(e.clientY), startHour), endHour);
+	const snapped = clampToDayBand(atHour(day.ms, snapHour(hour, "floor")), day.ms);
 	onexternaldrop({
 		start: new Date(snapped),
 		dataTransfer: e.dataTransfer
@@ -464,7 +540,8 @@ function onColsPointerDown(e) {
 	crStartX = e.clientX;
 	crStartY = e.clientY;
 	crDayMs = day.ms;
-	crAnchorMs = clampToDayBand(day.ms + Math.max(pointerHour(e.clientY), startHour) * HOUR_MS, day.ms);
+	crAnchorHour = Math.min(Math.max(pointerHour(e.clientY), startHour), endHour);
+	crAnchorMs = atHour(day.ms, crAnchorHour);
 	crStarted = false;
 	if (e.pointerType === "touch") {
 		longPressTimer = setTimeout(() => {
@@ -489,8 +566,7 @@ const onColsCreateMove = perFrame((e) => {
 		if (Math.abs(e.clientY - crStartY) < CREATE_THRESHOLD) return;
 		startColsCreate();
 	}
-	const raw = crDayMs + pointerHour(e.clientY) * HOUR_MS;
-	const snapped = clampToDayBand(Math.round(raw / SNAP_MS) * SNAP_MS, crDayMs);
+	const snapped = clampToDayBand(atHour(crDayMs, snapHour(pointerHour(e.clientY), "round")), crDayMs);
 	drag.updatePointer(new Date(Math.min(crAnchorMs, snapped)), new Date(Math.max(crAnchorMs + SNAP_MS, snapped)));
 });
 function cleanupColsCreate() {
@@ -538,8 +614,10 @@ function handleColsClick(e) {
 	if (!day || day.isDisabled) return;
 	const hour = Math.min(Math.max(pointerHour(e.clientY), startHour), endHour);
 	if (isBlockedAt(day.ms, hour)) return;
-	const startMs = clampToDayBand(Math.floor((day.ms + hour * HOUR_MS) / SNAP_MS) * SNAP_MS, day.ms);
-	const durMin = minDuration ?? 60;
+	const startMs = clampToDayBand(atHour(day.ms, snapHour(hour, "floor")), day.ms);
+	// An hour, or the minimum duration when that is longer. Blocked-slot and
+	// max-duration validation is Calendar's (ctx.oneventcreate), not ours.
+	const durMin = Math.max(60, minDuration ?? 0);
 	oneventcreate({
 		start: new Date(startMs),
 		end: new Date(startMs + durMin * 6e4)
@@ -583,7 +661,7 @@ const onEvMove = perFrame((e) => {
 	}
 	const duration = ev.end.getTime() - ev.start.getTime();
 	const raw = pointerTimeMs(e.clientX, e.clientY) - evGrabOffsetMs;
-	const snapped = Math.round(raw / SNAP_MS) * SNAP_MS;
+	const snapped = snapMs(raw, "round");
 	drag.updatePointer(new Date(snapped), new Date(snapped + duration));
 });
 function cleanupEvDrag() {
@@ -619,7 +697,10 @@ let rsStartY = 0;
 let rsStarted = false;
 let rsEdge = "end";
 let rsEvent = null;
-function onResizePointerDown(e, ev, edge) {
+/** The day column whose segment holds the grabbed grip — an overnight
+*  event's end grip sits on the next day. */
+let rsDayMs = 0;
+function onResizePointerDown(e, ev, edge, dayMs) {
 	if (e.button !== 0 || !drag || readOnly || ev.data?.readOnly) return;
 	e.stopPropagation();
 	evAnchor = e.currentTarget.parentElement?.getBoundingClientRect();
@@ -627,6 +708,7 @@ function onResizePointerDown(e, ev, edge) {
 	rsStarted = false;
 	rsEdge = edge;
 	rsEvent = ev;
+	rsDayMs = dayMs;
 	window.addEventListener("pointermove", onResizeMove);
 	window.addEventListener("pointerup", onResizeUp, { once: true });
 	window.addEventListener("pointercancel", onResizeCancel, { once: true });
@@ -640,9 +722,7 @@ const onResizeMove = perFrame((e) => {
 		drag.beginResize(ev.id, rsEdge, ev.start, ev.end);
 		addTouchScrollBlock();
 	}
-	const evDayMs = sod(ev.start.getTime());
-	const raw = evDayMs + pointerHour(e.clientY) * HOUR_MS;
-	const snapped = clampToDayBand(Math.round(raw / SNAP_MS) * SNAP_MS, evDayMs);
+	const snapped = clampToDayBand(atHour(rsDayMs, snapHour(pointerHour(e.clientY), "round")), rsDayMs);
 	if (rsEdge === "end") {
 		const end = Math.max(snapped, ev.start.getTime() + SNAP_MS);
 		drag.updatePointer(ev.start, new Date(end));
@@ -679,6 +759,18 @@ function onResizeCancel() {
 	if (drag && rsStarted) drag.cancel();
 	cleanupResize();
 }
+// ── Unmount mid-gesture ────────────────────────────
+// A view switch (or the host unmounting the calendar) can land between
+// pointerdown and pointerup: tear down the window listeners, the
+// long-press timer, the pending frame and the touch-scroll blocker, and
+// drop the half-made drag rather than leave it live in the shared context.
+$effect(() => () => {
+	const live = crStarted || evDragStarted || rsStarted;
+	cleanupColsCreate();
+	cleanupEvDrag();
+	cleanupResize();
+	if (live && drag?.active) drag.cancel();
+});
 // ── Escape cancels any in-flight drag ──────────────
 function onWindowKeydown(e) {
 	if (e.key !== "Escape" || !drag?.active) return;
@@ -852,7 +944,7 @@ function onWindowKeydown(e) {
 												style:top="{(s - startHour) * HOUR_H}px"
 												style:height="{(e - s) * HOUR_H}px"
 												title="{slot.label ? `${slot.label}, ` : ''}{range}"
-												aria-label="{slot.label || 'Unavailable'}, {range}"
+												aria-label="{slot.label || L.unavailable}, {range}"
 											>
 												{#if slot.label}
 													<span class="tw-blocked-lb">{slot.label}</span>
@@ -909,16 +1001,20 @@ function onWindowKeydown(e) {
 										<span class="tw-ev-live" aria-hidden="true"></span>
 									{/if}
 									{#if !readOnly && !p.ev.data?.readOnly}
-										<span
-											class="tw-ev-handle tw-ev-handle--start"
-											aria-hidden="true"
-											onpointerdown={(e) => onResizePointerDown(e, p.ev, 'start')}
-										></span>
-										<span
-											class="tw-ev-handle tw-ev-handle--end"
-											aria-hidden="true"
-											onpointerdown={(e) => onResizePointerDown(e, p.ev, 'end')}
-										></span>
+										{#if p.hasStart}
+											<span
+												class="tw-ev-handle tw-ev-handle--start"
+												aria-hidden="true"
+												onpointerdown={(e) => onResizePointerDown(e, p.ev, 'start', day.ms)}
+											></span>
+										{/if}
+										{#if p.hasEnd}
+											<span
+												class="tw-ev-handle tw-ev-handle--end"
+												aria-hidden="true"
+												onpointerdown={(e) => onResizePointerDown(e, p.ev, 'end', day.ms)}
+											></span>
+										{/if}
 									{/if}
 								</div>
 							{/each}
@@ -987,7 +1083,11 @@ function onWindowKeydown(e) {
 		min-height: 0;
 		overflow-y: auto;
 		overflow-x: auto;
-		overscroll-behavior: contain;
+		/* Horizontal stays contained (a sideways swipe must not trigger the
+		   browser's back navigation); vertical chains to the page, so a wheel
+		   over a page-embedded calendar scrolls on once the grid ends. */
+		overscroll-behavior-x: contain;
+		overscroll-behavior-y: auto;
 		scrollbar-width: thin;
 		scrollbar-color: var(--dt-scrollbar, rgba(0, 0, 0, 0.1)) transparent;
 	}
@@ -1061,7 +1161,7 @@ function onWindowKeydown(e) {
 	}
 	.tw-hd-num--today {
 		background: var(--dt-accent, #2563eb);
-		color: var(--dt-accent-fg, #ffffff);
+		color: var(--dt-accent-fg, var(--dt-btn-text, #ffffff));
 		font-weight: 700;
 	}
 

package/dist/views/shared/context.svelte.d.ts

@@ -6,7 +6,7 @@ import type { ViewState } from '../../engine/view-state.svelte.js';
 export interface CalendarContext {
     readonly viewState: ViewState | undefined;
     readonly drag: DragState | undefined;
-    readonly commitDrag: (() => void) | undefined;
+    readonly commitDrag: (() => Promise<void>) | undefined;
     readonly snapInterval: number;
     readonly minColumnWidth: number;
     readonly equalDays: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomideusz/svelte-calendar",
-  "version": "0.20.1",
-  "description": "A themeable Svelte 5 calendar with Day and Week views — Planner and Agenda.",
+  "version": "1.0.0",
+  "description": "A themeable Svelte 5 calendar: day, week, scrolling-week and month views, agenda lists, touch-first mobile layouts, drag-and-drop, timezones, a headless API and an embeddable web component.",
   "type": "module",
   "sideEffects": [
     "./widget/widget.js"
@@ -15,13 +15,18 @@
       "svelte": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./widget": "./widget/widget.js"
+    "./widget": {
+      "types": "./widget/widget.d.ts",
+      "default": "./widget/widget.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
     "widget",
     "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
+    "!dist/**/*.spec.*",
+    "!dist/widget"
   ],
   "imports": {
     "#lib": "./src/lib",
@@ -33,7 +38,7 @@
     "package": "svelte-kit sync && svelte-package",
     "package:watch": "svelte-kit sync && svelte-package --watch",
     "build:widget": "vite build --config vite.config.widget.ts",
-    "prepublishOnly": "npm run package",
+    "prepublishOnly": "npm run package && npm run build:widget",
     "preview": "vite preview",
     "prepare": "svelte-kit sync && svelte-package",
     "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
@@ -42,7 +47,7 @@
     "test:watch": "vitest"
   },
   "peerDependencies": {
-    "svelte": "^5.0.0"
+    "svelte": "^5.29.0"
   },
   "devDependencies": {
     "@sveltejs/adapter-auto": "8.0.0-next.4",
@@ -67,17 +72,27 @@
   },
   "keywords": [
     "svelte",
+    "svelte5",
     "calendar",
+    "event-calendar",
     "scheduler",
     "timeline",
-    "week",
+    "agenda",
     "day",
+    "week",
+    "month",
     "booking",
-    "svelte5"
+    "drag-and-drop",
+    "timezone",
+    "headless",
+    "web-component"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/nomideusz/svelte-calendar"
+    "url": "git+https://github.com/nomideusz/svelte-calendar.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nomideusz/svelte-calendar/issues"
   },
   "homepage": "https://svelte-calendar.xyz/"
 }