ent-unified-logon-template 0.0.1-security → 3.14.5

package/lib/common/components/body-wrapper.js

@@ -0,0 +1,116 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _checkStorageAvailability = _interopRequireDefault(require("../util/check-storage-availability"));
+
+var _sessionStorageError = _interopRequireDefault(require("./session-storage-error"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 BodyWrapper = /*#__PURE__*/function (_React$Component) {
+  _inherits(BodyWrapper, _React$Component);
+
+  var _super = _createSuper(BodyWrapper);
+
+  function BodyWrapper(props) {
+    var _this;
+
+    _classCallCheck(this, BodyWrapper);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "setNativeTitle", function () {
+      if (process.env.USAA_PLATFORM === 'native') {
+        var nav = require('usaa-native-bridge').nav;
+
+        nav.setTitle(_this.props.title);
+      }
+    });
+
+    _this.isSessionStorageAvailable = (0, _checkStorageAvailability.default)();
+    return _this;
+  }
+
+  _createClass(BodyWrapper, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.onContentError && !this.isSessionStorageAvailable) {
+        this.props.onContentError('sessionStorage unavailable');
+      }
+
+      this.setNativeTitle();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      if (prevProps.title !== this.props.title) {
+        this.setNativeTitle();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          bodyHeaderElement = _this$props.bodyHeaderElement,
+          bodyContent = _this$props.children;
+
+      if (!this.isSessionStorageAvailable) {
+        bodyContent = /*#__PURE__*/_react.default.createElement(_sessionStorageError.default, {
+          headerElement: bodyHeaderElement
+        });
+      }
+
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: this.props.className ? this.props.className : ''
+      }, bodyContent);
+    }
+  }]);
+
+  return BodyWrapper;
+}(_react.default.Component);
+
+exports.default = BodyWrapper;
+
+_defineProperty(BodyWrapper, "propTypes", {
+  bodyHeaderElement: _propTypes.default.string,
+  className: _propTypes.default.string,
+  onContentError: _propTypes.default.func,
+  title: _propTypes.default.string.isRequired
+});
+
+_defineProperty(BodyWrapper, "defaultProps", {
+  bodyHeaderElement: 'h1'
+});
+//# sourceMappingURL=body-wrapper.js.map

package/lib/common/components/disclosure.js

@@ -0,0 +1,192 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Disclosure = exports.default = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _templateConnect = _interopRequireDefault(require("../redux/template-connect"));
+
+var disclosureActions = _interopRequireWildcard(require("../redux/disclosures/disclosures-actions"));
+
+var _wcmRetriever = _interopRequireDefault(require("usaa-wcm-utils/lib/wcm-retriever"));
+
+var _usaaLogger = _interopRequireDefault(require("usaa-logger"));
+
+var _stringUtils = require("../util/string-utils");
+
+var _disclosureList = require("./footer/disclosure-list");
+
+var _shared = require("../../shared");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 logger = new _usaaLogger.default();
+
+var Disclosure = /*#__PURE__*/function (_React$Component) {
+  _inherits(Disclosure, _React$Component);
+
+  var _super = _createSuper(Disclosure);
+
+  function Disclosure(props) {
+    var _this;
+
+    _classCallCheck(this, Disclosure);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      id: ''
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "addDisclosureToStore", function (_ref) {
+      var id = _ref.id,
+          text = _ref.text;
+      var _this$props = _this.props,
+          aboveFootnotes = _this$props.aboveFootnotes,
+          dispatch = _this$props.dispatch,
+          last = _this$props.last,
+          order = _this$props.order;
+      var location;
+
+      if (aboveFootnotes) {
+        location = _disclosureList.ABOVE_FOOTNOTES;
+      }
+
+      dispatch(disclosureActions.addDisclosure({
+        id: id,
+        last: last,
+        location: location,
+        order: order,
+        text: text
+      }));
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getWcmDataAndAddDisclosure", function (isLoggedIn) {
+      (0, _wcmRetriever.default)(_this.state.id, isLoggedIn).then(function (response) {
+        var content = response;
+
+        if (content) {
+          _this.addDisclosureToStore({
+            id: _this.state.id,
+            text: content.mainContent
+          });
+
+          if (_this.props.onLoad) {
+            _this.props.onLoad(null);
+          }
+        }
+      }, function (error) {
+        if (_this.props.onLoad) {
+          _this.props.onLoad(error);
+        }
+      });
+    });
+
+    if (props.wcmKey) {
+      _this.state.id = props.wcmKey;
+    } else if (props.text) {
+      _this.state.id = "customDisclosure-".concat((0, _stringUtils.hashCode)(props.text));
+    }
+
+    return _this;
+  }
+
+  _createClass(Disclosure, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this2 = this;
+
+      if (this.props.wcmKey) {
+        (0, _shared.getGuid)().then(function () {
+          _this2.getWcmDataAndAddDisclosure(true);
+        }, function () {
+          _this2.getWcmDataAndAddDisclosure(false);
+        });
+      } else {
+        this.validateAndAddDisclosure();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.state.id) {
+        this.props.dispatch(disclosureActions.removeDisclosure(this.state.id));
+      }
+    }
+  }, {
+    key: "validateAndAddDisclosure",
+    value: function validateAndAddDisclosure() {
+      if (this.props.text) {
+        var text = this.props.text;
+
+        if (typeof text !== 'string') {
+          logger.log('disclosure: text prop is not a string - discarding disclosure!');
+          return;
+        }
+
+        this.addDisclosureToStore({
+          id: this.state.id,
+          text: text
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return false;
+    }
+  }]);
+
+  return Disclosure;
+}(_react.default.Component); // empty connect to get access to dispatch()
+
+
+exports.Disclosure = Disclosure;
+
+_defineProperty(Disclosure, "propTypes", {
+  aboveFootnotes: _propTypes.default.bool,
+  last: _propTypes.default.bool,
+  onLoad: _propTypes.default.func,
+  order: _propTypes.default.number,
+  text: _propTypes.default.string,
+  wcmKey: _propTypes.default.string
+});
+
+var _default = (0, _templateConnect.default)()(Disclosure); // export non-connected component for testing
+
+
+exports.default = _default;
+//# sourceMappingURL=disclosure.js.map

package/lib/common/components/exit-dialog-trigger.js

@@ -0,0 +1,180 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _usaaModals = require("usaa-modals");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _extends() { _extends = Object.assign || 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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 ExitDialogTrigger = /*#__PURE__*/function (_React$Component) {
+  _inherits(ExitDialogTrigger, _React$Component);
+
+  var _super = _createSuper(ExitDialogTrigger);
+
+  function ExitDialogTrigger() {
+    var _this;
+
+    _classCallCheck(this, ExitDialogTrigger);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      modalIsActive: false
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "_triggerRef", /*#__PURE__*/_react.default.createRef());
+
+    _defineProperty(_assertThisInitialized(_this), "showModal", function () {
+      _this.setState({
+        modalIsActive: true
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "hideModal", function () {
+      _this.setState({
+        modalIsActive: false
+      });
+    });
+
+    return _this;
+  }
+
+  _createClass(ExitDialogTrigger, [{
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var _this$props = this.props,
+          buttonId = _this$props.buttonId,
+          className = _this$props.className,
+          children = _this$props.children,
+          exitDialogProps = _this$props.exitDialogProps,
+          onAppExit = _this$props.onAppExit,
+          opensPopupAddendum = _this$props.opensPopupAddendum,
+          title = _this$props.title,
+          xFillColor = _this$props.xFillColor; // Set Default Exit Dialog Button
+
+      if (!children) {
+        var fillColor = xFillColor || '#12395b';
+        children = /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement("svg", {
+          xmlns: "http://www.w3.org/2000/svg",
+          width: "16",
+          height: "16",
+          viewBox: "0 0 16 16"
+        }, /*#__PURE__*/_react.default.createElement("path", {
+          fill: fillColor,
+          d: "M15.8 2.3L13.7.2 8 5.9 2.3.2.2 2.3 5.9 8 .2 13.7l2.1 2.1L8 10.1l5.7 5.7 2.1-2.1L10.1 8"
+        })), /*#__PURE__*/_react.default.createElement("span", {
+          className: "screenReader"
+        }, opensPopupAddendum));
+      } // Handle Suppression of Exit Dialog
+
+
+      if (exitDialogProps.suppress) {
+        return /*#__PURE__*/_react.default.createElement("button", {
+          id: buttonId,
+          type: "button",
+          className: className,
+          onClick: onAppExit
+        }, children, /*#__PURE__*/_react.default.createElement("span", {
+          className: "screenReader"
+        }, opensPopupAddendum));
+      } // Handle Dialog Options
+
+
+      var dialogActions = exitDialogProps.actions || [{
+        text: "Exit ".concat(title),
+        onClick: onAppExit
+      }, {
+        text: "Return to ".concat(title),
+        onClick: this.hideModal
+      }];
+      dialogActions = dialogActions.map(function (action) {
+        action = _objectSpread({}, action);
+
+        if (!action.onClick) {
+          action.onClick = _this2.hideModal;
+        }
+
+        return action;
+      });
+      return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_usaaModals.Modal, _extends({}, _usaaModals.Dialog.modalProps, {
+        closeOnEsc: true,
+        active: this.state.modalIsActive,
+        closeOnMaskClick: true,
+        onClose: this.close
+      }), /*#__PURE__*/_react.default.createElement(_usaaModals.Dialog, {
+        actions: dialogActions,
+        summary: exitDialogProps.summary
+      })), /*#__PURE__*/_react.default.createElement("button", {
+        id: buttonId,
+        className: className,
+        ref: this._triggerRef,
+        onClick: this.showModal,
+        type: "button"
+      }, children));
+    }
+  }]);
+
+  return ExitDialogTrigger;
+}(_react.default.Component);
+
+exports.default = ExitDialogTrigger;
+ExitDialogTrigger.propTypes = {
+  buttonId: _propTypes.default.string,
+  className: _propTypes.default.string,
+  exitDialogProps: _propTypes.default.shape({
+    summary: _propTypes.default.node.isRequired,
+    actions: _propTypes.default.arrayOf(_propTypes.default.shape({
+      text: _propTypes.default.node.isRequired,
+      onClick: _propTypes.default.func
+    })),
+    suppress: _propTypes.default.bool
+  }),
+  onAppExit: _propTypes.default.func.isRequired,
+  opensPopupAddendum: _propTypes.default.string,
+  title: _propTypes.default.string.isRequired,
+  xFillColor: _propTypes.default.string
+};
+//# sourceMappingURL=exit-dialog-trigger.js.map

package/lib/common/components/footer/disclosure-list.js

@@ -0,0 +1,119 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DisclosureList = exports.default = exports.BELOW_FOOTNOTES = exports.ABOVE_FOOTNOTES = exports.ABOVE_NAV = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _templateConnect = _interopRequireDefault(require("../../redux/template-connect"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+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 ABOVE_NAV = 'aboveNav';
+exports.ABOVE_NAV = ABOVE_NAV;
+var ABOVE_FOOTNOTES = 'aboveFootnotes';
+exports.ABOVE_FOOTNOTES = ABOVE_FOOTNOTES;
+var BELOW_FOOTNOTES = 'belowFootnotes';
+exports.BELOW_FOOTNOTES = BELOW_FOOTNOTES;
+
+var DisclosureList = /*#__PURE__*/function (_React$Component) {
+  _inherits(DisclosureList, _React$Component);
+
+  var _super = _createSuper(DisclosureList);
+
+  function DisclosureList() {
+    var _this;
+
+    _classCallCheck(this, DisclosureList);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "sortDisclosures", function (a, b) {
+      if (a.last && !b.last) {
+        return 1;
+      } else if (!a.last && b.last) {
+        return -1;
+      } else {
+        return (a.order || Number.MAX_VALUE) - (b.order || Number.MAX_VALUE);
+      }
+    });
+
+    return _this;
+  }
+
+  _createClass(DisclosureList, [{
+    key: "render",
+    value: function render() {
+      var location = this.props.location || BELOW_FOOTNOTES;
+      var disclosures = this.props.disclosures.filter(function (disclosure) {
+        return disclosure.location === location;
+      }).sort(this.sortDisclosures);
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: 'pageFooter-disclosures pageFooter-disclosures--' + location
+      }, disclosures.map(function (disclosure) {
+        return /*#__PURE__*/_react.default.createElement("p", {
+          key: disclosure.id,
+          dangerouslySetInnerHTML: {
+            __html: disclosure.text
+          }
+        }) // eslint-disable-line react/no-danger
+        ;
+      }));
+    }
+  }]);
+
+  return DisclosureList;
+}(_react.default.Component);
+
+exports.DisclosureList = DisclosureList;
+
+_defineProperty(DisclosureList, "propTypes", {
+  disclosures: _propTypes.default.array,
+  location: _propTypes.default.string
+});
+
+_defineProperty(DisclosureList, "defaultProps", {
+  disclosures: []
+});
+
+var _default = (0, _templateConnect.default)(function (state) {
+  return {
+    disclosures: state.template.disclosures
+  };
+})(DisclosureList); // non-connected component for testing
+
+
+exports.default = _default;
+//# sourceMappingURL=disclosure-list.js.map