@agilemotion/oui-react-js 1.2.7 → 1.2.8

package/dist/event/RouteActionHandler.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _RestUtils = require("../RestUtils");
+
+var _ApplicationContext = _interopRequireDefault(require("../ApplicationContext"));
+
+var _Utils = _interopRequireDefault(require("../Utils"));
+
+var _DynamicJS = _interopRequireDefault(require("../DynamicJS"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const location = window.location.protocol + "//" + window.location.hostname;
+
+class RouteActionHandler {
+  constructor() {
+    if (!RouteActionHandler.instance) {
+      RouteActionHandler.instance = this;
+    }
+
+    return RouteActionHandler.instance;
+  }
+
+  execute(actionConfig, event, component, currentViewId) {
+    // TODO : Implement this full URL
+    //String url = webUrl + "?version=1.0" + (viewPath != null ? "&id=" + URL.encodeQueryString(viewPath) : "")
+    //    + (viewPathRequestDto != null ? "&serviceRequest=" + URL.encodeQueryString(requestDtoWriter.write(viewPathRequestDto)) : "")
+    //    + (portalCurrentOrg != null ? "&profile=" + portalCurrentOrg : "");
+    _ApplicationContext.default.enableFormMarkers(false);
+
+    let forward = true;
+    let path = null;
+    let isParent = _Utils.default.isNull(actionConfig.parent) ? false : actionConfig.parent;
+    let isPopup = _Utils.default.isNull(actionConfig.popUp) ? false : actionConfig.popUp;
+
+    if (!_Utils.default.isNull(actionConfig.pathEvaluator)) {
+      path = _DynamicJS.default.executeScriptObject(currentViewId + 'ViewEvaluator_' + event.source.id, actionConfig.pathEvaluator);
+    } else {
+      path = actionConfig.path === '$event.data' ? event.data : actionConfig.path;
+
+      if ("@#{history.back}" === path) {
+        let historyElement = _ApplicationContext.default.getPreviousHistoryElement();
+
+        if (historyElement === null) {
+          console.error("Invalid path. Cannot got back in history");
+          return;
+        }
+
+        path = historyElement.path;
+        forward = false;
+      }
+    }
+
+    let parameterValues = [];
+
+    if (!_Utils.default.isNull(actionConfig.parameters)) {
+      for (let i = 0; i < actionConfig.parameters.length; i++) {
+        let parameter = actionConfig.parameters[i];
+
+        let parameterValue = _ApplicationContext.default.resolveParameterValue(parameter);
+
+        let validator = parameter.validator;
+
+        if (_Utils.default.isNull(parameterValue) && !_Utils.default.isNull(validator) && _Utils.default.evaluateBooleanExpression(validator.nullable, parameter.name) === false) {
+          console.error('Routing to path ' + path + ', failed. A null value for a NON-NULLABLE parameter was found - ' + JSON.stringify(parameter)); // TODO : Display the configured error message at the correct error panel
+
+          return;
+        }
+
+        let param = {};
+        param.name = parameter.name;
+        param.value = _Utils.default.isNull(parameterValue) ? null : parameterValue.instanceType === "TypedValue" ? parameterValue.value : parameterValue;
+        parameterValues.push(param);
+      }
+    }
+
+    let url = location + _ApplicationContext.default.getBaseApiUrl() + _ApplicationContext.default.getUIConfigPath() + "/view?version=1.0&id=" + path;
+    (0, _RestUtils.sendRequest)(url, data => {
+      if (isParent) {
+        _ApplicationContext.default.removeLoadedGraph();
+      }
+
+      if (data.type === 'view') {
+        let currentView = _ApplicationContext.default.getCurrentView();
+
+        if (_Utils.default.isNull(currentView) || !currentView.popUp) {
+          let view = {};
+          view.config = data;
+          view.handle = {};
+          view.parameters = parameterValues;
+          view.parent = isParent;
+          view.popUp = isPopup;
+
+          _ApplicationContext.default.addView(view, path, forward); // None-existing route to ensure that the current view unloads
+
+
+          if (_Utils.default.isNull(actionConfig.popUp) || actionConfig.popUp === false) {
+            _ApplicationContext.default.getViewPortHistory().push("/switch");
+
+            _ApplicationContext.default.getViewPortHistory().push("/view/" + data.id);
+          }
+        } else {
+          _ApplicationContext.default.closeCurrentView(false);
+
+          _ApplicationContext.default.getCurrentView().handle.api.updateModel(parameterValues);
+        }
+      } else if (data.type === 'graph') {
+        _ApplicationContext.default.loadGraph(isParent, isPopup, data);
+      }
+    }, e => {
+      console.error(e);
+    }, true, false);
+  }
+
+}
+
+const instance = new RouteActionHandler();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;

package/dist/event/ScriptActionHandler.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _DynamicJS = _interopRequireDefault(require("../DynamicJS"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ScriptActionHandler {
+  constructor() {
+    if (!ScriptActionHandler.instance) {
+      ScriptActionHandler.instance = this;
+    }
+
+    return ScriptActionHandler.instance;
+  }
+
+  execute(actionConfig, event, component, currentViewId) {
+    let componentId = event.getSource().api.id;
+
+    _DynamicJS.default.executeScriptObject(currentViewId + '_' + componentId + '_script', actionConfig.script, componentId, {}, event);
+  }
+
+}
+
+const instance = new ScriptActionHandler();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;

package/dist/event/ServiceCallActionHandler.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _RestUtils = require("../RestUtils");
+
+var _DynamicJS = _interopRequireDefault(require("./../DynamicJS"));
+
+var _Utils = _interopRequireDefault(require("./../Utils"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ServiceCallActionHandler {
+  constructor() {
+    if (!ServiceCallActionHandler.instance) {
+      ServiceCallActionHandler.instance = this;
+    }
+
+    return ServiceCallActionHandler.instance;
+  }
+
+  execute(actionConfig, event, component, currentViewId, successCallback, errorCallback) {
+    let method = actionConfig.service.type === 'remoteObjectProxy' ? _RestUtils.invokeRpc : _RestUtils.invokeRest;
+    method(actionConfig.service, component, currentViewId, result => {
+      let handle = !_Utils.default.isNull(component) && !_Utils.default.isNull(component.current) ? component.current : component;
+
+      if (!_Utils.default.isNull(actionConfig.postScript)) {
+        try {
+          let valuesMap = {};
+          valuesMap.response = result.data;
+
+          _DynamicJS.default.executeScriptObject('postScript_' + currentViewId + '_' + handle.getId(), actionConfig.postScript, handle.getId(), valuesMap);
+        } catch (e) {
+          console.error(e);
+        }
+      }
+
+      if (!_Utils.default.isNull(successCallback)) {
+        successCallback(result);
+      }
+    }, e => {
+      _Utils.default.publishSystemErrorMessage(currentViewId);
+
+      if (!_Utils.default.isNull(errorCallback)) {
+        errorCallback(e);
+      }
+    }, null, actionConfig.returnValueBinding, actionConfig.successMessage);
+  }
+
+}
+
+const instance = new ServiceCallActionHandler();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;

package/dist/event/SignalGraphActionHandler.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _Utils = _interopRequireDefault(require("./../Utils"));
+
+var _ApplicationContext = _interopRequireDefault(require("../ApplicationContext"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class SignalGraphActionHandler {
+  constructor() {
+    if (!SignalGraphActionHandler.instance) {
+      SignalGraphActionHandler.instance = this;
+    }
+
+    return SignalGraphActionHandler.instance;
+  }
+
+  execute(actionConfig, event, component, currentViewId) {
+    _ApplicationContext.default.signalGraph(actionConfig.graphId, event);
+  }
+
+}
+
+const instance = new SignalGraphActionHandler();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;

package/dist/js/Addresses.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Addresses {
+  constructor(resolver) {
+    this.resolver = resolver;
+  }
+
+  copy(from, to, checked) {
+    if (checked) {
+      let currentViewModel = this.resolver.resolveComponentApi('view').model;
+      let fromAddressLine1 = currentViewModel[from + '.line1'];
+      let fromAddressLine2 = currentViewModel[from + '.line2'];
+      let fromAddressLine3 = currentViewModel[from + '.line3'];
+      let fromAddressCode = currentViewModel[from + '.code'];
+      this.resolver.resolveComponentApi(to + '.line1').value = fromAddressLine1;
+      this.resolver.resolveComponentApi(to + '.line2').value = fromAddressLine2;
+      this.resolver.resolveComponentApi(to + '.line3').value = fromAddressLine3;
+      this.resolver.resolveComponentApi(to + '.code').value = fromAddressCode;
+    }
+  }
+
+}
+
+exports.default = Addresses;

package/dist/js/DynamicLib.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Utils = _interopRequireDefault(require("./../Utils"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class DynamicLib {
+  constructor(resolver) {
+    _defineProperty(this, "evaluateExpression", expression => {
+      return this.resolver.resolveExpressionValue(expression);
+    });
+
+    _defineProperty(this, "isNull", value => {
+      return _Utils.default.isNull(value);
+    });
+
+    this.resolver = resolver;
+  }
+
+}
+
+exports.default = DynamicLib;

package/dist/js/Validators.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Utils = _interopRequireDefault(require("../Utils"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Validators {
+  constructor(resolver) {
+    this.resolver = resolver;
+  }
+
+}
+
+exports.default = Validators;

package/dist/redux/store/ConfigureStore.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = ConfigureStore;
+
+var _redux = require("redux");
+
+var _reduxThunk = _interopRequireDefault(require("redux-thunk"));
+
+var _connectedReactRouter = require("connected-react-router");
+
+var Security = _interopRequireWildcard(require("./SecurityStore"));
+
+var Dashboard = _interopRequireWildcard(require("./DashboardStore"));
+
+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 ConfigureStore(history, initialState) {
+  const reducers = {
+    security: Security.reducer,
+    dashboard: Dashboard.reducer
+  };
+  const middleware = [_reduxThunk.default, (0, _connectedReactRouter.routerMiddleware)(history)]; // In development, use the browser's Redux dev tools extension if installed
+
+  const enhancers = [];
+  const isDevelopment = process.env.NODE_ENV === 'development';
+
+  if (isDevelopment && typeof window !== 'undefined' && window.devToolsExtension) {
+    enhancers.push(window.devToolsExtension());
+  }
+
+  const rootReducer = (0, _redux.combineReducers)(_objectSpread(_objectSpread({}, reducers), {}, {
+    router: (0, _connectedReactRouter.connectRouter)(history)
+  }));
+  return (0, _redux.createStore)(rootReducer, initialState, (0, _redux.compose)((0, _redux.applyMiddleware)(...middleware), ...enhancers));
+}

package/dist/redux/store/DashboardStore.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reducer = exports.actionCreators = void 0;
+
+var _RestUtils = require("../../RestUtils");
+
+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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+const requestType = 'REQUEST';
+const receiveDashboardSettingsType = 'RECEIVE_DASHBOARD_SETTINGS';
+const activeRouteMenu = 'ACTIVE_ROUTE_MENU';
+const secondaryThemeColor = 'SECONDARY_THEME_COLOR';
+const initialState = {
+  dashboardSettings: {},
+  isLoading: false,
+  error: false,
+  activeRouteMenu: "Dashboard",
+  secondaryThemeColor: "red"
+};
+let currentDashboardSettings = {};
+const actionCreators = {
+  getDashboardSettings: url => /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(dispatch) {
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            dispatch({
+              type: requestType
+            });
+            (0, _RestUtils.sendRequest)(url, response => {
+              dispatch({
+                type: receiveDashboardSettingsType,
+                dashboardSettings: response,
+                error: false
+              });
+            }, () => {
+              dispatch({
+                type: receiveDashboardSettingsType,
+                dashboardSettings: null,
+                error: true
+              });
+            });
+
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }(),
+  setActiveRoute: route => /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(dispatch) {
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            dispatch({
+              type: activeRouteMenu,
+              activeRouteMenu: route
+            });
+
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+
+    return function (_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }(),
+  setSecondaryThemeColor: secondaryColor => /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(dispatch) {
+      return regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            dispatch({
+              type: secondaryThemeColor,
+              secondaryThemeColor: secondaryColor
+            });
+
+          case 1:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+
+    return function (_x3) {
+      return _ref3.apply(this, arguments);
+    };
+  }()
+};
+exports.actionCreators = actionCreators;
+
+const reducer = (state, action) => {
+  state = state || initialState;
+
+  if (action.type === requestType) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      isLoading: true,
+      dashboardSettings: currentDashboardSettings,
+      error: false
+    });
+  }
+
+  if (action.type === receiveDashboardSettingsType) {
+    currentDashboardSettings = action.dashboardSettings;
+    return _objectSpread(_objectSpread({}, state), {}, {
+      error: action.error,
+      dashboardSettings: currentDashboardSettings,
+      isLoading: false
+    });
+  }
+
+  if (action.type === activeRouteMenu) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      activeRouteMenu: action.activeRouteMenu
+    });
+  }
+
+  if (action.type === secondaryThemeColor) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      secondaryThemeColor: action.secondaryThemeColor
+    });
+  }
+
+  return state;
+};
+
+exports.reducer = reducer;

package/dist/redux/store/History.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _history = require("history");
+
+const history = (0, _history.createBrowserHistory)();
+var _default = history;
+exports.default = _default;

package/dist/redux/store/SecurityStore.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reducer = exports.actionCreators = void 0;
+
+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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+const requestType = 'REQUEST';
+const receiveUserDetailsType = 'RECEIVE_USER_DETAILS';
+const initialState = {
+  userDetails: {},
+  isLoading: false,
+  error: false,
+  currentMenuJson: ""
+};
+let currentUserDetails = {};
+const actionCreators = {
+  login: (url, username, password) => /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(dispatch) {
+      var response, userDetails;
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            dispatch({
+              type: requestType
+            });
+            _context.next = 3;
+            return fetch(url);
+
+          case 3:
+            response = _context.sent;
+            _context.next = 6;
+            return response.json();
+
+          case 6:
+            userDetails = _context.sent;
+            dispatch({
+              type: receiveUserDetailsType,
+              userDetails
+            });
+
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }()
+};
+exports.actionCreators = actionCreators;
+
+const reducer = (state, action) => {
+  state = state || initialState;
+
+  if (action.type === requestType) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      isLoading: true,
+      error: false,
+      userDetails: {}
+    });
+  }
+
+  if (action.type === receiveUserDetailsType) {
+    currentUserDetails = JSON.parse(action.userDetails);
+    return _objectSpread(_objectSpread({}, state), {}, {
+      userDetails: currentUserDetails,
+      isLoading: false
+    });
+  }
+
+  return state;
+};
+
+exports.reducer = reducer;

package/dist/security/TokenManager.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Utils = _interopRequireDefault(require("../Utils"));
+
+var _RestUtils = require("../RestUtils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const MINUTE = 60000;
+const ACCESS_TOKEN_PROPERTY = "accessToken";
+const LAST_LOGIN = "lastLogin";
+const ID_TOKEN_PROPERTY = "idToken";
+const REFRESH_TOKEN_PROPERTY = "refreshToken";
+
+class TokenManager {
+  startTokenRefreshMonitor(url, username) {
+    setInterval(function () {
+      let lastLogin = sessionStorage.getItem(LAST_LOGIN);
+      let refreshToken = sessionStorage.getItem(REFRESH_TOKEN_PROPERTY);
+
+      if (!_Utils.default.isNull(lastLogin) && !_Utils.default.isNull(refreshToken)) {
+        let diff = (new Date().getTime() - parseFloat(lastLogin)) / MINUTE;
+
+        if (diff >= 57) {
+          console.log("Refreshing Token AT [" + diff + "]");
+          let refreshUrl = "".concat(url, "?refreshToken=").concat(refreshToken, "&username=").concat(username);
+          (0, _RestUtils.sendRequest)(refreshUrl, response => {
+            sessionStorage.setItem(ACCESS_TOKEN_PROPERTY, response.accessToken);
+            sessionStorage.setItem(ID_TOKEN_PROPERTY, response.idToken);
+            sessionStorage.setItem(LAST_LOGIN, new Date().getTime());
+          }, e => {
+            console.error('Error refreshing token');
+          }, false);
+        }
+      }
+    }, MINUTE);
+  }
+
+}
+
+const instance = new TokenManager();
+Object.freeze(instance);
+var _default = instance;
+exports.default = _default;