@sprinklrjs/spaceweb 11.0.0 → 12.0.0-ci.0

package/baseui/datepicker/calendar.d.ts

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import type { DateIOAdapter } from './utils/types';
+import DateHelpers from './utils/date-helpers';
+import type { CalendarProps, CalendarInternalState } from './types';
+export default class Calendar<T = Date> extends React.Component<CalendarProps<T>, CalendarInternalState<T>> {
+    static defaultProps: CalendarProps<unknown> & {
+        adapter: DateIOAdapter<Date>;
+    };
+    dateHelpers: DateHelpers<T>;
+    calendar: HTMLElement;
+    constructor(props: CalendarProps<T>);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: CalendarProps<T>): void;
+    isInView(date: T): boolean;
+    getSingleDate(value: T | undefined | null | Array<T | undefined | null>): T | undefined | null;
+    getDateInView: () => T;
+    handleMonthChange: (a: T) => void;
+    handleYearChange: (a: T) => void;
+    changeMonth: (a: {
+        date: T;
+    }) => unknown;
+    changeYear: (a: {
+        date: T;
+    }) => unknown;
+    renderCalendarHeader: (b: T, a: number) => React.ReactNode;
+    onKeyDown: (event: KeyboardEvent) => void;
+    handleArrowKey: (key: string) => void;
+    focusCalendar: () => void;
+    blurCalendar: () => void;
+    handleTabbing: (event: KeyboardEvent) => void;
+    onDayFocus: (a: {
+        event: Event;
+        date: T;
+    }) => unknown;
+    onDayMouseOver: (a: {
+        event: Event;
+        date: T;
+    }) => unknown;
+    onDayMouseLeave: (a: {
+        event: Event;
+        date: T;
+    }) => unknown;
+    /** Responsible for merging time values into date values. Note: the 'Day' component
+     * determines how the days themselves change when a new day is selected. */
+    handleDateChange: (a: {
+        readonly date: T | undefined | null | Array<T | undefined | null>;
+    }) => void;
+    handleTimeChange: (time: T, index: number) => void;
+    setHighlightedDate(date: T): void;
+    renderMonths: () => import("react/jsx-runtime").JSX.Element;
+    renderTimeSelect: () => React.ReactNode;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/baseui/datepicker/calendar.js

@@ -0,0 +1,401 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+var react_1 = require("react");
+/*
+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 noop_1 = (0, tslib_1.__importDefault)(require("lodash/noop"));
+var calendar_header_1 = (0, tslib_1.__importDefault)(require("./calendar-header"));
+var month_1 = (0, tslib_1.__importDefault)(require("./month"));
+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 constants_1 = require("./constants");
+var spacewebProvider_1 = require("../../spacewebProvider");
+var Calendar = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Calendar, _super);
+    function Calendar(props) {
+        var _this = _super.call(this, props) || this;
+        _this.getDateInView = function () {
+            var _a = _this.props, highlightedDate = _a.highlightedDate, value = _a.value;
+            // @ts-ignore
+            var minDate = _this.dateHelpers.getEffectiveMinDate(_this.props);
+            // @ts-ignore
+            var maxDate = _this.dateHelpers.getEffectiveMaxDate(_this.props);
+            var current = _this.dateHelpers.date();
+            var initialDate = _this.getSingleDate(value) || highlightedDate;
+            if (initialDate) {
+                return initialDate;
+            }
+            if (minDate && _this.dateHelpers.isBefore(current, minDate)) {
+                return minDate;
+            }
+            if (maxDate && _this.dateHelpers.isAfter(current, maxDate)) {
+                return maxDate;
+            }
+            return current;
+        };
+        _this.handleMonthChange = function (date) {
+            _this.setHighlightedDate(_this.dateHelpers.getStartOfMonth(date));
+            if (_this.props.onMonthChange) {
+                _this.props.onMonthChange({ date: date });
+            }
+        };
+        _this.handleYearChange = function (date) {
+            _this.setHighlightedDate(date);
+            if (_this.props.onYearChange) {
+                _this.props.onYearChange({ date: date });
+            }
+        };
+        _this.changeMonth = function (_a) {
+            var date = _a.date;
+            _this.setState({ date: date }, function () { return _this.handleMonthChange(_this.state.date); });
+        };
+        _this.changeYear = function (_a) {
+            var date = _a.date;
+            _this.setState({ date: date }, function () { return _this.handleYearChange(_this.state.date); });
+        };
+        _this.renderCalendarHeader = function (date, order) {
+            if (date === void 0) { date = _this.state.date; }
+            return ((0, react_1.createElement)(calendar_header_1.default, (0, tslib_1.__assign)({}, _this.props, { key: "month-header-".concat(order), date: date, order: order, onMonthChange: _this.changeMonth, onYearChange: _this.changeYear })));
+        };
+        _this.onKeyDown = function (event) {
+            switch (event.key) {
+                case 'ArrowUp':
+                case 'ArrowDown':
+                case 'ArrowLeft':
+                case 'ArrowRight':
+                case 'Home':
+                case 'End':
+                case 'PageUp':
+                case 'PageDown':
+                    _this.handleArrowKey(event.key);
+                    event.preventDefault();
+                    event.stopPropagation();
+                    break;
+                default:
+                    break;
+            }
+        };
+        _this.handleArrowKey = function (key) {
+            var oldDate = _this.state.highlightedDate;
+            var highlightedDate = oldDate;
+            var currentDate = _this.dateHelpers.date();
+            switch (key) {
+                case 'ArrowLeft':
+                    // adding `new Date()` as the last option to satisfy Flow
+                    highlightedDate = _this.dateHelpers.subDays(highlightedDate || currentDate, 1);
+                    break;
+                case 'ArrowRight':
+                    highlightedDate = _this.dateHelpers.addDays(
+                    // adding `new Date()` as the last option to satisfy Flow
+                    highlightedDate || currentDate, 1);
+                    break;
+                case 'ArrowUp':
+                    highlightedDate = _this.dateHelpers.subWeeks(
+                    // adding `new Date()` as the last option to satisfy Flow
+                    highlightedDate || currentDate, 1);
+                    break;
+                case 'ArrowDown':
+                    highlightedDate = _this.dateHelpers.addWeeks(
+                    // adding `new Date()` as the last option to satisfy Flow
+                    highlightedDate || currentDate, 1);
+                    break;
+                case 'Home':
+                    highlightedDate = _this.dateHelpers.getStartOfWeek(
+                    // adding `new Date()` as the last option to satisfy Flow
+                    highlightedDate || currentDate);
+                    break;
+                case 'End':
+                    highlightedDate = _this.dateHelpers.getEndOfWeek(
+                    // adding `new Date()` as the last option to satisfy Flow
+                    highlightedDate || currentDate);
+                    break;
+                case 'PageUp':
+                    highlightedDate = _this.dateHelpers.subMonths(
+                    // adding `new Date()` as the last option to satisfy Flow
+                    highlightedDate || currentDate, 1);
+                    break;
+                case 'PageDown':
+                    highlightedDate = _this.dateHelpers.addMonths(
+                    // adding `new Date()` as the last option to satisfy Flow
+                    highlightedDate || currentDate, 1);
+                    break;
+                default:
+                    break;
+            }
+            _this.setState({ highlightedDate: highlightedDate, date: highlightedDate });
+        };
+        _this.focusCalendar = function () {
+            if (!_this.state.focused) {
+                _this.setState({ focused: true });
+            }
+        };
+        _this.blurCalendar = function () {
+            if (!spacewebProvider_1.isServer) {
+                var activeElm = document.activeElement;
+                if (_this.calendar && !_this.calendar.contains(activeElm)) {
+                    _this.setState({ focused: false });
+                }
+            }
+        };
+        _this.handleTabbing = function (event) {
+            if (!spacewebProvider_1.isServer) {
+                if (event.keyCode === 9) {
+                    var activeElm = document.activeElement;
+                    // need to look for any tabindex >= 0 and ideally for not disabled
+                    // focusable by default elements like input, button, etc.
+                    var focusable = _this.state.rootElement
+                        ? _this.state.rootElement.querySelectorAll('[tabindex="0"]')
+                        : null;
+                    var length_1 = focusable ? focusable.length : 0;
+                    if (event.shiftKey) {
+                        if (focusable && activeElm === focusable[0]) {
+                            event.preventDefault();
+                            focusable[length_1 - 1].focus();
+                        }
+                    }
+                    else if (focusable && activeElm === focusable[length_1 - 1]) {
+                        event.preventDefault();
+                        focusable[0].focus();
+                    }
+                }
+            }
+        };
+        _this.onDayFocus = function (data) {
+            var date = data.date;
+            _this.setState({ highlightedDate: date });
+            _this.focusCalendar();
+            _this.props.onDayFocus && _this.props.onDayFocus(data);
+        };
+        _this.onDayMouseOver = function (data) {
+            var date = data.date;
+            _this.setState({ highlightedDate: date });
+            _this.props.onDayMouseOver && _this.props.onDayMouseOver(data);
+        };
+        _this.onDayMouseLeave = function (data) {
+            var date = data.date;
+            var value = _this.props.value;
+            var selected = _this.getSingleDate(value);
+            _this.setState({ highlightedDate: selected || date });
+            _this.props.onDayMouseLeave && _this.props.onDayMouseLeave(data);
+        };
+        /** Responsible for merging time values into date values. Note: the 'Day' component
+         * determines how the days themselves change when a new day is selected. */
+        _this.handleDateChange = function (data) {
+            var _a = _this.props.onChange, onChange = _a === void 0 ? noop_1.default : _a;
+            var updatedDate = data.date;
+            // Apply the currently selected time values (saved in state) to the updated date
+            if (Array.isArray(data.date)) {
+                // We'll need to update the date in time values of internal state
+                // eslint-disable-next-line react/no-access-state-in-setstate -- baseui migration
+                var newTimeState = (0, tslib_1.__spreadArray)([], (0, tslib_1.__read)(_this.state.time), false);
+                var start = data.date[0] ? _this.dateHelpers.applyDateToTime(newTimeState[0], data.date[0]) : null;
+                var end = data.date[1] ? _this.dateHelpers.applyDateToTime(newTimeState[1], data.date[1]) : null;
+                newTimeState[0] = start;
+                if (end) {
+                    updatedDate = [start, end];
+                    newTimeState[1] = end;
+                }
+                else {
+                    updatedDate = [start];
+                }
+                // Update the date in time values of internal state
+                _this.setState({ time: newTimeState });
+            }
+            else if (!Array.isArray(_this.props.value) && data.date) {
+                var newTimeState = _this.dateHelpers.applyDateToTime(_this.state.time[0], data.date);
+                updatedDate = newTimeState;
+                // Update the date in time values of internal state
+                _this.setState({ time: [newTimeState] });
+            }
+            onChange({ date: updatedDate });
+        };
+        _this.handleTimeChange = function (time, index) {
+            var _a = _this.props.onChange, onChange = _a === void 0 ? noop_1.default : _a;
+            // Save/update the time value in internal state
+            // eslint-disable-next-line react/no-access-state-in-setstate -- baseui migration
+            var newTimeState = (0, tslib_1.__spreadArray)([], (0, tslib_1.__read)(_this.state.time), false);
+            newTimeState[index] = _this.dateHelpers.applyTimeToDate(newTimeState[index], time);
+            _this.setState({ time: newTimeState });
+            // Time change calls calendar's onChange handler
+            // with the date value set to the date with updated time
+            if (Array.isArray(_this.props.value)) {
+                var dates = _this.props.value.map(function (date, i) {
+                    if (date && index === i) {
+                        return _this.dateHelpers.applyTimeToDate(date, time);
+                    }
+                    return date;
+                });
+                onChange({ date: [dates[0], dates[1]] });
+            }
+            else {
+                var date = _this.dateHelpers.applyTimeToDate(_this.props.value, time);
+                onChange({ date: date });
+            }
+        };
+        _this.renderMonths = function () {
+            var _a = _this.props, _b = _a.overrides, overrides = _b === void 0 ? {} : _b, orientation = _a.orientation;
+            var monthList = [];
+            var _c = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.CalendarContainer, styled_components_1.StyledCalendarContainer), 2), CalendarContainer = _c[0], calendarContainerProps = _c[1];
+            var _d = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.MonthContainer, styled_components_1.StyledMonthContainer), 2), MonthContainer = _d[0], monthContainerProps = _d[1];
+            for (var i = 0; i < (_this.props.monthsShown || 1); i += 1) {
+                var monthSubComponents = [];
+                var monthDate = _this.dateHelpers.addMonths(_this.state.date, i);
+                var monthKey = "month-".concat(i);
+                // @ts-ignore
+                monthSubComponents.push(_this.renderCalendarHeader(monthDate, i));
+                monthSubComponents.push(
+                // @ts-ignore
+                (0, jsx_runtime_1.jsx)(CalendarContainer, (0, tslib_1.__assign)({ 
+                    // @ts-ignore
+                    ref: function (calendar) {
+                        _this.calendar = calendar;
+                    }, role: "grid", "aria-multiselectable": _this.props.range || null, onKeyDown: _this.onKeyDown }, calendarContainerProps, { "$density": _this.props.density }, { children: (0, jsx_runtime_1.jsx)(month_1.default, { adapter: _this.props.adapter, date: monthDate, dateLabel: _this.props.dateLabel, density: _this.props.density, excludeDates: _this.props.excludeDates, filterDate: _this.props.filterDate, getTimeRangesForDate: _this.props.getTimeRangesForDate, highlightedDate: _this.state.highlightedDate, includeDates: _this.props.includeDates, focusedCalendar: _this.state.focused, range: _this.props.range, locale: _this.props.locale, maxDate: _this.props.maxDate, minDate: _this.props.minDate, month: _this.dateHelpers.getMonth(_this.state.date), onDayBlur: _this.blurCalendar, onDayFocus: _this.onDayFocus, onDayClick: _this.props.onDayClick, onDayMouseOver: _this.onDayMouseOver, onDayMouseLeave: _this.onDayMouseLeave, onChange: _this.handleDateChange, overrides: overrides, value: _this.props.value, peekNextMonth: _this.props.peekNextMonth, fixedHeight: _this.props.fixedHeight, hasLockedBehavior: !!_this.props.hasLockedBehavior, selectedInput: _this.props.selectedInput }, void 0) }), monthKey));
+                // @ts-ignore
+                monthList.push((0, jsx_runtime_1.jsx)("div", { children: monthSubComponents }, "month-component-".concat(i)));
+            }
+            return ((0, jsx_runtime_1.jsx)(MonthContainer, (0, tslib_1.__assign)({ "$orientation": orientation }, monthContainerProps, { children: monthList }), void 0));
+        };
+        _this.renderTimeSelect = function () {
+            var _a = _this.props.overrides, overrides = _a === void 0 ? {} : _a;
+            var _b = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.TimeSelectContainer, styled_components_1.StyledSelectorContainer), 2), TimeSelectContainer = _b[0], timeSelectContainerProps = _b[1];
+            return (0, jsx_runtime_1.jsx)(TimeSelectContainer, (0, tslib_1.__assign)({}, timeSelectContainerProps), void 0);
+        };
+        var _a = _this.props, highlightedDate = _a.highlightedDate, value = _a.value, adapter = _a.adapter;
+        // @ts-ignore
+        _this.dateHelpers = new date_helpers_1.default(adapter);
+        var dateInView = _this.getDateInView();
+        // @ts-ignore
+        var time = [];
+        if (Array.isArray(value)) {
+            // @ts-ignore
+            time = (0, tslib_1.__spreadArray)([], (0, tslib_1.__read)(value), false);
+        }
+        else if (value) {
+            // @ts-ignore
+            time = [value];
+        }
+        _this.state = {
+            highlightedDate: _this.getSingleDate(value) ||
+                (highlightedDate && _this.dateHelpers.isSameMonth(dateInView, highlightedDate)
+                    ? highlightedDate
+                    : _this.dateHelpers.date()),
+            focused: false,
+            date: dateInView,
+            rootElement: null,
+            // @ts-ignore
+            time: time,
+        };
+        return _this;
+    }
+    Calendar.prototype.componentDidMount = function () {
+        if (this.props.autoFocusCalendar) {
+            this.focusCalendar();
+        }
+    };
+    Calendar.prototype.componentDidUpdate = function (prevProps) {
+        if (this.props.highlightedDate &&
+            !this.dateHelpers.isSameDay(this.props.highlightedDate, prevProps.highlightedDate)) {
+            // eslint-disable-next-line react/no-did-update-set-state -- baseui migration
+            this.setState({
+                date: this.props.highlightedDate,
+            });
+        }
+        if (this.props.autoFocusCalendar && this.props.autoFocusCalendar !== prevProps.autoFocusCalendar) {
+            this.focusCalendar();
+        }
+        if (prevProps.value !== this.props.value) {
+            var nextDate = this.getDateInView();
+            if (!this.isInView(nextDate)) {
+                // eslint-disable-next-line react/no-did-update-set-state -- baseui migration
+                this.setState({
+                    date: nextDate,
+                });
+            }
+        }
+    };
+    Calendar.prototype.isInView = function (date) {
+        // we calculate the month delta between the date arg and the date in the state.
+        var currentDate = this.state.date;
+        // First we get the year delta
+        var yearDelta = this.dateHelpers.getYear(date) - this.dateHelpers.getYear(currentDate);
+        // then we convert it to months. Then we simply add the date-without-year month delta back in.
+        var monthDelta = yearDelta * 12 + this.dateHelpers.getMonth(date) - this.dateHelpers.getMonth(currentDate);
+        // we just check that the delta is between the range given by "this month" (i.e. 0) and "the last month" (i.e. monthsShown)
+        return monthDelta >= 0 && monthDelta < (this.props.monthsShown || 1);
+    };
+    // eslint-disable-next-line class-methods-use-this -- baseui migration
+    Calendar.prototype.getSingleDate = function (value) {
+        // need to check this.props.range but flow would complain
+        // at the return value in the else clause
+        if (Array.isArray(value)) {
+            return value[0] || null;
+        }
+        return value;
+    };
+    Calendar.prototype.setHighlightedDate = function (date) {
+        var value = this.props.value;
+        var selected = this.getSingleDate(value);
+        var nextState;
+        if (selected && this.dateHelpers.isSameMonth(selected, date) && this.dateHelpers.isSameYear(selected, date)) {
+            nextState = { highlightedDate: selected };
+        }
+        else {
+            nextState = {
+                highlightedDate: date,
+            };
+        }
+        this.setState(nextState);
+    };
+    Calendar.prototype.render = function () {
+        var _this = this;
+        var _a = this.props.overrides, overrides = _a === void 0 ? {} : _a;
+        var _b = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.Root, styled_components_1.StyledRoot), 2), Root = _b[0], rootProps = _b[1];
+        // @ts-ignore
+        var _c = (0, tslib_1.__read)([].concat(this.props.value), 2), startDate = _c[0], endDate = _c[1];
+        return ((0, jsx_runtime_1.jsxs)(Root, (0, tslib_1.__assign)({ "$density": this.props.density, "data-baseweb": "calendar", role: "application", "aria-roledescription": "date picker", 
+            // @ts-ignore
+            ref: function (root) {
+                if (root && root instanceof HTMLElement && !_this.state.rootElement) {
+                    _this.setState({ rootElement: root });
+                }
+            }, onKeyDown: this.props.trapTabbing ? this.handleTabbing : null }, rootProps, { children: [this.renderMonths(), this.props.timeSelectStart && this.renderTimeSelect(), this.props.timeSelectEnd && this.props.range && this.renderTimeSelect()] }), void 0));
+    };
+    Calendar.defaultProps = {
+        autoFocusCalendar: false,
+        dateLabel: null,
+        density: constants_1.DENSITY.default,
+        excludeDates: null,
+        filterDate: null,
+        highlightedDate: null,
+        includeDates: null,
+        range: false,
+        locale: null,
+        maxDate: null,
+        minDate: null,
+        onDayClick: noop_1.default,
+        onDayFocus: noop_1.default,
+        onDayMouseOver: noop_1.default,
+        onDayMouseLeave: noop_1.default,
+        onMonthChange: noop_1.default,
+        onYearChange: noop_1.default,
+        onChange: noop_1.default,
+        orientation: constants_1.ORIENTATION.horizontal,
+        overrides: {},
+        peekNextMonth: false,
+        // @ts-ignore
+        adapter: date_fns_adapter_1.default,
+        value: null,
+        trapTabbing: false,
+    };
+    return Calendar;
+}(React.Component));
+exports.default = Calendar;

package/baseui/datepicker/constants.d.ts

@@ -0,0 +1,30 @@
+export declare const DISPLAY_FORMAT = "L";
+export declare const ISO_FORMAT = "YYYY-MM-DD";
+export declare const ISO_MONTH_FORMAT = "YYYY-MM";
+export declare const ORIENTATION: Readonly<{
+    readonly horizontal: "horizontal";
+    readonly vertical: "vertical";
+}>;
+export declare const STATE_CHANGE_TYPE: Readonly<{
+    readonly change: "change";
+    readonly moveUp: "moveUp";
+    readonly moveDown: "moveDown";
+    readonly moveLeft: "moveLeft";
+    readonly moveRight: "moveRight";
+    readonly mouseOver: "mouseOver";
+    readonly mouseLeave: "mouseLeave";
+}>;
+export declare const WEEKDAYS: number[];
+export declare const DEFAULT_MONTHS: number[];
+export declare const DENSITY: {
+    readonly high: "high";
+    readonly default: "default";
+};
+export declare const INPUT_ROLE: {
+    readonly startDate: "startDate";
+    readonly endDate: "endDate";
+};
+export declare const RANGED_CALENDAR_BEHAVIOR: {
+    readonly default: "default";
+    readonly locked: "locked";
+};

package/baseui/datepicker/constants.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANGED_CALENDAR_BEHAVIOR = exports.INPUT_ROLE = exports.DENSITY = exports.DEFAULT_MONTHS = exports.WEEKDAYS = exports.STATE_CHANGE_TYPE = exports.ORIENTATION = exports.ISO_MONTH_FORMAT = exports.ISO_FORMAT = exports.DISPLAY_FORMAT = void 0;
+/*
+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.
+*/
+exports.DISPLAY_FORMAT = 'L';
+exports.ISO_FORMAT = 'YYYY-MM-DD';
+exports.ISO_MONTH_FORMAT = 'YYYY-MM';
+exports.ORIENTATION = Object.freeze({
+    horizontal: 'horizontal',
+    vertical: 'vertical',
+});
+exports.STATE_CHANGE_TYPE = Object.freeze({
+    change: 'change',
+    moveUp: 'moveUp',
+    moveDown: 'moveDown',
+    moveLeft: 'moveLeft',
+    moveRight: 'moveRight',
+    mouseOver: 'mouseOver',
+    mouseLeave: 'mouseLeave',
+});
+exports.WEEKDAYS = [0, 1, 2, 3, 4, 5, 6];
+exports.DEFAULT_MONTHS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+exports.DENSITY = {
+    high: 'high',
+    default: 'default',
+};
+exports.INPUT_ROLE = {
+    startDate: 'startDate',
+    endDate: 'endDate',
+};
+exports.RANGED_CALENDAR_BEHAVIOR = {
+    default: 'default',
+    locked: 'locked',
+};

package/baseui/datepicker/day.d.ts

@@ -0,0 +1,86 @@
+import * as React from 'react';
+import DateHelpers from './utils/date-helpers';
+import type { DayProps, DayState } from './types';
+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;
+    }): string;
+    render(): import("react/jsx-runtime").JSX.Element;
+}