navigation-stack 0.5.2 → 0.6.0

package/lib/esm/NavigationStack.js

@@ -1,81 +1,170 @@
-const _excluded = ["maintainScrollPosition"];
-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; }
-import { applyMiddleware, createStore } from 'redux';
-import Actions from './redux/Actions';
-import createMiddlewares from './redux/createMiddlewares';
-import locationReducer from './redux/locationReducer';
+import { addBasePath, removeBasePath } from './basePath';
+import LocationDataStorage from './data-storage/LocationDataStorage';
+import getLocationFromInternalLocation from './getLocationFromInternalLocation';
+import isPromise from './isPromise';
+import { addNavigationBlocker, removeAllNavigationBlockers } from './navigationBlockers';
+import { blockNonProgrammaticNavigationIfRequired, blockProgrammaticNavigationIfRequired } from './navigationBlockersEvaluation';
+import parseInputLocation from './parseInputLocation';
 import ScrollPositionRestoration from './scroll-position/ScrollPositionRestoration';
-function getCreateMiddlewaresOptions(navigationStackOptions) {
-  if (!navigationStackOptions) {
-    return undefined;
-  }
-  // eslint-disable-next-line no-unused-vars
-  const restOptions = _objectWithoutPropertiesLoose(navigationStackOptions, _excluded);
-  return restOptions;
-}
+import Session from './session/Session';
 export default 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(Environment);
+
+    // Base path, if used.
+    this._basePath = basePath;
+
+    // Create location data storage.
+    this.dataStorage = new LocationDataStorage(this._session, {
+      namespace: 'navigation-stack'
+    });
 
-    // Create a Redux store.
-    this._store = createStore(locationReducer, applyMiddleware(...createMiddlewares(session, getCreateMiddlewaresOptions(options))));
+    // Allows temporarily ignoring location update events when set to `true`.
+    this._ignoreLocationUpdates = false;
+
+    // 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 = removeBasePath(location, this._basePath);
+
+        // See if the location update should've been blocked.
+        // If it should've, it will automatically "rewind" it.
+        const result = 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 = getLocationFromInternalLocation(location);
+          }
+        };
+        if (isPromise(result)) {
+          result.then(onResult);
+        } else {
+          onResult(result);
+        }
+      }
+    });
 
     // Create `ScrollPositionRestoration`.
-    if (options && options.maintainScrollPosition) {
-      this._scrollPositionRestoration = new ScrollPositionRestoration(session);
+    if (manageScrollPosition) {
+      this._scrollPositionRestoration = new ScrollPositionRestoration(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(getLocationFromInternalLocation(locationInternal));
+    });
+  }
+  addNavigationBlocker(blocker) {
+    return 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.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.push(location));
+    this._navigate('push', location);
   }
   replace(location) {
-    this._store.dispatch(Actions.replace(location));
+    this._navigate('replace', location);
+  }
+  _navigate(operation, location) {
+    const toLocation = this._parseInputLocation(location);
+    const result = blockProgrammaticNavigationIfRequired(toLocation, this._session);
+    const onResult = blocked => {
+      if (!blocked) {
+        this._session.navigate(operation, toLocation);
+      }
+    };
+    if (isPromise(result)) {
+      result.then(onResult);
+    } else {
+      onResult(result);
+    }
   }
   shift(delta) {
-    this._store.dispatch(Actions.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();
+    removeAllNavigationBlockers(this._session);
     if (this._scrollPositionRestoration) {
       this._scrollPositionRestoration.stop();
     }
-    this._store.dispatch(Actions.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 addBasePath(parseInputLocation(inputLocation), this._basePath);
   }
 }

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

@@ -6,6 +6,7 @@ export default 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;
   }
@@ -22,8 +23,8 @@ export default 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;
@@ -36,8 +37,8 @@ export default 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;
     }
@@ -50,8 +51,8 @@ export default 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/esm/environment/InMemoryEnvironment.js

@@ -1,8 +1,14 @@
 import InMemoryDataStorage from './data-storage/InMemoryDataStorage';
+import InMemorySessionLifecycle from './lifecycle/InMemorySessionLifecycle';
+import InMemoryLog from './log/InMemoryLog';
+import InMemoryNavigation from './navigation/InMemoryNavigation';
 import InMemoryScrollPosition from './scroll-position/InMemoryScrollPosition';
 export default class InMemoryEnvironment {
   constructor() {
     this.dataStorage = new InMemoryDataStorage();
+    this.log = new InMemoryLog();
+    this.lifecycle = new InMemorySessionLifecycle();
+    this.navigation = new InMemoryNavigation();
     this.scrollPosition = new InMemoryScrollPosition();
   }
 }

package/lib/esm/environment/ServerSideRenderEnvironment.js

@@ -0,0 +1,10 @@
+import InMemoryEnvironment from './InMemoryEnvironment';
+import ServerSideNavigation from './navigation/ServerSideNavigation';
+
+// `ServerSideRenderSession` is just a `InMemorySession` that specifically prohibits any navigation.
+export default class ServerSideRenderEnvironment extends InMemoryEnvironment {
+  constructor() {
+    super();
+    this.navigation = new ServerSideNavigation();
+  }
+}

package/lib/esm/environment/WebBrowserEnvironment.js

@@ -1,8 +1,14 @@
 import WebBrowserDataStorage from './data-storage/WebBrowserDataStorage';
+import WebBrowserSessionLifecycle from './lifecycle/WebBrowserSessionLifecycle';
+import WebBrowserLog from './log/WebBrowserLog';
+import WebBrowserNavigation from './navigation/WebBrowserNavigation';
 import WebBrowserScrollPosition from './scroll-position/WebBrowserScrollPosition';
 export default class WebBrowserEnvironment {
   constructor() {
     this.dataStorage = new WebBrowserDataStorage();
     this.scrollPosition = new WebBrowserScrollPosition();
+    this.lifecycle = new WebBrowserSessionLifecycle();
+    this.log = new WebBrowserLog();
+    this.navigation = new WebBrowserNavigation();
   }
 }

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

@@ -0,0 +1,17 @@
+const DEBUG_ENABLED = false;
+export default 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);
+  }
+}

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

@@ -0,0 +1,16 @@
+export default 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);
+  }
+}

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

@@ -5,12 +5,23 @@ export default 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/esm/{session → environment}/navigation/ServerSideNavigation.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-underscore-dangle, max-classes-per-file */
 
-import ServerSideNavigationError from './error/ServerSideNavigationError';
+import ServerSideRedirectError from './error/ServerSideRedirectError';
 export default class ServerSideNavigation {
   init(initialLocation, {
     operation,
@@ -16,12 +16,21 @@ export default 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 () => {};
   }
 
@@ -32,7 +41,7 @@ export default class ServerSideNavigation {
     index,
     delta
   }) {
-    throw new ServerSideNavigationError(location);
+    throw new ServerSideRedirectError(location);
   }
 
   // eslint-disable-next-line no-unused-vars

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

@@ -47,15 +47,28 @@ export default 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 {
@@ -86,6 +99,16 @@ export default 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,
@@ -102,7 +125,8 @@ export default 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`.
@@ -116,7 +140,7 @@ export default class WebBrowserNavigation {
         index
       };
       // Call `history.replaceState()`.
-      this._storeAdditionalPropertiesForLocation(initialLocation, additionalProperties, delta);
+      this._navigateToLocationAndKeepItsAdditionalPropertiesInHistory(initialLocation, additionalProperties, delta);
     }
     this._currentLocationIndex = index;
 
@@ -136,7 +160,7 @@ export default class WebBrowserNavigation {
       key,
       index
     };
-    this._storeAdditionalPropertiesForLocation(location, additionalProperties, delta);
+    this._navigateToLocationAndKeepItsAdditionalPropertiesInHistory(location, additionalProperties, delta);
     this._currentLocationIndex = index;
 
     // Call the listeners.
@@ -198,7 +222,23 @@ export default 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 = getLocationUrl(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/esm/{session/navigation/error/ServerSideNavigationError.js → environment/navigation/error/ServerSideRedirectError.js}

@@ -1,7 +1,7 @@
 const _excluded = ["operation"];
 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; }
 import getLocationUrl from '../../../getLocationUrl';
-export default class ServerSideNavigationError extends Error {
+export default class ServerSideRedirectError extends Error {
   constructor(location) {
     super(location ? `Navigate to ${getLocationUrl(location)}` : 'Navigate to previous or next location');
     if (location) {

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

@@ -45,9 +45,24 @@ export default 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/esm/getLocationBaseFromLocation.js

@@ -0,0 +1,9 @@
+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`.
+export default function getLocationBaseFromLocation(location) {
+  // eslint-disable-next-line no-unused-vars
+  const locationBase = _objectWithoutPropertiesLoose(location, _excluded);
+  return locationBase;
+}

package/lib/esm/getLocationUrl.js

@@ -1,4 +1,4 @@
-import { stringify as stringifyQuery } from 'query-string';
+import stringifyQueryAsSearch from './stringifyQueryAsSearch';
 export default function getLocationUrl({
   pathname,
   search,
@@ -6,10 +6,7 @@ export default function getLocationUrl({
   hash
 }) {
   if (!search && query) {
-    const queryString = stringifyQuery(query);
-    if (queryString) {
-      search = `?${queryString}`;
-    }
+    search = stringifyQueryAsSearch(query);
   }
   return `${pathname}${search || ''}${hash || ''}`;
 }

package/lib/esm/index.js

@@ -4,11 +4,8 @@ export { default as getLocationUrl } from './getLocationUrl';
 export { default as parseLocationUrl } from './parseLocationUrl';
 export { default as parseInputLocation } from './parseInputLocation';
 export { default as NavigationStack } from './NavigationStack';
-export { default as DataStorage } from './data-storage/DataStorage';
-export { default as LocationDataStorage } from './data-storage/LocationDataStorage';
-export { default as Session } from './session/Session';
-export { default as InMemorySession } from './session/InMemorySession';
-export { default as WebBrowserSession } from './session/WebBrowserSession';
-export { default as ServerSideRenderSession } from './session/ServerSideRenderSession';
-export { default as ServerSideNavigationError } from './session/navigation/error/ServerSideNavigationError';
-export { default as NavigationOutOfBoundsError } from './session/navigation/error/NavigationOutOfBoundsError';
+export { default as InMemoryEnvironment } from './environment/InMemoryEnvironment';
+export { default as WebBrowserEnvironment } from './environment/WebBrowserEnvironment';
+export { default as ServerSideRenderEnvironment } from './environment/ServerSideRenderEnvironment';
+export { default as ServerSideRedirectError } from './environment/navigation/error/ServerSideRedirectError';
+export { default as NavigationOutOfBoundsError } from './environment/navigation/error/NavigationOutOfBoundsError';