navigation-stack 0.5.2 → 0.6.0

package/lib/cjs/scroll-position/ScrollPositionRestoration.js

@@ -7,7 +7,6 @@ var _ScrollPositionSaver = _interopRequireDefault(require("./ScrollPositionSaver
 var _ScrollPositionSetter = _interopRequireDefault(require("./ScrollPositionSetter"));
 var _constants = require("./constants");
 var _LocationDataStorage = _interopRequireDefault(require("../data-storage/LocationDataStorage"));
-var _debug = _interopRequireDefault(require("../debug"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable no-underscore-dangle */
 
@@ -22,7 +21,7 @@ function areEqualScrollPositions(scrollPosition1, scrollPosition2) {
   return true;
 }
 class ScrollPositionRestoration {
-  constructor(session, _options) {
+  constructor(session, options) {
     // Once configured, scroll restoration mode persists across page reloads.
     // I.e. even if a user refreshes the page in a web browser, the custom
     // `window.history.scrollRestoration` value will still remain.
@@ -54,10 +53,10 @@ class ScrollPositionRestoration {
       running
     }) => {
       if (running) {
-        (0, _debug.default)('▶ running');
+        this._log.debug('▶ running');
         this._disableAutomaticScrollRestoration();
       } else {
-        (0, _debug.default)('⏹ not running');
+        this._log.debug('⏹ not running');
         this._enableAutomaticScrollRestoration();
 
         // There might be previous scroll position already saved in the data storage.
@@ -85,27 +84,30 @@ class ScrollPositionRestoration {
       try {
         this._scrollPosition.disableAutomaticScrollRestoration();
       } catch (error) {
-        // eslint-disable-next-line no-console
-        console.error('[navigation-stack] could not disable default scroll restoration mode');
+        this._log.error('[navigation-stack] could not disable default scroll restoration mode');
       }
     };
     this._enableAutomaticScrollRestoration = () => {
       try {
         this._scrollPosition.enableAutomaticScrollRestoration();
       } catch (error) {
-        // eslint-disable-next-line no-console
-        console.error('[navigation-stack] could not enable default scroll restoration mode');
+        this._log.error('[navigation-stack] could not enable default scroll restoration mode');
       }
     };
     this._saveScrollPositionForLocation = (location, scrollableContainerKey, scrollPosition) => {
       this._locationDataStorage.set(location, scrollableContainerKey || _constants.PAGE_SCROLLABLE_CONTAINER_KEY, scrollPosition);
     };
+    this._log = session.environment.log;
     this._scrollPosition = session.environment.scrollPosition;
-    this._sessionLifecycle = session.lifecycle;
+
+    // Custom `ScrollPositionSetter`.
+    this._scrollPositionSetter = options.scrollPositionSetter;
+    this._sessionLifecycle = session.environment.lifecycle;
     this._locationDataStorage = new _LocationDataStorage.default(session, {
-      namespace: 'navigation-stack/scroll-position'
+      namespace: 'navigation-stack-scroll-position'
     });
     this._scrollPositionSaver = new _ScrollPositionSaver.default({
+      log: this._log,
       scrollPosition: this._scrollPosition,
       saveScrollPositionForLocation: this._saveScrollPositionForLocation,
       getScrollableContainers: () => this._scrollableContainers,
@@ -127,20 +129,22 @@ class ScrollPositionRestoration {
       // Using this option, a developer could theoretically provide their own implementation
       // of setting a scroll position. For example, it could use "smooth" (animated) scrolling, etc.
       // This could be part of the public API if anyone provided a sensible real-world use case for it.
-      scrollPositionSetter: _options && _options._pageScrollPositionSetter ||
-      // The default page scroll position setter.
+      scrollPositionSetter: options && options._pageScrollPositionSetter ||
+      // eslint-disable-next-line new-cap
+      this._scrollPositionSetter && new this._scrollPositionSetter() ||
+      // A default `ScrollPositionSetter` for a page (sets page scroll position twice with a momentary delay).
       new _PageScrollPositionSetter.default(),
       // This function is only used in tests.
       // There seems to be no use of it in real life, hence it's not public API.
       // It's only used in tests.
-      _getSavedScrollPositionOnLocationChange: _options && _options._getSavedPageScrollPositionOnLocationChange,
+      _getSavedScrollPositionOnLocationChange: options && options._getSavedPageScrollPositionOnLocationChange,
       // This function is only used in tests.
       // There seems to be no use of it in real life, hence it's not public API.
       // It's only used in tests.
-      _shouldSetScrollPositionOnLocationChange: _options && _options._shouldSetPageScrollPositionOnLocationChange
+      shouldChangeScrollPositionOnLocationChange: options && options.shouldChangePageScrollPositionOnLocationChange
     };
   }
-  addScrollableContainer(scrollableContainerKey, scrollableContainer, _options) {
+  addScrollableContainer(scrollableContainerKey, scrollableContainer, options) {
     // Originally, `scrollableContainerKey` was auto-generated,
     // but then it didn't work with the concept of dynamically adding or removing
     // scrollable containers after `ScrollPositionRestoration` has already started.
@@ -157,7 +161,7 @@ class ScrollPositionRestoration {
     if (this._scrollableContainers[scrollableContainerKey]) {
       throw new Error(`Scrollable container key "${scrollableContainerKey}" is already added`);
     }
-    (0, _debug.default)('add scrollable container', scrollableContainerKey);
+    this._log.debug('add scrollable container', scrollableContainerKey);
 
     // Add scrollable container entry.
     this._scrollableContainers[scrollableContainerKey] = {
@@ -166,17 +170,17 @@ class ScrollPositionRestoration {
       // Using this option, a developer could theoretically provide their own implementation
       // of setting a scroll position. For example, it could use "smooth" (animated) scrolling, etc.
       // This could be part of the public API if anyone provided a sensible real-world use case for it.
-      scrollPositionSetter: _options && _options._scrollPositionSetter ||
+      scrollPositionSetter: options && options._scrollPositionSetter || this._scrollPositionSetter && new this._scrollPositionSetter() ||
       // The default basic "immediate" scroll position setter.
       new _ScrollPositionSetter.default(),
       // This function is only used in tests.
       // There seems to be no use of it in real life, hence it's not public API.
       // It's only used in tests.
-      _shouldSetScrollPositionOnLocationChange: _options && _options._shouldSetScrollPositionOnLocationChange,
+      shouldChangeScrollPositionOnLocationChange: options && options.shouldChangeScrollPositionOnLocationChange,
       // This function is only used in tests.
       // There seems to be no use of it in real life, hence it's not public API.
       // It's only used in tests.
-      _getSavedScrollPositionOnLocationChange: _options && _options._getSavedScrollPositionOnLocationChange
+      _getSavedScrollPositionOnLocationChange: options && options._getSavedScrollPositionOnLocationChange
     };
 
     // Scrollable containers could be added at any time, including page mount.
@@ -188,10 +192,10 @@ class ScrollPositionRestoration {
     if (this._location) {
       const previouslySavedScrollPosition = this._getSavedScrollPositionForLocation(this._location, scrollableContainerKey);
       if (previouslySavedScrollPosition) {
-        (0, _debug.default)('restore scroll position on add scrollable container', this._location.pathname, scrollableContainerKey, previouslySavedScrollPosition);
+        this._log.debug('restore scroll position on add scrollable container', this._location.pathname, scrollableContainerKey, previouslySavedScrollPosition);
         this._scrollPosition.setScrollableContainerScrollPosition(scrollableContainer, previouslySavedScrollPosition);
       } else {
-        (0, _debug.default)('save scroll position on add scrollable container', this._location.pathname, scrollableContainerKey);
+        this._log.debug('save scroll position on add scrollable container', this._location.pathname, scrollableContainerKey);
         this._scrollPositionSaver.saveScrollableContainerScrollPosition(scrollableContainerKey, scrollableContainer);
       }
     }
@@ -201,7 +205,7 @@ class ScrollPositionRestoration {
 
     // Removes the scrollable container.
     return () => {
-      (0, _debug.default)('remove scrollable container', scrollableContainerKey);
+      this._log.debug('remove scrollable container', scrollableContainerKey);
       this._scrollPositionSaver._scrollPositionAutoSaver.cancelSaveScrollableContainerScrollPosition(scrollableContainerKey);
       this._scrollPositionSaver._scrollPositionAutoSaver.removeScrollableContainerScrollListener(scrollableContainerKey);
       delete this._scrollableContainers[scrollableContainerKey];
@@ -273,7 +277,7 @@ class ScrollPositionRestoration {
     if (!location.key) {
       throw new Error('`location` must have a `key`');
     }
-    (0, _debug.default)('rendered location', location.pathname);
+    this._log.debug('rendered location', location.pathname);
     this._prevLocation = this._location;
     this._location = location;
     this._scrollPosition.init();
@@ -334,8 +338,8 @@ class ScrollPositionRestoration {
       // This function is only used in tests.
       // There seems to be no use of it in real life, hence it's not public API.
       // It's only used in tests.
-      if (scrollableContainerEntry._shouldSetScrollPositionOnLocationChange) {
-        if (!scrollableContainerEntry._shouldSetScrollPositionOnLocationChange(this._location, this._prevLocation)) {
+      if (scrollableContainerEntry.shouldChangeScrollPositionOnLocationChange) {
+        if (!scrollableContainerEntry.shouldChangeScrollPositionOnLocationChange(this._prevLocation, this._location)) {
           return Promise.resolve();
         }
       }
@@ -347,14 +351,14 @@ class ScrollPositionRestoration {
       // There seems to be no use of it in real life, hence it's not public API.
       // It's only used in tests.
       if (scrollableContainerEntry._getSavedScrollPositionOnLocationChange) {
-        scrollPositionOrAnchorToSet = scrollableContainerEntry._getSavedScrollPositionOnLocationChange(this._location, this._prevLocation);
+        scrollPositionOrAnchorToSet = scrollableContainerEntry._getSavedScrollPositionOnLocationChange(this._prevLocation, this._location);
       }
 
       // Get scroll position (or anchor) to set.
       if (!scrollPositionOrAnchorToSet) {
         scrollPositionOrAnchorToSet = scrollableContainerKey === _constants.PAGE_SCROLLABLE_CONTAINER_KEY ? this._getPageScrollPositionOrAnchorToSet(this._location) : this._getScrollableContainerScrollPositionToSet(this._location, scrollableContainerKey);
       }
-      (0, _debug.default)('restore scroll position', this._location.pathname, scrollableContainerKey, scrollPositionOrAnchorToSet);
+      this._log.debug('restore scroll position', this._location.pathname, scrollableContainerKey, scrollPositionOrAnchorToSet);
 
       // Set scroll position of scrollable container.
       return scrollableContainerEntry.scrollPositionSetter.set(scrollableContainerEntry.scrollableContainer, scrollPositionOrAnchorToSet, this._scrollPosition);

package/lib/cjs/scroll-position/ScrollPositionSaver.js

@@ -4,24 +4,26 @@ exports.__esModule = true;
 exports.default = void 0;
 var _ScrollPositionAutoSaver = _interopRequireDefault(require("./ScrollPositionAutoSaver"));
 var _constants = require("./constants");
-var _debug = _interopRequireDefault(require("../debug"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable no-underscore-dangle */
 
 class ScrollPositionSaver {
   constructor({
+    log,
     scrollPosition,
     getLocation,
     saveScrollPositionForLocation,
     getScrollableContainers,
     shouldSaveScrollPosition
   }) {
+    this._log = log;
     this._scrollPosition = scrollPosition;
     this._getLocation = getLocation;
     this._saveScrollPositionForLocation = saveScrollPositionForLocation;
     this._getScrollableContainers = getScrollableContainers;
     this._shouldSaveScrollPosition = shouldSaveScrollPosition;
     this._scrollPositionAutoSaver = new _ScrollPositionAutoSaver.default({
+      log: this._log,
       scrollPosition: this._scrollPosition,
       scrollPositionSaver: this,
       getScrollableContainers,
@@ -42,7 +44,7 @@ class ScrollPositionSaver {
     if (!this._shouldSaveScrollPosition()) {
       return;
     }
-    (0, _debug.default)('save scroll position', this._getLocation().pathname);
+    this._log.debug('save scroll position', this._getLocation().pathname);
 
     // Get scrollable containers.
     const scrollableContainers = this._getScrollableContainers();
@@ -57,7 +59,7 @@ class ScrollPositionSaver {
     }
   }
   savePageScrollPosition() {
-    (0, _debug.default)('save scroll position', this._getLocation().pathname, _constants.PAGE_SCROLLABLE_CONTAINER_KEY, this._scrollPosition.getPageScrollPosition());
+    this._log.debug('save scroll position', this._getLocation().pathname, _constants.PAGE_SCROLLABLE_CONTAINER_KEY, this._scrollPosition.getPageScrollPosition());
 
     // * If this is not a scheduled "auto-save" of scroll position
     //   and there already exists any scheduled "auto-save" of scroll position,
@@ -70,7 +72,7 @@ class ScrollPositionSaver {
     this._saveScrollPositionForLocation(this._getLocation(), undefined, this._scrollPosition.getPageScrollPosition());
   }
   saveScrollableContainerScrollPosition(scrollableContainerKey, scrollableContainer) {
-    (0, _debug.default)('save scroll position', this._getLocation().pathname, scrollableContainerKey, this._scrollPosition.getScrollableContainerScrollPosition(scrollableContainer));
+    this._log.debug('save scroll position', this._getLocation().pathname, scrollableContainerKey, this._scrollPosition.getScrollableContainerScrollPosition(scrollableContainer));
 
     // * If this is not a scheduled "auto-save" of scroll position
     //   and there already exists any scheduled "auto-save" of scroll position,

package/lib/cjs/session/Session.js

@@ -2,20 +2,17 @@
 
 exports.__esModule = true;
 exports.default = void 0;
-var _debug = _interopRequireDefault(require("../debug"));
 var _parseInputLocation = _interopRequireDefault(require("../parseInputLocation"));
 var _createSessionKey = _interopRequireDefault(require("./key/createSessionKey"));
-var _NavigationOutOfBoundsError = _interopRequireDefault(require("./navigation/error/NavigationOutOfBoundsError"));
-var _operations = _interopRequireDefault(require("./navigation/operation/operations"));
 var _Subscription = _interopRequireDefault(require("./subscription/Subscription"));
+var _NavigationOutOfBoundsError = _interopRequireDefault(require("../environment/navigation/error/NavigationOutOfBoundsError"));
+var _operations = _interopRequireDefault(require("../environment/navigation/operation/operations"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const INITIAL_KEY_INDEX = -1;
 const INITIAL_INDEX = -1;
 const INIT_LOCATION_DELTA = 0;
 class Session {
-  constructor({
-    navigation
-  }) {
+  constructor(EnvironmentClass) {
     // This function is used by navigation.
     this._getCurrentLocationIndex = () => {
       return this._currentLocationIndex;
@@ -25,6 +22,9 @@ class Session {
     // under the hood, and `window.sessionStorage` is shared between different sessions.
     this.key = (0, _createSessionKey.default)();
 
+    // Create an environment instance.
+    this.environment = new EnvironmentClass();
+
     // `this._locationKeyIndex` is incremented every time the current location changes.
     this._locationKeyIndex = INITIAL_KEY_INDEX;
 
@@ -36,18 +36,34 @@ 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.default();
 
-    // Manages subscriptions.
-    this._subscription = new _Subscription.default({
-      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.
@@ -57,16 +73,20 @@ class Session {
       // but if it was possible, this call would be required. It would also be required
       // by `navigation` to call `session.getNextKey()` function to increment `locationKeyIndex`.
       this._updateTerminalLocationIndex(location);
-      (0, _debug.default)('current location', location.pathname, 'index', this._currentLocationIndex);
+      this.environment.log.debug('current location', location.pathname, 'index', this._currentLocationIndex);
     });
   }
 
   // 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 !== _operations.default.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.
@@ -74,6 +94,18 @@ 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');
@@ -86,7 +118,7 @@ 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 = (0, _parseInputLocation.default)(initialLocation);
       }
@@ -97,18 +129,19 @@ class Session {
     if (this._currentLocationIndex !== INITIAL_INDEX) {
       throw new Error('Already started');
     }
-    (0, _debug.default)('▶ start session', initialLocation.pathname);
+    this.environment.log.debug('▶ start session', initialLocation.pathname);
     this._started = true;
     const key = this._getNextLocationKey();
     const index = INITIAL_INDEX + 1;
     const delta = INIT_LOCATION_DELTA;
-    const locationResult = this._navigation.init(initialLocation, {
+    const locationResult = this.environment.navigation.init(initialLocation, {
       operation: _operations.default.INIT,
       key,
       index,
       delta
     });
     if (locationResult) {
+      // Notify all subscribers about this "synchronous" location change.
       this._subscription.notifySubscribers(locationResult);
     }
   }
@@ -116,7 +149,7 @@ class Session {
     if (this._stopped) {
       throw Error('Already stopped');
     }
-    (0, _debug.default)('⏹ stop session');
+    this.environment.log.debug('⏹ stop session');
 
     // Once stopped, it won't be able to be restarted.
     this._stopped = true;
@@ -142,16 +175,17 @@ class Session {
     });
     const key = this._getNextLocationKey();
     const index = this._currentLocationIndex + delta;
-    (0, _debug.default)(operation === _operations.default.PUSH ? '↓' : '⇅', operation, location.pathname, 'index', index);
+    this.environment.log.debug(operation === _operations.default.PUSH ? '↓' : '⇅', operation, location.pathname, 'index', index);
 
     // Navigate to the location.
-    const locationResult = this._navigation.navigate(location, {
+    const locationResult = this.environment.navigation.navigate(location, {
       operation,
       key,
       index,
       delta
     });
     if (locationResult) {
+      // Notify all subscribers about this "synchronous" location change.
       this._subscription.notifySubscribers(locationResult);
     }
   }
@@ -165,7 +199,7 @@ class Session {
       return;
     }
     const index = this._currentLocationIndex + delta;
-    (0, _debug.default)(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) {
@@ -173,12 +207,13 @@ class Session {
     }
 
     // Navigate to the location.
-    const locationResult = this._navigation.shift({
+    const locationResult = this.environment.navigation.shift({
       operation: _operations.default.SHIFT,
       index,
       delta
     });
     if (locationResult) {
+      // Notify all subscribers about this "synchronous" location change.
       this._subscription.notifySubscribers(locationResult);
     }
   }

package/lib/cjs/session/subscription/Subscription.js

@@ -3,22 +3,34 @@
 exports.__esModule = true;
 exports.default = void 0;
 class Subscription {
-  constructor({
-    activateSubscription
-  } = {}) {
-    this.notifySubscribers = argument => {
-      // `._latest` is only used in tests.
-      this._latest = argument;
-      for (const {
-        listener
-      } of this._listeners) {
-        listener(argument);
-      }
-    };
-    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 = [];
+  }
+
+  // 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,
@@ -38,7 +50,9 @@ 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.
@@ -70,10 +84,14 @@ 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/lib/cjs/stringifyQuery.js

@@ -0,0 +1,66 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = stringifyQuery;
+// "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()}`);
+}
+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;
+}
+module.exports = exports.default;

package/lib/cjs/stringifyQueryAsSearch.js

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = stringifyQueryAsSearch;
+var _stringifyQuery = _interopRequireDefault(require("./stringifyQuery"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function stringifyQueryAsSearch(query) {
+  const queryString = (0, _stringifyQuery.default)(query);
+  if (queryString) {
+    return `?${queryString}`;
+  }
+  return '';
+}
+module.exports = exports.default;