orc-shared 1.7.0-dev.6 → 1.7.0-dev.7

package/dist/actions/modules.js

@@ -1,7 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.setRoutingPerformed = exports.setNewScopeAndModuleName = exports.setModulesStructure = exports.setModuleAsVisible = exports.initializeFirstModuleScope = exports.SET_ROUTING_PERFORMED = exports.SET_NEW_SCOPE_AND_MODULE_NAME = exports.SET_MODULE_AS_VISIBLE = exports.SET_MODULES_STRUCTURE = exports.INITIALIZE_FIRST_MODULE_SCOPE = void 0;
+exports.setRoutingPerformed = exports.setModulesStructure = exports.setModuleAsVisible = exports.initializeFirstModuleScope = exports.SET_ROUTING_PERFORMED = exports.SET_MODULE_AS_VISIBLE = exports.SET_MODULES_STRUCTURE = exports.INITIALIZE_FIRST_MODULE_SCOPE = void 0;
 (function () {
   var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
   enterModule && enterModule(module);
@@ -37,16 +37,6 @@ var initializeFirstModuleScope = exports.initializeFirstModuleScope = function i
     payload: scope
   };
 };
-var SET_NEW_SCOPE_AND_MODULE_NAME = exports.SET_NEW_SCOPE_AND_MODULE_NAME = "SET_NEW_SCOPE_AND_MODULE_NAME";
-var setNewScopeAndModuleName = exports.setNewScopeAndModuleName = function setNewScopeAndModuleName(scope, moduleName) {
-  return {
-    type: SET_NEW_SCOPE_AND_MODULE_NAME,
-    payload: {
-      scope: scope,
-      moduleName: moduleName
-    }
-  };
-};
 var SET_ROUTING_PERFORMED = exports.SET_ROUTING_PERFORMED = "SET_ROUTING_PERFORMED";
 var setRoutingPerformed = exports.setRoutingPerformed = function setRoutingPerformed() {
   return {
@@ -65,8 +55,6 @@ var setRoutingPerformed = exports.setRoutingPerformed = function setRoutingPerfo
   reactHotLoader.register(setModuleAsVisible, "setModuleAsVisible", "/home/vsts/work/1/s/src/actions/modules.js");
   reactHotLoader.register(INITIALIZE_FIRST_MODULE_SCOPE, "INITIALIZE_FIRST_MODULE_SCOPE", "/home/vsts/work/1/s/src/actions/modules.js");
   reactHotLoader.register(initializeFirstModuleScope, "initializeFirstModuleScope", "/home/vsts/work/1/s/src/actions/modules.js");
-  reactHotLoader.register(SET_NEW_SCOPE_AND_MODULE_NAME, "SET_NEW_SCOPE_AND_MODULE_NAME", "/home/vsts/work/1/s/src/actions/modules.js");
-  reactHotLoader.register(setNewScopeAndModuleName, "setNewScopeAndModuleName", "/home/vsts/work/1/s/src/actions/modules.js");
   reactHotLoader.register(SET_ROUTING_PERFORMED, "SET_ROUTING_PERFORMED", "/home/vsts/work/1/s/src/actions/modules.js");
   reactHotLoader.register(setRoutingPerformed, "setRoutingPerformed", "/home/vsts/work/1/s/src/actions/modules.js");
 })();
@@ -87,8 +75,6 @@ var setRoutingPerformed = exports.setRoutingPerformed = function setRoutingPerfo
   reactHotLoader.register(setModuleAsVisible, "setModuleAsVisible", "/home/vsts/work/1/s/src/actions/modules.js");
   reactHotLoader.register(INITIALIZE_FIRST_MODULE_SCOPE, "INITIALIZE_FIRST_MODULE_SCOPE", "/home/vsts/work/1/s/src/actions/modules.js");
   reactHotLoader.register(initializeFirstModuleScope, "initializeFirstModuleScope", "/home/vsts/work/1/s/src/actions/modules.js");
-  reactHotLoader.register(SET_NEW_SCOPE_AND_MODULE_NAME, "SET_NEW_SCOPE_AND_MODULE_NAME", "/home/vsts/work/1/s/src/actions/modules.js");
-  reactHotLoader.register(setNewScopeAndModuleName, "setNewScopeAndModuleName", "/home/vsts/work/1/s/src/actions/modules.js");
   reactHotLoader.register(SET_ROUTING_PERFORMED, "SET_ROUTING_PERFORMED", "/home/vsts/work/1/s/src/actions/modules.js");
   reactHotLoader.register(setRoutingPerformed, "setRoutingPerformed", "/home/vsts/work/1/s/src/actions/modules.js");
 })();

package/dist/actions/scopes.js

@@ -68,12 +68,13 @@ var getDefaultScope = exports.getDefaultScope = function getDefaultScope(module)
   });
 };
 var APPLICATION_SCOPE_HAS_CHANGED = exports.APPLICATION_SCOPE_HAS_CHANGED = "APPLICATION_SCOPE_HAS_CHANGED";
-var applicationScopeHasChanged = exports.applicationScopeHasChanged = function applicationScopeHasChanged(previousScope, newScope) {
+var applicationScopeHasChanged = exports.applicationScopeHasChanged = function applicationScopeHasChanged(previousScope, newScope, moduleName) {
   return {
     type: APPLICATION_SCOPE_HAS_CHANGED,
     payload: {
       previousScope: previousScope,
-      newScope: newScope
+      newScope: newScope,
+      moduleName: moduleName
     }
   };
 };

package/dist/buildStore.js

@@ -26,6 +26,7 @@ var _metadata = _interopRequireDefault(require("./reducers/metadata"));
 var _requestStates = _interopRequireDefault(require("./reducers/requestStates"));
 var _tasks = _interopRequireDefault(require("./reducers/tasks"));
 var _globalErrorMessages = _interopRequireDefault(require("./reducers/globalErrorMessages"));
+var _scopeRouteState = _interopRequireDefault(require("./reducers/scopeRouteState"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -90,7 +91,8 @@ var buildStore = function buildStore(reducers, devOptions) {
       metadata: _metadata.default,
       requestStates: _requestStates.default,
       tasks: _tasks.default,
-      globalErrorMessages: _globalErrorMessages.default
+      globalErrorMessages: _globalErrorMessages.default,
+      scopeRouteState: _scopeRouteState.default
     }));
   };
   var rootReducer = buildReducer(reducers);

package/dist/components/Scope/useScopeConfirmationModalState.js

@@ -10,7 +10,6 @@ var _scopes = require("../../actions/scopes");
 var _useScopeData3 = _interopRequireDefault(require("./useScopeData"));
 var _view = require("../../selectors/view");
 var _constants = require("../../constants");
-var _modules = require("../../actions/modules");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -77,8 +76,7 @@ var useApplicationScopeChanger = function useApplicationScopeChanger(closingTabH
   var moduleName = (0, _useSelectorAndUnwrap.default)(_navigation.selectCurrentModuleName);
   return function (previousScope, newScope) {
     ExecuteClosingTabHandlerActions(closingTabHandlerActions).then(function () {
-      dispatch((0, _modules.setNewScopeAndModuleName)(newScope, moduleName));
-      dispatch((0, _scopes.applicationScopeHasChanged)(previousScope, newScope));
+      dispatch((0, _scopes.applicationScopeHasChanged)(previousScope, newScope, moduleName));
     });
   };
 };

package/dist/hooks/useScopeGuardLoader.js

@@ -0,0 +1,77 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _reactRedux = require("react-redux");
+var _scopeRouteState = require("../selectors/scopeRouteState");
+var _useLoader = _interopRequireDefault(require("./useLoader"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+(function () {
+  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
+  enterModule && enterModule(module);
+})();
+(function () {
+  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
+  enterModule && enterModule(module);
+})();
+var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
+  return a;
+};
+var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
+  return a;
+};
+// look at scopeRouteState.js for documentation
+
+var useScopeGuardLoader = function useScopeGuardLoader(actions, cutoutSelector) {
+  var changeInProgress = (0, _reactRedux.useSelector)(_scopeRouteState.getScopeChangeInProgress);
+  var cutoutSelectorGuard = function cutoutSelectorGuard() {
+    if (changeInProgress) {
+      return true;
+    }
+    if (cutoutSelector) {
+      for (var _len = arguments.length, selArgs = new Array(_len), _key = 0; _key < _len; _key++) {
+        selArgs[_key] = arguments[_key];
+      }
+      return cutoutSelector.apply(null, selArgs);
+    }
+    return true;
+  };
+  (0, _useLoader.default)(actions, cutoutSelectorGuard);
+};
+__signature__(useScopeGuardLoader, "useSelector{changeInProgress}\nuseLoader{}", function () {
+  return [_reactRedux.useSelector, _useLoader.default];
+});
+__signature__(useScopeGuardLoader, "useSelector{changeInProgress}\nuseLoader{}", function () {
+  return [_reactRedux.useSelector, _useLoader.default];
+});
+var _default = useScopeGuardLoader;
+var _default2 = _default;
+var _default3 = exports.default = _default2;
+;
+(function () {
+  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+  if (!reactHotLoader) {
+    return;
+  }
+  reactHotLoader.register(useScopeGuardLoader, "useScopeGuardLoader", "/home/vsts/work/1/s/src/hooks/useScopeGuardLoader.js");
+  reactHotLoader.register(_default, "default", "/home/vsts/work/1/s/src/hooks/useScopeGuardLoader.js");
+})();
+;
+(function () {
+  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
+  leaveModule && leaveModule(module);
+})();
+;
+(function () {
+  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+  if (!reactHotLoader) {
+    return;
+  }
+  reactHotLoader.register(useScopeGuardLoader, "useScopeGuardLoader", "/home/vsts/work/1/s/src/hooks/useScopeGuardLoader.js");
+  reactHotLoader.register(_default2, "default", "/home/vsts/work/1/s/src/hooks/useScopeGuardLoader.js");
+})();
+;
+(function () {
+  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
+  leaveModule && leaveModule(module);
+})();

package/dist/reducers/modules.js

@@ -5,6 +5,7 @@ exports.default = void 0;
 var _immutable = _interopRequireDefault(require("immutable"));
 var _modules = require("../actions/modules");
 var _constants = require("./../constants");
+var _scopes = require("../actions/scopes");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 (function () {
   var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
@@ -73,15 +74,15 @@ var viewStateReducer = function viewStateReducer(state, action) {
         visibleModules.push(action.payload);
         return state.set("visibleModules", _immutable.default.fromJS(visibleModules));
       }
-    case _modules.SET_NEW_SCOPE_AND_MODULE_NAME:
+    case _scopes.APPLICATION_SCOPE_HAS_CHANGED:
       {
         var lastScopeAndModuleSelection = state.get("lastScopeAndModuleSelection").toJS();
-        if (action.payload.scope !== lastScopeAndModuleSelection.scope) {
+        if (action.payload.newScope !== lastScopeAndModuleSelection.scope) {
           state = state.set("visibleModules", _immutable.default.fromJS([]));
         }
         return state.set("lastScopeAndModuleSelection", _immutable.default.fromJS({
           moduleName: action.payload.moduleName,
-          scope: action.payload.scope,
+          scope: action.payload.newScope,
           routingPerformed: false
         }));
       }

package/dist/reducers/scopeRouteState.js

@@ -0,0 +1,83 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _immutable = _interopRequireDefault(require("immutable"));
+var _navigation = require("../actions/navigation");
+var _scopes = require("../actions/scopes");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+(function () {
+  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
+  enterModule && enterModule(module);
+})();
+(function () {
+  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
+  enterModule && enterModule(module);
+})();
+var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
+  return a;
+};
+var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
+  return a;
+};
+var initialState = _immutable.default.fromJS({
+  scopeChangeInProgress: false
+});
+
+/*
+	This reducer and its associated hook is used to prevent a request from being sent out while the application's scope is changing.
+	Basically the reducer responds to an action, set a flag to true and then set it to false once another action is triggered (route change).
+
+	This is a pretty hackish way to ensure that the correct requests are being executed (references #74924, #74764) however we know of no other way to achieve the desired result.
+* */
+
+var viewStateReducer = function viewStateReducer(state, action) {
+  if (state === void 0) {
+    state = initialState;
+  }
+  switch (action.type) {
+    case _scopes.APPLICATION_SCOPE_HAS_CHANGED:
+      {
+        return state.set("scopeChangeInProgress", action.payload.newScope !== action.payload.previousScope);
+      }
+    case _navigation.SET_ROUTE:
+      {
+        return state.set("scopeChangeInProgress", false);
+      }
+    default:
+      return state;
+  }
+};
+var _default = viewStateReducer;
+var _default2 = _default;
+var _default3 = exports.default = _default2;
+;
+(function () {
+  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+  if (!reactHotLoader) {
+    return;
+  }
+  reactHotLoader.register(initialState, "initialState", "/home/vsts/work/1/s/src/reducers/scopeRouteState.js");
+  reactHotLoader.register(viewStateReducer, "viewStateReducer", "/home/vsts/work/1/s/src/reducers/scopeRouteState.js");
+  reactHotLoader.register(_default, "default", "/home/vsts/work/1/s/src/reducers/scopeRouteState.js");
+})();
+;
+(function () {
+  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
+  leaveModule && leaveModule(module);
+})();
+;
+(function () {
+  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+  if (!reactHotLoader) {
+    return;
+  }
+  reactHotLoader.register(initialState, "initialState", "/home/vsts/work/1/s/src/reducers/scopeRouteState.js");
+  reactHotLoader.register(viewStateReducer, "viewStateReducer", "/home/vsts/work/1/s/src/reducers/scopeRouteState.js");
+  reactHotLoader.register(_default2, "default", "/home/vsts/work/1/s/src/reducers/scopeRouteState.js");
+})();
+;
+(function () {
+  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
+  leaveModule && leaveModule(module);
+})();

package/dist/selectors/scopeRouteState.js

@@ -0,0 +1,53 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getScopeChangeInProgress = void 0;
+var _reselect = require("reselect");
+(function () {
+  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
+  enterModule && enterModule(module);
+})();
+(function () {
+  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
+  enterModule && enterModule(module);
+})();
+var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
+  return a;
+};
+var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
+  return a;
+};
+var scopeRouteStateData = function scopeRouteStateData(state) {
+  return state.get("scopeRouteState");
+};
+var getScopeChangeInProgress = exports.getScopeChangeInProgress = (0, _reselect.createSelector)(scopeRouteStateData, function (data) {
+  return data.get("scopeChangeInProgress");
+});
+;
+(function () {
+  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+  if (!reactHotLoader) {
+    return;
+  }
+  reactHotLoader.register(scopeRouteStateData, "scopeRouteStateData", "/home/vsts/work/1/s/src/selectors/scopeRouteState.js");
+  reactHotLoader.register(getScopeChangeInProgress, "getScopeChangeInProgress", "/home/vsts/work/1/s/src/selectors/scopeRouteState.js");
+})();
+;
+(function () {
+  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
+  leaveModule && leaveModule(module);
+})();
+;
+(function () {
+  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+  if (!reactHotLoader) {
+    return;
+  }
+  reactHotLoader.register(scopeRouteStateData, "scopeRouteStateData", "/home/vsts/work/1/s/src/selectors/scopeRouteState.js");
+  reactHotLoader.register(getScopeChangeInProgress, "getScopeChangeInProgress", "/home/vsts/work/1/s/src/selectors/scopeRouteState.js");
+})();
+;
+(function () {
+  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
+  leaveModule && leaveModule(module);
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "orc-shared",
-	"version": "1.7.0-dev.6",
+	"version": "1.7.0-dev.7",
 	"description": "Shared code for Orckestra applications",
 	"main": "./src/index.js",
 	"exports": {

package/src/actions/modules.js

@@ -19,16 +19,6 @@ export const initializeFirstModuleScope = scope => ({
 	payload: scope,
 });
 
-export const SET_NEW_SCOPE_AND_MODULE_NAME = "SET_NEW_SCOPE_AND_MODULE_NAME";
-
-export const setNewScopeAndModuleName = (scope, moduleName) => ({
-	type: SET_NEW_SCOPE_AND_MODULE_NAME,
-	payload: {
-		scope,
-		moduleName,
-	},
-});
-
 export const SET_ROUTING_PERFORMED = "SET_ROUTING_PERFORMED";
 
 export const setRoutingPerformed = () => ({

package/src/actions/modules.test.js

@@ -3,11 +3,9 @@ import {
 	initializeFirstModuleScope,
 	SET_MODULE_AS_VISIBLE,
 	SET_MODULES_STRUCTURE,
-	SET_NEW_SCOPE_AND_MODULE_NAME,
 	SET_ROUTING_PERFORMED,
 	setModuleAsVisible,
 	setModulesStructure,
-	setNewScopeAndModuleName,
 	setRoutingPerformed,
 } from "./modules";
 
@@ -38,18 +36,6 @@ describe("setModuleAsVisible", () => {
 	});
 });
 
-describe("setNewScopeAndModuleName", () => {
-	it("creates an action object", () => {
-		expect(setNewScopeAndModuleName, "when called with", ["matrixScope", "moduleNeo"], "to equal", {
-			type: SET_NEW_SCOPE_AND_MODULE_NAME,
-			payload: {
-				scope: "matrixScope",
-				moduleName: "moduleNeo",
-			},
-		});
-	});
-});
-
 describe("setRoutingPerformed", () => {
 	it("creates an action object", () => {
 		expect(setRoutingPerformed, "when called", "to equal", {

package/src/actions/scopes.js

@@ -50,12 +50,13 @@ export const getDefaultScope = module =>
 
 export const APPLICATION_SCOPE_HAS_CHANGED = "APPLICATION_SCOPE_HAS_CHANGED";
 
-export const applicationScopeHasChanged = (previousScope, newScope) => {
+export const applicationScopeHasChanged = (previousScope, newScope, moduleName) => {
 	return {
 		type: APPLICATION_SCOPE_HAS_CHANGED,
 		payload: {
 			previousScope,
 			newScope,
+			moduleName,
 		},
 	};
 };

package/src/actions/scopes.test.js

@@ -140,11 +140,12 @@ describe("getScopes", () => {
 
 describe("applicationScopeHasChanged", () => {
 	it("creates an action object", () => {
-		expect(applicationScopeHasChanged, "when called with", ["oldScope", "newScope"], "to equal", {
+		expect(applicationScopeHasChanged, "when called with", ["oldScope", "newScope", "module"], "to equal", {
 			type: APPLICATION_SCOPE_HAS_CHANGED,
 			payload: {
 				previousScope: "oldScope",
 				newScope: "newScope",
+				moduleName: "module",
 			},
 		});
 	});

package/src/buildStore.js

@@ -22,6 +22,7 @@ import metadataReducer from "./reducers/metadata";
 import requestStatesReducer from "./reducers/requestStates";
 import tasksReducer from "./reducers/tasks";
 import globalErrorMessagesReducer from "./reducers/globalErrorMessages";
+import scopeRouteStateReducer from "./reducers/scopeRouteState";
 
 window.BUILD_ID = BUILD_ID;
 window.BUILD_NUMBER = BUILD_NUMBER;
@@ -69,6 +70,7 @@ const buildStore = (reducers, devOptions = {}) => {
 			requestStates: requestStatesReducer,
 			tasks: tasksReducer,
 			globalErrorMessages: globalErrorMessagesReducer,
+			scopeRouteState: scopeRouteStateReducer,
 		});
 	const rootReducer = buildReducer(reducers);
 

package/src/components/Scope/useScopeConfirmationModalState.js

@@ -6,7 +6,6 @@ import { applicationScopeHasChanged } from "../../actions/scopes";
 import useScopeData from "./useScopeData";
 import { hasUnsavedDataSelector } from "../../selectors/view";
 import { scopeConfirmationDialogTypes } from "../../constants";
-import { setNewScopeAndModuleName } from "../../actions/modules";
 
 const ExecuteClosingTabHandlerActions = async closingTabHandlerActions => {
 	if (closingTabHandlerActions.length <= 0) return Promise.resolve();
@@ -22,8 +21,7 @@ const useApplicationScopeChanger = closingTabHandlerActions => {
 
 	return (previousScope, newScope) => {
 		ExecuteClosingTabHandlerActions(closingTabHandlerActions).then(() => {
-			dispatch(setNewScopeAndModuleName(newScope, moduleName));
-			dispatch(applicationScopeHasChanged(previousScope, newScope));
+			dispatch(applicationScopeHasChanged(previousScope, newScope, moduleName));
 		});
 	};
 };

package/src/components/Scope/useScopeConfirmationModalState.test.js

@@ -5,7 +5,6 @@ import { TestWrapper } from "../../utils/testUtils";
 import useScopeConfirmationModalState from "./useScopeConfirmationModalState";
 import { mount } from "enzyme";
 import { APPLICATION_SCOPE_HAS_CHANGED } from "../../actions/scopes";
-import { SET_NEW_SCOPE_AND_MODULE_NAME } from "../../actions/modules";
 
 jest.mock("../../utils/buildUrl", () => {
 	const modExport = {};
@@ -180,17 +179,6 @@ describe("useScopeConfirmationModalState", () => {
 		await new Promise(resolve => setTimeout(resolve, 10));
 
 		expect(store.dispatch, "to have calls satisfying", [
-			{
-				args: [
-					{
-						type: SET_NEW_SCOPE_AND_MODULE_NAME,
-						payload: {
-							scope: "newScope",
-							moduleName: "TheModuleName",
-						},
-					},
-				],
-			},
 			{
 				args: [
 					{
@@ -198,6 +186,7 @@ describe("useScopeConfirmationModalState", () => {
 						payload: {
 							previousScope: "TheOldScope",
 							newScope: "newScope",
+							moduleName: "TheModuleName",
 						},
 					},
 				],
@@ -255,17 +244,6 @@ describe("useScopeConfirmationModalState", () => {
 		expect(isModalOpened, "to equal", "false");
 
 		expect(store.dispatch, "to have calls satisfying", [
-			{
-				args: [
-					{
-						type: SET_NEW_SCOPE_AND_MODULE_NAME,
-						payload: {
-							scope: "newScope",
-							moduleName: "TheModuleName",
-						},
-					},
-				],
-			},
 			{
 				args: [
 					{
@@ -273,6 +251,7 @@ describe("useScopeConfirmationModalState", () => {
 						payload: {
 							previousScope: "TheOldScope",
 							newScope: "newScope",
+							moduleName: "TheModuleName",
 						},
 					},
 				],
@@ -325,19 +304,8 @@ describe("useScopeConfirmationModalState", () => {
 			{ args: [null, true] },
 		]);
 
-		expect(store.dispatch.callCount, "to be", 2);
+		expect(store.dispatch.callCount, "to be", 1);
 		expect(store.dispatch, "to have calls satisfying", [
-			{
-				args: [
-					{
-						type: SET_NEW_SCOPE_AND_MODULE_NAME,
-						payload: {
-							scope: "newScope",
-							moduleName: "TheModuleName",
-						},
-					},
-				],
-			},
 			{
 				args: [
 					{
@@ -345,6 +313,7 @@ describe("useScopeConfirmationModalState", () => {
 						payload: {
 							previousScope: "TheOldScope",
 							newScope: "newScope",
+							moduleName: "TheModuleName",
 						},
 					},
 				],

package/src/hooks/useScopeGuardLoader.js

@@ -0,0 +1,25 @@
+import { useSelector } from "react-redux";
+import { getScopeChangeInProgress } from "../selectors/scopeRouteState";
+import useLoader from "./useLoader";
+
+// look at scopeRouteState.js for documentation
+
+const useScopeGuardLoader = (actions, cutoutSelector) => {
+	const changeInProgress = useSelector(getScopeChangeInProgress);
+
+	const cutoutSelectorGuard = (...selArgs) => {
+		if (changeInProgress) {
+			return true;
+		}
+
+		if (cutoutSelector) {
+			return cutoutSelector.apply(null, selArgs);
+		}
+
+		return true;
+	};
+
+	useLoader(actions, cutoutSelectorGuard);
+};
+
+export default useScopeGuardLoader;

package/src/hooks/useScopeGuardLoader.test.js

@@ -0,0 +1,187 @@
+import React, { useState } from "react";
+import { mount, act } from "unexpected-reaction";
+import { Provider, useSelector } from "react-redux";
+import Immutable from "immutable";
+import sinon from "sinon";
+import { spyOnConsole } from "../utils/testUtils";
+import useScopeGuardLoader from "./useScopeGuardLoader";
+
+const TestComp = ({ loader, cutout }) => {
+	useScopeGuardLoader(loader, cutout);
+	const [tick, setTick] = useState(0);
+	const live = useSelector(state => state.get("live"));
+	return (
+		<div id="test" onClick={() => setTick(tick + 1)} data-live={live}>
+			{tick}
+		</div>
+	);
+};
+
+describe("useScopeGuardLoader", () => {
+	spyOnConsole(["warn"]);
+
+	let loader, state, store, appNode;
+	beforeEach(() => {
+		state = Immutable.fromJS({
+			cutout: "yes",
+			live: 0,
+			requests: {
+				logout: false,
+			},
+			scopeRouteState: {
+				scopeChangeInProgress: false,
+			},
+		});
+		const subs = [];
+		store = {
+			updateState: () => {
+				subs.forEach((sub, i) => {
+					sub();
+				});
+			},
+			subscribe: sub => {
+				subs.push(sub);
+				return () => {};
+			},
+			getState: () => state,
+			dispatch: sinon.spy().named("dispatch"),
+		};
+		loader = { type: "TEST_ACTION" };
+		appNode = document.createElement("div");
+		document.body.appendChild(appNode);
+	});
+	afterEach(() => {
+		document.body.removeChild(appNode);
+	});
+
+	it("dispatches the loader action on mount if cutout returns falsy", () =>
+		expect(
+			<Provider store={store}>
+				<TestComp loader={loader} cutout={state => state.get("live")} />
+			</Provider>,
+			"when mounted",
+			"to satisfy",
+			<div>0</div>,
+		).then(() => expect(store.dispatch, "to have calls satisfying", [{ args: [loader] }])));
+
+	it("does not dispatch the loader action on mount because scope change is in progress", () => {
+		state = state.setIn(["scopeRouteState", "scopeChangeInProgress"], true);
+
+		return expect(
+			<Provider store={store}>
+				<TestComp loader={loader} cutout={state => state.get("live")} />
+			</Provider>,
+			"when mounted",
+			"to satisfy",
+			<div>0</div>,
+		).then(() => expect(store.dispatch, "not to have calls satisfying", [{ args: [loader] }]));
+	});
+
+	it("does not dispatch loader if cutout returns truthy", () =>
+		expect(
+			<Provider store={store}>
+				<TestComp loader={loader} cutout={state => state.get("cutout")} />
+			</Provider>,
+			"when mounted",
+			"to satisfy",
+			<div>0</div>,
+		).then(() => expect(store.dispatch, "was not called")));
+
+	it("does not dispatch loader if logged out", () => {
+		state = state.setIn(["requests", "logout"], true);
+
+		expect(
+			<Provider store={store}>
+				<TestComp loader={loader} cutout={state => state.get("cutout")} />
+			</Provider>,
+			"when mounted",
+			"to satisfy",
+			<div>0</div>,
+		).then(() => expect(store.dispatch, "was not called"));
+	});
+
+	it("does not dispatch loader if no cutout selector given, warns", () =>
+		expect(
+			<Provider store={store}>
+				<TestComp loader={loader} />
+			</Provider>,
+			"when mounted",
+			"to satisfy",
+			<div>0</div>,
+		)
+			.then(() => expect(store.dispatch, "was not called"))
+			.then(() =>
+				expect(console.warn, "not to have calls satisfying", [
+					{
+						args: ["useLoader hook called without cutout selector, loader will never be dispatched."],
+					},
+				]),
+			));
+
+	it("dispatches multiple loader actions", () => {
+		const loaderSeries = [{ type: "TEST_ACTION1" }, { type: "TEST_ACTION2" }, { type: "TEST_ACTION3" }];
+		return expect(
+			<Provider store={store}>
+				<TestComp loader={loaderSeries} cutout={state => state.get("live")} />
+			</Provider>,
+			"when mounted",
+			"to satisfy",
+			<div>0</div>,
+		).then(() =>
+			expect(store.dispatch, "to have calls satisfying", [
+				{ args: [loaderSeries[0]] },
+				{ args: [loaderSeries[1]] },
+				{ args: [loaderSeries[2]] },
+			]),
+		);
+	});
+
+	it("only dispatches once if cutout does not change", () =>
+		expect(
+			<Provider store={store}>
+				<TestComp loader={loader} cutout={state => state.get("live")} />
+			</Provider>,
+			"when mounted",
+			"with event",
+			"click",
+			"with event",
+			"click",
+			"with event",
+			"click",
+			"with event",
+			"click",
+			"to satisfy",
+			<div>4</div>,
+		).then(() => expect(store.dispatch, "to have calls satisfying", [{ args: [loader] }])));
+
+	it("fires loader if cutout is falsy, but not again if it becomes truthy", () => {
+		const selector = state => state.get("live");
+		mount(
+			<Provider store={store}>
+				<TestComp loader={loader} cutout={selector} />
+			</Provider>,
+		);
+		expect(store.dispatch, "to have calls satisfying", [{}]);
+		act(() => {
+			state = state.set("live", 1);
+			store.updateState();
+		});
+		expect(store.dispatch, "was called once");
+	});
+
+	it("fires loader if cutout was truthy, becomes falsy", () => {
+		const selector = state => state.get("live");
+		state = state.set("live", 1);
+		mount(
+			<Provider store={store}>
+				<TestComp loader={loader} cutout={selector} />
+			</Provider>,
+		);
+		expect(store.dispatch, "was not called");
+		act(() => {
+			state = state.set("live", 0);
+			store.updateState();
+		});
+		expect(store.dispatch, "was called");
+	});
+});

package/src/reducers/modules.js

@@ -3,10 +3,10 @@ import {
 	INITIALIZE_FIRST_MODULE_SCOPE,
 	SET_MODULE_AS_VISIBLE,
 	SET_MODULES_STRUCTURE,
-	SET_NEW_SCOPE_AND_MODULE_NAME,
 	SET_ROUTING_PERFORMED,
 } from "../actions/modules";
 import { infoBar } from "./../constants";
+import { APPLICATION_SCOPE_HAS_CHANGED } from "../actions/scopes";
 
 const initialState = Immutable.fromJS({
 	tree: {},
@@ -58,10 +58,10 @@ const viewStateReducer = (state = initialState, action) => {
 			return state.set("visibleModules", Immutable.fromJS(visibleModules));
 		}
 
-		case SET_NEW_SCOPE_AND_MODULE_NAME: {
+		case APPLICATION_SCOPE_HAS_CHANGED: {
 			const lastScopeAndModuleSelection = state.get("lastScopeAndModuleSelection").toJS();
 
-			if (action.payload.scope !== lastScopeAndModuleSelection.scope) {
+			if (action.payload.newScope !== lastScopeAndModuleSelection.scope) {
 				state = state.set("visibleModules", Immutable.fromJS([]));
 			}
 
@@ -69,7 +69,7 @@ const viewStateReducer = (state = initialState, action) => {
 				"lastScopeAndModuleSelection",
 				Immutable.fromJS({
 					moduleName: action.payload.moduleName,
-					scope: action.payload.scope,
+					scope: action.payload.newScope,
 					routingPerformed: false,
 				}),
 			);

package/src/reducers/modules.test.js

@@ -3,10 +3,10 @@ import {
 	initializeFirstModuleScope,
 	setModuleAsVisible,
 	setModulesStructure,
-	setNewScopeAndModuleName,
 	setRoutingPerformed,
 } from "../actions/modules";
 import modulesReducer from "./modules";
+import { applicationScopeHasChanged } from "../actions/scopes";
 
 describe("View state reducer", () => {
 	const initialState = {
@@ -145,7 +145,7 @@ describe("View state reducer", () => {
 		const oldState = Immutable.fromJS({
 			...initialState,
 			lastScopeAndModuleSelection: {
-				scope: "aScope",
+				scope: "newScope",
 				moduleName: null,
 				routingPerformed: true,
 			},
@@ -154,13 +154,13 @@ describe("View state reducer", () => {
 		const expected = {
 			...initialState,
 			lastScopeAndModuleSelection: {
-				scope: "aScope",
+				scope: "newScope",
 				moduleName: "moduleMatrix",
 				routingPerformed: false,
 			},
 		};
 
-		const action = setNewScopeAndModuleName("aScope", "moduleMatrix");
+		const action = applicationScopeHasChanged("prevScope", "newScope", "moduleMatrix");
 		const newState = modulesReducer(oldState, action);
 		return expect(newState, "not to be", oldState).and("to equal", Immutable.fromJS(expected));
 	});
@@ -180,7 +180,7 @@ describe("View state reducer", () => {
 			},
 		};
 
-		const action = setNewScopeAndModuleName("newScope", "moduleMatrix");
+		const action = applicationScopeHasChanged("prevScope", "newScope", "moduleMatrix");
 		const newState = modulesReducer(oldState, action);
 		return expect(newState, "not to be", oldState).and("to equal", Immutable.fromJS(expected));
 	});

package/src/reducers/scopeRouteState.js

@@ -0,0 +1,29 @@
+import Immutable from "immutable";
+import { SET_ROUTE } from "../actions/navigation";
+import { APPLICATION_SCOPE_HAS_CHANGED } from "../actions/scopes";
+
+const initialState = Immutable.fromJS({
+	scopeChangeInProgress: false,
+});
+
+/*
+	This reducer and its associated hook is used to prevent a request from being sent out while the application's scope is changing.
+	Basically the reducer responds to an action, set a flag to true and then set it to false once another action is triggered (route change).
+
+	This is a pretty hackish way to ensure that the correct requests are being executed (references #74924, #74764) however we know of no other way to achieve the desired result.
+* */
+
+const viewStateReducer = (state = initialState, action) => {
+	switch (action.type) {
+		case APPLICATION_SCOPE_HAS_CHANGED: {
+			return state.set("scopeChangeInProgress", action.payload.newScope !== action.payload.previousScope);
+		}
+		case SET_ROUTE: {
+			return state.set("scopeChangeInProgress", false);
+		}
+		default:
+			return state;
+	}
+};
+
+export default viewStateReducer;

package/src/reducers/scopeRouteState.test.js

@@ -0,0 +1,49 @@
+import Immutable from "immutable";
+import { applicationScopeHasChanged } from "../actions/scopes";
+import reducer from "./scopeRouteState";
+import { setRoute } from "../actions/navigation";
+
+describe("scopeRouteState", () => {
+	it("behaves as a reducer should", () =>
+		expect(reducer, "to be a reducer with initial state", { scopeChangeInProgress: false }));
+
+	it("set scopeChangeInProgress to true if scope is different", () => {
+		const oldState = Immutable.Map({
+			scopeChangeInProgress: false,
+		});
+		const action = applicationScopeHasChanged("prevScope", "newScope", "module");
+
+		const newState = reducer(oldState, action);
+		return expect(newState, "not to be", oldState).and(
+			"to satisfy",
+			Immutable.fromJS({
+				scopeChangeInProgress: true,
+			}),
+		);
+	});
+
+	it("scopeChangeInProgress stays false if prev and new scope are identical", () => {
+		const oldState = Immutable.Map({
+			scopeChangeInProgress: false,
+		});
+		const action = applicationScopeHasChanged("sameScope", "sameScope", "module");
+
+		const newState = reducer(oldState, action);
+		return expect(newState, "to be", oldState);
+	});
+
+	it("set scopeChangeInProgress to false when route changes", () => {
+		const oldState = Immutable.Map({
+			scopeChangeInProgress: true,
+		});
+		const action = setRoute("loc", {});
+
+		const newState = reducer(oldState, action);
+		return expect(newState, "not to be", oldState).and(
+			"to satisfy",
+			Immutable.fromJS({
+				scopeChangeInProgress: false,
+			}),
+		);
+	});
+});

package/src/selectors/scopeRouteState.js

@@ -0,0 +1,5 @@
+import { createSelector } from "reselect";
+
+const scopeRouteStateData = state => state.get("scopeRouteState");
+
+export const getScopeChangeInProgress = createSelector(scopeRouteStateData, data => data.get("scopeChangeInProgress"));

package/src/selectors/scopeRouteState.test.js

@@ -0,0 +1,13 @@
+import Immutable from "immutable";
+import { getScopeChangeInProgress } from "./scopeRouteState";
+
+describe("getScopeChangeInProgress", () => {
+	it("return the value from the store", () => {
+		const state = Immutable.fromJS({
+			scopeRouteState: {
+				scopeChangeInProgress: true,
+			},
+		});
+		return expect(getScopeChangeInProgress, "called with", [state], "to equal", true);
+	});
+});