navigation-stack 0.5.2 → 0.6.0

package/lib/cjs/NavigationStack.js

@@ -2,86 +2,175 @@
 
 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 _basePath = require("./basePath");
+var _LocationDataStorage = _interopRequireDefault(require("./data-storage/LocationDataStorage"));
+var _getLocationFromInternalLocation = _interopRequireDefault(require("./getLocationFromInternalLocation"));
+var _isPromise = _interopRequireDefault(require("./isPromise"));
+var _navigationBlockers = require("./navigationBlockers");
+var _navigationBlockersEvaluation = require("./navigationBlockersEvaluation");
+var _parseInputLocation = _interopRequireDefault(require("./parseInputLocation"));
 var _ScrollPositionRestoration = _interopRequireDefault(require("./scroll-position/ScrollPositionRestoration"));
-const _excluded = ["maintainScrollPosition"];
+var _Session = _interopRequireDefault(require("./session/Session"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-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; }
-function getCreateMiddlewaresOptions(navigationStackOptions) {
-  if (!navigationStackOptions) {
-    return undefined;
-  }
-  // eslint-disable-next-line no-unused-vars
-  const restOptions = _objectWithoutPropertiesLoose(navigationStackOptions, _excluded);
-  return restOptions;
-}
 class NavigationStack {
-  constructor(session, options) {
-    this._session = session;
+  constructor(Environment, {
+    basePath,
+    manageScrollPosition,
+    scrollPositionSetter
+  } = {}) {
+    // Allows temporarily ignoring location update events.
+    this._doAndIgnoreLocationUpdates = func => {
+      this._ignoreLocationUpdates = true;
+      func();
+      this._ignoreLocationUpdates = false;
+    };
+    // Create a session.
+    this._session = new _Session.default(Environment);
+
+    // Base path, if used.
+    this._basePath = basePath;
+
+    // Create location data storage.
+    this.dataStorage = new _LocationDataStorage.default(this._session, {
+      namespace: 'navigation-stack'
+    });
+
+    // Allows temporarily ignoring location update events when set to `true`.
+    this._ignoreLocationUpdates = false;
 
-    // Create a Redux store.
-    this._store = (0, _redux.createStore)(_locationReducer.default, (0, _redux.applyMiddleware)(...(0, _createMiddlewares.default)(session, getCreateMiddlewaresOptions(options))));
+    // Subscribe to location updates.
+    // * Ignores location updates if `_ignoreLocationUpdates` flag is temporarily set.
+    // * Runs navigation blockers to see if the location update should be reverted.
+    // * Updates `this._location` if the update wasn't ignored or blocked.
+    this._unsubscribe = this._session.subscribe(location => {
+      // If this location update shouldn't be temporarily ignored.
+      if (!this._ignoreLocationUpdates) {
+        // Remove `basePath` from `location`.
+        location = (0, _basePath.removeBasePath)(location, this._basePath);
+
+        // See if the location update should've been blocked.
+        // If it should've, it will automatically "rewind" it.
+        const result = (0, _navigationBlockersEvaluation.blockNonProgrammaticNavigationIfRequired)(location, this._session, this._doAndIgnoreLocationUpdates);
+        const onResult = blocked => {
+          if (!blocked) {
+            // Update `this._location`.
+            // Since it's gonna be returned from the public `this.current()` method,
+            // convert it from `LocationInternal` to `Location`.
+            this._location = (0, _getLocationFromInternalLocation.default)(location);
+          }
+        };
+        if ((0, _isPromise.default)(result)) {
+          result.then(onResult);
+        } else {
+          onResult(result);
+        }
+      }
+    });
 
     // Create `ScrollPositionRestoration`.
-    if (options && options.maintainScrollPosition) {
-      this._scrollPositionRestoration = new _ScrollPositionRestoration.default(session);
+    if (manageScrollPosition) {
+      this._scrollPositionRestoration = new _ScrollPositionRestoration.default(this._session,
+      // Custom `ScrollPositionSetter`.
+      {
+        scrollPositionSetter
+      });
     }
   }
+
+  // Subscribes to any changes of the current location.
+  // The first subscriber is always the `NavigationStack` itself
+  // because its listener is what drives the actual navigation.
+  // Any additional application-specific listeners could be added, if required.
+  subscribe(listener) {
+    // `NavigationStack.subscribe()` is simply a proxy to `Session.subscribe()`
+    // with the only convenience feature that it "normalizes" the `location` argument.
+    return this._session.subscribe(locationInternal => {
+      listener((0, _getLocationFromInternalLocation.default)(locationInternal));
+    });
+  }
+  addNavigationBlocker(blocker) {
+    return (0, _navigationBlockers.addNavigationBlocker)(this._session, blocker);
+  }
   addScrollableContainer(scrollableContainerKey, scrollableContainer) {
     if (!this._scrollPositionRestoration) {
-      throw new Error('`maintainScrollPosition: true` option not passed');
+      throw new Error('`manageScrollPosition: 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) {
+    if (this._location) {
       throw new Error('Already initialized');
     }
-    this._store.dispatch(_Actions.default.init(initialLocation));
-    this._latestLocation = this.current();
+    this._session.start(initialLocation && this._parseInputLocation(initialLocation));
+    if (this._scrollPositionRestoration) {
+      this._scrollPositionRestoration.start();
+    }
   }
   current() {
-    return this._store.getState();
+    // TypeScript definition of the `.current()` method tells that it always returns
+    // some non-`undefined` location.
+    // But `this._location` is `undefined` until `.init(initialLocation?)` is called.
+    // To work around that limitation, it simply throws if `.current()` is called before `.init()`.
+    if (!this._location) {
+      throw new Error('Not initialized');
+    }
+    return this._location;
   }
   push(location) {
-    this._store.dispatch(_Actions.default.push(location));
+    this._navigate('push', location);
   }
   replace(location) {
-    this._store.dispatch(_Actions.default.replace(location));
+    this._navigate('replace', location);
+  }
+  _navigate(operation, location) {
+    const toLocation = this._parseInputLocation(location);
+    const result = (0, _navigationBlockersEvaluation.blockProgrammaticNavigationIfRequired)(toLocation, this._session);
+    const onResult = blocked => {
+      if (!blocked) {
+        this._session.navigate(operation, toLocation);
+      }
+    };
+    if ((0, _isPromise.default)(result)) {
+      result.then(onResult);
+    } else {
+      onResult(result);
+    }
   }
   shift(delta) {
-    this._store.dispatch(_Actions.default.shift(delta));
+    this._session.shift(delta);
   }
   stop() {
+    if (!this._unsubscribe) {
+      throw new Error('Already stopped');
+    }
+    this._unsubscribe();
+    this._unsubscribe = undefined;
+
+    // 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.
+    this._session.stop();
+    (0, _navigationBlockers.removeAllNavigationBlockers)(this._session);
     if (this._scrollPositionRestoration) {
       this._scrollPositionRestoration.stop();
     }
-    this._store.dispatch(_Actions.default.stop());
   }
-  locationRendered() {
-    if (this._scrollPositionRestoration) {
-      const location = this.current();
-      if (!location) {
-        throw new Error('Not initialized');
-      }
-      return this._scrollPositionRestoration.locationRendered(location);
+  locationRendered(location) {
+    if (!this._scrollPositionRestoration) {
+      throw new Error('`manageScrollPosition: true` option not passed');
     }
-    return Promise.resolve();
+    return this._scrollPositionRestoration.locationRendered(location);
+  }
+  _parseInputLocation(inputLocation) {
+    // Parse input location (string or incomplete object) to a proper `location` object.
+    // Add `basePath` to `location`.
+    return (0, _basePath.addBasePath)((0, _parseInputLocation.default)(inputLocation), this._basePath);
   }
 }
 exports.default = NavigationStack;

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

@@ -10,6 +10,7 @@ class DataStorage {
       throw new Error('`DataStorage` requires a `session.key`');
     }
     this._sessionKey = session.key;
+    this._log = session.environment.log;
     this._dataStorage = session.environment.dataStorage;
     this._namespace = namespace;
   }
@@ -26,8 +27,8 @@ class DataStorage {
       // 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');
+      this._log.error('[navigation-stack] Could not read data from storage');
+      this._log.error(error);
 
       // Pretend that the entry doesn't exist.
       return undefined;
@@ -40,8 +41,8 @@ class DataStorage {
         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');
+        this._log.error('[navigation-stack] Could not delete data from storage');
+        this._log.error(error);
       }
       return;
     }
@@ -54,8 +55,8 @@ class DataStorage {
     } 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');
+      this._log.error('[navigation-stack] Could not save data in storage');
+      this._log.error(error);
     }
   }
 

package/lib/cjs/environment/InMemoryEnvironment.js

@@ -3,11 +3,17 @@
 exports.__esModule = true;
 exports.default = void 0;
 var _InMemoryDataStorage = _interopRequireDefault(require("./data-storage/InMemoryDataStorage"));
+var _InMemorySessionLifecycle = _interopRequireDefault(require("./lifecycle/InMemorySessionLifecycle"));
+var _InMemoryLog = _interopRequireDefault(require("./log/InMemoryLog"));
+var _InMemoryNavigation = _interopRequireDefault(require("./navigation/InMemoryNavigation"));
 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.log = new _InMemoryLog.default();
+    this.lifecycle = new _InMemorySessionLifecycle.default();
+    this.navigation = new _InMemoryNavigation.default();
     this.scrollPosition = new _InMemoryScrollPosition.default();
   }
 }

package/lib/cjs/{session/ServerSideRenderSession.js → environment/ServerSideRenderEnvironment.js}

@@ -2,16 +2,15 @@
 
 exports.__esModule = true;
 exports.default = void 0;
-var _InMemorySession = _interopRequireDefault(require("./InMemorySession"));
+var _InMemoryEnvironment = _interopRequireDefault(require("./InMemoryEnvironment"));
 var _ServerSideNavigation = _interopRequireDefault(require("./navigation/ServerSideNavigation"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // `ServerSideRenderSession` is just a `InMemorySession` that specifically prohibits any navigation.
-class ServerSideRenderSession extends _InMemorySession.default {
+class ServerSideRenderEnvironment extends _InMemoryEnvironment.default {
   constructor() {
-    super({
-      navigation: new _ServerSideNavigation.default()
-    });
+    super();
+    this.navigation = new _ServerSideNavigation.default();
   }
 }
-exports.default = ServerSideRenderSession;
+exports.default = ServerSideRenderEnvironment;
 module.exports = exports.default;

package/lib/cjs/environment/WebBrowserEnvironment.js

@@ -3,12 +3,18 @@
 exports.__esModule = true;
 exports.default = void 0;
 var _WebBrowserDataStorage = _interopRequireDefault(require("./data-storage/WebBrowserDataStorage"));
+var _WebBrowserSessionLifecycle = _interopRequireDefault(require("./lifecycle/WebBrowserSessionLifecycle"));
+var _WebBrowserLog = _interopRequireDefault(require("./log/WebBrowserLog"));
+var _WebBrowserNavigation = _interopRequireDefault(require("./navigation/WebBrowserNavigation"));
 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();
+    this.lifecycle = new _WebBrowserSessionLifecycle.default();
+    this.log = new _WebBrowserLog.default();
+    this.navigation = new _WebBrowserNavigation.default();
   }
 }
 exports.default = WebBrowserEnvironment;

package/lib/cjs/environment/log/InMemoryLog.js

@@ -0,0 +1,23 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+const DEBUG_ENABLED = false;
+class InMemoryLog {
+  debug(...args) {
+    if (DEBUG_ENABLED) {
+      // eslint-disable-next-line no-console
+      console.log(...args);
+    }
+  }
+  warn(...args) {
+    // eslint-disable-next-line no-console
+    console.warn(...args);
+  }
+  error(...args) {
+    // eslint-disable-next-line no-console
+    console.error(...args);
+  }
+}
+exports.default = InMemoryLog;
+module.exports = exports.default;

package/lib/cjs/environment/log/WebBrowserLog.js

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class WebBrowserLog {
+  debug(...args) {
+    if (window.NAVIGATION_STACK_DEBUG_ENABLED) {
+      // eslint-disable-next-line no-console
+      console.log(...args);
+    }
+  }
+  warn(...args) {
+    // eslint-disable-next-line no-console
+    console.warn(...args);
+  }
+  error(...args) {
+    // eslint-disable-next-line no-console
+    console.error(...args);
+  }
+}
+exports.default = WebBrowserLog;
+module.exports = exports.default;

package/lib/cjs/{session → environment}/navigation/InMemoryNavigation.js

@@ -10,12 +10,23 @@ class InMemoryNavigation {
     this._stack = [];
   }
 
+  // Subscribes to any "asynchronous" changes of the current location,
+  // "asynchronous" changes being ones that happen out-of-sync with the code
+  // that might have potentially triggered those changes.
+  //
+  // For example, in a web browser, "Back"/"Forward" navigation happens out-of-sync
+  // with the code that calls `window.pushState()` or `window.replaceState()` function.
+  //
+  // Additionally, in a web browser, "Back"/"Forward" navigation could be triggered
+  // outside of the application code by user clicking those "Back"/"Forward" buttons manually
+  // in their web browser.
+  //
   // eslint-disable-next-line no-unused-vars
-  subscribe(listener) {
-    // `InMemoryNavigation` doesn't have any "asynchronycity" about it
-    // and performs any navigation immediately at the time of the call.
-    // Hence, no asynchronous listener would ever be called
-    // due to no asynchronous events being dispatched.
+  subscribeToAsyncrhonousLocationUpdates(listener) {
+    // `InMemoryNavigation` location changes are always "synchronous"
+    // with the code that initiated such changes, i.e. it always performs
+    // any navigation immediately at the time such navigation is triggered in code.
+    // Hence, this function doesn't have to "subscribe" to anything, so it's a "no op".
     return () => {};
   }
   init(initialLocation, {

package/lib/cjs/{session → environment}/navigation/ServerSideNavigation.js

@@ -2,7 +2,7 @@
 
 exports.__esModule = true;
 exports.default = void 0;
-var _ServerSideNavigationError = _interopRequireDefault(require("./error/ServerSideNavigationError"));
+var _ServerSideRedirectError = _interopRequireDefault(require("./error/ServerSideRedirectError"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable no-underscore-dangle, max-classes-per-file */
 
@@ -21,12 +21,21 @@ class ServerSideNavigation {
     });
   }
 
+  // Subscribes to any "asynchronous" changes of the current location,
+  // "asynchronous" changes being ones that happen out-of-sync with the code
+  // that might have potentially triggered those changes.
+  //
+  // For example, in a web browser, "Back"/"Forward" navigation happens out-of-sync
+  // with the code that calls `window.pushState()` or `window.replaceState()` function.
+  //
+  // Additionally, in a web browser, "Back"/"Forward" navigation could be triggered
+  // outside of the application code by user clicking those "Back"/"Forward" buttons manually
+  // in their web browser.
+  //
   // eslint-disable-next-line no-unused-vars
-  subscribe(listener) {
-    // `ServerSideNavigation` doesn't have any "asynchronycity" about it
-    // and any navigation is prohibited and would result in an error.
-    // So no asynchronous listener would ever be called
-    // due to no asynchronous events being dispatched.
+  subscribeToAsyncrhonousLocationUpdates(listener) {
+    // `ServerSideNavigation` location changes are prohibited, so they couldn't happen.
+    // Hence, this function doesn't have to "subscribe" to anything, so it's a "no op".
     return () => {};
   }
 
@@ -37,7 +46,7 @@ class ServerSideNavigation {
     index,
     delta
   }) {
-    throw new _ServerSideNavigationError.default(location);
+    throw new _ServerSideRedirectError.default(location);
   }
 
   // eslint-disable-next-line no-unused-vars

package/lib/cjs/{session → environment}/navigation/WebBrowserNavigation.js

@@ -53,15 +53,28 @@ class WebBrowserNavigation {
     this._currentLocationIndex = NO_LOCATION_INDEX;
   }
 
-  // Subscribes to changes in the current location.
+  // Subscribes to any "asynchronous" changes of the current location,
+  // "asynchronous" changes being ones that happen out-of-sync with the code
+  // that might have potentially triggered those changes.
+  //
+  // For example, in a web browser, "Back"/"Forward" navigation happens out-of-sync
+  // with the code that calls `window.pushState()` or `window.replaceState()` function.
+  //
+  // Additionally, in a web browser, "Back"/"Forward" navigation could be triggered
+  // outside of the application code by user clicking those "Back"/"Forward" buttons manually
+  // in their web browser.
+  //
   // Returns an `unsubscribe()` function which is "idempotent", i.e. it can be called multiple times.
-  subscribe(listener) {
+  //
+  subscribeToAsyncrhonousLocationUpdates(listener) {
     const onPopState = () => {
       // If "popstate" event is received before navigation is initialized,
-      // ignore such "popstate" event. This behavior is logical from the application code's view.
+      // ignore such "popstate" event. Such "ignore" behavior is logical from
+      // the application code's point of view: it doesn't expect any navigation events
+      // to be recorded before it has initialized the navigation.
       // And besides, `this._currentLocationIndex` is not defined in such conditions.
       if (this._currentLocationIndex === NO_LOCATION_INDEX) {
-        throw new Error('Received a "popstate" event before initialized');
+        throw new Error('Received a "popstate" event before finished initializing navigation');
       }
       const prevIndex = this._currentLocationIndex;
       const {
@@ -92,6 +105,16 @@ class WebBrowserNavigation {
       this._subscribed = false;
     };
   }
+
+  // When run in a web browser, it could not only "start" a new navigation session
+  // but also "resume" a previously-started navigation session. That could happen
+  // when the user refreshes a page in a web browser which still retains
+  // the previous navigation session's data but at the same time restarts
+  // the javascript code from scratch.
+  //
+  // So this `init()` method handles both cases: when there's previous navigation session's data
+  // that should be restored and when there's no previous navigation session's data.
+  //
   init(initialLocation, {
     operation,
     key,
@@ -108,7 +131,8 @@ class WebBrowserNavigation {
     // by calling `window.history.replaceState()` on page load.
     // Otherwise, `window.history.state` would be `null` for the initial location
     // and there'd be no place to store the additional properties of the initial location
-    // such as `location.key`.
+    // such as `location.key`. Without `location.key` always being present the initial location object,
+    // there'd be a bug of incorrect scroll position being set on the initial location URL in some scenarios:
     // https://github.com/taion/scroll-behavior/issues/215
     //
     // If the user opens the initial page for the first time, `window.history.state` will be `null`.
@@ -122,7 +146,7 @@ class WebBrowserNavigation {
         index
       };
       // Call `history.replaceState()`.
-      this._storeAdditionalPropertiesForLocation(initialLocation, additionalProperties, delta);
+      this._navigateToLocationAndKeepItsAdditionalPropertiesInHistory(initialLocation, additionalProperties, delta);
     }
     this._currentLocationIndex = index;
 
@@ -142,7 +166,7 @@ class WebBrowserNavigation {
       key,
       index
     };
-    this._storeAdditionalPropertiesForLocation(location, additionalProperties, delta);
+    this._navigateToLocationAndKeepItsAdditionalPropertiesInHistory(location, additionalProperties, delta);
     this._currentLocationIndex = index;
 
     // Call the listeners.
@@ -204,7 +228,23 @@ class WebBrowserNavigation {
       delta
     };
   }
-  _storeAdditionalPropertiesForLocation(location, additionalProperties, delta) {
+
+  // Stores "additional" properties associated with `location` in web browser's history storage.
+  // Web browser's history storage is not intended for large datasets and should only be used
+  // to store small bits of data.
+  //
+  // "Some browsers save state objects to the user's disk so they can be restored after the user restarts
+  //  the browser, and impose a size limit on the serialized representation of a state object, and will throw
+  //  an exception if you pass a state object whose serialized representation is larger than that size limit.
+  //  So in cases where you want to ensure you have more space than what some browsers might impose,
+  //  you're encouraged to use sessionStorage and/or localStorage."
+  //
+  // Source: https://developer.mozilla.org/en-US/docs/Web/API/History/pushState
+  //
+  // To store large amounts of data, one could use `window.sessionStorage` instead.
+  // It is accessible via `DataStorage(session)` class.
+  //
+  _navigateToLocationAndKeepItsAdditionalPropertiesInHistory(location, additionalProperties, delta) {
     const url = (0, _getLocationUrl.default)(location);
     // `delta` property is not stored in `window.history.state`
     // because it is supposed to be recalculated every time when reading from `window.history.state`.

package/lib/cjs/{session/navigation/error/ServerSideNavigationError.js → environment/navigation/error/ServerSideRedirectError.js}

@@ -6,7 +6,7 @@ var _getLocationUrl = _interopRequireDefault(require("../../../getLocationUrl"))
 const _excluded = ["operation"];
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 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; }
-class ServerSideNavigationError extends Error {
+class ServerSideRedirectError extends Error {
   constructor(location) {
     super(location ? `Navigate to ${(0, _getLocationUrl.default)(location)}` : 'Navigate to previous or next location');
     if (location) {
@@ -17,5 +17,5 @@ class ServerSideNavigationError extends Error {
     }
   }
 }
-exports.default = ServerSideNavigationError;
+exports.default = ServerSideRedirectError;
 module.exports = exports.default;

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

@@ -49,9 +49,24 @@ class WebBrowserScrollPosition {
     };
   }
   enableAutomaticScrollRestoration() {
+    // The default "auto" behavior seems to work in the following way:
+    //
+    // * It doesn't scroll to top on `window.history.pushState()` or `window.history.replaceState()`.
+    //
+    // * It does restore scroll position on "popstate" event
+    //   (they say, in Firefox it happens before the event is dispatched,
+    //    while in Chrome it happens after the event is dispatched)
+    //
+    // https://v5.reactrouter.com/web/guides/scroll-restoration
+    //
     window.history.scrollRestoration = 'auto';
   }
   disableAutomaticScrollRestoration() {
+    // Setting `window.history.scrollRestoration` value updates it in the current history entry
+    // and any subsequent history entries.
+    // This means that it should be set at application initialization stage,
+    // that is before any navigation.
+    // https://majido.github.io/scroll-restoration-proposal/history-based-api.html
     window.history.scrollRestoration = 'manual';
   }
   init() {}

package/lib/cjs/getLocationBaseFromLocation.js

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = getLocationBaseFromLocation;
+const _excluded = ["key", "index"];
+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 `Location` object to a `LocationBase` object.
+// It hides properties of location such as `key` or `index`.
+function getLocationBaseFromLocation(location) {
+  // eslint-disable-next-line no-unused-vars
+  const locationBase = _objectWithoutPropertiesLoose(location, _excluded);
+  return locationBase;
+}
+module.exports = exports.default;

package/lib/cjs/getLocationUrl.js

@@ -2,7 +2,8 @@
 
 exports.__esModule = true;
 exports.default = getLocationUrl;
-var _queryString = require("query-string");
+var _stringifyQueryAsSearch = _interopRequireDefault(require("./stringifyQueryAsSearch"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function getLocationUrl({
   pathname,
   search,
@@ -10,10 +11,7 @@ function getLocationUrl({
   hash
 }) {
   if (!search && query) {
-    const queryString = (0, _queryString.stringify)(query);
-    if (queryString) {
-      search = `?${queryString}`;
-    }
+    search = (0, _stringifyQueryAsSearch.default)(query);
   }
   return `${pathname}${search || ''}${hash || ''}`;
 }