@rio-cloud/rio-uikit 1.13.2 → 2.0.0-beta.2

package/components/datepicker/DayPicker.js

@@ -1,330 +1,281 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useState, useRef } from 'react';
-import { DayPicker as ReactDayPicker } from 'react-day-picker';
-import { format, isValid, parse } from 'date-fns';
-import * as locales from 'date-fns/locale';
-import noop from 'lodash/fp/noop';
-import debounce from 'lodash/fp/debounce';
-import 'react-day-picker/dist/style.css';
-import useClickOutside from '../../hooks/useClickOutside';
-import usePopperDropdown from '../../hooks/usePopperDropdown';
-import useKey from '../../hooks/useKey';
-import ClearableInput from '../clearableInput/ClearableInput';
-import classNames from 'classnames';
-const DayPicker = (props) => {
-    const { id, selected, inputProps = {}, alignRight, bsSize = '', locale = 'en-GB', footer, inline, showOutsideDays = true, fixedWeeks = true, mode = 'single', dateFormat, placeholder, isClearable = false, closeOnSelect = true, onSelectChange = noop, defaultMonth, startMonth, endMonth, inputClassName, className, } = props;
-    const isSingleMode = mode === 'single';
-    const isMultipleMode = mode === 'multiple';
-    const isRangeMode = mode === 'range';
-    const isControlled = selected !== undefined;
-    const [internalSelected, setInternalSelected] = useState();
-    const selectedValue = isControlled ? selected : internalSelected;
-    const narrowedSelected = (() => {
-        if (isSingleMode) {
-            return selectedValue instanceof Date ? selectedValue : undefined;
-        }
-        if (isMultipleMode) {
-            return Array.isArray(selectedValue) ? selectedValue : undefined;
-        }
-        return isDateRange(selectedValue) ? selectedValue : undefined;
-    })();
-    const selectionProps = { selected: narrowedSelected };
-    const resolvedLocale = resolveLocale(locale);
-    const [internalInputValue, setInternalInputValue] = useState('');
-    const inputValue = isControlled && !isSingleMode
-        ? formatSelectedForInput(narrowedSelected, locale, mode, dateFormat)
-        : internalInputValue;
-    // const inputValue = isSingleMode
-    //     ? internalInputValue
-    //     : formatSelectedForInput(narrowedSelected, locale, mode, dateFormat);
-    // const inputValue = internalInputValue;
-    // This ensures that whenever the external selected prop changes, the input field gets updated accordingly
-    useEffect(() => {
-        if (isSingleMode && isControlled && selected instanceof Date) {
-            setInternalInputValue(formatDate(selected, locale, dateFormat));
-        }
-    }, [selected, isSingleMode, isControlled, locale, dateFormat]);
-    const handleInputChange = (newValue) => doHandleInputValue(newValue);
-    const handleInputChangeNative = (event) => doHandleInputValue(event.currentTarget.value);
-    const debouncedParseInput = useRef(debounce(300, (rawValue) => {
-        const parsed = parseDateString(rawValue, locale);
-        console.log(parsed);
-        const isValid = !!parsed;
-        setInternalSelected(parsed);
-        if (isSingleMode && 'onInputChange' in props && props.onInputChange) {
-            props.onInputChange(rawValue, parsed, isValid);
-        }
-        const shouldNotify = parsed !== undefined || rawValue === '';
-        if (shouldNotify) {
-            // parse to desired dateFormat for use on outside
-            const formattedSelected = dateFormat ? parseDateString(rawValue, locale, dateFormat) : parsed;
-            onSelectChange(formattedSelected, {});
-        }
-    })).current;
-    const doHandleInputValue = (rawValue) => {
-        // const parsed = parseDateString(rawValue, locale, dateFormat);
-        // const isValid = !!parsed;
-        // if (!isControlled) {
-        //     // && isValidDate(parsed); // TODO: optional second validation
-        //     setInternalInputValue(rawValue);
-        //     setInternalSelected(parsed as typeof props.selected);
-        // } else if (isSingleMode) {
-        //     setInternalInputValue(rawValue);
-        // }
-        // if (isSingleMode && 'onInputChange' in props && props.onInputChange) {
-        //     props.onInputChange(rawValue, parsed, isValid);
-        // }
-        // const shouldNotify = parsed !== undefined || rawValue === '';
-        // if (shouldNotify) {
-        //     onSelectChange(parsed as typeof selected, {});
-        // }
-        setInternalInputValue(rawValue); // always update input state
-        debouncedParseInput(rawValue); // defer parsing & callback execution
-    };
-    const keyboardRef = useRef(false);
-    const handleInputBlur = (event) => {
-        // Do not close the dropdown on input blur when the user selects something inside the dropdown itself
-        const nextFocused = event.relatedTarget;
-        const focusInsideDropdown = nextFocused && popperElementRef.current?.contains(nextFocused);
-        if (isDropdownOpen && !focusInsideDropdown) {
-            closePopper();
-        }
-        if (!isSingleMode) {
-            return;
-        }
-        const parsed = parseDateString(internalInputValue, locale, dateFormat);
-        if (parsed && isValid(parsed)) {
-            setInternalSelected(parsed);
-            onSelectChange?.(parsed, {});
-            setInternalInputValue(formatDate(parsed, locale, dateFormat));
-        }
-    };
-    const handleOnInputFocus = () => {
-        if (!isDropdownOpen) {
-            openPopper();
-        }
-    };
-    const handleInputKeyPress = (event) => {
-        // Workaround to figure out if the user navigates via keyboard
-        if (event.key === 'Tab') {
-            keyboardRef.current = true;
-        }
-        if (event.key !== 'Enter') {
-            return;
-        }
-        // In case the dropdown is not open but the input is focused, open the dropdown on enter
-        if (!isDropdownOpen) {
-            handleInputClick();
-            return;
-        }
-        // In case the dropdown is open, the input is focused and the prop allows it, close the dropdown
-        if (isDropdownOpen && closeOnSelect) {
-            onSelectChange(narrowedSelected, {});
-            closePopper();
-        }
-    };
-    const handleSelectedChange = (newValue) => {
-        if (!isControlled) {
-            setInternalSelected(newValue);
-        }
-    };
-    const handleClearSelection = () => {
-        handleInputChange('');
-        handleSelectedChange(undefined);
-        setInternalInputValue('');
-        if (isControlled) {
-            setInternalSelected(undefined);
-        }
-        if (isRangeMode && 'onChange' in props && props.onChange) {
-            props.onChange(undefined);
-        }
-        onSelectChange(undefined, {});
-    };
-    const handleDaySelect = (selected, triggerDate, modifiers, event) => {
-        // safe because of discriminated union
-        handleSelectedChange(selected);
-        // trigger callback
-        onSelectChange(selected, modifiers);
-        if (isSingleMode && !isControlled) {
-            // should be the only place formatting is applied to the input
-            setInternalInputValue(formatDate(selected, locale, dateFormat));
-        }
-        if (keyboardRef.current) {
-            // Note: When the date is selected via enter key, assume the user uses keyboard navigation.
-            // In this case the input should be focused to allow to tab to another element in his form.
-            // However, it is not possible to detect according to the event since the event.type is alway "click".
-            // Instead we check if the user used the tab key to focus the day picker.
-            inputRef?.current?.focus();
-        }
-        if (closeOnSelect) {
-            closePopper();
-            keyboardRef.current = false;
-        }
+import { jsxs as k, jsx as i, Fragment as Se } from "react/jsx-runtime";
+import { useState as re, useEffect as ae, useRef as N } from "react";
+import { DayPicker as ie } from "react-day-picker";
+import { format as se, parse as be, isValid as ce } from "date-fns";
+import * as E from "date-fns/locale";
+import { debounce as De } from "es-toolkit/function";
+import "react-day-picker/dist/style.css";
+import Pe from "../../hooks/useClickOutside.js";
+import ke from "../../hooks/usePopperDropdown.js";
+import Ne from "../../hooks/useKey.js";
+import we from "../clearableInput/ClearableInput.js";
+import Re from "classnames";
+const Ee = (e) => !e.mode || e.mode === "single", xe = (e) => e.mode === "multiple", Le = (e) => e.mode === "range", Je = (e) => {
+  const {
+    id: o,
+    selected: r,
+    inputProps: s = {},
+    alignRight: u,
+    bsSize: f = "",
+    locale: a = "en-GB",
+    footer: S,
+    inline: le,
+    showOutsideDays: F = !0,
+    fixedWeeks: T = !0,
+    mode: M = "single",
+    dateFormat: p,
+    placeholder: O,
+    isClearable: B = !1,
+    closeOnSelect: j = !0,
+    defaultMonth: K,
+    startMonth: V,
+    endMonth: A,
+    inputClassName: G,
+    className: $
+  } = e, c = M === "single", de = M === "multiple", ye = M === "range", m = r !== void 0, [ue, b] = re(), h = m ? r : ue, w = c ? h instanceof Date ? h : void 0 : de ? Array.isArray(h) ? h : void 0 : Fe(h) ? h : void 0, z = { selected: w }, H = Te(a), [U, C] = re(""), W = m && !c ? Oe(w, a, M, p) : U;
+  ae(() => {
+    c && m && r instanceof Date && C(x(r, a, p));
+  }, [r, c, m, a, p]);
+  const I = (n, t) => {
+    if (Ee(e) && e.onSelectChange) {
+      e.onSelectChange(n, t);
+      return;
+    }
+    if (xe(e) && e.onSelectChange) {
+      e.onSelectChange(n, t);
+      return;
+    }
+    Le(e) && e.onSelectChange && e.onSelectChange(n, t);
+  }, Z = (n) => q(n), fe = (n) => q(n.currentTarget.value), pe = N(
+    De((n) => {
+      const t = L(n, a);
+      console.log(t);
+      const d = !!t;
+      if (b(t), c && "onInputChange" in e && e.onInputChange && e.onInputChange(n, t, d), t !== void 0 || n === "") {
+        const Ie = p ? L(n, a, p) : t;
+        I(Ie, {});
+      }
+    }, 300)
+  ).current, q = (n) => {
+    C(n), pe(n);
+  }, D = N(!1), J = (n) => {
+    const t = n.relatedTarget, d = t && te.current?.contains(t);
+    if (l && !d && v(), !c)
+      return;
+    const y = L(U, a, p);
+    y && ce(y) && (b(y), I(y, {}), C(x(y, a, p)));
+  }, Q = () => {
+    l || ee();
+  }, X = (n) => {
+    if (n.key === "Tab" && (D.current = !0), n.key === "Enter") {
+      if (!l) {
+        P();
+        return;
+      }
+      l && j && (I(w, {}), v());
+    }
+  }, Y = (n) => {
+    m || b(n);
+  }, me = () => {
+    Z(""), Y(void 0), C(""), m && b(void 0), ye && "onChange" in e && e.onChange && e.onChange(void 0), I(void 0, {});
+  }, _ = (n, t, d, y) => {
+    Y(n), I(n, d), c && !m && C(x(n, a, p)), D.current && g?.current?.focus(), j && (v(), D.current = !1);
+  }, {
+    isOpen: l,
+    open: ee,
+    close: v,
+    referenceRef: ne,
+    popperElementRef: ge,
+    popperStyles: Me,
+    popperAttributes: he
+  } = ke({ placement: u ? "bottom-end" : "bottom-start" }), g = N(null), te = N(null), ve = (n) => {
+    te.current = n, ge(n);
+  }, R = Pe(
+    (n) => {
+      const t = n.target;
+      if (!t) {
+        v();
+        return;
+      }
+      const d = ne.current?.contains(t), y = g.current?.contains(t);
+      d || y || v();
+    },
+    void 0,
+    l
+  ), P = () => {
+    ee(), g.current?.focus();
+  };
+  Ne("Escape", (n) => {
+    const t = n.target;
+    g.current && g.current === t && l && v();
+  }), ae(() => {
+    const n = (t) => {
+      !l || !R.current || t.key === "Tab" && R.current.contains(document.activeElement) && (D.current = !0, console.log("User tabbed into dropdown"));
     };
-    const { isOpen: isDropdownOpen, open: openPopper, close: closePopper, referenceRef: popperRef, popperElementRef: setPopperElement, popperStyles, popperAttributes, } = usePopperDropdown({ placement: alignRight ? 'bottom-end' : 'bottom-start' });
-    const inputRef = useRef(null);
-    const popperElementRef = useRef(null);
-    const assignPopperElement = (element) => {
-        popperElementRef.current = element;
-        setPopperElement(element);
+    return document.addEventListener("keydown", n), () => {
+      document.removeEventListener("keydown", n);
     };
-    // Close the dropdown when clicking outside the dropdown wrapper.
-    // It also checks if the click happened into the input, in which case the
-    // dropdown will remain open.
-    const outsideRef = useClickOutside(event => {
-        const target = event.target;
-        if (!target) {
-            closePopper();
-            return;
+  }, [l]);
+  const oe = `DayPicker ${f === "sm" ? "margin-10" : "margin-15"} ${f}`;
+  if (le)
+    return /* @__PURE__ */ k("div", { className: `display-flex flex-column justify-content-between ${$}`, children: [
+      /* @__PURE__ */ i(
+        ie,
+        {
+          ...z,
+          mode: M,
+          defaultMonth: K,
+          locale: H,
+          onSelect: _,
+          captionLayout: "dropdown",
+          animate: !0,
+          navLayout: "around",
+          startMonth: V,
+          endMonth: A,
+          showOutsideDays: F,
+          fixedWeeks: T,
+          className: oe
         }
-        const clickedWithinTrigger = popperRef.current?.contains(target);
-        const clickedWithinInput = inputRef.current?.contains(target);
-        if (clickedWithinTrigger || clickedWithinInput) {
-            return;
+      ),
+      S ? /* @__PURE__ */ i("div", { className: "padding-15", children: S }) : /* @__PURE__ */ i("div", {})
+    ] });
+  const Ce = {
+    ...s,
+    readOnly: !c,
+    style: {
+      background: "var(--color-white)",
+      ...s?.style ?? {}
+    }
+  };
+  return /* @__PURE__ */ k(Se, { children: [
+    /* @__PURE__ */ i("div", { ref: ne, className: `form-group ${$}`, children: /* @__PURE__ */ k("div", { className: "input-group", children: [
+      /* @__PURE__ */ i("span", { className: "input-group-addon", onClick: P, children: /* @__PURE__ */ i("span", { className: "rioglyph rioglyph-calendar", "aria-hidden": "true" }) }),
+      B && /* @__PURE__ */ i(
+        we,
+        {
+          id: o,
+          autoComplete: "off",
+          placeholder: O,
+          ...Ce,
+          type: "text",
+          value: W,
+          onChange: Z,
+          onClick: P,
+          onClear: me,
+          onBlur: J,
+          onFocus: Q,
+          onKeyPress: X,
+          ref: g,
+          inputClassName: G
         }
-        closePopper();
-    }, undefined, isDropdownOpen);
-    const handleInputClick = () => {
-        openPopper();
-        inputRef.current?.focus();
-    };
-    // Needed to select all tabbable elements inside the dropdown calendar and to disable the
-    // focus on tab for all of these. This allows the user to tab between multiple inputs on the page
-    // or when having two day pickers side by side. Tabbing from one day picker input to the other will
-    // open and close the dropdown respectively and achieving the same usability as the old DatePicker.
-    // useEffect(() => {
-    //     if (isDropdownOpen && outsideRef.current) {
-    //         // get all buttons to disable the tab on them
-    //         const tabbableElements = (outsideRef.current as HTMLElement).querySelectorAll<HTMLElement>(
-    //             'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
-    //         );
-    //         tabbableElements.forEach((element: Element) => {
-    //             element.setAttribute('tabindex', '-1');
-    //         });
-    //     }
-    // }, [isDropdownOpen, outsideRef]);
-    // Close the dropdown when it is open and when the user presses the "escape" key
-    useKey('Escape', event => {
-        const target = event.target;
-        const isInput = inputRef.current && inputRef.current === target;
-        if (isInput && isDropdownOpen) {
-            closePopper();
+      ),
+      !B && /* @__PURE__ */ i(
+        "input",
+        {
+          id: o,
+          size: 12,
+          type: "text",
+          autoComplete: "off",
+          placeholder: O,
+          ...s,
+          value: W,
+          onChange: fe,
+          onClick: P,
+          onBlur: J,
+          onFocus: Q,
+          onKeyDown: X,
+          ref: g,
+          readOnly: !c,
+          className: Re("ClearableInput form-control bg-white", G)
         }
-    });
-    useEffect(() => {
-        const handleKeyDown = (event) => {
-            if (!isDropdownOpen || !outsideRef.current) {
-                return;
+      )
+    ] }) }),
+    l && /* @__PURE__ */ i(
+      "div",
+      {
+        style: Me,
+        className: "DayPickerPopover z-index-max bg-white shadow-default rounded margin-y-3 border",
+        ...he,
+        ref: ve,
+        role: "dialog",
+        "aria-label": "DayPicker calendar",
+        children: /* @__PURE__ */ k("div", { ref: R, className: "display-flex flex-column justify-content-between", children: [
+          /* @__PURE__ */ i(
+            ie,
+            {
+              ...z,
+              mode: M,
+              defaultMonth: K,
+              locale: H,
+              onSelect: _,
+              captionLayout: "dropdown",
+              animate: !0,
+              navLayout: "around",
+              startMonth: V,
+              endMonth: A,
+              showOutsideDays: F,
+              fixedWeeks: T,
+              className: oe
             }
-            if (event.key === 'Tab') {
-                const focusedInside = outsideRef.current.contains(document.activeElement);
-                if (focusedInside) {
-                    keyboardRef.current = true;
-                    console.log('User tabbed into dropdown');
-                    // Optional: closePopper(); or focus inputRef.current
-                }
-            }
-        };
-        document.addEventListener('keydown', handleKeyDown);
-        return () => {
-            document.removeEventListener('keydown', handleKeyDown);
-        };
-    }, [isDropdownOpen]);
-    const dayPickerClassName = `DayPicker ${bsSize === 'sm' ? 'margin-10' : 'margin-15'} ${bsSize}`;
-    if (inline) {
-        // Render day picker inline without a dropdown and an input
-        return (_jsxs("div", { className: `display-flex flex-column justify-content-between ${className}`, children: [_jsx(ReactDayPicker, { ...selectionProps, mode: mode, defaultMonth: defaultMonth, locale: resolvedLocale, onSelect: handleDaySelect, captionLayout: 'dropdown', animate: true, navLayout: 'around', startMonth: startMonth, endMonth: endMonth, showOutsideDays: showOutsideDays, fixedWeeks: fixedWeeks, className: dayPickerClassName }), footer ? _jsx("div", { className: 'padding-15', children: footer }) : _jsx("div", {})] }));
-    }
-    const clearableInputProps = {
-        ...inputProps,
-        readOnly: !isSingleMode,
-        style: {
-            background: 'var(--color-white)',
-            ...(inputProps?.style ?? {}),
-        },
-    };
-    return (_jsxs(_Fragment, { children: [_jsx("div", { ref: popperRef, className: `form-group ${className}`, children: _jsxs("div", { className: 'input-group', children: [_jsx("span", { className: 'input-group-addon', onClick: handleInputClick, children: _jsx("span", { className: 'rioglyph rioglyph-calendar', "aria-hidden": 'true' }) }), isClearable && (_jsx(ClearableInput, { id: id, autoComplete: 'off', placeholder: placeholder, ...clearableInputProps, type: 'text', value: inputValue, onChange: handleInputChange, onClick: handleInputClick, onClear: handleClearSelection, onBlur: handleInputBlur, onFocus: handleOnInputFocus, onKeyPress: handleInputKeyPress, 
-                            // hasError={hasError}
-                            ref: inputRef, inputClassName: inputClassName })), !isClearable && (_jsx("input", { id: id, size: 12, type: 'text', autoComplete: 'off', placeholder: placeholder, ...inputProps, value: inputValue, onChange: handleInputChangeNative, onClick: handleInputClick, onBlur: handleInputBlur, onFocus: handleOnInputFocus, onKeyDown: handleInputKeyPress, ref: inputRef, readOnly: !isSingleMode, className: classNames('ClearableInput form-control bg-white', inputClassName) }))] }) }), isDropdownOpen && (_jsx("div", { style: popperStyles, className: 'DayPickerPopover z-index-max bg-white shadow-default rounded margin-y-3 border', ...popperAttributes, ref: assignPopperElement, role: 'dialog', "aria-label": 'DayPicker calendar', children: _jsxs("div", { ref: outsideRef, className: 'display-flex flex-column justify-content-between', children: [_jsx(ReactDayPicker, { ...selectionProps, mode: mode, defaultMonth: defaultMonth, locale: resolvedLocale, onSelect: handleDaySelect, captionLayout: 'dropdown', animate: true, navLayout: 'around', startMonth: startMonth, endMonth: endMonth, showOutsideDays: showOutsideDays, fixedWeeks: fixedWeeks, className: dayPickerClassName }), footer ? _jsx("div", { className: 'padding-15', children: footer }) : _jsx("div", {})] }) }))] }));
-};
-const isDateRange = (value) => {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const range = value;
-    const fromIsValid = range.from === undefined || range.from instanceof Date;
-    const toIsValid = range.to === undefined || range.to instanceof Date;
-    return fromIsValid && toIsValid;
-};
-const resolveLocale = (localeCode) => {
-    const baseCode = localeCode.split('-')[0]; // 'de-DE' → 'de'
-    return (locales[baseCode] || locales[localeCode] || locales.enGB);
+          ),
+          S ? /* @__PURE__ */ i("div", { className: "padding-15", children: S }) : /* @__PURE__ */ i("div", {})
+        ] })
+      }
+    )
+  ] });
+}, Fe = (e) => {
+  if (!e || typeof e != "object")
+    return !1;
+  const o = e, r = o.from === void 0 || o.from instanceof Date, s = o.to === void 0 || o.to instanceof Date;
+  return r && s;
+}, Te = (e) => {
+  const o = e.split("-")[0];
+  return E[o] || E[e] || E.enGB;
+}, x = (e, o, r) => e ? r ? se(e, r) : new Intl.DateTimeFormat(o).format(e) : "", Oe = (e, o, r, s) => {
+  if (!e)
+    return "";
+  const u = (f) => s ? se(f, s) : new Intl.DateTimeFormat(o).format(f);
+  if (r === "single" && e instanceof Date)
+    return u(e);
+  if (r === "multiple" && Array.isArray(e))
+    return e.map(u).join(", ");
+  if (r === "range" && typeof e == "object" && "from" in e) {
+    const { from: f, to: a } = e;
+    return !f || !a ? "" : [f, a].filter(Boolean).map(u).join(" – ");
+  }
+  return "";
+}, Be = {
+  "bg-BG": "dd.MM.yyyy",
+  "cs-CZ": "dd.MM.yyyy",
+  "da-DK": "dd-MM-yyyy",
+  "de-DE": "dd.MM.yyyy",
+  "el-GR": "dd/MM/yyyy",
+  "en-GB": "dd/MM/yyyy",
+  "es-ES": "dd/MM/yyyy",
+  "et-EE": "dd.MM.yyyy",
+  "fi-FI": "dd.MM.yyyy",
+  "fr-FR": "dd/MM/yyyy",
+  "hr-HR": "dd.MM.yyyy",
+  "hu-HU": "yyyy. MM. dd.",
+  "it-IT": "dd/MM/yyyy",
+  "lt-LT": "dd-MM-yyyy",
+  "lv-LV": "dd.MM.yyyy",
+  "nb-NO": "dd.MM.yyyy",
+  "nl-NL": "dd-MM-yyyy",
+  "pl-PL": "dd.MM.yyyy",
+  "pt-BR": "dd/MM/yyyy",
+  "pt-PT": "dd/MM/yyyy",
+  "ro-RO": "dd.MM.yyyy",
+  "sk-SK": "dd.MM.yyyy",
+  "sl-SI": "dd.MM.yyyy",
+  "sv-SE": "yyyy-MM-dd"
+}, je = (e, o = "yyyy-MM-dd") => Be[e] || o, L = (e, o, r) => {
+  if (!e)
+    return;
+  const s = r || je(o, r), u = be(e, s, /* @__PURE__ */ new Date());
+  return ce(u) ? u : void 0;
 };
-const formatDate = (date, localeCode, dateFormat) => {
-    if (!date) {
-        return '';
-    }
-    if (dateFormat) {
-        return format(date, dateFormat); // use override
-    }
-    // fallback to locale-based formatting
-    return new Intl.DateTimeFormat(localeCode).format(date);
-};
-const formatSelectedForInput = (selected, localeCode, mode, dateFormat) => {
-    if (!selected) {
-        return '';
-    }
-    const formatFn = (date) => dateFormat ? format(date, dateFormat) : new Intl.DateTimeFormat(localeCode).format(date);
-    if (mode === 'single' && selected instanceof Date) {
-        return formatFn(selected);
-    }
-    if (mode === 'multiple' && Array.isArray(selected)) {
-        return selected.map(formatFn).join(', ');
-    }
-    if (mode === 'range' && typeof selected === 'object' && 'from' in selected) {
-        const { from, to } = selected;
-        if (!from || !to) {
-            return '';
-        }
-        return [from, to].filter(Boolean).map(formatFn).join(' – ');
-    }
-    return '';
-};
-const localeFormatMap = {
-    'bg-BG': 'dd.MM.yyyy',
-    'cs-CZ': 'dd.MM.yyyy',
-    'da-DK': 'dd-MM-yyyy',
-    'de-DE': 'dd.MM.yyyy',
-    'el-GR': 'dd/MM/yyyy',
-    'en-GB': 'dd/MM/yyyy',
-    'es-ES': 'dd/MM/yyyy',
-    'et-EE': 'dd.MM.yyyy',
-    'fi-FI': 'dd.MM.yyyy',
-    'fr-FR': 'dd/MM/yyyy',
-    'hr-HR': 'dd.MM.yyyy',
-    'hu-HU': 'yyyy. MM. dd.',
-    'it-IT': 'dd/MM/yyyy',
-    'lt-LT': 'dd-MM-yyyy',
-    'lv-LV': 'dd.MM.yyyy',
-    'nb-NO': 'dd.MM.yyyy',
-    'nl-NL': 'dd-MM-yyyy',
-    'pl-PL': 'dd.MM.yyyy',
-    'pt-BR': 'dd/MM/yyyy',
-    'pt-PT': 'dd/MM/yyyy',
-    'ro-RO': 'dd.MM.yyyy',
-    'sk-SK': 'dd.MM.yyyy',
-    'sl-SI': 'dd.MM.yyyy',
-    'sv-SE': 'yyyy-MM-dd',
-};
-const getFormatForLocale = (localeCode, fallback = 'yyyy-MM-dd') => {
-    return localeFormatMap[localeCode] || fallback;
-};
-const parseDateString = (value, localeCode, dateFormat) => {
-    if (!value) {
-        return undefined;
-    }
-    const formatToUse = dateFormat || getFormatForLocale(localeCode, dateFormat);
-    const parsed = parse(value, formatToUse, new Date());
-    return isValid(parsed) ? parsed : undefined;
+export {
+  Je as default
 };
-export default DayPicker;
+//# sourceMappingURL=DayPicker.js.map