@cwellt_software/cwellt-reactjs-lib 1.4.10 → 1.4.12

package/dist/index.cjs.js

@@ -5037,6 +5037,265 @@ function CwSearchInput(optionsProps) {
     return (jsxRuntime.jsxs("div", { className: `cw-search-input ${className || ""}`, style: style, id: id, ...otherProps, "data-direction": direction, children: [jsxRuntime.jsxs(CwAlign, { ...alignProps, children: [labelProps && (jsxRuntime.jsx(CwLabel, { ...labelProps, children: labelProps.text })), jsxRuntime.jsxs("div", { className: "cw-search-input-wrapper", ref: wrapperRef, children: [jsxRuntime.jsx("input", { type: "text", value: searchText, onChange: handleInputChange, onFocus: handleInputFocus, onBlur: handleInputBlur, placeholder: placeholder, className: "cw-input-search", disabled: disabled }), isLoading && (jsxRuntime.jsx("div", { className: "cw-search-input-loading", children: jsxRuntime.jsx(CwIcon, { iconId: "spinner" }) })), jsxRuntime.jsx("div", { className: "cw-search-input-icons", children: searchText && !disabled && !isLoading ? (jsxRuntime.jsx(CwButton, { type: "button", onClick: handleClearClick, "aria-label": "Clear search", variant: "icon", icon: "close", color: "neutral" })) : (iconProps ? jsxRuntime.jsx(CwIcon, { ...iconProps }) : jsxRuntime.jsx(CwIcon, { iconId: "search" })) })] })] }), renderPanel(jsxRuntime.jsx("div", { ref: panelRef, className: dropdownStyles.dropdown, style: panelStyle, children: jsxRuntime.jsx("ul", { children: filteredOptions.map((option) => (jsxRuntime.jsx("li", { className: dropdownStyles.option, onClick: () => handleOptionSelect(option), onMouseDown: (e) => e.preventDefault(), children: renderOption ? renderOption(option) : option.description }, option.id))) }) }))] }));
 }
 
+/**
+ * Generic API-backed search input. Fetches matching options from a caller-supplied `onSearch`
+ * callback as the user types (debounced), renders them in a portal-based dropdown with keyboard
+ * navigation, and commits the selected id via `onChange`.
+ *
+ * All domain logic — API URLs, auth/config, display formatting, provider/secondary lookups — lives
+ * in the caller's callbacks, so this component stays application-agnostic. It is the base for thin
+ * wrappers such as `FindAirport` / `FindCrewmember`.
+ *
+ * Improvements over the legacy `CwFindAirport` / `CwFindCrewmember`: an `AbortController` cancels
+ * superseded in-flight requests (fixes out-of-order results), and `minChars` / `debounceMs` are
+ * configurable.
+ *
+ * @example
+ * <CwSearchAsync
+ *   onSearch={(text, signal) => repo.search(text, signal)}
+ *   onChange={(id) => setSelectedId(id)}
+ *   labelProps={{ text: 'Airport' }}
+ *   icon={{ iconId: 'control-tower' }}
+ * />
+ */
+const CwSearchAsync = ({ onSearch, onChange, value, onResolveInitial, onResolveSelection, icon, placeholder = "Search…", minChars = 2, debounceMs = 300, disabled = false, required = false, initialDisplayText, searchTrigger, labelProps, alignProps, width, className = "", }) => {
+    // State
+    const [inputValue, setInputValue] = React.useState("");
+    const [options, setOptions] = React.useState([]);
+    const [isLoading, setIsLoading] = React.useState(false);
+    const [isInitialLoading, setIsInitialLoading] = React.useState(false);
+    const [showDropdown, setShowDropdown] = React.useState(false);
+    const [highlightedIndex, setHighlightedIndex] = React.useState(-1);
+    const [tooltipText, setTooltipText] = React.useState("");
+    // Refs
+    const inputRef = React.useRef(null);
+    const wrapperRef = React.useRef(null);
+    const debounceRef = React.useRef();
+    const abortRef = React.useRef(null);
+    const lastQueryRef = React.useRef("");
+    const didMountRef = React.useRef(false);
+    const lastResolvedValueRef = React.useRef(undefined);
+    const initialResolveAbortRef = React.useRef(null);
+    // Stable ids wiring the combobox input to its listbox popup for assistive tech.
+    const listboxId = React.useId();
+    const optionId = (index) => `${listboxId}-opt-${index}`;
+    // Cancel a pending initial-value resolve when the user takes over (typing / clearing / reset),
+    // so a slow resolve can't overwrite newer input and the loading flag never sticks.
+    const cancelInitialResolve = React.useCallback(() => {
+        initialResolveAbortRef.current?.abort();
+        initialResolveAbortRef.current = null;
+        setIsInitialLoading(false);
+    }, []);
+    const { panelRef, panelStyle, renderPanel } = useDropdownPortal({
+        anchorRef: wrapperRef,
+        isOpen: showDropdown && options.length > 0,
+        onClose: () => { setShowDropdown(false); setHighlightedIndex(-1); },
+    });
+    // Core search runner — aborts superseded requests and drops stale responses.
+    const runSearch = React.useCallback(async (text) => {
+        abortRef.current?.abort();
+        if (text.length < minChars) {
+            setOptions([]);
+            setShowDropdown(false);
+            setHighlightedIndex(-1);
+            return;
+        }
+        const controller = new AbortController();
+        abortRef.current = controller;
+        lastQueryRef.current = text;
+        setIsLoading(true);
+        try {
+            const results = await onSearch(text, controller.signal);
+            if (controller.signal.aborted)
+                return; // superseded → drop
+            setOptions(results);
+            setShowDropdown(results.length > 0); // empty → close silently (dark cockpit)
+            setHighlightedIndex(-1);
+        }
+        catch (error) {
+            if (controller.signal.aborted)
+                return; // aborts reject with AbortError → ignore
+            console.error("CwSearchAsync onSearch failed:", error);
+            setOptions([]);
+            setShowDropdown(false);
+        }
+        finally {
+            if (abortRef.current === controller) {
+                setIsLoading(false);
+                abortRef.current = null;
+            }
+        }
+    }, [minChars, onSearch]);
+    // Keep a stable handle to the latest runSearch for the searchTrigger effect.
+    const runSearchRef = React.useRef(runSearch);
+    React.useEffect(() => { runSearchRef.current = runSearch; });
+    const debouncedSearch = React.useCallback((text) => {
+        if (debounceRef.current)
+            window.clearTimeout(debounceRef.current);
+        // Abort eagerly on every keystroke so a fast typist never has two live fetches.
+        abortRef.current?.abort();
+        debounceRef.current = window.setTimeout(() => runSearch(text), debounceMs);
+    }, [runSearch, debounceMs]);
+    const handleInputChange = (e) => {
+        const newValue = e.target.value;
+        setInputValue(newValue);
+        if (newValue !== inputValue) {
+            cancelInitialResolve();
+            debouncedSearch(newValue);
+        }
+    };
+    const handleOptionSelect = async (optionId) => {
+        const picked = options.find(o => o.id === optionId);
+        if (!picked)
+            return;
+        setShowDropdown(false);
+        let committed = picked;
+        if (onResolveSelection) {
+            abortRef.current?.abort();
+            const controller = new AbortController();
+            abortRef.current = controller;
+            try {
+                const resolved = await onResolveSelection(picked, controller.signal);
+                if (controller.signal.aborted)
+                    return;
+                committed = resolved;
+                setOptions([resolved]);
+            }
+            catch (error) {
+                if (controller.signal.aborted)
+                    return;
+                console.error("CwSearchAsync onResolveSelection failed:", error);
+                return; // abort the commit, mirroring the legacy provider-airport behaviour
+            }
+            finally {
+                if (abortRef.current === controller)
+                    abortRef.current = null;
+            }
+        }
+        setInputValue(committed.inputLabel ?? committed.label);
+        setTooltipText(committed.label);
+        onChange(committed.id);
+    };
+    const handleKeyDown = (e) => {
+        if (!showDropdown || options.length === 0)
+            return;
+        switch (e.key) {
+            case "ArrowDown":
+                e.preventDefault();
+                setHighlightedIndex(prev => (prev < options.length - 1 ? prev + 1 : 0));
+                break;
+            case "ArrowUp":
+                e.preventDefault();
+                setHighlightedIndex(prev => (prev > 0 ? prev - 1 : options.length - 1));
+                break;
+            case "Enter":
+                e.preventDefault();
+                if (highlightedIndex >= 0 && highlightedIndex < options.length) {
+                    handleOptionSelect(options[highlightedIndex].id);
+                }
+                break;
+            case "Escape":
+                setShowDropdown(false);
+                setHighlightedIndex(-1);
+                break;
+        }
+    };
+    const handleInputFocus = () => {
+        if (options.length > 0)
+            setShowDropdown(true);
+    };
+    const handleClear = () => {
+        if (debounceRef.current)
+            window.clearTimeout(debounceRef.current);
+        abortRef.current?.abort();
+        cancelInitialResolve();
+        setInputValue("");
+        setTooltipText("");
+        setOptions([]);
+        setShowDropdown(false);
+        lastQueryRef.current = "";
+        onChange(null);
+        inputRef.current?.focus();
+    };
+    // Resolve a preselected value to display text.
+    React.useEffect(() => {
+        if (value == null)
+            return;
+        if (initialDisplayText) {
+            setInputValue(initialDisplayText);
+            setTooltipText(initialDisplayText);
+            lastResolvedValueRef.current = value;
+            return;
+        }
+        if (!onResolveInitial)
+            return;
+        if (lastResolvedValueRef.current === value)
+            return; // already resolved this value
+        const controller = new AbortController();
+        initialResolveAbortRef.current = controller;
+        setIsInitialLoading(true);
+        onResolveInitial(value, controller.signal)
+            .then(opt => {
+            if (controller.signal.aborted)
+                return;
+            lastResolvedValueRef.current = value; // mark resolved only on success
+            setOptions([opt]);
+            setInputValue(opt.inputLabel ?? opt.label);
+            setTooltipText(opt.label);
+        })
+            .catch(error => {
+            if (!controller.signal.aborted)
+                console.error("CwSearchAsync onResolveInitial failed:", error);
+        })
+            .finally(() => {
+            // Clear the spinner only if this resolve is still the current one (not superseded/cancelled).
+            if (initialResolveAbortRef.current === controller) {
+                setIsInitialLoading(false);
+                initialResolveAbortRef.current = null;
+            }
+        });
+        return () => controller.abort();
+    }, [value, initialDisplayText, onResolveInitial]);
+    // Reset when the controlled value is cleared by the parent.
+    React.useEffect(() => {
+        if (value == null) {
+            if (debounceRef.current)
+                window.clearTimeout(debounceRef.current);
+            abortRef.current?.abort();
+            cancelInitialResolve();
+            setInputValue("");
+            setTooltipText("");
+            setOptions([]);
+            setShowDropdown(false);
+            setHighlightedIndex(-1);
+            lastQueryRef.current = "";
+            lastResolvedValueRef.current = undefined;
+        }
+    }, [value, cancelInitialResolve]);
+    // Re-run the last query when searchTrigger changes (skip first mount).
+    React.useEffect(() => {
+        if (!didMountRef.current) {
+            didMountRef.current = true;
+            return;
+        }
+        if (searchTrigger === undefined)
+            return;
+        if (lastQueryRef.current)
+            runSearchRef.current(lastQueryRef.current);
+    }, [searchTrigger]);
+    // Cleanup on unmount.
+    React.useEffect(() => () => {
+        if (debounceRef.current)
+            window.clearTimeout(debounceRef.current);
+        abortRef.current?.abort();
+    }, []);
+    const direction = alignProps?.flexDirection || "row";
+    return (jsxRuntime.jsxs("div", { className: `cw-search-input ${className}`, style: {
+            ...(width ? { width } : {}),
+            ...(labelProps?.labelWidth ? { "--label-width": labelProps.labelWidth } : {}),
+        }, "data-direction": direction, children: [jsxRuntime.jsxs(CwAlign, { ...alignProps, itemProp: required ? "required" : "", children: [labelProps && (jsxRuntime.jsx(CwLabel, { ...labelProps, children: labelProps.text })), jsxRuntime.jsxs("div", { className: "cw-search-input-wrapper", ref: wrapperRef, children: [jsxRuntime.jsx("input", { ref: inputRef, type: "text", value: inputValue, onChange: handleInputChange, onKeyDown: handleKeyDown, onFocus: handleInputFocus, placeholder: isInitialLoading ? "Loading…" : placeholder, disabled: disabled, required: required, autoComplete: "off", role: "combobox", "aria-haspopup": "listbox", "aria-expanded": showDropdown, "aria-controls": listboxId, "aria-activedescendant": highlightedIndex >= 0 ? optionId(highlightedIndex) : undefined, title: tooltipText }), (isLoading || isInitialLoading) && (jsxRuntime.jsx("div", { className: "cw-search-input-loading", children: jsxRuntime.jsx(CwIcon, { iconId: "spinner" }) })), jsxRuntime.jsx("div", { className: "cw-search-input-icons", children: inputValue && !disabled && !isInitialLoading ? (jsxRuntime.jsx(CwButton, { type: "button", onClick: handleClear, "aria-label": "Clear selection", variant: "icon", icon: "close", color: "neutral" })) : (icon ? jsxRuntime.jsx(CwIcon, { ...icon }) : jsxRuntime.jsx(CwIcon, { iconId: "search" })) })] })] }), renderPanel(jsxRuntime.jsx("div", { ref: panelRef, id: listboxId, className: dropdownStyles.dropdown, style: panelStyle, role: "listbox", children: jsxRuntime.jsx("ul", { children: options.map((option, index) => (jsxRuntime.jsx("li", { id: optionId(index), className: `${dropdownStyles.option}${index === highlightedIndex ? ` ${dropdownStyles.optionFocused}` : ""}`, onClick: () => handleOptionSelect(option.id), onMouseDown: (e) => e.preventDefault(), onMouseEnter: () => setHighlightedIndex(index), role: "option", "aria-selected": index === highlightedIndex, children: option.subLabel ? (jsxRuntime.jsxs("span", { className: "cw-search-async-option-lines", children: [jsxRuntime.jsx("span", { children: option.label }), jsxRuntime.jsx("span", { className: "cw-search-async-option-sub", children: option.subLabel })] })) : (option.label) }, option.id))) }) }))] }));
+};
+
 var styles$5 = {"menu":"cw-context-menu-module__menu__tXmun","item":"cw-context-menu-module__item__-ko8L","arrow":"cw-context-menu-module__arrow__LHZmQ"};
 
 const ARROW_SIZE = 8;
@@ -7003,7 +7262,7 @@ function formatPlainDate(pd, fmt) {
         .replace("dd", String(pd.day).padStart(2, "0"));
 }
 
-function CwDatePickerTemporal({ value, onChange, minDate, maxDate, disabledDates, disabledMatcher, defaultMonth, labelProps, alignProps, placeholder = "Select a date", displayFormat = "dd.MM.yyyy", disabled, required, className, showClear = true, popupPosition = "left-bottom", numberOfMonths = 1, showTodayButton = false, todayLabel = "Today", feedback, }) {
+function CwDatePickerTemporal({ value, onChange, minDate, maxDate, disabledDates, disabledMatcher, defaultMonth, labelProps, alignProps, placeholder = "Select a date", displayFormat = "dd.MM.yyyy", disabled, required, className, showClear = true, popupPosition = "left-bottom", numberOfMonths = 1, showTodayButton = false, locale: locale$1 = locale.enGB, todayLabel = "Today", yearRangeStart, yearRangeEnd, feedback, }) {
     const [isOpen, setIsOpen] = React.useState(false);
     const [inputValue, setInputValue] = React.useState();
     const containerRef = React.useRef(null);
@@ -7092,6 +7351,19 @@ function CwDatePickerTemporal({ value, onChange, minDate, maxDate, disabledDates
             setIsOpen(false);
         }
     }, [minDate, maxDate, onChange]);
+    // Derive start/end months for the year dropdown range, guarding against inverted yearRange props
+    const dropdownStartMonth = React.useMemo(() => {
+        const inferredStart = minDate ? minDate.year : Temporal.Now.plainDateISO().year - 10;
+        const inferredEnd = yearRangeEnd ?? (maxDate ? maxDate.year : Temporal.Now.plainDateISO().year + 5);
+        const year = Math.min(yearRangeStart ?? inferredStart, inferredEnd);
+        return new Date(year, 0, 1);
+    }, [yearRangeStart, yearRangeEnd, minDate, maxDate]);
+    const dropdownEndMonth = React.useMemo(() => {
+        const inferredEnd = maxDate ? maxDate.year : Temporal.Now.plainDateISO().year + 5;
+        const inferredStart = yearRangeStart ?? (minDate ? minDate.year : Temporal.Now.plainDateISO().year - 10);
+        const year = Math.max(yearRangeEnd ?? inferredEnd, inferredStart);
+        return new Date(year, 11, 31);
+    }, [yearRangeStart, yearRangeEnd, minDate, maxDate]);
     // Memoize disabled days (convert PlainDate[] to Date[] for DayPicker)
     const disabledDays = React.useMemo(() => [
         ...(disabledDates?.map(plainDateToJsDate) || []),
@@ -7103,13 +7375,463 @@ function CwDatePickerTemporal({ value, onChange, minDate, maxDate, disabledDates
     const defaultMonthJsDate = defaultMonth
         ? new Date(defaultMonth.year, defaultMonth.month - 1, 1)
         : selectedJsDate;
-    return (jsxRuntime.jsxs("div", { ref: containerRef, className: `cw-datepicker ${className || ""}`, children: [jsxRuntime.jsxs(CwAlign, { ...alignProps, itemProp: required ? "required" : "", children: [labelProps && (jsxRuntime.jsx(CwLabel, { ...labelProps, children: labelProps.text })), jsxRuntime.jsxs("div", { ref: wrapperRef, className: styles$4.pickerWrapper, children: [jsxRuntime.jsx("input", { ref: inputRef, type: "text", value: inputValue, placeholder: placeholder, onChange: handleInputChange, onBlur: handleInputBlur, onClick: handleInputClick, onKeyDown: handleInputKeyDown, disabled: disabled, required: required }), jsxRuntime.jsx("div", { className: styles$4.pickerIcons, children: showClear && value && !disabled ? (jsxRuntime.jsx(CwButton, { type: "button", variant: "icon", color: "neutral", icon: "close", onClick: handleClear, tabIndex: -1, "aria-label": "Clear date" })) : (jsxRuntime.jsx(CwIcon, { iconId: "calendar" })) }), renderPopup(jsxRuntime.jsxs("div", { ref: popupRef, className: styles$4.pickerPopup, style: popupStyle, children: [jsxRuntime.jsx(reactDayPicker.DayPicker, { mode: "single", selected: selectedJsDate, defaultMonth: defaultMonthJsDate, onSelect: handleDaySelect, disabled: disabledDays, numberOfMonths: numberOfMonths, modifiers: {
+    return (jsxRuntime.jsxs("div", { ref: containerRef, className: `cw-datepicker ${className || ""}`, children: [jsxRuntime.jsxs(CwAlign, { ...alignProps, itemProp: required ? "required" : "", children: [labelProps && (jsxRuntime.jsx(CwLabel, { ...labelProps, children: labelProps.text })), jsxRuntime.jsxs("div", { ref: wrapperRef, className: styles$4.pickerWrapper, children: [jsxRuntime.jsx("input", { ref: inputRef, type: "text", value: inputValue, placeholder: placeholder, onChange: handleInputChange, onBlur: handleInputBlur, onClick: handleInputClick, onKeyDown: handleInputKeyDown, disabled: disabled, required: required }), jsxRuntime.jsx("div", { className: styles$4.pickerIcons, children: showClear && value && !disabled ? (jsxRuntime.jsx(CwButton, { type: "button", variant: "icon", color: "neutral", icon: "close", onClick: handleClear, tabIndex: -1, "aria-label": "Clear date" })) : (jsxRuntime.jsx(CwIcon, { iconId: "calendar" })) }), renderPopup(jsxRuntime.jsxs("div", { ref: popupRef, className: styles$4.pickerPopup, style: popupStyle, children: [jsxRuntime.jsx(reactDayPicker.DayPicker, { mode: "single", selected: selectedJsDate, defaultMonth: defaultMonthJsDate, onSelect: handleDaySelect, disabled: disabledDays, numberOfMonths: numberOfMonths, locale: locale$1, captionLayout: "dropdown", startMonth: dropdownStartMonth, endMonth: dropdownEndMonth, modifiers: {
                                             today: new Date(),
                                         }, modifiersClassNames: {
                                             today: "rdp-day-today",
                                         } }), showTodayButton && (jsxRuntime.jsx("footer", { className: "cw-flex-row cw-align-right-center", children: jsxRuntime.jsx(CwButton, { type: "button", variant: "outline", onClick: handleTodayClick, text: todayLabel }) }))] }))] })] }), feedbackMessages.map((feedbackItem, index) => (jsxRuntime.jsx("p", { className: "cw-input-info", "data-color": feedbackItem.type, children: feedbackItem.message }, index)))] }));
 }
 
+// dateRangePresetsTemporal.ts
+// Temporal-typed counterpart of dateRangePresets.ts (used by CwDateRangePickerTemporal).
+// Each preset is evaluated at click time; a reference date can be injected for testing.
+const ref = (today) => today ?? Temporal.Now.plainDateISO();
+/** Monday as first day of the week (ISO dayOfWeek: 1 = Mon … 7 = Sun). */
+const startOfWeek = (d) => d.subtract({ days: d.dayOfWeek - 1 });
+const startOfMonth = (d) => d.with({ day: 1 });
+const endOfMonth = (d) => d.with({ day: d.daysInMonth });
+/** First day of the quarter that contains `d`. */
+const startOfQuarter = (d) => Temporal.PlainDate.from({ year: d.year, month: Math.floor((d.month - 1) / 3) * 3 + 1, day: 1 });
+const PRESET_LIBRARY_TEMPORAL = {
+    // === PAST DAYS ===
+    today: {
+        key: "today",
+        label: "Today",
+        getValue: (t) => { const d = ref(t); return { from: d, to: d }; },
+    },
+    yesterday: {
+        key: "yesterday",
+        label: "Yesterday",
+        getValue: (t) => { const d = ref(t).subtract({ days: 1 }); return { from: d, to: d }; },
+    },
+    past2Days: {
+        key: "past2Days",
+        label: "Past 2 Days",
+        getValue: (t) => { const d = ref(t); return { from: d.subtract({ days: 2 }), to: d }; },
+    },
+    past3Days: {
+        key: "past3Days",
+        label: "Past 3 Days",
+        getValue: (t) => { const d = ref(t); return { from: d.subtract({ days: 3 }), to: d }; },
+    },
+    past7Days: {
+        key: "past7Days",
+        label: "Past 7 days",
+        getValue: (t) => { const d = ref(t); return { from: d.subtract({ days: 7 }), to: d }; },
+    },
+    past14Days: {
+        key: "past14Days",
+        label: "Past 14 days",
+        getValue: (t) => { const d = ref(t); return { from: d.subtract({ days: 14 }), to: d }; },
+    },
+    past30Days: {
+        key: "past30Days",
+        label: "Past 30 days",
+        getValue: (t) => { const d = ref(t); return { from: d.subtract({ days: 30 }), to: d }; },
+    },
+    past90Days: {
+        key: "past90Days",
+        label: "Past 90 days",
+        getValue: (t) => { const d = ref(t); return { from: d.subtract({ days: 90 }), to: d }; },
+    },
+    // === NEXT DAYS ===
+    next7Days: {
+        key: "next7Days",
+        label: "Next 7 days",
+        getValue: (t) => { const d = ref(t); return { from: d, to: d.add({ days: 7 }) }; },
+    },
+    next14Days: {
+        key: "next14Days",
+        label: "Next 14 days",
+        getValue: (t) => { const d = ref(t); return { from: d, to: d.add({ days: 14 }) }; },
+    },
+    next30Days: {
+        key: "next30Days",
+        label: "Next 30 days",
+        getValue: (t) => { const d = ref(t); return { from: d, to: d.add({ days: 30 }) }; },
+    },
+    // === WEEKS (Monday-first) ===
+    thisWeek: {
+        key: "thisWeek",
+        label: "This week",
+        getValue: (t) => { const s = startOfWeek(ref(t)); return { from: s, to: s.add({ days: 6 }) }; },
+    },
+    lastWeek: {
+        key: "lastWeek",
+        label: "Last week",
+        getValue: (t) => { const end = startOfWeek(ref(t)).subtract({ days: 1 }); return { from: end.subtract({ days: 6 }), to: end }; },
+    },
+    nextWeek: {
+        key: "nextWeek",
+        label: "Next week",
+        getValue: (t) => { const s = startOfWeek(ref(t)).add({ days: 7 }); return { from: s, to: s.add({ days: 6 }) }; },
+    },
+    // === MONTHS ===
+    thisMonth: {
+        key: "thisMonth",
+        label: "This month",
+        getValue: (t) => { const d = ref(t); return { from: startOfMonth(d), to: endOfMonth(d) }; },
+    },
+    lastMonth: {
+        key: "lastMonth",
+        label: "Last month",
+        getValue: (t) => { const d = startOfMonth(ref(t)).subtract({ months: 1 }); return { from: d, to: endOfMonth(d) }; },
+    },
+    nextMonth: {
+        key: "nextMonth",
+        label: "Next month",
+        getValue: (t) => { const d = startOfMonth(ref(t)).add({ months: 1 }); return { from: d, to: endOfMonth(d) }; },
+    },
+    // === QUARTERS ===
+    thisQuarter: {
+        key: "thisQuarter",
+        label: "This quarter",
+        getValue: (t) => { const from = startOfQuarter(ref(t)); return { from, to: from.add({ months: 3 }).subtract({ days: 1 }) }; },
+    },
+    lastQuarter: {
+        key: "lastQuarter",
+        label: "Last quarter",
+        getValue: (t) => { const from = startOfQuarter(ref(t)).subtract({ months: 3 }); return { from, to: from.add({ months: 3 }).subtract({ days: 1 }) }; },
+    },
+    nextQuarter: {
+        key: "nextQuarter",
+        label: "Next quarter",
+        getValue: (t) => { const from = startOfQuarter(ref(t)).add({ months: 3 }); return { from, to: from.add({ months: 3 }).subtract({ days: 1 }) }; },
+    },
+    // === YEAR ===
+    thisYear: {
+        key: "thisYear",
+        label: "This year",
+        getValue: (t) => {
+            const y = ref(t).year;
+            return { from: Temporal.PlainDate.from({ year: y, month: 1, day: 1 }), to: Temporal.PlainDate.from({ year: y, month: 12, day: 31 }) };
+        },
+    },
+    lastYear: {
+        key: "lastYear",
+        label: "Last year",
+        getValue: (t) => {
+            const y = ref(t).year - 1;
+            return { from: Temporal.PlainDate.from({ year: y, month: 1, day: 1 }), to: Temporal.PlainDate.from({ year: y, month: 12, day: 31 }) };
+        },
+    },
+};
+/**
+ * Helper to get presets by their keys.
+ * @example getPresetsByKeysTemporal(['thisWeek', 'past7Days', 'past30Days'])
+ */
+const getPresetsByKeysTemporal = (keys) => keys.map((key) => PRESET_LIBRARY_TEMPORAL[key]).filter((preset) => preset !== undefined);
+
+function CwDateRangePickerTemporal({ value, onChange, minDate, maxDate, disabledDates, disabledMatcher, maxRangeDays, defaultMonth, labelProps, alignProps, placeholderFrom = "From date", placeholderTo = "To date", displayFormat = "dd.MM.yyyy", disabled, required, className, showClear = true, popupPosition = "left-bottom", numberOfMonths = 2, locale: locale$1 = locale.enGB, yearRangeStart, yearRangeEnd, showPresets = false, presetKeys, customPresets, }) {
+    const [isOpen, setIsOpen] = React.useState(false);
+    const [inputFromValue, setInputFromValue] = React.useState("");
+    const [inputToValue, setInputToValue] = React.useState("");
+    const [rangeErrorMessage, setRangeErrorMessage] = React.useState(null);
+    const [focusedInput, setFocusedInput] = React.useState();
+    const containerRef = React.useRef(null);
+    const wrapperRef = React.useRef(null);
+    const inputFromRef = React.useRef(null);
+    const inputToRef = React.useRef(null);
+    const prevValueRef = React.useRef(undefined);
+    const prevDisplayFormatRef = React.useRef(displayFormat);
+    const rangeError = React.useCallback(() => (maxRangeDays ? `Range cannot exceed ${maxRangeDays} days` : "Invalid date range"), [maxRangeDays]);
+    const handleClose = React.useCallback(() => {
+        setIsOpen(false);
+        setFocusedInput(undefined);
+    }, []);
+    const { popupRef, popupStyle, renderPopup } = usePickerPopup({
+        anchorRef: wrapperRef,
+        isOpen,
+        onClose: handleClose,
+        position: popupPosition,
+    });
+    // Calculate presets to render
+    const presetsToRender = React.useMemo(() => {
+        let presets = [];
+        if (presetKeys && presetKeys.length > 0) {
+            presets = getPresetsByKeysTemporal(presetKeys);
+        }
+        if (customPresets && customPresets.length > 0) {
+            presets = [...presets, ...customPresets];
+        }
+        return presets;
+    }, [presetKeys, customPresets]);
+    // Validate date range
+    const validateRange = React.useCallback((from, to) => {
+        if (!from || !to)
+            return true; // Partial ranges are OK during selection
+        if (Temporal.PlainDate.compare(from, to) > 0)
+            return false;
+        if (maxRangeDays) {
+            const daysDiff = from.until(to, { largestUnit: "day" }).days;
+            if (daysDiff > maxRangeDays)
+                return false;
+        }
+        return true;
+    }, [maxRangeDays]);
+    // Sync input values with prop value
+    React.useEffect(() => {
+        const currentFrom = value?.from?.toString();
+        const currentTo = value?.to?.toString();
+        const prevFrom = prevValueRef.current?.from;
+        const prevTo = prevValueRef.current?.to;
+        if (currentFrom !== prevFrom ||
+            currentTo !== prevTo ||
+            prevDisplayFormatRef.current !== displayFormat) {
+            prevValueRef.current = { from: currentFrom, to: currentTo };
+            prevDisplayFormatRef.current = displayFormat;
+            setInputFromValue(value?.from ? formatPlainDate(value.from, displayFormat) : "");
+            setInputToValue(value?.to ? formatPlainDate(value.to, displayFormat) : "");
+        }
+    }, [value, displayFormat]);
+    const handleRangeSelect = React.useCallback((range, selectedDay) => {
+        const selected = jsDateToPlainDate(selectedDay);
+        let newRange;
+        if (focusedInput === 'from') {
+            newRange = { from: selected, to: value?.to };
+            if (newRange.to && Temporal.PlainDate.compare(selected, newRange.to) > 0) {
+                newRange.to = undefined;
+                setFocusedInput('to');
+                setRangeErrorMessage(null);
+            }
+            else if (newRange.to) {
+                if (!validateRange(newRange.from, newRange.to)) {
+                    setRangeErrorMessage(rangeError());
+                    return;
+                }
+                setRangeErrorMessage(null);
+                setIsOpen(false);
+                setFocusedInput(undefined);
+            }
+            else {
+                setFocusedInput('to');
+                setRangeErrorMessage(null);
+            }
+        }
+        else if (focusedInput === 'to') {
+            newRange = { from: value?.from, to: selected };
+            if (newRange.from && Temporal.PlainDate.compare(selected, newRange.from) < 0) {
+                newRange.from = undefined;
+                setFocusedInput('from');
+                setRangeErrorMessage(null);
+            }
+            else if (newRange.from) {
+                if (!validateRange(newRange.from, newRange.to)) {
+                    setRangeErrorMessage(rangeError());
+                    return;
+                }
+                setRangeErrorMessage(null);
+                setIsOpen(false);
+                setFocusedInput(undefined);
+            }
+            else {
+                setFocusedInput('from');
+                setRangeErrorMessage(null);
+            }
+        }
+        else {
+            if (!range) {
+                onChange(undefined);
+                return;
+            }
+            newRange = {
+                from: range.from ? jsDateToPlainDate(range.from) : undefined,
+                to: range.to ? jsDateToPlainDate(range.to) : undefined,
+            };
+            if (range.from && range.to) {
+                if (!validateRange(newRange.from, newRange.to)) {
+                    setRangeErrorMessage(rangeError());
+                    return;
+                }
+                setRangeErrorMessage(null);
+                setIsOpen(false);
+                setFocusedInput(undefined);
+            }
+            else if (range.from) {
+                setFocusedInput('to');
+                setRangeErrorMessage(null);
+            }
+            else {
+                setFocusedInput('from');
+                setRangeErrorMessage(null);
+            }
+        }
+        onChange(newRange);
+    }, [onChange, validateRange, value, focusedInput, rangeError]);
+    const handleClearFrom = React.useCallback((e) => {
+        e.stopPropagation();
+        onChange({ from: undefined, to: value?.to });
+        setInputFromValue("");
+    }, [onChange, value]);
+    const handleClearTo = React.useCallback((e) => {
+        e.stopPropagation();
+        onChange({ from: value?.from, to: undefined });
+        setInputToValue("");
+    }, [onChange, value]);
+    const handleInputFromClick = React.useCallback(() => {
+        if (!disabled) {
+            setIsOpen(true);
+            setFocusedInput('from');
+        }
+    }, [disabled]);
+    const handleInputToClick = React.useCallback(() => {
+        if (!disabled) {
+            setIsOpen(true);
+            setFocusedInput('to');
+        }
+    }, [disabled]);
+    const handleInputFromChange = React.useCallback((e) => {
+        const newValue = e.currentTarget.value;
+        setInputFromValue(newValue);
+        const parsed = parseDate(newValue, displayFormat);
+        if (parsed) {
+            if (validate(parsed, minDate, maxDate) && validateRange(parsed, value?.to)) {
+                onChange({ from: parsed, to: value?.to });
+            }
+        }
+        else if (newValue === "") {
+            onChange({ from: undefined, to: value?.to });
+        }
+    }, [displayFormat, minDate, maxDate, validateRange, onChange, value]);
+    const handleInputToChange = React.useCallback((e) => {
+        const newValue = e.currentTarget.value;
+        setInputToValue(newValue);
+        const parsed = parseDate(newValue, displayFormat);
+        if (parsed) {
+            if (validate(parsed, minDate, maxDate) && validateRange(value?.from, parsed)) {
+                onChange({ from: value?.from, to: parsed });
+            }
+        }
+        else if (newValue === "") {
+            onChange({ from: value?.from, to: undefined });
+        }
+    }, [displayFormat, minDate, maxDate, validateRange, onChange, value]);
+    const handleInputBlur = React.useCallback((type) => {
+        const inputValue = type === 'from' ? inputFromValue : inputToValue;
+        const currentValue = type === 'from' ? value?.from : value?.to;
+        const trimmed = inputValue?.trim();
+        if (trimmed) {
+            const parsed = parseDate(trimmed, displayFormat);
+            if (parsed && validate(parsed, minDate, maxDate)) {
+                const newRange = type === 'from'
+                    ? { from: parsed, to: value?.to }
+                    : { from: value?.from, to: parsed };
+                if (validateRange(newRange.from, newRange.to)) {
+                    onChange(newRange);
+                    if (type === 'from') {
+                        setInputFromValue(formatPlainDate(parsed, displayFormat));
+                    }
+                    else {
+                        setInputToValue(formatPlainDate(parsed, displayFormat));
+                    }
+                    return;
+                }
+            }
+        }
+        // Reset to current value if invalid
+        if (type === 'from') {
+            setInputFromValue(currentValue ? formatPlainDate(currentValue, displayFormat) : "");
+        }
+        else {
+            setInputToValue(currentValue ? formatPlainDate(currentValue, displayFormat) : "");
+        }
+    }, [inputFromValue, inputToValue, value, displayFormat, minDate, maxDate, validateRange, onChange]);
+    const handleInputKeyDown = React.useCallback((e, type) => {
+        if (e.key === "Enter") {
+            e.preventDefault();
+            if (type === 'from') {
+                inputFromRef.current?.blur();
+                inputToRef.current?.focus();
+            }
+            else {
+                inputToRef.current?.blur();
+                setIsOpen(false);
+            }
+        }
+        else if (e.key === "Escape") {
+            setIsOpen(false);
+            if (type === 'from') {
+                inputFromRef.current?.blur();
+            }
+            else {
+                inputToRef.current?.blur();
+            }
+        }
+    }, []);
+    // Handle preset click
+    const handlePresetClick = React.useCallback((preset, e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        const nextRange = preset.getValue();
+        if (!validate(nextRange.from, minDate, maxDate) ||
+            !validate(nextRange.to, minDate, maxDate) ||
+            !validateRange(nextRange.from, nextRange.to)) {
+            setRangeErrorMessage(rangeError());
+            return;
+        }
+        setRangeErrorMessage(null);
+        onChange(nextRange);
+        setIsOpen(false);
+    }, [maxDate, minDate, onChange, rangeError, validateRange]);
+    // Derive start/end months for the year dropdown range, guarding against inverted yearRange props
+    const dropdownStartMonth = React.useMemo(() => {
+        const inferredStart = minDate ? minDate.year : Temporal.Now.plainDateISO().year - 10;
+        const inferredEnd = yearRangeEnd ?? (maxDate ? maxDate.year : Temporal.Now.plainDateISO().year + 5);
+        const year = Math.min(yearRangeStart ?? inferredStart, inferredEnd);
+        return new Date(year, 0, 1);
+    }, [yearRangeStart, yearRangeEnd, minDate, maxDate]);
+    const dropdownEndMonth = React.useMemo(() => {
+        const inferredEnd = maxDate ? maxDate.year : Temporal.Now.plainDateISO().year + 5;
+        const inferredStart = yearRangeStart ?? (minDate ? minDate.year : Temporal.Now.plainDateISO().year - 10);
+        const year = Math.max(yearRangeEnd ?? inferredEnd, inferredStart);
+        return new Date(year, 11, 31);
+    }, [yearRangeStart, yearRangeEnd, minDate, maxDate]);
+    // Memoize disabled days (convert Temporal → Date for DayPicker)
+    const disabledDays = React.useMemo(() => {
+        const baseDisabled = [
+            ...(disabledDates?.map(plainDateToJsDate) || []),
+            ...(minDate ? [{ before: plainDateToJsDate(minDate) }] : []),
+            ...(maxDate ? [{ after: plainDateToJsDate(maxDate) }] : []),
+            ...(disabledMatcher ? [disabledMatcher] : []),
+        ];
+        // If maxRangeDays is set and we have a "from" date, disable dates beyond the range
+        if (maxRangeDays) {
+            if (value?.from) {
+                const maxAllowedDate = value.from.add({ days: maxRangeDays });
+                if (focusedInput !== 'from') {
+                    baseDisabled.push({ after: plainDateToJsDate(maxAllowedDate) });
+                }
+                if (focusedInput === 'to' && !value?.to) {
+                    const minAllowedDate = value.from.subtract({ days: maxRangeDays });
+                    baseDisabled.push({ before: plainDateToJsDate(minAllowedDate) });
+                }
+            }
+            if (value?.to && !value?.from && focusedInput === 'from') {
+                const minAllowedDate = value.to.subtract({ days: maxRangeDays });
+                baseDisabled.push({ before: plainDateToJsDate(minAllowedDate) });
+            }
+        }
+        return baseDisabled;
+    }, [disabledDates, minDate, maxDate, disabledMatcher, maxRangeDays, value, focusedInput]);
+    const selectedRange = React.useMemo(() => {
+        if (value?.from || value?.to) {
+            return {
+                from: value?.from ? plainDateToJsDate(value.from) : undefined,
+                to: value?.to ? plainDateToJsDate(value.to) : undefined,
+            };
+        }
+        return undefined;
+    }, [value]);
+    const defaultMonthJsDate = defaultMonth
+        ? new Date(defaultMonth.year, defaultMonth.month - 1, 1)
+        : (value?.from ? plainDateToJsDate(value.from) : undefined);
+    return (jsxRuntime.jsx("div", { ref: containerRef, className: `cw-rangepicker ${className || ""}`, children: jsxRuntime.jsxs(CwAlign, { ...alignProps, itemProp: required ? "required" : "", children: [labelProps && (jsxRuntime.jsx(CwLabel, { ...labelProps, children: labelProps.text })), jsxRuntime.jsxs("div", { ref: wrapperRef, className: rangeStyles.rangeWrapper, children: [jsxRuntime.jsxs("div", { className: styles$4.pickerWrapper, children: [jsxRuntime.jsx("input", { ref: inputFromRef, type: "text", value: inputFromValue, placeholder: placeholderFrom, onChange: handleInputFromChange, onBlur: () => handleInputBlur('from'), onClick: handleInputFromClick, onKeyDown: (e) => handleInputKeyDown(e, 'from'), disabled: disabled, required: required, "data-focused": focusedInput === 'from' }), jsxRuntime.jsx("div", { className: styles$4.pickerIcons, children: showClear && value?.from && !disabled ? (jsxRuntime.jsx(CwButton, { type: "button", variant: "icon", color: "neutral", icon: "close", onClick: handleClearFrom, tabIndex: -1, "aria-label": "Clear from date" })) : (jsxRuntime.jsx(CwIcon, { iconId: "calendar" })) })] }), jsxRuntime.jsx(CwIcon, { iconId: "arrow-right", size: "medium" }), jsxRuntime.jsxs("div", { className: styles$4.pickerWrapper, children: [jsxRuntime.jsx("input", { ref: inputToRef, type: "text", value: inputToValue, placeholder: placeholderTo, onChange: handleInputToChange, onBlur: () => handleInputBlur('to'), onClick: handleInputToClick, onKeyDown: (e) => handleInputKeyDown(e, 'to'), disabled: disabled, required: required, "data-focused": focusedInput === 'to' }), jsxRuntime.jsx("div", { className: styles$4.pickerIcons, children: showClear && value?.to && !disabled ? (jsxRuntime.jsx(CwButton, { type: "button", variant: "icon", color: "neutral", icon: "close", onClick: handleClearTo, tabIndex: -1, "aria-label": "Clear to date" })) : (jsxRuntime.jsx(CwIcon, { iconId: "calendar" })) })] }), renderPopup(jsxRuntime.jsxs("div", { ref: popupRef, className: `${styles$4.pickerPopup} ${rangeStyles.rangePopup}`, style: popupStyle, children: [jsxRuntime.jsxs("div", { className: rangeStyles.rangeCalendarRow, children: [showPresets && presetsToRender.length > 0 && (jsxRuntime.jsx("div", { className: rangeStyles.presetList, children: presetsToRender.map((preset) => (jsxRuntime.jsx("button", { type: "button", onClick: (e) => handlePresetClick(preset, e), children: preset.label }, preset.key))) })), jsxRuntime.jsx(reactDayPicker.DayPicker, { mode: "range", selected: selectedRange, onSelect: handleRangeSelect, disabled: disabledDays, numberOfMonths: numberOfMonths, defaultMonth: defaultMonthJsDate, locale: locale$1, captionLayout: "dropdown", startMonth: dropdownStartMonth, endMonth: dropdownEndMonth, modifiers: {
+                                                today: new Date(),
+                                            }, modifiersClassNames: {
+                                                today: "rdp-day-today",
+                                            } })] }), jsxRuntime.jsx("div", { role: "alert", "aria-live": "polite", className: rangeStyles.rangeError, children: rangeErrorMessage })] }))] })] }) }));
+}
+
 const ResourcesTitleList = ({ resources, canBePinned, includesPinned, onCrewPinning, onClickResourceContextMenu, ResourceTitleComponent, }) => {
     const onClickContextMenu = React.useCallback((key, resource) => {
         if (onClickResourceContextMenu) {
@@ -9602,13 +10324,13 @@ const PinRowHeader = ({ value, width, onEvent }) => {
                                         jsxRuntime.jsxs("span", { className: styles["scheduler-crewmember-functions"], children: ["(", value.title3, ")"] }), value.subtitle2 && jsxRuntime.jsxs("span", { children: ["-", value.subtitle2] })] })] }), isLoading ? jsxRuntime.jsx("span", { className: "cwi-icons cwi-spinner" }) : undefined] }) }, value.rowId) }, value.rowId);
 };
 
-const SuperScheduler = ({ id, state, header, rows, events, headerColumnComp, pinnedOrderCategory, unPinnedOrderCategory, backgroundEvents, indicatorRows = [], contextMenuItems, onEvent, rowHeightRem = 1.75, rowHeaderWidth, maxEventHeightRem, }) => {
+const SuperScheduler = ({ id, state, header, rows, events, headerColumnComp, pinnedOrderCategory, unPinnedOrderCategory, backgroundEvents, indicatorRows = [], contextMenuItems, onEvent, rowHeightRem = 1.75, rowHeaderWidth, maxEventHeightRem, EventComp = SchedulerEvent, }) => {
     const pinnedRows = rows.filter((it) => it.isPinned);
     const notPinnedRows = rows.filter((it) => !it.isPinned);
     const isFirstVisible = pinnedRows.length > 0;
-    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [isFirstVisible && (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(Scheduler, { id: `${id}-pinned`, state: state, header: header, rows: pinnedRows, events: events, backgroundEvents: backgroundEvents, indicatorRows: indicatorRows, contextMenuItems: contextMenuItems, orderCategories: pinnedOrderCategory, onEvent: onEvent, EventComp: SchedulerEvent, RowTitleComp: headerColumnComp, rowHeightRem: rowHeightRem, rowHeaderWidth: rowHeaderWidth, maxEventHeightRem: maxEventHeightRem }), jsxRuntime.jsx("div", { children: jsxRuntime.jsx(CwButton, { onClick: () => {
+    return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [isFirstVisible && (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx(Scheduler, { id: `${id}-pinned`, state: state, header: header, rows: pinnedRows, events: events, backgroundEvents: backgroundEvents, indicatorRows: indicatorRows, contextMenuItems: contextMenuItems, orderCategories: pinnedOrderCategory, onEvent: onEvent, EventComp: EventComp, RowTitleComp: headerColumnComp, rowHeightRem: rowHeightRem, rowHeaderWidth: rowHeaderWidth, maxEventHeightRem: maxEventHeightRem }), jsxRuntime.jsx("div", { children: jsxRuntime.jsx(CwButton, { onClick: () => {
                                 onEvent(new OnClearPinned());
-                            }, children: "Clear pinned" }) })] })), jsxRuntime.jsx(Scheduler, { id: `${id}-notPinned`, state: { ...state, isHeaderVisible: !isFirstVisible }, header: header, rows: notPinnedRows, events: events, backgroundEvents: backgroundEvents, indicatorRows: indicatorRows, contextMenuItems: contextMenuItems, orderCategories: unPinnedOrderCategory, onEvent: onEvent, EventComp: SchedulerEvent, RowTitleComp: headerColumnComp, rowHeightRem: rowHeightRem, rowHeaderWidth: rowHeaderWidth, maxEventHeightRem: maxEventHeightRem })] }));
+                            }, children: "Clear pinned" }) })] })), jsxRuntime.jsx(Scheduler, { id: `${id}-notPinned`, state: { ...state, isHeaderVisible: !isFirstVisible }, header: header, rows: notPinnedRows, events: events, backgroundEvents: backgroundEvents, indicatorRows: indicatorRows, contextMenuItems: contextMenuItems, orderCategories: unPinnedOrderCategory, onEvent: onEvent, EventComp: EventComp, RowTitleComp: headerColumnComp, rowHeightRem: rowHeightRem, rowHeaderWidth: rowHeaderWidth, maxEventHeightRem: maxEventHeightRem })] }));
 };
 
 /**
@@ -10067,6 +10789,7 @@ exports.CwContextMenu = CwContextMenu;
 exports.CwDatePicker = CwDatePicker;
 exports.CwDatePickerTemporal = CwDatePickerTemporal;
 exports.CwDateRangePicker = CwDateRangePicker;
+exports.CwDateRangePickerTemporal = CwDateRangePickerTemporal;
 exports.CwDateTimePicker = CwDateTimePicker;
 exports.CwDateTimePickerCompact = CwDateTimePickerCompact;
 exports.CwDialog = CwDialog;
@@ -10111,6 +10834,7 @@ exports.CwOption = CwOption;
 exports.CwPopoverButton = CwPopoverButton;
 exports.CwReportModal = CwReportModal;
 exports.CwScheduler = CwScheduler;
+exports.CwSearchAsync = CwSearchAsync;
 exports.CwSearchInput = CwSearchInput;
 exports.CwSelect = CwSelect;
 exports.CwSelectList = CwSelectList;
@@ -10153,6 +10877,7 @@ exports.OnRightClickRow = OnRightClickRow;
 exports.OnRightDragStart = OnRightDragStart;
 exports.OnStartClickHeaderEvent = OnStartClickHeaderEvent;
 exports.OnUnpinRow = OnUnpinRow;
+exports.PRESET_LIBRARY_TEMPORAL = PRESET_LIBRARY_TEMPORAL;
 exports.PinRowHeader = PinRowHeader;
 exports.Resource = Resource;
 exports.Scheduler = Scheduler;
@@ -10166,6 +10891,7 @@ exports.eventIsVisible = eventIsVisible;
 exports.filterVisibleEvents = filterVisibleEvents;
 exports.getDefaultDivisions = getDefaultDivisions;
 exports.getEventSizes = getEventSizes;
+exports.getPresetsByKeysTemporal = getPresetsByKeysTemporal;
 exports.itemsToMultiFilterTags = itemsToMultiFilterTags;
 exports.useCwMessage = useCwMessage;
 exports.useSortableList = useSortableList;