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

package/lib/common/components/wcm-display.js

@@ -0,0 +1,416 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.COMPONENT_ATTR = exports.COMPONENT_XML_ELEMENT = exports.WcmDisplayForTesting = exports.default = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _wcmRetriever = _interopRequireDefault(require("../util/wcm-retriever"));
+
+var _templateConnect = _interopRequireDefault(require("../redux/template-connect"));
+
+var disclosureActions = _interopRequireWildcard(require("../redux/disclosures/disclosures-actions"));
+
+var footnoteActions = _interopRequireWildcard(require("../redux/footnotes/footnotes-actions"));
+
+var _usaaLogger = _interopRequireDefault(require("usaa-logger"));
+
+var _stringUtils = require("../util/string-utils");
+
+var _parseWcmXml2 = _interopRequireDefault(require("../util/parse-wcm-xml"));
+
+var _renderWatcher = require("./render-watcher");
+
+var _wcmComponentLoaders = _interopRequireDefault(require("../wcm-component-loaders"));
+
+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 _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 _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 _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); }
+
+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); }
+
+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 COMPONENT_XML_ELEMENT = 'usaa-react-component';
+exports.COMPONENT_XML_ELEMENT = COMPONENT_XML_ELEMENT;
+var COMPONENT_ATTR = {
+  TYPE: 'component-name',
+  VERSION: 'component-version',
+  TARGET_ID: 'component-target-id'
+};
+exports.COMPONENT_ATTR = COMPONENT_ATTR;
+var logger = new _usaaLogger.default();
+var DEBUG_MSG = '(usaa-templates) common/components/wcm-display:';
+
+var WcmDisplay = /*#__PURE__*/function (_React$Component) {
+  _inherits(WcmDisplay, _React$Component);
+
+  var _super = _createSuper(WcmDisplay);
+
+  function WcmDisplay() {
+    var _this;
+
+    _classCallCheck(this, WcmDisplay);
+
+    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", {
+      disclosureIds: [],
+      footnoteIds: [],
+      isLoggedIn: false,
+      markupString: ''
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "getAndProcessWcmData", function (wcmKey, isLoggedIn, replacementMap) {
+      (0, _wcmRetriever.default)(wcmKey, isLoggedIn, replacementMap).then(_this.handleDataLoad, _this.handleFailure);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleDataLoad", function (response) {
+      var data = response || {};
+      var markup = data.mainContent;
+      var disclosuresBelowFootnotes = data.disclaimers.disclaimers;
+
+      if (!markup) {
+        _this.handleFailure(response.message || 'No markup returned');
+
+        return;
+      }
+
+      var _parseWcmXml = (0, _parseWcmXml2.default)(markup);
+
+      markup = _parseWcmXml.markup;
+      _this.components = _parseWcmXml.components;
+
+      var processedFootnotesAndMarkup = _this.processFootnotes(markup);
+
+      var addedDisclosureIds = _this.addDisclosures(disclosuresBelowFootnotes);
+
+      _this.setState({
+        disclosureIds: addedDisclosureIds,
+        footnoteIds: processedFootnotesAndMarkup.addedFootnoteIds,
+        markupString: processedFootnotesAndMarkup.processedMarkup
+      }, function () {
+        if (_this.props.onLoad) {
+          _this.props.onLoad(null, markup);
+        }
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "addDisclosures", function (disclosuresToAdd) {
+      return disclosuresToAdd.map(function (disclosureText) {
+        var id = "WcmDisplayDisclosure-".concat((0, _stringUtils.hashCode)(disclosureText));
+
+        _this.props.dispatch(disclosureActions.addDisclosure({
+          id: id,
+          text: disclosureText
+        }));
+
+        return id;
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "processFootnotes", function (markup) {
+      var markupFootnoteRegex = /<span class="footnote">(.+?)<\/span>/;
+      var footnoteNumber = _this.props.allFootnotes.length - _this.state.footnoteIds.length + 1;
+      var addedFootnoteIds = [];
+      var result = markupFootnoteRegex.exec(markup);
+
+      while (result) {
+        var footnoteText = result[1];
+        var id = "WcmDisplayFootnote-".concat((0, _stringUtils.hashCode)(footnoteText));
+        addedFootnoteIds.push(id);
+
+        _this.props.dispatch(footnoteActions.addFootnote({
+          id: id,
+          text: footnoteText
+        }));
+
+        markup = markup.replace(markupFootnoteRegex, "<sup data-footnote-id=\"".concat(id, "\">").concat(footnoteNumber++, "</sup>"));
+        result = markupFootnoteRegex.exec(markup);
+      }
+
+      return {
+        addedFootnoteIds: addedFootnoteIds,
+        processedMarkup: markup
+      };
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "handleFailure", function (err) {
+      if (_typeof(err) === 'object' && err.message) {
+        err = err.message;
+      }
+
+      _this.setState({
+        markupString: ''
+      }, function () {
+        if (_this.props.onLoad) {
+          _this.props.onLoad(err);
+        }
+      });
+
+      logger.warn(DEBUG_MSG, "Error loading WCM object for key ".concat(_this.props.wcmKey, ": ").concat(err));
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "renderComponentsIntoMarkup", function () {
+      _this.rendered = 0;
+
+      var renderCallback = function renderCallback() {
+        // callback to un-hide content when we're done rendering components
+        _this.rendered++;
+
+        if (_this.rendered === _this.components.length) {
+          _this.hiddenElementRef.style.display = '';
+        }
+      };
+
+      var _loop = function _loop(i) {
+        var component = _this.components[i];
+
+        var _component$props = component.props,
+            _COMPONENT_ATTR$TYPE = COMPONENT_ATTR.TYPE,
+            _COMPONENT_ATTR$VERSI = COMPONENT_ATTR.VERSION,
+            _COMPONENT_ATTR$TARGE = COMPONENT_ATTR.TARGET_ID,
+            compName = _component$props[_COMPONENT_ATTR$TYPE],
+            compVersion = _component$props[_COMPONENT_ATTR$VERSI],
+            compTargetId = _component$props[_COMPONENT_ATTR$TARGE],
+            otherProps = _objectWithoutProperties(_component$props, [_COMPONENT_ATTR$TYPE, _COMPONENT_ATTR$VERSI, _COMPONENT_ATTR$TARGE].map(_toPropertyKey));
+
+        if (!component || !compName || !compVersion || !compTargetId) {
+          logger.error(DEBUG_MSG, 'Invalid component.', component);
+          renderCallback();
+          return "continue";
+        }
+
+        var load = _this.props.mockLoaders || _wcmComponentLoaders.default;
+
+        if (!load || !load[compName] || !load[compName][compVersion] || !load[compName][compVersion].LOADER) {
+          logger.error(DEBUG_MSG, "Missing loader for '".concat(compName, "' version '").concat(compVersion, "'"));
+          renderCallback();
+          return "continue";
+        }
+
+        var compLoader = load[compName][compVersion].LOADER;
+        var compExport = load[compName][compVersion].EXPORT || 'default';
+        var El = _this.props.elementType;
+        compLoader(function (module) {
+          if (!module[compExport]) {
+            logger.error(DEBUG_MSG, "Missing '".concat(compName, "' version '").concat(compVersion, "' export '").concat(compExport, "'"));
+            renderCallback();
+            return;
+          }
+
+          var children = [];
+
+          if (component.innerHTML) {
+            children = /*#__PURE__*/_react.default.createElement(El, {
+              dangerouslySetInnerHTML: {
+                __html: component.innerHTML
+              }
+            });
+          }
+
+          var target = document.getElementById(compTargetId);
+
+          if (target) {
+            var Component = (0, _renderWatcher.withRenderWatcher)(module[compExport], renderCallback);
+
+            _reactDom.default.render( /*#__PURE__*/_react.default.createElement(Component, otherProps, children), target);
+          } else {
+            logger.error(DEBUG_MSG, "Error rendering '".concat(compName, "'. Target '").concat(compTargetId, "' does not exist."));
+            renderCallback();
+          }
+        });
+      };
+
+      for (var i in _this.components) {
+        var _ret = _loop(i);
+
+        if (_ret === "continue") continue;
+      }
+    });
+
+    return _this;
+  }
+
+  _createClass(WcmDisplay, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this2 = this;
+
+      (0, _shared.getGuid)().then(function () {
+        _this2.getAndProcessWcmData(_this2.props.wcmKey, true, _this2.props.replacementMap);
+
+        _this2.setState({
+          isLoggedIn: true
+        });
+      }, function () {
+        _this2.getAndProcessWcmData(_this2.props.wcmKey, false, _this2.props.replacementMap);
+      });
+    }
+  }, {
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(nextProps, nextState) {
+      if (nextState.markupString === '') {
+        return false;
+      }
+
+      return true;
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      var _this3 = this;
+
+      if (prevProps.wcmKey !== this.props.wcmKey) {
+        this.setState({
+          markupString: ''
+        }, function () {
+          _this3.getAndProcessWcmData(_this3.props.wcmKey, _this3.state.isLoggedIn, _this3.props.replacementMap);
+        });
+      } // check for parsed out react components in the wcm content which need rendered
+
+
+      if (this.components && this.components.length) {
+        this.renderComponentsIntoMarkup();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      var _this4 = this;
+
+      this.state.disclosureIds.forEach(function (id) {
+        _this4.props.dispatch(disclosureActions.removeDisclosure(id));
+      });
+      this.state.footnoteIds.forEach(function (id) {
+        _this4.props.dispatch(footnoteActions.removeFootnote(id));
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this5 = this;
+
+      var markup = this.state.markupString;
+      var footnoteIds = this.state.footnoteIds;
+
+      var _this$props = this.props,
+          mockLoaders = _this$props.mockLoaders,
+          wcmKey = _this$props.wcmKey,
+          dispatch = _this$props.dispatch,
+          allFootnotes = _this$props.allFootnotes,
+          El = _this$props.elementType,
+          otherProps = _objectWithoutProperties(_this$props, ["mockLoaders", "wcmKey", "dispatch", "allFootnotes", "elementType"]);
+
+      footnoteIds.forEach(function (footnoteId) {
+        var foundFootnoteIndex, footnoteReplacement;
+        var markupFootnoteRegex = new RegExp("<sup data-footnote-id=\"".concat(footnoteId, "\">(.*?)</sup>"));
+        var foundFootnote = allFootnotes.find(function (currentFootnote, index) {
+          foundFootnoteIndex = index;
+          return footnoteId === currentFootnote.id;
+        });
+
+        if (foundFootnote) {
+          footnoteReplacement = "<sup data-footnote-id=\"".concat(footnoteId, "\">").concat(foundFootnoteIndex + 1, "</sup>");
+        } else {
+          footnoteReplacement = '';
+          logger.warn(DEBUG_MSG, "Error locating footnote: ".concat(_this5.props.wcmKey));
+        }
+
+        markup = markup.replace(markupFootnoteRegex, footnoteReplacement);
+      });
+
+      if (this.components && this.components.length) {
+        // render our content hidden until components load
+        return /*#__PURE__*/_react.default.createElement(El, _extends({
+          ref: function ref(me) {
+            _this5.hiddenElementRef = me;
+          },
+          style: {
+            display: 'none'
+          },
+          dangerouslySetInnerHTML: {
+            __html: markup
+          }
+        }, otherProps));
+      } else {
+        return /*#__PURE__*/_react.default.createElement(El, _extends({
+          dangerouslySetInnerHTML: {
+            __html: markup
+          }
+        }, otherProps));
+      }
+    }
+  }]);
+
+  return WcmDisplay;
+}(_react.default.Component);
+
+exports.WcmDisplayForTesting = WcmDisplay;
+
+_defineProperty(WcmDisplay, "propTypes", {
+  allFootnotes: _propTypes.default.array,
+  elementType: _propTypes.default.string,
+  mockLoaders: _propTypes.default.object,
+  onLoad: _propTypes.default.func,
+  replacementMap: _propTypes.default.object,
+  wcmKey: _propTypes.default.string.isRequired
+});
+
+_defineProperty(WcmDisplay, "defaultProps", {
+  elementType: 'div'
+});
+
+var _default = (0, _templateConnect.default)(function (state) {
+  return {
+    allFootnotes: state.template.footnotes
+  };
+})(WcmDisplay); // export non-connected component for testing
+
+
+exports.default = _default;
+//# sourceMappingURL=wcm-display.js.map

package/lib/common/redux/disclosures/disclosures-actions.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDisclosure = addDisclosure;
+exports.removeDisclosure = removeDisclosure;
+exports.INF_REMOVE_DISCLOSURE = exports.INF_ADD_DISCLOSURE = void 0;
+var INF_ADD_DISCLOSURE = 'INF_ADD_DISCLOSURE';
+exports.INF_ADD_DISCLOSURE = INF_ADD_DISCLOSURE;
+var INF_REMOVE_DISCLOSURE = 'INF_REMOVE_DISCLOSURE';
+exports.INF_REMOVE_DISCLOSURE = INF_REMOVE_DISCLOSURE;
+
+function addDisclosure(disclosure) {
+  return {
+    type: INF_ADD_DISCLOSURE,
+    disclosure: disclosure
+  };
+}
+
+function removeDisclosure(id) {
+  return {
+    type: INF_REMOVE_DISCLOSURE,
+    id: id
+  };
+}
+//# sourceMappingURL=disclosures-actions.js.map

package/lib/common/redux/disclosures/disclosures-reducer.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Disclosures;
+
+var _disclosuresActions = require("./disclosures-actions");
+
+var _disclosureList = require("../../components/footer/disclosure-list");
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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 _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; }
+
+/*
+    [{
+        id: 'disclosureId1',
+        location: 'aboveNav',
+        text: 'Disclosure Text (can be markup),
+        usageCount: 1
+    }, {
+        id: 'disclosureId2',
+        location: 'aboveFootnotes',
+        text: 'Disclosure Text (can be markup),
+        usageCount: 1
+    }, {
+        id: 'disclosureId3',
+        location: 'belowFootnotes' //Default behavior if location not there,
+        text: 'Disclosure Text (can be markup),
+        usageCount: 1
+    }]
+ */
+function Disclosures() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var action = arguments.length > 1 ? arguments[1] : undefined;
+
+  switch (action.type) {
+    case _disclosuresActions.INF_ADD_DISCLOSURE:
+      {
+        var disclosureToAdd = action.disclosure;
+
+        if (!disclosureToAdd.location) {
+          disclosureToAdd.location = _disclosureList.BELOW_FOOTNOTES;
+        }
+
+        var existingDisclosure = state.find(function (item) {
+          return item.id === disclosureToAdd.id;
+        });
+
+        if (existingDisclosure) {
+          disclosureToAdd = _objectSpread(_objectSpread({}, disclosureToAdd), {}, {
+            usageCount: existingDisclosure.usageCount + 1
+          });
+
+          var nextState = _toConsumableArray(state);
+
+          nextState[nextState.indexOf(existingDisclosure)] = disclosureToAdd;
+          return nextState;
+        } else {
+          disclosureToAdd = _objectSpread(_objectSpread({}, disclosureToAdd), {}, {
+            usageCount: 1
+          });
+          return [].concat(_toConsumableArray(state), [disclosureToAdd]);
+        }
+      }
+
+    case _disclosuresActions.INF_REMOVE_DISCLOSURE:
+      {
+        var disclosureToRemove = state.find(function (item) {
+          return item.id === action.id;
+        });
+        var disclosureToRemoveIndex = state.indexOf(disclosureToRemove);
+
+        if (disclosureToRemove) {
+          var _nextState = _toConsumableArray(state);
+
+          if (disclosureToRemove.usageCount > 1) {
+            // uses remain - decrement the counter
+            _nextState[disclosureToRemoveIndex] = _objectSpread(_objectSpread({}, disclosureToRemove), {}, {
+              usageCount: disclosureToRemove.usageCount - 1
+            });
+          } else {
+            // no uses remain - remove the disclosure
+            _nextState = [].concat(_toConsumableArray(_nextState.slice(0, disclosureToRemoveIndex)), _toConsumableArray(_nextState.slice(disclosureToRemoveIndex + 1)));
+          }
+
+          return _nextState;
+        } else {
+          return state;
+        }
+      }
+
+    default:
+      return state;
+  }
+}
+//# sourceMappingURL=disclosures-reducer.js.map

package/lib/common/redux/footnotes/footnotes-actions.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addFootnote = addFootnote;
+exports.updateFootnoteText = updateFootnoteText;
+exports.removeFootnote = removeFootnote;
+exports.INF_UPDATE_FOOTNOTE_TEXT = exports.INF_REMOVE_FOOTNOTE = exports.INF_ADD_FOOTNOTE = void 0;
+var INF_ADD_FOOTNOTE = 'INF_ADD_FOOTNOTE';
+exports.INF_ADD_FOOTNOTE = INF_ADD_FOOTNOTE;
+var INF_REMOVE_FOOTNOTE = 'INF_REMOVE_FOOTNOTE';
+exports.INF_REMOVE_FOOTNOTE = INF_REMOVE_FOOTNOTE;
+var INF_UPDATE_FOOTNOTE_TEXT = 'INF_UPDATE_FOOTNOTE_TEXT';
+exports.INF_UPDATE_FOOTNOTE_TEXT = INF_UPDATE_FOOTNOTE_TEXT;
+
+function addFootnote(footnote) {
+  return {
+    type: INF_ADD_FOOTNOTE,
+    footnote: footnote
+  };
+}
+
+function updateFootnoteText(id, text) {
+  return {
+    type: INF_UPDATE_FOOTNOTE_TEXT,
+    id: id,
+    text: text
+  };
+}
+
+function removeFootnote(id) {
+  return {
+    type: INF_REMOVE_FOOTNOTE,
+    id: id
+  };
+}
+//# sourceMappingURL=footnotes-actions.js.map