navigation-stack 0.3.1 → 0.4.0

package/lib/cjs/{ActionTypes.js → redux/ActionTypes.js}

@@ -9,6 +9,6 @@ var _default = exports.default = {
   NAVIGATE: '@@navigation-stack/NAVIGATE',
   SHIFT: '@@navigation-stack/SHIFT',
   UPDATE: '@@navigation-stack/UPDATE',
-  DISPOSE: '@@navigation-stack/DISPOSE'
+  STOP: '@@navigation-stack/STOP'
 };
 module.exports = exports.default;

package/lib/cjs/redux/ActionTypesInternal.js

@@ -0,0 +1,8 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _default = exports.default = {
+  INTERNAL_LOCATION_UPDATE: '@@navigation-stack/INTERNAL_LOCATION_UPDATE'
+};
+module.exports = exports.default;

package/lib/cjs/{Actions.js → redux/Actions.js}

@@ -5,8 +5,9 @@ exports.default = void 0;
 var _ActionTypes = _interopRequireDefault(require("./ActionTypes"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 var _default = exports.default = {
-  init: () => ({
-    type: _ActionTypes.default.INIT
+  init: initialLocation => ({
+    type: _ActionTypes.default.INIT,
+    payload: initialLocation
   }),
   push: location => ({
     type: _ActionTypes.default.PUSH,
@@ -20,8 +21,8 @@ var _default = exports.default = {
     type: _ActionTypes.default.SHIFT,
     payload: delta
   }),
-  dispose: () => ({
-    type: _ActionTypes.default.DISPOSE
+  stop: () => ({
+    type: _ActionTypes.default.STOP
   })
 };
 module.exports = exports.default;

package/lib/cjs/redux/createMiddlewares.js

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = createMiddlewares;
+var _createAddInputLocationBasePathMiddleware = _interopRequireDefault(require("./middleware/createAddInputLocationBasePathMiddleware"));
+var _createNonProgrammaticNavigationBlockerMiddleware = _interopRequireDefault(require("./middleware/createNonProgrammaticNavigationBlockerMiddleware"));
+var _createProgrammaticNavigationBlockerMiddleware = _interopRequireDefault(require("./middleware/createProgrammaticNavigationBlockerMiddleware"));
+var _createRemoveOutputLocationBasePathMiddleware = _interopRequireDefault(require("./middleware/createRemoveOutputLocationBasePathMiddleware"));
+var _createUpdateInternalLocationMiddleware = _interopRequireDefault(require("./middleware/createUpdateInternalLocationMiddleware"));
+var _navigationOperationMiddleware = _interopRequireDefault(require("./middleware/navigationOperationMiddleware"));
+var _parseInputLocationMiddleware = _interopRequireDefault(require("./middleware/parseInputLocationMiddleware"));
+var _updateLocationMiddleware = _interopRequireDefault(require("./middleware/updateLocationMiddleware"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function createMiddlewares(session, options) {
+  // Allows temporarily ignoring location update events.
+  let shouldIgnoreNavigationLocationSubscriptionEvents = false;
+  const ignoreNavigationLocationSubscriptionEvents = func => {
+    shouldIgnoreNavigationLocationSubscriptionEvents = true;
+    func();
+    shouldIgnoreNavigationLocationSubscriptionEvents = false;
+  };
+  const middlewares = [
+  // Validates that the action "payload" (input location) is a proper `NormalizedInputLocation`.
+  _parseInputLocationMiddleware.default,
+  // Transforms a "PUSH" / "REPLACE" action into a "NAVIGATE" action.
+  _navigationOperationMiddleware.default,
+  // If a website is hosted under a certain path (`basePath`)
+  // then this middleware will automatically hide that starting segment from the `pathname` of `location`s.
+  (0, _createAddInputLocationBasePathMiddleware.default)(options && options.basePath),
+  // Allows blocking navigation.
+  // Handles `NAVIGATE` actions dispatched by the application itself.
+  (0, _createProgrammaticNavigationBlockerMiddleware.default)(session),
+  // This "middleware" performs the actual navigation according to the `session` being used.
+  // For example, when `WebBrowserSession` is used, it calls methods of the `history` object.
+  (0, _createUpdateInternalLocationMiddleware.default)(session, {
+    shouldIgnoreNavigationLocationSubscriptionEvents: () => shouldIgnoreNavigationLocationSubscriptionEvents
+  }),
+  // If a website is hosted under a certain path (`basePath`)
+  // then this middleware will automatically hide that starting segment from the `pathname` of `location`s.
+  (0, _createRemoveOutputLocationBasePathMiddleware.default)(options && options.basePath),
+  // Allows blocking navigation.
+  // Handles location `UPDATE` actions dispatched in response to location update events.
+  (0, _createNonProgrammaticNavigationBlockerMiddleware.default)(session, {
+    ignoreNavigationLocationSubscriptionEvents
+  })];
+
+  // Add `updateLocationMiddleware()`.
+  // It dispatches an `UPDATE` action with the new location
+  // so that the reducer could update it in global state.
+  //
+  // If `_internalLocationReducer` option is passed,
+  // it will not add this middleware. This is only used in tests.
+  //
+  // eslint-disable-next-line no-underscore-dangle
+  if (!(options && options._internalLocationReducer)) {
+    middlewares.push(_updateLocationMiddleware.default);
+  }
+  return middlewares;
+}
+module.exports = exports.default;

package/lib/cjs/redux/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+exports.__esModule = true;
+exports.locationReducer = exports.createMiddlewares = exports.Actions = exports.ActionTypes = void 0;
+var _Actions = _interopRequireDefault(require("./Actions"));
+exports.Actions = _Actions.default;
+var _ActionTypes = _interopRequireDefault(require("./ActionTypes"));
+exports.ActionTypes = _ActionTypes.default;
+var _createMiddlewares = _interopRequireDefault(require("./createMiddlewares"));
+exports.createMiddlewares = _createMiddlewares.default;
+var _locationReducer = _interopRequireDefault(require("./locationReducer"));
+exports.locationReducer = _locationReducer.default;
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/cjs/redux/internalLocationReducer.js

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = internalLocationReducer;
+var _ActionTypesInternal = _interopRequireDefault(require("./ActionTypesInternal"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function internalLocationReducer(state, action) {
+  // eslint-disable-next-line no-underscore-dangle
+  if (action.type === _ActionTypesInternal.default.INTERNAL_LOCATION_UPDATE) {
+    return action.payload;
+  }
+  return state;
+}
+module.exports = exports.default;

package/lib/cjs/redux/middleware/createAddInputLocationBasePathMiddleware.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = createAddInputLocationBasePathMiddleware;
+var _basePath = require("../../basePath");
+var _ActionTypes = _interopRequireDefault(require("../ActionTypes"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Creates a "middleware" that, when a website is hosted under a certain path (`basePath`),
+// automatically hides that starting segment from the `pathname` of `location`s.
+function createAddInputLocationBasePathMiddleware(basePath) {
+  return function addInputLocationBasePathMiddleware() {
+    return next => action => {
+      const {
+        type,
+        payload
+      } = action;
+      switch (type) {
+        // Transforms `NAVIGATE` action payload (`location`).
+        case _ActionTypes.default.NAVIGATE:
+          return next({
+            type,
+            payload: Object.assign({}, payload, {
+              location: (0, _basePath.addBasePath)(payload.location, basePath)
+            })
+          });
+        default:
+          return next(action);
+      }
+    };
+  };
+}
+module.exports = exports.default;

package/lib/cjs/redux/middleware/createNonProgrammaticNavigationBlockerMiddleware.js

@@ -0,0 +1,113 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = createNonProgrammaticNavigationBlockerMiddleware;
+var _getLocationFromInternalLocation = _interopRequireDefault(require("../../getLocationFromInternalLocation"));
+var _isPromise = _interopRequireDefault(require("../../isPromise"));
+var _navigationBlockers = require("../../navigationBlockers");
+var _operations = _interopRequireDefault(require("../../session/navigation/operation/operations"));
+var _ActionTypesInternal = _interopRequireDefault(require("../ActionTypesInternal"));
+var _createProgrammaticNavigationBlockerMiddleware = require("./createProgrammaticNavigationBlockerMiddleware");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Creates a "middleware" that applies navigation blockers for non-programmatic navigation,
+// i.e. the navigation that wasn't triggered by the application code and was triggered, say, by the user.
+// It also handles programmatic `SHIFT` navigation because it doesn't know the new location until
+// the environment performs the `delta` navigation and then tells the new location to `navigation-stack`.
+function createNonProgrammaticNavigationBlockerMiddleware(session, {
+  ignoreNavigationLocationSubscriptionEvents
+}) {
+  return function nonProgrammaticNavigationBlockerMiddleware() {
+    return next => action => {
+      const {
+        type,
+        payload
+      } = action;
+
+      // Declaring `result` variable here fixes ESLint error:
+      // "Unexpected lexical declaration in case block".
+      let result;
+      switch (type) {
+        // One could ask: Why run navigation blockers on `UPDATE` Redux action?
+        // Why not just run navigation blockers on `NAVIGATE` and `SHIFT` Redux action?
+        // The reason why it handles `UPDATE` Redux actions here is because
+        // `NAVIGATE` Redux actions are only emitted for programmatic "push" or "replace" navigation
+        // initiated by the application code, and there're other cases of navigation such as
+        // programmatic "shift" navigation or when the user manually clicks "Back" or "Forward" button
+        // in a web browser. And even if a "shift" navigation is initiated by the application code,
+        // it still doesn't know yet what the new location is gonna be cause it only knows the `delta`.
+        // Such "other" cases could only be handled by reacting to an `UPDATE` Redux action
+        // which is only emitted after the URL in the browser's address bar has changed.
+        //
+        // There's no real drawback in reacting to an `UPDATE` Redux action "post factum" because
+        // from the application's point of view the address bar doesn't matter and even doesn't exist.
+        // All that exists from the application's point of view is the `location` object in the Redux state.
+        // Until the `location` object in the Redux state is updated, the old page is still rendered.
+        // The appliation is only concerned with the updates of the `location` object in the Redux state
+        // and completely ignores any updates to the URL in the web browser's address bar.
+        //
+        // So here, the "middleware" attempts to prevent or allow navigation that has already happened
+        // in the web browser's address bar but hasn't yet happened in Redux state.
+        // For example, it could be a user clicking a "Back"/"Forward" button in their web browser.
+        // If such navigation should've been blocked, it will simply not update the `locaiton` object in Redux state,
+        // and it will also "rewind" the change of the URL in the web browser's address bar so that it's consistent
+        // with the `location` in Redux state.
+        //
+        // eslint-disable-next-line no-underscore-dangle
+        case _ActionTypesInternal.default.INTERNAL_LOCATION_UPDATE:
+          // Programmatic `PUSH`/`REPLACE` actions are handled in another middleware.
+          if (payload.operation === _operations.default.PUSH || payload.operation === _operations.default.REPLACE) {
+            return next(action);
+          }
+
+          // If no navigation blockers to run, don't do anything.
+          if ((0, _navigationBlockers.getNavigationBlockers)(session).length === 0) {
+            return next(action);
+          }
+
+          // If it was the initial page load or a redirect,
+          // it's not really a navigation that could be rolled back.
+          if (payload.delta === 0) {
+            return next(action);
+          }
+          result = (0, _navigationBlockers.runNavigationBlockers)((0, _navigationBlockers.getNavigationBlockers)(session),
+          // Here `getLocationFromInternalLocation(payload)` is `Location`.
+          (0, _getLocationFromInternalLocation.default)(payload));
+          if ((0, _isPromise.default)(result)) {
+            const status = (0, _createProgrammaticNavigationBlockerMiddleware.createNavigationBlockersEvaluationStatus)(session);
+
+            // While location blockers are running, rewind to the previous location.
+            ignoreNavigationLocationSubscriptionEvents(() => {
+              session.shift(-payload.delta);
+            });
+            result.then(promiseResult => {
+              if (promiseResult) {
+                // Navigation blocked.
+                // Already rewound to a previous location.
+              } else if (!status.cancelled) {
+                // Navigation not blocked.
+                // Rewind back to the new location.
+                ignoreNavigationLocationSubscriptionEvents(() => {
+                  session.shift(payload.delta);
+                });
+                // Update the location.
+                next(action);
+              }
+            });
+          } else if (result) {
+            // Prevent the navigation: rewind to the previous location.
+            ignoreNavigationLocationSubscriptionEvents(() => {
+              session.shift(-payload.delta);
+            });
+          } else {
+            // Update the location.
+            return next(action);
+          }
+          // eslint-disable-next-line consistent-return
+          return;
+        default:
+          return next(action);
+      }
+    };
+  };
+}
+module.exports = exports.default;

package/lib/cjs/redux/middleware/createProgrammaticNavigationBlockerMiddleware.js

@@ -0,0 +1,94 @@
+"use strict";
+
+exports.__esModule = true;
+exports.createNavigationBlockersEvaluationStatus = createNavigationBlockersEvaluationStatus;
+exports.default = createProgrammaticNavigationBlockerMiddleware;
+var _isPromise = _interopRequireDefault(require("../../isPromise"));
+var _navigationBlockers = require("../../navigationBlockers");
+var _ActionTypes = _interopRequireDefault(require("../ActionTypes"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function createNavigationBlockersEvaluationStatus(session) {
+  /* eslint-disable no-underscore-dangle */
+  if (session._navigationBlockersEvaluationStatus) {
+    session._navigationBlockersEvaluationStatus.cancelled = true;
+  }
+  session._navigationBlockersEvaluationStatus = {
+    cancelled: false
+  };
+  return session._navigationBlockersEvaluationStatus;
+}
+
+// Creates a "middleware" that applies navigation blockers for programmatic navigation,
+// i.e. the navigation that was triggered by the application code.
+// This only includes `PUSH` and `REPLACE` navigation, and other programmatic types of navigation
+// such as `SHIFT` aren't able to be handled here due to not yet having `location` info,
+// so they're handled in a different middleware.
+function createProgrammaticNavigationBlockerMiddleware(session) {
+  return function programmaticNavigationBlockerMiddleware() {
+    return next => action => {
+      const {
+        type,
+        payload
+      } = action;
+
+      // Declaring `result` variable here fixes ESLint error:
+      // "Unexpected lexical declaration in case block".
+      let result;
+      switch (type) {
+        // Prevent or allow navigation that was initiated by the application
+        // by dispatching a `.push()` or `.replace()` action.
+        //
+        // It doesn't handle `.shift()` navigation actions because it doesn't yet know
+        // the `location` that it's gonna `shift` to. Instead, it waits for the web browser
+        // to "shift" to that `location` and then reads it and rewinds the "shift"
+        // if it should've been blocked. That is handled by another "navigation blocker" middleware.
+        //
+        // This type of "shifting" and then rewinding the "shift" doesn't really matter to the application at all.
+        // From the application's point of view, all of that doesn't matter and even doesn't exist.
+        // All that exists from the application's point of view is the `location` object in the Redux state.
+        // Until the `location` object in the Redux state is updated, the old page is still rendered.
+        // The appliation is only concerned with the updates of the `location` object in the Redux state
+        // and completely ignores any updates to the URL in the web browser's address bar.
+        //
+        case _ActionTypes.default.NAVIGATE:
+          // `resultValue` variable name works around a stupid javascript error:
+          // "Cannot redeclare block-scoped variable 'result'".
+          result = (0, _navigationBlockers.runNavigationBlockers)((0, _navigationBlockers.getNavigationBlockers)(session),
+          // Here `payload.location` is `LocationBase`.
+          payload.location);
+          if ((0, _isPromise.default)(result)) {
+            const status = createNavigationBlockersEvaluationStatus(session);
+            // eslint-disable-next-line consistent-return
+            result.then(resultValue => {
+              if (!status.cancelled) {
+                if (!resultValue) {
+                  return next(action);
+                }
+              }
+            });
+          } else if (!result) {
+            return next(action);
+          }
+          // eslint-disable-next-line consistent-return
+          return;
+
+        // Programmatic SHIFT actions aren't handled here.
+        // Instead, they're handled in non-programmatic navigation blocker middleware.
+        // The rationale is that there's no `location` argument on "SHIFT" actions,
+        // so the navigation blockers don't know yet what is the new location gonna be.
+        // They have to wait for the environment to restore the new location
+        // and then tell it to `navigation-stack` by calling a listener.
+        case _ActionTypes.default.SHIFT:
+          // New `location` isn't known yet. Proceed without blocking anything.
+          return next(action);
+
+        // Remove any navigation blockers on `STOP` event.
+        case _ActionTypes.default.STOP:
+          (0, _navigationBlockers.removeAllNavigationBlockers)(session);
+          return next(action);
+        default:
+          return next(action);
+      }
+    };
+  };
+}

package/lib/cjs/redux/middleware/createRemoveOutputLocationBasePathMiddleware.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = createRemoveOutputLocationBasePathMiddleware;
+var _basePath = require("../../basePath");
+var _ActionTypesInternal = _interopRequireDefault(require("../ActionTypesInternal"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Creates a "middleware" that, when a website is hosted under a certain path (`basePath`),
+// automatically hides that starting segment from the `pathname` of `location`s.
+function createRemoveOutputLocationBasePathMiddleware(basePath) {
+  return function removeOutputLocationBasePathMiddleware() {
+    return next => action => {
+      const {
+        type,
+        payload
+      } = action;
+      switch (type) {
+        // Transforms `UPDATE` action payload (input `location`).
+        case _ActionTypesInternal.default.INTERNAL_LOCATION_UPDATE:
+          return next({
+            type,
+            payload: (0, _basePath.removeBasePath)(payload, basePath)
+          });
+        default:
+          return next(action);
+      }
+    };
+  };
+}
+module.exports = exports.default;

package/lib/cjs/redux/middleware/createUpdateInternalLocationMiddleware.js

@@ -0,0 +1,73 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = createUpdateInternalLocationMiddleware;
+var _ActionTypes = _interopRequireDefault(require("../ActionTypes"));
+var _ActionTypesInternal = _interopRequireDefault(require("../ActionTypesInternal"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Creates a "middleware" that performs the actual navigation according to the `session` being used.
+// For example, when `WebBrowserSession` is used, it calls methods of the `window.history` object.
+function createUpdateInternalLocationMiddleware(session, {
+  shouldIgnoreNavigationLocationSubscriptionEvents
+}) {
+  return function updateInternalLocationMiddleware() {
+    return next => {
+      // Whenever browser location changes,
+      // perform the same changes with the internal `location` object.
+      const unsubscribe = session.subscribe(location => {
+        if (!shouldIgnoreNavigationLocationSubscriptionEvents()) {
+          next({
+            // eslint-disable-next-line no-underscore-dangle
+            type: _ActionTypesInternal.default.INTERNAL_LOCATION_UPDATE,
+            payload: location
+          });
+        }
+      });
+      return action => {
+        const {
+          type,
+          payload
+        } = action;
+        switch (type) {
+          case _ActionTypes.default.INIT:
+            // `init()` will trigger the `subscribe()` listener,
+            // which will call `updateLocation()`.
+            session.start(payload);
+            // eslint-disable-next-line consistent-return
+            return;
+          case _ActionTypes.default.NAVIGATE:
+            // `navigate()` will trigger the `subscribe()` listener,
+            // which will call `updateLocation()`.
+            session.navigate(payload.operation, payload.location);
+            // eslint-disable-next-line consistent-return
+            return;
+          case _ActionTypes.default.SHIFT:
+            // `shift()` will trigger the `subscribe()` listener,
+            // which will call `updateLocation()`.
+            session.shift(payload);
+            // eslint-disable-next-line consistent-return
+            return;
+          case _ActionTypes.default.STOP:
+            // Remove location change subscription.
+            unsubscribe();
+            // Even if it calls `unsubscribe()` function above, any other subscriptions
+            // would still stay. We're not talking about `navigationStack.subscribe()`
+            // subscriptions because those don't really matter in terms of cleaning them up:
+            // those're just Redux store subscriptions that don't have any side effects.
+            // Subscriptions we're talking here are `Session`'s own subscription
+            // via `session.subscribe()` and any hypothetical manual `session.subscribe()`
+            // calls that could be made by the application code for whatever purpose.
+            // Both of those should be cleared.
+            // To work around that, `.stop()` function removes all subscriptions.
+            session.stop();
+            // eslint-disable-next-line consistent-return
+            return next(action);
+          default:
+            // eslint-disable-next-line consistent-return
+            return next(action);
+        }
+      };
+    };
+  };
+}
+module.exports = exports.default;

package/lib/cjs/{middleware/navigationActionMiddleware.js → redux/middleware/navigationOperationMiddleware.js}

@@ -1,11 +1,12 @@
 "use strict";
 
 exports.__esModule = true;
-exports.default = navigationActionMiddleware;
+exports.default = navigationOperationMiddleware;
+var _operations = _interopRequireDefault(require("../../session/navigation/operation/operations"));
 var _ActionTypes = _interopRequireDefault(require("../ActionTypes"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // This "middleware" transforms a `PUSH` / `REPLACE` action into a `NAVIGATE` action.
-function navigationActionMiddleware() {
+function navigationOperationMiddleware() {
   return next => action => {
     const {
       type,
@@ -16,18 +17,20 @@ function navigationActionMiddleware() {
       case _ActionTypes.default.PUSH:
         return next({
           type: _ActionTypes.default.NAVIGATE,
-          payload: Object.assign({}, payload, {
-            action: 'PUSH'
-          })
+          payload: {
+            operation: _operations.default.PUSH,
+            location: payload
+          }
         });
 
       // Converts a `REPLACE` action into a `NAVIGATE` action.
       case _ActionTypes.default.REPLACE:
         return next({
           type: _ActionTypes.default.NAVIGATE,
-          payload: Object.assign({}, payload, {
-            action: 'REPLACE'
-          })
+          payload: {
+            operation: _operations.default.REPLACE,
+            location: payload
+          }
         });
       default:
         return next(action);

package/lib/cjs/{middleware/normalizeInputLocationMiddleware.js → redux/middleware/parseInputLocationMiddleware.js}

@@ -1,23 +1,25 @@
 "use strict";
 
 exports.__esModule = true;
-exports.default = normalizeInputLocationMiddleware;
+exports.default = parseInputLocationMiddleware;
+var _parseInputLocation = _interopRequireDefault(require("../../parseInputLocation"));
 var _ActionTypes = _interopRequireDefault(require("../ActionTypes"));
-var _normalizeInputLocation = _interopRequireDefault(require("../normalizeInputLocation"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // This "middleware" transforms input location argument into a proper `NormalizedInputLocation`.
-function normalizeInputLocationMiddleware() {
+function parseInputLocationMiddleware() {
   return next => action => {
     const {
       type,
       payload
     } = action;
     switch (type) {
+      case _ActionTypes.default.INIT:
       case _ActionTypes.default.PUSH:
       case _ActionTypes.default.REPLACE:
         return next({
           type,
-          payload: (0, _normalizeInputLocation.default)(payload)
+          // `payload` is optional in `INIT` action.
+          payload: payload && (0, _parseInputLocation.default)(payload)
         });
       default:
         return next(action);

package/lib/cjs/redux/middleware/updateLocationMiddleware.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = updateLocationMiddleware;
+var _getLocationFromInternalLocation = _interopRequireDefault(require("../../getLocationFromInternalLocation"));
+var _ActionTypes = _interopRequireDefault(require("../ActionTypes"));
+var _ActionTypesInternal = _interopRequireDefault(require("../ActionTypesInternal"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function updateLocationMiddleware() {
+  return next => action => {
+    const {
+      type,
+      payload
+    } = action;
+    switch (type) {
+      // Convert `LocationInternal` object to a publicly-visible `Location` object.
+      // It hides non-essential properties of location such as `operation`, `index`, `delta`.
+      // eslint-disable-next-line no-underscore-dangle
+      case _ActionTypesInternal.default.INTERNAL_LOCATION_UPDATE:
+        // Dispatch a "public" `UPDATE` Redux action.
+        // This is what users of this package should use
+        // rather than `INTERNAL_LOCATION_UPDATE` which is for internal purposes.
+        next({
+          type: _ActionTypes.default.UPDATE,
+          payload: (0, _getLocationFromInternalLocation.default)(payload)
+        });
+        return;
+      default:
+        // eslint-disable-next-line consistent-return
+        return next(action);
+    }
+  };
+}
+module.exports = exports.default;