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

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

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Footnotes;
+
+var _footnotesActions = require("./footnotes-actions");
+
+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; }
+
+/*
+    let footnoteStructure = {
+        id: 'footnote1',
+        text: 'This is a footnote',
+        usageCount: 1
+    };
+*/
+function Footnotes() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var action = arguments.length > 1 ? arguments[1] : undefined;
+
+  switch (action.type) {
+    case _footnotesActions.INF_ADD_FOOTNOTE:
+      {
+        var incomingFootnote = action.footnote;
+        var footnoteToAdd;
+        var existingFootnote = state.find(function (item) {
+          return item.id === action.footnote.id;
+        });
+
+        if (existingFootnote) {
+          footnoteToAdd = _objectSpread(_objectSpread({}, existingFootnote), {}, {
+            usageCount: existingFootnote.usageCount + 1
+          });
+
+          var nextState = _toConsumableArray(state);
+
+          nextState[nextState.indexOf(existingFootnote)] = footnoteToAdd;
+          return nextState;
+        } else {
+          footnoteToAdd = _objectSpread(_objectSpread({}, incomingFootnote), {}, {
+            usageCount: 1
+          });
+          return [].concat(_toConsumableArray(state), [footnoteToAdd]);
+        }
+      }
+
+    case _footnotesActions.INF_UPDATE_FOOTNOTE_TEXT:
+      {
+        return state.map(function (footnote) {
+          if (footnote.id === action.id) {
+            return _objectSpread(_objectSpread({}, footnote), {}, {
+              text: action.text
+            });
+          }
+
+          return footnote;
+        });
+      }
+
+    case _footnotesActions.INF_REMOVE_FOOTNOTE:
+      {
+        var footnoteToRemove = state.find(function (item) {
+          return item.id === action.id;
+        });
+        var footnoteToRemoveIndex = state.indexOf(footnoteToRemove);
+
+        if (footnoteToRemove) {
+          var _nextState = _toConsumableArray(state);
+
+          if (footnoteToRemove.usageCount > 1) {
+            _nextState[footnoteToRemoveIndex] = _objectSpread(_objectSpread({}, footnoteToRemove), {}, {
+              usageCount: footnoteToRemove.usageCount - 1
+            });
+          } else {
+            // no uses remain - remove the disclosure
+            _nextState = [].concat(_toConsumableArray(_nextState.slice(0, footnoteToRemoveIndex)), _toConsumableArray(_nextState.slice(footnoteToRemoveIndex + 1)));
+          }
+
+          return _nextState;
+        } else {
+          return state;
+        }
+      }
+
+    default:
+      return state;
+  }
+}
+//# sourceMappingURL=footnotes-reducer.js.map

package/lib/common/redux/get-create-store.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getCreateStore;
+
+var _redux = require("redux");
+
+var _reduxThunk = _interopRequireDefault(require("redux-thunk"));
+
+var _profile = _interopRequireDefault(require("./profile"));
+
+var _footnotesReducer = _interopRequireDefault(require("./footnotes/footnotes-reducer"));
+
+var _disclosuresReducer = _interopRequireDefault(require("./disclosures/disclosures-reducer"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+function getCreateStore(extraReducers) {
+  var templateReducers = (0, _redux.combineReducers)(_objectSpread(_objectSpread({}, extraReducers), {}, {
+    disclosures: _disclosuresReducer.default,
+    footnotes: _footnotesReducer.default,
+    profile: _profile.default
+  }));
+  var templateMiddleware = [_reduxThunk.default];
+  var templateEnhancers = [];
+  /* The redux devtools extension no longer works with the context updates to react-redux 6 & 7.
+     It doesn't look like they've made any updates to address context in the extension.
+     We can come back and revisit later if needed.
+   // separate if block makes sure all nested code will be removed by webpack/uglify when false
+  if (process.env.USAA_ENV !== 'production') {
+      if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) {
+          templateEnhancers.push(
+              window.window.__REDUX_DEVTOOLS_EXTENSION__({name: STORE_KEY, instanceId: STORE_KEY})
+          );
+      }
+  }
+  */
+
+  return function createUsaaStore() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        reducers = _ref.reducers,
+        initialState = _ref.initialState,
+        _ref$middleware = _ref.middleware,
+        middleware = _ref$middleware === void 0 ? [] : _ref$middleware,
+        _ref$enhancers = _ref.enhancers,
+        enhancers = _ref$enhancers === void 0 ? [] : _ref$enhancers;
+
+    var rootReducer = (0, _redux.combineReducers)(_objectSpread(_objectSpread({}, reducers), {}, {
+      template: templateReducers
+    }));
+    var allMiddleware = [].concat(templateMiddleware, _toConsumableArray(middleware));
+
+    var appliedMiddleware = _redux.applyMiddleware.apply(this, allMiddleware);
+
+    var allEnhancers = [appliedMiddleware].concat(templateEnhancers, _toConsumableArray(enhancers));
+
+    var storeEnhancer = _redux.compose.apply(this, allEnhancers);
+
+    var store = (0, _redux.createStore)(rootReducer, initialState, storeEnhancer);
+    return store;
+  };
+}
+//# sourceMappingURL=get-create-store.js.map

package/lib/common/redux/profile.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ProfileReducer;
+exports.setProfileBaseData = setProfileBaseData;
+
+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; }
+
+var INF_PROFILE_SET_USER_BASE = 'INF_PROFILE_SET_USER_BASE';
+var initialState = {
+  firstName: '',
+  lastName: '',
+  middleName: '',
+  prefix: '',
+  suffix: ''
+};
+
+function ProfileReducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments.length > 1 ? arguments[1] : undefined;
+
+  switch (action.type) {
+    case INF_PROFILE_SET_USER_BASE:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          firstName: action.data.firstName,
+          lastName: action.data.lastName,
+          middleName: action.data.middleName,
+          prefix: action.data.prefix,
+          suffix: action.data.suffix
+        });
+      }
+  }
+
+  return state;
+}
+
+function setProfileBaseData(data) {
+  return {
+    type: INF_PROFILE_SET_USER_BASE,
+    data: data
+  };
+}
+//# sourceMappingURL=profile.js.map

package/lib/common/redux/template-connect.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = connectToTemplate;
+exports.TemplateContext = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactRedux = require("react-redux");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var TemplateContext = /*#__PURE__*/_react.default.createContext();
+
+exports.TemplateContext = TemplateContext;
+
+function connectToTemplate(mapStateToProps, mapDispatchToProps, mergeProps) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  options.context = TemplateContext;
+  return (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps, mergeProps, options);
+}
+//# sourceMappingURL=template-connect.js.map

package/lib/common/usaa-template-common-hoc.js

@@ -0,0 +1,80 @@
+"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 = addUsaaTemplateCommon;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactHelmet = require("react-helmet");
+
+var _reactRedux = require("react-redux");
+
+var _usaaTemplateCommon = _interopRequireDefault(require("./usaa-template-common"));
+
+var _getCreateStore = _interopRequireDefault(require("./redux/get-create-store"));
+
+var _templateConnect = 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 addUsaaTemplateCommon(BaseTemplate) {
+  var baseTemplateReducers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var createStore = (0, _getCreateStore.default)(baseTemplateReducers);
+
+  var UsaaTemplateCommonHOC = /*#__PURE__*/function (_React$Component) {
+    _inherits(UsaaTemplateCommonHOC, _React$Component);
+
+    var _super = _createSuper(UsaaTemplateCommonHOC);
+
+    function UsaaTemplateCommonHOC(props) {
+      var _this;
+
+      _classCallCheck(this, UsaaTemplateCommonHOC);
+
+      _this = _super.call(this, props);
+      _this.store = createStore();
+      return _this;
+    }
+
+    _createClass(UsaaTemplateCommonHOC, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/_react.default.createElement(_reactRedux.Provider, {
+          store: this.store,
+          context: _templateConnect.TemplateContext
+        }, /*#__PURE__*/_react.default.createElement(_usaaTemplateCommon.default, null, /*#__PURE__*/_react.default.createElement(BaseTemplate, this.props, /*#__PURE__*/_react.default.createElement(_reactHelmet.Helmet, {
+          titleTemplate: "%s | USAA"
+        }), this.props.children)));
+      }
+    }]);
+
+    return UsaaTemplateCommonHOC;
+  }(_react.default.Component);
+
+  return UsaaTemplateCommonHOC;
+}
+//# sourceMappingURL=usaa-template-common-hoc.js.map

package/lib/common/usaa-template-common.js

@@ -0,0 +1,178 @@
+"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 _loadUtag = _interopRequireDefault(require("./util/load-utag"));
+
+var a11y = _interopRequireWildcard(require("./util/a11y"));
+
+var _usaaPerformance = _interopRequireWildcard(require("usaa-performance"));
+
+var _usaaAnalytics = require("usaa-analytics");
+
+var _ecid = _interopRequireDefault(require("./util/ecid"));
+
+var _templateConnect = _interopRequireDefault(require("./redux/template-connect"));
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _usaaAuthentication = require("usaa-authentication");
+
+var _getProfileBaseData = _interopRequireDefault(require("./util/get-profile-base-data"));
+
+var _profile = require("./redux/profile");
+
+var _getProfileAnalytics = _interopRequireDefault(require("./util/get-profile-analytics"));
+
+require("normalize.css/normalize.css");
+
+require("usaa-css-core/css/base/base.css");
+
+require("usaa-css-grids/lib/css/grids.css");
+
+require("usaa-css-core/css/base/utilities.css");
+
+require("usaa-css-core/css/components/links.css");
+
+require("usaa-css-core/css/components/lists.css");
+
+require("../css/main-panel-common.css");
+
+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 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; }
+
+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); }
+
+var PerfTool = _usaaPerformance.default.getInstance();
+
+var analyticsAttempted = false;
+
+var UsaaTemplateCommon = /*#__PURE__*/function (_React$Component) {
+  _inherits(UsaaTemplateCommon, _React$Component);
+
+  var _super = _createSuper(UsaaTemplateCommon);
+
+  function UsaaTemplateCommon() {
+    var _this;
+
+    _classCallCheck(this, UsaaTemplateCommon);
+
+    _this = _super.call(this);
+    (0, _usaaAuthentication.checkForForceAuth)(); // ENTERPRISE CONVERSATION ID (cookie)
+
+    (0, _ecid.default)();
+    PerfTool.start('usaa-template-common', _usaaPerformance.PERF_CONTENT_TYPE.primary);
+    return _this;
+  }
+
+  _createClass(UsaaTemplateCommon, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this2 = this;
+
+      PerfTool.stop('usaa-template-common');
+      a11y.startKeyboardActiveListener(); // see if I'm a routed app
+
+      if (typeof window !== 'undefined' && window.location && window.USAA && window.USAA.ent && window.USAA.ent.digitalData && window.USAA.ent.routeData) {
+        this.routeData = window.USAA.ent.routeData;
+        this.route = ''; // store baseRoute appData
+
+        this.routeData[''] = _objectSpread({}, window.USAA.ent.digitalData);
+      } else {
+        this.routeData = false; // don't start no routes, it won't be no routes
+      }
+
+      (0, _usaaAuthentication.getGuid)().then(function (guid) {
+        _this2.guid = guid;
+        (0, _getProfileBaseData.default)(guid, _axios.default).then(function (data) {
+          return _this2.props.dispatch((0, _profile.setProfileBaseData)(data));
+        }).then(function () {
+          if (!analyticsAttempted) {
+            analyticsAttempted = true;
+            (0, _getProfileAnalytics.default)(guid, _axios.default).then(_loadUtag.default, _loadUtag.default);
+          }
+        }, _loadUtag.default);
+      }, _loadUtag.default);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      if (this.routeData) {
+        // See if my route changed.
+        var newRoute = window.location.pathname.slice(window.USAA.ent.baseRoute.length);
+
+        if (newRoute !== this.route) {
+          // search routeData for a route match
+          if (typeof this.routeData[newRoute] !== 'undefined') {
+            // don't overwrite the data from the profile service
+            var profile = {};
+
+            if (window.USAA.ent.digitalData.user) {
+              profile.user = {
+                attributes: window.USAA.ent.digitalData.user.attributes
+              };
+            } // merge routeData without destroying existing object
+
+
+            window.USAA.ent.digitalData = _objectSpread(_objectSpread({}, this.routeData[newRoute]), profile); // fire a new pageView
+
+            (0, _usaaAnalytics.pageView)();
+          }
+
+          this.route = newRoute;
+        }
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      a11y.stopKeyboardActiveListener();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return this.props.children;
+    }
+  }]);
+
+  return UsaaTemplateCommon;
+}(_react.default.Component);
+
+var _default = (0, _templateConnect.default)()(UsaaTemplateCommon);
+
+exports.default = _default;
+//# sourceMappingURL=usaa-template-common.js.map

package/lib/common/util/a11y.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startKeyboardActiveListener = startKeyboardActiveListener;
+exports.stopKeyboardActiveListener = stopKeyboardActiveListener;
+var keyboardIsActive = false;
+var textTypes = ['text', 'password', 'search', 'textarea'];
+
+function startKeyboardActiveListener() {
+  document.body.addEventListener('keydown', handleKeyDown);
+  document.body.addEventListener('mousedown', handleMousedown);
+}
+
+function stopKeyboardActiveListener() {
+  document.body.removeEventListener('keydown', handleKeyDown);
+  document.body.removeEventListener('mousedown', handleMousedown);
+  handleMousedown();
+}
+
+function handleKeyDown(ev) {
+  if (!keyboardIsActive && isValidKey(ev)) {
+    document.body.classList.add('keyboardActive');
+    keyboardIsActive = true;
+  }
+}
+
+function handleMousedown(ev) {
+  if (keyboardIsActive) {
+    document.body.classList.remove('keyboardActive');
+    keyboardIsActive = false;
+  }
+}
+
+function isValidKey(_ref) {
+  var code = _ref.code,
+      keyCode = _ref.keyCode,
+      target = _ref.target;
+  // you don't want to trigger the keyboardActive class
+  // if hitting space or enter in text inputs or textareas
+  var isTextInput = textTypes.indexOf(target.type) !== -1;
+  return code === 'Tab' || keyCode === 9 || (code === 'Enter' || keyCode === 13) && !isTextInput || (code === 'Space' || keyCode === 32) && !isTextInput;
+}
+//# sourceMappingURL=a11y.js.map

package/lib/common/util/check-storage-availability.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = checkForSessionStorage;
+
+var _usaaLogger = _interopRequireDefault(require("usaa-logger"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Checks to see if session storage is available for use.
+ * Using try...catch while trying to set an item in session storage
+ * is the only way to know for sure if it is available or not.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API#Testing_for_availability
+ * @returns {boolean} true if available
+ */
+function checkForSessionStorage() {
+  var isAvailable = true;
+  var TEST_STORAGE_KEY = 'TEST_STORAGE_KEY';
+
+  try {
+    window.sessionStorage.setItem(TEST_STORAGE_KEY, TEST_STORAGE_KEY);
+    window.sessionStorage.removeItem(TEST_STORAGE_KEY);
+  } catch (e) {
+    // If there is no window object, return true to not mess with prerender.
+    if (typeof window !== 'undefined') {
+      var logger = new _usaaLogger.default();
+      logger.log('UsaaTemplates - session storage is unavailable');
+      isAvailable = false;
+    }
+  }
+
+  return isAvailable;
+}
+//# sourceMappingURL=check-storage-availability.js.map