@skyscanner/backpack-web 9.0.0 → 9.1.0-alpha.1

package/bpk-component-datepicker/src/BpkDatepicker.js

@@ -1,192 +1,162 @@
-/*
- * 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 PropTypes from 'prop-types';
-import React, { Component } from 'react';
-
-import BpkInput, { withOpenEvents } from '../../bpk-component-input';
-import BpkModal from '../../bpk-component-modal';
-import BpkPopover from '../../bpk-component-popover';
-import { cssModules, deprecated } from '../../bpk-react-utils';
-import BpkBreakpoint, { BREAKPOINTS } from '../../bpk-component-breakpoint';
-import {
-  composeCalendar,
-  BpkCalendarGridHeader,
-  BpkCalendarGrid,
-  BpkCalendarDate,
-  withCalendarState,
-  CustomPropTypes,
-  CALENDAR_SELECTION_TYPE,
-  DateUtils,
-  BpkCalendarNav,
-} from '../../bpk-component-calendar';
-
-import STYLES from './BpkDatepicker.module.scss';
-
-const getClassName = cssModules(STYLES);
-
-const Input = withOpenEvents(BpkInput);
-
-const DefaultCalendar = withCalendarState(
-  composeCalendar(
-    BpkCalendarNav,
-    BpkCalendarGridHeader,
-    BpkCalendarGrid,
-    BpkCalendarDate,
-  ),
-);
-
-class BpkDatepicker extends Component {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _bpkComponentInput = _interopRequireWildcard(require("../../bpk-component-input"));
+
+var _bpkComponentModal = _interopRequireDefault(require("../../bpk-component-modal"));
+
+var _bpkComponentPopover = _interopRequireDefault(require("../../bpk-component-popover"));
+
+var _bpkReactUtils = require("../../bpk-react-utils");
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _bpkComponentBreakpoint = _interopRequireWildcard(require("../../bpk-component-breakpoint"));
+
+var _bpkComponentCalendar = require("../../bpk-component-calendar");
+
+const _excluded = ["calendarComponent", "changeMonthLabel", "closeButtonText", "dateModifiers", "daysOfWeek", "fixedWidth", "formatDate", "formatDateFull", "formatMonth", "getApplicationElement", "id", "initiallyFocusedDate", "inputComponent", "inputProps", "markOutsideDays", "markToday", "maxDate", "minDate", "nextMonthLabel", "onMonthChange", "previousMonthLabel", "renderTarget", "selectionConfiguration", "title", "valid", "weekStartsOn"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+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) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var STYLES = {
+  "bpk-datepicker__calendar": "BpkDatepicker-module__bpk-datepicker__calendar___1Xd_X",
+  "bpk-datepicker__input": "BpkDatepicker-module__bpk-datepicker__input___1FaeZ",
+  "bpk-keyframe-spin": "BpkDatepicker-module__bpk-keyframe-spin___1urft"
+};
+const getClassName = (0, _bpkReactUtils.cssModules)(STYLES);
+const Input = (0, _bpkComponentInput.withOpenEvents)(_bpkComponentInput.default);
+const DefaultCalendar = (0, _bpkComponentCalendar.withCalendarState)((0, _bpkComponentCalendar.composeCalendar)(_bpkComponentCalendar.BpkCalendarNav, _bpkComponentCalendar.BpkCalendarGridHeader, _bpkComponentCalendar.BpkCalendarGrid, _bpkComponentCalendar.BpkCalendarDate));
+
+class BpkDatepicker extends _react.Component {
   constructor(props) {
     super(props);
 
-    this.state = {
-      isOpen: props.isOpen,
-    };
-    this.inputRef = React.createRef();
-  }
-
-  componentDidUpdate(prevProps, prevState) {
-    const { isOpen } = this.props;
+    _defineProperty(this, "onOpen", () => {
+      this.setState({
+        isOpen: true
+      });
 
-    if (prevProps.isOpen !== isOpen && prevState.isOpen !== isOpen) {
-      if (isOpen) {
-        this.onOpen();
-      } else {
-        this.onClose();
+      if (this.props.onOpenChange) {
+        this.props.onOpenChange(true);
       }
-    }
-  }
+    });
 
-  onOpen = () => {
-    this.setState({
-      isOpen: true,
+    _defineProperty(this, "onClose", () => {
+      this.setState({
+        isOpen: false
+      });
+
+      if (this.props.onOpenChange) {
+        this.props.onOpenChange(false);
+      }
     });
-    if (this.props.onOpenChange) {
-      this.props.onOpenChange(true);
-    }
-  };
 
-  onClose = () => {
-    this.setState({
-      isOpen: false,
+    _defineProperty(this, "getLabel", (selectionConfiguration, formatDateFull) => {
+      if (selectionConfiguration.type === _bpkComponentCalendar.CALENDAR_SELECTION_TYPE.single && selectionConfiguration.date) {
+        return formatDateFull(selectionConfiguration.date);
+      }
+
+      if (selectionConfiguration.type === _bpkComponentCalendar.CALENDAR_SELECTION_TYPE.range) {
+        if (selectionConfiguration.startDate && !selectionConfiguration.endDate) {
+          return formatDateFull(selectionConfiguration.startDate);
+        }
+
+        if (selectionConfiguration.startDate && selectionConfiguration.endDate) {
+          return `${formatDateFull(selectionConfiguration.startDate)} - ${formatDateFull(selectionConfiguration.endDate)}`;
+        }
+      }
+
+      return '';
     });
-    if (this.props.onOpenChange) {
-      this.props.onOpenChange(false);
-    }
-  };
-
-  /**
-   * Gets the correct label for the input field to be supplied to the aria-label
-   * @param {Object} selectionConfiguration current selection configuration
-   * @param {Function} formatDateFull function supplied to format date
-   * @returns {String} date string
-   */
-  getLabel = (selectionConfiguration, formatDateFull) => {
-    if (
-      selectionConfiguration.type === CALENDAR_SELECTION_TYPE.single &&
-      selectionConfiguration.date
-    ) {
-      return formatDateFull(selectionConfiguration.date);
-    }
-    if (selectionConfiguration.type === CALENDAR_SELECTION_TYPE.range) {
-      if (selectionConfiguration.startDate && !selectionConfiguration.endDate) {
-        return formatDateFull(selectionConfiguration.startDate);
+
+    _defineProperty(this, "getValue", (selectionConfiguration, formatDate) => {
+      if (selectionConfiguration.type === _bpkComponentCalendar.CALENDAR_SELECTION_TYPE.single && selectionConfiguration.date) {
+        return formatDate(selectionConfiguration.date);
       }
-      if (selectionConfiguration.startDate && selectionConfiguration.endDate) {
-        return `${formatDateFull(
-          selectionConfiguration.startDate,
-        )} - ${formatDateFull(selectionConfiguration.endDate)}`;
+
+      if (selectionConfiguration.type === _bpkComponentCalendar.CALENDAR_SELECTION_TYPE.range) {
+        if (selectionConfiguration.startDate && !selectionConfiguration.endDate) {
+          return formatDate(selectionConfiguration.startDate);
+        }
+
+        if (selectionConfiguration.startDate && selectionConfiguration.endDate) {
+          return `${formatDate(selectionConfiguration.startDate)} - ${formatDate(selectionConfiguration.endDate)}`;
+        }
       }
-    }
-    return '';
-  };
-
-  /**
-   * Gets the correct value for the input field
-   * @param {Object} selectionConfiguration current selection configuration
-   * @param {Function} formatDate function supplied to format date
-   * @returns {String} date value
-   */
-  getValue = (selectionConfiguration, formatDate) => {
-    if (
-      selectionConfiguration.type === CALENDAR_SELECTION_TYPE.single &&
-      selectionConfiguration.date
-    ) {
-      return formatDate(selectionConfiguration.date);
-    }
-    if (selectionConfiguration.type === CALENDAR_SELECTION_TYPE.range) {
-      if (selectionConfiguration.startDate && !selectionConfiguration.endDate) {
-        return formatDate(selectionConfiguration.startDate);
+
+      return '';
+    });
+
+    _defineProperty(this, "handleDateSelect", (startDate, endDate = null) => {
+      const {
+        maxDate,
+        minDate,
+        onClose,
+        onDateSelect,
+        selectionConfiguration
+      } = this.props; // When the calendar is a single date we always want to close it when a date is selected
+      // or if its a range calendar we only want to close the calendar when a range is selected.
+      // If a custom onClose function is provided then we don't want to run the internal version.
+
+      if ((selectionConfiguration.type === _bpkComponentCalendar.CALENDAR_SELECTION_TYPE.single || selectionConfiguration.type === _bpkComponentCalendar.CALENDAR_SELECTION_TYPE.range && endDate) && !onClose) {
+        this.onClose();
       }
-      if (selectionConfiguration.startDate && selectionConfiguration.endDate) {
-        return `${formatDate(selectionConfiguration.startDate)} - ${formatDate(
-          selectionConfiguration.endDate,
-        )}`;
+
+      if (onDateSelect) {
+        const newStartDate = _bpkComponentCalendar.DateUtils.dateToBoundaries(startDate, _bpkComponentCalendar.DateUtils.startOfDay(minDate), _bpkComponentCalendar.DateUtils.startOfDay(maxDate));
+
+        const newEndDate = _bpkComponentCalendar.DateUtils.dateToBoundaries(endDate, _bpkComponentCalendar.DateUtils.startOfDay(minDate), _bpkComponentCalendar.DateUtils.startOfDay(maxDate));
+
+        if (selectionConfiguration.type === _bpkComponentCalendar.CALENDAR_SELECTION_TYPE.range && selectionConfiguration.startDate && !selectionConfiguration.endDate && (_bpkComponentCalendar.DateUtils.isAfter(newEndDate, selectionConfiguration.startDate) || _bpkComponentCalendar.DateUtils.isSameDay(newEndDate, selectionConfiguration.startDate))) {
+          onDateSelect(selectionConfiguration.startDate, newEndDate);
+        } else {
+          onDateSelect(newStartDate);
+        }
       }
-    }
-    return '';
-  };
-
-  handleDateSelect = (startDate, endDate = null) => {
-    const { maxDate, minDate, onClose, onDateSelect, selectionConfiguration } =
-      this.props;
-
-    // When the calendar is a single date we always want to close it when a date is selected
-    // or if its a range calendar we only want to close the calendar when a range is selected.
-    // If a custom onClose function is provided then we don't want to run the internal version.
-    if (
-      (selectionConfiguration.type === CALENDAR_SELECTION_TYPE.single ||
-        (selectionConfiguration.type === CALENDAR_SELECTION_TYPE.range &&
-          endDate)) &&
-      !onClose
-    ) {
-      this.onClose();
-    }
+    });
 
-    if (onDateSelect) {
-      const newStartDate = DateUtils.dateToBoundaries(
-        startDate,
-        DateUtils.startOfDay(minDate),
-        DateUtils.startOfDay(maxDate),
-      );
-      const newEndDate = DateUtils.dateToBoundaries(
-        endDate,
-        DateUtils.startOfDay(minDate),
-        DateUtils.startOfDay(maxDate),
-      );
-
-      if (
-        selectionConfiguration.type === CALENDAR_SELECTION_TYPE.range &&
-        selectionConfiguration.startDate &&
-        !selectionConfiguration.endDate &&
-        (DateUtils.isAfter(newEndDate, selectionConfiguration.startDate) ||
-          DateUtils.isSameDay(newEndDate, selectionConfiguration.startDate))
-      ) {
-        onDateSelect(selectionConfiguration.startDate, newEndDate);
+    this.state = {
+      isOpen: props.isOpen
+    };
+    this.inputRef = /*#__PURE__*/_react.default.createRef();
+  }
+
+  componentDidUpdate(prevProps, prevState) {
+    const {
+      isOpen
+    } = this.props;
+
+    if (prevProps.isOpen !== isOpen && prevState.isOpen !== isOpen) {
+      if (isOpen) {
+        this.onOpen();
       } else {
-        onDateSelect(newStartDate);
+        this.onClose();
       }
     }
-  };
+  }
 
   render() {
-    const {
+    const _this$props = this.props,
+          {
       calendarComponent: Calendar,
       changeMonthLabel,
       closeButtonText,
@@ -212,35 +182,30 @@ class BpkDatepicker extends Component {
       selectionConfiguration,
       title,
       valid,
-      weekStartsOn,
-      ...rest
-    } = this.props;
+      weekStartsOn
+    } = _this$props,
+          rest = _objectWithoutProperties(_this$props, _excluded); // The following props are not used in render
+
 
-    // The following props are not used in render
     delete rest.onDateSelect;
     delete rest.onOpenChange;
     delete rest.isOpen;
 
-    const input = inputComponent || (
-      <div
-        className={getClassName('bpk-datepicker__input')}
-        ref={this.inputRef}
-      >
-        <Input
-          id={id}
-          name={`${id}_input`}
-          value={this.getValue(selectionConfiguration, formatDate)}
-          aria-live="assertive"
-          aria-atomic="true"
-          aria-label={this.getLabel(selectionConfiguration, formatDateFull)}
-          onChange={() => null}
-          onOpen={this.onOpen}
-          isOpen={this.state.isOpen}
-          valid={valid}
-          {...inputProps}
-        />
-      </div>
-    );
+    const input = inputComponent || /*#__PURE__*/_react.default.createElement("div", {
+      className: getClassName('bpk-datepicker__input'),
+      ref: this.inputRef
+    }, /*#__PURE__*/_react.default.createElement(Input, _extends({
+      id: id,
+      name: `${id}_input`,
+      value: this.getValue(selectionConfiguration, formatDate),
+      "aria-live": "assertive",
+      "aria-atomic": "true",
+      "aria-label": this.getLabel(selectionConfiguration, formatDateFull),
+      onChange: () => null,
+      onOpen: this.onOpen,
+      isOpen: this.state.isOpen,
+      valid: valid
+    }, inputProps)));
 
     const calendarProps = {
       id: `${id}-calendar`,
@@ -260,94 +225,76 @@ class BpkDatepicker extends Component {
       previousMonthLabel,
       weekStartsOn,
       initiallyFocusedDate,
-      selectionConfiguration,
+      selectionConfiguration
     };
-
-    return (
-      <BpkBreakpoint query={BREAKPOINTS.MOBILE}>
-        {(isMobile) =>
-          isMobile ? (
-            <>
-              {input}
-              <BpkModal
-                id={`${id}-modal`}
-                renderTarget={renderTarget}
-                onClose={this.props.onClose || this.onClose}
-                isOpen={this.state.isOpen}
-                title={title}
-                closeLabel={closeButtonText}
-                getApplicationElement={getApplicationElement}
-              >
-                <Calendar {...calendarProps} fixedWidth={false} />
-              </BpkModal>
-            </>
-          ) : (
-            <BpkPopover
-              id={`${id}-popover`}
-              target={input}
-              renderTarget={renderTarget}
-              onClose={this.props.onClose || this.onClose}
-              isOpen={this.state.isOpen}
-              label={title}
-              closeButtonText={closeButtonText}
-              tabIndex={0}
-              {...rest}
-            >
-              <Calendar {...calendarProps} fixedWidth={fixedWidth} />
-            </BpkPopover>
-          )
-        }
-      </BpkBreakpoint>
-    );
+    return /*#__PURE__*/_react.default.createElement(_bpkComponentBreakpoint.default, {
+      query: _bpkComponentBreakpoint.BREAKPOINTS.MOBILE
+    }, isMobile => isMobile ? /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, input, /*#__PURE__*/_react.default.createElement(_bpkComponentModal.default, {
+      id: `${id}-modal`,
+      renderTarget: renderTarget,
+      onClose: this.props.onClose || this.onClose,
+      isOpen: this.state.isOpen,
+      title: title,
+      closeLabel: closeButtonText,
+      getApplicationElement: getApplicationElement
+    }, /*#__PURE__*/_react.default.createElement(Calendar, _extends({}, calendarProps, {
+      fixedWidth: false
+    })))) : /*#__PURE__*/_react.default.createElement(_bpkComponentPopover.default, _extends({
+      id: `${id}-popover`,
+      target: input,
+      renderTarget: renderTarget,
+      onClose: this.props.onClose || this.onClose,
+      isOpen: this.state.isOpen,
+      label: title,
+      closeButtonText: closeButtonText,
+      tabIndex: 0
+    }, rest), /*#__PURE__*/_react.default.createElement(Calendar, _extends({}, calendarProps, {
+      fixedWidth: fixedWidth
+    }))));
   }
+
 }
 
 BpkDatepicker.propTypes = {
   // Required
-  changeMonthLabel: PropTypes.string.isRequired,
-  closeButtonText: PropTypes.string.isRequired,
-  daysOfWeek: CustomPropTypes.DaysOfWeek.isRequired,
-  formatDate: PropTypes.func.isRequired,
-  formatDateFull: PropTypes.func.isRequired,
-  formatMonth: PropTypes.func.isRequired,
-  id: PropTypes.string.isRequired,
-  title: PropTypes.string.isRequired,
-  getApplicationElement: PropTypes.func.isRequired,
-  nextMonthLabel: PropTypes.string.isRequired,
-  previousMonthLabel: PropTypes.string.isRequired,
-  weekStartsOn: PropTypes.number.isRequired,
+  changeMonthLabel: _propTypes.default.string.isRequired,
+  closeButtonText: _propTypes.default.string.isRequired,
+  daysOfWeek: _bpkComponentCalendar.CustomPropTypes.DaysOfWeek.isRequired,
+  formatDate: _propTypes.default.func.isRequired,
+  formatDateFull: _propTypes.default.func.isRequired,
+  formatMonth: _propTypes.default.func.isRequired,
+  id: _propTypes.default.string.isRequired,
+  title: _propTypes.default.string.isRequired,
+  getApplicationElement: _propTypes.default.func.isRequired,
+  nextMonthLabel: _propTypes.default.string.isRequired,
+  previousMonthLabel: _propTypes.default.string.isRequired,
+  weekStartsOn: _propTypes.default.number.isRequired,
   // Optional
-  calendarComponent: PropTypes.elementType,
-  inputComponent: PropTypes.elementType,
-  date: deprecated(
-    PropTypes.instanceOf(Date),
-    'Use selectionConfiguration to set date',
-  ),
-  dateModifiers: CustomPropTypes.DateModifiers,
-  fixedWidth: PropTypes.bool,
-  inputProps: PropTypes.object, // eslint-disable-line react/forbid-prop-types
-  markOutsideDays: PropTypes.bool,
-  markToday: PropTypes.bool,
-  maxDate: PropTypes.instanceOf(Date),
-  minDate: PropTypes.instanceOf(Date),
-  onDateSelect: PropTypes.func,
-  onOpenChange: PropTypes.func,
-  onMonthChange: PropTypes.func,
-  selectionConfiguration: CustomPropTypes.SelectionConfiguration,
+  calendarComponent: _propTypes.default.elementType,
+  inputComponent: _propTypes.default.elementType,
+  date: (0, _bpkReactUtils.deprecated)(_propTypes.default.instanceOf(Date), 'Use selectionConfiguration to set date'),
+  dateModifiers: _bpkComponentCalendar.CustomPropTypes.DateModifiers,
+  fixedWidth: _propTypes.default.bool,
+  inputProps: _propTypes.default.object,
+  // eslint-disable-line react/forbid-prop-types
+  markOutsideDays: _propTypes.default.bool,
+  markToday: _propTypes.default.bool,
+  maxDate: _propTypes.default.instanceOf(Date),
+  minDate: _propTypes.default.instanceOf(Date),
+  onDateSelect: _propTypes.default.func,
+  onOpenChange: _propTypes.default.func,
+  onMonthChange: _propTypes.default.func,
+  selectionConfiguration: _bpkComponentCalendar.CustomPropTypes.SelectionConfiguration,
   // eslint-disable-next-line react/require-default-props
-  showWeekendSeparator: deprecated(
-    PropTypes.bool,
-    'The showWeekendSeparator prop in Week is now deprecated as no longer part of the calendar, so is no longer required',
-  ),
-  initiallyFocusedDate: PropTypes.instanceOf(Date),
-  renderTarget: PropTypes.func,
-  isOpen: PropTypes.bool,
-  valid: PropTypes.bool,
+  showWeekendSeparator: (0, _bpkReactUtils.deprecated)(_propTypes.default.bool, 'The showWeekendSeparator prop in Week is now deprecated as no longer part of the calendar, so is no longer required'),
+  initiallyFocusedDate: _propTypes.default.instanceOf(Date),
+  renderTarget: _propTypes.default.func,
+  isOpen: _propTypes.default.bool,
+  valid: _propTypes.default.bool,
   // Disabling this as if we set a default property for this value it causes the internal onClose function to stop working for default setup
   // eslint-disable-next-line react/require-default-props
-  onClose: PropTypes.func,
+  onClose: _propTypes.default.func
 };
-
 BpkDatepicker.defaultProps = {
   calendarComponent: DefaultCalendar,
   inputComponent: null,
@@ -364,11 +311,14 @@ BpkDatepicker.defaultProps = {
   onOpenChange: null,
   onMonthChange: null,
   previousMonthLabel: null,
-  selectionConfiguration: { type: CALENDAR_SELECTION_TYPE.single, date: null },
+  selectionConfiguration: {
+    type: _bpkComponentCalendar.CALENDAR_SELECTION_TYPE.single,
+    date: null
+  },
   initiallyFocusedDate: null,
   renderTarget: null,
   isOpen: false,
-  valid: null,
+  valid: null
 };
-
-export default BpkDatepicker;
+var _default = BpkDatepicker;
+exports.default = _default;

package/bpk-component-datepicker/src/themeAttributes.js

@@ -1,3 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _bpkComponentCalendar = require("../../bpk-component-calendar");
+
+var _bpkComponentModal = require("../../bpk-component-modal");
+
+var _bpkComponentPopover = require("../../bpk-component-popover");
+
 /*
  * Backpack - Skyscanner's Design System
  *
@@ -15,15 +28,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var _default = [..._bpkComponentCalendar.themeAttributes, ..._bpkComponentPopover.themeAttributes, ..._bpkComponentModal.themeAttributes].filter((attribute, index, attributes) => attributes.indexOf(attribute) === index);
 
-import { themeAttributes as calendarAttributes } from '../../bpk-component-calendar';
-import { themeAttributes as modalAttributes } from '../../bpk-component-modal';
-import { themeAttributes as popoverAttributes } from '../../bpk-component-popover';
-
-export default [
-  ...calendarAttributes,
-  ...popoverAttributes,
-  ...modalAttributes,
-].filter(
-  (attribute, index, attributes) => attributes.indexOf(attribute) === index,
-);
+exports.default = _default;

package/bpk-component-description-list/index.css

@@ -0,0 +1,11 @@
+/*  imported from BpkDescriptionList.module.scss  */
+
+@keyframes BpkDescriptionList-module__bpk-keyframe-spin___2y9gB{100%{transform:rotate(1turn)}}
+
+.BpkDescriptionList-module__bpk-description-list___2EonP{margin:0}
+
+.BpkDescriptionList-module__bpk-description-list__term___2BZT-{font-size:1rem;line-height:1.5rem;font-weight:700}
+
+.BpkDescriptionList-module__bpk-description-list__details___5K1bL{margin:0;margin-left:1.5rem}
+
+html[dir='rtl'] .BpkDescriptionList-module__bpk-description-list__details___5K1bL{margin-right:1.5rem;margin-left:0}