@arc-ui/components 12.0.0-beta7 → 12.1.0

package/lib/DatePicker/DatePicker.cjs

@@ -0,0 +1,539 @@
+'use client';
+'use strict';
+
+var index = require('../_shared/cjs/index-BLRjGROQ.cjs');
+var tslib_es6 = require('../_shared/cjs/tslib.es6-CCZ3TN_7.cjs');
+var React = require('react');
+var index$2 = require('../_shared/cjs/index-CTlXMLug.cjs');
+var index$3 = require('../_shared/cjs/index-BWfgSvRQ.cjs');
+var Calendar = require('../_shared/cjs/Calendar-D_jZ0cgf.cjs');
+var filterAttrs = require('../_shared/cjs/filter-attrs-D19P2s1V.cjs');
+var TextInput = require('../_shared/cjs/TextInput-BHzuoI7E.cjs');
+var index$1 = require('../_shared/cjs/index-DXNM3D1d.cjs');
+require('../_shared/cjs/Combination-6m6aOXZq.cjs');
+require('react/jsx-runtime');
+require('react-dom');
+require('../_shared/cjs/index-KrMgv4q_.cjs');
+require('../_shared/cjs/index-B11wQrRa.cjs');
+require('../_shared/cjs/index-BGGFOAAx.cjs');
+require('../_shared/cjs/index.es-B2ZfX2D7.cjs');
+require('../_shared/cjs/use-media-query-BJV2IbHi.cjs');
+require('../_shared/cjs/Text-jwsn80lQ.cjs');
+require('../_shared/cjs/suffix-modifier-DLUGR-yG.cjs');
+require('../_shared/cjs/index-DR8Rkav9.cjs');
+require('../_shared/cjs/Surface-DIU5ciDT.cjs');
+require('../_shared/cjs/VisuallyHidden-CQg3cOVK.cjs');
+require('../_shared/cjs/Heading-BYBmZkmS.cjs');
+require('../_shared/cjs/SemanticHeading-C1-fyc3V.cjs');
+require('../_shared/cjs/ThemeIcon-CwYN77IF.cjs');
+require('../_shared/cjs/Icon-Dk2XHa7V.cjs');
+require('../_shared/cjs/FormControl-TtboqHRx.cjs');
+require('../_shared/cjs/DisclosureMini-Cy7hNc90.cjs');
+require('../_shared/cjs/Spinner-427lpnHI.cjs');
+require('../_shared/cjs/Tooltip-CEb7YEP2.cjs');
+
+/**
+ * @name startOfDay
+ * @category Day Helpers
+ * @summary Return the start of a day for the given date.
+ *
+ * @description
+ * Return the start of a day for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param {Date|Number} date - the original date
+ * @returns {Date} the start of a day
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // The start of a day for 2 September 2014 11:55:00:
+ * const result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Tue Sep 02 2014 00:00:00
+ */
+function startOfDay(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+
+/**
+ * @name isSameDay
+ * @category Day Helpers
+ * @summary Are the given dates in the same day (and year and month)?
+ *
+ * @description
+ * Are the given dates in the same day (and year and month)?
+ *
+ * @param {Date|Number} dateLeft - the first date to check
+ * @param {Date|Number} dateRight - the second date to check
+ * @returns {Boolean} the dates are in the same day (and year and month)
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?
+ * const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))
+ * //=> true
+ *
+ * @example
+ * // Are 4 September and 4 October in the same day?
+ * const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4))
+ * //=> false
+ *
+ * @example
+ * // Are 4 September, 2014 and 4 September, 2015 in the same day?
+ * const result = isSameDay(new Date(2014, 8, 4), new Date(2015, 8, 4))
+ * //=> false
+ */
+function isSameDay(dirtyDateLeft, dirtyDateRight) {
+  index.requiredArgs(2, arguments);
+  var dateLeftStartOfDay = startOfDay(dirtyDateLeft);
+  var dateRightStartOfDay = startOfDay(dirtyDateRight);
+  return dateLeftStartOfDay.getTime() === dateRightStartOfDay.getTime();
+}
+
+var parseRangeString = function (value) {
+    if (value === void 0) { value = ""; }
+    var _a = value.replace(/\s/g, "").split("-"), _b = _a[0], start = _b === void 0 ? "" : _b, _c = _a[1], end = _c === void 0 ? "" : _c;
+    var _d = start.split("/"), startDay = _d[0], startMonth = _d[1], startYear = _d[2];
+    var _e = end.split("/"), endDay = _e[0], endMonth = _e[1], endYear = _e[2];
+    return {
+        start: {
+            date: start,
+            day: startDay,
+            month: startMonth,
+            year: startYear,
+        },
+        end: {
+            date: end,
+            day: endDay,
+            month: endMonth,
+            year: endYear,
+        },
+    };
+};
+
+var parseDateString = function (value) {
+    var _a = value.split("/"), day = _a[0], month = _a[1], year = _a[2];
+    return {
+        day: day,
+        month: month,
+        year: year,
+    };
+};
+
+var isDateValid = function (value) {
+    if (value === void 0) { value = ""; }
+    var _a = value.split("/"), day = _a[0], month = _a[1], year = _a[2];
+    return (/^\d{2}\/\d{2}\/\d{4}$/.test(value) &&
+        index.isValid(new Date("".concat(year, "-").concat(month, "-").concat(day))));
+};
+
+var isRangeValid = function (value) {
+    if (value === void 0) { value = ""; }
+    var _a = value.replace(/\s/g, "").split("-"), _b = _a[0], start = _b === void 0 ? "" : _b, _c = _a[1], end = _c === void 0 ? "" : _c;
+    return isDateValid(start) && isDateValid(end);
+};
+
+var DATE_FORMAT = "dd/MM/yyyy";
+
+var formatDate = function (value) {
+    return index.format(value, DATE_FORMAT);
+};
+
+var isDisabledDate = function (disabledDates, date) {
+    return Boolean(disabledDates &&
+        disabledDates.find(function (disabledDate) { return isSameDay(date, disabledDate); }));
+};
+
+var convertDateStringToDate = function (value) {
+    if (value === void 0) { value = ""; }
+    var _a = parseDateString(value), day = _a.day, month = _a.month, year = _a.year;
+    var isValidDate = isDateValid(value);
+    return isValidDate ? new Date("".concat(year, "-").concat(month, "-").concat(day)) : new Date();
+};
+
+var convertRangeStringToDates = function (value) {
+    if (value === void 0) { value = ""; }
+    var _a = parseRangeString(value), start = _a.start, end = _a.end;
+    return tslib_es6.__spreadArray(tslib_es6.__spreadArray([], (isDateValid(start.date)
+        ? [new Date("".concat(start.year, "-").concat(start.month, "-").concat(start.day))]
+        : []), true), (isDateValid(end.date)
+        ? [new Date("".concat(end.year, "-").concat(end.month, "-").concat(end.day))]
+        : []), true);
+};
+
+var convertRangeStringToDateTuple = function (value) {
+    if (value === void 0) { value = ""; }
+    var _a = parseRangeString(value), start = _a.start, end = _a.end;
+    var startDate = isDateValid(start.date)
+        ? new Date("".concat(start.year, "-").concat(start.month, "-").concat(start.day))
+        : undefined;
+    var endDate = isDateValid(end.date)
+        ? new Date("".concat(end.year, "-").concat(end.month, "-").concat(end.day))
+        : undefined;
+    return [startDate, endDate];
+};
+
+function validateRangeOnBlur(_a) {
+    var value = _a.value, minDate = _a.minDate, maxDate = _a.maxDate, disabledDates = _a.disabledDates, previousValidValue = _a.previousValidValue, dispatchChangeEvent = _a.dispatchChangeEvent, blurEvent = _a.blurEvent;
+    if (!isRangeValid(value))
+        return;
+    var _b = convertRangeStringToDates(value), start = _b[0], end = _b[1];
+    var isStartBeforeMin = minDate && Calendar.isBefore(start, minDate);
+    var isEndAfterMax = maxDate && Calendar.isAfter(end, maxDate);
+    var isStartDisabled = isDisabledDate(disabledDates, start);
+    var isEndDisabled = isDisabledDate(disabledDates, end);
+    if (isStartBeforeMin && isEndAfterMax) {
+        return dispatchChangeEvent(blurEvent, "".concat(formatDate(minDate), " - ").concat(formatDate(maxDate)));
+    }
+    if (isStartBeforeMin) {
+        return dispatchChangeEvent(blurEvent, "".concat(formatDate(minDate), " - ").concat(formatDate(end)));
+    }
+    if (isEndAfterMax) {
+        return dispatchChangeEvent(blurEvent, "".concat(formatDate(start), " - ").concat(formatDate(maxDate)));
+    }
+    if (isStartDisabled || isEndDisabled) {
+        var _c = previousValidValue
+            ? convertRangeStringToDates(previousValidValue)
+            : [], prevStart = _c[0], prevEnd = _c[1];
+        return dispatchChangeEvent(blurEvent, prevStart && prevEnd
+            ? "".concat(formatDate(prevStart), " - ").concat(formatDate(prevEnd))
+            : "");
+    }
+    if (Calendar.isAfter(start, end)) {
+        var _d = [start, end].sort(Calendar.compareAsc), orderedStart = _d[0], orderedEnd = _d[1];
+        return dispatchChangeEvent(blurEvent, "".concat(formatDate(orderedStart), " - ").concat(formatDate(orderedEnd)));
+    }
+}
+
+/**
+ * Use `DatePicker` to clearly present available dates and allow users to choose a way to enter information.
+ */
+var DatePicker = React.forwardRef(function (_a, ref) {
+    var errorMessage = _a.errorMessage, helper = _a.helper, id = _a.id, label = _a.label, isDisabled = _a.isDisabled, isReadOnly = _a.isReadOnly, isRequired = _a.isRequired, _b = _a.size, size = _b === void 0 ? "m" : _b, _c = _a.value, value = _c === void 0 ? "" : _c, name = _a.name, onBlur = _a.onBlur, onChange = _a.onChange, onDateSelect = _a.onDateSelect, onRangeSelect = _a.onRangeSelect, onClickDisclosure = _a.onClickDisclosure, disclosureTitle = _a.disclosureTitle, disclosureText = _a.disclosureText, type = _a.type, _d = _a.isFluid, isFluid = _d === void 0 ? false : _d, _e = _a.selectionType, selectionType = _e === void 0 ? "single" : _e, disabledDates = _a.disabledDates, minDate = _a.minDate, maxDate = _a.maxDate, props = tslib_es6.__rest(_a, ["errorMessage", "helper", "id", "label", "isDisabled", "isReadOnly", "isRequired", "size", "value", "name", "onBlur", "onChange", "onDateSelect", "onRangeSelect", "onClickDisclosure", "disclosureTitle", "disclosureText", "type", "isFluid", "selectionType", "disabledDates", "minDate", "maxDate"]);
+    var _f = index$1.useThemeElement(), themeElement = _f[0], setThemeElement = _f[1];
+    var _g = React.useState("Choose date"), ariaLabel = _g[0], setAriaLabel = _g[1];
+    var _h = React.useState(false), showCalendar = _h[0], setShowCalendar = _h[1];
+    var buttonRef = React.useRef(null);
+    var ourRef = React.useRef(null);
+    var previousValidValue = React.useRef(value);
+    var lowerCaseDateFormat = DATE_FORMAT.toLowerCase();
+    var placeHolder = selectionType === "range"
+        ? "".concat(lowerCaseDateFormat, " - ").concat(lowerCaseDateFormat)
+        : lowerCaseDateFormat;
+    React.useEffect(function () {
+        if (selectionType === "single" &&
+            isDateValid(value) &&
+            !isDisabledDate(disabledDates, convertDateStringToDate(value))) {
+            previousValidValue.current = value;
+        }
+        if (selectionType === "range" && isRangeValid(value)) {
+            var rangeHasDisabledDates = convertRangeStringToDates(value).some(function (rangeValue) { return isDisabledDate(disabledDates, rangeValue); });
+            if (!rangeHasDisabledDates) {
+                previousValidValue.current = value;
+            }
+        }
+    }, [value, disabledDates, selectionType]);
+    var getDatePickerRef = function (elementRef) {
+        ourRef.current = elementRef;
+        if (ref && typeof ref === "object") {
+            ref.current = elementRef;
+        }
+        if (ref && typeof ref === "function") {
+            ref(elementRef);
+        }
+    };
+    var dispatchChangeEvent = function (e, value) {
+        onChange &&
+            onChange(tslib_es6.__assign(tslib_es6.__assign({}, e), { target: tslib_es6.__assign(tslib_es6.__assign({}, e.target), { value: value }) }));
+    };
+    var handleRangeSelect = function (rangeSelection) {
+        var start = formatDate(rangeSelection.start);
+        var end = rangeSelection.end ? formatDate(rangeSelection.end) : null;
+        onRangeSelect &&
+            onRangeSelect(tslib_es6.__assign(tslib_es6.__assign({}, rangeSelection), { formattedRange: "".concat(start).concat(end ? " - ".concat(end) : "") }));
+        rangeSelection.isSelectionComplete && setShowCalendar(false);
+    };
+    var handleDateSelect = function (value) {
+        onDateSelect &&
+            onDateSelect({
+                date: value,
+                formattedDate: formatDate(value),
+            });
+        setShowCalendar(false);
+    };
+    var handleSingleSelectionBlur = function (e) {
+        if (value && isDateValid(value) && selectionType === "single") {
+            var _a = parseDateString(value), day = _a.day, month = _a.month, year = _a.year;
+            var date = new Date("".concat(year, "-").concat(month, "-").concat(day));
+            var isDateBeforeMinDate = minDate && Calendar.isBefore(date, minDate);
+            var isDateAfterMaxDate = maxDate && Calendar.isAfter(date, maxDate);
+            var isDisabledValue = isDisabledDate(disabledDates, date);
+            if (isDateBeforeMinDate) {
+                return dispatchChangeEvent(e, "".concat(formatDate(minDate)));
+            }
+            if (isDateAfterMaxDate) {
+                return dispatchChangeEvent(e, "".concat(formatDate(maxDate)));
+            }
+            if (isDisabledValue) {
+                var date_1 = previousValidValue.current
+                    ? convertDateStringToDate(previousValidValue.current)
+                    : new Date();
+                return dispatchChangeEvent(e, "".concat(formatDate(date_1)));
+            }
+        }
+    };
+    var handleRangeSelectionBlur = function (e) {
+        validateRangeOnBlur({
+            value: value,
+            minDate: minDate,
+            maxDate: maxDate,
+            disabledDates: disabledDates,
+            previousValidValue: previousValidValue.current,
+            dispatchChangeEvent: dispatchChangeEvent,
+            blurEvent: e,
+        });
+    };
+    var handleBlur = function (e) {
+        onBlur && onBlur(e);
+        if (selectionType === "single") {
+            handleSingleSelectionBlur(e);
+        }
+        if (selectionType === "range") {
+            handleRangeSelectionBlur(e);
+        }
+    };
+    var handleChange = function (e) {
+        onChange && onChange(e);
+    };
+    var handleCalendarOpenChange = function (isOpen) {
+        if (document.activeElement)
+            setShowCalendar(isOpen);
+    };
+    var handleIconClick = function () {
+        var _a;
+        !((_a = ourRef.current) === null || _a === void 0 ? void 0 : _a.contains(document.activeElement)) &&
+            !isDisabled &&
+            !isReadOnly &&
+            setShowCalendar(true);
+    };
+    var handleIconFocus = function () {
+        if (selectionType === "range" && isRangeValid(value)) {
+            var _a = convertRangeStringToDates(value), start = _a[0], end = _a[1];
+            return setAriaLabel("Change dates, currently selected dates are ".concat(index.format(start, "EEEE do MMMM, yyyy"), " to ").concat(index.format(end, "EEEE do MMMM, yyyy")));
+        }
+        if (selectionType === "single" && isDateValid(value)) {
+            var date = convertDateStringToDate(value);
+            return setAriaLabel("Change date, currently selected date is ".concat(index.format(date, "EEEE do MMMM, yyyy")));
+        }
+        setAriaLabel("Choose Date");
+    };
+    var handleCalendarClose = function () {
+        var _a, _b;
+        if (((_a = document.activeElement) === null || _a === void 0 ? void 0 : _a.tagName) === "BODY") {
+            (_b = buttonRef.current) === null || _b === void 0 ? void 0 : _b.focus();
+        }
+    };
+    var onCancelClick = function () {
+        setShowCalendar(false);
+    };
+    var handleAutoFocus = function (e) {
+        e.preventDefault();
+    };
+    return (React.createElement("div", { ref: setThemeElement, className: index$2.classNames({
+            "arc-DatePicker--constrained": !isFluid,
+        }) },
+        React.createElement(TextInput.TextInputWithPlaceHolder, tslib_es6.__assign({ ref: getDatePickerRef, trailingSlot: React.createElement(TextInput.InputIcon, { themeIcon: "datePickerCalendar", size: size, isReadOnly: isReadOnly, isDisabled: isDisabled, isButton: {
+                    ref: buttonRef,
+                    onClick: handleIconClick,
+                    onFocus: handleIconFocus,
+                    label: ariaLabel,
+                } }), placeholder: placeHolder, errorMessage: errorMessage, helper: helper, id: id, isDisabled: isDisabled, isReadOnly: isReadOnly, isRequired: isRequired, label: label, maxLength: selectionType === "range" ? 23 : 10, name: name, onBlur: handleBlur, onChange: handleChange, onClickDisclosure: onClickDisclosure, type: "text", value: value, disclosureTitle: disclosureTitle, disclosureText: disclosureText, size: size }, props, filterAttrs.filterAttrs(props))),
+        React.createElement(index$3.Root2, tslib_es6.__assign({ open: showCalendar, onOpenChange: handleCalendarOpenChange }, filterAttrs.filterAttrs(props)),
+            React.createElement(index$3.Anchor2, null),
+            React.createElement(index$3.Portal, { container: themeElement },
+                React.createElement(index$3.Content2, { align: "start", "aria-modal": "true", "aria-label": "Choose Date", className: "arc-DatePicker-modal", onOpenAutoFocus: handleAutoFocus, onCloseAutoFocus: handleCalendarClose },
+                    React.createElement(Calendar.Calendar, { autoFocusOnMount: true, type: type, onCancelClick: onCancelClick, selectionType: selectionType, selectedDate: convertDateStringToDate(value), selectedRange: convertRangeStringToDates(value), disabledDates: disabledDates, minDate: minDate, maxDate: maxDate, onDateSelect: handleDateSelect, onRangeSelect: handleRangeSelect }))))));
+});
+
+var lowerCaseDateFormat = DATE_FORMAT.toLowerCase();
+var DatePickerRange = function (_a) {
+    var _b, _c;
+    var inputStart = _a.inputStart, inputEnd = _a.inputEnd, _d = _a.type, type = _d === void 0 ? "month" : _d, minDate = _a.minDate, maxDate = _a.maxDate, disabledDates = _a.disabledDates, onRangeSelect = _a.onRangeSelect, _e = _a.isFluid, isFluid = _e === void 0 ? false : _e;
+    // startInput States
+    var _f = React.useState("Choose start date"), startAriaLabel = _f[0], setStartAriaLabel = _f[1];
+    var startButtonRef = React.useRef(null);
+    var startInputRef = React.useRef(null);
+    var _g = React.useState((_b = inputStart.value) !== null && _b !== void 0 ? _b : ""), startValue = _g[0], setStartValue = _g[1];
+    // endInput States
+    var _h = React.useState("Choose end date"), endAriaLabel = _h[0], setEndAriaLabel = _h[1];
+    var _j = React.useState((_c = inputEnd.value) !== null && _c !== void 0 ? _c : ""), endValue = _j[0], setEndValue = _j[1];
+    var endButtonRef = React.useRef(null);
+    var endInputRef = React.useRef(null);
+    var previousValidValue = React.useRef("");
+    var _k = index$1.useThemeElement(), themeElement = _k[0], setThemeElement = _k[1];
+    var _l = React.useState(false), showCalendar = _l[0], setShowCalendar = _l[1];
+    var _m = React.useState(null), activeInput = _m[0], setActiveInput = _m[1];
+    var getIsRequired = function (input) { var _a; return (_a = input.isRequired) !== null && _a !== void 0 ? _a : true; };
+    var getLabel = function (input, type) { var _a; return (_a = input.label) !== null && _a !== void 0 ? _a : "Select ".concat(type === "start" ? "a" : "an", " ").concat(type, " date"); };
+    // sync external props with internal value (not typing)
+    React.useEffect(function () {
+        if (inputStart.value !== undefined && inputStart.value !== startValue) {
+            setStartValue(inputStart.value);
+        }
+        if (inputEnd.value !== undefined && inputEnd.value !== endValue) {
+            setEndValue(inputEnd.value);
+        }
+    }, [inputStart.value, inputEnd.value, endValue, startValue]);
+    var handleIconClick = function (_a) {
+        var ref = _a.ref, isDisabled = _a.isDisabled, isReadOnly = _a.isReadOnly, input = _a.input;
+        if (ref &&
+            !ref.contains(document.activeElement) &&
+            !isDisabled &&
+            !isReadOnly) {
+            setActiveInput(input);
+            setShowCalendar(true);
+        }
+    };
+    var handleRangeSelect = function (rangeSelection) {
+        var start = rangeSelection.start, end = rangeSelection.end, isSelectionComplete = rangeSelection.isSelectionComplete;
+        var formattedStart = index.format(start, "dd/MM/yyyy");
+        var formattedEnd = end ? index.format(end, "dd/MM/yyyy") : "";
+        onRangeSelect === null || onRangeSelect === void 0 ? void 0 : onRangeSelect(tslib_es6.__assign(tslib_es6.__assign({}, rangeSelection), { formattedStart: formattedStart, formattedEnd: formattedEnd }));
+        if (isSelectionComplete) {
+            var fullRange = "".concat(formattedStart, " - ").concat(formattedEnd);
+            previousValidValue.current = fullRange;
+            setShowCalendar(false);
+        }
+    };
+    var handleCalendarClose = function () {
+        var _a, _b, _c;
+        if (((_a = document.activeElement) === null || _a === void 0 ? void 0 : _a.tagName) === "BODY") {
+            (_b = startButtonRef.current) === null || _b === void 0 ? void 0 : _b.focus();
+            (_c = endButtonRef.current) === null || _c === void 0 ? void 0 : _c.focus();
+        }
+    };
+    var handleIconFocus = function (_a) {
+        var input = _a.input;
+        if (isRangeValid("".concat(startValue, " - ").concat(endValue))) {
+            var _b = convertRangeStringToDates("".concat(startValue, " - ").concat(endValue)), start = _b[0], end = _b[1];
+            var label = "Change dates, currently selected dates are ".concat(index.format(start, "EEEE do MMMM, yyyy"), " to ").concat(index.format(end, "EEEE do MMMM, yyyy"));
+            input === "start" ? setStartAriaLabel(label) : setEndAriaLabel(label);
+            return;
+        }
+    };
+    var handleChange = function (e, input) {
+        if (input === "start") {
+            inputStart.onChange && inputStart.onChange(e);
+            setStartValue(e.target.value);
+            setActiveInput("start");
+        }
+        if (input === "end") {
+            inputEnd.onChange && inputEnd.onChange(e);
+            setEndValue(e.target.value);
+            setActiveInput("end");
+        }
+    };
+    var handleBlur = function (e, input) {
+        var value = "".concat(startValue, " - ").concat(endValue);
+        if (input === "start") {
+            inputStart.onBlur && inputStart.onBlur(e);
+        }
+        if (input === "end") {
+            inputEnd.onBlur && inputEnd.onBlur(e);
+        }
+        validateRangeOnBlur({
+            value: value,
+            minDate: minDate,
+            maxDate: maxDate,
+            disabledDates: disabledDates,
+            previousValidValue: previousValidValue.current,
+            dispatchChangeEvent: function (e, corrected) {
+                var _a, _b;
+                var _c = convertRangeStringToDates(corrected), start = _c[0], end = _c[1];
+                (_a = inputStart.onChange) === null || _a === void 0 ? void 0 : _a.call(inputStart, tslib_es6.__assign(tslib_es6.__assign({}, e), { target: tslib_es6.__assign(tslib_es6.__assign({}, e.target), { value: formatDate(start) }) }));
+                (_b = inputEnd.onChange) === null || _b === void 0 ? void 0 : _b.call(inputEnd, tslib_es6.__assign(tslib_es6.__assign({}, e), { target: tslib_es6.__assign(tslib_es6.__assign({}, e.target), { value: formatDate(end) }) }));
+                previousValidValue.current = corrected;
+            },
+            blurEvent: e,
+        });
+    };
+    var handleCalendarOpenChange = function (isOpen) {
+        if (document.activeElement)
+            setShowCalendar(isOpen);
+    };
+    var handleAutoFocus = function (e) {
+        e.preventDefault();
+    };
+    var setStartInputRef = function (el) {
+        startInputRef.current = el;
+    };
+    var setEndInputRef = function (el) {
+        endInputRef.current = el;
+    };
+    var onCancelClick = function () {
+        setShowCalendar(false);
+    };
+    var getCalendarRange = function () {
+        var _a = convertRangeStringToDateTuple("".concat(startValue, " - ").concat(endValue)), start = _a[0], end = _a[1];
+        // when inital or one date is set - allow user to pick start / end independently
+        if (start && end) {
+            if (activeInput === "start") {
+                return end ? [end] : [];
+            }
+            if (activeInput === "end") {
+                return start ? [start] : [];
+            }
+        }
+        // removes all non date obj
+        return [start, end].filter(function (d) { return d instanceof Date; });
+    };
+    return (React.createElement(index$3.Root2, { open: showCalendar, onOpenChange: handleCalendarOpenChange },
+        React.createElement("div", { className: "arc-DatePickerRange", ref: setThemeElement },
+            React.createElement("div", { className: index$2.classNames("arc-DatePickerRange-input", {
+                    "arc-DatePickerRange-input--isFluid": isFluid,
+                }) },
+                React.createElement(TextInput.TextInputWithPlaceHolder, tslib_es6.__assign({ ref: setStartInputRef, type: "text", trailingSlot: React.createElement(TextInput.InputIcon, { themeIcon: "datePickerCalendar", isButton: {
+                            ref: startButtonRef,
+                            onClick: function () {
+                                return handleIconClick({
+                                    ref: startInputRef.current,
+                                    isDisabled: inputStart.isDisabled,
+                                    isReadOnly: inputStart.isReadOnly,
+                                    input: "start",
+                                });
+                            },
+                            onFocus: function () { return handleIconFocus({ input: "start" }); },
+                            label: startAriaLabel,
+                        } }), maxLength: 23, onBlur: function (e) { return handleBlur(e, "start"); }, errorMessage: inputStart.errorMessage, helper: inputStart.helper, id: inputStart.id, isDisabled: inputStart.isDisabled, isReadOnly: inputStart.isReadOnly, isRequired: getIsRequired(inputStart), label: getLabel(inputStart, "start"), hideLabel: inputStart.hideLabel, name: inputStart.name, onClickDisclosure: inputStart.onClickDisclosure, disclosureTitle: inputStart.disclosureTitle, disclosureText: inputStart.disclosureText, placeholder: lowerCaseDateFormat, value: startValue, onChange: function (e) { return handleChange(e, "start"); } }, filterAttrs.filterAttrs(inputStart))),
+                activeInput === "start" && React.createElement(index$3.Anchor2, null)),
+            React.createElement("div", { className: index$2.classNames("arc-DatePickerRange-input", {
+                    "arc-DatePickerRange-input--isFluid": isFluid,
+                }) },
+                React.createElement(TextInput.TextInputWithPlaceHolder, tslib_es6.__assign({ ref: setEndInputRef, type: "text", trailingSlot: React.createElement(TextInput.InputIcon, { themeIcon: "datePickerCalendar", isButton: {
+                            ref: endButtonRef,
+                            onClick: function () {
+                                return handleIconClick({
+                                    ref: endInputRef.current,
+                                    isDisabled: inputEnd.isDisabled,
+                                    isReadOnly: inputEnd.isReadOnly,
+                                    input: "end",
+                                });
+                            },
+                            onFocus: function () { return handleIconFocus({ input: "end" }); },
+                            label: endAriaLabel,
+                        } }), maxLength: 23, onBlur: function (e) { return handleBlur(e, "end"); }, errorMessage: inputEnd.errorMessage, helper: inputEnd.helper, id: inputEnd.id, isDisabled: inputEnd.isDisabled, isReadOnly: inputEnd.isReadOnly, isRequired: getIsRequired(inputEnd), label: getLabel(inputEnd, "end"), hideLabel: inputStart.hideLabel, name: inputEnd.name, onClickDisclosure: inputEnd.onClickDisclosure, disclosureTitle: inputEnd.disclosureTitle, disclosureText: inputEnd.disclosureText, placeholder: lowerCaseDateFormat, value: endValue, onChange: function (e) { return handleChange(e, "end"); } }, filterAttrs.filterAttrs(inputEnd))),
+                activeInput === "end" && React.createElement(index$3.Anchor2, null))),
+        React.createElement(index$3.Portal, { container: themeElement },
+            React.createElement(index$3.Content2, { align: "start", "aria-modal": "true", "aria-label": "Choose Date", className: "arc-DatePicker-modal", onOpenAutoFocus: handleAutoFocus, onCloseAutoFocus: handleCalendarClose, sideOffset: 12 },
+                React.createElement(Calendar.Calendar, { autoFocusOnMount: true, type: type, onCancelClick: onCancelClick, selectionType: "range", selectedRange: getCalendarRange(), disabledDates: disabledDates, minDate: minDate, maxDate: maxDate, onRangeSelect: handleRangeSelect })))));
+};
+
+exports.DATE_FORMAT = DATE_FORMAT;
+exports.DatePicker = DatePicker;
+exports.DatePickerRange = DatePickerRange;
+exports.isDateValid = isDateValid;
+exports.isRangeValid = isRangeValid;
+exports.parseDateString = parseDateString;
+exports.parseRangeString = parseRangeString;