@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/chunk-4SO4LANY.js

@@ -0,0 +1,626 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/components/TimePicker.tsx
+var _react = require('react');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var Icon = ({ path, className }) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  "svg",
+  {
+    className,
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: _tigercatcore.icon20ViewBox,
+    fill: "currentColor",
+    children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { fillRule: "evenodd", d: path, clipRule: "evenodd" })
+  }
+);
+var TimePicker = (allProps) => {
+  const {
+    size = "md",
+    format = "24",
+    showSeconds = false,
+    hourStep = 1,
+    minuteStep = 1,
+    secondStep = 1,
+    disabled = false,
+    readonly = false,
+    required = false,
+    minTime,
+    maxTime,
+    clearable = true,
+    name,
+    id,
+    className,
+    onClear,
+    locale,
+    labels: labelsOverrides,
+    value,
+    defaultValue,
+    range,
+    ...restProps
+  } = allProps;
+  const divProps = (({ onChange: _omitOnChange, ...rest }) => rest)(restProps);
+  const isRangeMode = range === true;
+  const [isOpen, setIsOpen] = _react.useState.call(void 0, false);
+  const [internalSingleValue, setInternalSingleValue] = _react.useState.call(void 0, () => {
+    if (isRangeMode) return null;
+    const dv = defaultValue;
+    if (typeof dv === "string" || dv === null || dv === void 0) return _nullishCoalesce(dv, () => ( null));
+    return null;
+  });
+  const [internalRangeValue, setInternalRangeValue] = _react.useState.call(void 0, () => {
+    const dv = defaultValue;
+    if (Array.isArray(dv)) return [_nullishCoalesce(dv[0], () => ( null)), _nullishCoalesce(dv[1], () => ( null))];
+    return [null, null];
+  });
+  const [activePart, setActivePart] = _react.useState.call(void 0, "start");
+  const panelRef = _react.useRef.call(void 0, null);
+  const inputWrapperRef = _react.useRef.call(void 0, null);
+  const inputRef = _react.useRef.call(void 0, null);
+  const normalizeRangeValue = (input) => {
+    if (Array.isArray(input)) return [_nullishCoalesce(input[0], () => ( null)), _nullishCoalesce(input[1], () => ( null))];
+    return [null, null];
+  };
+  const isControlled = value !== void 0;
+  const currentSingleValue = (() => {
+    if (isRangeMode) return null;
+    const v = value;
+    if (isControlled && (typeof v === "string" || v === null)) return v;
+    return internalSingleValue;
+  })();
+  const currentRangeValue = (() => {
+    if (!isRangeMode) return [null, null];
+    if (isControlled) return normalizeRangeValue(value);
+    return internalRangeValue;
+  })();
+  const activeValue = isRangeMode ? currentRangeValue[activePart === "start" ? 0 : 1] : currentSingleValue;
+  const parsedTime = _tigercatcore.parseTime.call(void 0, activeValue);
+  const [selectedHours, setSelectedHours] = _react.useState.call(void 0, _nullishCoalesce(_optionalChain([parsedTime, 'optionalAccess', _ => _.hours]), () => ( 0)));
+  const [selectedMinutes, setSelectedMinutes] = _react.useState.call(void 0, _nullishCoalesce(_optionalChain([parsedTime, 'optionalAccess', _2 => _2.minutes]), () => ( 0)));
+  const [selectedSeconds, setSelectedSeconds] = _react.useState.call(void 0, _nullishCoalesce(_optionalChain([parsedTime, 'optionalAccess', _3 => _3.seconds]), () => ( 0)));
+  const [selectedPeriod, setSelectedPeriod] = _react.useState.call(void 0, "AM");
+  const syncFromActiveValue = _react.useCallback.call(void 0, () => {
+    const parsed = _tigercatcore.parseTime.call(void 0, activeValue);
+    if (!parsed) return;
+    setSelectedHours(parsed.hours);
+    setSelectedMinutes(parsed.minutes);
+    setSelectedSeconds(parsed.seconds);
+    if (format === "12") {
+      const { period } = _tigercatcore.to12HourFormat.call(void 0, parsed.hours);
+      setSelectedPeriod(period);
+    }
+  }, [activeValue, format]);
+  _react.useEffect.call(void 0, () => {
+    syncFromActiveValue();
+  }, [syncFromActiveValue]);
+  const labels = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getTimePickerLabels.call(void 0, locale, labelsOverrides),
+    [locale, labelsOverrides]
+  );
+  const placeholder = _nullishCoalesce(allProps.placeholder, () => ( (isRangeMode ? labels.selectTimeRange : labels.selectTime)));
+  const periodLabels = _react.useMemo.call(void 0, () => _tigercatcore.getTimePeriodLabels.call(void 0, locale), [locale]);
+  const displayValue = (() => {
+    if (!isRangeMode) {
+      return parsedTime ? _tigercatcore.formatTimeDisplayWithLocale.call(void 0, 
+        parsedTime.hours,
+        parsedTime.minutes,
+        parsedTime.seconds,
+        format,
+        showSeconds,
+        locale
+      ) : "";
+    }
+    const toDisplay = (timeStr) => {
+      const parsed = _tigercatcore.parseTime.call(void 0, timeStr);
+      if (!parsed) return "";
+      return _tigercatcore.formatTimeDisplayWithLocale.call(void 0, 
+        parsed.hours,
+        parsed.minutes,
+        parsed.seconds,
+        format,
+        showSeconds,
+        locale
+      );
+    };
+    const start = toDisplay(currentRangeValue[0]);
+    const end = toDisplay(currentRangeValue[1]);
+    if (!start && !end) return "";
+    return `${start} - ${end}`;
+  })();
+  const showClearButton = (() => {
+    if (!clearable || disabled || readonly) return false;
+    if (!isRangeMode) return currentSingleValue !== null;
+    return currentRangeValue[0] !== null || currentRangeValue[1] !== null;
+  })();
+  const hoursList = _react.useMemo.call(void 0, () => _tigercatcore.generateHours.call(void 0, hourStep, format), [hourStep, format]);
+  const minutesList = _react.useMemo.call(void 0, () => _tigercatcore.generateMinutes.call(void 0, minuteStep), [minuteStep]);
+  const secondsList = _react.useMemo.call(void 0, () => _tigercatcore.generateSeconds.call(void 0, secondStep), [secondStep]);
+  const togglePanel = () => {
+    if (!disabled && !readonly) {
+      if (isOpen) {
+        closePanel();
+        return;
+      }
+      setIsOpen(true);
+      syncFromActiveValue();
+    }
+  };
+  const closePanel = () => {
+    setIsOpen(false);
+    _optionalChain([inputRef, 'access', _4 => _4.current, 'optionalAccess', _5 => _5.focus, 'call', _6 => _6()]);
+  };
+  const focusOptionInUnit = (unit, action) => {
+    const panel = panelRef.current;
+    if (!panel) return;
+    const nodes = Array.from(
+      panel.querySelectorAll(`button[data-tiger-timepicker-unit="${unit}"]`)
+    ).filter((button) => !button.disabled);
+    if (nodes.length === 0) return;
+    const active = document.activeElement;
+    const activeIndex = active ? nodes.indexOf(active) : -1;
+    const selectedIndex = nodes.findIndex(
+      (button) => button.getAttribute("aria-selected") === "true"
+    );
+    const baseIndex = activeIndex >= 0 ? activeIndex : Math.max(0, selectedIndex);
+    let nextIndex = baseIndex;
+    if (action === "prev") nextIndex = Math.max(0, baseIndex - 1);
+    if (action === "next") nextIndex = Math.min(nodes.length - 1, baseIndex + 1);
+    if (action === "first") nextIndex = 0;
+    if (action === "last") nextIndex = nodes.length - 1;
+    _optionalChain([nodes, 'access', _7 => _7[nextIndex], 'optionalAccess', _8 => _8.focus, 'call', _9 => _9()]);
+  };
+  const handlePanelKeyDown = (event) => {
+    if (event.key === "Escape") {
+      event.preventDefault();
+      closePanel();
+      return;
+    }
+    const active = document.activeElement;
+    const unit = _optionalChain([active, 'optionalAccess', _10 => _10.getAttribute, 'call', _11 => _11("data-tiger-timepicker-unit")]);
+    if (!unit) return;
+    if (event.key === "ArrowUp") {
+      event.preventDefault();
+      focusOptionInUnit(unit, "prev");
+      return;
+    }
+    if (event.key === "ArrowDown") {
+      event.preventDefault();
+      focusOptionInUnit(unit, "next");
+      return;
+    }
+    if (event.key === "Home") {
+      event.preventDefault();
+      focusOptionInUnit(unit, "first");
+      return;
+    }
+    if (event.key === "End") {
+      event.preventDefault();
+      focusOptionInUnit(unit, "last");
+      return;
+    }
+    if (event.key === "Enter" || event.key === " ") {
+      const el = document.activeElement;
+      if (el && el.tagName === "BUTTON" && !el.disabled) {
+        event.preventDefault();
+        el.click();
+      }
+    }
+  };
+  const selectHour = (hour) => {
+    const hours24 = format === "12" ? _tigercatcore.to24HourFormat.call(void 0, hour, selectedPeriod) : hour;
+    setSelectedHours(hours24);
+    updateTime(hours24, selectedMinutes, selectedSeconds);
+  };
+  const selectMinute = (minute) => {
+    setSelectedMinutes(minute);
+    updateTime(selectedHours, minute, selectedSeconds);
+  };
+  const selectSecond = (second) => {
+    setSelectedSeconds(second);
+    updateTime(selectedHours, selectedMinutes, second);
+  };
+  const selectPeriod = (period) => {
+    setSelectedPeriod(period);
+    const { hours: hours12 } = _tigercatcore.to12HourFormat.call(void 0, selectedHours);
+    const hours24 = _tigercatcore.to24HourFormat.call(void 0, hours12, period);
+    setSelectedHours(hours24);
+    updateTime(hours24, selectedMinutes, selectedSeconds);
+  };
+  const updateTime = (hours, minutes, seconds) => {
+    if (!_tigercatcore.isTimeInRange.call(void 0, hours, minutes, minTime, maxTime)) {
+      return;
+    }
+    let timeString = _tigercatcore.formatTime.call(void 0, hours, minutes, seconds, showSeconds);
+    if (allProps.range !== true) {
+      if (!isControlled) {
+        setInternalSingleValue(timeString);
+      }
+      _optionalChain([allProps, 'access', _12 => _12.onChange, 'optionalCall', _13 => _13(timeString)]);
+      return;
+    }
+    const index = activePart === "start" ? 0 : 1;
+    const parsedStart = _tigercatcore.parseTime.call(void 0, currentRangeValue[0]);
+    const parsedEnd = _tigercatcore.parseTime.call(void 0, currentRangeValue[1]);
+    const candidateSeconds = hours * 3600 + minutes * 60 + seconds;
+    const startSeconds = parsedStart ? parsedStart.hours * 3600 + parsedStart.minutes * 60 + parsedStart.seconds : null;
+    const endSeconds = parsedEnd ? parsedEnd.hours * 3600 + parsedEnd.minutes * 60 + parsedEnd.seconds : null;
+    if (activePart === "end" && parsedStart && startSeconds !== null) {
+      if (candidateSeconds < startSeconds) {
+        timeString = _tigercatcore.formatTime.call(void 0, 
+          parsedStart.hours,
+          parsedStart.minutes,
+          parsedStart.seconds,
+          showSeconds
+        );
+        setSelectedHours(parsedStart.hours);
+        setSelectedMinutes(parsedStart.minutes);
+        setSelectedSeconds(parsedStart.seconds);
+        if (format === "12") {
+          const { period } = _tigercatcore.to12HourFormat.call(void 0, parsedStart.hours);
+          setSelectedPeriod(period);
+        }
+      }
+    }
+    const nextRange = [currentRangeValue[0], currentRangeValue[1]];
+    nextRange[index] = timeString;
+    if (activePart === "start" && endSeconds !== null && candidateSeconds > endSeconds) {
+      nextRange[1] = timeString;
+    }
+    if (!isControlled) {
+      setInternalRangeValue(nextRange);
+    }
+    _optionalChain([allProps, 'access', _14 => _14.onChange, 'optionalCall', _15 => _15(nextRange)]);
+    if (activePart === "start" && nextRange[1] === null) {
+      setActivePart("end");
+    }
+  };
+  const clearTime = (event) => {
+    event.stopPropagation();
+    if (allProps.range !== true) {
+      if (!isControlled) {
+        setInternalSingleValue(null);
+      }
+      _optionalChain([allProps, 'access', _16 => _16.onChange, 'optionalCall', _17 => _17(null)]);
+      _optionalChain([onClear, 'optionalCall', _18 => _18()]);
+      return;
+    }
+    const cleared = [null, null];
+    if (!isControlled) {
+      setInternalRangeValue(cleared);
+    }
+    _optionalChain([allProps, 'access', _19 => _19.onChange, 'optionalCall', _20 => _20(cleared)]);
+    _optionalChain([onClear, 'optionalCall', _21 => _21()]);
+  };
+  const setNow = () => {
+    const now = _tigercatcore.getCurrentTime.call(void 0, showSeconds);
+    const parsed = _tigercatcore.parseTime.call(void 0, now);
+    if (parsed) {
+      setSelectedHours(parsed.hours);
+      setSelectedMinutes(parsed.minutes);
+      setSelectedSeconds(parsed.seconds);
+      if (format === "12") {
+        const { period } = _tigercatcore.to12HourFormat.call(void 0, parsed.hours);
+        setSelectedPeriod(period);
+      }
+      updateTime(parsed.hours, parsed.minutes, parsed.seconds);
+    }
+  };
+  const isHourDisabled = (hour) => {
+    const hours24 = format === "12" ? _tigercatcore.to24HourFormat.call(void 0, hour, selectedPeriod) : hour;
+    return !_tigercatcore.isTimeInRange.call(void 0, hours24, selectedMinutes, minTime, maxTime);
+  };
+  const isMinuteDisabled = (minute) => {
+    return !_tigercatcore.isTimeInRange.call(void 0, selectedHours, minute, minTime, maxTime);
+  };
+  const handleInputClick = () => {
+    togglePanel();
+  };
+  _react.useEffect.call(void 0, () => {
+    const handleClickOutside = (event) => {
+      if (panelRef.current && inputWrapperRef.current && !panelRef.current.contains(event.target) && !inputWrapperRef.current.contains(event.target)) {
+        closePanel();
+      }
+    };
+    if (isOpen) {
+      document.addEventListener("click", handleClickOutside);
+      return () => {
+        document.removeEventListener("click", handleClickOutside);
+      };
+    }
+  }, [isOpen]);
+  _react.useEffect.call(void 0, () => {
+    if (!isOpen) return;
+    const panel = panelRef.current;
+    if (!panel) return;
+    const focusTimer = window.setTimeout(() => {
+      const selectedHour = panel.querySelector(
+        'button[data-tiger-timepicker-unit="hour"][aria-selected="true"]:not([disabled])'
+      );
+      if (selectedHour) {
+        selectedHour.focus();
+        return;
+      }
+      const firstHour = panel.querySelector(
+        'button[data-tiger-timepicker-unit="hour"]:not([disabled])'
+      );
+      _optionalChain([firstHour, 'optionalAccess', _22 => _22.focus, 'call', _23 => _23()]);
+    }, 0);
+    return () => window.clearTimeout(focusTimer);
+  }, [isOpen, activePart]);
+  const inputClasses = _tigercatcore.getTimePickerInputClasses.call(void 0, size, disabled || readonly);
+  const iconButtonClasses = _tigercatcore.getTimePickerIconButtonClasses.call(void 0, size);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.classNames.call(void 0, _tigercatcore.timePickerBaseClasses, className), ...divProps, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { ref: inputWrapperRef, className: _tigercatcore.timePickerInputWrapperClasses, children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        "input",
+        {
+          ref: inputRef,
+          type: "text",
+          className: inputClasses,
+          value: displayValue,
+          placeholder,
+          disabled,
+          readOnly: true,
+          required,
+          name,
+          id,
+          onClick: handleInputClick,
+          "aria-label": placeholder || labels.selectTime
+        }
+      ),
+      showClearButton && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        "button",
+        {
+          type: "button",
+          className: _tigercatcore.timePickerClearButtonClasses,
+          onClick: clearTime,
+          "aria-label": labels.clear,
+          children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Icon, { path: _tigercatcore.TimePickerCloseIconPath, className: "w-4 h-4" })
+        }
+      ),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        "button",
+        {
+          type: "button",
+          className: iconButtonClasses,
+          disabled: disabled || readonly,
+          onClick: togglePanel,
+          "aria-label": labels.toggle,
+          children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Icon, { path: _tigercatcore.ClockIconPath, className: "w-5 h-5" })
+        }
+      )
+    ] }),
+    isOpen && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+      "div",
+      {
+        ref: panelRef,
+        className: _tigercatcore.timePickerPanelClasses,
+        role: "dialog",
+        "aria-label": labels.dialog,
+        onKeyDown: handlePanelKeyDown,
+        children: [
+          isRangeMode && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.timePickerRangeHeaderClasses, children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "button",
+              {
+                type: "button",
+                className: _tigercatcore.getTimePickerRangeTabButtonClasses.call(void 0, activePart === "start"),
+                onClick: () => setActivePart("start"),
+                "aria-label": labels.start,
+                "aria-selected": activePart === "start",
+                children: labels.start
+              }
+            ),
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "button",
+              {
+                type: "button",
+                className: _tigercatcore.getTimePickerRangeTabButtonClasses.call(void 0, activePart === "end"),
+                onClick: () => setActivePart("end"),
+                "aria-label": labels.end,
+                "aria-selected": activePart === "end",
+                children: labels.end
+              }
+            )
+          ] }),
+          /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.timePickerMobileWheelClasses, children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "select",
+              {
+                className: _tigercatcore.timePickerMobileWheelSelectClasses,
+                value: format === "12" ? _tigercatcore.to12HourFormat.call(void 0, selectedHours).hours : selectedHours,
+                "aria-label": labels.hour,
+                onChange: (event) => selectHour(Number(event.target.value)),
+                children: hoursList.map((hour) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "option", { value: hour, disabled: isHourDisabled(hour), children: _tigercatcore.padTwo.call(void 0, hour) }, hour))
+              }
+            ),
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "select",
+              {
+                className: _tigercatcore.timePickerMobileWheelSelectClasses,
+                value: selectedMinutes,
+                "aria-label": labels.minute,
+                onChange: (event) => selectMinute(Number(event.target.value)),
+                children: minutesList.map((minute) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "option", { value: minute, disabled: isMinuteDisabled(minute), children: _tigercatcore.padTwo.call(void 0, minute) }, minute))
+              }
+            ),
+            showSeconds && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "select",
+              {
+                className: _tigercatcore.timePickerMobileWheelSelectClasses,
+                value: selectedSeconds,
+                "aria-label": labels.second,
+                onChange: (event) => selectSecond(Number(event.target.value)),
+                children: secondsList.map((second) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "option", { value: second, children: _tigercatcore.padTwo.call(void 0, second) }, second))
+              }
+            ),
+            format === "12" && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+              "select",
+              {
+                className: _tigercatcore.timePickerMobileWheelSelectClasses,
+                value: selectedPeriod,
+                "aria-label": "Period",
+                onChange: (event) => selectPeriod(event.target.value),
+                children: [
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "option", { value: "AM", children: periodLabels.am }),
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "option", { value: "PM", children: periodLabels.pm })
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.timePickerDesktopPanelContentClasses, children: [
+            /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.timePickerColumnClasses, children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.timePickerColumnHeaderClasses, children: labels.hour }),
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.timePickerColumnListClasses, children: hoursList.map((hour) => {
+                const hours24 = format === "12" ? _tigercatcore.to24HourFormat.call(void 0, hour, selectedPeriod) : hour;
+                const isSelected = selectedHours === hours24;
+                const isDisabled = isHourDisabled(hour);
+                return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "button",
+                  {
+                    type: "button",
+                    className: _tigercatcore.getTimePickerItemClasses.call(void 0, isSelected, isDisabled),
+                    disabled: isDisabled,
+                    onClick: () => selectHour(hour),
+                    "data-tiger-timepicker-unit": "hour",
+                    "aria-label": _tigercatcore.getTimePickerOptionAriaLabel.call(void 0, 
+                      hour,
+                      "hour",
+                      locale,
+                      labelsOverrides
+                    ),
+                    "aria-selected": isSelected,
+                    children: _tigercatcore.padTwo.call(void 0, hour)
+                  },
+                  hour
+                );
+              }) })
+            ] }),
+            /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.timePickerColumnClasses, children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.timePickerColumnHeaderClasses, children: labels.minute }),
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.timePickerColumnListClasses, children: minutesList.map((minute) => {
+                const isSelected = selectedMinutes === minute;
+                const isDisabled = isMinuteDisabled(minute);
+                return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "button",
+                  {
+                    type: "button",
+                    className: _tigercatcore.getTimePickerItemClasses.call(void 0, isSelected, isDisabled),
+                    disabled: isDisabled,
+                    onClick: () => selectMinute(minute),
+                    "data-tiger-timepicker-unit": "minute",
+                    "aria-label": _tigercatcore.getTimePickerOptionAriaLabel.call(void 0, 
+                      minute,
+                      "minute",
+                      locale,
+                      labelsOverrides
+                    ),
+                    "aria-selected": isSelected,
+                    children: _tigercatcore.padTwo.call(void 0, minute)
+                  },
+                  minute
+                );
+              }) })
+            ] }),
+            showSeconds && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.timePickerColumnClasses, children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.timePickerColumnHeaderClasses, children: labels.second }),
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.timePickerColumnListClasses, children: secondsList.map((second) => {
+                const isSelected = selectedSeconds === second;
+                return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "button",
+                  {
+                    type: "button",
+                    className: _tigercatcore.getTimePickerItemClasses.call(void 0, isSelected, false),
+                    onClick: () => selectSecond(second),
+                    "data-tiger-timepicker-unit": "second",
+                    "aria-label": _tigercatcore.getTimePickerOptionAriaLabel.call(void 0, 
+                      second,
+                      "second",
+                      locale,
+                      labelsOverrides
+                    ),
+                    "aria-selected": isSelected,
+                    children: _tigercatcore.padTwo.call(void 0, second)
+                  },
+                  second
+                );
+              }) })
+            ] }),
+            format === "12" && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.timePickerColumnClasses, children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.timePickerColumnHeaderClasses, children: " " }),
+              /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex flex-col", children: [
+                /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "button",
+                  {
+                    type: "button",
+                    className: _tigercatcore.getTimePickerPeriodButtonClasses.call(void 0, selectedPeriod === "AM"),
+                    onClick: () => selectPeriod("AM"),
+                    "data-tiger-timepicker-unit": "period",
+                    "aria-label": periodLabels.am,
+                    "aria-selected": selectedPeriod === "AM",
+                    children: periodLabels.am
+                  }
+                ),
+                /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "button",
+                  {
+                    type: "button",
+                    className: _tigercatcore.getTimePickerPeriodButtonClasses.call(void 0, selectedPeriod === "PM"),
+                    onClick: () => selectPeriod("PM"),
+                    "data-tiger-timepicker-unit": "period",
+                    "aria-label": periodLabels.pm,
+                    "aria-selected": selectedPeriod === "PM",
+                    children: periodLabels.pm
+                  }
+                )
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.timePickerFooterClasses, children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "button", { type: "button", className: _tigercatcore.timePickerFooterButtonClasses, onClick: setNow, children: labels.now }),
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "button", { type: "button", className: _tigercatcore.timePickerFooterButtonClasses, onClick: closePanel, children: labels.ok })
+          ] })
+        ]
+      }
+    )
+  ] });
+};
+
+
+
+exports.TimePicker = TimePicker;

package/dist/chunk-4TEILQSN.js

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/components/Switch.tsx
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var Switch = ({
+  checked = false,
+  disabled = false,
+  size = "md",
+  onChange,
+  className,
+  onClick,
+  onKeyDown,
+  tabIndex,
+  ...props
+}) => {
+  const switchClasses = _tigercatcore.getSwitchClasses.call(void 0, size, checked, disabled, className);
+  const thumbClasses = _tigercatcore.getSwitchThumbClasses.call(void 0, size, checked);
+  const toggle = () => {
+    if (disabled) return;
+    _optionalChain([onChange, 'optionalCall', _ => _(!checked)]);
+  };
+  const handleClick = (event) => {
+    _optionalChain([onClick, 'optionalCall', _2 => _2(event)]);
+    if (event.defaultPrevented) return;
+    toggle();
+  };
+  const handleKeyDown = (event) => {
+    _optionalChain([onKeyDown, 'optionalCall', _3 => _3(event)]);
+    if (event.defaultPrevented) return;
+    if (disabled) return;
+    if (event.key === " " || event.key === "Enter") {
+      event.preventDefault();
+      toggle();
+    }
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "button",
+    {
+      ...props,
+      type: "button",
+      role: "switch",
+      "aria-checked": checked,
+      className: switchClasses,
+      disabled,
+      onClick: handleClick,
+      onKeyDown: handleKeyDown,
+      "aria-disabled": disabled || void 0,
+      tabIndex: disabled ? -1 : tabIndex,
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: thumbClasses, "aria-hidden": "true" })
+    }
+  );
+};
+
+
+
+exports.Switch = Switch;