@skyscanner/backpack-web 25.8.0 → 25.8.3

package/bpk-component-calendar/src/BpkCalendarContainer.js

@@ -1,44 +1,31 @@
-"use strict";
+/*
+ * Backpack - Skyscanner's Design System
+ *
+ * Copyright 2016 Skyscanner Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.withCalendarState = exports.default = void 0;
-var _react = require("react");
-var _bpkReactUtils = require("../../bpk-react-utils");
-var _customProptypes = require("./custom-proptypes");
-var _BpkCalendarNav = _interopRequireDefault(require("./BpkCalendarNav"));
-var _BpkCalendarGrid = require("./BpkCalendarGrid");
-var _BpkCalendarGridHeader = _interopRequireDefault(require("./BpkCalendarGridHeader"));
-var _BpkCalendarDate = _interopRequireDefault(require("./BpkCalendarDate"));
-var _composeCalendar = _interopRequireDefault(require("./composeCalendar"));
-var _dateUtils = require("./date-utils");
-var _jsxRuntime = require("react/jsx-runtime");
-const _excluded = ["maxDate", "minDate", "onDateSelect", "onMonthChange", "selectionConfiguration"];
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } /*
-                                                                                                                                                                                                                                                                                                                                                                                           * Backpack - Skyscanner's Design System
-                                                                                                                                                                                                                                                                                                                                                                                           *
-                                                                                                                                                                                                                                                                                                                                                                                           * Copyright 2016 Skyscanner Ltd
-                                                                                                                                                                                                                                                                                                                                                                                           *
-                                                                                                                                                                                                                                                                                                                                                                                           * Licensed under the Apache License, Version 2.0 (the "License");
-                                                                                                                                                                                                                                                                                                                                                                                           * you may not use this file except in compliance with the License.
-                                                                                                                                                                                                                                                                                                                                                                                           * You may obtain a copy of the License at
-                                                                                                                                                                                                                                                                                                                                                                                           *
-                                                                                                                                                                                                                                                                                                                                                                                           *   http://www.apache.org/licenses/LICENSE-2.0
-                                                                                                                                                                                                                                                                                                                                                                                           *
-                                                                                                                                                                                                                                                                                                                                                                                           * Unless required by applicable law or agreed to in writing, software
-                                                                                                                                                                                                                                                                                                                                                                                           * distributed under the License is distributed on an "AS IS" BASIS,
-                                                                                                                                                                                                                                                                                                                                                                                           * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-                                                                                                                                                                                                                                                                                                                                                                                           * See the License for the specific language governing permissions and
-                                                                                                                                                                                                                                                                                                                                                                                           * limitations under the License.
-                                                                                                                                                                                                                                                                                                                                                                                           */
+import { Component } from 'react';
+import { isRTL } from "../../bpk-react-utils";
+import { CALENDAR_SELECTION_TYPE } from "./custom-proptypes";
+import BpkCalendarNav from "./BpkCalendarNav";
+import { BpkCalendarGridWithTransition } from "./BpkCalendarGrid";
+import BpkCalendarGridHeader from "./BpkCalendarGridHeader";
+import BpkCalendarDate from "./BpkCalendarDate";
+import composeCalendar from "./composeCalendar";
+import { addDays, addMonths, dateToBoundaries, isAfter, isSameMonth, isSameDay, lastDayOfMonth, setMonthYear, startOfDay, startOfMonth } from "./date-utils";
+import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * Updates the current focused date
  * @param {Object} currentProps current input properties
@@ -48,8 +35,8 @@ function _toPrimitive(input, hint) { if (typeof input !== "object" || input ===
 const focusedDateHasChanged = (currentProps, nextProps) => {
   const currentSelectConfig = currentProps.selectionConfiguration;
   const nextSelectConfig = nextProps.selectionConfiguration;
-  const rawNextSelectedDate = nextSelectConfig.type === _customProptypes.CALENDAR_SELECTION_TYPE.single ? nextSelectConfig.date : nextSelectConfig.startDate;
-  const rawSelectedDate = currentSelectConfig.type === _customProptypes.CALENDAR_SELECTION_TYPE.single ? currentSelectConfig.date : currentSelectConfig.startDate;
+  const rawNextSelectedDate = nextSelectConfig.type === CALENDAR_SELECTION_TYPE.single ? nextSelectConfig.date : nextSelectConfig.startDate;
+  const rawSelectedDate = currentSelectConfig.type === CALENDAR_SELECTION_TYPE.single ? currentSelectConfig.date : currentSelectConfig.startDate;
   if (!rawSelectedDate && !rawNextSelectedDate) {
     return false;
   }
@@ -58,7 +45,7 @@ const focusedDateHasChanged = (currentProps, nextProps) => {
   }
 
   // @ts-expect-error TS reporting incorrectly as we are already checking above that the dates are not null
-  return !(0, _dateUtils.isSameDay)(rawNextSelectedDate, rawSelectedDate);
+  return !isSameDay(rawNextSelectedDate, rawSelectedDate);
 };
 
 /**
@@ -71,10 +58,10 @@ const focusedDateHasChanged = (currentProps, nextProps) => {
  */
 const determineFocusedDate = (rawSelectedDate, initiallyFocusedDate, minDate, maxDate) => {
   if (rawSelectedDate) {
-    return (0, _dateUtils.dateToBoundaries)(rawSelectedDate, minDate, maxDate);
+    return dateToBoundaries(rawSelectedDate, minDate, maxDate);
   }
   if (initiallyFocusedDate) {
-    return (0, _dateUtils.dateToBoundaries)(initiallyFocusedDate, minDate, maxDate);
+    return dateToBoundaries(initiallyFocusedDate, minDate, maxDate);
   }
   return minDate;
 };
@@ -87,10 +74,10 @@ const determineFocusedDate = (rawSelectedDate, initiallyFocusedDate, minDate, ma
 const getRawSelectedDate = selectionConfig => {
   let rawDate = [];
   switch (selectionConfig.type) {
-    case _customProptypes.CALENDAR_SELECTION_TYPE.single:
+    case CALENDAR_SELECTION_TYPE.single:
       rawDate = [selectionConfig.date];
       break;
-    case _customProptypes.CALENDAR_SELECTION_TYPE.range:
+    case CALENDAR_SELECTION_TYPE.range:
       rawDate = [selectionConfig.startDate, selectionConfig.endDate];
       break;
     default:
@@ -100,124 +87,25 @@ const getRawSelectedDate = selectionConfig => {
   return rawDate;
 };
 const withCalendarState = Calendar => {
-  class BpkCalendarContainer extends _react.Component {
+  class BpkCalendarContainer extends Component {
+    static defaultProps = {
+      fixedWidth: true,
+      maxDate: addMonths(new Date(), 12),
+      minDate: new Date(),
+      onDateSelect: null,
+      onMonthChange: null,
+      selectionConfiguration: {
+        type: CALENDAR_SELECTION_TYPE.single,
+        date: null
+      },
+      initiallyFocusedDate: null,
+      markToday: true,
+      markOutsideDays: true
+    };
     constructor(props) {
       super(props);
-      _defineProperty(this, "handleDateFocus", (event, {
-        date,
-        source
-      }) => {
-        const {
-          onMonthChange
-        } = this.props;
-        const focusedDate = (0, _dateUtils.dateToBoundaries)(date, (0, _dateUtils.startOfDay)(this.props.minDate), (0, _dateUtils.startOfDay)(this.props.maxDate));
-        const didMonthChange = !(0, _dateUtils.isSameMonth)(this.state.focusedDate, focusedDate);
-        this.setState({
-          preventKeyboardFocus: false,
-          focusedDate
-        }, () => {
-          if (onMonthChange && didMonthChange) {
-            onMonthChange(event, {
-              month: (0, _dateUtils.startOfMonth)(focusedDate),
-              source
-            });
-          }
-        });
-      });
-      _defineProperty(this, "handleDateSelect", date => {
-        const {
-          onDateSelect,
-          selectionConfiguration
-        } = this.props;
-        const keyboardFocusState = {
-          preventKeyboardFocus: false
-        };
-        if (onDateSelect) {
-          const newDate = (0, _dateUtils.dateToBoundaries)(date, (0, _dateUtils.startOfDay)(this.props.minDate), (0, _dateUtils.startOfDay)(this.props.maxDate));
-          if (selectionConfiguration && selectionConfiguration.type === _customProptypes.CALENDAR_SELECTION_TYPE.range && selectionConfiguration.startDate && !selectionConfiguration.endDate && ((0, _dateUtils.isAfter)(newDate, selectionConfiguration.startDate) || (0, _dateUtils.isSameDay)(newDate, selectionConfiguration.startDate))) {
-            onDateSelect(selectionConfiguration.startDate, newDate);
-          } else {
-            onDateSelect(newDate);
-          }
-        } else {
-          this.setState(keyboardFocusState);
-        }
-      });
-      _defineProperty(this, "handleMonthChange", (event, {
-        month,
-        source
-      }) => {
-        this.handleDateFocus(event, {
-          date: (0, _dateUtils.setMonthYear)(this.state.focusedDate, month.getMonth(), month.getFullYear()),
-          source
-        });
-      });
-      _defineProperty(this, "handleDateKeyDown", event => {
-        const reverse = (0, _bpkReactUtils.isRTL)() ? -1 : 1;
-        const {
-          focusedDate
-        } = this.state;
-        const source = 'GRID';
-        let preventDefault = true;
-        switch (event.key) {
-          case 'ArrowRight':
-            this.handleDateFocus(event, {
-              date: (0, _dateUtils.addDays)(focusedDate, reverse * 1),
-              source
-            });
-            break;
-          case 'ArrowLeft':
-            this.handleDateFocus(event, {
-              date: (0, _dateUtils.addDays)(focusedDate, reverse * -1),
-              source
-            });
-            break;
-          case 'ArrowUp':
-            this.handleDateFocus(event, {
-              date: (0, _dateUtils.addDays)(focusedDate, -7),
-              source
-            });
-            break;
-          case 'ArrowDown':
-            this.handleDateFocus(event, {
-              date: (0, _dateUtils.addDays)(focusedDate, 7),
-              source
-            });
-            break;
-          case 'PageUp':
-            this.handleDateFocus(event, {
-              date: (0, _dateUtils.addMonths)(focusedDate, -1),
-              source
-            });
-            break;
-          case 'PageDown':
-            this.handleDateFocus(event, {
-              date: (0, _dateUtils.addMonths)(focusedDate, 1),
-              source
-            });
-            break;
-          case 'Home':
-            this.handleDateFocus(event, {
-              date: (0, _dateUtils.startOfMonth)(focusedDate),
-              source
-            });
-            break;
-          case 'End':
-            this.handleDateFocus(event, {
-              date: (0, _dateUtils.lastDayOfMonth)(focusedDate),
-              source
-            });
-            break;
-          default:
-            preventDefault = false;
-            break;
-        }
-        if (preventDefault) {
-          event.preventDefault();
-        }
-      });
-      const minDate = (0, _dateUtils.startOfDay)(this.props.minDate);
-      const maxDate = (0, _dateUtils.startOfDay)(this.props.maxDate);
+      const minDate = startOfDay(this.props.minDate);
+      const maxDate = startOfDay(this.props.maxDate);
       const rawSelectedDate = getRawSelectedDate(this.props.selectionConfiguration);
       const {
         initiallyFocusedDate
@@ -229,58 +117,155 @@ const withCalendarState = Calendar => {
     }
     UNSAFE_componentWillReceiveProps(nextProps) {
       const rawNextSelectedDate = getRawSelectedDate(nextProps.selectionConfiguration);
-      const minDate = (0, _dateUtils.startOfDay)(nextProps.minDate);
-      const maxDate = (0, _dateUtils.startOfDay)(nextProps.maxDate);
+      const minDate = startOfDay(nextProps.minDate);
+      const maxDate = startOfDay(nextProps.maxDate);
       if (focusedDateHasChanged(this.props, nextProps)) {
         this.setState({
-          focusedDate: (0, _dateUtils.dateToBoundaries)(rawNextSelectedDate[0], minDate, maxDate)
+          focusedDate: dateToBoundaries(rawNextSelectedDate[0], minDate, maxDate)
         });
       }
     }
+    handleDateFocus = (event, {
+      date,
+      source
+    }) => {
+      const {
+        onMonthChange
+      } = this.props;
+      const focusedDate = dateToBoundaries(date, startOfDay(this.props.minDate), startOfDay(this.props.maxDate));
+      const didMonthChange = !isSameMonth(this.state.focusedDate, focusedDate);
+      this.setState({
+        preventKeyboardFocus: false,
+        focusedDate
+      }, () => {
+        if (onMonthChange && didMonthChange) {
+          onMonthChange(event, {
+            month: startOfMonth(focusedDate),
+            source
+          });
+        }
+      });
+    };
+    handleDateSelect = date => {
+      const {
+        onDateSelect,
+        selectionConfiguration
+      } = this.props;
+      const keyboardFocusState = {
+        preventKeyboardFocus: false
+      };
+      if (onDateSelect) {
+        const newDate = dateToBoundaries(date, startOfDay(this.props.minDate), startOfDay(this.props.maxDate));
+        if (selectionConfiguration && selectionConfiguration.type === CALENDAR_SELECTION_TYPE.range && selectionConfiguration.startDate && !selectionConfiguration.endDate && (isAfter(newDate, selectionConfiguration.startDate) || isSameDay(newDate, selectionConfiguration.startDate))) {
+          onDateSelect(selectionConfiguration.startDate, newDate);
+        } else {
+          onDateSelect(newDate);
+        }
+      } else {
+        this.setState(keyboardFocusState);
+      }
+    };
+    handleMonthChange = (event, {
+      month,
+      source
+    }) => {
+      this.handleDateFocus(event, {
+        date: setMonthYear(this.state.focusedDate, month.getMonth(), month.getFullYear()),
+        source
+      });
+    };
+    handleDateKeyDown = event => {
+      const reverse = isRTL() ? -1 : 1;
+      const {
+        focusedDate
+      } = this.state;
+      const source = 'GRID';
+      let preventDefault = true;
+      switch (event.key) {
+        case 'ArrowRight':
+          this.handleDateFocus(event, {
+            date: addDays(focusedDate, reverse * 1),
+            source
+          });
+          break;
+        case 'ArrowLeft':
+          this.handleDateFocus(event, {
+            date: addDays(focusedDate, reverse * -1),
+            source
+          });
+          break;
+        case 'ArrowUp':
+          this.handleDateFocus(event, {
+            date: addDays(focusedDate, -7),
+            source
+          });
+          break;
+        case 'ArrowDown':
+          this.handleDateFocus(event, {
+            date: addDays(focusedDate, 7),
+            source
+          });
+          break;
+        case 'PageUp':
+          this.handleDateFocus(event, {
+            date: addMonths(focusedDate, -1),
+            source
+          });
+          break;
+        case 'PageDown':
+          this.handleDateFocus(event, {
+            date: addMonths(focusedDate, 1),
+            source
+          });
+          break;
+        case 'Home':
+          this.handleDateFocus(event, {
+            date: startOfMonth(focusedDate),
+            source
+          });
+          break;
+        case 'End':
+          this.handleDateFocus(event, {
+            date: lastDayOfMonth(focusedDate),
+            source
+          });
+          break;
+        default:
+          preventDefault = false;
+          break;
+      }
+      if (preventDefault) {
+        event.preventDefault();
+      }
+    };
     render() {
-      const _this$props = this.props,
-        {
-          maxDate,
-          minDate,
-          onDateSelect,
-          onMonthChange,
-          selectionConfiguration
-        } = _this$props,
-        calendarProps = _objectWithoutProperties(_this$props, _excluded);
-      const sanitisedMinDate = (0, _dateUtils.startOfDay)(minDate);
-      const sanitisedMaxDate = (0, _dateUtils.startOfDay)(maxDate);
-      const sanitisedFocusedDate = (0, _dateUtils.dateToBoundaries)(this.state.focusedDate, sanitisedMinDate, sanitisedMaxDate);
-      const month = (0, _dateUtils.startOfMonth)(sanitisedFocusedDate);
-      return /*#__PURE__*/(0, _jsxRuntime.jsx)(Calendar, _objectSpread(_objectSpread({
+      const {
+        maxDate,
+        minDate,
+        onDateSelect,
+        onMonthChange,
+        selectionConfiguration,
+        ...calendarProps
+      } = this.props;
+      const sanitisedMinDate = startOfDay(minDate);
+      const sanitisedMaxDate = startOfDay(maxDate);
+      const sanitisedFocusedDate = dateToBoundaries(this.state.focusedDate, sanitisedMinDate, sanitisedMaxDate);
+      const month = startOfMonth(sanitisedFocusedDate);
+      return /*#__PURE__*/_jsx(Calendar, {
         onMonthChange: this.handleMonthChange,
         onDateClick: this.handleDateSelect,
         month: month,
         onDateKeyDown: this.handleDateKeyDown,
         preventKeyboardFocus: this.state.preventKeyboardFocus,
-        focusedDate: sanitisedFocusedDate
-      }, calendarProps), {}, {
+        focusedDate: sanitisedFocusedDate,
+        ...calendarProps,
         minDate: sanitisedMinDate,
         maxDate: sanitisedMaxDate,
         selectionConfiguration: selectionConfiguration
-      }));
+      });
     }
   }
-  _defineProperty(BpkCalendarContainer, "defaultProps", {
-    fixedWidth: true,
-    maxDate: (0, _dateUtils.addMonths)(new Date(), 12),
-    minDate: new Date(),
-    onDateSelect: null,
-    onMonthChange: null,
-    selectionConfiguration: {
-      type: _customProptypes.CALENDAR_SELECTION_TYPE.single,
-      date: null
-    },
-    initiallyFocusedDate: null,
-    markToday: true,
-    markOutsideDays: true
-  });
   return BpkCalendarContainer;
 };
-exports.withCalendarState = withCalendarState;
-var _default = withCalendarState((0, _composeCalendar.default)(_BpkCalendarNav.default, _BpkCalendarGridHeader.default, _BpkCalendarGrid.BpkCalendarGridWithTransition, _BpkCalendarDate.default));
-exports.default = _default;
+export default withCalendarState(composeCalendar(BpkCalendarNav, BpkCalendarGridHeader, BpkCalendarGridWithTransition, BpkCalendarDate));
+export { withCalendarState };

package/bpk-component-calendar/src/BpkCalendarDate.js

@@ -1,40 +1,27 @@
-"use strict";
+/*
+ * Backpack - Skyscanner's Design System
+ *
+ * Copyright 2016 Skyscanner Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.SELECTION_TYPES = exports.ROW_TYPES = void 0;
-var _react = require("react");
-var _bpkReactUtils = require("../../bpk-react-utils");
-var _BpkCalendarDateModule = _interopRequireDefault(require("./BpkCalendarDate.module.css"));
-var _jsxRuntime = require("react/jsx-runtime");
-const _excluded = ["className", "date", "isBlocked", "isFocused", "isKeyboardFocusable", "isOutside", "isSelected", "isToday", "modifiers", "onClick", "onDateKeyDown", "selectionType", "style"];
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } /*
-                                                                                                                                                                                                                                                                                                                                                                                           * Backpack - Skyscanner's Design System
-                                                                                                                                                                                                                                                                                                                                                                                           *
-                                                                                                                                                                                                                                                                                                                                                                                           * Copyright 2016 Skyscanner Ltd
-                                                                                                                                                                                                                                                                                                                                                                                           *
-                                                                                                                                                                                                                                                                                                                                                                                           * Licensed under the Apache License, Version 2.0 (the "License");
-                                                                                                                                                                                                                                                                                                                                                                                           * you may not use this file except in compliance with the License.
-                                                                                                                                                                                                                                                                                                                                                                                           * You may obtain a copy of the License at
-                                                                                                                                                                                                                                                                                                                                                                                           *
-                                                                                                                                                                                                                                                                                                                                                                                           *   http://www.apache.org/licenses/LICENSE-2.0
-                                                                                                                                                                                                                                                                                                                                                                                           *
-                                                                                                                                                                                                                                                                                                                                                                                           * Unless required by applicable law or agreed to in writing, software
-                                                                                                                                                                                                                                                                                                                                                                                           * distributed under the License is distributed on an "AS IS" BASIS,
-                                                                                                                                                                                                                                                                                                                                                                                           * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-                                                                                                                                                                                                                                                                                                                                                                                           * See the License for the specific language governing permissions and
-                                                                                                                                                                                                                                                                                                                                                                                           * limitations under the License.
-                                                                                                                                                                                                                                                                                                                                                                                           */
-const getClassName = (0, _bpkReactUtils.cssModules)(_BpkCalendarDateModule.default);
-const SELECTION_TYPES = {
+import { PureComponent } from 'react';
+import { cssModules } from "../../bpk-react-utils";
+import STYLES from "./BpkCalendarDate.module.css";
+import { jsx as _jsx } from "react/jsx-runtime";
+const getClassName = cssModules(STYLES);
+export const SELECTION_TYPES = {
   none: 'none',
   single: 'single',
   start: 'start',
@@ -42,20 +29,29 @@ const SELECTION_TYPES = {
   end: 'end',
   sameDay: 'sameDay'
 };
-exports.SELECTION_TYPES = SELECTION_TYPES;
-const ROW_TYPES = {
+export const ROW_TYPES = {
   start: 'start',
   middle: 'middle',
   end: 'end',
   both: 'both'
 };
-exports.ROW_TYPES = ROW_TYPES;
 const navigatedByMonthNudger = () => document?.activeElement?.id && document.activeElement.id.indexOf('month_nudger') !== -1;
-class BpkCalendarDate extends _react.PureComponent {
-  constructor(...args) {
-    super(...args);
-    _defineProperty(this, "button", null);
-  }
+class BpkCalendarDate extends PureComponent {
+  static defaultProps = {
+    className: null,
+    isBlocked: false,
+    isFocused: false,
+    isKeyboardFocusable: true,
+    isOutside: false,
+    isSelected: false,
+    isToday: false,
+    modifiers: {},
+    onClick: null,
+    onDateKeyDown: () => {},
+    preventKeyboardFocus: true,
+    selectionType: SELECTION_TYPES.none,
+    style: {}
+  };
   componentDidMount() {
     if (!this.props.preventKeyboardFocus && this.props.isFocused) {
       // If we got here by clicking the nudger, don't focus this date
@@ -81,24 +77,24 @@ class BpkCalendarDate extends _react.PureComponent {
       this.button?.focus();
     }
   }
+  button = null;
   render() {
-    const _this$props = this.props,
-      {
-        className,
-        date,
-        isBlocked,
-        isFocused,
-        isKeyboardFocusable,
-        isOutside,
-        isSelected,
-        isToday,
-        modifiers,
-        onClick,
-        onDateKeyDown,
-        selectionType,
-        style
-      } = _this$props,
-      buttonProps = _objectWithoutProperties(_this$props, _excluded);
+    const {
+      className,
+      date,
+      isBlocked,
+      isFocused,
+      isKeyboardFocusable,
+      isOutside,
+      isSelected,
+      isToday,
+      modifiers,
+      onClick,
+      onDateKeyDown,
+      selectionType,
+      style,
+      ...buttonProps
+    } = this.props;
     const classNames = [getClassName('bpk-calendar-date')];
     Object.keys(modifiers).forEach(modifier => {
       if (modifiers[modifier](this.props)) {
@@ -124,7 +120,7 @@ class BpkCalendarDate extends _react.PureComponent {
       classNames.push(className);
     }
     delete buttonProps.preventKeyboardFocus;
-    return /*#__PURE__*/(0, _jsxRuntime.jsx)("button", _objectSpread(_objectSpread({
+    return /*#__PURE__*/_jsx("button", {
       type: "button",
       style: style,
       className: classNames.join(' '),
@@ -141,29 +137,13 @@ class BpkCalendarDate extends _react.PureComponent {
       "aria-pressed": isSelected,
       ref: button => {
         this.button = button;
-      }
-    }, buttonProps), {}, {
-      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+      },
+      ...buttonProps,
+      children: /*#__PURE__*/_jsx("span", {
         "aria-hidden": "true",
         children: date.getDate()
       })
-    }));
+    });
   }
 }
-_defineProperty(BpkCalendarDate, "defaultProps", {
-  className: null,
-  isBlocked: false,
-  isFocused: false,
-  isKeyboardFocusable: true,
-  isOutside: false,
-  isSelected: false,
-  isToday: false,
-  modifiers: {},
-  onClick: null,
-  onDateKeyDown: () => {},
-  preventKeyboardFocus: true,
-  selectionType: SELECTION_TYPES.none,
-  style: {}
-});
-var _default = BpkCalendarDate;
-exports.default = _default;
+export default BpkCalendarDate;