navigation-stack 0.5.3 → 0.6.0

package/lib/cjs/index.js

@@ -1,7 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.removeBasePath = exports.parseLocationUrl = exports.parseInputLocation = exports.getLocationUrl = exports.addNavigationBlocker = exports.addBasePath = exports.WebBrowserSession = exports.Session = exports.ServerSideRenderSession = exports.ServerSideNavigationError = exports.NavigationStack = exports.NavigationOutOfBoundsError = exports.LocationDataStorage = exports.InMemorySession = exports.DataStorage = void 0;
+exports.removeBasePath = exports.parseLocationUrl = exports.parseInputLocation = exports.getLocationUrl = exports.addNavigationBlocker = exports.addBasePath = exports.WebBrowserEnvironment = exports.ServerSideRenderEnvironment = exports.ServerSideRedirectError = exports.NavigationStack = exports.NavigationOutOfBoundsError = exports.InMemoryEnvironment = void 0;
 var _basePath = require("./basePath");
 exports.addBasePath = _basePath.addBasePath;
 exports.removeBasePath = _basePath.removeBasePath;
@@ -15,20 +15,14 @@ var _parseInputLocation = _interopRequireDefault(require("./parseInputLocation")
 exports.parseInputLocation = _parseInputLocation.default;
 var _NavigationStack = _interopRequireDefault(require("./NavigationStack"));
 exports.NavigationStack = _NavigationStack.default;
-var _DataStorage = _interopRequireDefault(require("./data-storage/DataStorage"));
-exports.DataStorage = _DataStorage.default;
-var _LocationDataStorage = _interopRequireDefault(require("./data-storage/LocationDataStorage"));
-exports.LocationDataStorage = _LocationDataStorage.default;
-var _Session = _interopRequireDefault(require("./session/Session"));
-exports.Session = _Session.default;
-var _InMemorySession = _interopRequireDefault(require("./session/InMemorySession"));
-exports.InMemorySession = _InMemorySession.default;
-var _WebBrowserSession = _interopRequireDefault(require("./session/WebBrowserSession"));
-exports.WebBrowserSession = _WebBrowserSession.default;
-var _ServerSideRenderSession = _interopRequireDefault(require("./session/ServerSideRenderSession"));
-exports.ServerSideRenderSession = _ServerSideRenderSession.default;
-var _ServerSideNavigationError = _interopRequireDefault(require("./session/navigation/error/ServerSideNavigationError"));
-exports.ServerSideNavigationError = _ServerSideNavigationError.default;
-var _NavigationOutOfBoundsError = _interopRequireDefault(require("./session/navigation/error/NavigationOutOfBoundsError"));
+var _InMemoryEnvironment = _interopRequireDefault(require("./environment/InMemoryEnvironment"));
+exports.InMemoryEnvironment = _InMemoryEnvironment.default;
+var _WebBrowserEnvironment = _interopRequireDefault(require("./environment/WebBrowserEnvironment"));
+exports.WebBrowserEnvironment = _WebBrowserEnvironment.default;
+var _ServerSideRenderEnvironment = _interopRequireDefault(require("./environment/ServerSideRenderEnvironment"));
+exports.ServerSideRenderEnvironment = _ServerSideRenderEnvironment.default;
+var _ServerSideRedirectError = _interopRequireDefault(require("./environment/navigation/error/ServerSideRedirectError"));
+exports.ServerSideRedirectError = _ServerSideRedirectError.default;
+var _NavigationOutOfBoundsError = _interopRequireDefault(require("./environment/navigation/error/NavigationOutOfBoundsError"));
 exports.NavigationOutOfBoundsError = _NavigationOutOfBoundsError.default;
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/cjs/navigationBlockers.js

@@ -5,58 +5,55 @@ exports.addNavigationBlocker = addNavigationBlocker;
 exports.getNavigationBlockers = getNavigationBlockers;
 exports.removeAllNavigationBlockers = removeAllNavigationBlockers;
 exports.runNavigationBlockers = runNavigationBlockers;
-var _debug = _interopRequireDefault(require("./debug"));
 var _isPromise = _interopRequireDefault(require("./isPromise"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable no-underscore-dangle */
 
-function getNavigationBlockers(session) {
-  return session._navigationBlockersList || [];
+function getNavigationBlockers(container) {
+  return container._navigationBlockersList || [];
 }
-function addNavigationBlockerToTheList(blocker, session) {
-  if (!session._navigationBlockersList) {
-    session._navigationBlockersList = [];
+function addNavigationBlockerToTheList(blocker, container) {
+  if (!container._navigationBlockersList) {
+    container._navigationBlockersList = [];
   }
-  session._navigationBlockersList.push(blocker);
+  container._navigationBlockersList.push(blocker);
 }
-function removeNavigationBlockerFromTheList(blocker, session) {
-  if (session._navigationBlockersList) {
-    session._navigationBlockersList = session._navigationBlockersList.filter(_ => _ !== blocker);
+function removeNavigationBlockerFromTheList(blocker, container) {
+  if (container._navigationBlockersList) {
+    container._navigationBlockersList = container._navigationBlockersList.filter(_ => _ !== blocker);
   }
 }
 function removeAllNavigationBlockers(session) {
-  if (getNavigationBlockers(session).some(blocker => blocker.beforeTermination)) {
+  // `navigationBlockers` are stored in `session`.
+  const container = session;
+  if (getNavigationBlockers(container).some(blocker => blocker.beforeTermination)) {
     if (!session._removeTerminationBlocker) {
       throw new Error('`_removeTerminationBlocker` property not found in the `session`');
     }
     session._removeTerminationBlocker();
     session._removeTerminationBlocker = undefined;
   }
-  session._navigationBlockersList = [];
+  container._navigationBlockersList = [];
 }
 
 // Runs the `blocker` while ignoring any errors that might be thrown by it.
 function runNavigationBlocker({
   blocker
-}, location) {
+}, location, environment) {
   let result;
   try {
     result = blocker(location);
   } catch (error) {
-    // eslint-disable-next-line no-console
-    console.warn(`Ignoring navigation blocker \`${blocker.name}\` that failed with \`${error}\`.`);
-    // eslint-disable-next-line no-console
-    console.error(error);
+    environment.log.warn(`Ignoring navigation blocker \`${blocker.name}\` that failed with \`${error}\`.`);
+    environment.log.error(error);
   }
 
   // If the blocker returned a `Promise`, await for that `Promise`
   // and then return the result.
   if ((0, _isPromise.default)(result)) {
     return result.catch(error => {
-      // eslint-disable-next-line no-console
-      console.warn(`Ignoring navigation blocker \`${blocker.name}\` that failed with \`${error}\`.`);
-      // eslint-disable-next-line no-console
-      console.error(error);
+      environment.log.warn(`Ignoring navigation blocker \`${blocker.name}\` that failed with \`${error}\`.`);
+      environment.log.error(error);
     });
   }
   // The blocker didn't return a `Promise`.
@@ -67,28 +64,28 @@ function runNavigationBlocker({
 // Runs all blockers in order.
 // If any blocker returns `true`, it stops and returns the result.
 // If there's no such blocker, returns `undefined`.
-function runNavigationBlockers(navigationBlockers, toLocation) {
+function runNavigationBlockers(navigationBlockers, toLocation, environment) {
   if (navigationBlockers.length === 0) {
     return undefined;
   }
 
   // Call the first blocker in the list.
-  const result = runNavigationBlocker(navigationBlockers[0], toLocation);
+  const result = runNavigationBlocker(navigationBlockers[0], toLocation, environment);
   const next = () => {
     // Proceed to the next blocker.
-    return runNavigationBlockers(navigationBlockers.slice(1), toLocation);
+    return runNavigationBlockers(navigationBlockers.slice(1), toLocation, environment);
   };
   if ((0, _isPromise.default)(result)) {
     return result.then(resultValue => {
       if (resultValue) {
-        (0, _debug.default)('Navigation blocked', toLocation.pathname);
+        environment.log.debug('Navigation blocked', toLocation.pathname);
         return resultValue;
       }
       return next();
     });
   }
   if (result) {
-    (0, _debug.default)('Navigation blocked', toLocation.pathname);
+    environment.log.debug('Navigation blocked', toLocation.pathname);
     return result;
   }
   return next();
@@ -96,7 +93,9 @@ function runNavigationBlockers(navigationBlockers, toLocation) {
 
 /* istanbul ignore next: not testable with Karma */
 function terminationBlocker(session) {
-  const result = runNavigationBlockers(getNavigationBlockers(session), null);
+  // `navigationBlockers` are stored in `session`.
+  const container = session;
+  const result = runNavigationBlockers(getNavigationBlockers(container), null, session.environment);
 
   // If no blocker returned anything, so don't prevent the navigation.
   if (!result) {
@@ -115,6 +114,9 @@ function terminationBlocker(session) {
   return true;
 }
 function addNavigationBlocker(session, blocker) {
+  // `navigationBlockers` are stored in `session`.
+  const container = session;
+
   // All navigation blockers also run on `beforeTermination` event.
   // If required, this could be a parameter of this function.
   // The rationale could be that adding a `beforeunload` listener
@@ -131,11 +133,11 @@ function addNavigationBlocker(session, blocker) {
   //  and this is bad for performance."
   //
   // https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
-  if (beforeTermination && !getNavigationBlockers(session).some(navigationBlocker => navigationBlocker.beforeTermination)) {
+  if (beforeTermination && !getNavigationBlockers(container).some(navigationBlocker => navigationBlocker.beforeTermination)) {
     if (session._removeTerminationBlocker) {
       throw new Error('Unexpected `_removeTerminationBlocker` property found in the `session`');
     }
-    session._removeTerminationBlocker = session.lifecycle.addTerminationBlocker(() => {
+    session._removeTerminationBlocker = session.environment.lifecycle.addTerminationBlocker(() => {
       return terminationBlocker(session);
     });
   }
@@ -143,12 +145,12 @@ function addNavigationBlocker(session, blocker) {
     blocker,
     beforeTermination
   };
-  addNavigationBlockerToTheList(newNavigationBlocker, session);
+  addNavigationBlockerToTheList(newNavigationBlocker, container);
   return () => {
-    removeNavigationBlockerFromTheList(newNavigationBlocker, session);
+    removeNavigationBlockerFromTheList(newNavigationBlocker, container);
 
     // If it was the last "beforeTermination" blocker, remove navigation blocker.
-    if (beforeTermination && !getNavigationBlockers(session).some(navigationBlocker => navigationBlocker.beforeTermination)) {
+    if (beforeTermination && !getNavigationBlockers(container).some(navigationBlocker => navigationBlocker.beforeTermination)) {
       if (!session._removeTerminationBlocker) {
         throw new Error('`_removeTerminationBlocker` property not found in the `session`');
       }

package/lib/cjs/navigationBlockersEvaluation.js

@@ -0,0 +1,150 @@
+"use strict";
+
+exports.__esModule = true;
+exports.blockNonProgrammaticNavigationIfRequired = blockNonProgrammaticNavigationIfRequired;
+exports.blockProgrammaticNavigationIfRequired = blockProgrammaticNavigationIfRequired;
+var _getLocationBaseFromLocation = _interopRequireDefault(require("./getLocationBaseFromLocation"));
+var _getLocationFromInternalLocation = _interopRequireDefault(require("./getLocationFromInternalLocation"));
+var _isPromise = _interopRequireDefault(require("./isPromise"));
+var _navigationBlockers = require("./navigationBlockers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Creates "navigation blockers evaluation" status object.
+// It tracks the "cancelled" status of the evaluation:
+// when next navigation happens, the previous one is no longer relevant
+// so the evaluation of navigation blockers for it can be cancelled.
+function createNavigationBlockersEvaluationStatus(container) {
+  /* eslint-disable no-underscore-dangle */
+  if (container._navigationBlockersEvaluationStatus) {
+    container._navigationBlockersEvaluationStatus.cancelled = true;
+  }
+  container._navigationBlockersEvaluationStatus = {
+    cancelled: false
+  };
+  return container._navigationBlockersEvaluationStatus;
+}
+
+// Prevents or allows navigation that was initiated by the application code
+// by making a `.push()` or `.replace()` method call.
+//
+// It doesn't handle `.shift()` method calls because it doesn't yet know
+// the `location` that it's gonna `shift` to. Instead, it waits for the web browser
+// to "shift" to that `location` and then reads the `location` from the address bar
+// and, if such "shift" should've been blocked, it "rewinds" the address bar back
+// to the previous location. This part is handled by another function.
+//
+// Such type of "shifting" and then rewinding the "shift" doesn't really matter to the application code at all.
+// From the application code's point of view, all web browser's address bar doesn't matter and even doesn't exist.
+// All that exists from the application code's point of view is the `location` object in the `NavigationStack`'s state.
+// Until the `location` object in the `NavigationStack`'s state is updated, the "old" page is still rendered.
+// The appliation is only concerned with the updates of the `location` object in the `NavigationStack`'s state
+// and completely ignores any updates to the URL in the web browser's address bar.
+//
+function blockProgrammaticNavigationIfRequired(toLocationBase,
+// `location` of type `LocationBase`
+session) {
+  // `resultValue` variable name works around a stupid javascript error:
+  // "Cannot redeclare block-scoped variable 'result'".
+  const result = (0, _navigationBlockers.runNavigationBlockers)((0, _navigationBlockers.getNavigationBlockers)(session),
+  // Here `payload.location` is `LocationBase`.
+  toLocationBase, session.environment);
+  if ((0, _isPromise.default)(result)) {
+    const evaluationStatus = createNavigationBlockersEvaluationStatus(session);
+    // eslint-disable-next-line consistent-return
+    return result.then(promiseResult => {
+      if (evaluationStatus.cancelled) {
+        return true;
+      }
+      return promiseResult;
+    });
+  }
+  return result;
+}
+
+// Runs navigation blockers on internal location update and "undoes" the location update
+// if it should've been blocked.
+//
+// One could ask: Why the hassle of running navigation blockers on internal location update
+// and then rewinding back if the location change should've been blocked?
+// Why not just run navigation blockers on `.push()`/`.replace()`/`.shift()`?
+//
+// The reason why it runs on internal location update here is because
+// aside from programmatic `.shift()` that can be initiated from the application code,
+// there's non-programmatic "shift" navigation when the user manually clicks "Back" or "Forward" button
+// in a web browser. And even if a "shift" navigation is initiated programmatically in the application code,
+// it still doesn't know yet what the new location is gonna be cause it only knows the numeric `delta`.
+// Such cases could only be handled by reacting to internal location updates which,
+// in case of "Back"/"Forward", only happen after the URL in the browser's address bar has changed.
+//
+// There's no real drawback in reacting to an internal location update "post factum" because
+// from the application code's point of view, web browser's address bar doesn't matter and even doesn't exist.
+// All that exists from the application code's point of view is the `navigationStack.current` location
+// returned from  the `NavigationStack`. Until that location is updated, the "old" page is still rendered.
+// The appliation is only concerned with the updates of the internal `location` object in the `NavigationStack``
+// and completely ignores any updates to the URL in the web browser's address bar.
+//
+// So here, the code attempts to prevent or allow navigation that has already happened
+// in the web browser's address bar but hasn't yet happened in the `NavigationStack`'s state.
+// For example, it could be a user clicking a "Back"/"Forward" button in a web browser.
+// If such navigation should've been blocked, it will simply not update the `location` object
+// in the `NavigationStack`'s state, and it will also "rewind" the change of the URL in the web browser's
+// address bar so that it's consistent with the `location` in the `NavigationStack`'s state.
+//
+// Returns either a `boolean` value or a `Promise` that resolves to a `boolean` value:
+// * `false` when navigation should not have been blocked and therefore was not "rewinded".
+// * `true` when navigation should have been blocked and therefore was "rewinded".
+// * `true` when it "rewinded" the navigation "just in case" and then started evaluating async blockers,
+//   but while doing that, next navigation already happened so this one is no longer relevant.
+//
+function blockNonProgrammaticNavigationIfRequired(toLocationInternal,
+// `location` of type `LocationInternal`
+session, doAndIgnoreLocationUpdates) {
+  // If there're no navigation blockers to run, don't do anything.
+  if ((0, _navigationBlockers.getNavigationBlockers)(session).length === 0) {
+    return false;
+  }
+
+  // If it was the initial page load or a redirect,
+  // it's not really a navigation that could be rolled back.
+  if (toLocationInternal.delta === 0) {
+    return false;
+  }
+  const result = (0, _navigationBlockers.runNavigationBlockers)((0, _navigationBlockers.getNavigationBlockers)(session), (0, _getLocationBaseFromLocation.default)((0, _getLocationFromInternalLocation.default)(toLocationInternal)), session.environment);
+
+  // If some navigation blocker returned a `Promise`.
+  if ((0, _isPromise.default)(result)) {
+    const evaluationStatus = createNavigationBlockersEvaluationStatus(session);
+
+    // While location blockers are running, rewind to the previous location.
+    doAndIgnoreLocationUpdates(() => {
+      session.shift(-toLocationInternal.delta);
+    });
+    return result.then(promiseResult => {
+      if (evaluationStatus.cancelled) {
+        return true;
+      }
+      if (promiseResult) {
+        // Navigation blocked.
+        // Already rewound to a previous location.
+        return true;
+      }
+      // Navigation not blocked.
+      // Rewind back to the new location.
+      doAndIgnoreLocationUpdates(() => {
+        session.shift(toLocationInternal.delta);
+      });
+      // Update the location.
+      return false;
+    });
+  }
+
+  // Navigation blockers did not return a `Promise`.
+  if (result) {
+    // Prevent the navigation: rewind to the previous location.
+    doAndIgnoreLocationUpdates(() => {
+      session.shift(-toLocationInternal.delta);
+    });
+    return true;
+  }
+  // Update the location.
+  return false;
+}

package/lib/cjs/parseInputLocation.js

@@ -2,9 +2,9 @@
 
 exports.__esModule = true;
 exports.default = parseInputLocation;
-var _createSearchFromQuery = _interopRequireDefault(require("./createSearchFromQuery"));
 var _parseLocationUrl = _interopRequireDefault(require("./parseLocationUrl"));
 var _parseQueryFromSearch = _interopRequireDefault(require("./parseQueryFromSearch"));
+var _stringifyQueryAsSearch = _interopRequireDefault(require("./stringifyQueryAsSearch"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function stringifyQueryParameterValue(value) {
   if (value === null || value === undefined) {
@@ -45,7 +45,7 @@ function parseInputLocation(location) {
   // if `query` is present but `search` is not.
   if (location.query && !location.search) {
     location = Object.assign({}, location, {
-      search: (0, _createSearchFromQuery.default)(location.query)
+      search: (0, _stringifyQueryAsSearch.default)(location.query)
     });
   }
 

package/lib/cjs/parseQueryFromSearch.js

@@ -2,14 +2,11 @@
 
 exports.__esModule = true;
 exports.default = parseQueryFromSearch;
-var _queryString = require("query-string");
+var _parseQueryString = _interopRequireDefault(require("./parseQueryString"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function parseQueryFromSearch(search) {
   if (search.length > '?'.length) {
-    try {
-      return (0, _queryString.parse)(search.slice(1));
-    } catch (error) {
-      // Ignore any query parsing errors.
-    }
+    return (0, _parseQueryString.default)(search.slice('?'.length));
   }
   return {};
 }

package/lib/cjs/parseQueryString.js

@@ -0,0 +1,77 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = parseQueryString;
+function splitAtFirstOccurence(string, separator) {
+  const separatorIndex = string.indexOf(separator);
+  if (separatorIndex === -1) {
+    return [string, ''];
+  }
+  return [string.slice(0, separatorIndex), string.slice(separatorIndex + separator.length)];
+}
+function decode(value) {
+  // There's a convention that a space character could be encoded
+  // either as "%20" or as "+". Both of them are valid.
+  // The "+" character is unusally preferred because it results in a more
+  // human-readable URL.
+  //
+  // https://dev.to/lico/understanding-how-spaces-are-encoded-20-with-encodeuri-vs-with-url-2d6c
+  // https://developer.mozilla.org/en-US/docs/Glossary/Percent-encoding
+  //
+  // Those "+" characters don't get transformed to spaces by `decodeURIComponent()` function.
+  // This means that they should be transformed to spaces manually.
+  //
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#decoding_query_parameters_from_a_url
+  //
+  value = value.replaceAll('+', ' ');
+
+  // `decodeURIComponent()` could throw an error of class `URIError`.
+  //
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError
+  //
+  // Example: "URIError: malformed URI sequence".
+  try {
+    return decodeURIComponent(value);
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error(error);
+    return value;
+  }
+}
+function parseQueryString(queryString) {
+  // Create an object with no prototype
+  const query = Object.create(null);
+
+  // query parameter parsing is described in the specification:
+  // https://url.spec.whatwg.org/#urlencoded-parsing
+  for (const keyValuePair of queryString.split('&')) {
+    if (!keyValuePair) {
+      continue;
+    }
+    let [key, value] = splitAtFirstOccurence(keyValuePair, '=');
+
+    // If `key` is empty, the specification considers this a valid case with `key: null`.
+    // But, there seems to be no practical use for a query parameter with `key: null`.
+    // So just skip it.
+    if (!key) {
+      continue;
+    }
+    key = decode(key);
+
+    // According to the specification, missing `=` should be treated as `value: null`.
+    if (value === '') {
+      value = null;
+    } else {
+      value = decode(value);
+    }
+
+    // The handling of duplicate URL query parameters is not explicitly defined by a single,
+    // universally enforced specification. Hence, we just assume such query parameters invalid
+    // and only include the first occurrence of the query parameter in the query string.
+    if (query[key] === undefined) {
+      query[key] = value;
+    }
+  }
+  return query;
+}
+module.exports = exports.default;

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

@@ -4,17 +4,18 @@ exports.__esModule = true;
 exports.default = void 0;
 var _constants = require("./constants");
 var _scheduleNextTick = _interopRequireDefault(require("./scheduleNextTick"));
-var _debug = _interopRequireDefault(require("../debug"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable no-underscore-dangle */
 
 class ScrollPositionAutoSaver {
   constructor({
+    log,
     scrollPosition,
     scrollPositionSaver,
     getScrollableContainers,
     shouldSaveScrollPosition
   }) {
+    this._log = log;
     this._scrollPosition = scrollPosition;
     this._scrollPositionSaver = scrollPositionSaver;
     this._shouldSaveScrollPosition = shouldSaveScrollPosition;
@@ -66,7 +67,7 @@ class ScrollPositionAutoSaver {
   cancelSavePageScrollPosition(hasRun) {
     if (this._cancelSavePageScrollPosition) {
       if (!hasRun) {
-        (0, _debug.default)('cancel delayed save scroll position', _constants.PAGE_SCROLLABLE_CONTAINER_KEY);
+        this._log.debug('cancel delayed save scroll position', _constants.PAGE_SCROLLABLE_CONTAINER_KEY);
       }
       this._cancelSavePageScrollPosition();
       this._cancelSavePageScrollPosition = null;
@@ -76,7 +77,7 @@ class ScrollPositionAutoSaver {
     const scrollableContainerEntry = this._getScrollableContainers()[scrollableContainerKey];
     if (scrollableContainerEntry.cancelSaveScrollPosition) {
       if (!hasRun) {
-        (0, _debug.default)('cancel delayed save scroll position', scrollableContainerKey);
+        this._log.debug('cancel delayed save scroll position', scrollableContainerKey);
       }
       scrollableContainerEntry.cancelSaveScrollPosition();
       scrollableContainerEntry.cancelSaveScrollPosition = null;
@@ -108,9 +109,9 @@ class ScrollPositionAutoSaver {
       // because there might be too many in a given short period of time
       // which could affect the performance of the application.
       if (!scrollableContainerEntry.cancelSaveScrollPosition) {
-        (0, _debug.default)('scroll detected', scrollableContainerKey);
+        this._log.debug('scroll detected', scrollableContainerKey);
         scrollableContainerEntry.cancelSaveScrollPosition = (0, _scheduleNextTick.default)(() => {
-          (0, _debug.default)('auto-save scroll position after scroll', scrollableContainerKey);
+          this._log.debug('auto-save scroll position after scroll', scrollableContainerKey);
           this._scrollPositionSaver.saveScrollableContainerScrollPosition(scrollableContainerKey, scrollableContainerEntry.scrollableContainer);
         });
       }
@@ -119,7 +120,7 @@ class ScrollPositionAutoSaver {
   addPageScrollListener() {
     // Set up scroll listener on the page.
     this._removePageScrollListener = this._scrollPosition.addPageScrollListener(() => {
-      (0, _debug.default)('scroll detected', _constants.PAGE_SCROLLABLE_CONTAINER_KEY);
+      this._log.debug('scroll detected', _constants.PAGE_SCROLLABLE_CONTAINER_KEY);
 
       // This flag is not used in real life and is only used in tests (for some reason).
       if (!this._shouldSaveScrollPosition()) {