navigation-stack 0.3.1 → 0.5.0

package/lib/esm/session/MemorySession.js

@@ -1,217 +0,0 @@
-/* eslint-disable max-classes-per-file */
-
-import normalizeInputLocation from '../normalizeInputLocation';
-
-// eslint-disable-next-line no-underscore-dangle
-function _loadState(load, isValidLoadedData) {
-  try {
-    const data = JSON.parse(load());
-
-    // Check that the stack and index at least seem reasonable before using
-    // them as state. This isn't foolproof, but it might prevent mistakes.
-    // Also perform a basic validation of `state`.
-    if (isValidLoadedData(data)) {
-      return data;
-    }
-  } catch (error) {} // eslint-disable-line no-empty
-
-  return null;
-}
-
-// eslint-disable-next-line no-underscore-dangle
-function _saveState(save, data) {
-  try {
-    save(JSON.stringify(data));
-  } catch (error) {} // eslint-disable-line no-empty
-}
-class MemoryNavigation {
-  constructor(initialLocation, {
-    save,
-    load
-  } = {}) {
-    this._save = save;
-    this._keyPrefix = Date.now().toString(36);
-    this._keyIndex = 0;
-    this._subscriptionListener = null;
-    const initialState = load ? _loadState(load, this._isValidLoadedData) : null;
-    if (initialState) {
-      this._stack = initialState.stack;
-      this._index = initialState.index;
-    } else {
-      this._stack = [Object.assign({}, normalizeInputLocation(initialLocation), {
-        key: this._getNextKey()
-      })];
-      this._index = 0;
-    }
-  }
-  _isValidLoadedData({
-    stack,
-    index
-  }) {
-    // Check that the `stack` and `index` at least seem reasonable before using them.
-    // This isn't foolproof, but it might prevent mistakes.
-    return Array.isArray(stack) && typeof index === 'number' && stack[index];
-  }
-  init() {
-    return this._createLocationObject({
-      action: 'INIT',
-      delta: 0
-    });
-  }
-  subscribe(listener) {
-    this._subscriptionListener = listener;
-    return () => {
-      this._subscriptionListener = null;
-    };
-  }
-  navigate(location) {
-    const {
-      action,
-      pathname,
-      search,
-      query,
-      hash,
-      state
-    } = location;
-    if (action !== 'PUSH' && action !== 'REPLACE') {
-      throw Error(`Unrecognized browser session action: ${action}`);
-    }
-    const delta = action === 'PUSH' ? 1 : 0;
-    this._index += delta;
-    const key = this._getNextKey();
-    this._stack[this._index] = {
-      pathname,
-      search,
-      query,
-      hash,
-      state,
-      key
-    };
-    if (action === 'PUSH') {
-      this._stack.length = this._index + 1;
-    }
-    if (this._save) {
-      _saveState(this._save, {
-        stack: this._stack,
-        index: this._index
-      });
-    }
-    return Object.assign({}, location, {
-      key,
-      index: this._index,
-      delta
-    });
-  }
-  shift(delta) {
-    const prevIndex = this._index;
-    this._index = Math.min(Math.max(this._index + delta, 0), this._stack.length - 1);
-    if (this._index === prevIndex) {
-      return;
-    }
-    if (this._save) {
-      _saveState(this._save, {
-        stack: this._stack,
-        index: this._index
-      });
-    }
-    if (this._subscriptionListener) {
-      this._subscriptionListener(this._createLocationObject({
-        action: 'SHIFT',
-        delta: this._index - prevIndex
-      }));
-    }
-  }
-  _getNextKey() {
-    const key = `${this._keyPrefix}.${this._keyIndex.toString(36)}`;
-    this._keyIndex++;
-    return key;
-  }
-  _createLocationObject({
-    action,
-    delta
-  }) {
-    return Object.assign({}, this._stack[this._index], {
-      action,
-      index: this._index,
-      delta
-    });
-  }
-}
-class MemoryDataStorage {
-  constructor({
-    load,
-    save
-  } = {}) {
-    this._save = save;
-    const initialState = load ? _loadState(load, this._isValidLoadedData) : null;
-    if (initialState) {
-      this._state = initialState.state;
-    } else {
-      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];
-    }
-    if (this._save) {
-      _saveState(this._save, {
-        state: this._state
-      });
-    }
-  }
-  set(key, value) {
-    this._state[key] = value;
-    if (this._save) {
-      _saveState(this._save, {
-        state: this._state
-      });
-    }
-  }
-  _isValidLoadedData({
-    state
-  }) {
-    // Perform a basic validation of `state`.
-    return typeof state === 'object' && state !== null;
-  }
-}
-function createNestedStateSaveLoadFunctions({
-  save,
-  load
-}, key) {
-  return {
-    save: save ? data => save(key, data) : undefined,
-    load: load ? () => load(key) : undefined
-  };
-}
-export default class MemorySession {
-  constructor(initialLocation, {
-    save,
-    load
-  } = {}) {
-    this.navigation = new MemoryNavigation(initialLocation, createNestedStateSaveLoadFunctions({
-      save,
-      load
-    }, 'navigation'));
-    this.dataStorage = new MemoryDataStorage(createNestedStateSaveLoadFunctions({
-      save,
-      load
-    }, 'dataStorage'));
-  }
-
-  // "Before destroy" listeners are currently ignored.
-  // If required, one could implement a `_destroy()` method
-  // and there check that the listeners actually do get called.
-  // eslint-disable-next-line no-unused-vars
-  addBeforeDestroyListener(listener) {
-    return () => {};
-  }
-}

package/lib/esm/session/ServerSession.js

@@ -1,58 +0,0 @@
-/* eslint-disable max-classes-per-file */
-
-import normalizeInputLocation from '../normalizeInputLocation';
-function noop() {}
-function serverSideNavigationNotPossible() {
-  throw new Error('Server-side navigation is not possible');
-}
-class ServerNavigation {
-  constructor(initialLocation) {
-    this._location = normalizeInputLocation(initialLocation);
-  }
-  init() {
-    return Object.assign({
-      action: 'INIT'
-    }, this._location, {
-      index: 0,
-      key: '0'
-    });
-  }
-  subscribe() {
-    // Server-side environment emits no location subscription events.
-    return noop;
-  }
-
-  // Navigation methods are not implemented, because `ServerSession` instances
-  // cannot navigate.
-  navigate() {
-    serverSideNavigationNotPossible();
-  }
-
-  // Navigation methods are not implemented, because `ServerSession` instances
-  // cannot navigate.
-  shift() {
-    serverSideNavigationNotPossible();
-  }
-}
-class ServerDataStorage {
-  // It doesn't seem to make any sense to store anything on server side.
-  // Hence, state management methods are "no op" stubs.
-  get() {
-    return null;
-  }
-  remove() {}
-  set() {}
-}
-export default class ServerSession {
-  constructor(initialLocation) {
-    this.navigation = new ServerNavigation(initialLocation);
-    this.dataStorage = new ServerDataStorage();
-  }
-
-  // "Before destroy" listeners are currently ignored.
-  // If required, one could implement a `_destroy()` method
-  // and there check that the listeners actually do get called.
-  addBeforeDestroyListener() {
-    return noop;
-  }
-}

package/src/LocationDataStorage.js

@@ -1,60 +0,0 @@
-import getLocationUrl from './getLocationUrl';
-
-export default class LocationDataStorage {
-  constructor(environment, { namespace }) {
-    this._environment = environment;
-    this._getFallbackLocationKey = getLocationUrl;
-    this._stateKeyPrefix = `${namespace}|`;
-    // this._stateKeyPrefix = namespace ? `${namespace}|` : '';
-  }
-
-  get(location, key) {
-    const stateKey = this._getStateKey(location, key);
-
-    try {
-      const value = this._environment.dataStorage.get(stateKey);
-      // === 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) {
-      // Pretend that the entry doesn't exist.
-      return undefined;
-    }
-  }
-
-  set(location, key, value) {
-    const stateKey = this._getStateKey(location, key);
-
-    if (value === undefined) {
-      try {
-        this._environment.dataStorage.remove(stateKey);
-      } catch (error) {
-        // No need to handle errors here.
-      }
-
-      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._environment.dataStorage.set(stateKey, 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.
-    }
-  }
-
-  _getStateKey(location, key) {
-    const locationKey = location.key || this._getFallbackLocationKey(location);
-    const keyPrefix = `${this._stateKeyPrefix}${locationKey}`;
-    return `${keyPrefix}|${key}`;
-  }
-}

package/src/addBeforeLocationChangeListener.js

@@ -1,2 +0,0 @@
-// eslint-disable-next-line no-restricted-exports
-export { addBeforeLocationChangeListener as default } from './beforeLocationChangeListeners';

package/src/beforeLocationChangeListeners.js

@@ -1,54 +0,0 @@
-/* eslint-disable no-underscore-dangle */
-
-export function getBeforeLocationChangeListeners(session) {
-  return session._beforeLocationChangeListenersList || [];
-}
-
-function addBeforeLocationChangeListenerToTheList(listener, session) {
-  if (!session._beforeLocationChangeListenersList) {
-    session._beforeLocationChangeListenersList = [];
-  }
-  session._beforeLocationChangeListenersList.push(listener);
-}
-
-function removeBeforeLocationChangeListenerFromTheList(listener, session) {
-  if (session._beforeLocationChangeListenersList) {
-    session._beforeLocationChangeListenersList =
-      session._beforeLocationChangeListenersList.filter((_) => _ !== listener);
-  }
-}
-
-export function removeAllBeforeLocationChangeListeners(session) {
-  session._beforeLocationChangeListenersList = [];
-}
-
-// Runs the `listener` while ignoring any errors that might be thrown by it.
-function runBeforeLocationChangeListener(listener, location) {
-  try {
-    listener(location);
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      `Ignoring before location change listener \`${listener.name}\` that failed with \`${error}\`.`,
-    );
-    // eslint-disable-next-line no-console
-    console.error(error);
-  }
-}
-
-// Runs all listeners in order.
-export function runBeforeLocationChangeListeners(
-  navigationListeners,
-  toLocation,
-) {
-  for (const listener of navigationListeners) {
-    runBeforeLocationChangeListener(listener, toLocation);
-  }
-}
-
-export function addBeforeLocationChangeListener(session, listener) {
-  addBeforeLocationChangeListenerToTheList(listener, session);
-  return () => {
-    removeBeforeLocationChangeListenerFromTheList(listener, session);
-  };
-}

package/src/createMiddlewares.js

@@ -1,45 +0,0 @@
-import createBasePathMiddleware from './middleware/createBasePathMiddleware';
-import createBeforeLocationChangeListenerMiddleware from './middleware/createBeforeLocationChangeListenerMiddleware';
-import createLocationMiddleware from './middleware/createLocationMiddleware';
-import createNavigationBlockerMiddleware from './middleware/createNavigationBlockerMiddleware';
-import navigationActionMiddleware from './middleware/navigationActionMiddleware';
-import normalizeInputLocationMiddleware from './middleware/normalizeInputLocationMiddleware';
-
-export default function createMiddlewares(session, options) {
-  // Allows temporarily ignoring location update events.
-  let shouldIgnoreLocationSubscriptionEvents = false;
-  const ignoreLocationSubscriptionEvents = (func) => {
-    shouldIgnoreLocationSubscriptionEvents = true;
-    func();
-    shouldIgnoreLocationSubscriptionEvents = false;
-  };
-
-  return [
-    // Validates that the action "payload" (input location) is a proper `NormalizedInputLocation`.
-    normalizeInputLocationMiddleware,
-    // Transforms a "PUSH" / "REPLACE" action into a "NAVIGATE" action.
-    navigationActionMiddleware,
-    // If a website is hosted under a certain path (`basePath`)
-    // then this middleware will automatically strip that starting segment from the `pathname` of `location`s.
-    createBasePathMiddleware(options && options.basePath),
-    // Allows blocking navigation.
-    // Handles `NAVIGATE` actions dispatched by the application itself.
-    createNavigationBlockerMiddleware(session, {
-      ignoreLocationSubscriptionEvents,
-    }),
-    // This "middleware" performs the actual navigation according to the `session` being used.
-    // For example, when `BrowserSession` is used, it calls methods of the `history` object.
-    createLocationMiddleware(session, {
-      shouldIgnoreLocationSubscriptionEvents: () =>
-        shouldIgnoreLocationSubscriptionEvents,
-    }),
-    // Allows blocking navigation.
-    // Handles location `UPDATE` actions dispatched in response to location update events.
-    createNavigationBlockerMiddleware(session, {
-      ignoreLocationSubscriptionEvents,
-    }),
-    // Allows subscribing to upcoming location changes
-    // before those changes are applied in the `location` object in the state.
-    createBeforeLocationChangeListenerMiddleware(session),
-  ];
-}

package/src/middleware/createBasePathMiddleware.js

@@ -1,20 +0,0 @@
-import { addBasePath, removeBasePath } from '../basePath';
-import createTransformLocationMiddleware from './createTransformLocationMiddleware';
-
-// Creates a "middleware" that, when a website is hosted under a certain path (`basePath`),
-// automatically strips that starting segment from the `pathname` of `location`s.
-export default function createBasePathMiddleware(basePath) {
-  return createTransformLocationMiddleware({
-    // Transforms input `Location`:
-    // prepends `basePath` to the URL.
-    transformInputLocation: (location) => {
-      return addBasePath(location, basePath);
-    },
-
-    // Transforms subscription `Location` object:
-    // removes `basePath` from the URL.
-    transformSubscriptionLocation: (location) => {
-      return removeBasePath(location, basePath);
-    },
-  });
-}

package/src/middleware/createBeforeLocationChangeListenerMiddleware.js

@@ -1,40 +0,0 @@
-import ActionTypes from '../ActionTypes';
-import {
-  getBeforeLocationChangeListeners,
-  removeAllBeforeLocationChangeListeners,
-  runBeforeLocationChangeListeners,
-} from '../beforeLocationChangeListeners';
-
-// Creates a "middleware" that calls upcoming navigation listeners.
-export default function createBeforeLocationChangeListenerMiddleware(session) {
-  return function navigationListenerMiddleware() {
-    return (next) => (action) => {
-      const { type, payload } = action;
-
-      switch (type) {
-        // Trigger navigation listeners before the `location` has been updated in Redux state.
-        // It doesn't matter that the new location URL has already been updated in the web browser's
-        // address bar, or that the web browser's history has already switched to the new locaiton.
-        // 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.UPDATE:
-          runBeforeLocationChangeListeners(
-            getBeforeLocationChangeListeners(session),
-            payload,
-          );
-          return next(action);
-
-        // Remove any navigation listeners on `DISPOSE` event.
-        case ActionTypes.DISPOSE:
-          removeAllBeforeLocationChangeListeners(session);
-          return next(action);
-
-        default:
-          return next(action);
-      }
-    };
-  };
-}

package/src/middleware/createLocationMiddleware.js

@@ -1,55 +0,0 @@
-import ActionTypes from '../ActionTypes';
-
-function updateLocation(location) {
-  return {
-    type: ActionTypes.UPDATE,
-    payload: location,
-  };
-}
-
-// Creates a "middleware" that performs the actual navigation according to the `session` being used.
-// For example, when `BrowserSession` is used, it calls methods of the `window.history` object.
-export default function createLocationMiddleware(
-  session,
-  { shouldIgnoreLocationSubscriptionEvents },
-) {
-  return function locationMiddleware() {
-    return (next) => {
-      // Whenever browser location changes,
-      // perform the same changes with the internal `location` object.
-      const unsubscribe = session.navigation.subscribe((location) => {
-        if (!shouldIgnoreLocationSubscriptionEvents()) {
-          next(updateLocation(location));
-        }
-      });
-
-      return (action) => {
-        const { type, payload } = action;
-
-        switch (type) {
-          case ActionTypes.INIT:
-            return next(updateLocation(session.navigation.init()));
-
-          case ActionTypes.NAVIGATE:
-            // `session.navigate()` doesn't trigger the `subscribe()` listener.
-            return next(updateLocation(session.navigation.navigate(payload)));
-
-          case ActionTypes.SHIFT:
-            // `shift()` will trigger the `subscribe()` listener,
-            // which will call `updateLocation()`.
-            session.navigation.shift(payload);
-            // eslint-disable-next-line consistent-return
-            return;
-
-          case ActionTypes.DISPOSE:
-            unsubscribe();
-            // eslint-disable-next-line consistent-return
-            return;
-
-          default:
-            return next(action);
-        }
-      };
-    };
-  };
-}