kalendly 0.1.6 → 0.2.0

package/dist/{vanilla/index.umd.js → index.umd.js}

@@ -18,34 +18,11 @@ var Kalendly = (() => {
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/vanilla/index.ts
-  var index_exports = {};
-  __export(index_exports, {
-    CalendarEngine: () => CalendarEngine,
-    DAYS: () => DAYS,
-    DEFAULT_CATEGORY_COLORS: () => DEFAULT_CATEGORY_COLORS,
-    MONTHS: () => MONTHS,
-    MONTHS_FULL: () => MONTHS_FULL,
-    VanillaCalendar: () => VanillaCalendar,
-    createCalendar: () => createCalendar,
-    formatAttendees: () => formatAttendees,
-    formatDateForDisplay: () => formatDateForDisplay,
-    formatTimeRange: () => formatTimeRange,
-    generateCalendarDates: () => generateCalendarDates,
-    generateYears: () => generateYears,
-    getCategoryColor: () => getCategoryColor,
-    getCellClasses: () => getCellClasses,
-    getDefaultEventColor: () => getDefaultEventColor,
-    getEventsForDate: () => getEventsForDate,
-    getMonthYearText: () => getMonthYearText,
-    getPopupPositionClass: () => getPopupPositionClass,
-    hasEvents: () => hasEvents,
-    isSameDay: () => isSameDay,
-    isToday: () => isToday,
-    isValidHexColor: () => isValidHexColor,
-    mergeCategoryColors: () => mergeCategoryColors,
-    normalizeDate: () => normalizeDate,
-    sortEventsByTime: () => sortEventsByTime
+  // src/web-components/CalendarElement.ts
+  var CalendarElement_exports = {};
+  __export(CalendarElement_exports, {
+    CalendarElement: () => CalendarElement,
+    defineCalendarElement: () => defineCalendarElement
   });
 
   // src/core/utils.ts
@@ -108,9 +85,6 @@ var Kalendly = (() => {
       return eventDate.getTime() === normalizedTargetDate.getTime();
     });
   }
-  function hasEvents(events, date) {
-    return getEventsForDate(events, date).length > 0;
-  }
   function generateCalendarDates(year, month, events = [], weekStartsOn = 0) {
     const firstDay = new Date(year, month, 1);
     const lastDay = new Date(year, month + 1, 0);
@@ -212,16 +186,6 @@ var Kalendly = (() => {
     if (attendees.length === 2) return attendees.join(" and ");
     return `${attendees.slice(0, -1).join(", ")}, and ${attendees[attendees.length - 1]}`;
   }
-  function sortEventsByTime(events) {
-    return [...events].sort((a, b) => {
-      const aAllDay = a.allDay || !a.startTime && !a.endTime;
-      const bAllDay = b.allDay || !b.startTime && !b.endTime;
-      if (aAllDay && !bAllDay) return -1;
-      if (!aAllDay && bAllDay) return 1;
-      if (!a.startTime || !b.startTime) return 0;
-      return a.startTime.localeCompare(b.startTime);
-    });
-  }
   var DEFAULT_CATEGORY_COLORS = {
     work: "#3b82f6",
     personal: "#8b5cf6",
@@ -230,13 +194,6 @@ var Kalendly = (() => {
     appointment: "#f59e0b",
     other: "#6b7280"
   };
-  function getDefaultEventColor(category, customColors) {
-    const colorMap = customColors || DEFAULT_CATEGORY_COLORS;
-    if (category && colorMap[category]) {
-      return colorMap[category];
-    }
-    return "#fc8917";
-  }
   function mergeCategoryColors(customColors) {
     return {
       ...DEFAULT_CATEGORY_COLORS,
@@ -480,78 +437,174 @@ var Kalendly = (() => {
     }
   };
 
-  // src/vanilla/Calendar.ts
-  var VanillaCalendar = class {
-    constructor(props) {
+  // src/web-components/CalendarElement.ts
+  var CalendarElement = class extends HTMLElement {
+    constructor() {
+      super(...arguments);
+      this.engine = null;
       this.unsubscribe = null;
+      this.actions = null;
       this.pickerOpen = false;
       this.yearInput = "";
       this.yearInputValid = true;
+      this.listenersAttached = false;
       this.clickOutsideHandler = null;
-      this.props = props;
-      if (typeof props.container === "string") {
-        const element = document.querySelector(props.container);
-        if (!element) {
-          throw new Error(`Container element "${props.container}" not found`);
-        }
-        this.container = element;
-      } else {
-        this.container = props.container;
+      this.delegatedClickHandler = null;
+      this.delegatedInputHandler = null;
+      this.delegatedBlurHandler = null;
+      this.delegatedKeydownHandler = null;
+      // Rich property backing fields
+      this._events = [];
+      this._theme = null;
+      this._categoryColors = null;
+      this._renderEvent = null;
+      this._renderNoEvents = null;
+    }
+    get events() {
+      return this._events;
+    }
+    set events(val) {
+      this._events = val;
+      if (this.engine) {
+        this.engine.updateEvents(val);
       }
-      this.engine = new CalendarEngine({
-        events: props.events,
-        initialDate: props.initialDate,
-        minYear: props.minYear,
-        maxYear: props.maxYear,
-        weekStartsOn: props.weekStartsOn
-      });
-      this.actions = this.engine.getActions();
+    }
+    set theme(val) {
+      this._theme = val;
       this.applyTheme();
-      this.init();
     }
-    applyTheme() {
-      if (this.props.theme) {
-        const root = document.documentElement;
-        const theme = this.props.theme;
-        if (theme.primary)
-          root.style.setProperty("--calendar-primary-color", theme.primary);
-        if (theme.secondary)
-          root.style.setProperty("--calendar-secondary-color", theme.secondary);
-        if (theme.tertiary)
-          root.style.setProperty("--calendar-tertiary-color", theme.tertiary);
-        if (theme.textColor)
-          root.style.setProperty("--calendar-text-color", theme.textColor);
-        if (theme.textLight)
-          root.style.setProperty("--calendar-text-light", theme.textLight);
-        if (theme.background)
-          root.style.setProperty("--calendar-background", theme.background);
-        if (theme.cellHover)
-          root.style.setProperty("--calendar-cell-hover", theme.cellHover);
-        if (theme.borderColor)
-          root.style.setProperty("--calendar-border-color", theme.borderColor);
-        if (theme.todayOutline)
-          root.style.setProperty("--calendar-today-outline", theme.todayOutline);
-        if (theme.selectedBg)
-          root.style.setProperty("--calendar-selected-bg", theme.selectedBg);
-        if (theme.eventIndicator)
-          root.style.setProperty(
-            "--calendar-event-indicator",
-            theme.eventIndicator
-          );
+    set categoryColors(val) {
+      this._categoryColors = val;
+      if (this.engine) {
+        this.engine.updateCategoryColors(val);
       }
     }
-    init() {
-      this.container.classList.add("kalendly-calendar");
-      if (this.props.className) {
-        this.container.classList.add(this.props.className);
-      }
+    set renderEvent(val) {
+      this._renderEvent = val;
+      if (this.engine) this.render();
+    }
+    set renderNoEvents(val) {
+      this._renderNoEvents = val;
+      if (this.engine) this.render();
+    }
+    connectedCallback() {
+      this.classList.add("kalendly-calendar");
+      this.initEngine();
+      this.render();
+    }
+    disconnectedCallback() {
+      this.cleanup();
+      this.classList.remove("kalendly-calendar");
+      this.innerHTML = "";
+    }
+    attributeChangedCallback(_name, oldVal, newVal) {
+      if (oldVal === newVal) return;
+      this.reinit();
+    }
+    get minYear() {
+      const val = this.getAttribute("min-year");
+      return val ? parseInt(val, 10) : (/* @__PURE__ */ new Date()).getFullYear() - 30;
+    }
+    get maxYear() {
+      const val = this.getAttribute("max-year");
+      return val ? parseInt(val, 10) : (/* @__PURE__ */ new Date()).getFullYear() + 10;
+    }
+    initEngine() {
+      const initialDateAttr = this.getAttribute("initial-date");
+      const initialDate = initialDateAttr ? new Date(initialDateAttr) : void 0;
+      const weekStartsOnAttr = this.getAttribute("week-starts-on");
+      const weekStartsOn = weekStartsOnAttr === "1" ? 1 : 0;
+      this.engine = new CalendarEngine({
+        events: this._events,
+        initialDate,
+        minYear: this.minYear,
+        maxYear: this.maxYear,
+        weekStartsOn,
+        categoryColors: this._categoryColors ?? void 0
+      });
+      this.actions = this.engine.getActions();
+      this.applyTheme();
       this.unsubscribe = this.engine.subscribe(() => {
         this.render();
       });
+    }
+    reinit() {
+      if (!this.engine) return;
+      this.cleanup();
+      this.initEngine();
       this.render();
     }
+    cleanup() {
+      if (this.unsubscribe) {
+        this.unsubscribe();
+        this.unsubscribe = null;
+      }
+      if (this.delegatedClickHandler) {
+        this.removeEventListener("click", this.delegatedClickHandler);
+        this.delegatedClickHandler = null;
+      }
+      if (this.delegatedInputHandler) {
+        this.removeEventListener("input", this.delegatedInputHandler);
+        this.delegatedInputHandler = null;
+      }
+      if (this.delegatedBlurHandler) {
+        this.removeEventListener("blur", this.delegatedBlurHandler, true);
+        this.delegatedBlurHandler = null;
+      }
+      if (this.delegatedKeydownHandler) {
+        this.removeEventListener("keydown", this.delegatedKeydownHandler);
+        this.delegatedKeydownHandler = null;
+      }
+      if (this.clickOutsideHandler) {
+        document.removeEventListener("click", this.clickOutsideHandler);
+        this.clickOutsideHandler = null;
+      }
+      this.listenersAttached = false;
+      if (this.engine) {
+        this.engine.destroy();
+        this.engine = null;
+      }
+      this.actions = null;
+    }
+    applyTheme() {
+      if (!this._theme) return;
+      const root = document.documentElement;
+      const t = this._theme;
+      if (t.primary)
+        root.style.setProperty("--calendar-primary-color", t.primary);
+      if (t.secondary)
+        root.style.setProperty("--calendar-secondary-color", t.secondary);
+      if (t.tertiary)
+        root.style.setProperty("--calendar-tertiary-color", t.tertiary);
+      if (t.textColor)
+        root.style.setProperty("--calendar-text-color", t.textColor);
+      if (t.textLight)
+        root.style.setProperty("--calendar-text-light", t.textLight);
+      if (t.background)
+        root.style.setProperty("--calendar-background", t.background);
+      if (t.cellHover)
+        root.style.setProperty("--calendar-cell-hover", t.cellHover);
+      if (t.borderColor)
+        root.style.setProperty("--calendar-border-color", t.borderColor);
+      if (t.todayOutline)
+        root.style.setProperty("--calendar-today-outline", t.todayOutline);
+      if (t.selectedBg)
+        root.style.setProperty("--calendar-selected-bg", t.selectedBg);
+      if (t.eventIndicator)
+        root.style.setProperty("--calendar-event-indicator", t.eventIndicator);
+    }
     render() {
+      if (!this.engine) return;
       const viewModel = this.engine.getViewModel();
+      const useShortMonths = this.hasAttribute("use-short-month-names");
+      const title = this.getAttribute("title");
+      const minYear = this.minYear;
+      const maxYear = this.maxYear;
+      const today = /* @__PURE__ */ new Date();
+      const todayMonth = today.getMonth();
+      const todayYear = today.getFullYear();
+      const isCurrentMonth = viewModel.currentYear === todayYear && viewModel.currentMonth === todayMonth;
+      const showScrollHint = viewModel.tasks.length > 3;
       const defaultRenderEvent = (event) => {
         const timeRange = formatTimeRange(event);
         const attendeesList = formatAttendees(event.attendees);
@@ -597,46 +650,46 @@ var Kalendly = (() => {
               ${event.status && event.status !== "scheduled" ? `<span class="badge status-${event.status}">${getStatusLabel(event.status)}</span>` : ""}
             </div>
           </div>
-          
+
           ${timeRange ? `
           <div class="event-time">
             <span class="event-time-label">Time:</span>
             <span class="event-time-value">${timeRange}</span>
           </div>
           ` : ""}
-          
+
           ${event.description ? `
           <div class="event-description">${event.description}</div>
           ` : ""}
-          
+
           ${event.location ? `
           <div class="event-time">
             <span class="event-time-label">Location:</span>
             <span class="event-time-value">${event.location}</span>
           </div>
           ` : ""}
-          
+
           ${attendeesList ? `
           <div class="event-time">
             <span class="event-time-label">Attendees:</span>
             <span class="event-time-value">${attendeesList}</span>
           </div>
           ` : ""}
-          
+
           ${event.organizer ? `
           <div class="event-time">
             <span class="event-time-label">Organizer:</span>
             <span class="event-time-value">${event.organizer}</span>
           </div>
           ` : ""}
-          
+
           ${event.notes ? `
           <div class="event-time">
             <span class="event-time-label">Notes:</span>
             <span class="event-time-value">${event.notes}</span>
           </div>
           ` : ""}
-          
+
           ${event.url ? `
           <div class="event-time">
             <a href="${event.url}" target="_blank" rel="noopener noreferrer" class="event-link">
@@ -644,7 +697,7 @@ var Kalendly = (() => {
             </a>
           </div>
           ` : ""}
-          
+
           ${event.tags && event.tags.length > 0 ? `
           <div class="event-tags">
             ${event.tags.map((tag) => `<span class="event-tag">${tag}</span>`).join("")}
@@ -654,25 +707,17 @@ var Kalendly = (() => {
       `;
       };
       const defaultRenderNoEvents = () => '<div class="no-events-message">No events scheduled for this day.</div>';
-      const renderEvent = this.props.renderEvent || defaultRenderEvent;
-      const renderNoEvents = this.props.renderNoEvents || defaultRenderNoEvents;
-      const showScrollHint = viewModel.tasks.length > 3;
-      const today = /* @__PURE__ */ new Date();
-      const todayMonth = today.getMonth();
-      const todayYear = today.getFullYear();
-      const minYear = this.props.minYear ?? todayYear - 30;
-      const maxYear = this.props.maxYear ?? todayYear + 10;
-      const isCurrentMonth = viewModel.currentYear === todayYear && viewModel.currentMonth === todayMonth;
+      const renderEvent = this._renderEvent || defaultRenderEvent;
+      const renderNoEvents = this._renderNoEvents || defaultRenderNoEvents;
       const html = `
-      ${this.props.title ? `
-        <div class="page--title">
-          <h1>${this.props.title}</h1>
-        </div>
+      ${title ? `
+      <div class="page--title">
+        <h1>${title}</h1>
+      </div>
       ` : ""}
 
       <div class="calendar--content">
         <div class="calendar--card">
-          <!-- Navigation Header -->
           <div class="calendar--nav-header">
             <button type="button" class="calendar--nav-arrow" data-action="previous" aria-label="Previous month">
               &#8249;
@@ -686,7 +731,7 @@ var Kalendly = (() => {
                 aria-expanded="${this.pickerOpen ? "true" : "false"}"
                 aria-haspopup="true"
               >
-                ${this.props.useShortMonthNames ? `${MONTHS[viewModel.currentMonth]} ${viewModel.currentYear}` : viewModel.monthAndYearText}
+                ${useShortMonths ? `${MONTHS[viewModel.currentMonth]} ${viewModel.currentYear}` : viewModel.monthAndYearText}
                 <span class="calendar--picker-chevron">&#9662;</span>
               </button>
 
@@ -717,7 +762,7 @@ var Kalendly = (() => {
                   </div>
 
                   <div class="calendar--picker-months">
-                    ${(this.props.useShortMonthNames ? MONTHS : MONTHS_FULL).map((month, index) => {
+                    ${(useShortMonths ? MONTHS : MONTHS_FULL).map((month, index) => {
         const isSelected = index === viewModel.currentMonth;
         const isCurrent = index === todayMonth && viewModel.currentYear === todayYear;
         return `
@@ -790,233 +835,204 @@ var Kalendly = (() => {
               ` : ""}
 
               <div class="events-container">
-                ${viewModel.tasks.length > 0 ? `
-                  ${viewModel.tasks.map((event) => renderEvent(event)).join("")}
-                ` : renderNoEvents()}
+                ${viewModel.tasks.length > 0 ? viewModel.tasks.map((event) => renderEvent(event)).join("") : renderNoEvents()}
               </div>
             </div>
           ` : ""}
         </div>
       </div>
     `;
-      this.container.innerHTML = html;
+      this.innerHTML = html;
       this.attachEventListeners();
     }
     attachEventListeners() {
-      const today = /* @__PURE__ */ new Date();
-      const todayYear = today.getFullYear();
-      const todayMonth = today.getMonth();
-      const minYear = this.props.minYear ?? todayYear - 30;
-      const maxYear = this.props.maxYear ?? todayYear + 10;
-      const tableBody = this.container.querySelector("[data-calendar-body]");
-      if (tableBody) {
-        tableBody.addEventListener("click", (e) => {
-          const target = e.target;
-          const cell = target.closest('td[data-clickable="true"]');
-          if (cell && cell.dataset.date) {
-            const date = new Date(cell.dataset.date);
-            const dayIndex = parseInt(cell.dataset.dayIndex || "0");
-            this.engine.handleDateClick(date, dayIndex);
-            this.container.dispatchEvent(
-              new CustomEvent("dateSelect", {
-                detail: { date, dayIndex }
-              })
-            );
-          }
-        });
-      }
-      const prevBtn = this.container.querySelector('[data-action="previous"]');
-      const nextBtn = this.container.querySelector('[data-action="next"]');
-      if (prevBtn) {
-        prevBtn.addEventListener("click", () => {
-          this.actions.previous();
-          this.dispatchMonthChange();
-        });
-      }
-      if (nextBtn) {
-        nextBtn.addEventListener("click", () => {
-          this.actions.next();
-          this.dispatchMonthChange();
-        });
-      }
-      const todayBtn = this.container.querySelector('[data-action="today"]');
-      if (todayBtn) {
-        todayBtn.addEventListener("click", () => {
-          this.actions.goToToday();
-          this.pickerOpen = false;
-          this.container.dispatchEvent(
-            new CustomEvent("monthChange", {
-              detail: { year: todayYear, month: todayMonth }
+      if (this.listenersAttached) return;
+      this.listenersAttached = true;
+      const minYear = this.minYear;
+      const maxYear = this.maxYear;
+      this.delegatedClickHandler = (e) => {
+        const target = e.target;
+        const cell = target.closest('td[data-clickable="true"]');
+        if (cell && cell.dataset.date) {
+          e.stopPropagation();
+          const date = new Date(cell.dataset.date);
+          const dayIndex = parseInt(cell.dataset.dayIndex || "0");
+          this.engine.handleDateClick(date, dayIndex);
+          this.dispatchEvent(
+            new CustomEvent("cal-date-select", {
+              bubbles: true,
+              composed: true,
+              detail: { date, events: this.engine.getEventsForDate(date) }
             })
           );
-        });
-      }
-      const pickerBtn = this.container.querySelector(
-        '[data-action="toggle-picker"]'
-      );
-      if (pickerBtn) {
-        pickerBtn.addEventListener("click", (e) => {
-          e.stopPropagation();
-          this.pickerOpen = !this.pickerOpen;
-          if (this.pickerOpen) {
-            this.yearInput = String(this.engine.getViewModel().currentYear);
-            this.yearInputValid = true;
-          }
-          this.render();
-        });
-      }
-      const yearPrevBtn = this.container.querySelector(
-        '[data-action="year-prev"]'
-      );
-      const yearNextBtn = this.container.querySelector(
-        '[data-action="year-next"]'
-      );
-      if (yearPrevBtn) {
-        yearPrevBtn.addEventListener("click", (e) => {
-          e.stopPropagation();
-          const vm = this.engine.getViewModel();
-          if (vm.currentYear > minYear) {
-            this.actions.jump(vm.currentYear - 1, vm.currentMonth);
-            this.yearInput = String(vm.currentYear - 1);
+          return;
+        }
+        const actionEl = target.closest("[data-action]");
+        if (!actionEl) return;
+        const action = actionEl.dataset.action;
+        e.stopPropagation();
+        switch (action) {
+          case "previous":
+            this.actions.previous();
             this.dispatchMonthChange();
-          }
-        });
-      }
-      if (yearNextBtn) {
-        yearNextBtn.addEventListener("click", (e) => {
-          e.stopPropagation();
-          const vm = this.engine.getViewModel();
-          if (vm.currentYear < maxYear) {
-            this.actions.jump(vm.currentYear + 1, vm.currentMonth);
-            this.yearInput = String(vm.currentYear + 1);
+            break;
+          case "next":
+            this.actions.next();
             this.dispatchMonthChange();
-          }
-        });
-      }
-      const yearInputEl = this.container.querySelector(
-        "[data-year-input]"
-      );
-      if (yearInputEl) {
-        yearInputEl.addEventListener("input", (e) => {
-          e.stopPropagation();
-          const value = e.target.value;
-          if (value === "" || /^\d+$/.test(value)) {
-            this.yearInput = value;
-            const year = parseInt(value, 10);
-            this.yearInputValid = value === "" || year >= minYear && year <= maxYear;
+            break;
+          case "today":
+            this.actions.goToToday();
+            this.pickerOpen = false;
+            this.dispatchMonthChange();
+            break;
+          case "toggle-picker":
+            this.pickerOpen = !this.pickerOpen;
+            if (this.pickerOpen) {
+              this.yearInput = String(this.engine.getViewModel().currentYear);
+              this.yearInputValid = true;
+            }
             this.render();
+            break;
+          case "year-prev": {
+            const vm = this.engine.getViewModel();
+            if (vm.currentYear > minYear) {
+              const newYear = vm.currentYear - 1;
+              this.yearInput = String(newYear);
+              this.updatePickerYear(newYear);
+              this.actions.jump(newYear, vm.currentMonth);
+              this.dispatchMonthChange();
+            }
+            break;
           }
-        });
-        yearInputEl.addEventListener("blur", (e) => {
-          e.stopPropagation();
-          const year = parseInt(this.yearInput, 10);
-          const vm = this.engine.getViewModel();
-          if (isNaN(year) || year < minYear || year > maxYear) {
-            this.yearInput = String(vm.currentYear);
-            this.yearInputValid = true;
-          } else {
-            this.actions.jump(year, vm.currentMonth);
-            this.dispatchMonthChange();
+          case "year-next": {
+            const vm = this.engine.getViewModel();
+            if (vm.currentYear < maxYear) {
+              const newYear = vm.currentYear + 1;
+              this.yearInput = String(newYear);
+              this.updatePickerYear(newYear);
+              this.actions.jump(newYear, vm.currentMonth);
+              this.dispatchMonthChange();
+            }
+            break;
           }
-          this.render();
-        });
-        yearInputEl.addEventListener("keydown", (e) => {
-          if (e.key === "Enter") {
-            yearInputEl.blur();
+          case "select-month": {
+            const month = parseInt(actionEl.dataset.month || "0", 10);
+            this.actions.jump(this.engine.getViewModel().currentYear, month);
+            this.pickerOpen = false;
+            this.dispatchMonthChange();
+            break;
           }
-        });
-      }
-      const monthBtns = this.container.querySelectorAll(
-        '[data-action="select-month"]'
-      );
-      monthBtns.forEach((btn) => {
-        btn.addEventListener("click", (e) => {
-          e.stopPropagation();
-          const month = parseInt(btn.dataset.month || "0", 10);
-          this.actions.jump(this.engine.getViewModel().currentYear, month);
-          this.pickerOpen = false;
+          case "close-popup":
+            this.engine.clearSelection();
+            break;
+        }
+      };
+      this.delegatedInputHandler = (e) => {
+        const target = e.target;
+        if (!target.matches("[data-year-input]")) return;
+        const value = target.value;
+        if (value === "" || /^\d+$/.test(value)) {
+          this.yearInput = value;
+          const year = parseInt(value, 10);
+          this.yearInputValid = value === "" || year >= minYear && year <= maxYear;
+          target.classList.toggle("invalid", !this.yearInputValid);
+        }
+      };
+      this.delegatedBlurHandler = (e) => {
+        const target = e.target;
+        if (!target.matches("[data-year-input]")) return;
+        const year = parseInt(this.yearInput, 10);
+        const vm = this.engine.getViewModel();
+        if (isNaN(year) || year < minYear || year > maxYear) {
+          this.yearInput = String(vm.currentYear);
+          this.yearInputValid = true;
+          target.value = this.yearInput;
+          target.classList.remove("invalid");
+        } else if (year !== vm.currentYear) {
+          this.actions.jump(year, vm.currentMonth);
           this.dispatchMonthChange();
-        });
-      });
-      const closeBtn = this.container.querySelector(
-        '[data-action="close-popup"]'
-      );
-      if (closeBtn) {
-        closeBtn.addEventListener("click", (e) => {
-          e.stopPropagation();
-          this.engine.clearSelection();
-        });
-      }
-      if (this.clickOutsideHandler) {
-        document.removeEventListener("click", this.clickOutsideHandler);
-      }
+        }
+      };
+      this.delegatedKeydownHandler = (e) => {
+        const target = e.target;
+        if (!target.matches("[data-year-input]")) return;
+        if (e.key === "Enter") target.blur();
+      };
+      this.addEventListener("click", this.delegatedClickHandler);
+      this.addEventListener("input", this.delegatedInputHandler);
+      this.addEventListener("blur", this.delegatedBlurHandler, true);
+      this.addEventListener("keydown", this.delegatedKeydownHandler);
       this.clickOutsideHandler = (e) => {
         const target = e.target;
-        const pickerBtn2 = this.container.querySelector(
-          '[data-action="toggle-picker"]'
-        );
-        if (pickerBtn2 && (target === pickerBtn2 || pickerBtn2.contains(target))) {
-          return;
-        }
-        const pickerContainer = this.container.querySelector(
-          "[data-picker-container]"
-        );
-        if (this.pickerOpen && pickerContainer && !pickerContainer.contains(target)) {
+        if (this.contains(target)) return;
+        if (this.pickerOpen) {
           this.pickerOpen = false;
           this.render();
           return;
         }
-        const popup = this.container.querySelector(".date-popup");
-        if (popup && !popup.contains(target) && !target.closest("[data-calendar-body]")) {
+        const popup = this.querySelector(".date-popup");
+        if (popup) {
           this.engine.clearSelection();
         }
       };
       document.addEventListener("click", this.clickOutsideHandler);
     }
+    updatePickerYear(year) {
+      const input = this.querySelector("[data-year-input]");
+      if (input) input.value = String(year);
+      const prevBtn = this.querySelector(
+        '[data-action="year-prev"]'
+      );
+      const nextBtn = this.querySelector(
+        '[data-action="year-next"]'
+      );
+      if (prevBtn) prevBtn.disabled = year <= this.minYear;
+      if (nextBtn) nextBtn.disabled = year >= this.maxYear;
+    }
     dispatchMonthChange() {
+      if (!this.engine) return;
       const vm = this.engine.getViewModel();
-      this.container.dispatchEvent(
-        new CustomEvent("monthChange", {
+      this.dispatchEvent(
+        new CustomEvent("cal-month-change", {
+          bubbles: true,
+          composed: true,
           detail: { year: vm.currentYear, month: vm.currentMonth }
         })
       );
     }
+    // Public API
     updateEvents(events) {
-      this.engine.updateEvents(events);
+      this.events = events;
     }
     updateTheme(theme) {
-      this.props.theme = theme;
-      this.applyTheme();
+      this.theme = theme;
     }
     getCurrentDate() {
-      return this.engine.getViewModel().selectedDate;
+      return this.engine?.getViewModel().selectedDate ?? null;
     }
     goToDate(date) {
-      this.actions.jump(date.getFullYear(), date.getMonth());
+      this.actions?.jump(date.getFullYear(), date.getMonth());
     }
     getEngine() {
+      if (!this.engine)
+        throw new Error("CalendarElement is not connected to the DOM");
       return this.engine;
     }
-    destroy() {
-      if (this.unsubscribe) {
-        this.unsubscribe();
-        this.unsubscribe = null;
-      }
-      if (this.clickOutsideHandler) {
-        document.removeEventListener("click", this.clickOutsideHandler);
-        this.clickOutsideHandler = null;
-      }
-      this.engine.destroy();
-      this.container.innerHTML = "";
-      this.container.classList.remove("kalendly-calendar");
-      if (this.props.className) {
-        this.container.classList.remove(this.props.className);
-      }
-    }
   };
-  function createCalendar(props) {
-    return new VanillaCalendar(props);
+  CalendarElement.observedAttributes = [
+    "initial-date",
+    "min-year",
+    "max-year",
+    "week-starts-on",
+    "title",
+    "use-short-month-names"
+  ];
+  function defineCalendarElement(tagName = "kal-calendar") {
+    if (typeof customElements !== "undefined" && !customElements.get(tagName)) {
+      customElements.define(tagName, CalendarElement);
+    }
   }
-  return __toCommonJS(index_exports);
+  return __toCommonJS(CalendarElement_exports);
 })();
+if (typeof customElements !== 'undefined' && !customElements.get('kal-calendar')) { customElements.define('kal-calendar', Kalendly.CalendarElement); }
 //# sourceMappingURL=index.umd.js.map