navigation-stack 0.5.3 → 0.6.0

package/src/session/Session.js

@@ -1,9 +1,8 @@
-import debug from '../debug';
 import parseInputLocation from '../parseInputLocation';
 import createSessionKey from './key/createSessionKey';
-import NavigationOutOfBoundsError from './navigation/error/NavigationOutOfBoundsError';
-import NavigationOperations from './navigation/operation/operations';
 import Subscription from './subscription/Subscription';
+import NavigationOutOfBoundsError from '../environment/navigation/error/NavigationOutOfBoundsError';
+import NavigationOperations from '../environment/navigation/operation/operations';
 
 const INITIAL_KEY_INDEX = -1;
 const INITIAL_INDEX = -1;
@@ -11,12 +10,15 @@ const INITIAL_INDEX = -1;
 const INIT_LOCATION_DELTA = 0;
 
 export default class Session {
-  constructor({ navigation }) {
+  constructor(EnvironmentClass) {
     // `key` is used in `WebBrowserSession` to uniquely identify a session
     // when storing data in a `WebBrowserDataStorage` which uses `window.sessionStorage`
     // under the hood, and `window.sessionStorage` is shared between different sessions.
     this.key = createSessionKey();
 
+    // Create an environment instance.
+    this.environment = new EnvironmentClass();
+
     // `this._locationKeyIndex` is incremented every time the current location changes.
     this._locationKeyIndex = INITIAL_KEY_INDEX;
 
@@ -28,18 +30,36 @@ export default class Session {
     // In other words, this is the last location index that it can `.shift()` to.
     this._terminalLocationIndex = this._currentLocationIndex;
 
-    // Create `navigation`.
-    this._navigation = navigation;
+    // Allows subscribing to location updates.
+    this._subscription = new Subscription();
 
-    // Manages subscriptions.
-    this._subscription = new Subscription({
-      activateSubscription: (listener) => {
-        return this._navigation.subscribe(listener);
-      },
+    // Subscribing to location changes means subscribing to both "synchronous"
+    // and "asynchronous" location changes. "synchronous" location changes
+    // happen immediately when the code triggers them."asynchronous" location changes
+    // either happen after an arbitrary delay or are even triggered from outside the code.
+    //
+    // Subscribing to "asynchronous" location changes is not necessary when
+    // there're no actual subscribers, in order to not unnecessarily "waste" any resources.
+    // Of course, this statement is rather far-fetched and in reality no one would ever tell any difference.
+    // Still, I felt like randomly introducing this seemingly unnecessary minor optimization.
+    //
+    // So it only subscribes to "asynchronous" location changes if there's at least one active subscriber.
+    // And in case all subscribers get unsubscribed, it will unsubscribe from "asynchronous" location changes too.
+    // One might think of it as some form of "mental masturbation", but what can I do — I already wrote the code.
+    //
+    this._subscription.onFirstSubscriber(() => {
+      return this.environment.navigation.subscribeToAsyncrhonousLocationUpdates(
+        (location) => {
+          // Notify all subscribers about this "asynchronous" location change.
+          this._subscription.notifySubscribers(location);
+        },
+      );
     });
 
-    // Update current location index when a location change was not initiated
-    // by this session but rather by the user clicking "Back" or "Forward" button.
+    // This subscription is triggered in two cases:
+    // * Set initial current location index at initial page load.
+    // * Update current location index whenever a location change is not initiated
+    //   by this session but rather by the user clicking "Back" or "Forward" button.
     this._unsubscribe = this.subscribe((location) => {
       // Update `this._currentLocationIndex` when the location change was not initiated
       // by this session but rather by the user clicking "Back" or "Forward" button.
@@ -50,7 +70,7 @@ export default class Session {
       // by `navigation` to call `session.getNextKey()` function to increment `locationKeyIndex`.
       this._updateTerminalLocationIndex(location);
 
-      debug(
+      this.environment.log.debug(
         'current location',
         location.pathname,
         'index',
@@ -60,14 +80,18 @@ export default class Session {
   }
 
   // Subscribes to changes in location.
+  // The first subscriber is always the `Session` itself:
+  // its listener keeps the current location index up-to-date.
+  // Any additional application-specific listeners could be added, if required.
+  // Applications should prefer adding any such listeners by calling `NavigationStack.subscribe()`
+  // method instead of calling this method directly, in order to "normalize" the `location` argument.
   subscribe(listener) {
     return this._subscription.subscribe((location) => {
       if (
         !this._isStarted() &&
         location.operation !== NavigationOperations.INIT
       ) {
-        // eslint-disable-next-line no-console
-        console.error('Unexpected location change', location);
+        this.environment.log.error('Unexpected location change', location);
         throw new Error('Not started');
       } else {
         // Call the listener.
@@ -76,6 +100,17 @@ export default class Session {
     });
   }
 
+  // Starts a navigation session.
+  //
+  // When run in a web browser, it could not only "start" a new session
+  // but also "resume" a previously-started session. That could happen
+  // when the user refreshes a page in a web browser which still retains
+  // the previous session's data but at the same time restarts the javascript code
+  // from scratch.
+  //
+  // So this `start()` method handles both cases: when there's previous session's data
+  // that should be restored and when there's no previous session's data.
+  //
   start(initialLocation) {
     if (this._stopped) {
       throw new Error('Can not be restarted');
@@ -88,7 +123,7 @@ export default class Session {
     // the initial location by the time javascript code starts execution.
     //
     if (!initialLocation) {
-      initialLocation = this._navigation.getInitialLocation();
+      initialLocation = this.environment.navigation.getInitialLocation();
       if (initialLocation) {
         initialLocation = parseInputLocation(initialLocation);
       }
@@ -102,7 +137,7 @@ export default class Session {
       throw new Error('Already started');
     }
 
-    debug('▶ start session', initialLocation.pathname);
+    this.environment.log.debug('▶ start session', initialLocation.pathname);
 
     this._started = true;
 
@@ -110,7 +145,7 @@ export default class Session {
     const index = INITIAL_INDEX + 1;
     const delta = INIT_LOCATION_DELTA;
 
-    const locationResult = this._navigation.init(initialLocation, {
+    const locationResult = this.environment.navigation.init(initialLocation, {
       operation: NavigationOperations.INIT,
       key,
       index,
@@ -118,6 +153,7 @@ export default class Session {
     });
 
     if (locationResult) {
+      // Notify all subscribers about this "synchronous" location change.
       this._subscription.notifySubscribers(locationResult);
     }
   }
@@ -127,7 +163,7 @@ export default class Session {
       throw Error('Already stopped');
     }
 
-    debug('⏹ stop session');
+    this.environment.log.debug('⏹ stop session');
 
     // Once stopped, it won't be able to be restarted.
     this._stopped = true;
@@ -160,7 +196,7 @@ export default class Session {
     const key = this._getNextLocationKey();
     const index = this._currentLocationIndex + delta;
 
-    debug(
+    this.environment.log.debug(
       operation === NavigationOperations.PUSH ? '↓' : '⇅',
       operation,
       location.pathname,
@@ -169,7 +205,7 @@ export default class Session {
     );
 
     // Navigate to the location.
-    const locationResult = this._navigation.navigate(location, {
+    const locationResult = this.environment.navigation.navigate(location, {
       operation,
       key,
       index,
@@ -177,6 +213,7 @@ export default class Session {
     });
 
     if (locationResult) {
+      // Notify all subscribers about this "synchronous" location change.
       this._subscription.notifySubscribers(locationResult);
     }
   }
@@ -193,7 +230,13 @@ export default class Session {
 
     const index = this._currentLocationIndex + delta;
 
-    debug(delta > 0 ? '→' : '←', 'shift', delta, 'index', index);
+    this.environment.log.debug(
+      delta > 0 ? '→' : '←',
+      'shift',
+      delta,
+      'index',
+      index,
+    );
 
     // Validate that the new `index` is not out of bounds.
     if (index < 0 || index > this._terminalLocationIndex) {
@@ -201,13 +244,14 @@ export default class Session {
     }
 
     // Navigate to the location.
-    const locationResult = this._navigation.shift({
+    const locationResult = this.environment.navigation.shift({
       operation: NavigationOperations.SHIFT,
       index,
       delta,
     });
 
     if (locationResult) {
+      // Notify all subscribers about this "synchronous" location change.
       this._subscription.notifySubscribers(locationResult);
     }
   }

package/src/session/subscription/Subscription.js

@@ -1,18 +1,35 @@
 export default class Subscription {
-  constructor({ activateSubscription } = {}) {
-    this._activateSubscription = activateSubscription;
-
+  constructor() {
     // This property is accessed in tests.
     this._listeners = [];
+
+    // These listeners will be called when the subscription enters "active" or "inactive" state.
+    // A subscription enters "active" state when it has at least one listener rather than zero.
+    // A subscription enters "inactive" state when it has no more listeners.
+    this._subscriptionActiveStateListeners = [];
+    this._subscriptionInactiveStateListeners = [];
   }
 
-  notifySubscribers = (argument) => {
+  // Adds a subscription active state listener.
+  // Returns a function that removes the subscription active state listener.
+  onFirstSubscriber(activeStateListener) {
+    this._subscriptionActiveStateListeners.push(activeStateListener);
+    // Return a function that removes the subscription active state listener.
+    return () => {
+      this._subscriptionActiveStateListeners =
+        this._subscriptionActiveStateListeners.filter(
+          (_) => _ !== activeStateListener,
+        );
+    };
+  }
+
+  notifySubscribers(argument) {
     // `._latest` is only used in tests.
     this._latest = argument;
     for (const { listener } of this._listeners) {
       listener(argument);
     }
-  };
+  }
 
   subscribe(listener) {
     // If subscriptions are stopped, i.e. no new subscriptions are to be added,
@@ -30,9 +47,12 @@ export default class Subscription {
 
     // If it's the first listener, activate subscription.
     if (this._listeners.length === 0) {
-      this._deactivateSubscription = this._activateSubscription(
-        this.notifySubscribers,
-      );
+      // Run all subscription active state listeners.
+      // The functions returned from those will become subscription inactive state listeners.
+      this._subscriptionInactiveStateListeners =
+        this._subscriptionActiveStateListeners.map((activeStateListener) =>
+          activeStateListener(),
+        );
     }
 
     // Add the `listener` to the list.
@@ -67,10 +87,15 @@ export default class Subscription {
     // Remove the `listener` from the list.
     this._listeners = this._listeners.filter((_) => _ !== listenerEntry);
 
-    // If it was the last listener, deactivate subscription.
+    // If it was the last listener.
     if (this._listeners.length === 0) {
-      this._deactivateSubscription();
-      this._deactivateSubscription = undefined;
+      // Run any subscription inactive state listeners,
+      // after which clear the list of such listeners.
+      for (const inactiveStateListener of this
+        ._subscriptionInactiveStateListeners) {
+        inactiveStateListener();
+      }
+      this._subscriptionInactiveStateListeners = [];
     }
   }
 }

package/src/stringifyQuery.js

@@ -0,0 +1,71 @@
+// "The more recent RFC3986 reserves !, ', (, ), and *,
+// even though these characters have no formalized URI delimiting uses.
+//
+// https://datatracker.ietf.org/doc/html/rfc3986
+//
+// The following function encodes a string for RFC3986-compliant URL component format.
+// It also encodes [ and ], which are part of the IPv6 URI syntax.
+//
+// An RFC3986-compliant encodeURI implementation should not escape them,
+// which is demonstrated in the encodeURI() example.
+//
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent#encoding_for_rfc3986
+//
+// Can throw a `URIError` if the `string` contains a "lone surrogate".
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#utf-16_characters_unicode_code_points_and_grapheme_clusters
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError
+// Example: "URIError: malformed URI sequence"
+//
+function encode(string) {
+  return encodeURIComponent(string).replace(
+    /[!'()*]/g,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`,
+  );
+}
+
+export default function stringifyQuery(query) {
+  let queryString = '';
+
+  if (!query) {
+    return queryString;
+  }
+
+  for (const key of Object.keys(query)) {
+    let value = query[key];
+
+    if (Array.isArray(value)) {
+      throw new Error('Array values are not supported');
+    }
+
+    // Ignore `value: undefined`.
+    if (value === undefined) {
+      continue;
+    }
+
+    // Stringify `value`.
+    if (value === null) {
+      value = '';
+    } else {
+      value = String(value);
+    }
+
+    // Can throw a `URIError` if the `string` contains a "lone surrogate".
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#utf-16_characters_unicode_code_points_and_grapheme_clusters
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError
+    // Example: "URIError: malformed URI sequence"
+    try {
+      const keyValuePair = `${encode(key)}${value ? '=' : ''}${encode(value)}`;
+
+      if (queryString.length > 1) {
+        queryString += '&';
+      }
+
+      queryString += keyValuePair;
+    } catch (error) {
+      // Simply ignore an invalid query parameter.
+      continue;
+    }
+  }
+
+  return queryString;
+}

package/src/stringifyQueryAsSearch.js

@@ -0,0 +1,9 @@
+import stringifyQuery from './stringifyQuery';
+
+export default function stringifyQueryAsSearch(query) {
+  const queryString = stringifyQuery(query);
+  if (queryString) {
+    return `?${queryString}`;
+  }
+  return '';
+}

package/test/NavigationStack.addBasePath.test.js

@@ -0,0 +1,50 @@
+import NavigationStack from '../src/NavigationStack';
+import InMemoryEnvironment from '../src/environment/InMemoryEnvironment';
+
+describe('NavigationStack (addBasePath)', () => {
+  it('should add `basePath` to `location.pathname`', () => {
+    const navigationStack = new NavigationStack(InMemoryEnvironment, {
+      basePath: '/base',
+    });
+    navigationStack.init('/path');
+    // eslint-disable-next-line no-underscore-dangle
+    expect(navigationStack._session._subscription._latest.pathname).to.equal(
+      '/base/path',
+    );
+    navigationStack.stop();
+  });
+
+  it('should add `basePath` (with a trailing slash) to `location.pathname`', () => {
+    const navigationStack = new NavigationStack(InMemoryEnvironment, {
+      basePath: '/base/',
+    });
+    navigationStack.init('/path');
+    // eslint-disable-next-line no-underscore-dangle
+    expect(navigationStack._session._subscription._latest.pathname).to.equal(
+      '/base/path',
+    );
+    navigationStack.stop();
+  });
+
+  it('should not modify `location.pathname` when no `basePath` was specified', () => {
+    const navigationStack = new NavigationStack(InMemoryEnvironment);
+    navigationStack.init('/path');
+    // eslint-disable-next-line no-underscore-dangle
+    expect(navigationStack._session._subscription._latest.pathname).to.equal(
+      '/path',
+    );
+    navigationStack.stop();
+  });
+
+  it('should not modify `location.pathname` when `basePath: "/"` was specified', () => {
+    const navigationStack = new NavigationStack(InMemoryEnvironment, {
+      basePath: '/',
+    });
+    navigationStack.init('/path');
+    // eslint-disable-next-line no-underscore-dangle
+    expect(navigationStack._session._subscription._latest.pathname).to.equal(
+      '/path',
+    );
+    navigationStack.stop();
+  });
+});

package/test/{redux/middleware/createNonProgrammaticNavigationBlockerMiddleware.test.js → NavigationStack.blockNonProgrammaticNavigationIfRequired.test.js}

@@ -1,56 +1,48 @@
 import delay from 'delay';
 import pDefer from 'p-defer';
-import { applyMiddleware, createStore } from 'redux';
 
-import addNavigationBlockerOriginal from '../../../src/addNavigationBlocker';
-import Actions from '../../../src/redux/Actions';
-import createMiddlewares from '../../../src/redux/createMiddlewares';
-import internalLocationReducer from '../../../src/redux/internalLocationReducer';
-import InMemorySession from '../../../src/session/InMemorySession';
+import NavigationStack from '../src/NavigationStack';
+import addNavigationBlockerOriginal from '../src/addNavigationBlocker';
+import InMemoryEnvironment from '../src/environment/InMemoryEnvironment';
 
-describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
+describe('NavigationStack (blockNonProgrammaticNavigationIfRequired)', () => {
   // const sandbox = sinon.createSandbox();
 
   let session;
-  let store;
+  let navigationStack;
 
   function addNavigationBlocker(blocker) {
     return addNavigationBlockerOriginal(session, blocker);
   }
 
   beforeEach(() => {
-    session = new InMemorySession();
-
-    store = createStore(
-      internalLocationReducer,
-      applyMiddleware(
-        ...createMiddlewares(session, {
-          _internalLocationReducer: true,
-        }),
-      ),
-    );
-    store.dispatch(Actions.init('/initial'));
-
-    sinon.spy(session.lifecycle, 'addTerminationBlocker');
+    navigationStack = new NavigationStack(InMemoryEnvironment);
+
+    // eslint-disable-next-line no-underscore-dangle
+    session = navigationStack._session;
+
+    navigationStack.init('/initial');
+
+    sinon.spy(session.environment.lifecycle, 'addTerminationBlocker');
   });
 
   afterEach(() => {
-    store.dispatch(Actions.stop());
+    navigationStack.stop();
 
     // sandbox.restore();
   });
 
   describe('shift navigation', () => {
     beforeEach(() => {
-      store.dispatch(Actions.push('/new'));
+      navigationStack.push('/new');
     });
 
     it('should allow navigation when blocker returns `undefined`', () => {
       const blocker = sinon.stub().returns(undefined);
       addNavigationBlocker(blocker);
 
-      store.dispatch(Actions.shift(-1));
-      expect(store.getState().pathname).to.equal('/initial');
+      navigationStack.shift(-1);
+      expect(navigationStack.current().pathname).to.equal('/initial');
 
       expect(blocker.firstCall.args[0]).to.include({
         // operation: 'shift',
@@ -62,34 +54,34 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
     it('should block navigation when blocker returns `true`', () => {
       addNavigationBlocker(() => true);
 
-      store.dispatch(Actions.shift(-1));
-      expect(store.getState().pathname).to.equal('/new');
+      navigationStack.shift(-1);
+      expect(navigationStack.current().pathname).to.equal('/new');
     });
 
     it('should allow navigation when blocker returns `undefined` (async)', async () => {
       const navigationBlockerDeferred = pDefer();
       addNavigationBlocker(() => navigationBlockerDeferred.promise);
 
-      store.dispatch(Actions.shift(-1));
-      expect(store.getState().pathname).to.equal('/new');
+      navigationStack.shift(-1);
+      expect(navigationStack.current().pathname).to.equal('/new');
 
       navigationBlockerDeferred.resolve(undefined);
       await delay(10);
 
-      expect(store.getState().pathname).to.equal('/initial');
+      expect(navigationStack.current().pathname).to.equal('/initial');
     });
 
     it('should block navigation when blocker returns `true` (async)', async () => {
       const navigationBlockerDeferred = pDefer();
       addNavigationBlocker(() => navigationBlockerDeferred.promise);
 
-      store.dispatch(Actions.shift(-1));
-      expect(store.getState().pathname).to.equal('/new');
+      navigationStack.shift(-1);
+      expect(navigationStack.current().pathname).to.equal('/new');
 
       navigationBlockerDeferred.resolve(true);
       await delay(10);
 
-      expect(store.getState().pathname).to.equal('/new');
+      expect(navigationStack.current().pathname).to.equal('/new');
     });
 
     // it('should show a confirmation dialog and allow navigation on string', () => {
@@ -97,33 +89,14 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
     //
     //   addNavigationBlocker(({ pathname }) => pathname);
     //
-    //   store.dispatch(Actions.shift(-1));
-    //   expect(store.getState().pathname).to.equal('/initial');
+    //   navigationStack.shift(-1));
+    //   expect(navigationStack.current().pathname).to.equal('/initial');
     //
     //   expect(window.confirm)
     //     .to.have.been.calledOnce()
     //     .and.to.have.been.called.with('/new');
     // });
 
-    it('should ignore the initial load when blocker returns `true`', () => {
-      // Get rid of the old store. We'll replace it with a new one.
-      store.dispatch(Actions.stop());
-
-      store = createStore(
-        internalLocationReducer,
-        applyMiddleware(
-          ...createMiddlewares(new InMemorySession(), {
-            _internalLocationReducer: true,
-          }),
-        ),
-      );
-      addNavigationBlocker(() => true);
-
-      expect(store.getState()).to.be.undefined();
-      store.dispatch(Actions.init('/initial'));
-      expect(store.getState().pathname).to.equal('/initial');
-    });
-
     it('should support async rewinding', async () => {
       // eslint-disable-next-line no-underscore-dangle
       if (session._subscription._listeners.length !== 2) {
@@ -152,7 +125,7 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
       const navigationBlockerDeferred = pDefer();
       addNavigationBlocker(() => navigationBlockerDeferred.promise);
 
-      store.dispatch(Actions.shift(-1));
+      navigationStack.shift(-1);
 
       // current location was updated immediately.
       // Any `.subscribe()` listeners haven't yet been called,
@@ -162,7 +135,7 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
       // eslint-disable-next-line no-underscore-dangle
       expect(session._subscription._latest.pathname).to.equal('/initial');
       // navigation is waiting.
-      expect(store.getState().pathname).to.equal('/new');
+      expect(navigationStack.current().pathname).to.equal('/new');
 
       // proceed with navigation.
       navigationDeferred.resolve();
@@ -172,7 +145,7 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
       // eslint-disable-next-line no-underscore-dangle
       expect(session._subscription._latest.pathname).to.equal('/new');
       // navigation almost finished: navigation blockers are running.
-      expect(store.getState().pathname).to.equal('/new');
+      expect(navigationStack.current().pathname).to.equal('/new');
 
       // finish navigation blockers.
       navigationBlockerDeferred.resolve(undefined);
@@ -187,7 +160,7 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
       expect(session._subscription._latest.pathname).to.equal('/initial');
       // navigation finished.
       // wasn't blocked.
-      expect(store.getState().pathname).to.equal('/initial');
+      expect(navigationStack.current().pathname).to.equal('/initial');
     });
 
     // it('should allow navigation without calling any blockers when `location.delta` is `null`', async () => {
@@ -211,7 +184,7 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
     //   // Without delta, we can't rewind the location change,
     //   // so navigation is allowed without calling any blockers.
     //   expect(currentNavigationLocation.pathname).to.equal('/initial');
-    //   expect(store.getState().pathname).to.equal('/initial');
+    //   expect(navigationStack.current().pathname).to.equal('/initial');
     // });
 
     // it('should allow navigation when blocker returns `undefined` and `location.delta` is `null`', async () => {
@@ -229,13 +202,13 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
     //
     //   // Without delta, we can't rewind on the session.
     //   expect(currentNavigationLocation.pathname).to.equal('/initial');
-    //   expect(store.getState().pathname).to.equal('/new');
+    //   expect(navigationStack.current().pathname).to.equal('/new');
     //
     //   navigationBlockerDeferred.resolve(undefined);
     //   await delay(10);
     //
     //   expect(currentNavigationLocation.pathname).to.equal('/initial');
-    //   expect(store.getState().pathname).to.equal('/initial');
+    //   expect(navigationStack.current().pathname).to.equal('/initial');
     // });
 
     // it('should block store update when blocker returns `true` and `location.delta` is `null`', async () => {
@@ -251,14 +224,29 @@ describe('createNonProgrammaticNavigationBlockerMiddleware', () => {
     //   /* eslint-enable no-underscore-dangle */
     //
     //   expect(session._navigation.getInitialLocation().pathname).to.equal('/initial');
-    //   expect(store.getState().pathname).to.equal('/new');
+    //   expect(navigationStack.current().pathname).to.equal('/new');
     //
     //   navigationBlockerDeferred.resolve(true);
     //   await delay(10);
     //
     //   // These are out-of-sync now, but it's the best we can do.
     //   expect(session._navigation.getInitialLocation().pathname).to.equal('/initial');
-    //   expect(store.getState().pathname).to.equal('/new');
+    //   expect(navigationStack.current().pathname).to.equal('/new');
     // });
   });
 });
+
+describe('NavigationStack (blockNonProgrammaticNavigationIfRequired) (init)', () => {
+  it('should allow the initial load even when a navigation blocker returns `true`', () => {
+    const navigationStack = new NavigationStack(InMemoryEnvironment);
+    // eslint-disable-next-line no-underscore-dangle
+    const session = navigationStack._session;
+    addNavigationBlockerOriginal(session, () => true);
+
+    // eslint-disable-next-line no-underscore-dangle
+    expect(navigationStack._location).to.be.undefined();
+    navigationStack.init('/initial');
+    // eslint-disable-next-line no-underscore-dangle
+    expect(navigationStack._location.pathname).to.equal('/initial');
+  });
+});