react-schedule-picker 1.0.0

package/dist/index.js

@@ -0,0 +1,956 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DAY_LABELS: () => DAY_LABELS,
+  DAY_ORDER: () => DAY_ORDER,
+  DEFAULT_PRESETS: () => DEFAULT_PRESETS,
+  HOURS: () => HOURS,
+  LOCALE_PRESETS: () => LOCALE_PRESETS,
+  SchedulePicker: () => SchedulePicker,
+  applyRect: () => applyRect,
+  countSelectedHours: () => countSelectedHours,
+  createEmptySchedule: () => createEmptySchedule,
+  createFullSchedule: () => createFullSchedule,
+  formatHourHeader: () => formatHourHeader,
+  fromRanges: () => fromRanges,
+  generateSlots: () => generateSlots,
+  getDefaultPresets: () => getDefaultPresets,
+  hasHour: () => hasHour,
+  isAllSelected: () => isAllSelected,
+  isSlotDisabled: () => isSlotDisabled,
+  resolveLocaleConfig: () => resolveLocaleConfig,
+  rotateDays: () => rotateDays,
+  slotToTimeString: () => slotToTimeString,
+  summarizeSchedule: () => summarizeSchedule,
+  toISO: () => toISO,
+  toRanges: () => toRanges,
+  toggleHour: () => toggleHour
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/SchedulePicker.tsx
+var import_react = require("react");
+
+// src/constants.ts
+var DAY_ORDER = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+var DAY_LABELS = {
+  mon: "Mon",
+  tue: "Tue",
+  wed: "Wed",
+  thu: "Thu",
+  fri: "Fri",
+  sat: "Sat",
+  sun: "Sun"
+};
+var HOURS = Array.from({ length: 24 }, (_, i) => i);
+var WEEKDAYS = ["mon", "tue", "wed", "thu", "fri"];
+var WEEKENDS = ["sat", "sun"];
+var DAY_HOURS = [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17];
+var NIGHT_HOURS = [18, 19, 20, 21, 22, 23, 0, 1, 2, 3, 4, 5];
+var DEFAULT_PRESETS = [
+  { label: "Weekday Day", days: WEEKDAYS, hours: DAY_HOURS },
+  { label: "Weekday Night", days: WEEKDAYS, hours: NIGHT_HOURS },
+  { label: "Weekend Day", days: WEEKENDS, hours: DAY_HOURS },
+  { label: "Weekend Night", days: WEEKENDS, hours: NIGHT_HOURS }
+];
+
+// src/utils.ts
+function generateSlots(minHour, maxHour, hourlyChunks) {
+  const slots = [];
+  const step = 1 / hourlyChunks;
+  for (let h = minHour; h <= maxHour; h++) {
+    for (let c = 0; c < hourlyChunks; c++) {
+      slots.push(h + c * step);
+    }
+  }
+  return slots;
+}
+function slotToTimeString(slot) {
+  const hour = Math.floor(slot);
+  const minutes = Math.round((slot - hour) * 60);
+  return `${hour}:${String(minutes).padStart(2, "0")}`;
+}
+function hasHour(schedule, day, hour) {
+  return schedule[day]?.includes(hour) ?? false;
+}
+function isSlotDisabled(disabledSlots, day, hour) {
+  if (!disabledSlots) return false;
+  return disabledSlots[day]?.includes(hour) ?? false;
+}
+function toggleHour(schedule, day, hour, selected) {
+  const current = schedule[day] ?? [];
+  const next = selected ? [.../* @__PURE__ */ new Set([...current, hour])].sort((a, b) => a - b) : current.filter((h) => h !== hour);
+  return { ...schedule, [day]: next };
+}
+function toggleHourWithMax(schedule, day, hour, selected, maxSelections, disabledSlots) {
+  if (isSlotDisabled(disabledSlots, day, hour)) return schedule;
+  if (selected && maxSelections !== void 0) {
+    const currentCount = countSelectedHours(schedule);
+    if (currentCount >= maxSelections) return schedule;
+  }
+  return toggleHour(schedule, day, hour, selected);
+}
+function applyRect(base, visibleDays, startDayIdx, startHour, endDayIdx, endHour, selected, slots, maxSelections, disabledSlots) {
+  const minDayIdx = Math.min(startDayIdx, endDayIdx);
+  const maxDayIdx = Math.max(startDayIdx, endDayIdx);
+  const startSlotIdx = slots.indexOf(startHour);
+  const endSlotIdx = slots.indexOf(endHour);
+  const minSlotIdx = Math.min(startSlotIdx, endSlotIdx);
+  const maxSlotIdx = Math.max(startSlotIdx, endSlotIdx);
+  let next = { ...base };
+  for (let di = minDayIdx; di <= maxDayIdx; di++) {
+    const day = visibleDays[di];
+    for (let si = minSlotIdx; si <= maxSlotIdx; si++) {
+      next = toggleHourWithMax(next, day, slots[si], selected, maxSelections, disabledSlots);
+    }
+  }
+  return next;
+}
+function formatHourHeader(hour) {
+  if (Number.isInteger(hour) && hour % 3 === 0) return String(hour);
+  return "\xB7";
+}
+function countSelectedHours(schedule) {
+  return Object.values(schedule).reduce(
+    (sum, hours) => sum + (hours?.length ?? 0),
+    0
+  );
+}
+function isAllSelected(schedule, visibleDays = DAY_ORDER) {
+  return visibleDays.every((day) => (schedule[day]?.length ?? 0) === 24);
+}
+function summarizeSchedule(schedule, dayLabels = {
+  mon: "Mon",
+  tue: "Tue",
+  wed: "Wed",
+  thu: "Thu",
+  fri: "Fri",
+  sat: "Sat",
+  sun: "Sun"
+}, visibleDays = DAY_ORDER, hourlyChunks = 1, noSelectionLabel = "No selection") {
+  const step = 1 / hourlyChunks;
+  const entries = visibleDays.filter((day) => (schedule[day]?.length ?? 0) > 0).map((day) => {
+    const slots = [...schedule[day] ?? []].sort((a, b) => a - b);
+    const ranges = [];
+    let start = slots[0];
+    let prev = slots[0];
+    for (let i = 1; i <= slots.length; i++) {
+      if (i < slots.length && Math.abs(slots[i] - prev - step) < 1e-3) {
+        prev = slots[i];
+      } else {
+        const endTime = prev + step;
+        ranges.push(`${slotToTimeString(start)}-${slotToTimeString(endTime)}`);
+        start = slots[i];
+        prev = slots[i];
+      }
+    }
+    return `${dayLabels[day] ?? day}: ${ranges.join(", ")}`;
+  });
+  return entries.length > 0 ? entries.join(" | ") : noSelectionLabel;
+}
+function createEmptySchedule() {
+  return {};
+}
+function createFullSchedule(visibleDays = DAY_ORDER) {
+  const schedule = {};
+  for (const day of visibleDays) {
+    schedule[day] = [...HOURS];
+  }
+  return schedule;
+}
+
+// src/locales.ts
+var format24h = (h) => String(h);
+var format12hAmPm = (h) => {
+  if (h === 0) return "12AM";
+  if (h === 12) return "12PM";
+  if (h < 12) return String(h);
+  return String(h - 12);
+};
+var PRESET_LABELS = {
+  en: {
+    weekdayDay: "Weekday Day",
+    weekdayNight: "Weekday Night",
+    weekendDay: "Weekend Day",
+    weekendNight: "Weekend Night"
+  },
+  ko: {
+    weekdayDay: "\uD3C9\uC77C \uC8FC\uAC04",
+    weekdayNight: "\uD3C9\uC77C \uC57C\uAC04",
+    weekendDay: "\uC8FC\uB9D0 \uC8FC\uAC04",
+    weekendNight: "\uC8FC\uB9D0 \uC57C\uAC04"
+  },
+  ja: {
+    weekdayDay: "\u5E73\u65E5 \u65E5\u4E2D",
+    weekdayNight: "\u5E73\u65E5 \u591C\u9593",
+    weekendDay: "\u9031\u672B \u65E5\u4E2D",
+    weekendNight: "\u9031\u672B \u591C\u9593"
+  },
+  zhCN: {
+    weekdayDay: "\u5DE5\u4F5C\u65E5\u767D\u5929",
+    weekdayNight: "\u5DE5\u4F5C\u65E5\u591C\u95F4",
+    weekendDay: "\u5468\u672B\u767D\u5929",
+    weekendNight: "\u5468\u672B\u591C\u95F4"
+  },
+  zhTW: {
+    weekdayDay: "\u5DE5\u4F5C\u65E5\u767D\u5929",
+    weekdayNight: "\u5DE5\u4F5C\u65E5\u591C\u9593",
+    weekendDay: "\u9031\u672B\u767D\u5929",
+    weekendNight: "\u9031\u672B\u591C\u9593"
+  }
+};
+var DAY_LABELS_BY_LOCALE = {
+  en: { mon: "Mon", tue: "Tue", wed: "Wed", thu: "Thu", fri: "Fri", sat: "Sat", sun: "Sun" },
+  ko: { mon: "\uC6D4", tue: "\uD654", wed: "\uC218", thu: "\uBAA9", fri: "\uAE08", sat: "\uD1A0", sun: "\uC77C" },
+  ja: { mon: "\u6708", tue: "\u706B", wed: "\u6C34", thu: "\u6728", fri: "\u91D1", sat: "\u571F", sun: "\u65E5" },
+  zhCN: { mon: "\u5468\u4E00", tue: "\u5468\u4E8C", wed: "\u5468\u4E09", thu: "\u5468\u56DB", fri: "\u5468\u4E94", sat: "\u5468\u516D", sun: "\u5468\u65E5" },
+  zhTW: { mon: "\u9031\u4E00", tue: "\u9031\u4E8C", wed: "\u9031\u4E09", thu: "\u9031\u56DB", fri: "\u9031\u4E94", sat: "\u9031\u516D", sun: "\u9031\u65E5" }
+};
+var LOCALE_PRESETS = {
+  "en": {
+    messages: {
+      clear: "Clear",
+      noSelection: "No selection",
+      presets: PRESET_LABELS.en
+    },
+    weekStartsOn: "mon",
+    weekendHighlight: "none",
+    formatHour: format24h,
+    dayLabels: DAY_LABELS_BY_LOCALE.en
+  },
+  "en-US": {
+    messages: {
+      clear: "Clear",
+      noSelection: "No selection",
+      presets: PRESET_LABELS.en
+    },
+    weekStartsOn: "sun",
+    weekendHighlight: "none",
+    formatHour: format12hAmPm,
+    dayLabels: DAY_LABELS_BY_LOCALE.en
+  },
+  "ko": {
+    messages: {
+      clear: "\uCD08\uAE30\uD654",
+      noSelection: "\uC120\uD0DD \uC5C6\uC74C",
+      presets: PRESET_LABELS.ko
+    },
+    weekStartsOn: "mon",
+    weekendHighlight: { sat: "#2d6af6", sun: "#f04646" },
+    formatHour: format24h,
+    dayLabels: DAY_LABELS_BY_LOCALE.ko
+  },
+  "ja": {
+    messages: {
+      clear: "\u30AF\u30EA\u30A2",
+      noSelection: "\u672A\u9078\u629E",
+      presets: PRESET_LABELS.ja
+    },
+    weekStartsOn: "sun",
+    weekendHighlight: { sat: "#2d6af6", sun: "#f04646" },
+    formatHour: format24h,
+    dayLabels: DAY_LABELS_BY_LOCALE.ja
+  },
+  "zh-CN": {
+    messages: {
+      clear: "\u6E05\u9664",
+      noSelection: "\u672A\u9009\u62E9",
+      presets: PRESET_LABELS.zhCN
+    },
+    weekStartsOn: "mon",
+    weekendHighlight: { sat: "#f04646", sun: "#f04646" },
+    formatHour: format24h,
+    dayLabels: DAY_LABELS_BY_LOCALE.zhCN
+  },
+  "zh-TW": {
+    messages: {
+      clear: "\u6E05\u9664",
+      noSelection: "\u672A\u9078\u64C7",
+      presets: PRESET_LABELS.zhTW
+    },
+    weekStartsOn: "mon",
+    weekendHighlight: { sat: "#f04646", sun: "#f04646" },
+    formatHour: format24h,
+    dayLabels: DAY_LABELS_BY_LOCALE.zhTW
+  }
+};
+function resolveLocaleConfig(input = {}) {
+  const preset = LOCALE_PRESETS[input.locale ?? "en"] ?? LOCALE_PRESETS.en;
+  const mergedMessages = {
+    clear: input.messages?.clear ?? preset.messages.clear,
+    noSelection: input.messages?.noSelection ?? preset.messages.noSelection,
+    presets: {
+      ...preset.messages.presets,
+      ...input.messages?.presets
+    }
+  };
+  const rawHighlight = input.weekendHighlight ?? preset.weekendHighlight;
+  const normalizedHighlight = rawHighlight === "none" ? {} : rawHighlight;
+  return {
+    messages: mergedMessages,
+    weekStartsOn: input.weekStartsOn ?? preset.weekStartsOn,
+    weekendHighlight: normalizedHighlight,
+    formatHour: preset.formatHour,
+    dayLabels: preset.dayLabels
+  };
+}
+function rotateDays(weekStartsOn) {
+  const base = [...DAY_ORDER];
+  const startIdx = base.indexOf(weekStartsOn);
+  if (startIdx <= 0) return base;
+  return [...base.slice(startIdx), ...base.slice(0, startIdx)];
+}
+var WEEKDAYS2 = ["mon", "tue", "wed", "thu", "fri"];
+var WEEKENDS2 = ["sat", "sun"];
+var DAY_HOURS2 = [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17];
+var NIGHT_HOURS2 = [18, 19, 20, 21, 22, 23, 0, 1, 2, 3, 4, 5];
+function getDefaultPresets(messages) {
+  return [
+    { label: messages.presets.weekdayDay, days: WEEKDAYS2, hours: DAY_HOURS2 },
+    { label: messages.presets.weekdayNight, days: WEEKDAYS2, hours: NIGHT_HOURS2 },
+    { label: messages.presets.weekendDay, days: WEEKENDS2, hours: DAY_HOURS2 },
+    { label: messages.presets.weekendNight, days: WEEKENDS2, hours: NIGHT_HOURS2 }
+  ];
+}
+
+// src/SchedulePicker.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function SchedulePicker({
+  value,
+  onChange,
+  onSelectEnd,
+  presets: presetsProp,
+  hideToolbar = false,
+  readOnly = false,
+  disabled = false,
+  minHour = 0,
+  maxHour = 23,
+  visibleDays: visibleDaysProp,
+  dayLabels: dayLabelsProp,
+  dayAxis = "x",
+  compactHourLabels = false,
+  formatHour,
+  disabledSlots,
+  className,
+  // Localization props
+  locale,
+  messages,
+  weekStartsOn,
+  weekendHighlight
+}) {
+  const resolvedLocale = (0, import_react.useMemo)(
+    () => resolveLocaleConfig({ locale, messages, weekStartsOn, weekendHighlight }),
+    [locale, messages, weekStartsOn, weekendHighlight]
+  );
+  const dayLabels = dayLabelsProp ?? resolvedLocale.dayLabels;
+  const effectiveFormatHour = formatHour ?? resolvedLocale.formatHour;
+  const visibleDays = (0, import_react.useMemo)(
+    () => visibleDaysProp ?? rotateDays(resolvedLocale.weekStartsOn),
+    [visibleDaysProp, resolvedLocale.weekStartsOn]
+  );
+  const activePresets = (0, import_react.useMemo)(
+    () => presetsProp ?? getDefaultPresets(resolvedLocale.messages),
+    [presetsProp, resolvedLocale.messages]
+  );
+  const [isDragging, setIsDragging] = (0, import_react.useState)(false);
+  const [isHeaderDragging, setIsHeaderDragging] = (0, import_react.useState)(false);
+  const [hoveredDay, setHoveredDay] = (0, import_react.useState)(null);
+  const [hoveredHour, setHoveredHour] = (0, import_react.useState)(null);
+  const [cornerHovered, setCornerHovered] = (0, import_react.useState)(false);
+  const dragSelectRef = (0, import_react.useRef)(true);
+  const headerDragSelectRef = (0, import_react.useRef)(true);
+  const headerStartRef = (0, import_react.useRef)(0);
+  const baseRef = (0, import_react.useRef)(value);
+  const startRef = (0, import_react.useRef)({ dayIdx: 0, slotIdx: 0 });
+  const headerBaseRef = (0, import_react.useRef)(value);
+  const tableRef = (0, import_react.useRef)(null);
+  const slots = (0, import_react.useMemo)(
+    () => generateSlots(minHour, maxHour, 1),
+    [minHour, maxHour]
+  );
+  const getHourLabel = (0, import_react.useCallback)(
+    (slot) => {
+      if (formatHour) return formatHour(slot);
+      if (compactHourLabels) return formatHourHeader(slot);
+      return effectiveFormatHour(slot);
+    },
+    [formatHour, effectiveFormatHour, compactHourLabels]
+  );
+  const handleCellPointerDown = (0, import_react.useCallback)(
+    (day, slot) => {
+      if (readOnly || isSlotDisabled(disabledSlots, day, slot)) return;
+      const dayIdx = visibleDays.indexOf(day);
+      const slotIdx = slots.indexOf(slot);
+      const willSelect = !hasHour(value, day, slot);
+      dragSelectRef.current = willSelect;
+      baseRef.current = value;
+      startRef.current = { dayIdx, slotIdx };
+      setIsDragging(true);
+      navigator.vibrate?.(8);
+      onChange(toggleHourWithMax(value, day, slot, willSelect, void 0, disabledSlots));
+    },
+    [value, onChange, visibleDays, slots, readOnly, disabledSlots]
+  );
+  const handleCellPointerOver = (0, import_react.useCallback)(
+    (day, slot) => {
+      if (!isDragging || readOnly) return;
+      const dayIdx = visibleDays.indexOf(day);
+      const slotIdx = slots.indexOf(slot);
+      const { dayIdx: sd, slotIdx: ss } = startRef.current;
+      const next = applyRect(baseRef.current, visibleDays, sd, slots[ss], dayIdx, slot, dragSelectRef.current, slots, void 0, disabledSlots);
+      onChange(next);
+    },
+    [isDragging, onChange, visibleDays, slots, readOnly, disabledSlots]
+  );
+  const handlePointerUp = (0, import_react.useCallback)(() => {
+    if (isDragging || isHeaderDragging) {
+      onSelectEnd?.(value);
+    }
+    setIsDragging(false);
+    setIsHeaderDragging(false);
+  }, [isDragging, isHeaderDragging, onSelectEnd, value]);
+  const applyDayRange = (0, import_react.useCallback)(
+    (base, startIdx, endIdx, selected) => {
+      const minIdx = Math.min(startIdx, endIdx);
+      const maxIdx = Math.max(startIdx, endIdx);
+      let next = { ...base };
+      for (let i = minIdx; i <= maxIdx; i++) {
+        const day = visibleDays[i];
+        if (selected) {
+          const enabledSlots = slots.filter((s) => !isSlotDisabled(disabledSlots, day, s));
+          next = { ...next, [day]: enabledSlots };
+        } else {
+          next = { ...next, [day]: [] };
+        }
+      }
+      return next;
+    },
+    [visibleDays, slots, disabledSlots]
+  );
+  const applyHourRange = (0, import_react.useCallback)(
+    (base, startIdx, endIdx, selected) => {
+      const minIdx = Math.min(startIdx, endIdx);
+      const maxIdx = Math.max(startIdx, endIdx);
+      let next = { ...base };
+      for (let i = minIdx; i <= maxIdx; i++) {
+        const slot = slots[i];
+        for (const d of visibleDays) {
+          next = toggleHourWithMax(next, d, slot, selected, void 0, disabledSlots);
+        }
+      }
+      return next;
+    },
+    [visibleDays, slots, disabledSlots]
+  );
+  const handleDayHeaderDown = (0, import_react.useCallback)(
+    (day) => {
+      if (readOnly) return;
+      const dayIdx = visibleDays.indexOf(day);
+      const current = value[day] ?? [];
+      const enabledSlots = slots.filter((s) => !isSlotDisabled(disabledSlots, day, s));
+      const allSelected = enabledSlots.length > 0 && enabledSlots.every((s) => current.includes(s));
+      const willSelect = !allSelected;
+      headerDragSelectRef.current = willSelect;
+      headerStartRef.current = dayIdx;
+      headerBaseRef.current = value;
+      setIsHeaderDragging("day");
+      navigator.vibrate?.(8);
+      onChange(applyDayRange(value, dayIdx, dayIdx, willSelect));
+    },
+    [value, onChange, slots, visibleDays, readOnly, disabledSlots, applyDayRange]
+  );
+  const handleDayHeaderOver = (0, import_react.useCallback)(
+    (day) => {
+      if (isHeaderDragging !== "day" || readOnly) return;
+      const dayIdx = visibleDays.indexOf(day);
+      onChange(applyDayRange(headerBaseRef.current, headerStartRef.current, dayIdx, headerDragSelectRef.current));
+    },
+    [isHeaderDragging, readOnly, visibleDays, onChange, applyDayRange]
+  );
+  const handleHourHeaderDown = (0, import_react.useCallback)(
+    (slot) => {
+      if (readOnly) return;
+      const slotIdx = slots.indexOf(slot);
+      const allSelected = visibleDays.every((d) => isSlotDisabled(disabledSlots, d, slot) || hasHour(value, d, slot));
+      const willSelect = !allSelected;
+      headerDragSelectRef.current = willSelect;
+      headerStartRef.current = slotIdx;
+      headerBaseRef.current = value;
+      setIsHeaderDragging("hour");
+      navigator.vibrate?.(8);
+      onChange(applyHourRange(value, slotIdx, slotIdx, willSelect));
+    },
+    [value, onChange, slots, visibleDays, readOnly, disabledSlots, applyHourRange]
+  );
+  const handleHourHeaderOver = (0, import_react.useCallback)(
+    (slot) => {
+      if (isHeaderDragging !== "hour" || readOnly) return;
+      const slotIdx = slots.indexOf(slot);
+      onChange(applyHourRange(headerBaseRef.current, headerStartRef.current, slotIdx, headerDragSelectRef.current));
+    },
+    [isHeaderDragging, readOnly, slots, onChange, applyHourRange]
+  );
+  const handleTouchMove = (0, import_react.useCallback)(
+    (e) => {
+      if (!isDragging && !isHeaderDragging || readOnly) return;
+      e.preventDefault();
+      const touch = e.touches[0];
+      const element = document.elementFromPoint(
+        touch.clientX,
+        touch.clientY
+      );
+      if (!element) return;
+      if (isDragging) {
+        const day = element.dataset.day;
+        const hourStr = element.dataset.hour;
+        if (day && hourStr) {
+          handleCellPointerOver(day, Number(hourStr));
+        }
+        return;
+      }
+      if (isHeaderDragging === "day") {
+        const dayHeader = element.dataset.dayHeader;
+        if (dayHeader) {
+          handleDayHeaderOver(dayHeader);
+        }
+        return;
+      }
+      if (isHeaderDragging === "hour") {
+        const hourHeader = element.dataset.hourHeader;
+        if (hourHeader) {
+          handleHourHeaderOver(Number(hourHeader));
+        }
+      }
+    },
+    [
+      isDragging,
+      isHeaderDragging,
+      readOnly,
+      handleCellPointerOver,
+      handleDayHeaderOver,
+      handleHourHeaderOver
+    ]
+  );
+  const handleToggleAll = (0, import_react.useCallback)(() => {
+    if (readOnly) return;
+    const allSelected = visibleDays.every((day) => {
+      const enabledSlots = slots.filter((s) => !isSlotDisabled(disabledSlots, day, s));
+      const current = value[day] ?? [];
+      return enabledSlots.length > 0 && enabledSlots.every((s) => current.includes(s));
+    });
+    if (allSelected) {
+      onChange({});
+    } else {
+      const next = {};
+      for (const day of visibleDays) {
+        next[day] = slots.filter((s) => !isSlotDisabled(disabledSlots, day, s));
+      }
+      onChange(next);
+    }
+  }, [value, onChange, visibleDays, slots, readOnly, disabledSlots]);
+  const handlePreset = (0, import_react.useCallback)(
+    (preset) => {
+      if (readOnly) return;
+      const next = {};
+      for (const d of preset.days) {
+        next[d] = [...preset.hours].filter((h) => !isSlotDisabled(disabledSlots, d, h)).sort((a, b) => a - b);
+      }
+      onChange(next);
+    },
+    [onChange, readOnly, disabledSlots]
+  );
+  const getDayLabelClass = (day) => {
+    const classes = ["rsp-day-label"];
+    if (resolvedLocale.weekendHighlight[day]) {
+      classes.push(`rsp-day-label--${day}`);
+    }
+    if (readOnly) classes.push("rsp-day-label--readonly");
+    return classes.join(" ");
+  };
+  const getDayLabelStyle = (day) => {
+    const color = resolvedLocale.weekendHighlight[day];
+    return color ? { color } : void 0;
+  };
+  const getCellClass = (day, slot) => {
+    const selected = hasHour(value, day, slot);
+    const slotDisabled = isSlotDisabled(disabledSlots, day, slot);
+    const highlighted = cornerHovered || hoveredDay === day || hoveredHour === slot;
+    return [
+      "rsp-cell",
+      selected && "rsp-cell--selected",
+      slotDisabled && "rsp-cell--disabled",
+      highlighted && !selected && !slotDisabled && "rsp-cell--highlighted",
+      readOnly && "rsp-cell--readonly"
+    ].filter(Boolean).join(" ");
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "div",
+    {
+      className: `rsp-container${disabled ? " rsp-container--disabled" : ""}${className ? ` ${className}` : ""}`,
+      onMouseUp: handlePointerUp,
+      onMouseLeave: handlePointerUp,
+      onTouchEnd: handlePointerUp,
+      children: [
+        !hideToolbar && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rsp-toolbar", children: [
+          activePresets.map((preset) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "button",
+            {
+              type: "button",
+              className: "rsp-preset-button",
+              onClick: () => handlePreset(preset),
+              disabled: readOnly,
+              children: preset.label
+            },
+            preset.label
+          )),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "button",
+            {
+              type: "button",
+              className: "rsp-preset-button rsp-toolbar-clear",
+              onClick: () => onChange({}),
+              disabled: readOnly,
+              children: resolvedLocale.messages.clear
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "div",
+          {
+            className: "rsp-table-wrapper",
+            onTouchMove: handleTouchMove,
+            children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("table", { className: "rsp-table", ref: tableRef, children: dayAxis === "y" ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("colgroup", { children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("col", { className: "rsp-day-col" }),
+                slots.map((s) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("col", {}, s))
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("tr", { className: "rsp-header-row", onMouseLeave: () => setHoveredHour(null), children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "th",
+                  {
+                    className: `rsp-corner-cell${readOnly ? "" : " rsp-corner-cell--clickable"}`,
+                    onClick: handleToggleAll,
+                    onMouseEnter: () => setCornerHovered(true),
+                    onMouseLeave: () => setCornerHovered(false),
+                    onTouchEnd: (e) => {
+                      e.preventDefault();
+                      handleToggleAll();
+                    }
+                  }
+                ),
+                slots.map((s) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "th",
+                  {
+                    "data-hour-header": s,
+                    className: `rsp-header-cell${readOnly ? " rsp-header-cell--readonly" : ""}`,
+                    onMouseDown: (e) => {
+                      e.preventDefault();
+                      handleHourHeaderDown(s);
+                    },
+                    onMouseOver: () => {
+                      setHoveredHour(s);
+                      handleHourHeaderOver(s);
+                    },
+                    onMouseEnter: () => setHoveredHour(s),
+                    onTouchStart: (e) => {
+                      e.preventDefault();
+                      handleHourHeaderDown(s);
+                    },
+                    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: getHourLabel(s) })
+                  },
+                  s
+                ))
+              ] }) }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("tbody", { onMouseLeave: () => setHoveredDay(null), children: visibleDays.map((day) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("tr", { className: "rsp-day-row", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "td",
+                  {
+                    "data-day-header": day,
+                    className: getDayLabelClass(day),
+                    style: getDayLabelStyle(day),
+                    onMouseDown: (e) => {
+                      e.preventDefault();
+                      handleDayHeaderDown(day);
+                    },
+                    onMouseOver: () => {
+                      setHoveredDay(day);
+                      handleDayHeaderOver(day);
+                    },
+                    onMouseEnter: () => setHoveredDay(day),
+                    onMouseLeave: () => setHoveredDay(null),
+                    onTouchStart: (e) => {
+                      e.preventDefault();
+                      handleDayHeaderDown(day);
+                    },
+                    children: dayLabels[day] ?? day
+                  }
+                ),
+                slots.map((slot) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "td",
+                  {
+                    className: getCellClass(day, slot),
+                    "data-day": day,
+                    "data-hour": slot,
+                    onMouseDown: (e) => {
+                      e.preventDefault();
+                      handleCellPointerDown(day, slot);
+                    },
+                    onMouseOver: () => handleCellPointerOver(day, slot),
+                    onTouchStart: (e) => {
+                      e.preventDefault();
+                      handleCellPointerDown(day, slot);
+                    }
+                  },
+                  slot
+                ))
+              ] }, day)) })
+            ] }) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("colgroup", { children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("col", { className: "rsp-hour-col" }),
+                visibleDays.map((d) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("col", {}, d))
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("tr", { className: "rsp-header-row", onMouseLeave: () => setHoveredDay(null), children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "th",
+                  {
+                    className: `rsp-corner-cell${readOnly ? "" : " rsp-corner-cell--clickable"}`,
+                    onClick: handleToggleAll,
+                    onMouseEnter: () => setCornerHovered(true),
+                    onMouseLeave: () => setCornerHovered(false),
+                    onTouchEnd: (e) => {
+                      e.preventDefault();
+                      handleToggleAll();
+                    }
+                  }
+                ),
+                visibleDays.map((day) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "th",
+                  {
+                    "data-day-header": day,
+                    className: `rsp-header-cell rsp-header-cell--day${readOnly ? " rsp-header-cell--readonly" : ""}`,
+                    style: getDayLabelStyle(day),
+                    onMouseDown: (e) => {
+                      e.preventDefault();
+                      handleDayHeaderDown(day);
+                    },
+                    onMouseOver: () => {
+                      setHoveredDay(day);
+                      handleDayHeaderOver(day);
+                    },
+                    onMouseEnter: () => setHoveredDay(day),
+                    onTouchStart: (e) => {
+                      e.preventDefault();
+                      handleDayHeaderDown(day);
+                    },
+                    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: dayLabels[day] ?? day })
+                  },
+                  day
+                ))
+              ] }) }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("tbody", { onMouseLeave: () => setHoveredHour(null), children: slots.map((slot) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("tr", { className: "rsp-day-row", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "td",
+                  {
+                    "data-hour-header": slot,
+                    className: `rsp-hour-label${readOnly ? " rsp-hour-label--readonly" : ""}`,
+                    onMouseDown: (e) => {
+                      e.preventDefault();
+                      handleHourHeaderDown(slot);
+                    },
+                    onMouseOver: () => {
+                      setHoveredHour(slot);
+                      handleHourHeaderOver(slot);
+                    },
+                    onMouseEnter: () => setHoveredHour(slot),
+                    onMouseLeave: () => setHoveredHour(null),
+                    onTouchStart: (e) => {
+                      e.preventDefault();
+                      handleHourHeaderDown(slot);
+                    },
+                    children: getHourLabel(slot)
+                  }
+                ),
+                visibleDays.map((day) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "td",
+                  {
+                    className: getCellClass(day, slot),
+                    "data-day": day,
+                    "data-hour": slot,
+                    onMouseDown: (e) => {
+                      e.preventDefault();
+                      handleCellPointerDown(day, slot);
+                    },
+                    onMouseOver: () => handleCellPointerOver(day, slot),
+                    onTouchStart: (e) => {
+                      e.preventDefault();
+                      handleCellPointerDown(day, slot);
+                    }
+                  },
+                  day
+                ))
+              ] }, slot)) })
+            ] }) })
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/serialize.ts
+var DAY_TO_ISO = {
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6,
+  sun: 7
+};
+var ISO_TO_DAY = {
+  1: "mon",
+  2: "tue",
+  3: "wed",
+  4: "thu",
+  5: "fri",
+  6: "sat",
+  7: "sun"
+};
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+function hourToTimeString(hour) {
+  return `${pad2(hour)}:00`;
+}
+function compressHours(hours) {
+  if (hours.length === 0) return [];
+  const sorted = [...hours].sort((a, b) => a - b);
+  const out = [];
+  let start = sorted[0];
+  let prev = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    const cur = sorted[i];
+    if (cur === prev + 1) {
+      prev = cur;
+    } else {
+      out.push({ start, end: prev + 1 });
+      start = cur;
+      prev = cur;
+    }
+  }
+  out.push({ start, end: prev + 1 });
+  return out;
+}
+function toRanges(schedule, options = {}) {
+  const ranges = [];
+  for (const dayKey of DAY_ORDER) {
+    const iso = DAY_TO_ISO[dayKey];
+    if (!iso) continue;
+    const hours = schedule[dayKey];
+    if (!hours || hours.length === 0) continue;
+    for (const { start, end } of compressHours(hours)) {
+      ranges.push({
+        day: iso,
+        start: hourToTimeString(start),
+        end: end >= 24 ? "24:00" : hourToTimeString(end)
+      });
+    }
+  }
+  const payload = { version: 1, ranges };
+  if (options.timezone) payload.timezone = options.timezone;
+  if (options.meta) payload.meta = options.meta;
+  return payload;
+}
+function parseTimeString(s) {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(s);
+  if (!m) throw new Error(`Invalid time string: ${s}`);
+  const h = Number(m[1]);
+  const min = Number(m[2]);
+  if (min !== 0) {
+    throw new Error(
+      `fromRanges only supports hour-aligned times (got ${s}). Sub-hour granularity is not supported in current version.`
+    );
+  }
+  if (h < 0 || h > 24) throw new Error(`Hour out of range: ${h}`);
+  return h;
+}
+function fromRanges(payload) {
+  const schedule = {};
+  for (const range of payload.ranges) {
+    const dayKey = ISO_TO_DAY[range.day];
+    if (!dayKey) throw new Error(`Invalid ISO day: ${range.day}`);
+    const start = parseTimeString(range.start);
+    const end = parseTimeString(range.end);
+    if (end <= start) {
+      throw new Error(
+        `Range end (${range.end}) must be after start (${range.start})`
+      );
+    }
+    const hours = schedule[dayKey] ?? [];
+    for (let h = start; h < end; h++) {
+      if (!hours.includes(h)) hours.push(h);
+    }
+    hours.sort((a, b) => a - b);
+    schedule[dayKey] = hours;
+  }
+  return schedule;
+}
+function toISO(schedule, options = {}) {
+  const payload = toRanges(schedule, options);
+  const availability = payload.ranges.map((r) => ({
+    day: r.day,
+    startTime: r.start,
+    endTime: r.end
+  }));
+  const out = { version: 1, availability };
+  if (options.timezone) out.timezone = options.timezone;
+  if (options.meta) out.meta = options.meta;
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DAY_LABELS,
+  DAY_ORDER,
+  DEFAULT_PRESETS,
+  HOURS,
+  LOCALE_PRESETS,
+  SchedulePicker,
+  applyRect,
+  countSelectedHours,
+  createEmptySchedule,
+  createFullSchedule,
+  formatHourHeader,
+  fromRanges,
+  generateSlots,
+  getDefaultPresets,
+  hasHour,
+  isAllSelected,
+  isSlotDisabled,
+  resolveLocaleConfig,
+  rotateDays,
+  slotToTimeString,
+  summarizeSchedule,
+  toISO,
+  toRanges,
+  toggleHour
+});
+//# sourceMappingURL=index.js.map