@skyscanner/backpack-web 25.4.0-alpha → 25.4.1

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

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _arrowLeft = _interopRequireDefault(require("../../bpk-component-icon/lg/arrow-left"));
+var _arrowRight = _interopRequireDefault(require("../../bpk-component-icon/lg/arrow-right"));
+var _bpkComponentSelect = _interopRequireDefault(require("../../bpk-component-select"));
+var _bpkReactUtils = require("../../bpk-react-utils");
+var _bpkComponentAriaLive = _interopRequireDefault(require("../../bpk-component-aria-live"));
+var _dateUtils = require("./date-utils");
+var _BpkCalendarNavModule = _interopRequireDefault(require("./BpkCalendarNav.module.css"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * 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.
+ */
+
+// @ts-expect-error Untyped import. See `decisions/imports-ts-suppressions.md`.
+
+// @ts-expect-error Untyped import. See `decisions/imports-ts-suppressions.md`.
+
+// @ts-expect-error Untyped import. See `decisions/imports-ts-suppressions.md`.
+
+const getClassName = (0, _bpkReactUtils.cssModules)(_BpkCalendarNavModule.default);
+const changeMonth = ({
+  callback,
+  max,
+  min,
+  month,
+  source
+}) => event => {
+  // Safeguard for disabled buttons is due to React bug in Chrome: https://github.com/facebook/react/issues/8308
+  // PR: https://github.com/facebook/react/pull/8329 - unresolved as of 22/12/2016
+  if ((0, _dateUtils.isWithinRange)(month, {
+    start: min,
+    end: max
+  })) {
+    event.persist();
+    callback(event, {
+      month,
+      source
+    });
+  }
+};
+const BpkCalendarNav = ({
+  changeMonthLabel,
+  disabled = false,
+  formatMonth,
+  id,
+  maxDate,
+  minDate,
+  month,
+  nextMonthLabel,
+  onMonthChange = () => {},
+  previousMonthLabel
+}) => {
+  const baseMonth = (0, _dateUtils.startOfMonth)(month);
+  const {
+    max,
+    min
+  } = (0, _dateUtils.getMonthRange)(minDate, maxDate);
+  const navigatableMonths = (0, _dateUtils.getMonthsInRange)(minDate, maxDate);
+  const prevMonth = (0, _dateUtils.addMonths)(baseMonth, -1);
+  const nextMonth = (0, _dateUtils.addMonths)(baseMonth, 1);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+    className: getClassName('bpk-calendar-nav'),
+    children: /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+      style: {
+        display: 'table-row'
+      },
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+        className: getClassName('bpk-calendar-nav__nudger'),
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)("button", {
+          type: "button",
+          className: getClassName('bpk-calendar-nav__button'),
+          id: `${id}_month_nudger_previous`,
+          onClick: changeMonth({
+            month: prevMonth,
+            min,
+            max,
+            callback: onMonthChange,
+            source: 'PREV'
+          }),
+          disabled: disabled || !(0, _dateUtils.isWithinRange)(prevMonth, {
+            start: min,
+            end: max
+          }),
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_arrowLeft.default, {
+            className: getClassName('bpk-calendar-nav__icon')
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+            className: getClassName('bpk-calendar-nav__text--hidden'),
+            children: previousMonthLabel
+          })]
+        })
+      }), /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+        className: getClassName('bpk-calendar-nav__month'),
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("label", {
+          htmlFor: `${id}_select`,
+          className: getClassName('bpk-calendar-nav__text--hidden'),
+          children: changeMonthLabel
+        }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_bpkComponentSelect.default, {
+          id: `${id}_select`,
+          name: "months",
+          value: (0, _dateUtils.formatIsoMonth)(baseMonth),
+          disabled: disabled,
+          onChange: event => {
+            event.persist();
+            onMonthChange(event, {
+              month: (0, _dateUtils.parseIsoDate)(event.target.value),
+              source: 'SELECT'
+            });
+          },
+          children: navigatableMonths.map(m => /*#__PURE__*/(0, _jsxRuntime.jsx)("option", {
+            value: (0, _dateUtils.formatIsoMonth)(m),
+            children: formatMonth(m)
+          }, m.toString()))
+        })]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+        className: getClassName('bpk-calendar-nav__nudger'),
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)("button", {
+          type: "button",
+          className: getClassName('bpk-calendar-nav__button'),
+          id: `${id}_month_nudger_next`,
+          onClick: changeMonth({
+            month: nextMonth,
+            min,
+            max,
+            callback: onMonthChange,
+            source: 'NEXT'
+          }),
+          disabled: disabled || !(0, _dateUtils.isWithinRange)((0, _dateUtils.addMonths)(baseMonth, 1), {
+            start: min,
+            end: max
+          }),
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_arrowRight.default, {
+            className: getClassName('bpk-calendar-nav__icon')
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+            className: getClassName('bpk-calendar-nav__text--hidden'),
+            children: nextMonthLabel
+          })]
+        })
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_bpkComponentAriaLive.default, {
+        children: formatMonth(baseMonth)
+      })]
+    })
+  });
+};
+var _default = BpkCalendarNav;
+exports.default = _default;

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

@@ -0,0 +1,333 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _bpkReactUtils = require("../../bpk-react-utils");
+var _dateUtils = require("./date-utils");
+var _customProptypes = require("./custom-proptypes");
+var _BpkCalendarGridModule = _interopRequireDefault(require("./BpkCalendarGrid.module.css"));
+var _BpkCalendarDate = require("./BpkCalendarDate");
+var _jsxRuntime = require("react/jsx-runtime");
+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 _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.
+                                                                                                                                                                                                                                                                                                                                                                                           */ // TODO: Move this to `Week.scss`
+// This should be using its own css file as `BpkCalendarGrid` is also importing `BpkCalendarGrid.module.css`
+// and the order of css imports can break the component.
+const getClassName = (0, _bpkReactUtils.cssModules)(_BpkCalendarGridModule.default);
+const shallowEqualProps = (props1, props2, propList) => {
+  let i = 0;
+  for (; i < propList.length; i += 1) {
+    if (props1[propList[i]] !== props2[propList[i]]) {
+      return false;
+    }
+  }
+  return true;
+};
+function or(total, bool) {
+  return total || bool;
+}
+
+/**
+ * Determines if the current date is selected
+ * @param {Date} date the current date from the calendar
+ * @param {Object} selectionConfiguration the current selection configuration
+ * @returns {Boolean} true is selected and false if not
+ */
+function getSelectedDate(date, selectionConfiguration) {
+  let startDate;
+  let endDate;
+  if (selectionConfiguration.type === _customProptypes.CALENDAR_SELECTION_TYPE.single) {
+    startDate = selectionConfiguration.date;
+  } else {
+    startDate = selectionConfiguration.startDate;
+    endDate = selectionConfiguration.endDate;
+  }
+  const sameStartDay = startDate && (0, _dateUtils.isSameDay)(date, startDate);
+  const sameEndDay = endDate && (0, _dateUtils.isSameDay)(date, endDate);
+  if (startDate && endDate && (sameStartDay || sameEndDay || (0, _dateUtils.isWithinRange)(date, {
+    start: startDate,
+    end: endDate
+  })) || startDate && !endDate && sameStartDay || sameStartDay) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Gets the correct selection type for the current date
+ * @param {Date} date the current date of the calendar
+ * @param {Object} selectionConfiguration the current selection configuration
+ * @param {Function} formatDateFull function to format dates
+ * @param {Date} month the current month of the calendar
+ * @param {Number} weekStartsOn index of the first day of the week
+ * @param {Boolean} ignoreOutsideDate ignore date outside current month
+ * @returns {String} selection type to be passed to the date
+ */
+function getSelectionType(date, selectionConfiguration, formatDateFull, month, weekStartsOn, ignoreOutsideDate) {
+  const {
+    endDate,
+    startDate
+  } = selectionConfiguration.type === _customProptypes.CALENDAR_SELECTION_TYPE.range ? selectionConfiguration : {
+    startDate: null,
+    endDate: null
+  };
+  const sameStartDay = startDate && (0, _dateUtils.isSameDay)(date, startDate);
+  const sameEndDay = endDate && (0, _dateUtils.isSameDay)(date, endDate);
+  const rangeDates = startDate && endDate;
+  const isEmptyCell = !(0, _dateUtils.isSameMonth)(date, month) && ignoreOutsideDate;
+  if (selectionConfiguration.type === _customProptypes.CALENDAR_SELECTION_TYPE.single && selectionConfiguration.date && (selectionConfiguration.date === formatDateFull(date) || formatDateFull(selectionConfiguration.date) === formatDateFull(date))) {
+    return _BpkCalendarDate.SELECTION_TYPES.single;
+  }
+  if (selectionConfiguration.type === _customProptypes.CALENDAR_SELECTION_TYPE.range) {
+    if (startDate && !endDate && sameStartDay || rangeDates && sameStartDay && sameEndDay) {
+      return _BpkCalendarDate.SELECTION_TYPES.single;
+    }
+    if (isEmptyCell && rangeDates && ((0, _dateUtils.isSameWeek)(startDate, (0, _dateUtils.startOfMonth)(startDate), {
+      weekStartsOn
+    }) && (0, _dateUtils.isSameWeek)(date, startDate, {
+      weekStartsOn
+    }) || (0, _dateUtils.isSameWeek)(endDate, (0, _dateUtils.endOfMonth)(endDate), {
+      weekStartsOn
+    }) && (0, _dateUtils.isSameWeek)(date, endDate, {
+      weekStartsOn
+    }))) {
+      return _BpkCalendarDate.SELECTION_TYPES.none;
+    }
+    if (isEmptyCell && rangeDates && !(0, _dateUtils.isSameMonth)(startDate, endDate) && ((0, _dateUtils.isSameWeek)(startDate, (0, _dateUtils.endOfMonth)(startDate), {
+      weekStartsOn
+    }) && (0, _dateUtils.isSameWeek)(date, startDate, {
+      weekStartsOn
+    }) || (0, _dateUtils.isSameWeek)(endDate, (0, _dateUtils.startOfMonth)(endDate), {
+      weekStartsOn
+    }) && (0, _dateUtils.isSameWeek)(date, endDate, {
+      weekStartsOn
+    }))) {
+      return _BpkCalendarDate.SELECTION_TYPES.middle;
+    }
+    if (rangeDates && (0, _dateUtils.isWithinRange)(date, {
+      start: startDate,
+      end: endDate
+    }) && !sameStartDay && !sameEndDay) {
+      return _BpkCalendarDate.SELECTION_TYPES.middle;
+    }
+    if (startDate && formatDateFull(startDate) === formatDateFull(date)) {
+      return _BpkCalendarDate.SELECTION_TYPES.start;
+    }
+    if (endDate && formatDateFull(endDate) === formatDateFull(date)) {
+      return _BpkCalendarDate.SELECTION_TYPES.end;
+    }
+  }
+  return _BpkCalendarDate.SELECTION_TYPES.none;
+}
+
+/**
+ * Handles changing selected date when in single mode
+ * @param {Object} props current props
+ * @param {Object} nextProps next props as the component is updating
+ * @returns {Boolean} based on if the date has changed
+ */
+const singleDateHandler = (props, nextProps) => {
+  const currentSelectConfig = props.selectionConfiguration;
+  const nextSelectConfig = nextProps.selectionConfiguration;
+  if ((nextSelectConfig.date && (0, _dateUtils.isSameWeek)(nextSelectConfig.date, nextProps.dates[0], {
+    weekStartsOn: nextProps.weekStartsOn
+  }) || currentSelectConfig.date && (0, _dateUtils.isSameWeek)(currentSelectConfig.date, props.dates[0], {
+    weekStartsOn: props.weekStartsOn
+  })) && currentSelectConfig.date !== nextSelectConfig.date) {
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Handles changing selected date when in range mode
+ * @param {Object} props current props
+ * @param {Object} nextProps next props as the component is updating
+ * @returns {Boolean} based on if the date has changed
+ */
+const rangeDateHandler = (props, nextProps) => {
+  const {
+    endDate,
+    startDate
+  } = props.selectionConfiguration;
+  const {
+    endDate: nextEndDate,
+    startDate: nextStartDate
+  } = nextProps.selectionConfiguration;
+  const startDateChanged = startDate && nextStartDate && !(0, _dateUtils.isSameDay)(startDate, nextStartDate);
+  const endDateChanged = endDate && nextEndDate && !(0, _dateUtils.isSameDay)(endDate, nextEndDate);
+  if (startDateChanged || endDateChanged) {
+    return true;
+  }
+  return false;
+};
+/*
+  Week - table row containing a week full of DateContainer components
+*/
+class Week extends _react.Component {
+  shouldComponentUpdate(nextProps) {
+    const shallowProps = ['DateComponent', 'dateModifiers', 'formatDateFull', 'isKeyboardFocusable', 'markOutsideDays', 'markToday', 'onDateClick', 'onDateKeyDown', 'preventKeyboardFocus', 'weekStartsOn', 'dates', 'cellClassName'];
+
+    // If any of the props have changed, component should update.
+    if (!shallowEqualProps(this.props, nextProps, shallowProps)) {
+      return true;
+    }
+
+    // If focusedDate is changing, and it'll be included as part
+    // of either the week we're rendering now or the next week
+    // we'll render, component should update.
+    if ((nextProps.focusedDate && (0, _dateUtils.isSameWeek)(nextProps.focusedDate, nextProps.dates[0], {
+      weekStartsOn: nextProps.weekStartsOn
+    }) || this.props.focusedDate && (0, _dateUtils.isSameWeek)(this.props.focusedDate, this.props.dates[0], {
+      weekStartsOn: this.props.weekStartsOn
+    })) && this.props.focusedDate !== nextProps.focusedDate) {
+      return true;
+    }
+
+    // If selected date is changing, and it'll be included as part
+    // of either the week we're rendering now or the next week we'll
+    // render, component should update.
+    if (this.props.selectionConfiguration?.type === _customProptypes.CALENDAR_SELECTION_TYPE.single && this.props.selectionConfiguration.date) {
+      return singleDateHandler(this.props, nextProps);
+    }
+    if (this.props.selectionConfiguration?.type === _customProptypes.CALENDAR_SELECTION_TYPE.range) {
+      return rangeDateHandler(this.props, nextProps);
+    }
+
+    // If min date is changing, component should update.
+    if (nextProps.minDate) {
+      if (nextProps.minDate !== this.props.minDate) {
+        return true;
+      }
+      if (!(0, _dateUtils.isSameDay)(nextProps.minDate, this.props.minDate)) {
+        return true;
+      }
+    }
+
+    // If max date is changing, component should update.
+    if (nextProps.maxDate) {
+      if (nextProps.maxDate !== this.props.maxDate) {
+        return true;
+      }
+      if (!(0, _dateUtils.isSameDay)(nextProps.maxDate, this.props.maxDate)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  render() {
+    const {
+      DateComponent,
+      cellClassName,
+      dateModifiers,
+      dateProps,
+      focusedDate,
+      formatDateFull,
+      ignoreOutsideDate,
+      isKeyboardFocusable,
+      markOutsideDays,
+      markToday,
+      maxDate,
+      minDate,
+      month,
+      onDateClick,
+      onDateKeyDown,
+      preventKeyboardFocus,
+      selectionConfiguration,
+      weekStartsOn
+    } = this.props;
+    if (ignoreOutsideDate) {
+      const daysOutside = this.props.dates.map(date => (0, _dateUtils.isSameMonth)(date, month));
+      const shouldRender = daysOutside.reduce(or);
+      if (!shouldRender) {
+        return null;
+      }
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+      className: getClassName('bpk-calendar-grid__week'),
+      children: this.props.dates.map(date => {
+        const isBlocked = minDate && maxDate ? !(0, _dateUtils.isWithinRange)(date, {
+          start: minDate,
+          end: maxDate
+        }) : false;
+        const dateSelectionType = getSelectionType(date, selectionConfiguration, formatDateFull, month, weekStartsOn, ignoreOutsideDate);
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(DateContainer, {
+          className: cellClassName,
+          isEmptyCell: !(0, _dateUtils.isSameMonth)(date, month) && ignoreOutsideDate,
+          isBlocked: isBlocked,
+          selectionType: dateSelectionType,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(DateComponent, _objectSpread({
+            date: date,
+            modifiers: dateModifiers,
+            "aria-label": formatDateFull(date),
+            onClick: onDateClick,
+            onDateKeyDown: onDateKeyDown,
+            preventKeyboardFocus: preventKeyboardFocus,
+            isKeyboardFocusable: isKeyboardFocusable,
+            isFocused: focusedDate && (0, _dateUtils.isSameDay)(date, focusedDate),
+            isSelected: getSelectedDate(date, selectionConfiguration),
+            isBlocked: isBlocked,
+            isOutside: markOutsideDays && !(0, _dateUtils.isSameMonth)(date, month),
+            isToday: markToday && (0, _dateUtils.isToday)(date),
+            selectionType: dateSelectionType
+          }, dateProps))
+        }, date.getDate());
+      })
+    });
+  }
+}
+_defineProperty(Week, "defaultProps", {
+  dateProps: {},
+  focusedDate: null,
+  ignoreOutsideDate: false,
+  maxDate: null,
+  minDate: null,
+  onDateClick: () => {},
+  onDateKeyDown: () => {},
+  selectionConfiguration: {
+    type: _customProptypes.CALENDAR_SELECTION_TYPE.single,
+    date: null
+  },
+  cellClassName: null
+});
+/*
+  DateContainer - one for each date in the grid; wraps the actual BpkCalendarDate (or custom) component
+*/
+const DateContainer = ({
+  children,
+  className = null,
+  isBlocked,
+  isEmptyCell,
+  selectionType
+}) => {
+  const classNames = getClassName('bpk-calendar-grid__date', `bpk-calendar-grid__date--${selectionType}`, className);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+    "aria-hidden": isEmptyCell || isBlocked,
+    className: classNames,
+    children: children
+  });
+};
+var _default = Week;
+exports.default = _default;

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

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _bpkReactUtils = require("../../bpk-react-utils");
+var _customProptypes = require("./custom-proptypes");
+var _BpkCalendarModule = _interopRequireDefault(require("./BpkCalendar.module.css"));
+var _jsxRuntime = require("react/jsx-runtime");
+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 _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)(_BpkCalendarModule.default);
+const composeCalendar = (Nav, GridHeader, Grid, CalendarDate) => {
+  const BpkCalendar = ({
+    changeMonthLabel = null,
+    className = null,
+    dateModifiers = {},
+    dateProps = {},
+    daysOfWeek,
+    fixedWidth = true,
+    focusedDate = null,
+    formatDateFull,
+    formatMonth,
+    gridClassName = null,
+    gridProps = {},
+    headerProps = {},
+    id,
+    markOutsideDays = true,
+    markToday = true,
+    maxDate,
+    minDate,
+    month,
+    navProps = {},
+    nextMonthLabel = null,
+    onDateClick = null,
+    onDateKeyDown = null,
+    onMonthChange = null,
+    preventKeyboardFocus = false,
+    previousMonthLabel = null,
+    selectionConfiguration = {
+      type: _customProptypes.CALENDAR_SELECTION_TYPE.single,
+      date: null
+    },
+    weekDayKey = 'nameAbbr',
+    weekStartsOn
+  }) => {
+    const classNames = [getClassName('bpk-calendar')];
+    if (className) {
+      classNames.push(className);
+    }
+    if (fixedWidth) {
+      classNames.push(getClassName('bpk-calendar--fixed'));
+    }
+    const headerClasses = [];
+    // If the Nav is present add `bpk-calendar__header` which
+    // adds spacing between the nav and header.
+    if (Nav) {
+      headerClasses.push(getClassName('bpk-calendar__header'));
+    }
+    const gridClasses = [];
+    // If the GridHeader is not present add `bpk-calendar__grid` which
+    // adds spacing between the nav and grid.
+    if (!GridHeader && Nav) {
+      gridClasses.push(getClassName('bpk-calendar__grid'));
+    }
+    if (gridClassName) {
+      gridClasses.push(gridClassName);
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+      className: classNames.join(' '),
+      children: [Nav && /*#__PURE__*/(0, _jsxRuntime.jsx)(Nav, _objectSpread({
+        changeMonthLabel: changeMonthLabel,
+        formatMonth: formatMonth,
+        id: `${id}__bpk_calendar_nav`,
+        maxDate: maxDate,
+        minDate: minDate,
+        month: month,
+        nextMonthLabel: nextMonthLabel,
+        onMonthChange: onMonthChange,
+        previousMonthLabel: previousMonthLabel
+      }, navProps)), GridHeader && /*#__PURE__*/(0, _jsxRuntime.jsx)(GridHeader, _objectSpread({
+        daysOfWeek: daysOfWeek,
+        weekStartsOn: weekStartsOn,
+        weekDayKey: weekDayKey,
+        className: headerClasses.join(' ')
+      }, headerProps)), /*#__PURE__*/(0, _jsxRuntime.jsx)(Grid, _objectSpread({
+        DateComponent: CalendarDate,
+        dateModifiers: dateModifiers,
+        daysOfWeek: daysOfWeek,
+        formatDateFull: formatDateFull,
+        formatMonth: formatMonth,
+        month: month,
+        onDateClick: onDateClick,
+        onDateKeyDown: onDateKeyDown,
+        preventKeyboardFocus: preventKeyboardFocus,
+        weekStartsOn: weekStartsOn,
+        maxDate: maxDate,
+        minDate: minDate,
+        focusedDate: focusedDate,
+        markToday: markToday,
+        markOutsideDays: markOutsideDays,
+        className: gridClasses.join(' '),
+        dateProps: dateProps,
+        selectionConfiguration: selectionConfiguration
+      }, gridProps))]
+    });
+  };
+  return BpkCalendar;
+};
+var _default = composeCalendar;
+exports.default = _default;