@nomideusz/svelte-calendar 0.6.0 → 0.6.4

package/dist/adapters/mapped.js

@@ -0,0 +1,343 @@
+import { VIVID_PALETTE } from '../core/palette.js';
+// ── Internal helpers ────────────────────────────────────
+let counter = 0;
+function uid() {
+    return `mapped-${Date.now()}-${++counter}`;
+}
+/** Parse a date/time value into a Date object */
+function toDate(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value === 'number')
+        return new Date(value);
+    if (typeof value === 'string') {
+        const d = new Date(value);
+        if (isNaN(d.getTime())) {
+            throw new Error(`Cannot parse date: "${value}"`);
+        }
+        return d;
+    }
+    throw new Error(`Cannot convert to Date: ${typeof value}`);
+}
+/** Combine "YYYY-MM-DD" date and "HH:MM" time into a Date */
+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`);
+    if (isNaN(d.getTime())) {
+        throw new Error(`Cannot combine date "${dateStr}" and time "${timeStr}"`);
+    }
+    return d;
+}
+/** Coerce a source value into an EventStatus */
+function coerceStatus(value, fieldName) {
+    if (typeof value === 'string') {
+        const lower = value.toLowerCase();
+        if (lower === 'cancelled' || lower === 'canceled')
+            return 'cancelled';
+        if (lower === 'tentative')
+            return 'tentative';
+        if (lower === 'full')
+            return 'full';
+        if (lower === 'limited')
+            return 'limited';
+        return 'confirmed';
+    }
+    if (typeof value === 'boolean') {
+        // E.g. is_cancelled: true → 'cancelled'
+        const lowerField = fieldName.toLowerCase();
+        if (lowerField.includes('cancel'))
+            return value ? 'cancelled' : 'confirmed';
+        if (lowerField.includes('tentative'))
+            return value ? 'tentative' : 'confirmed';
+        return value ? 'confirmed' : 'tentative';
+    }
+    return 'confirmed';
+}
+/** Parse an RGB string like "rgb(62, 101, 255)" to a hex color */
+function normalizeColor(value) {
+    if (!value)
+        return undefined;
+    if (typeof value !== 'string')
+        return undefined;
+    const str = value.trim();
+    // Already hex
+    if (str.startsWith('#'))
+        return str;
+    // rgb(r, g, b) format
+    const rgbMatch = str.match(/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i);
+    if (rgbMatch) {
+        const r = parseInt(rgbMatch[1], 10);
+        const g = parseInt(rgbMatch[2], 10);
+        const b = parseInt(rgbMatch[3], 10);
+        return `#${((1 << 24) | (r << 16) | (g << 8) | b).toString(16).slice(1)}`;
+    }
+    // CSS named colors and other formats — pass through
+    return str;
+}
+/**
+ * Collect unmapped fields into the `data` payload.
+ */
+function collectData(raw, mappedKeys, include) {
+    const data = {};
+    const keys = include === '*' ? Object.keys(raw) : include;
+    for (const key of keys) {
+        if (!mappedKeys.has(key) && raw[key] !== undefined) {
+            data[key] = raw[key];
+        }
+    }
+    return data;
+}
+// ── Factory ─────────────────────────────────────────────
+/**
+ * Create a CalendarAdapter from an array of external records + mapping config.
+ *
+ * @example
+ * ```ts
+ * // Yoga school schedule
+ * const adapter = createMappedAdapter(yogaSchedule.events, {
+ *   fields: {
+ *     title: 'class_name',
+ *     start: 'starts_at_iso',
+ *     end: 'ends_at_iso',
+ *     subtitle: 'teacher',
+ *     location: 'room',
+ *     color: 'color',
+ *     externalId: 'reference_id',
+ *     status: 'is_cancelled',
+ *     tags: ['is_free', 'is_bookable_online'],
+ *   },
+ * });
+ *
+ * // Medical appointments
+ * const adapter = createMappedAdapter(appointments, {
+ *   fields: {
+ *     title: 'procedure_name',
+ *     start: 'scheduled_at',
+ *     end: 'scheduled_end',
+ *     subtitle: 'doctor_name',
+ *     location: 'office',
+ *     resourceId: 'doctor_id',
+ *   },
+ * });
+ *
+ * // Full custom mapper
+ * const adapter = createMappedAdapter(rawData, {
+ *   mapEvent: (raw) => ({
+ *     id: raw.uid,
+ *     title: `${raw.first_name} ${raw.last_name}`,
+ *     start: new Date(raw.timestamp),
+ *     end: new Date(raw.timestamp + raw.duration_ms),
+ *     location: raw.room,
+ *   }),
+ * });
+ * ```
+ */
+export function createMappedAdapter(sourceData, options = {}) {
+    const { fields, mapEvent: customMapper, includeData = '*', autoColor = true, palette = VIVID_PALETTE, readOnly = true, } = options;
+    // Build the internal event list
+    const events = [];
+    const colorAssignments = new Map();
+    let colorIndex = 0;
+    function resolveColor(ev) {
+        // When autoColor is on, always assign from palette (ignore source color)
+        if (!autoColor && ev.color)
+            return ev.color;
+        const key = ev.category ?? ev.title;
+        if (!colorAssignments.has(key)) {
+            colorAssignments.set(key, palette[colorIndex % palette.length]);
+            colorIndex++;
+        }
+        return colorAssignments.get(key);
+    }
+    function withColor(ev) {
+        const color = resolveColor(ev);
+        return color ? { ...ev, color } : ev;
+    }
+    /**
+     * Map a single raw record using the declarative field mapping.
+     */
+    function mapWithFields(raw, index) {
+        const f = fields;
+        const r = raw;
+        // ── ID ──
+        const id = f.id
+            ? String(r[f.id] ?? '')
+            : String(r['id'] ?? r['reference_id'] ?? r['externalId'] ?? r['_id'] ?? uid());
+        // ── Title ──
+        const titleKey = f.title ?? 'title';
+        const title = String(r[titleKey] ?? r['name'] ?? r['class_name'] ?? `Event ${index + 1}`);
+        // ── Start / End ──
+        let start;
+        let end;
+        if (f.start && r[f.start] !== undefined) {
+            start = toDate(r[f.start]);
+        }
+        else if (f.date && f.startTime && r[f.date] && r[f.startTime]) {
+            start = combineDateAndTime(String(r[f.date]), String(r[f.startTime]));
+        }
+        else if (r['start'] !== undefined) {
+            start = toDate(r['start']);
+        }
+        else if (r['starts_at_iso'] !== undefined) {
+            start = toDate(r['starts_at_iso']);
+        }
+        else if (r['start_time'] !== undefined && r['date'] !== undefined) {
+            start = combineDateAndTime(String(r['date']), String(r['start_time']));
+        }
+        else {
+            throw new Error(`Cannot determine start time for record ${index}: no matching field found`);
+        }
+        if (f.end && r[f.end] !== undefined) {
+            end = toDate(r[f.end]);
+        }
+        else if (f.date && f.endTime && r[f.date] && r[f.endTime]) {
+            end = combineDateAndTime(String(r[f.date]), String(r[f.endTime]));
+        }
+        else if (r['end'] !== undefined) {
+            end = toDate(r['end']);
+        }
+        else if (r['ends_at_iso'] !== undefined) {
+            end = toDate(r['ends_at_iso']);
+        }
+        else if (r['end_time'] !== undefined && r['date'] !== undefined) {
+            end = combineDateAndTime(String(r['date']), String(r['end_time']));
+        }
+        else {
+            // Default: 1 hour after start
+            end = new Date(start.getTime() + 60 * 60 * 1000);
+        }
+        // ── Optional fields ──
+        const color = normalizeColor(r[f.color ?? 'color']);
+        const subtitle = f.subtitle ? String(r[f.subtitle] ?? '') || undefined : undefined;
+        const location = f.location
+            ? String(r[f.location] ?? '') || undefined
+            : r['room'] ? String(r['room']) : r['location'] ? String(r['location']) : undefined;
+        const category = f.category ? String(r[f.category] ?? '') || undefined : undefined;
+        const resourceId = f.resourceId ? String(r[f.resourceId] ?? '') || undefined : undefined;
+        const externalId = f.externalId
+            ? String(r[f.externalId] ?? '') || undefined
+            : r['reference_id'] ? String(r['reference_id']) : undefined;
+        // ── Status ──
+        let status;
+        if (f.status && r[f.status] !== undefined) {
+            status = coerceStatus(r[f.status], f.status);
+        }
+        else if (r['is_cancelled'] !== undefined) {
+            status = coerceStatus(r['is_cancelled'], 'is_cancelled');
+        }
+        // ── Tags ──
+        let tags;
+        if (f.tags && f.tags.length > 0) {
+            tags = [];
+            for (const tagKey of f.tags) {
+                const val = r[tagKey];
+                if (val === true) {
+                    // Convert key name to human-readable tag
+                    tags.push(tagKey.replace(/^is_/, '').replace(/_/g, ' '));
+                }
+                else if (typeof val === 'string' && val) {
+                    tags.push(val);
+                }
+            }
+            if (tags.length === 0)
+                tags = undefined;
+        }
+        // ── Data (unmapped fields) ──
+        const mappedKeys = new Set();
+        for (const v of Object.values(f)) {
+            if (typeof v === 'string')
+                mappedKeys.add(v);
+            if (Array.isArray(v))
+                v.forEach((k) => mappedKeys.add(k));
+        }
+        // Also mark auto-detected keys as mapped
+        for (const k of ['id', 'title', 'name', 'class_name', 'start', 'end',
+            'starts_at_iso', 'ends_at_iso', 'start_time', 'end_time', 'date',
+            'color', 'room', 'location', 'reference_id', 'is_cancelled']) {
+            mappedKeys.add(k);
+        }
+        const data = collectData(r, mappedKeys, includeData);
+        const ev = { id, title, start, end };
+        if (color)
+            ev.color = color;
+        if (subtitle)
+            ev.subtitle = subtitle;
+        if (location)
+            ev.location = location;
+        if (category)
+            ev.category = category;
+        if (resourceId)
+            ev.resourceId = resourceId;
+        if (externalId)
+            ev.externalId = externalId;
+        if (status && status !== 'confirmed')
+            ev.status = status;
+        if (tags)
+            ev.tags = tags;
+        if (Object.keys(data).length > 0)
+            ev.data = data;
+        return ev;
+    }
+    // ── Build events array ──
+    for (let i = 0; i < sourceData.length; i++) {
+        const mapper = customMapper ?? mapWithFields;
+        const ev = withColor(mapper(sourceData[i], i));
+        events.push(ev);
+    }
+    // ── Adapter interface ──
+    function overlaps(ev, range) {
+        return ev.start < range.end && ev.end > range.start;
+    }
+    return {
+        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.');
+            }
+            const handler = options.onMutate?.onCreate;
+            if (handler) {
+                const raw = await handler(data);
+                const mapper = customMapper ?? mapWithFields;
+                const ev = withColor(mapper(raw, events.length));
+                events.push(ev);
+                return ev;
+            }
+            // Fallback: create locally
+            const ev = { ...data, id: uid() };
+            events.push(withColor(ev));
+            return ev;
+        },
+        async updateEvent(id, patch) {
+            if (readOnly) {
+                throw new Error('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}`);
+            const handler = options.onMutate?.onUpdate;
+            if (handler) {
+                const raw = await handler(id, patch);
+                const mapper = customMapper ?? mapWithFields;
+                const ev = withColor(mapper(raw, idx));
+                events[idx] = ev;
+                return ev;
+            }
+            events[idx] = { ...events[idx], ...patch, id };
+            return events[idx];
+        },
+        async deleteEvent(id) {
+            if (readOnly) {
+                throw new Error('Mapped adapter is read-only. Set readOnly: false and provide onMutate to enable writes.');
+            }
+            const handler = options.onMutate?.onDelete;
+            if (handler)
+                await handler(id);
+            const idx = events.findIndex((e) => e.id === id);
+            if (idx >= 0)
+                events.splice(idx, 1);
+        },
+    };
+}

package/dist/adapters/recurring.d.ts

@@ -57,12 +57,23 @@ export interface RecurringEvent {
     tags?: string[];
     /** Category for grouping */
     category?: string;
+    /** Location or room name */
+    location?: string;
+    /** Resource ID for multi-resource views */
+    resourceId?: string;
     /** Arbitrary payload */
     data?: Record<string, unknown>;
 }
 export interface RecurringAdapterOptions {
     /** Start weeks on Monday (default: true) */
     mondayStart?: boolean;
+    /**
+     * Custom color palette for auto-coloring events.
+     * Pass `generatePalette('#yourAccent')` to get theme-harmonious colors,
+     * or provide your own array of hex strings.
+     * Defaults to the built-in vivid palette.
+     */
+    palette?: string[];
 }
 /**
  * Create a CalendarAdapter that projects recurring events onto concrete

package/dist/adapters/recurring.js

@@ -68,7 +68,9 @@ function createConcreteEvent(rec, date) {
         category: rec.category,
         subtitle: rec.subtitle,
         tags: rec.tags,
-        data: { ...rec.data, recurringId: rec.id },
+        location: rec.location,
+        resourceId: rec.resourceId,
+        data: { ...rec.data, recurringId: rec.id, readOnly: true },
     };
 }
 // ── Count → until resolution ────────────────────────────
@@ -230,8 +232,9 @@ const PALETTE = VIVID_PALETTE;
  * Read-only by default — create/update/delete throw.
  */
 export function createRecurringAdapter(schedule, options = {}) {
-    const { mondayStart = true } = options;
-    // Auto-color: assign from vivid palette by category/title
+    const { mondayStart = true, palette } = options;
+    const colors = palette?.length ? palette : PALETTE;
+    // Auto-color: assign from palette by category/title
     const colorAssignments = new Map();
     let colorIndex = 0;
     for (const rec of schedule) {
@@ -239,7 +242,7 @@ export function createRecurringAdapter(schedule, options = {}) {
             continue;
         const key = rec.category ?? rec.title;
         if (!colorAssignments.has(key)) {
-            colorAssignments.set(key, PALETTE[colorIndex % PALETTE.length]);
+            colorAssignments.set(key, colors[colorIndex % colors.length]);
             colorIndex++;
         }
     }
@@ -282,14 +285,7 @@ export function createRecurringAdapter(schedule, options = {}) {
             }
             return events;
         },
-        async createEvent() {
-            throw new Error('createRecurringAdapter is read-only. Use a memory or REST adapter for mutations.');
-        },
-        async updateEvent() {
-            throw new Error('createRecurringAdapter is read-only. Use a memory or REST adapter for mutations.');
-        },
-        async deleteEvent() {
-            throw new Error('createRecurringAdapter is read-only. Use a memory or REST adapter for mutations.');
-        },
+        // Read-only adapter: CRUD methods intentionally omitted.
+        // Use createMemoryAdapter or createRestAdapter for mutations.
     };
 }

package/dist/adapters/types.d.ts

@@ -15,9 +15,18 @@ export interface CalendarAdapter {
     /** Fetch events that overlap the given date range */
     fetchEvents(range: DateRange): Promise<TimelineEvent[]>;
     /** Create a new event, return it with a server-assigned ID */
-    createEvent(event: Omit<TimelineEvent, 'id'>): Promise<TimelineEvent>;
+    createEvent?(event: Omit<TimelineEvent, 'id'>): Promise<TimelineEvent>;
     /** Update an event, return the full updated event */
-    updateEvent(id: string, patch: Partial<TimelineEvent>): Promise<TimelineEvent>;
+    updateEvent?(id: string, patch: Partial<TimelineEvent>): Promise<TimelineEvent>;
     /** Delete an event by ID */
+    deleteEvent?(id: string): Promise<void>;
+}
+/**
+ * A CalendarAdapter that supports full CRUD operations.
+ * Use this type when you need to guarantee write support.
+ */
+export interface WritableCalendarAdapter extends CalendarAdapter {
+    createEvent(event: Omit<TimelineEvent, 'id'>): Promise<TimelineEvent>;
+    updateEvent(id: string, patch: Partial<TimelineEvent>): Promise<TimelineEvent>;
     deleteEvent(id: string): Promise<void>;
 }