@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/baseui/datepicker/day.d.ts

@@ -0,0 +1,87 @@
+import * as React from 'react';
+import DateHelpers from './utils/date-helpers';
+import type { DayProps, DayState } from './types';
+import type { Locale } from '../locale';
+export default class Day<T = Date> extends React.Component<DayProps<T>, DayState> {
+    static defaultProps: {
+        disabled: boolean;
+        highlighted: boolean;
+        range: boolean;
+        adapter: import("./utils/types").DateIOAdapter<Date>;
+        onClick: () => void;
+        onSelect: () => void;
+        onFocus: () => void;
+        onBlur: () => void;
+        onMouseOver: () => void;
+        onMouseLeave: () => void;
+        overrides: {};
+        peekNextMonth: boolean;
+        value: null;
+    };
+    dayElm: HTMLElement;
+    state: {
+        isHovered: boolean;
+        isFocusVisible: boolean;
+    };
+    dateHelpers: DateHelpers<T>;
+    constructor(props: DayProps<T>);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: DayProps<T>): void;
+    getDateProp: () => T;
+    getMonthProp: () => number;
+    /**
+     * Determines how the day value(s) should be updated when a new day is selected.
+     * Note: time values are incorporated into new day/date values downstream in `Calendar`.
+     * Note: Situations where Start Dates are after End Dates are handled downstream in `Datepicker`.
+     * */
+    onSelect: (a: T) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    onClick: (event: Event) => void;
+    onFocus: (event: Event) => void;
+    onBlur: (event: Event) => void;
+    onMouseOver: (event: Event) => void;
+    onMouseLeave: (event: Event) => void;
+    isOutsideMonth: () => boolean;
+    getOrderedDates: () => T[];
+    isOutsideOfMonthButWithinRange: () => boolean;
+    isSelected(): boolean;
+    clampToDayStart: (a: T) => T;
+    isPseudoSelected(): boolean | undefined;
+    isPseudoHighlighted(): boolean | undefined;
+    getSharedProps(): {
+        $date: T;
+        $density: "default" | "high";
+        $disabled: boolean;
+        $endDate: boolean;
+        $hasDateLabel: boolean;
+        $hasRangeHighlighted: boolean;
+        $hasRangeOnRight: boolean | null | undefined;
+        $hasRangeSelected: boolean;
+        $highlightedDate: T | null | undefined;
+        $isHighlighted: boolean;
+        $isHovered: boolean;
+        $isFocusVisible: boolean;
+        $startOfMonth: boolean;
+        $endOfMonth: boolean;
+        $month: number;
+        $outsideMonth: boolean;
+        $outsideMonthWithinRange: boolean;
+        $peekNextMonth: boolean;
+        $pseudoHighlighted: boolean | undefined;
+        $pseudoSelected: boolean | undefined;
+        $range: boolean;
+        $selected: boolean;
+        $startDate: boolean;
+        $hasLockedBehavior: boolean;
+        $selectedInput: import("./types").InputRole;
+        $value: T | (T | null | undefined)[] | null | undefined;
+    };
+    getAriaLabel(sharedProps: {
+        $disabled: boolean;
+        $range: boolean;
+        $selected: boolean;
+        $startDate: boolean;
+        $endDate: boolean;
+    }, localeContext: Locale): string;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/baseui/datepicker/day.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+var React = (0, tslib_1.__importStar)(require("react"));
+var styled_components_1 = require("./styled-components");
+var date_fns_adapter_1 = (0, tslib_1.__importDefault)(require("./utils/date-fns-adapter"));
+var date_helpers_1 = (0, tslib_1.__importDefault)(require("./utils/date-helpers"));
+var overrides_1 = require("../helpers/overrides");
+var locale_1 = require("../locale");
+var focusVisible_1 = require("../utils/focusVisible");
+var constants_1 = require("./constants");
+var Day = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Day, _super);
+    function Day(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            isHovered: false,
+            isFocusVisible: false,
+        };
+        _this.getDateProp = function () {
+            return _this.props.date === undefined ? _this.dateHelpers.date() : _this.props.date;
+        };
+        _this.getMonthProp = function () {
+            return _this.props.month === undefined || _this.props.month === null
+                ? _this.dateHelpers.getMonth(_this.getDateProp())
+                : _this.props.month;
+        };
+        /**
+         * Determines how the day value(s) should be updated when a new day is selected.
+         * Note: time values are incorporated into new day/date values downstream in `Calendar`.
+         * Note: Situations where Start Dates are after End Dates are handled downstream in `Datepicker`.
+         * */
+        _this.onSelect = function (selectedDate) {
+            var _a = _this.props, range = _a.range, value = _a.value;
+            var nextDate;
+            if (Array.isArray(value) && range && _this.props.hasLockedBehavior) {
+                var currentDate = _this.props.value;
+                var nextStartDate = null;
+                var nextEndDate = null;
+                if (_this.props.selectedInput === constants_1.INPUT_ROLE.startDate) {
+                    // @ts-ignore
+                    nextStartDate = selectedDate;
+                    // @ts-ignore
+                    nextEndDate = Array.isArray(currentDate) && currentDate[1] ? currentDate[1] : null;
+                }
+                else if (_this.props.selectedInput === constants_1.INPUT_ROLE.endDate) {
+                    // @ts-ignore
+                    nextStartDate = Array.isArray(currentDate) && currentDate[0] ? currentDate[0] : null;
+                    // @ts-ignore
+                    nextEndDate = selectedDate;
+                }
+                nextDate = [nextStartDate];
+                if (nextEndDate) {
+                    nextDate.push(nextEndDate);
+                }
+            }
+            else if (Array.isArray(value) && range && !_this.props.hasLockedBehavior) {
+                var _b = (0, tslib_1.__read)(value, 2), start = _b[0], end = _b[1];
+                // Starting a new range
+                if ((!start && !end) || (start && end)) {
+                    nextDate = [selectedDate, null];
+                    // EndDate needs a StartDate, SelectedDate comes before EndDate
+                }
+                else if (!start && end && _this.dateHelpers.isAfter(end, selectedDate)) {
+                    nextDate = [selectedDate, end];
+                    // EndDate needs a StartDate, but SelectedDate comes after EndDate
+                }
+                else if (!start && end && _this.dateHelpers.isAfter(selectedDate, end)) {
+                    nextDate = [end, selectedDate];
+                    // StartDate needs an EndDate, SelectedDate comes after StartDate
+                }
+                else if (start && !end && _this.dateHelpers.isAfter(selectedDate, start)) {
+                    nextDate = [start, selectedDate];
+                }
+                else {
+                    nextDate = [selectedDate, start];
+                }
+            }
+            else {
+                nextDate = selectedDate;
+            }
+            _this.props.onSelect({ date: nextDate });
+        };
+        _this.onKeyDown = function (event) {
+            var date = _this.getDateProp();
+            var _a = _this.props, highlighted = _a.highlighted, disabled = _a.disabled;
+            if (event.key === 'Enter' && highlighted && !disabled) {
+                event.preventDefault();
+                _this.onSelect(date);
+            }
+        };
+        _this.onClick = function (event) {
+            var date = _this.getDateProp();
+            var disabled = _this.props.disabled;
+            if (!disabled) {
+                _this.props.onClick({ event: event, date: date });
+                _this.onSelect(date);
+            }
+        };
+        _this.onFocus = function (event) {
+            if ((0, focusVisible_1.isFocusVisible)(event)) {
+                _this.setState({ isFocusVisible: true });
+            }
+            _this.props.onFocus({ event: event, date: _this.getDateProp() });
+        };
+        _this.onBlur = function (event) {
+            if (_this.state.isFocusVisible !== false) {
+                _this.setState({ isFocusVisible: false });
+            }
+            _this.props.onBlur({ event: event, date: _this.getDateProp() });
+        };
+        _this.onMouseOver = function (event) {
+            _this.setState({ isHovered: true });
+            _this.props.onMouseOver({ event: event, date: _this.getDateProp() });
+        };
+        _this.onMouseLeave = function (event) {
+            _this.setState({ isHovered: false });
+            _this.props.onMouseLeave({ event: event, date: _this.getDateProp() });
+        };
+        _this.isOutsideMonth = function () {
+            var month = _this.getMonthProp();
+            return month !== undefined && month !== _this.dateHelpers.getMonth(_this.getDateProp());
+        };
+        _this.getOrderedDates = function () {
+            var _a = _this.props, highlightedDate = _a.highlightedDate, value = _a.value;
+            if (!value || !Array.isArray(value) || !value[0] || (!value[1] && !highlightedDate)) {
+                return [];
+            }
+            var firstValue = value[0];
+            var secondValue = value.length > 1 && value[1] ? value[1] : highlightedDate;
+            if (!firstValue || !secondValue) {
+                return [];
+            }
+            var firstDate = _this.clampToDayStart(firstValue);
+            var secondDate = _this.clampToDayStart(secondValue);
+            return _this.dateHelpers.isAfter(firstDate, secondDate) ? [secondDate, firstDate] : [firstDate, secondDate];
+        };
+        _this.isOutsideOfMonthButWithinRange = function () {
+            var date = _this.clampToDayStart(_this.getDateProp());
+            var dates = _this.getOrderedDates();
+            if (dates.length < 2 || _this.dateHelpers.isSameDay(dates[0], dates[1])) {
+                return false;
+            }
+            var day = _this.dateHelpers.getDate(date);
+            /**
+             * Empty days (no number label) at the beginning/end of the month should be included
+             * within the range if the last day of a month and the first day of the next month are
+             * within the range.
+             */
+            if (day > 15) {
+                var firstDayOfNextMonth = _this.clampToDayStart(_this.dateHelpers.addDays(_this.dateHelpers.getEndOfMonth(date), 1));
+                return (_this.dateHelpers.isOnOrBeforeDay(dates[0], _this.dateHelpers.getEndOfMonth(date)) &&
+                    _this.dateHelpers.isOnOrAfterDay(dates[1], firstDayOfNextMonth));
+            }
+            else {
+                var lastDayOfPreviousMonth = _this.clampToDayStart(_this.dateHelpers.subDays(_this.dateHelpers.getStartOfMonth(date), 1));
+                return (_this.dateHelpers.isOnOrAfterDay(dates[1], _this.dateHelpers.getStartOfMonth(date)) &&
+                    _this.dateHelpers.isOnOrBeforeDay(dates[0], lastDayOfPreviousMonth));
+            }
+        };
+        _this.clampToDayStart = function (dt) {
+            var _a = _this.dateHelpers, setSeconds = _a.setSeconds, setMinutes = _a.setMinutes, setHours = _a.setHours;
+            return setSeconds(setMinutes(setHours(dt, 0), 0), 0);
+        };
+        _this.dateHelpers = new date_helpers_1.default(props.adapter);
+        return _this;
+    }
+    Day.prototype.componentDidMount = function () {
+        if (this.dayElm && this.props.focusedCalendar) {
+            if (this.props.highlighted || (!this.props.highlightedDate && this.isSelected())) {
+                this.dayElm.focus();
+            }
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Day.prototype.componentDidUpdate = function (prevProps) {
+        if (this.dayElm && this.props.focusedCalendar) {
+            if (this.props.highlighted || (!this.props.highlightedDate && this.isSelected())) {
+                this.dayElm.focus();
+            }
+        }
+    };
+    Day.prototype.isSelected = function () {
+        var date = this.getDateProp();
+        var value = this.props.value;
+        if (Array.isArray(value)) {
+            return this.dateHelpers.isSameDay(date, value[0]) || this.dateHelpers.isSameDay(date, value[1]);
+        }
+        else {
+            return this.dateHelpers.isSameDay(date, value);
+        }
+    };
+    // calculated for range case only
+    Day.prototype.isPseudoSelected = function () {
+        var date = this.getDateProp();
+        var value = this.props.value;
+        if (Array.isArray(value)) {
+            var _a = (0, tslib_1.__read)(value, 2), start = _a[0], end = _a[1];
+            if (!start && !end) {
+                return false;
+            }
+            if (start && end) {
+                return this.dateHelpers.isDayInRange(date, start, end);
+            }
+        }
+    };
+    // calculated for range case only
+    Day.prototype.isPseudoHighlighted = function () {
+        var date = this.getDateProp();
+        var _a = this.props, value = _a.value, highlightedDate = _a.highlightedDate;
+        if (Array.isArray(value)) {
+            var _b = (0, tslib_1.__read)(value, 2), start = _b[0], end = _b[1];
+            if (!start && !end) {
+                return false;
+            }
+            if (highlightedDate && start && !end) {
+                if (this.dateHelpers.isAfter(highlightedDate, start)) {
+                    return this.dateHelpers.isDayInRange(this.clampToDayStart(date), this.clampToDayStart(start), this.clampToDayStart(highlightedDate));
+                }
+                else {
+                    return this.dateHelpers.isDayInRange(this.clampToDayStart(date), this.clampToDayStart(highlightedDate), this.clampToDayStart(start));
+                }
+            }
+            if (highlightedDate && !start && end) {
+                if (this.dateHelpers.isAfter(highlightedDate, end)) {
+                    return this.dateHelpers.isDayInRange(this.clampToDayStart(date), this.clampToDayStart(end), this.clampToDayStart(highlightedDate));
+                }
+                else {
+                    return this.dateHelpers.isDayInRange(this.clampToDayStart(date), this.clampToDayStart(highlightedDate), this.clampToDayStart(end));
+                }
+            }
+        }
+    };
+    Day.prototype.getSharedProps = function () {
+        var date = this.getDateProp();
+        var _a = this.props, value = _a.value, highlightedDate = _a.highlightedDate, range = _a.range, highlighted = _a.highlighted, peekNextMonth = _a.peekNextMonth;
+        var $isHighlighted = highlighted;
+        var $selected = this.isSelected();
+        var $hasRangeHighlighted = !!(Array.isArray(value) &&
+            range &&
+            highlightedDate &&
+            ((value[0] && !value[1] && !this.dateHelpers.isSameDay(value[0], highlightedDate)) ||
+                (!value[0] && value[1] && !this.dateHelpers.isSameDay(value[1], highlightedDate))));
+        var $outsideMonth = !peekNextMonth && this.isOutsideMonth();
+        var $outsideMonthWithinRange = !!(Array.isArray(value) &&
+            range &&
+            $outsideMonth &&
+            !peekNextMonth &&
+            this.isOutsideOfMonthButWithinRange());
+        return {
+            $date: date,
+            $density: this.props.density,
+            $disabled: this.props.disabled,
+            $endDate: (Array.isArray(value) &&
+                !!(value[0] && value[1]) &&
+                range &&
+                $selected &&
+                this.dateHelpers.isSameDay(date, value[1])) ||
+                false,
+            $hasDateLabel: !!this.props.dateLabel,
+            $hasRangeHighlighted: $hasRangeHighlighted,
+            $hasRangeOnRight: Array.isArray(value) &&
+                $hasRangeHighlighted &&
+                highlightedDate &&
+                ((value[0] && this.dateHelpers.isAfter(highlightedDate, value[0])) ||
+                    (value[1] && this.dateHelpers.isAfter(highlightedDate, value[1]))),
+            $hasRangeSelected: Array.isArray(value) ? !!(value[0] && value[1]) : false,
+            $highlightedDate: highlightedDate,
+            $isHighlighted: $isHighlighted,
+            $isHovered: this.state.isHovered,
+            $isFocusVisible: this.state.isFocusVisible,
+            $startOfMonth: this.dateHelpers.isStartOfMonth(date),
+            $endOfMonth: this.dateHelpers.isEndOfMonth(date),
+            $month: this.getMonthProp(),
+            $outsideMonth: $outsideMonth,
+            $outsideMonthWithinRange: $outsideMonthWithinRange,
+            $peekNextMonth: peekNextMonth,
+            $pseudoHighlighted: range && !$isHighlighted && !$selected ? this.isPseudoHighlighted() : false,
+            $pseudoSelected: range && !$selected ? this.isPseudoSelected() : false,
+            $range: range,
+            $selected: $selected,
+            $startDate: Array.isArray(value) && value[0] && value[1] && range && $selected
+                ? this.dateHelpers.isSameDay(date, value[0])
+                : false,
+            $hasLockedBehavior: this.props.hasLockedBehavior,
+            $selectedInput: this.props.selectedInput,
+            $value: this.props.value,
+        };
+    };
+    Day.prototype.getAriaLabel = function (sharedProps, localeContext) {
+        var date = this.getDateProp();
+        return "".concat(sharedProps.$selected
+            ? sharedProps.$range
+                ? sharedProps.$endDate
+                    ? localeContext.datepicker.selectedEndDateLabel
+                    : localeContext.datepicker.selectedStartDateLabel
+                : localeContext.datepicker.selectedLabel
+            : sharedProps.$disabled
+                ? localeContext.datepicker.dateNotAvailableLabel
+                : localeContext.datepicker.chooseLabel, " ").concat(this.dateHelpers.format(date, 'fullOrdinalWeek', this.props.locale), ". ").concat(!sharedProps.$disabled ? localeContext.datepicker.dateAvailableLabel : '');
+    };
+    Day.prototype.render = function () {
+        var _this = this;
+        var date = this.getDateProp();
+        var _a = this.props, peekNextMonth = _a.peekNextMonth, _b = _a.overrides, overrides = _b === void 0 ? {} : _b;
+        var sharedProps = this.getSharedProps();
+        var _c = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.Day, styled_components_1.StyledDay), 2), Day = _c[0], dayProps = _c[1];
+        var _d = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.DayLabel, styled_components_1.StyledDayLabel), 2), DayLabel = _d[0], dayLabelProps = _d[1];
+        var dateLabel = this.props.dateLabel && this.props.dateLabel(date);
+        return !peekNextMonth && sharedProps.$outsideMonth ? ((0, jsx_runtime_1.jsx)(Day, (0, tslib_1.__assign)({ role: "gridcell" }, sharedProps, dayProps, { onFocus: this.onFocus, onBlur: this.onBlur }), void 0)) : (
+        // eslint-disable-next-line jsx-a11y/mouse-events-have-key-events
+        (0, jsx_runtime_1.jsx)(locale_1.LocaleContext.Consumer, { children: function (locale) { return ((0, jsx_runtime_1.jsxs)(Day, (0, tslib_1.__assign)({ "aria-label": _this.getAriaLabel(sharedProps, locale), 
+                // @ts-ignore
+                ref: function (dayElm) {
+                    _this.dayElm = dayElm;
+                }, role: "gridcell", "aria-roledescription": "button", tabIndex: _this.props.highlighted || (!_this.props.highlightedDate && _this.isSelected()) ? 0 : -1 }, sharedProps, dayProps, { 
+                // Adding event handlers after customers overrides in order to
+                // make sure the components functions as expected
+                // We can extract the handlers from props overrides
+                // and call it along with internal handlers by creating an inline handler
+                onFocus: _this.onFocus, onBlur: _this.onBlur, onClick: _this.onClick, onKeyDown: _this.onKeyDown, onMouseOver: _this.onMouseOver, onMouseLeave: _this.onMouseLeave }, { children: [(0, jsx_runtime_1.jsx)("div", { children: _this.dateHelpers.getDate(date) }, void 0), dateLabel ? ((0, jsx_runtime_1.jsx)(DayLabel, (0, tslib_1.__assign)({}, sharedProps, dayLabelProps, { children: dateLabel }), void 0)) : null] }), void 0)); } }, void 0));
+    };
+    Day.defaultProps = {
+        disabled: false,
+        highlighted: false,
+        range: false,
+        adapter: date_fns_adapter_1.default,
+        onClick: function () { },
+        onSelect: function () { },
+        onFocus: function () { },
+        onBlur: function () { },
+        onMouseOver: function () { },
+        onMouseLeave: function () { },
+        overrides: {},
+        peekNextMonth: true,
+        // @ts-ignore
+        value: null,
+    };
+    return Day;
+}(React.Component));
+exports.default = Day;

package/baseui/datepicker/index.d.ts

@@ -0,0 +1,10 @@
+import type { SharedStyleProps } from './types';
+export { default as Calendar } from './calendar';
+export { formatDate } from './utils';
+export { DENSITY, ORIENTATION, RANGED_CALENDAR_BEHAVIOR, STATE_CHANGE_TYPE } from './constants';
+export * from './styled-components';
+export * from '../timepicker';
+export * from './types';
+export type { DatepickerLocale } from './locale';
+/** @deprecated use SharedStyleProps instead. To be removed in future versions.*/
+export declare type SharedStylePropsT = SharedStyleProps;

package/baseui/datepicker/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_CHANGE_TYPE = exports.RANGED_CALENDAR_BEHAVIOR = exports.ORIENTATION = exports.DENSITY = exports.formatDate = exports.Calendar = void 0;
+var tslib_1 = require("tslib");
+// export { default as StatefulContainer } from './stateful-container';
+var calendar_1 = require("./calendar");
+Object.defineProperty(exports, "Calendar", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(calendar_1).default; } });
+// export { default as StatefulCalendar } from './stateful-calendar';
+// export { default as Datepicker, default as DatePicker } from './datepicker';
+// export { default as StatefulDatepicker, default as StatefulDatePicker } from './stateful-datepicker';
+// Util functions
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "formatDate", { enumerable: true, get: function () { return utils_1.formatDate; } });
+// Constants
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "DENSITY", { enumerable: true, get: function () { return constants_1.DENSITY; } });
+Object.defineProperty(exports, "ORIENTATION", { enumerable: true, get: function () { return constants_1.ORIENTATION; } });
+Object.defineProperty(exports, "RANGED_CALENDAR_BEHAVIOR", { enumerable: true, get: function () { return constants_1.RANGED_CALENDAR_BEHAVIOR; } });
+Object.defineProperty(exports, "STATE_CHANGE_TYPE", { enumerable: true, get: function () { return constants_1.STATE_CHANGE_TYPE; } });
+// Styled elements
+(0, tslib_1.__exportStar)(require("./styled-components"), exports);
+// Dependency components and their types
+(0, tslib_1.__exportStar)(require("../timepicker"), exports);
+// export * from '../timezonepicker';
+// Flow
+(0, tslib_1.__exportStar)(require("./types"), exports);

package/baseui/datepicker/locale.d.ts

@@ -0,0 +1,65 @@
+export declare type DatepickerLocale = {
+    ariaLabel: string;
+    ariaLabelRange: string;
+    ariaLabelCalendar: string;
+    ariaRoleDescriptionCalendarMonth: string;
+    nextMonth: string;
+    previousMonth: string;
+    pastWeek: string;
+    pastMonth: string;
+    pastThreeMonths: string;
+    pastSixMonths: string;
+    pastYear: string;
+    pastTwoYears: string;
+    screenReaderMessageInput: string;
+    selectedDate: string;
+    selectedDateRange: string;
+    selectSecondDatePrompt: string;
+    quickSelectLabel: string;
+    quickSelectAriaLabel: string;
+    quickSelectPlaceholder: string;
+    timeSelectEndLabel: string;
+    timeSelectStartLabel: string;
+    timePickerAriaLabel12Hour: string;
+    timePickerAriaLabel24Hour: string;
+    timezonePickerAriaLabel: string;
+    selectedStartDateLabel: string;
+    selectedEndDateLabel: string;
+    dateNotAvailableLabel: string;
+    dateAvailableLabel: string;
+    selectedLabel: string;
+    chooseLabel: string;
+};
+declare const locale: {
+    ariaLabel: string;
+    ariaLabelRange: string;
+    ariaLabelCalendar: string;
+    ariaRoleDescriptionCalendarMonth: string;
+    previousMonth: string;
+    nextMonth: string;
+    pastWeek: string;
+    pastMonth: string;
+    pastThreeMonths: string;
+    pastSixMonths: string;
+    pastYear: string;
+    pastTwoYears: string;
+    screenReaderMessageInput: string;
+    selectedDate: string;
+    selectedDateRange: string;
+    selectSecondDatePrompt: string;
+    quickSelectLabel: string;
+    quickSelectAriaLabel: string;
+    quickSelectPlaceholder: string;
+    timeSelectEndLabel: string;
+    timeSelectStartLabel: string;
+    timePickerAriaLabel12Hour: string;
+    timePickerAriaLabel24Hour: string;
+    timezonePickerAriaLabel: string;
+    selectedStartDateLabel: string;
+    selectedEndDateLabel: string;
+    dateNotAvailableLabel: string;
+    dateAvailableLabel: string;
+    selectedLabel: string;
+    chooseLabel: string;
+};
+export default locale;

package/baseui/datepicker/locale.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var locale = {
+    ariaLabel: 'Select a date.',
+    ariaLabelRange: 'Select a date range.',
+    ariaLabelCalendar: 'Calendar.',
+    ariaRoleDescriptionCalendarMonth: 'Calendar month',
+    previousMonth: 'Previous month.',
+    nextMonth: 'Next month.',
+    pastWeek: 'Past Week',
+    pastMonth: 'Past Month',
+    pastThreeMonths: 'Past 3 Months',
+    pastSixMonths: 'Past 6 Months',
+    pastYear: 'Past Year',
+    pastTwoYears: 'Past 2 Years',
+    screenReaderMessageInput: 'Date format is ${formatString}. Press the down arrow or enter key to interact with the calendar and select a date. Press the escape button to close the calendar.',
+    selectedDate: 'Selected date is ${date}.',
+    selectedDateRange: 'Selected date range is from ${startDate} to ${endDate}.',
+    selectSecondDatePrompt: 'Select the second date.',
+    quickSelectLabel: 'Choose a date range',
+    quickSelectAriaLabel: 'Choose a date range',
+    quickSelectPlaceholder: 'None',
+    timeSelectEndLabel: 'End time',
+    timeSelectStartLabel: 'Start time',
+    timePickerAriaLabel12Hour: 'Select a time, 12-hour format.',
+    timePickerAriaLabel24Hour: 'Select a time, 24-hour format.',
+    timezonePickerAriaLabel: 'Select a timezone.',
+    selectedStartDateLabel: 'Selected start date.',
+    selectedEndDateLabel: 'Selected end date.',
+    dateNotAvailableLabel: 'Not available.',
+    dateAvailableLabel: "It's available.",
+    selectedLabel: 'Selected.',
+    chooseLabel: 'Choose',
+};
+exports.default = locale;

package/baseui/datepicker/month.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import DateHelpers from './utils/date-helpers';
+import type { MonthProps } from './types';
+export default class CalendarMonth<T = Date> extends React.Component<MonthProps<T>> {
+    static defaultProps: {
+        dateLabel: null;
+        density: "high";
+        excludeDates: null;
+        filterDate: null;
+        highlightDates: null;
+        includeDates: null;
+        locale: null;
+        maxDate: null;
+        minDate: null;
+        month: null;
+        adapter: import("./utils/types").DateIOAdapter<Date>;
+        onDayClick: () => void;
+        onDayFocus: () => void;
+        onDayBlur: () => void;
+        onDayMouseOver: () => void;
+        onDayMouseLeave: () => void;
+        overrides: {};
+        peekNextMonth: boolean;
+        value: null;
+    };
+    dateHelpers: DateHelpers<T>;
+    constructor(props: MonthProps<T>);
+    getDateProp: () => T;
+    isWeekInMonth: (a: T) => boolean;
+    renderWeeks: () => never[];
+    render(): import("react/jsx-runtime").JSX.Element;
+}