@nomideusz/svelte-calendar 0.20.1 → 1.0.0

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`).
      *