@expcat/tigercat-react 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yizhe Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-2DOPHSZP.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var React = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/components/Breadcrumb.tsx
+var BreadcrumbContext = React.createContext(null);
+function useBreadcrumbContext() {
+  return React.useContext(BreadcrumbContext);
+}
+var Breadcrumb = ({
+  separator = "/",
+  className,
+  style,
+  children,
+  ...props
+}) => {
+  const containerClasses = React__default.default.useMemo(
+    () => tigercatCore.classNames(tigercatCore.breadcrumbContainerClasses, className),
+    [className]
+  );
+  const contextValue = React__default.default.useMemo(() => ({ separator }), [separator]);
+  return /* @__PURE__ */ jsxRuntime.jsx(BreadcrumbContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx("nav", { className: containerClasses, "aria-label": "Breadcrumb", style, ...props, children: /* @__PURE__ */ jsxRuntime.jsx("ol", { className: "flex items-center flex-wrap gap-2", children }) }) });
+};
+
+exports.Breadcrumb = Breadcrumb;
+exports.useBreadcrumbContext = useBreadcrumbContext;

package/dist/chunk-2TS6X5RA.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Tag.tsx
+var CloseIcon = () => /* @__PURE__ */ jsxRuntime.jsx(
+  "svg",
+  {
+    className: "h-3 w-3",
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "none",
+    viewBox: tigercatCore.icon24ViewBox,
+    stroke: "currentColor",
+    strokeWidth: tigercatCore.icon24StrokeWidth,
+    "aria-hidden": "true",
+    focusable: "false",
+    children: /* @__PURE__ */ jsxRuntime.jsx(
+      "path",
+      {
+        strokeLinecap: tigercatCore.icon24PathStrokeLinecap,
+        strokeLinejoin: tigercatCore.icon24PathStrokeLinejoin,
+        d: tigercatCore.tagCloseIconPath
+      }
+    )
+  }
+);
+var Tag = ({
+  variant = "default",
+  size = "md",
+  closable = false,
+  closeAriaLabel = "Close tag",
+  onClose,
+  children,
+  className,
+  ...props
+}) => {
+  const [isVisible, setIsVisible] = react.useState(true);
+  const tagClasses = tigercatCore.classNames(
+    tigercatCore.tagBaseClasses,
+    tigercatCore.getTagVariantClasses(variant),
+    tigercatCore.tagSizeClasses[size],
+    className
+  );
+  const scheme = tigercatCore.defaultTagThemeColors[variant];
+  const closeButtonClasses = tigercatCore.classNames(tigercatCore.tagCloseButtonBaseClasses, scheme.closeBgHover, scheme.text);
+  const handleClose = (event) => {
+    event.stopPropagation();
+    onClose?.(event);
+    if (!event.defaultPrevented) {
+      setIsVisible(false);
+    }
+  };
+  if (!isVisible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("span", { className: tagClasses, role: "status", ...props, children: [
+    children != null && /* @__PURE__ */ jsxRuntime.jsx("span", { children }),
+    closable && /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        className: closeButtonClasses,
+        onClick: handleClose,
+        "aria-label": closeAriaLabel,
+        type: "button",
+        children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, {})
+      }
+    )
+  ] });
+};
+
+exports.Tag = Tag;

package/dist/chunk-2Y327ZU4.js

@@ -0,0 +1,493 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/DatePicker.tsx
+var Icon = ({ path, className }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "svg",
+  {
+    className,
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: tigercatCore.icon20ViewBox,
+    fill: "currentColor",
+    children: /* @__PURE__ */ jsxRuntime.jsx("path", { fillRule: "evenodd", d: path, clipRule: "evenodd" })
+  }
+);
+var isRangeDatePicker = (props) => props.range === true;
+var DatePicker = (props) => {
+  const {
+    size = "md",
+    disabled = false,
+    readonly = false,
+    required = false,
+    clearable = true,
+    format = "yyyy-MM-dd"
+  } = props;
+  const isRangeMode = isRangeDatePicker(props);
+  const placeholder = props.placeholder ?? (isRangeMode ? "Select date range" : "Select date");
+  const divProps = (({
+    value: _value,
+    defaultValue: _defaultValue,
+    range: _range,
+    locale: _locale,
+    labels: _labels,
+    size: _size,
+    format: _format,
+    placeholder: _placeholder,
+    disabled: _disabled,
+    readonly: _readonly,
+    required: _required,
+    minDate: _minDate,
+    maxDate: _maxDate,
+    clearable: _clearable,
+    name: _name,
+    id: _id,
+    onChange: _onChange,
+    onClear: _onClear,
+    className: _className,
+    ...rest
+  }) => rest)(props);
+  const [isOpen, setIsOpen] = react.useState(false);
+  const [activeDateIso, setActiveDateIso] = react.useState(null);
+  const [internalValue, setInternalValue] = react.useState(() => {
+    if (isRangeMode) return null;
+    return tigercatCore.parseDate(props.defaultValue ?? null);
+  });
+  const [internalRangeValue, setInternalRangeValue] = react.useState(() => {
+    if (!isRangeMode) return [null, null];
+    const tuple = props.defaultValue ?? null;
+    if (!tuple) return [null, null];
+    const start = Array.isArray(tuple) ? tigercatCore.parseDate(tuple[0]) : null;
+    const end = Array.isArray(tuple) ? tigercatCore.parseDate(tuple[1]) : null;
+    return [start, end];
+  });
+  const calendarRef = react.useRef(null);
+  const inputWrapperRef = react.useRef(null);
+  const inputRef = react.useRef(null);
+  const pendingFocusIsoRef = react.useRef(null);
+  const restoreFocusRef = react.useRef(null);
+  const isControlled = props.value !== void 0;
+  const selectedDate = (() => {
+    if (isRangeMode) return null;
+    const current = isControlled ? props.value : internalValue;
+    return tigercatCore.parseDate(current ?? null);
+  })();
+  const selectedRange = (() => {
+    if (!isRangeMode) return [null, null];
+    const tuple = isControlled ? props.value : internalRangeValue;
+    if (!tuple) return [null, null];
+    const start = Array.isArray(tuple) ? tigercatCore.parseDate(tuple[0]) : null;
+    const end = Array.isArray(tuple) ? tigercatCore.parseDate(tuple[1]) : null;
+    return [start, end];
+  })();
+  const minDateParsed = tigercatCore.parseDate(props.minDate ?? null);
+  const maxDateParsed = tigercatCore.parseDate(props.maxDate ?? null);
+  const [viewingMonth, setViewingMonth] = react.useState(
+    (selectedDate ?? selectedRange[0])?.getMonth() ?? (/* @__PURE__ */ new Date()).getMonth()
+  );
+  const [viewingYear, setViewingYear] = react.useState(
+    (selectedDate ?? selectedRange[0])?.getFullYear() ?? (/* @__PURE__ */ new Date()).getFullYear()
+  );
+  const displayValue = (() => {
+    if (!isRangeMode) {
+      return selectedDate ? tigercatCore.formatDate(selectedDate, format) : "";
+    }
+    const [start, end] = selectedRange;
+    const startText = start ? tigercatCore.formatDate(start, format) : "";
+    const endText = end ? tigercatCore.formatDate(end, format) : "";
+    if (!startText && !endText) return "";
+    if (startText && endText) return `${startText} - ${endText}`;
+    return startText ? `${startText} - ` : ` - ${endText}`;
+  })();
+  const showClearButton = (() => {
+    if (!clearable || disabled || readonly) return false;
+    if (!isRangeMode) return selectedDate !== null;
+    return selectedRange[0] !== null || selectedRange[1] !== null;
+  })();
+  const calendarDays = tigercatCore.getCalendarDays(viewingYear, viewingMonth);
+  const dayNames = tigercatCore.getShortDayNames(props.locale);
+  const labels = tigercatCore.getDatePickerLabels(props.locale, props.labels);
+  const toggleCalendar = () => {
+    if (!disabled && !readonly) {
+      setIsOpen(!isOpen);
+      if (!isOpen) {
+        restoreFocusRef.current = document.activeElement ?? null;
+        const baseDate = selectedDate ?? selectedRange[0];
+        if (baseDate) {
+          setViewingMonth(baseDate.getMonth());
+          setViewingYear(baseDate.getFullYear());
+        }
+      }
+    }
+  };
+  const closeCalendar = () => {
+    setIsOpen(false);
+  };
+  const getFirstEnabledIsoInView = () => {
+    for (const date of calendarDays) {
+      if (!date) continue;
+      const iso = tigercatCore.formatDate(date, "yyyy-MM-dd");
+      const isDisabled = isDateDisabled(date);
+      if (!isDisabled) return iso;
+    }
+    return null;
+  };
+  const getPreferredFocusIso = () => {
+    const focusDate = isRangeMode ? selectedRange[0] ?? selectedRange[1] : selectedDate;
+    if (focusDate) {
+      return tigercatCore.formatDate(focusDate, "yyyy-MM-dd");
+    }
+    const today = tigercatCore.normalizeDate(/* @__PURE__ */ new Date());
+    if (tigercatCore.isDateInRange(today, minDateParsed, maxDateParsed)) {
+      return tigercatCore.formatDate(today, "yyyy-MM-dd");
+    }
+    return getFirstEnabledIsoInView();
+  };
+  const focusDateButtonByIso = (iso) => {
+    const button = calendarRef.current?.querySelector(
+      `button[data-date="${iso}"]`
+    );
+    if (!button || button.disabled) return false;
+    button.focus();
+    setActiveDateIso(iso);
+    return true;
+  };
+  const restoreFocus = () => {
+    const target = restoreFocusRef.current ?? inputRef.current;
+    if (!target) return;
+    if (typeof target.focus === "function") {
+      target.focus();
+    }
+  };
+  const addDays = (date, days) => {
+    const next = new Date(date);
+    next.setDate(next.getDate() + days);
+    return next;
+  };
+  const moveFocus = (deltaDays) => {
+    const activeEl = document.activeElement;
+    const currentIso = activeEl?.getAttribute("data-date") ?? activeDateIso ?? null;
+    const baseIso = currentIso ?? getPreferredFocusIso();
+    if (!baseIso) return;
+    const baseDate = tigercatCore.parseDate(baseIso);
+    if (!baseDate) return;
+    let candidate = addDays(baseDate, deltaDays);
+    for (let attempts = 0; attempts < 42; attempts++) {
+      const iso = tigercatCore.formatDate(candidate, "yyyy-MM-dd");
+      const el = calendarRef.current?.querySelector(
+        `button[data-date="${iso}"]`
+      );
+      if (el && !el.disabled) {
+        el.focus();
+        setActiveDateIso(iso);
+        return;
+      }
+      if (!el) {
+        pendingFocusIsoRef.current = iso;
+        setViewingYear(candidate.getFullYear());
+        setViewingMonth(candidate.getMonth());
+        setActiveDateIso(iso);
+        return;
+      }
+      candidate = addDays(candidate, deltaDays);
+    }
+  };
+  const handleCalendarKeyDown = (event) => {
+    if (!isOpen) return;
+    switch (event.key) {
+      case "Escape": {
+        event.preventDefault();
+        closeCalendar();
+        return;
+      }
+      case "ArrowRight": {
+        event.preventDefault();
+        moveFocus(1);
+        return;
+      }
+      case "ArrowLeft": {
+        event.preventDefault();
+        moveFocus(-1);
+        return;
+      }
+      case "ArrowDown": {
+        event.preventDefault();
+        moveFocus(7);
+        return;
+      }
+      case "ArrowUp": {
+        event.preventDefault();
+        moveFocus(-7);
+        return;
+      }
+      case "Enter":
+      case " ": {
+        const activeEl = document.activeElement;
+        if (activeEl?.tagName === "BUTTON" && activeEl.dataset.date) {
+          event.preventDefault();
+          if (!activeEl.disabled) activeEl.click();
+        }
+        return;
+      }
+    }
+  };
+  const setRangeValue = (next) => {
+    if (!isControlled) {
+      setInternalRangeValue(next);
+    }
+    props.onChange?.(next);
+  };
+  const selectDate = (date) => {
+    if (!date) return;
+    const normalizedDate = tigercatCore.normalizeDate(date);
+    if (!tigercatCore.isDateInRange(normalizedDate, minDateParsed, maxDateParsed)) {
+      return;
+    }
+    if (!isRangeMode) {
+      if (!isControlled) {
+        setInternalValue(normalizedDate);
+      }
+      props.onChange?.(normalizedDate);
+      closeCalendar();
+      return;
+    }
+    const [start, end] = selectedRange;
+    if (!start || start && end) {
+      setRangeValue([normalizedDate, null]);
+      return;
+    }
+    if (normalizedDate < start) {
+      setRangeValue([start, start]);
+    } else {
+      setRangeValue([start, normalizedDate]);
+    }
+  };
+  const setToday = () => {
+    selectDate(/* @__PURE__ */ new Date());
+  };
+  const clearDate = (event) => {
+    event.stopPropagation();
+    if (!isRangeMode) {
+      if (!isControlled) {
+        setInternalValue(null);
+      }
+      props.onChange?.(null);
+    } else {
+      setRangeValue([null, null]);
+    }
+    props.onClear?.();
+  };
+  const previousMonth = () => {
+    if (viewingMonth === 0) {
+      setViewingMonth(11);
+      setViewingYear(viewingYear - 1);
+    } else {
+      setViewingMonth(viewingMonth - 1);
+    }
+  };
+  const nextMonth = () => {
+    if (viewingMonth === 11) {
+      setViewingMonth(0);
+      setViewingYear(viewingYear + 1);
+    } else {
+      setViewingMonth(viewingMonth + 1);
+    }
+  };
+  const isDateDisabled = (date) => {
+    if (!date) return true;
+    return !tigercatCore.isDateInRange(date, minDateParsed, maxDateParsed);
+  };
+  const isCurrentMonth = (date) => {
+    if (!date) return false;
+    return date.getMonth() === viewingMonth;
+  };
+  const handleInputClick = () => {
+    toggleCalendar();
+  };
+  react.useEffect(() => {
+    const handleClickOutside = (event) => {
+      if (calendarRef.current && inputWrapperRef.current && !calendarRef.current.contains(event.target) && !inputWrapperRef.current.contains(event.target)) {
+        closeCalendar();
+      }
+    };
+    if (isOpen) {
+      document.addEventListener("click", handleClickOutside);
+      return () => {
+        document.removeEventListener("click", handleClickOutside);
+      };
+    }
+  }, [isOpen]);
+  react.useEffect(() => {
+    if (isOpen) {
+      restoreFocusRef.current = document.activeElement ?? null;
+      const preferred = pendingFocusIsoRef.current ?? getPreferredFocusIso();
+      pendingFocusIsoRef.current = null;
+      setTimeout(() => {
+        if (preferred && focusDateButtonByIso(preferred)) return;
+        const fallback = getFirstEnabledIsoInView();
+        if (fallback) focusDateButtonByIso(fallback);
+      }, 0);
+      return;
+    }
+    setTimeout(() => {
+      restoreFocus();
+    }, 0);
+  }, [isOpen]);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    const pending = pendingFocusIsoRef.current;
+    if (!pending) return;
+    pendingFocusIsoRef.current = null;
+    setTimeout(() => {
+      if (focusDateButtonByIso(pending)) return;
+      const fallback = getFirstEnabledIsoInView();
+      if (fallback) focusDateButtonByIso(fallback);
+    }, 0);
+  }, [isOpen, viewingMonth, viewingYear]);
+  const inputClasses = tigercatCore.getDatePickerInputClasses(size, disabled || readonly);
+  const iconButtonClasses = tigercatCore.getDatePickerIconButtonClasses(size);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: tigercatCore.classNames(tigercatCore.datePickerBaseClasses, props.className), ...divProps, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: inputWrapperRef, className: tigercatCore.datePickerInputWrapperClasses, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref: inputRef,
+          type: "text",
+          className: inputClasses,
+          value: displayValue,
+          placeholder,
+          disabled,
+          readOnly: true,
+          required,
+          name: props.name,
+          id: props.id,
+          onClick: handleInputClick,
+          "aria-label": placeholder || "Select date"
+        }
+      ),
+      showClearButton && /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: tigercatCore.datePickerClearButtonClasses,
+          onClick: clearDate,
+          "aria-label": labels.clearDate,
+          children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { path: tigercatCore.CloseIconPath, className: "w-4 h-4" })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: iconButtonClasses,
+          disabled: disabled || readonly,
+          onClick: toggleCalendar,
+          "aria-label": labels.toggleCalendar,
+          children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { path: tigercatCore.CalendarIconPath, className: "w-5 h-5" })
+        }
+      )
+    ] }),
+    isOpen && /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        ref: calendarRef,
+        className: tigercatCore.datePickerCalendarClasses,
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-label": labels.calendar,
+        onKeyDown: handleCalendarKeyDown,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: tigercatCore.datePickerCalendarHeaderClasses, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                className: tigercatCore.datePickerNavButtonClasses,
+                onClick: previousMonth,
+                "aria-label": labels.previousMonth,
+                children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { path: tigercatCore.ChevronLeftIconPath, className: "w-5 h-5" })
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.datePickerMonthYearClasses, children: tigercatCore.formatMonthYear(viewingYear, viewingMonth, props.locale) }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                className: tigercatCore.datePickerNavButtonClasses,
+                onClick: nextMonth,
+                "aria-label": labels.nextMonth,
+                children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { path: tigercatCore.ChevronRightIconPath, className: "w-5 h-5" })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.datePickerCalendarGridClasses, role: "row", children: dayNames.map((day) => /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.datePickerDayNameClasses, role: "columnheader", children: day }, day)) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: tigercatCore.datePickerCalendarGridClasses,
+              role: "grid",
+              "aria-rowcount": 6,
+              "aria-colcount": 7,
+              children: calendarDays.map((date, index) => {
+                if (!date) return null;
+                const [rangeStart, rangeEnd] = selectedRange;
+                const isRangeStart = isRangeMode && rangeStart ? tigercatCore.isSameDay(date, rangeStart) : false;
+                const isRangeEnd = isRangeMode && rangeEnd ? tigercatCore.isSameDay(date, rangeEnd) : false;
+                const isInRange = isRangeMode && rangeStart && rangeEnd && tigercatCore.normalizeDate(date) >= tigercatCore.normalizeDate(rangeStart) && tigercatCore.normalizeDate(date) <= tigercatCore.normalizeDate(rangeEnd);
+                const isSelected = !isRangeMode ? selectedDate ? tigercatCore.isSameDay(date, selectedDate) : false : isRangeStart || isRangeEnd;
+                const isCurrentMonthDay = isCurrentMonth(date);
+                const isTodayDay = tigercatCore.isToday(date);
+                const isSelectingRangeEnd = isRangeMode && Boolean(rangeStart) && !rangeEnd;
+                const isBeforeRangeStart = isSelectingRangeEnd && rangeStart && tigercatCore.normalizeDate(date) < tigercatCore.normalizeDate(rangeStart);
+                const isDisabled = isDateDisabled(date) || Boolean(isBeforeRangeStart);
+                const iso = tigercatCore.formatDate(date, "yyyy-MM-dd");
+                return /* @__PURE__ */ jsxRuntime.jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: tigercatCore.getDatePickerDayCellClasses(
+                      isCurrentMonthDay,
+                      isSelected,
+                      isTodayDay,
+                      isDisabled,
+                      Boolean(isInRange),
+                      Boolean(isRangeStart),
+                      Boolean(isRangeEnd)
+                    ),
+                    disabled: isDisabled,
+                    onClick: () => selectDate(date),
+                    role: "gridcell",
+                    "data-date": iso,
+                    onFocus: () => setActiveDateIso(iso),
+                    tabIndex: activeDateIso === iso && !isDisabled ? 0 : -1,
+                    "aria-label": iso,
+                    "aria-selected": isSelected,
+                    "aria-current": isTodayDay ? "date" : void 0,
+                    children: date.getDate()
+                  },
+                  index
+                );
+              })
+            }
+          ),
+          isRangeMode && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: tigercatCore.datePickerFooterClasses, children: [
+            /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: tigercatCore.datePickerFooterButtonClasses, onClick: setToday, children: labels.today }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                className: tigercatCore.datePickerFooterButtonClasses,
+                onClick: closeCalendar,
+                children: labels.ok
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] });
+};
+
+exports.DatePicker = DatePicker;

package/dist/chunk-3GD3LOII.mjs

@@ -0,0 +1,23 @@
+import { classNames, layoutSidebarClasses } from '@expcat/tigercat-core';
+import { jsx } from 'react/jsx-runtime';
+
+// src/components/Sidebar.tsx
+var Sidebar = ({
+  className,
+  width = "256px",
+  collapsed = false,
+  style,
+  children,
+  ...props
+}) => {
+  const sidebarClasses = classNames(layoutSidebarClasses, className);
+  const sidebarStyle = {
+    ...style,
+    width: collapsed ? "0px" : width,
+    minWidth: collapsed ? "0px" : width,
+    overflow: "hidden"
+  };
+  return /* @__PURE__ */ jsx("aside", { className: sidebarClasses, style: sidebarStyle, ...props, children: !collapsed && children });
+};
+
+export { Sidebar };