sibujs 1.0.0-beta.1

package/dist/widgets.cjs

@@ -0,0 +1,919 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// widgets.ts
+var widgets_exports = {};
+__export(widgets_exports, {
+  accordion: () => accordion,
+  combobox: () => combobox,
+  contentEditable: () => contentEditable,
+  datePicker: () => datePicker,
+  fileUpload: () => fileUpload,
+  popover: () => popover,
+  select: () => select,
+  tabs: () => tabs,
+  tooltip: () => tooltip
+});
+module.exports = __toCommonJS(widgets_exports);
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  subscriberStack.push(subscriber);
+  currentSubscriber = subscriber;
+  effectFn();
+  subscriberStack.pop();
+  currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    subscriberStack.push(null);
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    trackingSuspended = false;
+  }
+}
+function recordDependency(signal2) {
+  if (!currentSubscriber) return;
+  let deps = currentSubscriber._deps;
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    currentSubscriber._deps = deps;
+  }
+  if (!deps.has(signal2)) {
+    deps.add(signal2);
+    let subs = signal2[SUBS];
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal2, subs);
+      signal2[SUBS] = subs;
+    }
+    subs.add(currentSubscriber);
+    if (subs.size === 1) {
+      signal2.__f = currentSubscriber;
+    } else if (signal2.__f !== void 0) {
+      signal2.__f = void 0;
+    }
+  }
+}
+function queueSignalNotification(signal2) {
+  const subs = signal2[SUBS];
+  if (!subs) return;
+  for (const sub of subs) {
+    if (sub._c) {
+      propagateDirty(sub);
+    } else if (!pendingSet.has(sub)) {
+      pendingSet.add(sub);
+      pendingQueue.push(sub);
+    }
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i = 0;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  let sig = sub._sig;
+  let suspended = false;
+  if (sig && sig._g) {
+    const sDeps = sub._deps;
+    if (sDeps && sDeps.size === 1) {
+      suspendTracking();
+      suspended = true;
+      const s = sig;
+      s._d = false;
+      s._v = s._g();
+    }
+  }
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        if (suspended && nSig._g) {
+          const fDeps = first._deps;
+          if (fDeps && fDeps.size === 1) {
+            nSig._d = false;
+            nSig._v = nSig._g();
+          }
+        }
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s of subs) {
+      if (s._c) {
+        s();
+        const nSig = s._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s);
+        }
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    sig = nextSig;
+  }
+  if (suspended) resumeTracking();
+}
+function notifySubscribers(signal2) {
+  const first = signal2.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        first();
+      }
+      let i = 0;
+      while (i < pendingQueue.length) {
+        pendingQueue[i]();
+        i++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal2[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub of subs) {
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub of subs) {
+      pendingQueue[directCount++] = sub;
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (pendingQueue[i2]._c) {
+        propagateDirty(pendingQueue[i2]);
+      }
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (!pendingQueue[i2]._c) {
+        if (!pendingSet.has(pendingQueue[i2])) {
+          pendingQueue[i2]();
+        }
+      }
+    }
+    let i = directCount;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const deps = subscriber._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : true;
+}
+function devAssert(condition, message) {
+  if (isDev() && !condition) {
+    throw new Error(`[Sibu] ${message}`);
+  }
+}
+
+// src/core/signals/derived.ts
+function derived(getter, options) {
+  devAssert(typeof getter === "function", "derived: argument must be a getter function.");
+  const debugName = options?.name;
+  const cs = {};
+  cs._d = false;
+  cs._g = getter;
+  const markDirty = () => {
+    if (cs._d) return;
+    cs._d = true;
+  };
+  markDirty._c = 1;
+  markDirty._sig = cs;
+  track(() => {
+    cs._d = false;
+    cs._v = getter();
+  }, markDirty);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  function computedGetter() {
+    if (trackingSuspended) {
+      if (cs._d) {
+        cs._d = false;
+        cs._v = getter();
+      }
+      return cs._v;
+    }
+    recordDependency(cs);
+    if (cs._d) {
+      const oldValue = cs._v;
+      cs._d = false;
+      suspendTracking();
+      try {
+        cs._v = getter();
+      } finally {
+        resumeTracking();
+      }
+      if (hook && oldValue !== cs._v) {
+        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      }
+    }
+    return cs._v;
+  }
+  if (debugName) {
+    computedGetter.__name = debugName;
+    cs.__name = debugName;
+  }
+  computedGetter.__signal = cs;
+  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  return computedGetter;
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+function flushBatch() {
+  const signals = Array.from(pendingSignals);
+  pendingSignals.clear();
+  for (const signal2 of signals) {
+    queueSignalNotification(signal2);
+  }
+  drainNotificationQueue();
+}
+
+// src/core/signals/signal.ts
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = options?.name;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    const oldValue = state.value;
+    state.value = newValue;
+    const hook2 = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook2) hook2.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  return [get, set];
+}
+
+// src/widgets/Combobox.ts
+function combobox(options) {
+  const { items, filterFn, itemToString } = options;
+  const defaultFilterFn = (item, q) => {
+    const str = itemToString ? itemToString(item) : String(item);
+    return str.toLowerCase().includes(q.toLowerCase());
+  };
+  const filter = filterFn ?? defaultFilterFn;
+  const [query, setQuery] = signal("");
+  const [selectedItem, setSelectedItem] = signal(null);
+  const [highlightedIndex, setHighlightedIndex] = signal(-1);
+  const [isOpen, setIsOpen] = signal(false);
+  const filteredItems = derived(() => {
+    const q = query();
+    if (q === "") return items;
+    return items.filter((item) => filter(item, q));
+  });
+  function select2(item) {
+    batch(() => {
+      setSelectedItem(item);
+      const str = itemToString ? itemToString(item) : String(item);
+      setQuery(str);
+      setIsOpen(false);
+    });
+  }
+  function highlightNext() {
+    const filtered = filteredItems();
+    if (filtered.length === 0) return;
+    setHighlightedIndex((prev) => {
+      const next = prev + 1;
+      return next >= filtered.length ? 0 : next;
+    });
+  }
+  function highlightPrev() {
+    const filtered = filteredItems();
+    if (filtered.length === 0) return;
+    setHighlightedIndex((prev) => {
+      const next = prev - 1;
+      return next < 0 ? filtered.length - 1 : next;
+    });
+  }
+  function selectHighlighted() {
+    const filtered = filteredItems();
+    const idx = highlightedIndex();
+    if (idx >= 0 && idx < filtered.length) {
+      select2(filtered[idx]);
+    }
+  }
+  function open() {
+    setIsOpen(true);
+  }
+  function close() {
+    setIsOpen(false);
+  }
+  return {
+    query,
+    setQuery,
+    filteredItems,
+    selectedItem,
+    select: select2,
+    highlightedIndex,
+    highlightNext,
+    highlightPrev,
+    selectHighlighted,
+    isOpen,
+    open,
+    close
+  };
+}
+
+// src/widgets/Tabs.ts
+function tabs(options) {
+  const { tabs: tabDefs, defaultTab } = options;
+  const initialTab = defaultTab ?? tabDefs.find((t) => !t.disabled)?.id ?? tabDefs[0]?.id ?? "";
+  const [activeTab, setActiveTabState] = signal(initialTab);
+  function setActiveTab(id) {
+    const tab = tabDefs.find((t) => t.id === id);
+    if (tab && !tab.disabled) {
+      setActiveTabState(id);
+    }
+  }
+  const tabs2 = derived(
+    () => tabDefs.map((t) => ({
+      ...t,
+      isActive: t.id === activeTab()
+    }))
+  );
+  function findCurrentIndex() {
+    return tabDefs.findIndex((t) => t.id === activeTab());
+  }
+  function nextTab() {
+    const currentIdx = findCurrentIndex();
+    const len = tabDefs.length;
+    if (len === 0) return;
+    for (let i = 1; i <= len; i++) {
+      const candidate = tabDefs[(currentIdx + i) % len];
+      if (!candidate.disabled) {
+        setActiveTabState(candidate.id);
+        return;
+      }
+    }
+  }
+  function prevTab() {
+    const currentIdx = findCurrentIndex();
+    const len = tabDefs.length;
+    if (len === 0) return;
+    for (let i = 1; i <= len; i++) {
+      const candidate = tabDefs[(currentIdx - i + len) % len];
+      if (!candidate.disabled) {
+        setActiveTabState(candidate.id);
+        return;
+      }
+    }
+  }
+  return {
+    activeTab,
+    setActiveTab,
+    tabs: tabs2,
+    nextTab,
+    prevTab
+  };
+}
+
+// src/widgets/Accordion.ts
+function accordion(options) {
+  const { items: itemDefs, multiple = false, defaultExpanded = [] } = options;
+  const [expandedIds, setExpandedIds] = signal(new Set(defaultExpanded));
+  const items = derived(
+    () => itemDefs.map((item) => ({
+      ...item,
+      isExpanded: expandedIds().has(item.id)
+    }))
+  );
+  function expand(id) {
+    if (!itemDefs.some((item) => item.id === id)) return;
+    if (multiple) {
+      setExpandedIds((prev) => {
+        const next = new Set(prev);
+        next.add(id);
+        return next;
+      });
+    } else {
+      setExpandedIds(/* @__PURE__ */ new Set([id]));
+    }
+  }
+  function collapse(id) {
+    setExpandedIds((prev) => {
+      const next = new Set(prev);
+      next.delete(id);
+      return next;
+    });
+  }
+  function toggle(id) {
+    if (expandedIds().has(id)) {
+      collapse(id);
+    } else {
+      expand(id);
+    }
+  }
+  function expandAll() {
+    if (multiple) {
+      setExpandedIds(new Set(itemDefs.map((item) => item.id)));
+    }
+  }
+  function collapseAll() {
+    setExpandedIds(/* @__PURE__ */ new Set());
+  }
+  return {
+    items,
+    toggle,
+    expand,
+    collapse,
+    expandAll,
+    collapseAll
+  };
+}
+
+// src/widgets/Popover.ts
+function popover() {
+  const [isOpen, setIsOpen] = signal(false);
+  function open() {
+    setIsOpen(true);
+  }
+  function close() {
+    setIsOpen(false);
+  }
+  function toggle() {
+    setIsOpen((prev) => !prev);
+  }
+  return { isOpen, open, close, toggle };
+}
+
+// src/widgets/Select.ts
+function select(options) {
+  const { items, multiple = false } = options;
+  const [selectedItems, setSelectedItems] = signal([]);
+  const [isOpen, setIsOpen] = signal(false);
+  const [highlightedIndex, setHighlightedIndex] = signal(-1);
+  const selectedItem = derived(() => {
+    const sel = selectedItems();
+    return sel.length > 0 ? sel[sel.length - 1] : null;
+  });
+  function select2(item) {
+    if (multiple) {
+      setSelectedItems((prev) => {
+        if (prev.includes(item)) return prev;
+        return [...prev, item];
+      });
+    } else {
+      batch(() => {
+        setSelectedItems([item]);
+        setIsOpen(false);
+      });
+    }
+  }
+  function deselect(item) {
+    setSelectedItems((prev) => prev.filter((i) => i !== item));
+  }
+  function toggle(item) {
+    if (selectedItems().includes(item)) {
+      deselect(item);
+    } else {
+      select2(item);
+    }
+  }
+  function isSelected(item) {
+    return selectedItems().includes(item);
+  }
+  function open() {
+    setIsOpen(true);
+  }
+  function close() {
+    setIsOpen(false);
+  }
+  function highlightNext() {
+    if (items.length === 0) return;
+    setHighlightedIndex((prev) => {
+      const next = prev + 1;
+      return next >= items.length ? 0 : next;
+    });
+  }
+  function highlightPrev() {
+    if (items.length === 0) return;
+    setHighlightedIndex((prev) => {
+      const next = prev - 1;
+      return next < 0 ? items.length - 1 : next;
+    });
+  }
+  function selectHighlighted() {
+    const idx = highlightedIndex();
+    if (idx >= 0 && idx < items.length) {
+      select2(items[idx]);
+    }
+  }
+  function clear() {
+    setSelectedItems([]);
+  }
+  return {
+    selectedItems,
+    selectedItem,
+    select: select2,
+    deselect,
+    toggle,
+    isSelected,
+    isOpen,
+    open,
+    close,
+    highlightedIndex,
+    highlightNext,
+    highlightPrev,
+    selectHighlighted,
+    clear
+  };
+}
+
+// src/widgets/Tooltip.ts
+function tooltip(options) {
+  const delay = options?.delay ?? 0;
+  const [isVisible, setIsVisible] = signal(false);
+  const [content, setContent] = signal("");
+  let delayTimer = null;
+  function show() {
+    if (delay > 0) {
+      if (delayTimer !== null) {
+        clearTimeout(delayTimer);
+      }
+      delayTimer = setTimeout(() => {
+        setIsVisible(true);
+        delayTimer = null;
+      }, delay);
+    } else {
+      setIsVisible(true);
+    }
+  }
+  function hide() {
+    if (delayTimer !== null) {
+      clearTimeout(delayTimer);
+      delayTimer = null;
+    }
+    setIsVisible(false);
+  }
+  return { isVisible, show, hide, content, setContent };
+}
+
+// src/widgets/FileUpload.ts
+function fileUpload(options) {
+  const accept = options?.accept;
+  const multiple = options?.multiple ?? false;
+  const maxSize = options?.maxSize;
+  const onFiles = options?.onFiles;
+  const [files, setFiles] = signal([]);
+  const [errors, setErrors] = signal([]);
+  const [isDragOver, setDragOver] = signal(false);
+  function isAccepted(file) {
+    if (!accept) return true;
+    const acceptedTypes = accept.split(",").map((t) => t.trim().toLowerCase());
+    const fileName = file.name.toLowerCase();
+    const fileType = file.type.toLowerCase();
+    return acceptedTypes.some((pattern) => {
+      if (pattern.startsWith(".")) {
+        return fileName.endsWith(pattern);
+      }
+      if (pattern.endsWith("/*")) {
+        const prefix = pattern.slice(0, pattern.indexOf("/"));
+        return fileType.startsWith(`${prefix}/`);
+      }
+      return fileType === pattern;
+    });
+  }
+  function addFiles(fileList) {
+    const incoming = Array.from(fileList);
+    const validFiles = [];
+    const newErrors = [];
+    for (const file of incoming) {
+      if (!isAccepted(file)) {
+        newErrors.push(`File "${file.name}" is not an accepted type`);
+        continue;
+      }
+      if (maxSize !== void 0 && file.size > maxSize) {
+        newErrors.push(`File "${file.name}" exceeds maximum size of ${maxSize} bytes`);
+        continue;
+      }
+      validFiles.push(file);
+    }
+    batch(() => {
+      setErrors(newErrors);
+      if (validFiles.length > 0) {
+        if (multiple) {
+          setFiles((prev) => [...prev, ...validFiles]);
+        } else {
+          setFiles([validFiles[validFiles.length - 1]]);
+        }
+        if (onFiles) {
+          onFiles(validFiles);
+        }
+      }
+    });
+  }
+  function removeFile(index) {
+    setFiles((prev) => {
+      if (index < 0 || index >= prev.length) return prev;
+      const next = [...prev];
+      next.splice(index, 1);
+      return next;
+    });
+  }
+  function clear() {
+    batch(() => {
+      setFiles([]);
+      setErrors([]);
+    });
+  }
+  return {
+    files,
+    addFiles,
+    removeFile,
+    clear,
+    errors,
+    isDragOver,
+    setDragOver
+  };
+}
+
+// src/widgets/contentEditable.ts
+function contentEditable() {
+  const [content, setContent] = signal("");
+  const [isFocused, setFocused] = signal(false);
+  function execCommand(command, value) {
+    if (typeof document !== "undefined" && document.execCommand) {
+      document.execCommand(command, false, value ?? "");
+    }
+  }
+  function bold() {
+    execCommand("bold");
+  }
+  function italic() {
+    execCommand("italic");
+  }
+  function underline() {
+    execCommand("underline");
+  }
+  return {
+    content,
+    setContent,
+    isFocused,
+    setFocused,
+    execCommand,
+    bold,
+    italic,
+    underline
+  };
+}
+
+// src/widgets/datePicker.ts
+function datePicker(options) {
+  const minDate = options?.minDate;
+  const maxDate = options?.maxDate;
+  const initialDate = options?.initialDate ?? null;
+  const [selectedDate, setSelectedDate] = signal(initialDate);
+  const [viewDate, setViewDate] = signal(initialDate ?? /* @__PURE__ */ new Date());
+  function isDateDisabled(date) {
+    if (minDate && date < stripTime(minDate)) return true;
+    if (maxDate && date > stripTime(maxDate)) return true;
+    return false;
+  }
+  function stripTime(d) {
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  }
+  function sameDay(a, b) {
+    return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+  }
+  function select2(date) {
+    if (!isDateDisabled(date)) {
+      setSelectedDate(date);
+    }
+  }
+  function nextMonth() {
+    setViewDate((prev) => {
+      const next = new Date(prev);
+      next.setMonth(next.getMonth() + 1);
+      return next;
+    });
+  }
+  function prevMonth() {
+    setViewDate((prev) => {
+      const next = new Date(prev);
+      next.setMonth(next.getMonth() - 1);
+      return next;
+    });
+  }
+  function nextYear() {
+    setViewDate((prev) => {
+      const next = new Date(prev);
+      next.setFullYear(next.getFullYear() + 1);
+      return next;
+    });
+  }
+  function prevYear() {
+    setViewDate((prev) => {
+      const next = new Date(prev);
+      next.setFullYear(next.getFullYear() - 1);
+      return next;
+    });
+  }
+  const daysInMonth = derived(() => {
+    const vd = viewDate();
+    const year = vd.getFullYear();
+    const month = vd.getMonth();
+    const today = /* @__PURE__ */ new Date();
+    const selected = selectedDate();
+    const firstDay = new Date(year, month, 1);
+    const startDow = firstDay.getDay();
+    const lastDay = new Date(year, month + 1, 0);
+    const totalDaysInMonth = lastDay.getDate();
+    const days = [];
+    for (let i = startDow - 1; i >= 0; i--) {
+      const date = new Date(year, month, -i);
+      days.push({
+        date,
+        isCurrentMonth: false,
+        isToday: sameDay(date, today),
+        isSelected: selected !== null && sameDay(date, selected),
+        isDisabled: isDateDisabled(date)
+      });
+    }
+    for (let d = 1; d <= totalDaysInMonth; d++) {
+      const date = new Date(year, month, d);
+      days.push({
+        date,
+        isCurrentMonth: true,
+        isToday: sameDay(date, today),
+        isSelected: selected !== null && sameDay(date, selected),
+        isDisabled: isDateDisabled(date)
+      });
+    }
+    const remaining = days.length % 7;
+    if (remaining > 0) {
+      const trailingCount = 7 - remaining;
+      for (let i = 1; i <= trailingCount; i++) {
+        const date = new Date(year, month + 1, i);
+        days.push({
+          date,
+          isCurrentMonth: false,
+          isToday: sameDay(date, today),
+          isSelected: selected !== null && sameDay(date, selected),
+          isDisabled: isDateDisabled(date)
+        });
+      }
+    }
+    return days;
+  });
+  return {
+    selectedDate,
+    select: select2,
+    viewDate,
+    setViewDate,
+    nextMonth,
+    prevMonth,
+    nextYear,
+    prevYear,
+    daysInMonth,
+    isDateDisabled
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  accordion,
+  combobox,
+  contentEditable,
+  datePicker,
+  fileUpload,
+  popover,
+  select,
+  tabs,
+  tooltip
+});