@nomideusz/svelte-calendar 0.21.0 → 1.0.1

package/dist/adapters/composite.d.ts

@@ -1,14 +1,25 @@
 import type { CalendarAdapter } from './types.js';
 export interface CompositeAdapterOptions {
     /**
-     * Index of the adapter that handles mutations (create/update/delete).
+     * Index of the adapter that handles `createEvent`.
      * Defaults to `0` (the first adapter).
      */
     primaryIndex?: number;
+    /**
+     * Called when one child's `fetchEvents` fails. With it, the others'
+     * events still load and the failure is yours to show; without it, one
+     * failing child fails the whole load (the calendar's `onerror`).
+     */
+    onFetchError?: (error: unknown, adapterIndex: number) => void;
 }
 /**
  * Create a CalendarAdapter that merges events from multiple child adapters.
  *
+ * Updates and deletes go to the child that returned the event. An event from
+ * a child that cannot write it is refused with a `read-only` error — the
+ * calendar then hands the move to the host (`oneventmove`) instead of
+ * dropping it.
+ *
  * @param adapters  Array of child adapters to merge.
  * @param options   Optional configuration.
  */

package/dist/adapters/composite.js

@@ -1,6 +1,13 @@
+import { CalendarReadOnlyError, EventNotFoundError, isNotFoundError } from './errors.js';
+import { overlapsRange } from '../core/time.js';
 /**
  * Create a CalendarAdapter that merges events from multiple child adapters.
  *
+ * Updates and deletes go to the child that returned the event. An event from
+ * a child that cannot write it is refused with a `read-only` error — the
+ * calendar then hands the move to the host (`oneventmove`) instead of
+ * dropping it.
+ *
  * @param adapters  Array of child adapters to merge.
  * @param options   Optional configuration.
  */
@@ -8,63 +15,118 @@ export function createCompositeAdapter(adapters, options = {}) {
     if (adapters.length === 0) {
         throw new Error('createCompositeAdapter requires at least one adapter');
     }
-    const { primaryIndex = 0 } = options;
+    const { primaryIndex = 0, onFetchError } = options;
     if (primaryIndex < 0 || primaryIndex >= adapters.length) {
         throw new Error(`primaryIndex ${primaryIndex} is out of range [0, ${adapters.length - 1}]`);
     }
     const primary = adapters[primaryIndex];
+    /** Each child's last successful fetch, shown while it is failing. */
+    const lastGood = [];
+    /** Which child returned each event id — where its writes go. */
+    const owner = new Map();
+    // Flatten and deduplicate by id (first occurrence wins)
+    function mergeBatches(results) {
+        const seen = new Set();
+        const merged = [];
+        results.forEach((batch, i) => {
+            for (const ev of batch ?? []) {
+                if (seen.has(ev.id))
+                    continue;
+                seen.add(ev.id);
+                owner.set(ev.id, adapters[i]);
+                merged.push(ev);
+            }
+        });
+        return merged;
+    }
+    /**
+     * Run a write on the child that owns `id`. An id no fetch has returned
+     * (created elsewhere, or a host calling the adapter directly) is offered
+     * to each writable child in turn; only a "not found" moves on.
+     */
+    async function routeWrite(id, op, run) {
+        const known = owner.get(id);
+        if (known) {
+            if (!known[op])
+                throw new CalendarReadOnlyError(`read-only: the adapter that holds ${id} cannot write it`);
+            return run(known);
+        }
+        let readOnlyChild = false;
+        for (const adapter of adapters) {
+            if (!adapter[op]) {
+                readOnlyChild = true;
+                continue;
+            }
+            try {
+                return await run(adapter);
+            }
+            catch (e) {
+                // A refusal or a real failure is an answer; only "not mine" asks on.
+                if (!isNotFoundError(e))
+                    throw e;
+            }
+        }
+        if (readOnlyChild)
+            throw new CalendarReadOnlyError(`read-only: no writable adapter holds ${id}`);
+        throw new EventNotFoundError(id);
+    }
+    const canUpdate = adapters.some((a) => a.updateEvent);
+    const canDelete = adapters.some((a) => a.deleteEvent);
+    const allSync = adapters.every((a) => a.fetchEventsSync);
     return {
         async fetchEvents(range) {
-            const results = await Promise.all(adapters.map((a) => a.fetchEvents(range)));
-            // Flatten and deduplicate by id (first occurrence wins)
-            const seen = new Set();
-            const merged = [];
-            for (const batch of results) {
-                for (const ev of batch) {
-                    if (!seen.has(ev.id)) {
-                        seen.add(ev.id);
-                        merged.push(ev);
-                    }
-                }
+            if (!onFetchError) {
+                return mergeBatches(await Promise.all(adapters.map((a) => a.fetchEvents(range))));
             }
-            return merged;
+            const settled = await Promise.allSettled(adapters.map((a) => a.fetchEvents(range)));
+            return mergeBatches(settled.map((r, i) => {
+                if (r.status === 'fulfilled') {
+                    lastGood[i] = r.value;
+                    return r.value;
+                }
+                onFetchError(r.reason, i);
+                // The store treats a load as the whole truth for its range: keep
+                // what this child last gave, or its events would vanish.
+                return (lastGood[i] ?? []).filter((ev) => overlapsRange(ev, range.start, range.end));
+            }));
         },
+        // Answers at once only when every child does; otherwise the async path.
+        ...(allSync
+            ? {
+                fetchEventsSync(range) {
+                    const results = [];
+                    for (const a of adapters) {
+                        const r = a.fetchEventsSync(range);
+                        if (!r)
+                            return undefined;
+                        results.push(r);
+                    }
+                    return mergeBatches(results);
+                },
+            }
+            : {}),
         // Create always goes to primary
-        ...(primary.createEvent ? { createEvent: (event) => primary.createEvent(event) } : {}),
-        // Update/delete: try each adapter that supports the operation.
-        // This handles the case where a recurring adapter generates events
-        // that the primary (memory) adapter doesn't know about.
-        async updateEvent(id, patch) {
-            for (const adapter of adapters) {
-                if (!adapter.updateEvent)
-                    continue;
-                try {
-                    return await adapter.updateEvent(id, patch);
-                }
-                catch (e) {
-                    // A refusal is an answer: the adapter that owns this event
-                    // cannot write it, and asking the others would turn that
-                    // into a meaningless "not found" the host cannot act on.
-                    if (e instanceof Error && e.message.includes('read-only'))
-                        throw e;
-                    // Otherwise: not this adapter's event, try the next.
-                }
+        ...(primary.createEvent
+            ? {
+                async createEvent(event) {
+                    const created = await primary.createEvent(event);
+                    owner.set(created.id, primary);
+                    return created;
+                },
             }
-            throw new Error(`Event not found in any adapter: ${id}`);
-        },
-        async deleteEvent(id) {
-            for (const adapter of adapters) {
-                if (!adapter.deleteEvent)
-                    continue;
-                try {
-                    await adapter.deleteEvent(id);
-                    return;
-                }
-                catch {
-                    // Event not in this adapter, try next
-                }
+            : {}),
+        ...(canUpdate
+            ? {
+                updateEvent: (id, patch) => routeWrite(id, 'updateEvent', (a) => a.updateEvent(id, patch)),
             }
-            throw new Error(`Event not found in any adapter: ${id}`);
-        },
+            : {}),
+        ...(canDelete
+            ? {
+                async deleteEvent(id) {
+                    await routeWrite(id, 'deleteEvent', (a) => a.deleteEvent(id));
+                    owner.delete(id);
+                },
+            }
+            : {}),
     };
 }

package/dist/adapters/errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The two refusals the calendar tells apart when a write fails.
+ *
+ * Throw `CalendarReadOnlyError` from an adapter that holds an event but
+ * cannot store a change to it: the Calendar keeps the dragged block where it
+ * was dropped and hands the move to the host (`oneventmove`), which owns the
+ * write. Throw `EventNotFoundError` when an id is not yours: a composite
+ * adapter then asks its next child, and a drag of it ends quietly.
+ *
+ * Plain `Error`s whose message contains "read-only" / "not found" are read
+ * the same way, so adapters written before these classes keep working.
+ */
+export declare class CalendarReadOnlyError extends Error {
+    constructor(message?: string);
+}
+export declare class EventNotFoundError extends Error {
+    constructor(id: string);
+}
+/** Whether an adapter refused a write it could not store. */
+export declare function isReadOnlyError(e: unknown): boolean;
+/** Whether an adapter answered "not my event". */
+export declare function isNotFoundError(e: unknown): boolean;

package/dist/adapters/errors.js

@@ -0,0 +1,32 @@
+/**
+ * The two refusals the calendar tells apart when a write fails.
+ *
+ * Throw `CalendarReadOnlyError` from an adapter that holds an event but
+ * cannot store a change to it: the Calendar keeps the dragged block where it
+ * was dropped and hands the move to the host (`oneventmove`), which owns the
+ * write. Throw `EventNotFoundError` when an id is not yours: a composite
+ * adapter then asks its next child, and a drag of it ends quietly.
+ *
+ * Plain `Error`s whose message contains "read-only" / "not found" are read
+ * the same way, so adapters written before these classes keep working.
+ */
+export class CalendarReadOnlyError extends Error {
+    constructor(message = 'read-only: this adapter cannot store changes') {
+        super(message.includes('read-only') ? message : `read-only: ${message}`);
+        this.name = 'CalendarReadOnlyError';
+    }
+}
+export class EventNotFoundError extends Error {
+    constructor(id) {
+        super(`Event not found: ${id}`);
+        this.name = 'EventNotFoundError';
+    }
+}
+/** Whether an adapter refused a write it could not store. */
+export function isReadOnlyError(e) {
+    return e instanceof CalendarReadOnlyError || (e instanceof Error && /read-only/i.test(e.message));
+}
+/** Whether an adapter answered "not my event". */
+export function isNotFoundError(e) {
+    return e instanceof EventNotFoundError || (e instanceof Error && /not found/i.test(e.message));
+}

package/dist/adapters/index.d.ts

@@ -12,3 +12,4 @@ export { withInitialEvents } from './seeded.js';
 export type { CompositeAdapterOptions } from './composite.js';
 export { createJmapAdapter } from './jmap.js';
 export type { JmapClient, JmapCalendarAdapterOptions } from './jmap.js';
+export { CalendarReadOnlyError, EventNotFoundError, isReadOnlyError, isNotFoundError } from './errors.js';

package/dist/adapters/index.js

@@ -5,3 +5,4 @@ export { createMappedAdapter } from './mapped.js';
 export { createCompositeAdapter } from './composite.js';
 export { withInitialEvents } from './seeded.js';
 export { createJmapAdapter } from './jmap.js';
+export { CalendarReadOnlyError, EventNotFoundError, isReadOnlyError, isNotFoundError } from './errors.js';

package/dist/adapters/jmap.js

@@ -1,37 +1,46 @@
+import { addDaysMs } from '../core/time.js';
 export function createJmapAdapter(client, options) {
     const getAccountId = options.getAccountId;
     const timeZone = options.timeZone ?? 'Etc/UTC';
+    /**
+     * Parse an RFC 8601/JSCalendar duration into its calendar part (weeks and
+     * days — whole days on the wall clock, which a DST change makes 23 or 25
+     * hours long) and its exact part (hours, minutes, seconds).
+     */
     function parseIsoDuration(duration) {
-        const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/i.exec(duration);
+        const match = /^P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/i.exec(duration);
         if (!match)
-            return 0;
-        const days = Number(match[1] ?? 0);
-        const hours = Number(match[2] ?? 0);
-        const minutes = Number(match[3] ?? 0);
-        const seconds = Number(match[4] ?? 0);
-        return (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000;
+            return { days: 0, ms: 0 };
+        const weeks = Number(match[1] ?? 0);
+        const days = Number(match[2] ?? 0);
+        const hours = Number(match[3] ?? 0);
+        const minutes = Number(match[4] ?? 0);
+        const seconds = Number(match[5] ?? 0);
+        return { days: weeks * 7 + days, ms: ((hours * 60 + minutes) * 60 + seconds) * 1000 };
     }
     function parseEventStart(event) {
+        // An all-day event is floating: it sits on its date wherever the viewer
+        // is. utcStart would pin it to the server zone's midnight instead.
+        if (event.start && event.showWithoutTime) {
+            const [datePart] = event.start.split('T');
+            const [year, month, day] = datePart.split('-').map(Number);
+            return new Date(year, month - 1, day);
+        }
         if (event.utcStart)
             return new Date(event.utcStart);
-        if (event.start) {
-            if (event.showWithoutTime) {
-                const [datePart] = event.start.split('T');
-                const [year, month, day] = datePart.split('-').map(Number);
-                return new Date(year, month - 1, day);
-            }
+        if (event.start)
             return new Date(event.start);
-        }
         return new Date();
     }
     function parseEventEnd(event, start) {
-        if (event.utcEnd)
+        if (event.utcEnd && !event.showWithoutTime)
             return new Date(event.utcEnd);
         if (event.duration) {
-            return new Date(start.getTime() + parseIsoDuration(event.duration));
+            const { days, ms } = parseIsoDuration(event.duration);
+            return new Date(addDaysMs(start.getTime(), days) + ms);
         }
         if (event.showWithoutTime) {
-            return new Date(start.getFullYear(), start.getMonth(), start.getDate(), 23, 59, 59, 999);
+            return new Date(addDaysMs(start.getTime(), 1));
         }
         return new Date(start.getTime() + 60 * 60 * 1000);
     }

package/dist/adapters/mapped.d.ts

@@ -106,7 +106,7 @@ export interface MappedAdapterOptions<T = Record<string, unknown>> {
      * Color palette used for auto-coloring.
      * Defaults to VIVID_PALETTE.
      */
-    palette?: string[];
+    palette?: readonly string[];
     /**
      * When true (default), create/update/delete throw an error.
      * Set to false and provide `onMutate` to enable writes.
@@ -167,4 +167,4 @@ export interface MutationHandler<T = Record<string, unknown>> {
  * });
  * ```
  */
-export declare function createMappedAdapter<T extends Record<string, unknown> = Record<string, unknown>>(sourceData: T[], options?: MappedAdapterOptions<T>): CalendarAdapter;
+export declare function createMappedAdapter<T extends object = Record<string, unknown>>(sourceData: T[], options?: MappedAdapterOptions<T>): CalendarAdapter;

package/dist/adapters/mapped.js

@@ -1,4 +1,6 @@
 import { VIVID_PALETTE } from '../core/palette.js';
+import { overlapsRange } from '../core/time.js';
+import { CalendarReadOnlyError, EventNotFoundError } from './errors.js';
 // ── Internal helpers ────────────────────────────────────
 let counter = 0;
 function uid() {
@@ -23,7 +25,10 @@ function toDate(value) {
 function combineDateAndTime(dateStr, timeStr) {
     // Handle various date formats
     const datePart = dateStr.includes('T') ? dateStr.split('T')[0] : dateStr;
-    const d = new Date(`${datePart}T${timeStr}:00`);
+    // "7:00", "07:00" and "07:00:00" all mean the same wall-clock time.
+    const t = /^(\d{1,2}):(\d{2})(?::(\d{2}))?/.exec(timeStr.trim());
+    const time = t ? `${t[1].padStart(2, '0')}:${t[2]}:${t[3] ?? '00'}` : timeStr;
+    const d = new Date(`${datePart}T${time}`);
     if (isNaN(d.getTime())) {
         throw new Error(`Cannot combine date "${dateStr}" and time "${timeStr}"`);
     }
@@ -158,11 +163,11 @@ export function createMappedAdapter(sourceData, options = {}) {
      * Map a single raw record using the declarative field mapping.
      */
     function mapWithFields(raw, index) {
-        const f = fields;
+        const f = fields ?? {};
         const r = raw;
         // ── ID ──
-        const id = f.id
-            ? String(r[f.id] ?? '')
+        const id = f.id && r[f.id] != null
+            ? String(r[f.id])
             : String(r['id'] ?? r['reference_id'] ?? r['externalId'] ?? r['_id'] ?? uid());
         // ── Title ──
         const titleKey = f.title ?? 'title';
@@ -287,15 +292,19 @@ export function createMappedAdapter(sourceData, options = {}) {
     }
     // ── Adapter interface ──
     function overlaps(ev, range) {
-        return ev.start < range.end && ev.end > range.start;
+        return overlapsRange(ev, range.start, range.end);
     }
     return {
+        // The records are in memory: answer at once, so a server render holds them.
+        fetchEventsSync(range) {
+            return events.filter((ev) => overlaps(ev, range));
+        },
         async fetchEvents(range) {
             return events.filter((ev) => overlaps(ev, range));
         },
         async createEvent(data) {
             if (readOnly) {
-                throw new Error('Mapped adapter is read-only. Set readOnly: false and provide onMutate to enable writes.');
+                throw new CalendarReadOnlyError('Mapped adapter is read-only. Set readOnly: false and provide onMutate to enable writes.');
             }
             const handler = options.onMutate?.onCreate;
             if (handler) {
@@ -312,11 +321,11 @@ export function createMappedAdapter(sourceData, options = {}) {
         },
         async updateEvent(id, patch) {
             if (readOnly) {
-                throw new Error('Mapped adapter is read-only. Set readOnly: false and provide onMutate to enable writes.');
+                throw new CalendarReadOnlyError('Mapped adapter is read-only. Set readOnly: false and provide onMutate to enable writes.');
             }
             const idx = events.findIndex((e) => e.id === id);
             if (idx < 0)
-                throw new Error(`Event not found: ${id}`);
+                throw new EventNotFoundError(id);
             const handler = options.onMutate?.onUpdate;
             if (handler) {
                 const raw = await handler(id, patch);
@@ -330,7 +339,7 @@ export function createMappedAdapter(sourceData, options = {}) {
         },
         async deleteEvent(id) {
             if (readOnly) {
-                throw new Error('Mapped adapter is read-only. Set readOnly: false and provide onMutate to enable writes.');
+                throw new CalendarReadOnlyError('Mapped adapter is read-only. Set readOnly: false and provide onMutate to enable writes.');
             }
             const handler = options.onMutate?.onDelete;
             if (handler)

package/dist/adapters/memory.d.ts

@@ -18,6 +18,6 @@ export interface MemoryAdapterOptions {
      * Defaults to VIVID_PALETTE. Pass `generatePalette(accent)` to
      * make event colors adapt to your theme.
      */
-    palette?: string[];
+    palette?: readonly string[];
 }
 export declare function createMemoryAdapter(initial?: TimelineEvent[], options?: MemoryAdapterOptions): CalendarAdapter;

package/dist/adapters/memory.js

@@ -1,4 +1,6 @@
 import { VIVID_PALETTE } from '../core/palette.js';
+import { overlapsRange } from '../core/time.js';
+import { EventNotFoundError } from './errors.js';
 let counter = 0;
 function uid() {
     return `mem-${Date.now()}-${++counter}`;
@@ -24,7 +26,7 @@ export function createMemoryAdapter(initial = [], options) {
         return color ? { ...ev, color } : ev;
     }
     function overlaps(ev, range) {
-        return ev.start < range.end && ev.end > range.start;
+        return overlapsRange(ev, range.start, range.end);
     }
     const fetchEventsSync = (range) => events.filter((ev) => overlaps(ev, range)).map(withColor);
     return {
@@ -40,14 +42,14 @@ export function createMemoryAdapter(initial = [], options) {
         async updateEvent(id, patch) {
             const idx = events.findIndex((e) => e.id === id);
             if (idx < 0)
-                throw new Error(`Event not found: ${id}`);
+                throw new EventNotFoundError(id);
             events[idx] = { ...events[idx], ...patch, id };
             return withColor(events[idx]);
         },
         async deleteEvent(id) {
             const idx = events.findIndex((e) => e.id === id);
             if (idx < 0)
-                throw new Error(`Event not found: ${id}`);
+                throw new EventNotFoundError(id);
             events.splice(idx, 1);
         },
     };

package/dist/adapters/recurring.d.ts

@@ -79,7 +79,7 @@ export interface RecurringAdapterOptions {
      * or provide your own array of hex strings.
      * Defaults to the built-in vivid palette.
      */
-    palette?: string[];
+    palette?: readonly string[];
     /**
      * Let projected occurrences be dragged (default: `false`).
      *

package/dist/adapters/recurring.js

@@ -1,5 +1,6 @@
-import { startOfWeek, addDaysMs, diffDays, DAY_MS } from '../core/time.js';
+import { startOfWeek, addDaysMs, diffDays, DAY_MS, overlapsRange } from '../core/time.js';
 import { VIVID_PALETTE } from '../core/palette.js';
+import { CalendarReadOnlyError, EventNotFoundError } from './errors.js';
 // ── Helpers ─────────────────────────────────────────────
 /** Parse "HH:MM" into [hours, minutes] */
 function parseTime(time) {
@@ -30,16 +31,23 @@ function parseDate(str) {
         throw new Error(`Invalid date "${str}"`);
     return date;
 }
-/** ISO weekday offset from Monday: 1→0, 2→1, … 7→6 */
-function isoWeekdayToOffset(dayOfWeek) {
-    return dayOfWeek - 1;
+/**
+ * Days from the start of the week to an ISO weekday (1=Mon … 7=Sun).
+ * Monday weeks: 1→0 … 7→6. Sunday weeks: 7→0, 1→1 … 6→6.
+ */
+function isoWeekdayToOffset(dayOfWeek, mondayStart) {
+    return mondayStart ? dayOfWeek - 1 : dayOfWeek % 7;
 }
-/** Normalize `dayOfWeek` to a sorted array */
-function normalizeDays(value) {
+/**
+ * Normalize `dayOfWeek` to an array in week order — the projection walks it
+ * in order and stops at the first day past its bound, so Sunday must come
+ * first in a Sunday week.
+ */
+function normalizeDays(value, mondayStart) {
     if (value == null)
         return [];
     const arr = Array.isArray(value) ? [...value] : [value];
-    return arr.sort((a, b) => a - b);
+    return arr.sort((a, b) => isoWeekdayToOffset(a, mondayStart) - isoWeekdayToOffset(b, mondayStart));
 }
 /** Clamp day to last day of month (e.g. 31 → 28 in Feb) */
 function clampDayOfMonth(year, month, day) {
@@ -58,7 +66,9 @@ function createConcreteEvent(rec, date) {
     const [sh, sm] = parseTime(rec.startTime);
     const [eh, em] = parseTime(rec.endTime);
     const start = new Date(date.getFullYear(), date.getMonth(), date.getDate(), sh, sm);
-    const end = new Date(date.getFullYear(), date.getMonth(), date.getDate(), eh, em);
+    // An end before the start runs past midnight (22:00–02:00).
+    const overnight = eh * 60 + em < sh * 60 + sm;
+    const end = new Date(date.getFullYear(), date.getMonth(), date.getDate() + (overnight ? 1 : 0), eh, em);
     return {
         id: `${rec.id}--${dateKey(date)}`,
         title: rec.title,
@@ -91,7 +101,7 @@ function computeUntilFromCount(rec, startDateObj, mondayStart) {
             return d;
         }
         case 'weekly': {
-            const days = normalizeDays(rec.dayOfWeek);
+            const days = normalizeDays(rec.dayOfWeek, mondayStart);
             if (days.length === 0)
                 return undefined;
             const startMs = startDateObj.getTime();
@@ -100,7 +110,7 @@ function computeUntilFromCount(rec, startDateObj, mondayStart) {
             const maxCycles = Math.ceil(count / days.length) + 2;
             for (let c = 0; c < maxCycles; c++) {
                 for (const day of days) {
-                    const dayMs = addDaysMs(weekMs, isoWeekdayToOffset(day));
+                    const dayMs = addDaysMs(weekMs, isoWeekdayToOffset(day, mondayStart));
                     if (dayMs >= startMs) {
                         remaining--;
                         if (remaining === 0)
@@ -112,8 +122,12 @@ function computeUntilFromCount(rec, startDateObj, mondayStart) {
             return undefined;
         }
         case 'monthly': {
+            // The start month counts only if its occurrence is on or after
+            // startDate (20 Jan with dayOfMonth 15 begins in February).
+            const first = clampDayOfMonth(startDateObj.getFullYear(), startDateObj.getMonth(), rec.dayOfMonth ?? 1);
             const totalMonths = startDateObj.getFullYear() * 12 +
                 startDateObj.getMonth() +
+                (first < startDateObj ? interval : 0) +
                 (count - 1) * interval;
             const y = Math.floor(totalMonths / 12);
             const m = totalMonths % 12;
@@ -150,7 +164,7 @@ function projectDaily(rec, range, startDate, effectiveUntil, out) {
 }
 function projectWeekly(rec, range, startDate, effectiveUntil, mondayStart, out) {
     const interval = rec.interval ?? 1;
-    const days = normalizeDays(rec.dayOfWeek);
+    const days = normalizeDays(rec.dayOfWeek, mondayStart);
     if (days.length === 0)
         return;
     const startDateMs = startDate?.getTime();
@@ -174,7 +188,7 @@ function projectWeekly(rec, range, startDate, effectiveUntil, mondayStart, out)
     }
     while (weekMs < rangeEndMs) {
         for (const day of days) {
-            const dayMs = addDaysMs(weekMs, isoWeekdayToOffset(day));
+            const dayMs = addDaysMs(weekMs, isoWeekdayToOffset(day, mondayStart));
             if (startDateMs != null && dayMs < startDateMs)
                 continue;
             if (dayMs >= rangeEndMs)
@@ -210,7 +224,7 @@ function projectMonthly(rec, range, startDate, effectiveUntil, out) {
             break;
         if (effectiveUntil && date > effectiveUntil)
             break;
-        if (date >= range.start && (!startDate || date >= startDate)) {
+        if (!startDate || date >= startDate) {
             const ev = createConcreteEvent(rec, date);
             if (ev.start < range.end && ev.end > range.start) {
                 out.push(ev);
@@ -254,6 +268,10 @@ export function createRecurringAdapter(schedule, options = {}) {
     }
     const fetchEventsSync = (range) => {
         const events = [];
+        // Project from a day earlier: an occurrence that runs past midnight
+        // (22:00–02:00) overlaps the range from the day before it. The
+        // overlap filter below trims back to the requested range.
+        const projected = { start: new Date(addDaysMs(range.start.getTime(), -1)), end: range.end };
         for (const rec of schedule) {
             const colored = { ...rec, color: resolveColor(rec) };
             const freq = rec.frequency ?? 'weekly';
@@ -272,13 +290,13 @@ export function createRecurringAdapter(schedule, options = {}) {
             }
             switch (freq) {
                 case 'daily':
-                    projectDaily(colored, range, sd, effectiveUntil, events);
+                    projectDaily(colored, projected, sd, effectiveUntil, events);
                     break;
                 case 'weekly':
-                    projectWeekly(colored, range, sd, effectiveUntil, mondayStart, events);
+                    projectWeekly(colored, projected, sd, effectiveUntil, mondayStart, events);
                     break;
                 case 'monthly':
-                    projectMonthly(colored, range, sd, effectiveUntil, events);
+                    projectMonthly(colored, projected, sd, effectiveUntil, events);
                     break;
             }
         }
@@ -288,7 +306,7 @@ export function createRecurringAdapter(schedule, options = {}) {
             for (const d of rec.excludeDates ?? [])
                 skipped.add(`${rec.id}--${d.replace(/-/g, '')}`);
         }
-        const kept = skipped.size ? events.filter((e) => !skipped.has(e.id)) : events;
+        const kept = events.filter((e) => !skipped.has(e.id) && overlapsRange(e, range.start, range.end));
         return movable ? kept : kept.map((e) => ({ ...e, data: { ...e.data, readOnly: true } }));
     };
     return {
@@ -303,9 +321,9 @@ export function createRecurringAdapter(schedule, options = {}) {
         async updateEvent(id) {
             const ruleId = id.split('--')[0];
             if (!schedule.some((rec) => rec.id === ruleId)) {
-                throw new Error(`Event not found: ${id}`);
+                throw new EventNotFoundError(id);
             }
-            throw new Error(`read-only: ${id} is a projected occurrence. Add its date to the rule's excludeDates and store the change yourself.`);
+            throw new CalendarReadOnlyError(`read-only: ${id} is a projected occurrence. Add its date to the rule's excludeDates and store the change yourself.`);
         },
     };
 }

package/dist/adapters/rest.d.ts

@@ -12,9 +12,9 @@ export interface RestAdapterOptions {
     baseUrl: string;
     /** Custom headers (e.g. Authorization) */
     headers?: Record<string, string>;
-    /** Map API response to TimelineEvent[] */
+    /** Map API response to TimelineEvent[] (default: the body is an array of events, `start`/`end` parsed into Dates) */
     mapEvents?: (data: unknown) => TimelineEvent[];
-    /** Map API response to a single TimelineEvent */
+    /** Map API response to a single TimelineEvent (default: the body is the event, `start`/`end` parsed into Dates) */
     mapEvent?: (data: unknown) => TimelineEvent;
 }
 export declare function createRestAdapter(options: RestAdapterOptions): CalendarAdapter;