@helpwave/hightide/dist/components/user-action/DateAndTimePicker.mjs

helpwave's component and theming library

// src/components/user-action/DateAndTimePicker.tsx
import clsx7 from "clsx";

// src/localization/LanguageProvider.tsx
import { createContext, useContext, useEffect, useState as useState2 } from "react";

// src/hooks/useLocalStorage.ts
import { useCallback, useState } from "react";

// src/localization/util.ts
var languages = ["en", "de"];
var languagesLocalNames = {
  en: "English",
  de: "Deutsch"
};
var DEFAULT_LANGUAGE = "en";
var LanguageUtil = {
  languages,
  DEFAULT_LANGUAGE,
  languagesLocalNames
};

// src/localization/LanguageProvider.tsx
import { jsx } from "react/jsx-runtime";
var LanguageContext = createContext({
  language: LanguageUtil.DEFAULT_LANGUAGE,
  setLanguage: (v) => v
});
var useLanguage = () => useContext(LanguageContext);
var useLocale = (overWriteLanguage) => {
  const { language } = useLanguage();
  const mapping = {
    en: "en-US",
    de: "de-DE"
  };
  return mapping[overWriteLanguage ?? language];
};

// src/localization/useTranslation.ts
var TranslationPluralCount = {
  zero: 0,
  one: 1,
  two: 2,
  few: 3,
  many: 11,
  other: -1
};
var useTranslation = (translations, overwriteTranslation = {}) => {
  const { language: languageProp, translation: overwrite } = overwriteTranslation;
  const { language: inferredLanguage } = useLanguage();
  const usedLanguage = languageProp ?? inferredLanguage;
  const usedTranslations = [...translations];
  if (overwrite) {
    usedTranslations.push(overwrite);
  }
  return (key, options) => {
    const { count, replacements } = { ...{ count: 0, replacements: {} }, ...options };
    try {
      for (let i = translations.length - 1; i >= 0; i--) {
        const translation = translations[i];
        const localizedTranslation = translation[usedLanguage];
        if (!localizedTranslation) {
          continue;
        }
        const value = localizedTranslation[key];
        if (!value) {
          continue;
        }
        let forProcessing;
        if (typeof value !== "string") {
          if (count === TranslationPluralCount.zero && value?.zero) {
            forProcessing = value.zero;
          } else if (count === TranslationPluralCount.one && value?.one) {
            forProcessing = value.one;
          } else if (count === TranslationPluralCount.two && value?.two) {
            forProcessing = value.two;
          } else if (TranslationPluralCount.few <= count && count < TranslationPluralCount.many && value?.few) {
            forProcessing = value.few;
          } else if (count > TranslationPluralCount.many && value?.many) {
            forProcessing = value.many;
          } else {
            forProcessing = value.other;
          }
        } else {
          forProcessing = value;
        }
        forProcessing = forProcessing.replace(/\{\{(\w+)}}/g, (_, placeholder) => {
          return replacements[placeholder] ?? `{{key:${placeholder}}}`;
        });
        return forProcessing;
      }
    } catch (e) {
      console.error(e);
    }
    return `{{${usedLanguage}:${key}}}`;
  };
};

// src/util/noop.ts
var noop = () => void 0;

// src/util/array.ts
var equalSizeGroups = (array, groupSize) => {
  if (groupSize <= 0) {
    console.warn(`group size should be greater than 0: groupSize = ${groupSize}`);
    return [[...array]];
  }
  const groups = [];
  for (let i = 0; i < array.length; i += groupSize) {
    groups.push(array.slice(i, Math.min(i + groupSize, array.length)));
  }
  return groups;
};
var defaultRangeOptions = {
  allowEmptyRange: false,
  stepSize: 1,
  exclusiveStart: false,
  exclusiveEnd: true
};
var range = (endOrRange, options) => {
  const { allowEmptyRange, stepSize, exclusiveStart, exclusiveEnd } = { ...defaultRangeOptions, ...options };
  let start = 0;
  let end;
  if (typeof endOrRange === "number") {
    end = endOrRange;
  } else {
    start = endOrRange[0];
    end = endOrRange[1];
  }
  if (!exclusiveEnd) {
    end -= 1;
  }
  if (exclusiveStart) {
    start += 1;
  }
  if (end - 1 < start) {
    if (!allowEmptyRange) {
      console.warn(`range: end (${end}) < start (${start}) should be allowed explicitly, set options.allowEmptyRange to true`);
    }
    return [];
  }
  return Array.from({ length: end - start }, (_, index) => index * stepSize + start);
};
var closestMatch = (list, firstCloser) => {
  return list.reduce((item1, item2) => {
    return firstCloser(item1, item2) ? item1 : item2;
  });
};

// src/util/date.ts
var monthsList = ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
var weekDayList = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
var changeDuration = (date, duration, isAdding) => {
  const {
    years = 0,
    months = 0,
    days = 0,
    hours = 0,
    minutes = 0,
    seconds = 0,
    milliseconds = 0
  } = duration;
  if (years < 0) {
    console.error(`Range error years must be greater than 0: received ${years}`);
    return new Date(date);
  }
  if (months < 0 || months > 11) {
    console.error(`Range error month must be 0 <= month <= 11: received ${months}`);
    return new Date(date);
  }
  if (days < 0) {
    console.error(`Range error days must be greater than 0: received ${days}`);
    return new Date(date);
  }
  if (hours < 0 || hours > 23) {
    console.error(`Range error hours must be 0 <= hours <= 23: received ${hours}`);
    return new Date(date);
  }
  if (minutes < 0 || minutes > 59) {
    console.error(`Range error minutes must be 0 <= minutes <= 59: received ${minutes}`);
    return new Date(date);
  }
  if (seconds < 0 || seconds > 59) {
    console.error(`Range error seconds must be 0 <= seconds <= 59: received ${seconds}`);
    return new Date(date);
  }
  if (milliseconds < 0) {
    console.error(`Range error seconds must be greater than 0: received ${milliseconds}`);
    return new Date(date);
  }
  const multiplier = isAdding ? 1 : -1;
  const newDate = new Date(date);
  newDate.setFullYear(newDate.getFullYear() + multiplier * years);
  newDate.setMonth(newDate.getMonth() + multiplier * months);
  newDate.setDate(newDate.getDate() + multiplier * days);
  newDate.setHours(newDate.getHours() + multiplier * hours);
  newDate.setMinutes(newDate.getMinutes() + multiplier * minutes);
  newDate.setSeconds(newDate.getSeconds() + multiplier * seconds);
  newDate.setMilliseconds(newDate.getMilliseconds() + multiplier * milliseconds);
  return newDate;
};
var addDuration = (date, duration) => {
  return changeDuration(date, duration, true);
};
var subtractDuration = (date, duration) => {
  return changeDuration(date, duration, false);
};
var isInTimeSpan = (value, startDate, endDate) => {
  if (startDate && endDate) {
    console.assert(startDate <= endDate);
    return startDate <= value && value <= endDate;
  } else if (startDate) {
    return startDate <= value;
  } else if (endDate) {
    return endDate >= value;
  } else {
    return true;
  }
};
var equalDate = (date1, date2) => {
  return date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate();
};
var getWeeksForCalenderMonth = (date, weekStart, weeks = 6) => {
  const month = date.getMonth();
  const year = date.getFullYear();
  const dayList = [];
  let currentDate = new Date(year, month, 1);
  const weekStartIndex = weekDayList.indexOf(weekStart);
  while (currentDate.getDay() !== weekStartIndex) {
    currentDate = subtractDuration(currentDate, { days: 1 });
  }
  while (dayList.length < 7 * weeks) {
    const date2 = new Date(currentDate);
    date2.setHours(date2.getHours(), date2.getMinutes());
    dayList.push(date2);
    currentDate = addDuration(currentDate, { days: 1 });
  }
  return equalSizeGroups(dayList, 7);
};

// src/components/user-action/Button.tsx
import { forwardRef } from "react";
import clsx from "clsx";
import { jsx as jsx2, jsxs } from "react/jsx-runtime";
var ButtonColorUtil = {
  solid: ["primary", "secondary", "tertiary", "positive", "warning", "negative", "neutral"],
  text: ["primary", "negative", "neutral"],
  outline: ["primary"]
};
var IconButtonUtil = {
  icon: [...ButtonColorUtil.solid, "transparent"]
};
var paddingMapping = {
  small: "btn-sm",
  medium: "btn-md",
  large: "btn-lg"
};
var iconPaddingMapping = {
  tiny: "icon-btn-xs",
  small: "icon-btn-sm",
  medium: "icon-btn-md",
  large: "icon-btn-lg"
};
var ButtonUtil = {
  paddingMapping,
  iconPaddingMapping
};
var SolidButton = forwardRef(function SolidButton2({
  children,
  color = "primary",
  size = "medium",
  startIcon,
  endIcon,
  onClick,
  className,
  ...restProps
}, ref) {
  const colorClasses = {
    primary: "not-disabled:bg-button-solid-primary-background not-disabled:text-button-solid-primary-text",
    secondary: "not-disabled:bg-button-solid-secondary-background not-disabled:text-button-solid-secondary-text",
    tertiary: "not-disabled:bg-button-solid-tertiary-background not-disabled:text-button-solid-tertiary-text",
    positive: "not-disabled:bg-button-solid-positive-background not-disabled:text-button-solid-positive-text",
    warning: "not-disabled:bg-button-solid-warning-background not-disabled:text-button-solid-warning-text",
    negative: "not-disabled:bg-button-solid-negative-background not-disabled:text-button-solid-negative-text",
    neutral: "not-disabled:bg-button-solid-neutral-background not-disabled:text-button-solid-neutral-text"
  }[color];
  const iconColorClasses = {
    primary: "not-group-disabled:text-button-solid-primary-icon",
    secondary: "not-group-disabled:text-button-solid-secondary-icon",
    tertiary: "not-group-disabled:text-button-solid-tertiary-icon",
    positive: "not-group-disabled:text-button-solid-positive-icon",
    warning: "not-group-disabled:text-button-solid-warning-icon",
    negative: "not-group-disabled:text-button-solid-negative-icon",
    neutral: "not-group-disabled:text-button-solid-neutral-icon"
  }[color];
  return /* @__PURE__ */ jsxs(
    "button",
    {
      ref,
      onClick,
      className: clsx(
        "group font-semibold",
        colorClasses,
        "not-disabled:hover:brightness-90",
        "disabled:text-disabled-text disabled:bg-disabled-background",
        ButtonUtil.paddingMapping[size],
        className
      ),
      ...restProps,
      children: [
        startIcon && /* @__PURE__ */ jsx2(
          "span",
          {
            className: clsx(
              iconColorClasses,
              "group-disabled:text-disabled-icon"
            ),
            children: startIcon
          }
        ),
        children,
        endIcon && /* @__PURE__ */ jsx2(
          "span",
          {
            className: clsx(
              iconColorClasses,
              "group-disabled:text-disabled-icon"
            ),
            children: endIcon
          }
        )
      ]
    }
  );
});
var TextButton = ({
  children,
  color = "neutral",
  size = "medium",
  startIcon,
  endIcon,
  onClick,
  coloredHoverBackground = true,
  className,
  ...restProps
}) => {
  const colorClasses = {
    primary: "not-disabled:bg-transparent not-disabled:text-button-text-primary-text",
    negative: "not-disabled:bg-transparent not-disabled:text-button-text-negative-text",
    neutral: "not-disabled:bg-transparent not-disabled:text-button-text-neutral-text"
  }[color];
  const backgroundColor = {
    primary: "not-disabled:hover:bg-button-text-primary-text/20",
    negative: "not-disabled:hover:bg-button-text-negative-text/20",
    neutral: "not-disabled:hover:bg-button-text-neutral-text/20"
  }[color];
  const iconColorClasses = {
    primary: "not-group-disabled:text-button-text-primary-icon",
    negative: "not-group-disabled:text-button-text-negative-icon",
    neutral: "not-group-disabled:text-button-text-neutral-icon"
  }[color];
  return /* @__PURE__ */ jsxs(
    "button",
    {
      onClick,
      className: clsx(
        "group font-semibold",
        "disabled:text-disabled-text",
        colorClasses,
        {
          [backgroundColor]: coloredHoverBackground,
          "not-disabled:hover:bg-button-text-hover-background": !coloredHoverBackground
        },
        ButtonUtil.paddingMapping[size],
        className
      ),
      ...restProps,
      children: [
        startIcon && /* @__PURE__ */ jsx2(
          "span",
          {
            className: clsx(
              iconColorClasses,
              "group-disabled:text-disabled-icon"
            ),
            children: startIcon
          }
        ),
        children,
        endIcon && /* @__PURE__ */ jsx2(
          "span",
          {
            className: clsx(
              iconColorClasses,
              "group-disabled:text-disabled-icon"
            ),
            children: endIcon
          }
        )
      ]
    }
  );
};

// src/components/date/TimePicker.tsx
import { useEffect as useEffect2, useRef, useState as useState3 } from "react";
import { Scrollbars } from "react-custom-scrollbars-2";
import clsx2 from "clsx";
import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
var TimePicker = ({
  time = /* @__PURE__ */ new Date(),
  onChange = noop,
  is24HourFormat = true,
  minuteIncrement = "5min",
  maxHeight = 300,
  className = ""
}) => {
  const minuteRef = useRef(null);
  const hourRef = useRef(null);
  const isPM = time.getHours() >= 11;
  const hours = is24HourFormat ? range(24) : range([1, 12], { exclusiveEnd: false });
  let minutes = range(60);
  useEffect2(() => {
    const scrollToItem = () => {
      if (minuteRef.current) {
        const container = minuteRef.current.parentElement;
        const hasOverflow = container.scrollHeight > maxHeight;
        if (hasOverflow) {
          minuteRef.current.scrollIntoView({
            behavior: "instant",
            block: "nearest"
          });
        }
      }
    };
    scrollToItem();
  }, [minuteRef, minuteRef.current]);
  useEffect2(() => {
    const scrollToItem = () => {
      if (hourRef.current) {
        const container = hourRef.current.parentElement;
        const hasOverflow = container.scrollHeight > maxHeight;
        if (hasOverflow) {
          hourRef.current.scrollIntoView({
            behavior: "instant",
            block: "nearest"
          });
        }
      }
    };
    scrollToItem();
  }, [hourRef, hourRef.current]);
  switch (minuteIncrement) {
    case "5min":
      minutes = minutes.filter((value) => value % 5 === 0);
      break;
    case "10min":
      minutes = minutes.filter((value) => value % 10 === 0);
      break;
    case "15min":
      minutes = minutes.filter((value) => value % 15 === 0);
      break;
    case "30min":
      minutes = minutes.filter((value) => value % 30 === 0);
      break;
  }
  const closestMinute = closestMatch(minutes, (item1, item2) => Math.abs(item1 - time.getMinutes()) < Math.abs(item2 - time.getMinutes()));
  const style = (selected) => clsx2(
    "chip-full hover:brightness-90 hover:bg-primary hover:text-on-primary rounded-md mr-3",
    { "bg-primary text-on-primary": selected, "bg-white text-black": !selected }
  );
  const onChangeWrapper = (transformer) => {
    const newDate = new Date(time);
    transformer(newDate);
    onChange(newDate);
  };
  return /* @__PURE__ */ jsxs2("div", { className: clsx2("flex-row-2 w-fit min-w-[150px] select-none", className), children: [
    /* @__PURE__ */ jsx3(Scrollbars, { autoHeight: true, autoHeightMax: maxHeight, style: { height: "100%" }, children: /* @__PURE__ */ jsx3("div", { className: "flex-col-1 h-full", children: hours.map((hour) => {
      const currentHour = hour === time.getHours() - (!is24HourFormat && isPM ? 12 : 0);
      return /* @__PURE__ */ jsx3(
        "button",
        {
          ref: currentHour ? hourRef : void 0,
          className: style(currentHour),
          onClick: () => onChangeWrapper((newDate) => newDate.setHours(hour + (!is24HourFormat && isPM ? 12 : 0))),
          children: hour.toString().padStart(2, "0")
        },
        hour
      );
    }) }) }),
    /* @__PURE__ */ jsx3(Scrollbars, { autoHeight: true, autoHeightMax: maxHeight, style: { height: "100%" }, children: /* @__PURE__ */ jsx3("div", { className: "flex-col-1 h-full", children: minutes.map((minute) => {
      const currentMinute = minute === closestMinute;
      return /* @__PURE__ */ jsx3(
        "button",
        {
          ref: currentMinute ? minuteRef : void 0,
          className: style(currentMinute),
          onClick: () => onChangeWrapper((newDate) => newDate.setMinutes(minute)),
          children: minute.toString().padStart(2, "0")
        },
        minute + minuteIncrement
      );
    }) }) }),
    !is24HourFormat && /* @__PURE__ */ jsxs2("div", { className: "flex-col-1", children: [
      /* @__PURE__ */ jsx3(
        "button",
        {
          className: style(!isPM),
          onClick: () => onChangeWrapper((newDate) => isPM && newDate.setHours(newDate.getHours() - 12)),
          children: "AM"
        }
      ),
      /* @__PURE__ */ jsx3(
        "button",
        {
          className: style(isPM),
          onClick: () => onChangeWrapper((newDate) => !isPM && newDate.setHours(newDate.getHours() + 12)),
          children: "PM"
        }
      )
    ] })
  ] });
};

// src/components/date/DatePicker.tsx
import { useEffect as useEffect6, useState as useState7 } from "react";
import { ArrowDown, ArrowUp, ChevronDown as ChevronDown2 } from "lucide-react";
import clsx6 from "clsx";

// src/components/date/YearMonthPicker.tsx
import { useEffect as useEffect4, useRef as useRef2, useState as useState5 } from "react";
import { Scrollbars as Scrollbars2 } from "react-custom-scrollbars-2";
import clsx4 from "clsx";

// src/components/layout-and-navigation/Expandable.tsx
import { forwardRef as forwardRef2, useCallback as useCallback2, useEffect as useEffect3, useState as useState4 } from "react";
import { ChevronDown } from "lucide-react";
import clsx3 from "clsx";
import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
var ExpansionIcon = ({ isExpanded, className }) => {
  return /* @__PURE__ */ jsx4(
    ChevronDown,
    {
      className: clsx3(
        "min-w-6 w-6 min-h-6 h-6 transition-transform duration-200 ease-in-out",
        { "rotate-180": isExpanded },
        className
      )
    }
  );
};
var Expandable = forwardRef2(function Expandable2({
  children,
  label,
  icon,
  isExpanded = false,
  onChange = noop,
  clickOnlyOnHeader = true,
  disabled = false,
  className,
  headerClassName,
  contentClassName,
  contentExpandedClassName
}, ref) {
  const defaultIcon = useCallback2((expanded) => /* @__PURE__ */ jsx4(ExpansionIcon, { isExpanded: expanded }), []);
  icon ??= defaultIcon;
  return /* @__PURE__ */ jsxs3(
    "div",
    {
      ref,
      className: clsx3("flex-col-0 bg-surface text-on-surface group rounded-lg shadow-sm", { "cursor-pointer": !clickOnlyOnHeader && !disabled }, className),
      onClick: () => !clickOnlyOnHeader && !disabled && onChange(!isExpanded),
      children: [
        /* @__PURE__ */ jsxs3(
          "div",
          {
            className: clsx3(
              "flex-row-2 py-2 px-4 rounded-lg justify-between items-center bg-surface text-on-surface select-none",
              {
                "group-hover:brightness-97": !isExpanded,
                "hover:brightness-97": isExpanded && !disabled,
                "cursor-pointer": clickOnlyOnHeader && !disabled
              },
              headerClassName
            ),
            onClick: () => clickOnlyOnHeader && !disabled && onChange(!isExpanded),
            children: [
              label,
              icon(isExpanded)
            ]
          }
        ),
        /* @__PURE__ */ jsx4(
          "div",
          {
            className: clsx3(
              "flex-col-2 px-4 transition-all duration-300 ease-in-out",
              {
                [clsx3("max-h-96 opacity-100 pb-2 overflow-y-auto", contentExpandedClassName)]: isExpanded,
                "max-h-0 opacity-0 overflow-hidden": !isExpanded
              },
              contentClassName
            ),
            children
          }
        )
      ]
    }
  );
});
var ExpandableUncontrolled = forwardRef2(function ExpandableUncontrolled2({
  isExpanded,
  onChange = noop,
  ...props
}, ref) {
  const [usedIsExpanded, setUsedIsExpanded] = useState4(isExpanded);
  useEffect3(() => {
    setUsedIsExpanded(isExpanded);
  }, [isExpanded]);
  return /* @__PURE__ */ jsx4(
    Expandable,
    {
      ...props,
      ref,
      isExpanded: usedIsExpanded,
      onChange: (value) => {
        onChange(value);
        setUsedIsExpanded(value);
      }
    }
  );
});

// src/components/date/YearMonthPicker.tsx
import { jsx as jsx5 } from "react/jsx-runtime";
var YearMonthPicker = ({
  displayedYearMonth = /* @__PURE__ */ new Date(),
  start = subtractDuration(/* @__PURE__ */ new Date(), { years: 50 }),
  end = addDuration(/* @__PURE__ */ new Date(), { years: 50 }),
  onChange = noop,
  className = "",
  maxHeight = 300,
  showValueOpen = true
}) => {
  const locale = useLocale();
  const ref = useRef2(null);
  useEffect4(() => {
    const scrollToItem = () => {
      if (ref.current) {
        ref.current.scrollIntoView({
          behavior: "instant",
          block: "center"
        });
      }
    };
    scrollToItem();
  }, [ref]);
  if (end < start) {
    console.error(`startYear: (${start}) less than endYear: (${end})`);
    return null;
  }
  const years = range([start.getFullYear(), end.getFullYear()], { exclusiveEnd: false });
  return /* @__PURE__ */ jsx5("div", { className: clsx4("flex-col-0 select-none", className), children: /* @__PURE__ */ jsx5(Scrollbars2, { autoHeight: true, autoHeightMax: maxHeight, style: { height: "100%" }, children: /* @__PURE__ */ jsx5("div", { className: "flex-col-1 mr-3", children: years.map((year) => {
    const selectedYear = displayedYearMonth.getFullYear() === year;
    return /* @__PURE__ */ jsx5(
      ExpandableUncontrolled,
      {
        ref: (displayedYearMonth.getFullYear() ?? (/* @__PURE__ */ new Date()).getFullYear()) === year ? ref : void 0,
        label: /* @__PURE__ */ jsx5("span", { className: clsx4({ "text-primary font-bold": selectedYear }), children: year }),
        isExpanded: showValueOpen && selectedYear,
        contentClassName: "gap-y-1",
        children: equalSizeGroups([...monthsList], 3).map((monthList, index) => /* @__PURE__ */ jsx5("div", { className: "flex-row-1", children: monthList.map((month) => {
          const monthIndex = monthsList.indexOf(month);
          const newDate = new Date(year, monthIndex);
          const selectedMonth = selectedYear && monthIndex === displayedYearMonth.getMonth();
          const firstOfMonth = new Date(year, monthIndex, 1);
          const lastOfMonth = new Date(year, monthIndex, 1);
          const isAfterStart = start === void 0 || start <= addDuration(subtractDuration(lastOfMonth, { days: 1 }), { months: 1 });
          const isBeforeEnd = end === void 0 || firstOfMonth <= end;
          const isValid = isAfterStart && isBeforeEnd;
          return /* @__PURE__ */ jsx5(
            SolidButton,
            {
              disabled: !isValid,
              color: selectedMonth && isValid ? "primary" : "neutral",
              className: "flex-1",
              size: "small",
              onClick: () => {
                onChange(newDate);
              },
              children: new Intl.DateTimeFormat(locale, { month: "short" }).format(newDate)
            },
            month
          );
        }) }, index))
      },
      year
    );
  }) }) }) });
};

// src/components/date/DayPicker.tsx
import clsx5 from "clsx";
import { useEffect as useEffect5, useState as useState6 } from "react";
import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
var DayPicker = ({
  displayedMonth,
  selected,
  start,
  end,
  onChange = noop,
  weekStart = "monday",
  markToday = true,
  className = ""
}) => {
  const locale = useLocale();
  const month = displayedMonth.getMonth();
  const weeks = getWeeksForCalenderMonth(displayedMonth, weekStart);
  return /* @__PURE__ */ jsxs4("div", { className: clsx5("flex-col-1 min-w-[220px] select-none", className), children: [
    /* @__PURE__ */ jsx6("div", { className: "flex-row-2 text-center", children: weeks[0].map((weekDay, index) => /* @__PURE__ */ jsx6("div", { className: "flex-1 font-semibold", children: new Intl.DateTimeFormat(locale, { weekday: "long" }).format(weekDay).substring(0, 2) }, index)) }),
    weeks.map((week, index) => /* @__PURE__ */ jsx6("div", { className: "flex-row-2 text-center", children: week.map((date) => {
      const isSelected = !!selected && equalDate(selected, date);
      const isToday = equalDate(/* @__PURE__ */ new Date(), date);
      const isSameMonth = date.getMonth() === month;
      const isDayValid = isInTimeSpan(date, start, end);
      return /* @__PURE__ */ jsx6(
        "button",
        {
          disabled: !isDayValid,
          className: clsx5(
            "flex-1 rounded-full border-2",
            {
              "text-description": !isSameMonth && !isSelected && isDayValid,
              "text-button-solid-neutral-text bg-button-solid-neutral-background": !isSelected && isSameMonth && isDayValid,
              "text-button-solid-primary-text bg-button-solid-primary-background": isSelected && isDayValid,
              "hover:brightness-90 hover:bg-button-solid-primary-background hover:text-button-solid-primary-text": isDayValid,
              "text-disabled-text bg-disabled-background cursor-not-allowed": !isDayValid,
              "border-secondary": isToday && markToday,
              "border-transparent": !isToday || !markToday
            }
          ),
          onClick: () => onChange(date),
          children: date.getDate()
        },
        date.getDate()
      );
    }) }, index))
  ] });
};

// src/localization/defaults/time.ts
var monthTranslation = {
  en: {
    january: "January",
    february: "Febuary",
    march: "March",
    april: "April",
    may: "May",
    june: "June",
    july: "July",
    august: "August",
    september: "September",
    october: "October",
    november: "November",
    december: "December"
  },
  de: {
    january: "Januar",
    february: "Febuar",
    march: "M\xE4rz",
    april: "April",
    may: "Mai",
    june: "Juni",
    july: "Juli",
    august: "August",
    september: "September",
    october: "October",
    november: "November",
    december: "December"
  }
};
var timeTranslation = {
  en: {
    ...monthTranslation.en,
    century: { one: "Century", other: "Centuries" },
    decade: { one: "Decade", other: "Decades" },
    year: { one: "Year", other: "Years" },
    month: { one: "Month", other: "Months" },
    day: { one: "Day", other: "Days" },
    hour: { one: "Hour", other: "Hours" },
    minute: { one: "Minute", other: "Minutes" },
    second: { one: "Second", other: "Seconds" },
    millisecond: { one: "Millisecond", other: "Milliseconds" },
    microsecond: { one: "Microsecond", other: "Microseconds" },
    nanosecond: { one: "Nanosecond", other: "Nanoseconds" },
    yesterday: "Yesterday",
    today: "Today",
    tomorrow: "Tomorrow",
    in: "in",
    ago: "ago"
  },
  de: {
    ...monthTranslation.de,
    century: { one: "Jahrhundert", other: "Jahrhunderte" },
    decade: { one: "Jahrzehnt", other: "Jahrzehnte" },
    year: { one: "Jahr", other: "Jahre" },
    month: { one: "Monat", other: "Monate" },
    day: { one: "Tag", other: "Tage" },
    hour: { one: "Stunde", other: "Stunden" },
    minute: { one: "Minute", other: "Minuten" },
    second: { one: "Sekunde", other: "Sekunden" },
    millisecond: { one: "Millisekunde", other: "Millisekunden" },
    microsecond: { one: "Mikrosekunde", other: "Mikrosekunden" },
    nanosecond: { one: "Nanosekunde", other: "Nanosekunden" },
    yesterday: "Gestern",
    today: "Heute",
    tomorrow: "Morgen",
    in: "in",
    ago: "vor"
  }
};

// src/components/date/DatePicker.tsx
import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
var DatePicker = ({
  overwriteTranslation,
  value = /* @__PURE__ */ new Date(),
  start = subtractDuration(/* @__PURE__ */ new Date(), { years: 50 }),
  end = addDuration(/* @__PURE__ */ new Date(), { years: 50 }),
  initialDisplay = "day",
  onChange = noop,
  yearMonthPickerProps,
  dayPickerProps,
  className = ""
}) => {
  const locale = useLocale();
  const translation = useTranslation([timeTranslation], overwriteTranslation);
  const [displayedMonth, setDisplayedMonth] = useState7(value);
  const [displayMode, setDisplayMode] = useState7(initialDisplay);
  useEffect6(() => {
    setDisplayedMonth(value);
  }, [value]);
  return /* @__PURE__ */ jsxs5("div", { className: clsx6("flex-col-4", className), children: [
    /* @__PURE__ */ jsxs5("div", { className: "flex-row-2 items-center justify-between h-7", children: [
      /* @__PURE__ */ jsxs5(
        TextButton,
        {
          className: clsx6("flex-row-1 items-center cursor-pointer select-none", {
            "text-disabled-text": displayMode !== "day"
          }),
          onClick: () => setDisplayMode(displayMode === "day" ? "yearMonth" : "day"),
          children: [
            `${new Intl.DateTimeFormat(locale, { month: "long" }).format(displayedMonth)} ${displayedMonth.getFullYear()}`,
            /* @__PURE__ */ jsx7(ChevronDown2, { size: 16 })
          ]
        }
      ),
      displayMode === "day" && /* @__PURE__ */ jsxs5("div", { className: "flex-row-2 justify-end", children: [
        /* @__PURE__ */ jsx7(
          SolidButton,
          {
            size: "small",
            color: "primary",
            disabled: !isInTimeSpan(subtractDuration(displayedMonth, { months: 1 }), start, end),
            onClick: () => {
              setDisplayedMonth(subtractDuration(displayedMonth, { months: 1 }));
            },
            children: /* @__PURE__ */ jsx7(ArrowUp, { size: 20 })
          }
        ),
        /* @__PURE__ */ jsx7(
          SolidButton,
          {
            size: "small",
            color: "primary",
            disabled: !isInTimeSpan(addDuration(displayedMonth, { months: 1 }), start, end),
            onClick: () => {
              setDisplayedMonth(addDuration(displayedMonth, { months: 1 }));
            },
            children: /* @__PURE__ */ jsx7(ArrowDown, { size: 20 })
          }
        )
      ] })
    ] }),
    displayMode === "yearMonth" ? /* @__PURE__ */ jsx7(
      YearMonthPicker,
      {
        ...yearMonthPickerProps,
        displayedYearMonth: value,
        start,
        end,
        onChange: (newDate) => {
          setDisplayedMonth(newDate);
          setDisplayMode("day");
        }
      }
    ) : /* @__PURE__ */ jsxs5("div", { children: [
      /* @__PURE__ */ jsx7(
        DayPicker,
        {
          ...dayPickerProps,
          displayedMonth,
          start,
          end,
          selected: value,
          onChange: (date) => {
            onChange(date);
          }
        }
      ),
      /* @__PURE__ */ jsx7("div", { className: "mt-2", children: /* @__PURE__ */ jsx7(
        TextButton,
        {
          color: "primary",
          onClick: () => {
            const newDate = /* @__PURE__ */ new Date();
            newDate.setHours(value.getHours(), value.getMinutes());
            onChange(newDate);
          },
          children: translation("today")
        }
      ) })
    ] })
  ] });
};

// src/localization/defaults/form.ts
var formTranslation = {
  en: {
    add: "Add",
    all: "All",
    apply: "Apply",
    back: "Back",
    cancel: "Cancel",
    change: "Change",
    clear: "Clear",
    click: "Click",
    clickToCopy: "Click to Copy",
    close: "Close",
    confirm: "Confirm",
    copy: "Copy",
    copied: "Copied",
    create: "Create",
    decline: "Decline",
    delete: "Delete",
    discard: "Discard",
    discardChanges: "Discard Changes",
    done: "Done",
    edit: "Edit",
    enterText: "Enter text here",
    error: "Error",
    exit: "Exit",
    fieldRequiredError: "This field is required.",
    invalidEmailError: "Please enter a valid email address.",
    less: "Less",
    loading: "Loading",
    maxLengthError: "Maximum length exceeded.",
    minLengthError: "Minimum length not met.",
    more: "More",
    next: "Next",
    no: "No",
    none: "None",
    of: "of",
    optional: "Optional",
    pleaseWait: "Please wait...",
    previous: "Previous",
    remove: "Remove",
    required: "Required",
    reset: "Reset",
    save: "Save",
    saved: "Saved",
    search: "Search",
    select: "Select",
    selectOption: "Select an option",
    show: "Show",
    showMore: "Show more",
    showLess: "Show less",
    submit: "Submit",
    success: "Success",
    update: "Update",
    unsavedChanges: "Unsaved Changes",
    unsavedChangesSaveQuestion: "Do you want to save your changes?",
    yes: "Yes"
  },
  de: {
    add: "Hinzuf\xFCgen",
    all: "Alle",
    apply: "Anwenden",
    back: "Zur\xFCck",
    cancel: "Abbrechen",
    change: "\xC4ndern",
    clear: "L\xF6schen",
    click: "Klicken",
    clickToCopy: "Zum kopieren klicken",
    close: "Schlie\xDFen",
    confirm: "Best\xE4tigen",
    copy: "Kopieren",
    copied: "Kopiert",
    create: "Erstellen",
    decline: "Ablehnen",
    delete: "L\xF6schen",
    discard: "Verwerfen",
    discardChanges: "\xC4nderungen Verwerfen",
    done: "Fertig",
    edit: "Bearbeiten",
    enterText: "Text hier eingeben",
    error: "Fehler",
    exit: "Beenden",
    fieldRequiredError: "Dieses Feld ist erforderlich.",
    invalidEmailError: "Bitte geben Sie eine g\xFCltige E-Mail-Adresse ein.",
    less: "Weniger",
    loading: "L\xE4dt",
    maxLengthError: "Maximale L\xE4nge \xFCberschritten.",
    minLengthError: "Mindestl\xE4nge nicht erreicht.",
    more: "Mehr",
    next: "Weiter",
    no: "Nein",
    none: "Nichts",
    of: "von",
    optional: "Optional",
    pleaseWait: "Bitte warten...",
    previous: "Vorherige",
    remove: "Entfernen",
    required: "Erforderlich",
    reset: "Zur\xFCcksetzen",
    save: "Speichern",
    saved: "Gespeichert",
    search: "Suche",
    select: "Select",
    selectOption: "Option ausw\xE4hlen",
    show: "Anzeigen",
    showMore: "Mehr anzeigen",
    showLess: "Weniger anzeigen",
    submit: "Abschicken",
    success: "Erfolg",
    update: "Update",
    unsavedChanges: "Ungespeicherte \xC4nderungen",
    unsavedChangesSaveQuestion: "M\xF6chtest du die \xC4nderungen speichern?",
    yes: "Ja"
  }
};

// src/components/user-action/DateAndTimePicker.tsx
import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
var DateTimePicker = ({
  overwriteTranslation,
  value = /* @__PURE__ */ new Date(),
  start = subtractDuration(/* @__PURE__ */ new Date(), { years: 50 }),
  end = addDuration(/* @__PURE__ */ new Date(), { years: 50 }),
  mode = "dateTime",
  onFinish = noop,
  onChange = noop,
  onRemove = noop,
  timePickerProps,
  datePickerProps
}) => {
  const translation = useTranslation([formTranslation, timeTranslation], overwriteTranslation);
  const useDate = mode === "dateTime" || mode === "date";
  const useTime = mode === "dateTime" || mode === "time";
  let dateDisplay;
  let timeDisplay;
  if (useDate) {
    dateDisplay = /* @__PURE__ */ jsx8(
      DatePicker,
      {
        ...datePickerProps,
        className: "min-w-[320px] min-h-[250px]",
        yearMonthPickerProps: { maxHeight: 218 },
        value,
        start,
        end,
        onChange
      }
    );
  }
  if (useTime) {
    timeDisplay = /* @__PURE__ */ jsx8(
      TimePicker,
      {
        ...timePickerProps,
        className: clsx7("h-full", { "justify-between w-full": mode === "time" }),
        maxHeight: 250,
        time: value,
        onChange
      }
    );
  }
  return /* @__PURE__ */ jsxs6("div", { className: "flex-col-2 w-fit", children: [
    /* @__PURE__ */ jsxs6("div", { className: "flex-row-4", children: [
      dateDisplay,
      timeDisplay
    ] }),
    /* @__PURE__ */ jsx8("div", { className: "flex-row-2 justify-end", children: /* @__PURE__ */ jsxs6("div", { className: "flex-row-2 mt-1", children: [
      /* @__PURE__ */ jsx8(SolidButton, { size: "medium", color: "negative", onClick: onRemove, children: translation("clear") }),
      /* @__PURE__ */ jsx8(
        SolidButton,
        {
          size: "medium",
          onClick: () => onFinish(value),
          children: translation("change")
        }
      )
    ] }) })
  ] });
};
export {
  DateTimePicker
};
//# sourceMappingURL=DateAndTimePicker.mjs.map