@sprinklrjs/spaceweb 11.0.0 → 12.0.0-ci.0

package/esm/baseui/datepicker/utils/calendar-header-helpers.js

@@ -0,0 +1,30 @@
+import { __assign } from "tslib";
+/*
+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.
+*/
+import { DEFAULT_MONTHS } from '../constants';
+var getDefaultMonthItems = function (formatMonthLabel) {
+    return DEFAULT_MONTHS.map(function (month) { return ({
+        id: month.toString(),
+        label: formatMonthLabel(month),
+    }); });
+};
+export var filterMonthItems = function (monthItems, filterList) {
+    return monthItems.map(function (month) {
+        if (!filterList.includes(Number(month.id))) {
+            return __assign(__assign({}, month), { disabled: true });
+        }
+        return month;
+    });
+};
+export var getFilteredMonthItems = function (_a) {
+    var filterMonthsList = _a.filterMonthsList, formatMonthLabel = _a.formatMonthLabel;
+    var monthItems = getDefaultMonthItems(formatMonthLabel);
+    if (filterMonthsList) {
+        monthItems = filterMonthItems(monthItems, filterMonthsList);
+    }
+    return monthItems;
+};

package/esm/baseui/datepicker/utils/date-fns-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { DateIOAdapter } from './types';
+declare const adapter: DateIOAdapter<Date>;
+export default adapter;

package/esm/baseui/datepicker/utils/date-fns-adapter.js

@@ -0,0 +1,10 @@
+/*
+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.
+*/
+import DateFnsUtils from '@date-io/date-fns';
+// @ts-expect-error todo(flow->ts) DateIOAdapter types is not exactly correct
+var adapter = new DateFnsUtils({});
+export default adapter;

package/esm/baseui/datepicker/utils/date-helpers.d.ts

@@ -0,0 +1,100 @@
+import type { DateIOAdapter, DateInput, AdapterOptions } from './types';
+import type { GetTimeRangesForDate } from '../types';
+declare class DateHelpers<T> {
+    adapter: DateIOAdapter<T>;
+    constructor(adapter: DateIOAdapter<T>);
+    cloneAdapter: (b: DateIOAdapter<T>, a?: ((a: AdapterOptions) => AdapterOptions) | null) => DateIOAdapter<T>;
+    format: (c: T, b: string, a?: any) => string;
+    getAdapterWithNewLocale: (a: unknown) => DateIOAdapter<T>;
+    date: (a: DateInput<T> | void) => T;
+    dateToSeconds: (a: T) => number;
+    secondsToHourMinute: (a: number) => [number, number];
+    differenceInCalendarMonths: (b: T, a: T) => number;
+    getStartOfWeek: (b: T, a?: any) => T;
+    formatDate: (c: T, b: string, a?: any) => string;
+    getWeekdayMinInLocale: (b: T, a: any) => string;
+    getMonthInLocale: (b: number, a: any) => string;
+    getWeekdayInLocale: (b: T, a: any) => string;
+    getQuarterInLocale: (b: number, a: any) => string;
+    getEndOfWeek: (a: T) => T;
+    getDay: (a: T) => number;
+    addWeeks: (b: T, a: number) => T;
+    subWeeks: (b: T, a: number) => T;
+    addYears: (b: T, a: number) => T;
+    subYears: (b: T, a: number) => T;
+    isSameYear: (b?: T | null, a?: T | null) => boolean;
+    isStartOfMonth: (a: T) => boolean;
+    isEndOfMonth: (a: T) => boolean;
+    isDayInRange: (c: T, b: T, a: T) => boolean;
+    isSameDay: (b?: T | null, a?: T | null) => boolean;
+    isSameMonth: (b?: T | null, a?: T | null) => boolean;
+    dateRangeIncludesDates: (b: Array<T | undefined | null>, a?: Array<T> | null) => boolean;
+    subDays: (b: T, a: number) => T;
+    subMonths: (b: T, a: number) => T;
+    min: (a: Array<T>) => T;
+    max: (a: Array<T>) => T;
+    getEffectiveMinDate: (a: {
+        minDate?: T | null;
+        includeDates?: Array<T>;
+    }) => T;
+    getEffectiveMaxDate: (a: {
+        maxDate?: T | null;
+        includeDates?: Array<T>;
+    }) => T;
+    monthDisabledBefore: (b: T, a: {
+        minDate?: T | undefined | null;
+        includeDates?: Array<T> | undefined | null;
+    }) => boolean;
+    monthDisabledAfter: (b: T, a: {
+        maxDate?: T | undefined | null;
+        includeDates?: Array<T> | undefined | null;
+    }) => boolean;
+    setDate: (b: T, a: number) => T;
+    getDate: (a: T) => number;
+    applyDateToTime: (b: T | undefined | null, a: T) => T;
+    applyTimeToDate: (b: T | undefined | null, a: T) => T;
+    isDayDisabled: (b: T, a: {
+        minDate?: T | undefined | null;
+        maxDate?: T | undefined | null;
+        excludeDates?: Array<T> | undefined | null;
+        includeDates?: Array<T> | undefined | null;
+        filterDate?: ((day: T) => boolean) | undefined | null;
+        getTimeRangesForDate?: GetTimeRangesForDate<T>;
+    }) => boolean;
+    isOnOrAfterDay: (b: T, a: T) => boolean;
+    isOnOrBeforeDay: (b: T, a: T) => boolean;
+    isOutOfBounds: (b: T, a: {
+        minDate?: T | undefined | null;
+        maxDate?: T | undefined | null;
+    }) => boolean;
+    parseString: (c: string, b: string, a?: any | null) => T;
+    parse: (c: string, b: string, a?: any | null) => T;
+    setMilliseconds: (b: T, a: number) => T;
+    set: (a: T, values: {
+        year?: number;
+        date?: number;
+        month?: number;
+        hours?: number;
+        minutes?: number;
+        seconds?: number;
+    }) => T;
+    getQuarter: (a: T) => number;
+    setSeconds: (b: T, a: number) => T;
+    setMinutes: (b: T, a: number) => T;
+    setHours: (b: T, a: number) => T;
+    setMonth: (b: T, a: number) => T;
+    setYear: (b: T, a: number) => T;
+    getMinutes: (a: T) => number;
+    getHours: (a: T) => number;
+    getMonth: (a: T) => number;
+    getYear: (a: T) => number;
+    getStartOfMonth: (a: T) => T;
+    getEndOfMonth: (a: T) => T;
+    addDays: (b: T, a: number) => T;
+    addMonths: (b: T, a: number) => T;
+    isBefore: (b: T, a: T) => boolean;
+    isAfter: (b: T, a: T) => boolean;
+    isEqual: (b: T, a: T) => boolean;
+    isValid: (a: unknown) => boolean;
+}
+export default DateHelpers;

package/esm/baseui/datepicker/utils/date-helpers.js

@@ -0,0 +1,327 @@
+import { __assign, __read } from "tslib";
+import { DISABLE_WHOLE_DAY } from '../../../date-picker/constants';
+var MINUTE = 60;
+var HOUR = MINUTE * 60;
+var checkDayDisabledFromFilter = function (day, getTimeRangesForDate) {
+    return (getTimeRangesForDate === null || getTimeRangesForDate === void 0 ? void 0 : getTimeRangesForDate(day)) === DISABLE_WHOLE_DAY;
+};
+var DateHelpers = /** @class */ (function () {
+    function DateHelpers(adapter) {
+        var _this = this;
+        this.cloneAdapter = function (adapter, updateOptionsBase) {
+            var adapterMap = {
+                // all utils classes set the arguments passed into their constructor as public members in some way
+                // it just varies by class, most just set formats and locale, but this handles the exceptions
+                MomentUtils: {
+                    formats: {
+                        monthNumber: 'M',
+                        dayOfMonthNumber: 'D',
+                        fullOrdinalWeek: 'dddd, MMMM Do YYYY',
+                        slashDate: 'YYYY/MM/DD',
+                        weekday: 'dddd',
+                        // moment does not have a similar 'single character' weekday format like the other libraries
+                        // the format below will only supply two character abbreviations.
+                        weekdaymin: 'dd',
+                        quarter: '[Q]Q',
+                    },
+                },
+                DateFnsUtils: {
+                    formats: {
+                        monthNumber: 'M',
+                        dayOfMonthNumber: 'd',
+                        weekday: 'EEEE',
+                        weekdaymin: 'EEEEEE',
+                        slashDate: 'yyyy/MM/dd',
+                        fullOrdinalWeek: 'EEEE, MMMM do yyyy',
+                        quarter: 'QQQ',
+                    },
+                },
+                LuxonUtils: {
+                    formats: {
+                        monthNumber: 'M',
+                        dayOfMonthNumber: 'd',
+                        weekday: 'EEEE',
+                        weekdaymin: 'EEEEE',
+                        slashDate: 'yyyy/MM/dd',
+                        fullOrdinalWeek: 'EEEE, MMMM dd yyyy',
+                        quarter: 'Qq',
+                    },
+                },
+            };
+            // @ts-ignore
+            var defaultGetOptions = function (instance) { return ({
+                formats: instance.formats,
+                locale: instance.locale,
+            }); };
+            var updateOptions = updateOptionsBase || defaultGetOptions;
+            var UtilsClass = adapter.constructor;
+            var className = adapter.constructor.name;
+            // This ensures that if the adapter class isn't
+            // supported it just falls back the default formats
+            // NOTE: in e2e tests playwright seems to add
+            // a JSHandle wrapping class to all objects
+            // so className always resolves to JSHandle:e
+            // and if falls back to the default
+            // if we want to test other adapter implementation
+            // in e2e tests down the road, we're going to have
+            // to figure that out
+            var _a = 
+            // @ts-ignore
+            adapterMap[className] || adapterMap.DateFnsUtils, _b = _a.getOptions, getOptions = _b === void 0 ? defaultGetOptions : _b, formats = _a.formats;
+            var options = getOptions(adapter);
+            return new UtilsClass(
+            // eslint-disable-next-line prefer-object-spread -- baseui migration
+            Object.assign({}, updateOptions(
+            // eslint-disable-next-line prefer-object-spread -- baseui migration
+            Object.assign({}, options, {
+                // eslint-disable-next-line prefer-object-spread -- baseui migration
+                formats: Object.assign({}, options.formats, formats),
+            }))));
+        };
+        this.format = function (date, format, locale) {
+            var adapter = locale ? _this.getAdapterWithNewLocale(locale) : _this.adapter;
+            return adapter.format(date, format);
+        };
+        this.getAdapterWithNewLocale = function (locale) {
+            return _this.cloneAdapter(_this.adapter, function (options) { return (__assign(__assign({}, options), { locale: locale })); });
+        };
+        this.date = function (date) { return _this.adapter.date(date); };
+        this.dateToSeconds = function (date) {
+            var seconds = _this.adapter.getSeconds(date);
+            var minutes = _this.adapter.getMinutes(date) * MINUTE;
+            var hours = _this.adapter.getHours(date) * HOUR;
+            return seconds + minutes + hours;
+        };
+        this.secondsToHourMinute = function (seconds) {
+            var d = _this.adapter.toJsDate(_this.adapter.date(seconds * 1000));
+            return [d.getUTCHours(), d.getUTCMinutes()];
+        };
+        this.differenceInCalendarMonths = function (fromDate, toDate) {
+            var yearDiff = _this.adapter.getYear(fromDate) - _this.adapter.getYear(toDate);
+            var monthDiff = _this.adapter.getMonth(fromDate) - _this.adapter.getMonth(toDate);
+            return yearDiff * 12 + monthDiff;
+        };
+        this.getStartOfWeek = function (date, locale) {
+            var adapter = locale ? _this.getAdapterWithNewLocale(locale) : _this.adapter;
+            // rewrapping this date here ensures that the locale will be taken into account in all adapters
+            return adapter.startOfWeek(adapter.date(date));
+        };
+        this.formatDate = function (date, formatString, locale) {
+            var adapter = locale ? _this.getAdapterWithNewLocale(locale) : _this.adapter;
+            return adapter.formatByString(date, formatString);
+        };
+        this.getWeekdayMinInLocale = function (date, locale) {
+            return _this.getAdapterWithNewLocale(locale).format(date, 'weekdaymin');
+        };
+        this.getMonthInLocale = function (monthNumber, locale) {
+            var localeAdapter = _this.getAdapterWithNewLocale(locale);
+            return localeAdapter.format(localeAdapter.setMonth(localeAdapter.date(), monthNumber), 'month');
+        };
+        this.getWeekdayInLocale = function (date, locale) {
+            return _this.getAdapterWithNewLocale(locale).format(date, 'weekday');
+        };
+        this.getQuarterInLocale = function (quarterNumber, locale) {
+            var localeAdapter = _this.getAdapterWithNewLocale(locale);
+            return localeAdapter.format(localeAdapter.setMonth(localeAdapter.date(), quarterNumber * 3), 'quarter');
+        };
+        this.getEndOfWeek = function (date) { return _this.adapter.endOfWeek(date); };
+        this.getDay = function (date) { return Number(_this.adapter.formatByString(date, 'e')) - 1; };
+        this.addWeeks = function (date, weekNumber) { return _this.adapter.addDays(date, weekNumber * 7); };
+        this.subWeeks = function (date, weekNumber) { return _this.addWeeks(date, weekNumber * -1); };
+        this.addYears = function (date, yearNumber) { return _this.adapter.addMonths(date, yearNumber * 12); };
+        this.subYears = function (date, yearNumber) { return _this.addYears(date, yearNumber * -1); };
+        this.isSameYear = function (fromDate, toDate) {
+            if (fromDate && toDate) {
+                return _this.adapter.isSameYear(fromDate, toDate);
+            }
+            return false;
+        };
+        this.isStartOfMonth = function (date) { return _this.adapter.isSameDay(date, _this.adapter.startOfMonth(date)); };
+        this.isEndOfMonth = function (date) { return _this.adapter.isSameDay(date, _this.adapter.endOfMonth(date)); };
+        this.isDayInRange = function (date, startDate, endDate) {
+            return _this.adapter.isWithinRange(date, [startDate, endDate]);
+        };
+        this.isSameDay = function (fromDate, toDate) {
+            if (fromDate && toDate) {
+                return _this.adapter.isSameDay(fromDate, toDate);
+            }
+            return false;
+        };
+        this.isSameMonth = function (fromDate, toDate) {
+            if (fromDate && toDate) {
+                return _this.adapter.isSameMonth(fromDate, toDate);
+            }
+            return false;
+        };
+        this.dateRangeIncludesDates = function (dateRange, dates) {
+            var _a = __read(dateRange, 2), startDate = _a[0], endDate = _a[1];
+            if (startDate && endDate && Array.isArray(dates) && dates.length) {
+                for (var i = 0; i < dates.length; i += 1) {
+                    var day = dates[i];
+                    if (_this.isDayInRange(day, startDate, endDate)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        this.subDays = function (date, days) { return _this.adapter.addDays(date, days * -1); };
+        this.subMonths = function (date, months) { return _this.adapter.addMonths(date, months * -1); };
+        this.min = function (dates) {
+            return dates.reduce(function (minDate, date) { return (_this.adapter.isBefore(date, minDate) ? date : minDate); });
+        };
+        this.max = function (dates) {
+            return dates.reduce(function (maxDate, date) { return (_this.adapter.isAfter(date, maxDate) ? date : maxDate); });
+        };
+        this.getEffectiveMinDate = function (_a) {
+            var minDate = _a.minDate, includeDates = _a.includeDates;
+            if (includeDates && minDate) {
+                var minDates = includeDates.filter(function (includeDate) { return _this.isOnOrAfterDay(includeDate, minDate); });
+                return _this.min(minDates);
+            }
+            else if (includeDates && includeDates.length) {
+                return _this.min(includeDates);
+            }
+            else if (!(includeDates && includeDates.length) && minDate) {
+                return minDate;
+            }
+            // this condition can't ever be reached
+            // but flow isn't smart enough to see that all of the conditions are covered
+            return _this.adapter.date();
+        };
+        this.getEffectiveMaxDate = function (_a) {
+            var maxDate = _a.maxDate, includeDates = _a.includeDates;
+            if (includeDates && maxDate) {
+                var maxDates = includeDates.filter(function (includeDate) { return _this.isOnOrBeforeDay(includeDate, maxDate); });
+                return _this.max(maxDates);
+            }
+            else if (includeDates) {
+                return _this.max(includeDates);
+            }
+            else if (!includeDates && maxDate) {
+                return maxDate;
+            }
+            // this condition can't ever be reached
+            // but flow isn't smart enough to see that all of the conditions are covered
+            return _this.adapter.date();
+        };
+        this.monthDisabledBefore = function (day, _a) {
+            var _b = _a === void 0 ? {} : _a, minDate = _b.minDate, includeDates = _b.includeDates;
+            var previousMonth = _this.subMonths(day, 1);
+            return ((!!minDate && _this.differenceInCalendarMonths(minDate, previousMonth) > 0) ||
+                (!!includeDates &&
+                    includeDates.every(function (includeDate) { return _this.differenceInCalendarMonths(includeDate, previousMonth) > 0; })) ||
+                false);
+        };
+        this.monthDisabledAfter = function (day, _a) {
+            var _b = _a === void 0 ? {} : _a, maxDate = _b.maxDate, includeDates = _b.includeDates;
+            var nextMonth = _this.adapter.addMonths(day, 1);
+            return ((!!maxDate && _this.differenceInCalendarMonths(nextMonth, maxDate) > 0) ||
+                (!!includeDates &&
+                    includeDates.every(function (includeDate) { return _this.differenceInCalendarMonths(nextMonth, includeDate) > 0; })) ||
+                false);
+        };
+        this.setDate = function (date, dayNumber) {
+            var startOfMonthNoTime = _this.adapter.startOfMonth(date);
+            var startOfMonthHoursAndMinutes = _this.adapter.mergeDateAndTime(startOfMonthNoTime, date);
+            var startOfMonth = _this.adapter.setSeconds(startOfMonthHoursAndMinutes, _this.adapter.getSeconds(date));
+            return _this.adapter.addDays(startOfMonth, dayNumber - 1);
+        };
+        this.getDate = function (date) { return Number(_this.adapter.format(date, 'dayOfMonthNumber')); };
+        this.applyDateToTime = function (time, date) {
+            if (!time)
+                return date;
+            var yearNumber = _this.adapter.getYear(date);
+            var monthNumber = _this.adapter.getMonth(date);
+            var dayNumber = _this.getDate(date);
+            var yearDate = _this.adapter.setYear(time, yearNumber);
+            var monthDate = _this.adapter.setMonth(yearDate, monthNumber);
+            return _this.setDate(monthDate, dayNumber);
+        };
+        this.applyTimeToDate = function (date, time) {
+            if (!date)
+                return time;
+            return _this.adapter.setSeconds(_this.adapter.mergeDateAndTime(date, time), 0);
+        };
+        this.isDayDisabled = function (day, _a) {
+            var _b = _a === void 0 ? {} : _a, minDate = _b.minDate, maxDate = _b.maxDate, excludeDates = _b.excludeDates, includeDates = _b.includeDates, filterDate = _b.filterDate, getTimeRangesForDate = _b.getTimeRangesForDate;
+            return _this.isOutOfBounds(day, { minDate: minDate, maxDate: maxDate }) ||
+                (excludeDates && excludeDates.some(function (excludeDate) { return _this.adapter.isSameDay(day, excludeDate); })) ||
+                (includeDates && !includeDates.some(function (includeDate) { return _this.adapter.isSameDay(day, includeDate); })) ||
+                checkDayDisabledFromFilter(day, getTimeRangesForDate) ||
+                (filterDate && !filterDate(day)) ||
+                false;
+        };
+        //Tue Apr 12 2011 00:00:00 GMT-0500, Tue Apr 12 2011 11:21:31 GMT-0500
+        this.isOnOrAfterDay = function (fromDate, toDate) {
+            if (_this.adapter.isSameDay(fromDate, toDate)) {
+                return true;
+            }
+            return _this.adapter.isAfter(fromDate, toDate);
+        };
+        this.isOnOrBeforeDay = function (fromDate, toDate) {
+            if (_this.adapter.isSameDay(fromDate, toDate)) {
+                return true;
+            }
+            return _this.adapter.isBefore(fromDate, toDate);
+        };
+        this.isOutOfBounds = function (day, _a) {
+            var _b = _a === void 0 ? {} : _a, minDate = _b.minDate, maxDate = _b.maxDate;
+            return (!!minDate && !_this.isOnOrAfterDay(day, minDate)) || (!!maxDate && !_this.isOnOrBeforeDay(day, maxDate));
+        };
+        this.parseString = function (string, formatString, locale) {
+            var adapter = locale ? _this.getAdapterWithNewLocale(locale) : _this.adapter;
+            return adapter.parse(string, formatString);
+        };
+        this.parse = function (string, format, locale) {
+            var adapter = locale ? _this.getAdapterWithNewLocale(locale) : _this.adapter;
+            return adapter.parse(string, adapter.formats[format]);
+        };
+        this.setMilliseconds = function (date, milliseconds) {
+            return _this.adapter.date(_this.adapter.getSeconds(_this.adapter.startOfDay(date)) * 1000 + milliseconds);
+        };
+        this.set = function (date, values) {
+            var updatedDate = date;
+            if (values.year != null) {
+                updatedDate = _this.setYear(updatedDate, values.year);
+            }
+            if (values.month != null) {
+                updatedDate = _this.setMonth(updatedDate, values.month);
+            }
+            if (values.date != null) {
+                updatedDate = _this.setDate(updatedDate, Number(values.date));
+            }
+            if (values.hours != null) {
+                updatedDate = _this.setHours(updatedDate, Number(values.hours));
+            }
+            if (values.minutes != null) {
+                updatedDate = _this.setMinutes(updatedDate, Number(values.minutes));
+            }
+            if (values.seconds != null) {
+                updatedDate = _this.setSeconds(updatedDate, Number(values.seconds));
+            }
+            return updatedDate;
+        };
+        this.getQuarter = function (date) { return Math.floor(_this.getMonth(date) / 3) + 1; };
+        this.setSeconds = function (date, seconds) { return _this.adapter.setSeconds(date, seconds); };
+        this.setMinutes = function (date, minutes) { return _this.adapter.setMinutes(date, minutes); };
+        this.setHours = function (date, hours) { return _this.adapter.setHours(date, hours); };
+        this.setMonth = function (date, monthNumber) { return _this.adapter.setMonth(date, monthNumber); };
+        this.setYear = function (date, yearNumber) { return _this.adapter.setYear(date, yearNumber); };
+        this.getMinutes = function (date) { return _this.adapter.getMinutes(date); };
+        this.getHours = function (date) { return _this.adapter.getHours(date); };
+        this.getMonth = function (date) { return _this.adapter.getMonth(date); };
+        this.getYear = function (date) { return _this.adapter.getYear(date); };
+        this.getStartOfMonth = function (date) { return _this.adapter.startOfMonth(date); };
+        this.getEndOfMonth = function (date) { return _this.adapter.endOfMonth(date); };
+        this.addDays = function (date, days) { return _this.adapter.addDays(date, days); };
+        this.addMonths = function (date, months) { return _this.adapter.addMonths(date, months); };
+        this.isBefore = function (fromDate, toDate) { return _this.adapter.isBefore(fromDate, toDate); };
+        this.isAfter = function (fromDate, toDate) { return _this.adapter.isAfter(fromDate, toDate); };
+        this.isEqual = function (fromDate, toDate) { return _this.adapter.isEqual(fromDate, toDate); };
+        this.isValid = function (possibleDate) { return _this.adapter.isValid(possibleDate); };
+        this.adapter = this.cloneAdapter(adapter);
+    }
+    return DateHelpers;
+}());
+export default DateHelpers;

package/esm/baseui/datepicker/utils/day-state.d.ts

@@ -0,0 +1,20 @@
+import type { SharedStyleProps } from '../types';
+/**
+  r == range - date range can be selected
+  d == disabled - disabled date
+  h == highlighted - currently highlighted date, the highlight is triggered on hover or focus
+  mO == hovered (mouse-over) - currently hovered date
+  s == selected - selected date, in a range both start and end date are marked as `selected`
+  rS == range-selected - when start and end dates of a range are set
+  sD == start-date - selected start date of the range
+  eD == end-date - selected end date of the range
+  pS == pseudo-selected - any date between two selected dates in a range
+  rH == range-highlighed - when only a single date of a range selected and the second date is highlighted but not yet selected
+  pH == pseudo-highlighted -  any date between a selected date in a range and the currently highlighted date (case when only one date selected in a range case)
+  rR == range-on-right - the range-highlighed case with the highlighed date is after the selected one
+  rL == range-on-left - the range-highlighed case with the highlighed date is before the selected one
+  sM == start-of-month - the first day of the month
+  eM == end-of-month - the last day of the month
+  oM == outside-month - date outside of currently displayed month (when peekNextMonth is set to true)
+ */
+export default function getDayStateCode(props: SharedStyleProps): string;

package/esm/baseui/datepicker/utils/day-state.js

@@ -0,0 +1,31 @@
+/**
+  r == range - date range can be selected
+  d == disabled - disabled date
+  h == highlighted - currently highlighted date, the highlight is triggered on hover or focus
+  mO == hovered (mouse-over) - currently hovered date
+  s == selected - selected date, in a range both start and end date are marked as `selected`
+  rS == range-selected - when start and end dates of a range are set
+  sD == start-date - selected start date of the range
+  eD == end-date - selected end date of the range
+  pS == pseudo-selected - any date between two selected dates in a range
+  rH == range-highlighed - when only a single date of a range selected and the second date is highlighted but not yet selected
+  pH == pseudo-highlighted -  any date between a selected date in a range and the currently highlighted date (case when only one date selected in a range case)
+  rR == range-on-right - the range-highlighed case with the highlighed date is after the selected one
+  rL == range-on-left - the range-highlighed case with the highlighed date is before the selected one
+  sM == start-of-month - the first day of the month
+  eM == end-of-month - the last day of the month
+  oM == outside-month - date outside of currently displayed month (when peekNextMonth is set to true)
+ */
+//  r  d  h  s  rS sD eD pS rH pH rR rL sM eM oM
+//  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1
+export default function getDayStateCode(props) {
+    var _a = props.$range, $range = _a === void 0 ? false : _a, _b = props.$disabled, $disabled = _b === void 0 ? false : _b, _c = props.$isHighlighted, $isHighlighted = _c === void 0 ? false : _c, _d = props.$isHovered, $isHovered = _d === void 0 ? false : _d, _e = props.$selected, $selected = _e === void 0 ? false : _e, _f = props.$hasRangeSelected, $hasRangeSelected = _f === void 0 ? false : _f, _g = props.$startDate, $startDate = _g === void 0 ? false : _g, _h = props.$endDate, $endDate = _h === void 0 ? false : _h, _j = props.$pseudoSelected, $pseudoSelected = _j === void 0 ? false : _j, _k = props.$hasRangeHighlighted, $hasRangeHighlighted = _k === void 0 ? false : _k, _l = props.$pseudoHighlighted, $pseudoHighlighted = _l === void 0 ? false : _l, _m = props.$hasRangeOnRight, $hasRangeOnRight = _m === void 0 ? false : _m, _o = props.$startOfMonth, $startOfMonth = _o === void 0 ? false : _o, _p = props.$endOfMonth, $endOfMonth = _p === void 0 ? false : _p, _q = props.$outsideMonth, $outsideMonth = _q === void 0 ? false : _q;
+    // @ts-ignore
+    return "".concat(+$range).concat(+$disabled).concat(+(($isHighlighted || $isHovered)
+    // @ts-ignore
+    )).concat(+$selected).concat(+$hasRangeSelected).concat(+$startDate).concat(+$endDate).concat(+$pseudoSelected).concat(+$hasRangeHighlighted).concat(+$pseudoHighlighted).concat(+(($hasRangeHighlighted && !$pseudoHighlighted && $hasRangeOnRight)
+    // @ts-ignore
+    )).concat(+(($hasRangeHighlighted && !$pseudoHighlighted && !$hasRangeOnRight)
+    // @ts-ignore
+    )).concat(+$startOfMonth).concat(+$endOfMonth).concat(+$outsideMonth);
+}

package/esm/baseui/datepicker/utils/index.d.ts

@@ -0,0 +1,68 @@
+declare type DirtyDate = Date | number;
+export declare const formatDate: (c: Date, b: string, a?: any) => string;
+export declare const getStartOfWeek: (b: Date, a?: any) => Date;
+export declare const getEndOfWeek: (a: Date) => Date;
+export declare const getStartOfMonth: (a: Date) => Date;
+export declare const getEndOfMonth: (a: Date) => Date;
+export declare const isSameYear: (b?: Date | null | undefined, a?: Date | null | undefined) => boolean;
+export declare const isSameMonth: (b?: Date | null | undefined, a?: Date | null | undefined) => boolean;
+export declare const isSameDay: (b?: Date | null | undefined, a?: Date | null | undefined) => boolean;
+export declare const isDayInRange: (c: Date, b: Date, a: Date) => boolean;
+export declare const isStartOfMonth: (a: Date) => boolean;
+export declare const isEndOfMonth: (a: Date) => boolean;
+export declare const getWeekdayMinInLocale: (b: Date, a: any) => string;
+export declare const getWeekdayInLocale: (b: Date, a: any) => string;
+export declare const getMonthInLocale: (b: number, a: any) => string;
+export declare const getQuarterInLocale: (b: number, a: any) => string;
+export declare const isDayDisabled: (b: Date, a: {
+    minDate?: Date | null | undefined;
+    maxDate?: Date | null | undefined;
+    excludeDates?: Date[] | null | undefined;
+    includeDates?: Date[] | null | undefined;
+    filterDate?: ((day: Date) => boolean) | null | undefined;
+    getTimeRangesForDate?: import("..").GetTimeRangesForDate<Date> | undefined;
+}) => boolean;
+export declare const isOutOfBounds: (b: Date, a: {
+    minDate?: Date | null | undefined;
+    maxDate?: Date | null | undefined;
+}) => boolean;
+export declare const monthDisabledBefore: (b: Date, a: {
+    minDate?: Date | null | undefined;
+    includeDates?: Date[] | null | undefined;
+}) => boolean;
+export declare const monthDisabledAfter: (b: Date, a: {
+    maxDate?: Date | null | undefined;
+    includeDates?: Date[] | null | undefined;
+}) => boolean;
+export declare const getEffectiveMinDate: (a: {
+    minDate?: Date | null | undefined;
+    includeDates?: Date[] | undefined;
+}) => Date;
+export declare const getEffectiveMaxDate: (a: {
+    maxDate?: Date | null | undefined;
+    includeDates?: Date[] | undefined;
+}) => Date;
+export declare const applyTimeToDate: (b: Date | null | undefined, a: Date) => Date;
+export declare const applyDateToTime: (b: Date | null | undefined, a: Date) => Date;
+export declare const setSeconds: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const setMinutes: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const setHours: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const setMonth: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const setYear: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const getMinutes: (dirtyDate: DirtyDate) => number;
+export declare const getHours: (dirtyDate: DirtyDate) => number;
+export declare const getDate: (dirtyDate: DirtyDate) => number;
+export declare const getMonth: (dirtyDate: DirtyDate) => number;
+export declare const getYear: (dirtyDate: DirtyDate) => number;
+export declare const addDays: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const addWeeks: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const addMonths: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const addYears: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const subDays: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const subWeeks: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const subMonths: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const subYears: (dirtyDate: DirtyDate, number: number) => Date;
+export declare const isBefore: (fromDirty: DirtyDate, toDirty: DirtyDate) => boolean;
+export declare const isAfter: (fromDirty: DirtyDate, toDirty: DirtyDate) => boolean;
+export declare const format: (date: Date, format: string, locale?: any | null) => string;
+export {};