@forcecalendar/interface 0.10.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forcecalendar/interface",
-  "version": "0.10.0",
+  "version": "1.0.0",
   "type": "module",
   "description": "Official interface layer for forceCalendar Core - Enterprise calendar components",
   "main": "dist/force-calendar-interface.umd.js",

package/src/components/views/MonthView.js

@@ -108,11 +108,30 @@ export class MonthView extends BaseComponent {
     }
 
     getContrastingTextColor(bgColor) {
-        if (!bgColor) return 'white';
-        const color = (bgColor.charAt(0) === '#') ? bgColor.substring(1, 7) : bgColor;
-        const r = parseInt(color.substring(0, 2), 16);
-        const g = parseInt(color.substring(2, 4), 16);
-        const b = parseInt(color.substring(4, 6), 16);
+        if (!bgColor || typeof bgColor !== 'string') return 'white';
+
+        // Extract hex color, removing # if present
+        const color = (bgColor.charAt(0) === '#') ? bgColor.substring(1) : bgColor;
+
+        // Validate hex format (3 or 6 characters)
+        if (!/^[0-9A-Fa-f]{3}$|^[0-9A-Fa-f]{6}$/.test(color)) {
+            return 'white'; // Fallback for invalid format
+        }
+
+        // Expand 3-char hex to 6-char
+        const fullColor = color.length === 3
+            ? color[0] + color[0] + color[1] + color[1] + color[2] + color[2]
+            : color;
+
+        const r = parseInt(fullColor.substring(0, 2), 16);
+        const g = parseInt(fullColor.substring(2, 4), 16);
+        const b = parseInt(fullColor.substring(4, 6), 16);
+
+        // Check for NaN (shouldn't happen with validation, but just in case)
+        if (isNaN(r) || isNaN(g) || isNaN(b)) {
+            return 'white';
+        }
+
         const uicolors = [r / 255, g / 255, b / 255];
         const c = uicolors.map((col) => {
             if (col <= 0.03928) {

package/src/core/EventBus.js

@@ -102,13 +102,14 @@ class EventBus {
             }
         }
 
-        // Handle wildcard subscriptions
-        for (const subscription of this.wildcardHandlers) {
+        // Handle wildcard subscriptions (copy Set to avoid mutation during iteration)
+        const toRemove = [];
+        for (const subscription of [...this.wildcardHandlers]) {
             if (this.matchesPattern(eventName, subscription.pattern)) {
                 const { handler, once } = subscription;
 
                 if (once) {
-                    this.wildcardHandlers.delete(subscription);
+                    toRemove.push(subscription);
                 }
 
                 try {
@@ -121,6 +122,8 @@ class EventBus {
                 }
             }
         }
+        // Remove one-time handlers after iteration
+        toRemove.forEach(sub => this.wildcardHandlers.delete(sub));
 
         return Promise.all(promises);
     }

package/src/core/StateManager.js

@@ -145,33 +145,53 @@ class StateManager {
     // Event management
     addEvent(event) {
         const addedEvent = this.calendar.addEvent(event);
-        this.state.events.push(addedEvent);
-        this.setState({ events: [...this.state.events] });
+        if (!addedEvent) {
+            console.error('Failed to add event to calendar');
+            eventBus.emit('event:error', { action: 'add', event, error: 'Failed to add event' });
+            return null;
+        }
+        // Create new array to avoid mutation before setState
+        const newEvents = [...this.state.events, addedEvent];
+        this.setState({ events: newEvents });
         eventBus.emit('event:added', { event: addedEvent });
         return addedEvent;
     }
 
     updateEvent(eventId, updates) {
         const event = this.calendar.updateEvent(eventId, updates);
-        if (event) {
-            const index = this.state.events.findIndex(e => e.id === eventId);
-            if (index > -1) {
-                this.state.events[index] = event;
-                this.setState({ events: [...this.state.events] });
-                eventBus.emit('event:updated', { event });
-            }
+        if (!event) {
+            console.error(`Failed to update event: ${eventId}`);
+            eventBus.emit('event:error', { action: 'update', eventId, updates, error: 'Event not found in calendar' });
+            return null;
         }
+
+        const index = this.state.events.findIndex(e => e.id === eventId);
+        if (index === -1) {
+            console.error(`Event ${eventId} not found in state`);
+            eventBus.emit('event:error', { action: 'update', eventId, error: 'Event not found in state' });
+            return null;
+        }
+
+        // Create new array to avoid mutation before setState
+        const newEvents = [...this.state.events];
+        newEvents[index] = event;
+        this.setState({ events: newEvents });
+        eventBus.emit('event:updated', { event });
         return event;
     }
 
     deleteEvent(eventId) {
         const deleted = this.calendar.removeEvent(eventId);
-        if (deleted) {
-            this.state.events = this.state.events.filter(e => e.id !== eventId);
-            this.setState({ events: [...this.state.events] });
-            eventBus.emit('event:deleted', { eventId });
+        if (!deleted) {
+            console.error(`Failed to delete event: ${eventId}`);
+            eventBus.emit('event:error', { action: 'delete', eventId, error: 'Event not found' });
+            return false;
         }
-        return deleted;
+        // Create new array to avoid mutation before setState
+        const newEvents = this.state.events.filter(e => e.id !== eventId);
+        this.setState({ events: newEvents });
+        eventBus.emit('event:deleted', { eventId });
+        return true;
     }
 
     getEvents() {

package/src/utils/DOMUtils.js

@@ -255,6 +255,15 @@ export class DOMUtils {
         const focusableElements = container.querySelectorAll(
             'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
         );
+
+        // Handle case where there are no focusable elements
+        if (focusableElements.length === 0) {
+            // Make container focusable as fallback
+            container.setAttribute('tabindex', '-1');
+            container.focus();
+            return () => container.removeAttribute('tabindex');
+        }
+
         const firstFocusable = focusableElements[0];
         const lastFocusable = focusableElements[focusableElements.length - 1];
 
@@ -263,12 +272,12 @@ export class DOMUtils {
 
             if (e.shiftKey) {
                 if (document.activeElement === firstFocusable) {
-                    lastFocusable.focus();
+                    lastFocusable?.focus();
                     e.preventDefault();
                 }
             } else {
                 if (document.activeElement === lastFocusable) {
-                    firstFocusable.focus();
+                    firstFocusable?.focus();
                     e.preventDefault();
                 }
             }