@sprinklrjs/spaceweb 12.14.4 → 12.33.2

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

@@ -0,0 +1,364 @@
+import { __assign, __read } from "tslib";
+var MINUTE = 60;
+var HOUR = MINUTE * 60;
+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;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            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(Object.assign({}, updateOptions(Object.assign({}, options, {
+                formats: Object.assign({}, options.formats, formats),
+            }))));
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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;
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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));
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.formatDate = function (date, formatString, locale) {
+            var adapter = locale ? _this.getAdapterWithNewLocale(locale) : _this.adapter;
+            return adapter.formatByString(date, formatString);
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.getWeekdayMinInLocale = function (date, locale) {
+            return _this.getAdapterWithNewLocale(locale).format(date, 'weekdaymin');
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.getMonthInLocale = function (monthNumber, locale) {
+            var localeAdapter = _this.getAdapterWithNewLocale(locale);
+            return localeAdapter.format(localeAdapter.setMonth(localeAdapter.date(), monthNumber), 'month');
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.getWeekdayInLocale = function (date, locale) {
+            return _this.getAdapterWithNewLocale(locale).format(date, 'weekday');
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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++) {
+                    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;
+            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); })) ||
+                (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)));
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.parseString = function (string, formatString, locale) {
+            var adapter = locale ? _this.getAdapterWithNewLocale(locale) : _this.adapter;
+            return adapter.parse(string, formatString);
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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,67 @@
+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;
+}) => 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 {};

package/esm/baseui/datepicker/utils/index.js

@@ -0,0 +1,76 @@
+/*
+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.
+*/
+/* eslint-disable import/extensions */
+import defaultAdapter from './date-fns-adapter';
+import DateHelpers from './date-helpers';
+var defaultDateHelpers = new DateHelpers(defaultAdapter);
+var wrapDate = defaultAdapter.date;
+export var formatDate = defaultDateHelpers.formatDate;
+export var getStartOfWeek = defaultDateHelpers.getStartOfWeek;
+export var getEndOfWeek = defaultDateHelpers.getEndOfWeek;
+export var getStartOfMonth = defaultDateHelpers.getStartOfMonth;
+export var getEndOfMonth = defaultDateHelpers.getEndOfMonth;
+export var isSameYear = defaultDateHelpers.isSameYear;
+export var isSameMonth = defaultDateHelpers.isSameMonth;
+export var isSameDay = defaultDateHelpers.isSameDay;
+export var isDayInRange = defaultDateHelpers.isDayInRange;
+export var isStartOfMonth = defaultDateHelpers.isStartOfMonth;
+export var isEndOfMonth = defaultDateHelpers.isEndOfMonth;
+export var getWeekdayMinInLocale = defaultDateHelpers.getWeekdayMinInLocale;
+export var getWeekdayInLocale = defaultDateHelpers.getWeekdayInLocale;
+export var getMonthInLocale = defaultDateHelpers.getMonthInLocale;
+export var getQuarterInLocale = defaultDateHelpers.getQuarterInLocale;
+export var isDayDisabled = defaultDateHelpers.isDayDisabled;
+export var isOutOfBounds = defaultDateHelpers.isOutOfBounds;
+export var monthDisabledBefore = defaultDateHelpers.monthDisabledBefore;
+export var monthDisabledAfter = defaultDateHelpers.monthDisabledAfter;
+export var getEffectiveMinDate = defaultDateHelpers.getEffectiveMinDate;
+export var getEffectiveMaxDate = defaultDateHelpers.getEffectiveMaxDate;
+export var applyTimeToDate = defaultDateHelpers.applyTimeToDate;
+export var applyDateToTime = defaultDateHelpers.applyDateToTime;
+var createDirtySetter = function (setter) {
+    return function (dirtyDate, number) { return setter(wrapDate(dirtyDate), number); };
+};
+var createDirtyGetter = function (getter) {
+    return function (dirtyDate) { return getter(wrapDate(dirtyDate)); };
+};
+var createDirtyCompare = function (compare) {
+    return function (fromDirty, toDirty) {
+        return compare(wrapDate(fromDirty), wrapDate(toDirty));
+    };
+};
+// ** Re-exported from date-fns **
+// these need to be able to accept either number or date
+// to maintain parity with the old exports
+// ** Date Setters **
+export var setSeconds = createDirtySetter(defaultDateHelpers.setSeconds);
+export var setMinutes = createDirtySetter(defaultDateHelpers.setMinutes);
+export var setHours = createDirtySetter(defaultDateHelpers.setHours);
+export var setMonth = createDirtySetter(defaultDateHelpers.setMonth);
+export var setYear = createDirtySetter(defaultDateHelpers.setYear);
+// ** Date Getters **
+export var getMinutes = createDirtyGetter(defaultDateHelpers.getMinutes);
+export var getHours = createDirtyGetter(defaultDateHelpers.getHours);
+export var getDate = createDirtyGetter(defaultDateHelpers.getDate);
+export var getMonth = createDirtyGetter(defaultDateHelpers.getMonth);
+export var getYear = createDirtyGetter(defaultDateHelpers.getYear);
+// ** Date Math
+export var addDays = createDirtySetter(defaultDateHelpers.addDays);
+export var addWeeks = createDirtySetter(defaultDateHelpers.addWeeks);
+export var addMonths = createDirtySetter(defaultDateHelpers.addMonths);
+export var addYears = createDirtySetter(defaultDateHelpers.addYears);
+export var subDays = createDirtySetter(defaultDateHelpers.subDays);
+export var subWeeks = createDirtySetter(defaultDateHelpers.subWeeks);
+export var subMonths = createDirtySetter(defaultDateHelpers.subMonths);
+export var subYears = createDirtySetter(defaultDateHelpers.subYears);
+// ** Date Comparison
+export var isBefore = createDirtyCompare(defaultDateHelpers.isBefore);
+export var isAfter = createDirtyCompare(defaultDateHelpers.isAfter);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export var format = function (date, format, locale) {
+    return defaultDateHelpers.format(date, format, locale);
+};

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

@@ -0,0 +1,69 @@
+declare type DateValues<T> = T | string | number;
+export declare type DateInput<T> = DateValues<T>;
+declare type Comparison<T> = (value: T, comparing: T) => boolean;
+declare type DateInDateOut<T> = (value: T) => T;
+declare type DateFunc<T> = (a: DateInput<T> | void) => T;
+export declare type AdapterOptions = {
+    locale?: unknown;
+    formats?: {
+        [key: string]: string;
+    };
+    instance?: unknown;
+};
+export declare type DateIOAdapter<T> = {
+    locale?: unknown;
+    formats: {
+        [key: string]: string;
+    };
+    date: DateFunc<T>;
+    toJsDate(value: DateInput<T>): Date;
+    parse(value: string, format: string): T;
+    getCurrentLocaleCode(): string;
+    is12HourCycleInCurrentLocale(): boolean;
+    isNull(value?: T): boolean;
+    isValid(value: unknown): boolean;
+    getDiff: (from: T, to: T) => number;
+    isEqual: Comparison<T>;
+    isSameDay: Comparison<T>;
+    isSameMonth: Comparison<T>;
+    isSameYear: Comparison<T>;
+    isSameHour: Comparison<T>;
+    isAfter: Comparison<T>;
+    isAfterDay: Comparison<T>;
+    isAfterYear: Comparison<T>;
+    isBeforeDay: Comparison<T>;
+    isBeforeYear: Comparison<T>;
+    isBefore: Comparison<T>;
+    startOfMonth: DateInDateOut<T>;
+    endOfMonth: DateInDateOut<T>;
+    startOfWeek: DateInDateOut<T>;
+    endOfWeek(value: T): T;
+    addDays(value: T, count: number): T;
+    addMonths(value: T, count: number): T;
+    isWithinRange(value: T, range: T[]): boolean;
+    startOfDay: DateInDateOut<T>;
+    endOfDay: DateInDateOut<T>;
+    format(value: T, formatKey: string): string;
+    formatByString(value: T, formatString: string): string;
+    formatNumber(numberToFormat: string): string;
+    getHours(value: T): number;
+    setHours(value: T, count: number): T;
+    getMinutes(value: T): number;
+    setMinutes(value: T, count: number): T;
+    getSeconds(value: T): number;
+    setSeconds(value: T, count: number): T;
+    getMonth(value: T): number;
+    setMonth(value: T, count: number): T;
+    getNextMonth: DateInDateOut<T>;
+    getPreviousMonth: DateInDateOut<T>;
+    getMonthArray(value: T): T[];
+    getYear(value: T): number;
+    setYear(value: T, count: number): T;
+    mergeDateAndTime(date: T, time: T): T;
+    getWeekdays(): string[];
+    getWeekArray(date: T): T[][];
+    getYearRange(start: T, end: T): T[];
+    /** Allow to customize displaying "am/pm" strings */
+    getMeridiemText(ampm: 'am' | 'pm'): string;
+};
+export {};

package/esm/baseui/datepicker/utils/types.js

@@ -0,0 +1 @@
+export {};

package/esm/baseui/datepicker/week.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import DateHelpers from './utils/date-helpers';
+import type { WeekProps } from './types';
+export default class Week<T = Date> extends React.Component<WeekProps<T>> {
+    static defaultProps: {
+        adapter: import("./utils/types").DateIOAdapter<Date>;
+        highlightedDate: null;
+        onDayClick: () => void;
+        onDayFocus: () => void;
+        onDayBlur: () => void;
+        onDayMouseOver: () => void;
+        onDayMouseLeave: () => void;
+        onChange: () => void;
+        overrides: {};
+        peekNextMonth: boolean;
+    };
+    dateHelpers: DateHelpers<T>;
+    constructor(props: WeekProps<T>);
+    renderDays: () => never[];
+    render(): import("react/jsx-runtime").JSX.Element;
+}