@nomideusz/svelte-calendar 0.5.2 → 0.6.3

package/dist/adapters/memory.d.ts

@@ -2,24 +2,22 @@
  * In-memory adapter — the default for demos and testing.
  *
  * Events are stored in a plain array. No persistence across page loads.
- * Perfect for prototyping and unit tests.
+ * Events without a `color` are auto-assigned one from a palette,
+ * grouped by `category` or `title` so related events share a color.
  *
  * Usage:
  *   import { createMemoryAdapter } from './';
  *   const adapter = createMemoryAdapter(initialEvents);
- *   const store = createEventStore(adapter);
+ *   const adapter = createMemoryAdapter(initialEvents, { palette: myColors });
  */
 import type { TimelineEvent } from '../core/types.js';
 import type { CalendarAdapter } from './types.js';
 export interface MemoryAdapterOptions {
-    /** Map of category/title to color */
-    colorMap?: Record<string, string>;
     /**
-     * Auto-assign colors to events by category or title.
-     *   true    → use the default vivid palette
-     *   string  → hex accent color (e.g. '#6366f1') to generate a
-     *             theme-harmonious palette via golden-angle hue rotation
+     * Custom color palette for auto-coloring events.
+     * Defaults to VIVID_PALETTE. Pass `generatePalette(accent)` to
+     * make event colors adapt to your theme.
      */
-    autoColor?: boolean | string;
+    palette?: string[];
 }
 export declare function createMemoryAdapter(initial?: TimelineEvent[], options?: MemoryAdapterOptions): CalendarAdapter;

package/dist/adapters/memory.js

@@ -1,38 +1,23 @@
-import { generatePalette, VIVID_PALETTE } from '../core/palette.js';
+import { VIVID_PALETTE } from '../core/palette.js';
 let counter = 0;
 function uid() {
     return `mem-${Date.now()}-${++counter}`;
 }
-/** Default palette for auto-coloring */
-const AUTO_COLORS = VIVID_PALETTE;
-export function createMemoryAdapter(initial = [], options = {}) {
-    const { colorMap, autoColor } = options;
+export function createMemoryAdapter(initial = [], options) {
     const events = [...initial];
-    // Resolve palette: vivid default or theme-aware
-    const palette = autoColor
-        ? typeof autoColor === 'string'
-            ? generatePalette(autoColor)
-            : AUTO_COLORS
-        : AUTO_COLORS;
-    // Build auto-color assignments
+    const palette = options?.palette ?? VIVID_PALETTE;
+    // Auto-color: assign from vivid palette by category/title
     const colorAssignments = new Map();
     let colorIndex = 0;
     function resolveColor(ev) {
         if (ev.color)
             return ev.color;
-        if (!colorMap && !autoColor)
-            return undefined;
         const key = ev.category ?? ev.title;
-        if (colorMap?.[key])
-            return colorMap[key];
-        if (autoColor) {
-            if (!colorAssignments.has(key)) {
-                colorAssignments.set(key, palette[colorIndex % palette.length]);
-                colorIndex++;
-            }
-            return colorAssignments.get(key);
+        if (!colorAssignments.has(key)) {
+            colorAssignments.set(key, palette[colorIndex % palette.length]);
+            colorIndex++;
         }
-        return undefined;
+        return colorAssignments.get(key);
     }
     function withColor(ev) {
         const color = resolveColor(ev);

package/dist/adapters/recurring.d.ts

@@ -63,19 +63,21 @@ export interface RecurringEvent {
 export interface RecurringAdapterOptions {
     /** Start weeks on Monday (default: true) */
     mondayStart?: boolean;
-    /** Map of category/title to color */
-    colorMap?: Record<string, string>;
     /**
-     * Auto-assign colors to events by category or title.
-     *   true    → use the default vivid palette
-     *   string  → hex accent color to generate a harmonious palette
+     * 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.
      */
-    autoColor?: boolean | string;
+    palette?: string[];
 }
 /**
  * Create a CalendarAdapter that projects recurring events onto concrete
  * dates for whatever range the calendar requests.
  *
+ * Events without a `color` are auto-assigned one from a vivid palette,
+ * grouped by `category` or `title` so related events share a color.
+ *
  * Read-only by default — create/update/delete throw.
  */
 export declare function createRecurringAdapter(schedule: RecurringEvent[], options?: RecurringAdapterOptions): CalendarAdapter;

package/dist/adapters/recurring.js

@@ -1,5 +1,5 @@
 import { startOfWeek, DAY_MS } from '../core/time.js';
-import { generatePalette, VIVID_PALETTE } from '../core/palette.js';
+import { VIVID_PALETTE } from '../core/palette.js';
 // ── Helpers ─────────────────────────────────────────────
 /** Parse "HH:MM" into [hours, minutes] */
 function parseTime(time) {
@@ -46,14 +46,21 @@ function clampDayOfMonth(year, month, day) {
     const lastDay = new Date(year, month + 1, 0).getDate();
     return new Date(year, month, Math.min(day, lastDay));
 }
+/** Format a Date as a compact "YYYYMMDD" key for stable instance IDs. */
+function dateKey(d) {
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    return `${y}${m}${day}`;
+}
 /** Create a concrete TimelineEvent from a recurring def + occurrence date */
-function createConcreteEvent(rec, date, instanceKey) {
+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);
     return {
-        id: `${rec.id}--${instanceKey}`,
+        id: `${rec.id}--${dateKey(date)}`,
         title: rec.title,
         start,
         end,
@@ -129,16 +136,14 @@ function projectDaily(rec, range, startDate, effectiveUntil, out) {
         if (cursor < rangeStart)
             cursor.setDate(cursor.getDate() + interval);
     }
-    let idx = 0;
     while (cursor < range.end) {
         if (effectiveUntil && cursor > effectiveUntil)
             break;
-        const ev = createConcreteEvent(rec, cursor, `d${idx}`);
+        const ev = createConcreteEvent(rec, cursor);
         if (ev.start < range.end && ev.end > range.start) {
             out.push(ev);
         }
         cursor.setDate(cursor.getDate() + interval);
-        idx++;
     }
 }
 function projectWeekly(rec, range, startDate, effectiveUntil, mondayStart, out) {
@@ -165,7 +170,6 @@ function projectWeekly(rec, range, startDate, effectiveUntil, mondayStart, out)
             weekMs += interval * 7 * DAY_MS;
         }
     }
-    let weekIndex = Math.round((weekMs - anchorWeekMs) / (7 * DAY_MS));
     while (weekMs < rangeEndMs) {
         for (const day of days) {
             const dayMs = weekMs + isoWeekdayToOffset(day) * DAY_MS;
@@ -176,13 +180,12 @@ function projectWeekly(rec, range, startDate, effectiveUntil, mondayStart, out)
             if (effectiveUntil && dayMs > effectiveUntil.getTime())
                 return;
             const dayDate = new Date(dayMs);
-            const ev = createConcreteEvent(rec, dayDate, `w${weekIndex}--d${day}`);
+            const ev = createConcreteEvent(rec, dayDate);
             if (ev.start < range.end && ev.end > range.start) {
                 out.push(ev);
             }
         }
         weekMs += interval * 7 * DAY_MS;
-        weekIndex += interval;
     }
 }
 function projectMonthly(rec, range, startDate, effectiveUntil, out) {
@@ -206,7 +209,7 @@ function projectMonthly(rec, range, startDate, effectiveUntil, out) {
         if (effectiveUntil && date > effectiveUntil)
             break;
         if (date >= range.start && (!startDate || date >= startDate)) {
-            const ev = createConcreteEvent(rec, date, `m${y}-${String(m + 1).padStart(2, '0')}`);
+            const ev = createConcreteEvent(rec, date);
             if (ev.start < range.end && ev.end > range.start) {
                 out.push(ev);
             }
@@ -216,34 +219,29 @@ function projectMonthly(rec, range, startDate, effectiveUntil, out) {
 }
 // ── Adapter factory ─────────────────────────────────────
 /** Default palette for auto-coloring */
-const AUTO_COLORS = VIVID_PALETTE;
+const PALETTE = VIVID_PALETTE;
 /**
  * Create a CalendarAdapter that projects recurring events onto concrete
  * dates for whatever range the calendar requests.
  *
+ * Events without a `color` are auto-assigned one from a vivid palette,
+ * grouped by `category` or `title` so related events share a color.
+ *
  * Read-only by default — create/update/delete throw.
  */
 export function createRecurringAdapter(schedule, options = {}) {
-    const { mondayStart = true, colorMap, autoColor } = options;
-    // Resolve palette
-    const palette = autoColor
-        ? typeof autoColor === 'string'
-            ? generatePalette(autoColor)
-            : AUTO_COLORS
-        : AUTO_COLORS;
-    // Build auto-color assignments
+    const { mondayStart = true, palette } = options;
+    const colors = palette?.length ? palette : PALETTE;
+    // Auto-color: assign from palette by category/title
     const colorAssignments = new Map();
-    if (autoColor || colorMap) {
-        let colorIndex = 0;
-        for (const rec of schedule) {
-            const key = rec.category ?? rec.title;
-            if (colorMap?.[key]) {
-                colorAssignments.set(key, colorMap[key]);
-            }
-            else if (autoColor && !colorAssignments.has(key)) {
-                colorAssignments.set(key, palette[colorIndex % palette.length]);
-                colorIndex++;
-            }
+    let colorIndex = 0;
+    for (const rec of schedule) {
+        if (rec.color)
+            continue;
+        const key = rec.category ?? rec.title;
+        if (!colorAssignments.has(key)) {
+            colorAssignments.set(key, colors[colorIndex % colors.length]);
+            colorIndex++;
         }
     }
     function resolveColor(rec) {