navigation-stack 0.3.1 → 0.4.0

package/data-storage/package.json

@@ -0,0 +1,6 @@
+{
+  "private": true,
+  "name": "navigation-stack/data-storage",
+  "main": "./../lib/cjs/data-storage/index.js",
+  "module": "./../lib/esm/data-storage/index.js"
+}

package/karma.conf.cjs

@@ -14,7 +14,7 @@ module.exports = (config) => {
   const { env } = process;
 
   config.set({
-    frameworks: ['mocha', 'webpack', 'sinon-chai'],
+    frameworks: ['webpack', 'mocha', 'sinon-chai'],
 
     files: ['test/index.js', { pattern: 'test/**/*.test.js', watched: false }],
 
@@ -26,16 +26,32 @@ module.exports = (config) => {
       mode: 'development',
       module: {
         rules: [
-          { test: /\.js$/, exclude: /node_modules/, use: 'babel-loader' },
+          {
+            test: /\.js$/,
+            exclude: /node_modules/,
+            use: {
+              loader: 'babel-loader',
+            },
+          },
         ],
       },
       plugins: [
         new webpack.DefinePlugin({
           __DEV__: true,
         }),
+        new webpack.ProvidePlugin({
+          process: 'process/browser',
+        }),
       ],
     },
 
+    resolve: {
+      fallback: {
+        process: require.resolve('process/browser'),
+        util: require.resolve('util/'),
+      },
+    },
+
     webpackMiddleware: {
       noInfo: true,
     },
@@ -53,11 +69,12 @@ module.exports = (config) => {
 
     customLaunchers: {
       ChromeCi: {
-        base: 'ChromeHeadless',
+        // base: 'ChromeHeadless',
+        base: 'Chrome',
         flags: ['--no-sandbox'],
       },
     },
 
-    browsers: env.BROWSER ? env.BROWSER.split(',') : ['Chrome'],
+    browsers: env.BROWSER ? env.BROWSER.split(',') : ['Chrome', 'Firefox'],
   });
 };

package/lib/cjs/NavigationStack.js

@@ -0,0 +1,73 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _redux = require("redux");
+var _Actions = _interopRequireDefault(require("./redux/Actions"));
+var _createMiddlewares = _interopRequireDefault(require("./redux/createMiddlewares"));
+var _locationReducer = _interopRequireDefault(require("./redux/locationReducer"));
+var _ScrollPositionRestoration = _interopRequireDefault(require("./scroll-position/ScrollPositionRestoration"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class NavigationStack {
+  constructor(session, options) {
+    this._session = session;
+
+    // Create a Redux store.
+    this._store = (0, _redux.createStore)(_locationReducer.default, (0, _redux.applyMiddleware)(...(0, _createMiddlewares.default)(session, options)));
+
+    // Create `ScrollPositionRestoration`.
+    if (options && options.maintainScrollPosition) {
+      this._scrollPositionRestoration = new _ScrollPositionRestoration.default(session);
+    }
+  }
+  addScrollableContainer(scrollableContainerKey, scrollableContainer) {
+    if (!this._scrollPositionRestoration) {
+      throw new Error('`maintainScrollPosition: true` option not passed');
+    }
+    return this._scrollPositionRestoration.addScrollableContainer(scrollableContainerKey, scrollableContainer);
+  }
+  subscribe(listener) {
+    // Subscribe to any potential Redux state changes.
+    return this._store.subscribe(() => {
+      // Initially, calls the listener when setting the initial location.
+      // After that, calls it on any location change.
+      const location = this.current();
+      if (!this._latestLocation || location !== this._latestLocation) {
+        this._latestLocation = location;
+        listener(location);
+      }
+    });
+  }
+  init(initialLocation) {
+    if (this._latestLocation) {
+      throw new Error('Already initialized');
+    }
+    this._store.dispatch(_Actions.default.init(initialLocation));
+    this._latestLocation = this.current();
+  }
+  current() {
+    return this._store.getState();
+  }
+  push(location) {
+    this._store.dispatch(_Actions.default.push(location));
+  }
+  replace(location) {
+    this._store.dispatch(_Actions.default.replace(location));
+  }
+  shift(delta) {
+    this._store.dispatch(_Actions.default.shift(delta));
+  }
+  stop() {
+    if (this._scrollPositionRestoration) {
+      this._scrollPositionRestoration.stop();
+    }
+    this._store.dispatch(_Actions.default.stop());
+  }
+  locationRendered() {
+    if (this._scrollPositionRestoration) {
+      this._scrollPositionRestoration.locationRendered(this.current());
+    }
+  }
+}
+exports.default = NavigationStack;
+module.exports = exports.default;

package/lib/cjs/data-storage/DataStorage.js

@@ -0,0 +1,71 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class DataStorage {
+  constructor(session, {
+    namespace
+  }) {
+    if (!session.key) {
+      throw new Error('`DataStorage` requires a `session.key`');
+    }
+    this._sessionKey = session.key;
+    this._dataStorage = session.environment.dataStorage;
+    this._namespace = namespace;
+  }
+  get(key) {
+    const storageKey = this._getStorageKey(key);
+    try {
+      const value = this._dataStorage.get(storageKey);
+      // === null is probably sufficient.
+      if (value === null) {
+        return undefined;
+      }
+
+      // We want to catch JSON parse errors in case someone separately threw
+      // junk into sessionStorage under our namespace.
+      return JSON.parse(value);
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('[navigation-stack] Could not read data from storage');
+
+      // Pretend that the entry doesn't exist.
+      return undefined;
+    }
+  }
+  set(key, value) {
+    const storageKey = this._getStorageKey(key);
+    if (value === undefined) {
+      try {
+        this._dataStorage.remove(storageKey);
+      } catch (error) {
+        // No need to handle errors here.
+        // eslint-disable-next-line no-console
+        console.error('[navigation-stack] Could not delete data from storage');
+      }
+      return;
+    }
+
+    // Unlike with read, we want to fail on invalid values here, since the
+    // value here is provided by the caller of this method.
+    const valueString = JSON.stringify(value);
+    try {
+      this._dataStorage.set(storageKey, valueString);
+    } catch (error) {
+      // No need to handle errors here either. If it didn't work, it didn't
+      // work. We make no guarantees about actually saving the value.
+      // eslint-disable-next-line no-console
+      console.error('[navigation-stack] Could not save data in storage');
+    }
+  }
+
+  // It could also implement a method that would clean up any data written so far,
+  // but so far it doesn't seem to be required by any real-world use case.
+  // cleanUp() {}
+
+  _getStorageKey(key) {
+    return `${this._sessionKey}|${this.namespace}|${key}`;
+  }
+}
+exports.default = DataStorage;
+module.exports = exports.default;

package/lib/cjs/data-storage/LocationDataStorage.js

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _DataStorage = _interopRequireDefault(require("./DataStorage"));
+var _getLocationUrl = _interopRequireDefault(require("../getLocationUrl"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class LocationDataStorage {
+  constructor(session, {
+    namespace
+  }) {
+    this._storage = new _DataStorage.default(session, {
+      namespace
+    });
+    this._getFallbackLocationKey = _getLocationUrl.default;
+  }
+  get(location, key) {
+    return this._storage.get(this._getKey(location, key));
+  }
+  set(location, key, value) {
+    this._storage.set(this._getKey(location, key), value);
+  }
+  _getKey(location, key) {
+    const locationKey = location.key || this._getFallbackLocationKey(location);
+    return `${locationKey}|${key}`;
+  }
+}
+exports.default = LocationDataStorage;
+module.exports = exports.default;

package/lib/cjs/data-storage/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+exports.__esModule = true;
+exports.LocationDataStorage = exports.DataStorage = void 0;
+var _DataStorage = _interopRequireDefault(require("./DataStorage"));
+exports.DataStorage = _DataStorage.default;
+var _LocationDataStorage = _interopRequireDefault(require("./LocationDataStorage"));
+exports.LocationDataStorage = _LocationDataStorage.default;
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/cjs/environment/InMemoryEnvironment.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _InMemoryDataStorage = _interopRequireDefault(require("./data-storage/InMemoryDataStorage"));
+var _InMemoryScrollPosition = _interopRequireDefault(require("./scroll-position/InMemoryScrollPosition"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class InMemoryEnvironment {
+  constructor() {
+    this.dataStorage = new _InMemoryDataStorage.default();
+    this.scrollPosition = new _InMemoryScrollPosition.default();
+  }
+}
+exports.default = InMemoryEnvironment;
+module.exports = exports.default;

package/lib/cjs/environment/WebBrowserEnvironment.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _WebBrowserDataStorage = _interopRequireDefault(require("./data-storage/WebBrowserDataStorage"));
+var _WebBrowserScrollPosition = _interopRequireDefault(require("./scroll-position/WebBrowserScrollPosition"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class WebBrowserEnvironment {
+  constructor() {
+    this.dataStorage = new _WebBrowserDataStorage.default();
+    this.scrollPosition = new _WebBrowserScrollPosition.default();
+  }
+}
+exports.default = WebBrowserEnvironment;
+module.exports = exports.default;

package/lib/cjs/environment/data-storage/InMemoryDataStorage.js

@@ -0,0 +1,27 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class InMemoryDataStorage {
+  constructor() {
+    this._state = {};
+  }
+
+  // Returns either a `string` value or `null` if the key doesn't exist.
+  get(key) {
+    if (key in this._state) {
+      return this._state[key];
+    }
+    return null;
+  }
+  remove(key) {
+    if (key in this._state) {
+      delete this._state[key];
+    }
+  }
+  set(key, value) {
+    this._state[key] = value;
+  }
+}
+exports.default = InMemoryDataStorage;
+module.exports = exports.default;

package/lib/cjs/environment/data-storage/WebBrowserDataStorage.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class WebBrowserDataStorage {
+  // Returns either a `string` value or `null` if the key doesn't exist.
+  get(key) {
+    // `sessionStorage` persists across page reloads, and so does web browser navigation history.
+    return window.sessionStorage.getItem(key);
+  }
+  remove(key) {
+    // `sessionStorage` persists across page reloads, and so does web browser navigation history.
+    window.sessionStorage.removeItem(key);
+  }
+  set(key, value) {
+    // `sessionStorage` persists across page reloads, and so does web browser navigation history.
+    window.sessionStorage.setItem(key, value);
+  }
+}
+exports.default = WebBrowserDataStorage;
+module.exports = exports.default;

package/lib/cjs/environment/scroll-position/InMemoryScrollPosition.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class InMemoryScrollPosition {
+  constructor() {
+    this.init();
+  }
+  getPageScrollPosition() {
+    return this._pageScrollPosition || [0, 0];
+  }
+  setPageScrollPosition(scrollPosition) {
+    this._pageScrollPosition = scrollPosition;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  setPageScrollPositionAtAnchor(anchor) {
+    this.setPageScrollPosition([0, 0]);
+  }
+  getScrollableContainerScrollPosition(key) {
+    return this._scrollableContainerScrollPositions[key] || [0, 0];
+  }
+  setScrollableContainerScrollPosition(key, scrollPosition) {
+    this._scrollableContainerScrollPositions[key] = scrollPosition;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addPageScrollListener(listener) {
+    return () => {};
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addScrollableContainerScrollListener(scrollableContainerElement, listener) {
+    return () => {};
+  }
+  enableAutomaticScrollRestoration() {}
+  disableAutomaticScrollRestoration() {}
+  init() {
+    this._pageScrollPosition = undefined;
+    this._scrollableContainerScrollPositions = {};
+  }
+}
+exports.default = InMemoryScrollPosition;
+module.exports = exports.default;

package/lib/cjs/environment/scroll-position/WebBrowserScrollPosition.js

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class WebBrowserScrollPosition {
+  getPageScrollPosition() {
+    return [window.pageXOffset, window.pageYOffset];
+  }
+  setPageScrollPosition(scrollPosition) {
+    const [scrollX, scrollY] = scrollPosition;
+    window.scrollTo(scrollX, scrollY);
+  }
+  setPageScrollPositionAtAnchor(anchor) {
+    const anchorElement = document.getElementById(anchor) || document.getElementsByName(anchor)[0];
+    if (anchorElement) {
+      // By default it scrolls the element into view
+      // so that it's visible at the top of the window.
+      anchorElement.scrollIntoView();
+    } else {
+      this.setPageScrollPosition([0, 0]);
+    }
+  }
+  getScrollableContainerScrollPosition(scrollableContainerElement) {
+    return [scrollableContainerElement.scrollLeft, scrollableContainerElement.scrollTop];
+  }
+  setScrollableContainerScrollPosition(scrollableContainerElement, scrollPosition) {
+    const [scrollX, scrollY] = scrollPosition;
+    scrollableContainerElement.scrollLeft = scrollX;
+    scrollableContainerElement.scrollTop = scrollY;
+  }
+  addPageScrollListener(listener) {
+    // eslint-disable-next-line no-unused-vars
+    const scrollListener = event => {
+      listener();
+    };
+    window.addEventListener('scroll', scrollListener);
+    return () => {
+      window.removeEventListener('scroll', scrollListener);
+    };
+  }
+  addScrollableContainerScrollListener(scrollableContainerElement, listener) {
+    // eslint-disable-next-line no-unused-vars
+    const scrollListener = event => {
+      listener();
+    };
+    scrollableContainerElement.addEventListener('scroll', scrollListener);
+    return () => {
+      scrollableContainerElement.removeEventListener('scroll', scrollListener);
+    };
+  }
+  enableAutomaticScrollRestoration() {
+    window.history.scrollRestoration = 'auto';
+  }
+  disableAutomaticScrollRestoration() {
+    window.history.scrollRestoration = 'manual';
+  }
+  init() {}
+}
+exports.default = WebBrowserScrollPosition;
+module.exports = exports.default;

package/lib/cjs/getLocationFromInternalLocation.js

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = getLocationFromInternalLocation;
+const _excluded = ["operation", "index", "delta"];
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+// Converts `LocationInternal` object to a publicly-visible `Location` object.
+// It hides non-essential properties of location such as `operation`, `index`, `delta`.
+function getLocationFromInternalLocation(internalLocation) {
+  // eslint-disable-next-line no-unused-vars
+  const location = _objectWithoutPropertiesLoose(internalLocation, _excluded);
+  return location;
+}
+module.exports = exports.default;

package/lib/cjs/index.js

@@ -1,11 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.removeBasePath = exports.parseLocationUrl = exports.locationReducer = exports.getLocationUrl = exports.createMiddlewares = exports.addNavigationBlocker = exports.addBasePath = exports.ServerSession = exports.MemorySession = exports.LocationDataStorage = exports.BrowserSession = exports.Actions = exports.ActionTypes = void 0;
-var _Actions = _interopRequireDefault(require("./Actions"));
-exports.Actions = _Actions.default;
-var _ActionTypes = _interopRequireDefault(require("./ActionTypes"));
-exports.ActionTypes = _ActionTypes.default;
+exports.removeBasePath = exports.parseLocationUrl = exports.parseInputLocation = exports.getLocationUrl = exports.addNavigationBlocker = exports.addBasePath = exports.WebBrowserSession = exports.Session = exports.ServerSideRenderSession = exports.ServerSideNavigationError = exports.NavigationStack = exports.NavigationOutOfBoundsError = exports.LocationDataStorage = exports.InMemorySession = exports.DataStorage = void 0;
 var _basePath = require("./basePath");
 exports.addBasePath = _basePath.addBasePath;
 exports.removeBasePath = _basePath.removeBasePath;
@@ -15,16 +11,24 @@ var _getLocationUrl = _interopRequireDefault(require("./getLocationUrl"));
 exports.getLocationUrl = _getLocationUrl.default;
 var _parseLocationUrl = _interopRequireDefault(require("./parseLocationUrl"));
 exports.parseLocationUrl = _parseLocationUrl.default;
-var _createMiddlewares = _interopRequireDefault(require("./createMiddlewares"));
-exports.createMiddlewares = _createMiddlewares.default;
-var _locationReducer = _interopRequireDefault(require("./locationReducer"));
-exports.locationReducer = _locationReducer.default;
-var _LocationDataStorage = _interopRequireDefault(require("./LocationDataStorage"));
+var _parseInputLocation = _interopRequireDefault(require("./parseInputLocation"));
+exports.parseInputLocation = _parseInputLocation.default;
+var _NavigationStack = _interopRequireDefault(require("./NavigationStack"));
+exports.NavigationStack = _NavigationStack.default;
+var _DataStorage = _interopRequireDefault(require("./data-storage/DataStorage"));
+exports.DataStorage = _DataStorage.default;
+var _LocationDataStorage = _interopRequireDefault(require("./data-storage/LocationDataStorage"));
 exports.LocationDataStorage = _LocationDataStorage.default;
-var _BrowserSession = _interopRequireDefault(require("./session/BrowserSession"));
-exports.BrowserSession = _BrowserSession.default;
-var _MemorySession = _interopRequireDefault(require("./session/MemorySession"));
-exports.MemorySession = _MemorySession.default;
-var _ServerSession = _interopRequireDefault(require("./session/ServerSession"));
-exports.ServerSession = _ServerSession.default;
+var _Session = _interopRequireDefault(require("./session/Session"));
+exports.Session = _Session.default;
+var _InMemorySession = _interopRequireDefault(require("./session/InMemorySession"));
+exports.InMemorySession = _InMemorySession.default;
+var _WebBrowserSession = _interopRequireDefault(require("./session/WebBrowserSession"));
+exports.WebBrowserSession = _WebBrowserSession.default;
+var _ServerSideRenderSession = _interopRequireDefault(require("./session/ServerSideRenderSession"));
+exports.ServerSideRenderSession = _ServerSideRenderSession.default;
+var _ServerSideNavigationError = _interopRequireDefault(require("./session/navigation/error/ServerSideNavigationError"));
+exports.ServerSideNavigationError = _ServerSideNavigationError.default;
+var _NavigationOutOfBoundsError = _interopRequireDefault(require("./session/navigation/error/NavigationOutOfBoundsError"));
+exports.NavigationOutOfBoundsError = _NavigationOutOfBoundsError.default;
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/cjs/navigationBlockers.js

@@ -24,12 +24,12 @@ function removeNavigationBlockerFromTheList(blocker, session) {
   }
 }
 function removeAllNavigationBlockers(session) {
-  if (getNavigationBlockers(session).some(blocker => blocker.beforeDestroy)) {
-    if (!session._removeBeforeDestroyListener) {
-      throw new Error('`_removeBeforeDestroyListener` property not found in the `session`');
+  if (getNavigationBlockers(session).some(blocker => blocker.beforeTermination)) {
+    if (!session._removeTerminationBlocker) {
+      throw new Error('`_removeTerminationBlocker` property not found in the `session`');
     }
-    session._removeBeforeDestroyListener();
-    session._removeBeforeDestroyListener = undefined;
+    session._removeTerminationBlocker();
+    session._removeTerminationBlocker = undefined;
   }
   session._navigationBlockersList = [];
 }
@@ -92,33 +92,33 @@ function runNavigationBlockers(navigationBlockers, toLocation) {
 }
 
 /* istanbul ignore next: not testable with Karma */
-function onBeforeDestroy(session) {
+function terminationBlocker(session) {
   const result = runNavigationBlockers(getNavigationBlockers(session), null);
 
-  // If no blocker returned anything, don't prevent the "unload" event.
+  // If no blocker returned anything, so don't prevent the navigation.
   if (!result) {
     return undefined;
   }
 
   // Web browsers don't allow displaying a custom modal in "beforeunload" phase.
   // They only allow displaying a standard one, with the default text.
-  // Hence, "asynchronous" blockers should be ignored.
+  // Hence, "asynchronous" blockers should be ignored because web browsers won't wait for those to finish anyway.
   // https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
   if ((0, _isPromise.default)(result)) {
     return undefined;
   }
 
-  // Prevent the "unload" event.
+  // Block the navigation.
   return true;
 }
 function addNavigationBlocker(session, blocker) {
-  // All navigation blockers also run on `beforeDestroy` event.
+  // All navigation blockers also run on `beforeTermination` event.
   // If required, this could be a parameter of this function.
   // The rationale could be that adding a `beforeunload` listener
   // disables web page caching in some browsers like Firefox.
-  const beforeDestroy = true;
+  const beforeTermination = true;
 
-  // If it's the first "beforeDestroy" blocker, add the global `onBeforeDestroy` listener.
+  // If it's the first "beforeTermination" blocker, add a `terminationBlocker`.
   //
   // Sidenote: Add the "beforeunload" event listener only as needed, as its presence
   // prevents the page from being added to the page navigation cache:
@@ -128,27 +128,29 @@ function addNavigationBlocker(session, blocker) {
   //  and this is bad for performance."
   //
   // https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
-  if (beforeDestroy && !getNavigationBlockers(session).some(navigationBlocker => navigationBlocker.beforeDestroy)) {
-    if (session._removeBeforeDestroyListener) {
-      throw new Error('Unexpected `_removeBeforeDestroyListener` property found in the `session`');
+  if (beforeTermination && !getNavigationBlockers(session).some(navigationBlocker => navigationBlocker.beforeTermination)) {
+    if (session._removeTerminationBlocker) {
+      throw new Error('Unexpected `_removeTerminationBlocker` property found in the `session`');
     }
-    session._removeBeforeDestroyListener = session.addBeforeDestroyListener(() => onBeforeDestroy(session));
+    session._removeTerminationBlocker = session.lifecycle.addTerminationBlocker(() => {
+      return terminationBlocker(session);
+    });
   }
   const newNavigationBlocker = {
     blocker,
-    beforeDestroy
+    beforeTermination
   };
   addNavigationBlockerToTheList(newNavigationBlocker, session);
   return () => {
     removeNavigationBlockerFromTheList(newNavigationBlocker, session);
 
-    // If it was the last "beforeDestroy" blocker, remove the global `onBeforeDestroy` listener.
-    if (beforeDestroy && !getNavigationBlockers(session).some(navigationBlocker => navigationBlocker.beforeDestroy)) {
-      if (!session._removeBeforeDestroyListener) {
-        throw new Error('`_removeBeforeDestroyListener` property not found in the `session`');
+    // If it was the last "beforeTermination" blocker, remove navigation blocker.
+    if (beforeTermination && !getNavigationBlockers(session).some(navigationBlocker => navigationBlocker.beforeTermination)) {
+      if (!session._removeTerminationBlocker) {
+        throw new Error('`_removeTerminationBlocker` property not found in the `session`');
       }
-      session._removeBeforeDestroyListener();
-      session._removeBeforeDestroyListener = undefined;
+      session._removeTerminationBlocker();
+      session._removeTerminationBlocker = undefined;
     }
   };
 }

package/lib/cjs/{normalizeInputLocation.js → parseInputLocation.js}

@@ -1,15 +1,15 @@
 "use strict";
 
 exports.__esModule = true;
-exports.default = normalizeInputLocation;
+exports.default = parseInputLocation;
 var _createSearchFromQuery = _interopRequireDefault(require("./createSearchFromQuery"));
 var _parseLocationUrl = _interopRequireDefault(require("./parseLocationUrl"));
 var _parseQueryFromSearch = _interopRequireDefault(require("./parseQueryFromSearch"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// * If `location` is a string, it parses it into a `NormalizedInputLocation`.
+// * If `location` is a string, it parses it into a `LocationBase`.
 // * If `location` is an object, it ensures that `search` and `hash` properties aren't `undefined`,
-//   i.e. it "ensures" that the `location` object can be used as a `NormalizedInputLocation`.
-function normalizeInputLocation(location) {
+//   i.e. it "ensures" that the `location` object can be used as a `LocationBase`.
+function parseInputLocation(location) {
   if (typeof location === 'string') {
     return (0, _parseLocationUrl.default)(location);
   }
@@ -17,7 +17,13 @@ function normalizeInputLocation(location) {
   // Convert `query` property values to strings.
   if (location.query) {
     for (const key of Object.keys(location.query)) {
-      location.query[key] = String(location.query[key]);
+      if (typeof location.query[key] !== 'string') {
+        location = Object.assign({}, location, {
+          query: Object.assign({}, location.query, {
+            [key]: String(location.query[key])
+          })
+        });
+      }
     }
   }
 
@@ -36,12 +42,22 @@ function normalizeInputLocation(location) {
     });
   }
 
-  // Set default values on `search` and `hash`
-  // if those properties are not present.
-  return Object.assign({}, location, {
+  // Set default values for properties that're not present.
+  // Ignore unknown properties.
+  const {
+    state
+  } = location;
+  location = {
+    pathname: location.pathname,
     query: location.query || {},
     search: location.search || '',
     hash: location.hash || ''
-  });
+  };
+  if (state) {
+    location.state = state;
+  }
+
+  // Return `location`.
+  return location;
 }
 module.exports = exports.default;