@skyscanner/backpack-web 25.7.0-beta.2 → 25.8.0

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

@@ -1,31 +1,44 @@
-/*
- * 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.
- */
+"use strict";
 
-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";
+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.
+                                                                                                                                                                                                                                                                                                                                                                                           */
 /**
  * Updates the current focused date
  * @param {Object} currentProps current input properties
@@ -35,8 +48,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 const focusedDateHasChanged = (currentProps, nextProps) => {
   const currentSelectConfig = currentProps.selectionConfiguration;
   const nextSelectConfig = nextProps.selectionConfiguration;
-  const rawNextSelectedDate = nextSelectConfig.type === CALENDAR_SELECTION_TYPE.single ? nextSelectConfig.date : nextSelectConfig.startDate;
-  const rawSelectedDate = currentSelectConfig.type === CALENDAR_SELECTION_TYPE.single ? currentSelectConfig.date : currentSelectConfig.startDate;
+  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;
   if (!rawSelectedDate && !rawNextSelectedDate) {
     return false;
   }
@@ -45,7 +58,7 @@ const focusedDateHasChanged = (currentProps, nextProps) => {
   }
 
   // @ts-expect-error TS reporting incorrectly as we are already checking above that the dates are not null
-  return !isSameDay(rawNextSelectedDate, rawSelectedDate);
+  return !(0, _dateUtils.isSameDay)(rawNextSelectedDate, rawSelectedDate);
 };
 
 /**
@@ -58,10 +71,10 @@ const focusedDateHasChanged = (currentProps, nextProps) => {
  */
 const determineFocusedDate = (rawSelectedDate, initiallyFocusedDate, minDate, maxDate) => {
   if (rawSelectedDate) {
-    return dateToBoundaries(rawSelectedDate, minDate, maxDate);
+    return (0, _dateUtils.dateToBoundaries)(rawSelectedDate, minDate, maxDate);
   }
   if (initiallyFocusedDate) {
-    return dateToBoundaries(initiallyFocusedDate, minDate, maxDate);
+    return (0, _dateUtils.dateToBoundaries)(initiallyFocusedDate, minDate, maxDate);
   }
   return minDate;
 };
@@ -74,10 +87,10 @@ const determineFocusedDate = (rawSelectedDate, initiallyFocusedDate, minDate, ma
 const getRawSelectedDate = selectionConfig => {
   let rawDate = [];
   switch (selectionConfig.type) {
-    case CALENDAR_SELECTION_TYPE.single:
+    case _customProptypes.CALENDAR_SELECTION_TYPE.single:
       rawDate = [selectionConfig.date];
       break;
-    case CALENDAR_SELECTION_TYPE.range:
+    case _customProptypes.CALENDAR_SELECTION_TYPE.range:
       rawDate = [selectionConfig.startDate, selectionConfig.endDate];
       break;
     default:
@@ -87,25 +100,124 @@ const getRawSelectedDate = selectionConfig => {
   return rawDate;
 };
 const withCalendarState = Calendar => {
-  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
-    };
+  class BpkCalendarContainer extends _react.Component {
     constructor(props) {
       super(props);
-      const minDate = startOfDay(this.props.minDate);
-      const maxDate = startOfDay(this.props.maxDate);
+      _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 rawSelectedDate = getRawSelectedDate(this.props.selectionConfiguration);
       const {
         initiallyFocusedDate
@@ -117,155 +229,58 @@ const withCalendarState = Calendar => {
     }
     UNSAFE_componentWillReceiveProps(nextProps) {
       const rawNextSelectedDate = getRawSelectedDate(nextProps.selectionConfiguration);
-      const minDate = startOfDay(nextProps.minDate);
-      const maxDate = startOfDay(nextProps.maxDate);
+      const minDate = (0, _dateUtils.startOfDay)(nextProps.minDate);
+      const maxDate = (0, _dateUtils.startOfDay)(nextProps.maxDate);
       if (focusedDateHasChanged(this.props, nextProps)) {
         this.setState({
-          focusedDate: dateToBoundaries(rawNextSelectedDate[0], minDate, maxDate)
+          focusedDate: (0, _dateUtils.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 {
-        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, {
+      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({
         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;
 };
-export default withCalendarState(composeCalendar(BpkCalendarNav, BpkCalendarGridHeader, BpkCalendarGridWithTransition, BpkCalendarDate));
-export { withCalendarState };
+exports.withCalendarState = withCalendarState;
+var _default = withCalendarState((0, _composeCalendar.default)(_BpkCalendarNav.default, _BpkCalendarGridHeader.default, _BpkCalendarGrid.BpkCalendarGridWithTransition, _BpkCalendarDate.default));
+exports.default = _default;

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

@@ -1,27 +1,40 @@
-/*
- * 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.
- */
+"use strict";
 
-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 = {
+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 = {
   none: 'none',
   single: 'single',
   start: 'start',
@@ -29,29 +42,20 @@ export const SELECTION_TYPES = {
   end: 'end',
   sameDay: 'sameDay'
 };
-export const ROW_TYPES = {
+exports.SELECTION_TYPES = SELECTION_TYPES;
+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 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: {}
-  };
+class BpkCalendarDate extends _react.PureComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "button", null);
+  }
   componentDidMount() {
     if (!this.props.preventKeyboardFocus && this.props.isFocused) {
       // If we got here by clicking the nudger, don't focus this date
@@ -77,24 +81,24 @@ class BpkCalendarDate extends PureComponent {
       this.button?.focus();
     }
   }
-  button = null;
   render() {
-    const {
-      className,
-      date,
-      isBlocked,
-      isFocused,
-      isKeyboardFocusable,
-      isOutside,
-      isSelected,
-      isToday,
-      modifiers,
-      onClick,
-      onDateKeyDown,
-      selectionType,
-      style,
-      ...buttonProps
-    } = this.props;
+    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 classNames = [getClassName('bpk-calendar-date')];
     Object.keys(modifiers).forEach(modifier => {
       if (modifiers[modifier](this.props)) {
@@ -120,7 +124,7 @@ class BpkCalendarDate extends PureComponent {
       classNames.push(className);
     }
     delete buttonProps.preventKeyboardFocus;
-    return /*#__PURE__*/_jsx("button", {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)("button", _objectSpread(_objectSpread({
       type: "button",
       style: style,
       className: classNames.join(' '),
@@ -137,13 +141,29 @@ class BpkCalendarDate extends PureComponent {
       "aria-pressed": isSelected,
       ref: button => {
         this.button = button;
-      },
-      ...buttonProps,
-      children: /*#__PURE__*/_jsx("span", {
+      }
+    }, buttonProps), {}, {
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
         "aria-hidden": "true",
         children: date.getDate()
       })
-    });
+    }));
   }
 }
-export default BpkCalendarDate;
+_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;