@entur/datepicker 3.0.6 → 4.0.0-RC.0

package/dist/datepicker.cjs.development.js

@@ -14,16 +14,25 @@ var button = require('@entur/button');
 var form = require('@entur/form');
 var tooltip = require('@entur/tooltip');
 require('react-datepicker/dist/react-datepicker.css');
+var datepicker$1 = require('@react-stately/datepicker');
 var datepicker = require('@react-aria/datepicker');
 var i18n = require('@react-aria/i18n');
-var datepicker$1 = require('@react-stately/datepicker');
 var date = require('@internationalized/date');
+var calendar = require('@react-aria/calendar');
+var calendar$1 = require('@react-stately/calendar');
+var button$1 = require('@react-aria/button');
+var a11y = require('@entur/a11y');
+var reactDom = require('@floating-ui/react-dom');
+var FocusLock = require('react-focus-lock');
+var tokens = require('@entur/tokens');
+var modal = require('@entur/modal');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var ReactDatepicker__default = /*#__PURE__*/_interopDefaultLegacy(ReactDatepicker);
 var classNames__default = /*#__PURE__*/_interopDefaultLegacy(classNames);
+var FocusLock__default = /*#__PURE__*/_interopDefaultLegacy(FocusLock);
 
 function _extends() {
   _extends = Object.assign || function (target) {
@@ -99,7 +108,7 @@ function getMonthName(monthIndex, locale) {
   return formatter.format(new Date(year, monthIndex));
 }
 
-var _excluded$4 = ["style", "label", "inputPlaceholder", "prepend", "feedback", "variant", "disabled", "calendarButtonTooltipOpen", "calendarButtonTooltipClose", "hideCalendarButton", "disableLabelAnimation", "inputRef", "calendarButtonId", "forwardRef", "toggleCalendarGUI", "onKeyDownInput", "onBlurInput", "selectedDate", "setFocusToCalendarGUI", "setShouldFocusOnCalendarButtonAfterSelect", "calendarGUIIsOpen", "placeholder", "onClick", "aria-labelledby"];
+var _excluded$a = ["style", "label", "inputPlaceholder", "prepend", "feedback", "variant", "disabled", "calendarButtonTooltipOpen", "calendarButtonTooltipClose", "hideCalendarButton", "disableLabelAnimation", "inputRef", "calendarButtonId", "forwardRef", "toggleCalendarGUI", "onKeyDownInput", "onBlurInput", "selectedDate", "setFocusToCalendarGUI", "setShouldFocusOnCalendarButtonAfterSelect", "calendarGUIIsOpen", "placeholder", "onClick", "aria-labelledby"];
 var DatePickerInput = /*#__PURE__*/React__default["default"].forwardRef(function (_ref, ref) {
   var style = _ref.style,
       label = _ref.label,
@@ -123,7 +132,7 @@ var DatePickerInput = /*#__PURE__*/React__default["default"].forwardRef(function
       setShouldFocusOnCalendarButtonAfterSelect = _ref.setShouldFocusOnCalendarButtonAfterSelect,
       calendarGUIIsOpen = _ref.calendarGUIIsOpen,
       onClick = _ref.onClick,
-      rest = _objectWithoutPropertiesLoose(_ref, _excluded$4);
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded$a);
 
   React__default["default"].useEffect(function () {
     var _inputRef$current, _inputRef$current2, _inputRef$current3;
@@ -201,7 +210,7 @@ var DatePickerInput = /*#__PURE__*/React__default["default"].forwardRef(function
   }, rest));
 });
 
-var _excluded$3 = ["style", "className", "selectedDate", "label", "placeholder", "onChange", "onKeyDown", "dateFormats", "minDate", "maxDate", "inline", "disabled", "prepend", "feedback", "variant", "validationFeedback", "validationVariant", "disableLabelAnimation", "calendarButtonTooltipOpen", "calendarButtonTooltipClose", "hideCalendarButton", "hideCalendar", "hideValidation", "weekLabel", "chooseDayAriaLabelPrefix", "previousMonthAriaLabel", "nextMonthAriaLabel", "locale", "open"];
+var _excluded$9 = ["style", "className", "selectedDate", "label", "placeholder", "onChange", "onKeyDown", "dateFormats", "minDate", "maxDate", "inline", "disabled", "prepend", "feedback", "variant", "validationFeedback", "validationVariant", "disableLabelAnimation", "calendarButtonTooltipOpen", "calendarButtonTooltipClose", "hideCalendarButton", "hideCalendar", "hideValidation", "weekLabel", "chooseDayAriaLabelPrefix", "previousMonthAriaLabel", "nextMonthAriaLabel", "locale", "open"];
 ReactDatepicker.registerLocale('nb', locale.nb);
 var DatePicker = /*#__PURE__*/React__default["default"].forwardRef(function (_ref, ref) {
   var style = _ref.style,
@@ -253,7 +262,7 @@ var DatePicker = /*#__PURE__*/React__default["default"].forwardRef(function (_re
       _ref$locale = _ref.locale,
       locale$1 = _ref$locale === void 0 ? locale.nb : _ref$locale,
       open = _ref.open,
-      rest = _objectWithoutPropertiesLoose(_ref, _excluded$3);
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded$9);
 
   var datepickerId = utils.useRandomId('eds-datepicker');
   var datepickerRef = React.useRef(null);
@@ -485,6 +494,541 @@ var DatePicker = /*#__PURE__*/React__default["default"].forwardRef(function (_re
   }, rest)));
 });
 
+var FieldSegment = function FieldSegment(_ref) {
+  var segment = _ref.segment,
+      state = _ref.state;
+  var ref = React.useRef(null);
+
+  var _useDateSegment = datepicker.useDateSegment(segment, state, ref),
+      segmentProps = _useDateSegment.segmentProps;
+
+  var is12HourFormatted = state.segments.some(function (segment) {
+    return segment.text === 'AM' || segment.text === 'PM';
+  });
+
+  var segmentDisplayText = function segmentDisplayText() {
+    if (is12HourFormatted) return segment.text; // if number add '0' padding to start when one digit
+
+    if (segment.text.match(/\d+/)) return segment.text.padStart(2, '0');
+    return segment.text;
+  };
+
+  return React__default["default"].createElement("div", _extends({}, segmentProps, {
+    ref: ref,
+    className: classNames__default["default"]('eds-date-and-time-field__segment', {
+      'eds-date-and-time-field__segment--placeholder': segment.isPlaceholder,
+      'eds-date-and-time-field__segment--dot-separator': segment.text === '.'
+    }),
+    tabIndex: state.isDisabled ? -1 : segmentProps.tabIndex
+  }), segmentDisplayText());
+};
+
+/**
+ * Tar inn et JS Date-objekt og returnerer et av Date- eller TimeValue-objektene fra @internationalized/date-pakken
+ * @param {Date} date JS Date-objekt som ønskes konvertert til et Date- eller TimeValue-objekt
+ * @param {boolean} noDateOnlyTime Hvis datoen er irrelevant kan denne settes til true, da får man et Time-objekt uten dato tilbake
+ * @param {boolean} noTimeOnlyDate Hvis tidspunktet er irrelevant kan denne settes til true, da får man et CalendarDate-objekt uten tidspunkt tilbake
+ * @param {string} timeZone Tidssonen på IANA-formatet som tidpunktet skal konverteres til. Utelates denne får man et tidspunkt uten tidssone. Kan brukes med og uten en UTC-offset Vær obs på annen oppførsel med offset, les mer på beskrivelsen av offset
+ * @param {number} offset UTC-offset i millisekunder, må brukes med en tidssone. Ved å legge på en offset lager du en variant av en tidssone. Det betyr at tidspunktet ikke endres (time, minutt, sekund uendret), men tidssonen, med tilhørende offset, tidspunktet er i endres.
+ * @returns {Time | CalendarDateTime | ZonedDateTime | CalendarDate} et av Time- eller DateValue-objektene med verdier fra date
+ */
+
+var nativeDateToTimeOrDateValue = function nativeDateToTimeOrDateValue(date$1, noDateOnlyTime, noTimeOnlyDate, timeZone, offset) {
+  if (noDateOnlyTime === void 0) {
+    noDateOnlyTime = false;
+  }
+
+  if (noTimeOnlyDate === void 0) {
+    noTimeOnlyDate = false;
+  }
+
+  if (timeZone) {
+    if (offset) {
+      return new date.ZonedDateTime(date$1.getFullYear(), date$1.getMonth() + 1, date$1.getDate(), timeZone, offset, date$1.getHours(), date$1.getMinutes(), date$1.getSeconds());
+    }
+
+    return date.parseAbsolute(date$1.toISOString(), timeZone);
+  }
+
+  if (noDateOnlyTime) return new date.Time(date$1.getHours(), date$1.getMinutes(), date$1.getSeconds(), 0);
+  if (noTimeOnlyDate) return new date.CalendarDate(date$1.getFullYear(), date$1.getMonth() + 1, date$1.getDate());
+  return new date.CalendarDateTime(date$1.getFullYear(), date$1.getMonth() + 1, date$1.getDate(), date$1.getHours(), date$1.getMinutes(), date$1.getSeconds());
+};
+/**
+ * Tar inn et av Date- eller TimeValue-objektene fra @internationalized/date-pakken og returnerer et JS Date-objekt
+ * @param {DateValue | TimeValue} value En dato eller et tidspunkt på Date- eller TimeValue-formatet som ønskes konvertert til et JS Date-objekt
+ * @param {string} timeZoneForCalendarDateTime Tidssonen value er i. Fungerer kun med typen er CalendarDateTime
+ * @returns {Date} et Date-objekt med verdier fra time
+ */
+// This function uses a lot of @ts-expect-error to make it work with all Date- and TimeValue types. Sorry ...
+
+var timeOrDateValueToNativeDate = function timeOrDateValueToNativeDate(value, timeZoneForCalendarDateTime) {
+  // @ts-expect-error .day does not exist on Time-object
+  if (!value.day) {
+    // type is Time
+    var date$1 = new Date(); // @ts-expect-error hour does not exist on CalendarDate
+
+    date$1.setHours(value.hour); // @ts-expect-error minute does not exist on CalendarDate
+
+    date$1.setMinutes(value.minute); // @ts-expect-error second does not exist on CalendarDate
+
+    date$1.setSeconds(value.second);
+    return date$1;
+  } // @ts-expect-error .day does not exist on Time-object
+
+
+  if (!value.hour) {
+    // type is CalendarDate
+    // @ts-expect-error .toDate(timeZone) does not exist in type Time
+    return value.toDate(timeZoneForCalendarDateTime != null ? timeZoneForCalendarDateTime : date.getLocalTimeZone());
+  } // @ts-expect-error .timeZone does not exist in type Time and CalendarDateTime
+
+
+  if (!value.timeZone) {
+    // type is CalendarDateTime
+    if (timeZoneForCalendarDateTime) // @ts-expect-error .toDate(timeZone) does not exist in type Time
+      return value.toDate(timeZoneForCalendarDateTime);
+    return new Date( // @ts-expect-error not in type Time
+    value.year, // @ts-expect-error not in type Time
+    value.month - 1, // @ts-expect-error not in type Time
+    value.day, // @ts-expect-error not in type CalendarDate
+    value.hour, // @ts-expect-error not in type CalendarDate
+    value.minute, // @ts-expect-error not in type CalendarDate
+    value.second);
+  } // @ts-expect-error .toDate() does not exist in type Time or CalendarDateTime
+
+
+  return value.toDate();
+};
+var createCalendar = function createCalendar(identifier) {
+  if (identifier === void 0) {
+    identifier = 'gregory';
+  }
+
+  switch (identifier) {
+    case 'gregory':
+      return new date.GregorianCalendar();
+
+    default:
+      throw new Error("Unsupported calendar " + identifier);
+  }
+};
+var ariaLabelIfNorwegian = function ariaLabelIfNorwegian(norwegianAriaLabel, locale, propsCollection) {
+  if (locale.toLowerCase() !== 'no-no') return propsCollection['aria-label'];
+  return norwegianAriaLabel;
+};
+
+var _excluded$8 = ["selectedDate", "label", "locale", "showTimeZone", "showTime", "granularity", "disabled", "variant", "feedback", "validationVariant", "validationFeedback", "labelTooltip", "style", "className", "labelProps", "append"];
+var DateField = /*#__PURE__*/React__default["default"].forwardRef(function (_ref, ref) {
+  var value = _ref.selectedDate,
+      label = _ref.label,
+      customLocale = _ref.locale,
+      showTimeZone = _ref.showTimeZone,
+      showTime = _ref.showTime,
+      _ref$granularity = _ref.granularity,
+      granularity = _ref$granularity === void 0 ? 'day' : _ref$granularity,
+      disabled = _ref.disabled,
+      variant = _ref.variant,
+      feedback = _ref.feedback,
+      _ref$validationVarian = _ref.validationVariant,
+      validationVariant = _ref$validationVarian === void 0 ? 'error' : _ref$validationVarian,
+      _ref$validationFeedba = _ref.validationFeedback,
+      validationFeedback = _ref$validationFeedba === void 0 ? 'Ugyldig dato' : _ref$validationFeedba,
+      labelTooltip = _ref.labelTooltip,
+      style = _ref.style,
+      className = _ref.className,
+      parentLabelProps = _ref.labelProps,
+      append = _ref.append,
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded$8);
+
+  var _useLocale = i18n.useLocale(),
+      locale = _useLocale.locale;
+
+  var state = datepicker$1.useDateFieldState(_extends({}, rest, {
+    locale: customLocale != null ? customLocale : locale,
+    createCalendar: createCalendar,
+    value: value === null ? undefined : value,
+    hideTimeZone: !showTimeZone,
+    granularity: showTime ? 'minute' : granularity
+  }));
+  var dateFieldRef = React.useRef(null);
+
+  var _useDateField = datepicker.useDateField(_extends({}, rest, {
+    label: label,
+    isDisabled: disabled || rest.isDisabled
+  }), state, dateFieldRef),
+      labelProps = _useDateField.labelProps,
+      fieldProps = _useDateField.fieldProps;
+
+  var id = utils.useRandomId('datefield');
+  return React__default["default"].createElement(utils.ConditionalWrapper, {
+    condition: customLocale !== undefined,
+    wrapper: function wrapper(child) {
+      return React__default["default"].createElement(i18n.I18nProvider, {
+        locale: customLocale
+      }, child);
+    }
+  }, React__default["default"].createElement(form.BaseFormControl, _extends({
+    style: style,
+    className: classNames__default["default"]('eds-datefield', className),
+    labelId: id,
+    ref: utils.mergeRefs(dateFieldRef, ref),
+    disabled: state.isDisabled,
+    disableLabelAnimation: true,
+    label: label,
+    labelTooltip: labelTooltip,
+    labelProps: parentLabelProps != null ? parentLabelProps : labelProps
+  }, fieldProps, {
+    variant: (variant != null ? variant : state.validationState === 'invalid') ? validationVariant : undefined,
+    feedback: (feedback != null ? feedback : state.validationState === 'invalid') ? validationFeedback : undefined,
+    append: append,
+    ariaAlertOnFeedback: true
+  }), state.segments.map(function (segment, i) {
+    return React__default["default"].createElement(FieldSegment, {
+      segment: segment,
+      state: state,
+      key: i
+    });
+  })));
+});
+
+var _excluded$7 = ["children", "className", "style"];
+var CalendarButton = function CalendarButton(_ref) {
+  var children = _ref.children,
+      className = _ref.className,
+      style = _ref.style,
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$7);
+
+  var ref = React.useRef(null);
+
+  var _useButton = button$1.useButton(props, ref),
+      buttonProps = _useButton.buttonProps;
+
+  return React__default["default"].createElement(button.IconButton, _extends({}, buttonProps, {
+    ref: ref,
+    className: className,
+    style: style
+  }), children);
+};
+
+var _excluded$6 = ["state", "date", "onSelectedCellClick"];
+var CalendarCell = function CalendarCell(_ref) {
+  var _state$timeZone;
+
+  var state = _ref.state,
+      date$1 = _ref.date,
+      _ref$onSelectedCellCl = _ref.onSelectedCellClick,
+      onSelectedCellClick = _ref$onSelectedCellCl === void 0 ? function () {
+    return;
+  } : _ref$onSelectedCellCl,
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded$6);
+
+  var cellRef = React.useRef(null);
+
+  var _useCalendarCell = calendar.useCalendarCell({
+    date: date$1
+  }, state, cellRef),
+      cellProps = _useCalendarCell.cellProps,
+      buttonProps = _useCalendarCell.buttonProps,
+      isSelected = _useCalendarCell.isSelected,
+      isOutsideVisibleRange = _useCalendarCell.isOutsideVisibleRange,
+      isDisabled = _useCalendarCell.isDisabled,
+      isUnavailable = _useCalendarCell.isUnavailable,
+      formattedDate = _useCalendarCell.formattedDate;
+
+  return React__default["default"].createElement("td", _extends({}, cellProps, {
+    className: "eds-datepicker__calendar__grid__cell__td"
+  }), React__default["default"].createElement("div", _extends({}, buttonProps, {
+    ref: cellRef,
+    hidden: isOutsideVisibleRange,
+    className: classNames__default["default"]('eds-datepicker__calendar__grid__cell', {
+      'eds-datepicker__calendar__grid__cell--selected': isSelected,
+      'eds-datepicker__calendar__grid__cell--disabled': isDisabled || isUnavailable,
+      'eds-datepicker__calendar__grid__cell--outside-month': isOutsideVisibleRange,
+      'eds-datepicker__calendar__grid__cell--today': date.isEqualDay(date$1, date.now((_state$timeZone = state.timeZone) != null ? _state$timeZone : date.getLocalTimeZone()))
+    })
+  }, rest, {
+    onClick: function onClick(e) {
+      buttonProps.onClick && buttonProps.onClick(e);
+      isSelected && onSelectedCellClick();
+    }
+  }), formattedDate));
+};
+
+var _excluded$5 = ["state", "navigationDescription", "onSelectedCellClick"];
+var CalendarGrid = function CalendarGrid(_ref) {
+  var state = _ref.state,
+      navigationDescription = _ref.navigationDescription,
+      _ref$onSelectedCellCl = _ref.onSelectedCellClick,
+      onSelectedCellClick = _ref$onSelectedCellCl === void 0 ? function () {
+    return;
+  } : _ref$onSelectedCellCl,
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded$5);
+
+  var calendarGridId = utils.useRandomId('eds-calendar');
+
+  var _useLocale = i18n.useLocale(),
+      locale = _useLocale.locale;
+
+  var _useCalendarGrid = calendar.useCalendarGrid(rest, state),
+      gridProps = _useCalendarGrid.gridProps,
+      headerProps = _useCalendarGrid.headerProps,
+      weekDays = _useCalendarGrid.weekDays;
+
+  var weeksInMonth = date.getWeeksInMonth(state.visibleRange.start, locale);
+  var weeksArray = Array.from(Array(weeksInMonth).keys());
+
+  var weekDaysMapped = function weekDaysMapped() {
+    if (locale.toLowerCase() === 'no-no' || locale.toLowerCase() === 'no') return ['ma', 'ti', 'on', 'to', 'fr', 'lø', 'sø'];
+    if (weekDays.toString() === 'M,T,W,T,F,S,S') return ['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su'];
+    return weekDays.map(function (day) {
+      return day.toLowerCase();
+    });
+  };
+
+  var getNavigationDescription = function getNavigationDescription() {
+    if (navigationDescription) return navigationDescription;
+    if (locale.toLowerCase().includes('en')) return 'Use the arrow keys to navigate between dates';
+    return 'Bruk piltastene til å navigere mellom datoer';
+  };
+
+  return React__default["default"].createElement(React__default["default"].Fragment, null, React__default["default"].createElement("table", _extends({}, gridProps, {
+    cellSpacing: "0",
+    className: "eds-datepicker__calendar__grid"
+  }), React__default["default"].createElement("thead", _extends({}, headerProps), React__default["default"].createElement("tr", null, weekDaysMapped().map(function (day, index) {
+    return React__default["default"].createElement("th", {
+      key: index
+    }, day);
+  }))), React__default["default"].createElement("tbody", null, weeksArray.map(function (weekIndex) {
+    return React__default["default"].createElement("tr", {
+      key: weekIndex
+    }, state.getDatesInWeek(weekIndex).map(function (date, i) {
+      return date ? React__default["default"].createElement(CalendarCell, {
+        key: i,
+        state: state,
+        date: date,
+        "aria-describedby": calendarGridId + 'description',
+        onSelectedCellClick: onSelectedCellClick
+      }) : React__default["default"].createElement("td", {
+        key: i
+      });
+    }));
+  }))), React__default["default"].createElement(a11y.VisuallyHidden, {
+    id: calendarGridId + 'description'
+  }, getNavigationDescription()));
+};
+
+var _excluded$4 = ["selectedDate", "onChange", "locale", "style", "children", "navigationDescription", "onSelectedCellClick"];
+var Calendar = /*#__PURE__*/React__default["default"].forwardRef(function (_ref, ref) {
+  var onChange = _ref.onChange,
+      customLocale = _ref.locale,
+      style = _ref.style,
+      navigationDescription = _ref.navigationDescription,
+      _ref$onSelectedCellCl = _ref.onSelectedCellClick,
+      onSelectedCellClick = _ref$onSelectedCellCl === void 0 ? function () {
+    return;
+  } : _ref$onSelectedCellCl,
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded$4);
+
+  var _useLocale = i18n.useLocale(),
+      locale = _useLocale.locale;
+
+  var state = calendar$1.useCalendarState(_extends({}, rest, {
+    onChange: onChange,
+    locale: customLocale != null ? customLocale : locale,
+    createCalendar: createCalendar
+  }));
+
+  var _useCalendar = calendar.useCalendar(rest, state),
+      calendarProps = _useCalendar.calendarProps,
+      prevButtonProps = _useCalendar.prevButtonProps,
+      nextButtonProps = _useCalendar.nextButtonProps,
+      title = _useCalendar.title;
+
+  return React__default["default"].createElement(utils.ConditionalWrapper, {
+    condition: customLocale,
+    wrapper: function wrapper(child) {
+      return React__default["default"].createElement(i18n.I18nProvider, {
+        locale: customLocale
+      }, child);
+    }
+  }, React__default["default"].createElement("div", _extends({}, calendarProps, {
+    ref: ref,
+    className: "eds-datepicker__calendar",
+    style: style
+  }), React__default["default"].createElement("div", {
+    className: "eds-datepicker__calendar__header"
+  }, React__default["default"].createElement(CalendarButton, _extends({}, prevButtonProps, {
+    "aria-label": ariaLabelIfNorwegian('Forrige måned', locale, prevButtonProps)
+  }), React__default["default"].createElement(icons.LeftArrowIcon, {
+    size: 20
+  })), React__default["default"].createElement("h2", null, title), React__default["default"].createElement(CalendarButton, _extends({}, nextButtonProps, {
+    "aria-label": ariaLabelIfNorwegian('Neste måned', locale, nextButtonProps)
+  }), React__default["default"].createElement(icons.RightArrowIcon, {
+    size: 20
+  }))), React__default["default"].createElement(CalendarGrid, {
+    state: state,
+    navigationDescription: navigationDescription,
+    onSelectedCellClick: onSelectedCellClick
+  })));
+});
+
+var _excluded$3 = ["selectedDate", "onChange", "locale", "disabled", "showTime", "showTimeZone", "className", "style", "variant", "feedback", "validationVariant", "validationFeedback", "disableModal", "labelTooltip", "navigationDescription", "minDate", "maxDate", "modalTreshold"];
+var DatePickerBeta = function DatePickerBeta(_ref) {
+  var value = _ref.selectedDate,
+      onChange = _ref.onChange,
+      locale = _ref.locale,
+      isDisabled = _ref.disabled,
+      showTime = _ref.showTime,
+      _ref$showTimeZone = _ref.showTimeZone,
+      showTimeZone = _ref$showTimeZone === void 0 ? false : _ref$showTimeZone,
+      className = _ref.className,
+      variant = _ref.variant,
+      feedback = _ref.feedback,
+      validationVariant = _ref.validationVariant,
+      validationFeedback = _ref.validationFeedback,
+      _ref$disableModal = _ref.disableModal,
+      disableModal = _ref$disableModal === void 0 ? false : _ref$disableModal,
+      labelTooltip = _ref.labelTooltip,
+      navigationDescription = _ref.navigationDescription,
+      minValue = _ref.minDate,
+      maxValue = _ref.maxDate,
+      _ref$modalTreshold = _ref.modalTreshold,
+      modalTreshold = _ref$modalTreshold === void 0 ? 1000 : _ref$modalTreshold,
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded$3);
+
+  var CALENDAR_MODAL_MAX_SCREEN_WIDTH = modalTreshold;
+  var datePickerRef = React.useRef(null);
+  var calendarRef = React.useRef(null);
+  var dateFieldRef = React.useRef(null);
+
+  var _useWindowDimensions = utils.useWindowDimensions(),
+      width = _useWindowDimensions.width;
+
+  var state = datepicker$1.useDatePickerState(_extends({}, rest, {
+    minValue: minValue,
+    maxValue: maxValue,
+    value: value,
+    onChange: onChange
+  }));
+
+  var _useDatePicker = datepicker.useDatePicker(_extends({
+    isDisabled: isDisabled,
+    minValue: minValue,
+    maxValue: maxValue,
+    autoFocus: true
+  }, rest), state, datePickerRef),
+      groupProps = _useDatePicker.groupProps,
+      labelProps = _useDatePicker.labelProps,
+      fieldProps = _useDatePicker.fieldProps,
+      buttonProps = _useDatePicker.buttonProps,
+      dialogProps = _useDatePicker.dialogProps,
+      calendarProps = _useDatePicker.calendarProps; // calculations for floating-UI popover position
+
+
+  var _useFloating = reactDom.useFloating({
+    whileElementsMounted: reactDom.autoUpdate,
+    placement: 'bottom-start',
+    middleware: [reactDom.offset(tokens.space.extraSmall), reactDom.flip(), reactDom.shift({
+      padding: tokens.space.extraSmall
+    })]
+  }),
+      x = _useFloating.x,
+      y = _useFloating.y,
+      reference = _useFloating.reference,
+      floating = _useFloating.floating,
+      strategy = _useFloating.strategy;
+
+  var onChangeCalendar = function onChangeCalendar(newSelectedDate) {
+    // Necessary to avoid state update on unmounted component
+    requestAnimationFrame(function () {
+      calendarProps.onChange && calendarProps.onChange(newSelectedDate);
+    });
+  };
+
+  utils.useOnClickOutside([calendarRef], function () {
+    state.setOpen(false);
+  });
+  utils.useOnEscape(calendarRef, function () {
+    state.setOpen(false);
+  });
+
+  var calendarSharedProps = _extends({}, dialogProps, calendarProps, {
+    disabled: calendarProps.isDisabled,
+    navigationDescription: navigationDescription,
+    onSelectedCellClick: function onSelectedCellClick() {
+      return state.setOpen(false);
+    },
+    onChange: onChangeCalendar
+  });
+
+  var useModal = width <= CALENDAR_MODAL_MAX_SCREEN_WIDTH && !disableModal;
+  var popoverCalendar = React__default["default"].createElement("div", {
+    // styling for floating-UI popover
+    style: {
+      position: strategy,
+      top: y != null ? y : 0,
+      left: x != null ? x : 0,
+      zIndex: tokens.zIndexes.popover
+    },
+    ref: function ref(node) {
+      floating(node);
+    }
+  }, React__default["default"].createElement(FocusLock__default["default"], {
+    disabled: !state.isOpen || useModal,
+    returnFocus: true
+  }, state.isOpen && React__default["default"].createElement(Calendar, _extends({}, calendarSharedProps, {
+    ref: calendarRef
+  }))));
+  var modalCalendar = React__default["default"].createElement(modal.Modal, {
+    size: "small",
+    title: "",
+    open: state.isOpen,
+    onDismiss: function onDismiss() {
+      return state.setOpen(false);
+    },
+    closeOnClickOutside: true,
+    className: "eds-datepicker__calendar-modal"
+  }, React__default["default"].createElement(Calendar, _extends({}, calendarSharedProps)));
+  return React__default["default"].createElement(utils.ConditionalWrapper, {
+    condition: locale !== undefined,
+    wrapper: function wrapper(child) {
+      return React__default["default"].createElement(i18n.I18nProvider, {
+        locale: locale
+      }, child);
+    }
+  }, React__default["default"].createElement("div", {
+    className: classNames__default["default"]('eds-datepicker', className)
+  }, React__default["default"].createElement("div", _extends({}, groupProps, {
+    ref: function ref(node) {
+      datePickerRef.current = node;
+      reference(node);
+    },
+    id: undefined,
+    className: "eds-datepicker__datefield__wrapper"
+  }), React__default["default"].createElement(DateField, _extends({}, fieldProps, {
+    selectedDate: state.value,
+    label: rest.label,
+    labelProps: labelProps,
+    showTime: showTime,
+    showTimeZone: showTimeZone,
+    ref: dateFieldRef,
+    variant: variant,
+    feedback: feedback,
+    validationVariant: validationVariant,
+    validationFeedback: validationFeedback,
+    labelTooltip: labelTooltip,
+    className: classNames__default["default"]('eds-datepicker__datefield', {
+      'eds-datepicker__datefield--disabled': fieldProps.isDisabled
+    })
+  })), !fieldProps.isDisabled && React__default["default"].createElement(CalendarButton, _extends({}, buttonProps, {
+    onPress: function onPress() {
+      return state.setOpen(!state.isOpen);
+    },
+    className: "eds-datepicker__open-calendar-button"
+  }), React__default["default"].createElement(icons.CalendarIcon, null)), useModal ? modalCalendar : popoverCalendar)));
+};
+
 var _excluded$2 = ["className", "style", "label", "onChange", "feedback", "variant", "disableLabelAnimation", "prepend"],
     _excluded2$1 = ["onChange", "variant", "value"];
 var NativeDatePicker = /*#__PURE__*/React__default["default"].forwardRef(function (_ref, ref) {
@@ -565,33 +1109,6 @@ var NativeDatePickerBase = /*#__PURE__*/React__default["default"].forwardRef(fun
   }, rest));
 });
 
-var TimeSegment = function TimeSegment(_ref) {
-  var segment = _ref.segment,
-      state = _ref.state;
-  var ref = React.useRef(null);
-
-  var _useDateSegment = datepicker.useDateSegment(segment, state, ref),
-      segmentProps = _useDateSegment.segmentProps;
-
-  var is12HourFormatted = state.segments.some(function (segment) {
-    return segment.text === 'AM' || segment.text === 'PM';
-  });
-
-  var segmentDisplayText = function segmentDisplayText() {
-    if (is12HourFormatted) return segment.text; // if number add '0' padding to start when one digit
-
-    if (segment.text.match(/\d+/)) return segment.text.padStart(2, '0');
-    return segment.text;
-  };
-
-  return React__default["default"].createElement("div", _extends({}, segmentProps, {
-    ref: ref,
-    className: classNames__default["default"]('eds-timepicker__segment', {
-      'eds-timepicker__segment--placeholder': segment.isPlaceholder
-    })
-  }), segmentDisplayText());
-};
-
 var TimePickerArrowButton = function TimePickerArrowButton(_ref) {
   var direction = _ref.direction,
       onClick = _ref.onClick,
@@ -706,7 +1223,7 @@ var TimePicker = /*#__PURE__*/React__default["default"].forwardRef(function (_re
     variant: variant,
     feedback: feedback
   }), state.segments.map(function (segment, i) {
-    return React__default["default"].createElement(TimeSegment, {
+    return React__default["default"].createElement(FieldSegment, {
       segment: segment,
       state: state,
       key: i
@@ -794,71 +1311,17 @@ var NativeTimePickerBase = /*#__PURE__*/React__default["default"].forwardRef(fun
   }, rest));
 });
 
-/**
- * Tar inn et JS Date-objekt og returnerer et av TimeValue-objektene fra @internationalized/date-pakken
- * @param {Date} date JS Date-objekt som ønskes konvertert til et TimeValue-objekt
- * @param {boolean} noDateOnlyTime Hvis datoen er irrelevant kan denne settes til true, da får man et Time-objekt uten dato tilbake
- * @param {string} timeZone Tidssonen på IANA-formatet som tidpunktet skal konverteres til. Utelates denne får man et tidspunkt uten tidssone. Kan brukes med og uten en UTC-offset Vær obs på annen oppførsel med offset, les mer på beskrivelsen av offset
- * @param {number} offset UTC-offset i millisekunder, må brukes med en tidssone. Ved å legge på en offset lager du en variant av en tidssone. Det betyr at tidspunktet ikke endres (time, minutt, sekund uendret), men tidssonen, med tilhørende offset, tidspunktet er i endres.
- * @returns {Time | CalendarDateTime | ZonedDateTime} et av TimeValue-objektene med verdier fra date
- */
-
-var nativeDateToTimeValue = function nativeDateToTimeValue(date$1, noDateOnlyTime, timeZone, offset) {
-  if (noDateOnlyTime === void 0) {
-    noDateOnlyTime = false;
-  }
-
-  if (timeZone) {
-    if (offset) {
-      return new date.ZonedDateTime(date$1.getFullYear(), date$1.getMonth() + 1, date$1.getDate(), timeZone, offset, date$1.getHours(), date$1.getMinutes(), date$1.getSeconds());
-    }
-
-    return date.parseAbsolute(date$1.toISOString(), timeZone);
-  }
-
-  if (noDateOnlyTime) return new date.Time(date$1.getHours(), date$1.getMinutes(), date$1.getSeconds(), 0);
-  return new date.CalendarDateTime(date$1.getFullYear(), date$1.getMonth() + 1, date$1.getDate(), date$1.getHours(), date$1.getMinutes(), date$1.getSeconds());
-};
-/**
- * Tar inn et av TimeValue-objektene fra @internationalized/date-pakken og returnerer et JS Date-objekt
- * @param {TimeValue} time Et tidspunkt på TimeValue-formatet som ønsket konvertert til et JS Date-objekt
- * @param {string} timeZoneForCalendarDateTime Tidssonen time er i. Fungerer kun med typen er CalendarDateTime
- * @returns {Date} et Date-objekt med verdier fra time
- */
-// This function uses a lot of @ts-expect-error to make it work with all TimeValue types. Sorry ...
-
-var timeValueToNativeDate = function timeValueToNativeDate(time, timeZoneForCalendarDateTime) {
-  // @ts-expect-error .day does not exist on Time-object
-  if (!time.day) {
-    // type is Time
-    var date = new Date();
-    date.setHours(time.hour);
-    date.setMinutes(time.minute);
-    date.setSeconds(time.second);
-    return date;
-  } // @ts-expect-error .timeZone does not exist in type Time and CalendarDateTime
-
-
-  if (!time.timeZone) {
-    // type is CalendarDateTime
-    if (timeZoneForCalendarDateTime) // @ts-expect-error .toDate(timeZone) does not exist in type Time
-      return time.toDate(timeZoneForCalendarDateTime);
-    return new Date( // @ts-expect-error not in type Time
-    time.year, // @ts-expect-error not in type Time
-    time.month - 1, // @ts-expect-error not in type Time
-    time.day, time.hour, time.minute, time.second);
-  } // @ts-expect-error .toDate() does not exist in type Time or CalendarDateTime
-
-
-  return time.toDate();
-};
-
 utils.warnAboutMissingStyles('datepicker', 'form', 'icons');
 
+exports.Calendar = Calendar;
+exports.DateField = DateField;
 exports.DatePicker = DatePicker;
+exports.DatePickerBeta = DatePickerBeta;
 exports.NativeDatePicker = NativeDatePicker;
 exports.NativeTimePicker = NativeTimePicker;
 exports.TimePicker = TimePicker;
-exports.nativeDateToTimeValue = nativeDateToTimeValue;
-exports.timeValueToNativeDate = timeValueToNativeDate;
+exports.ariaLabelIfNorwegian = ariaLabelIfNorwegian;
+exports.createCalendar = createCalendar;
+exports.nativeDateToTimeOrDateValue = nativeDateToTimeOrDateValue;
+exports.timeOrDateValueToNativeDate = timeOrDateValueToNativeDate;
 //# sourceMappingURL=datepicker.cjs.development.js.map