@angular-wave/angular.ts 0.7.8 → 0.8.0

package/src/services/location/location.js

@@ -1,7 +1,6 @@
 import { trimEmptyHash, urlResolve } from "../../shared/url-utils/url-utils.js";
 import {
   encodeUriSegment,
-  isBoolean,
   isDefined,
   isNumber,
   isObject,
@@ -9,263 +8,161 @@ import {
   isUndefined,
   minErr,
   parseKeyValue,
-  toInt,
   toKeyValue,
   equals,
+  startsWith,
 } from "../../shared/utils.js";
 import { getBaseHref } from "../../shared/dom.js";
+import { $injectTokens as $t } from "../../injection-tokens.js";
+
+const PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/;
+const $locationMinErr = minErr("$location");
+
+let urlUpdatedByLocation = false;
 
 /**
- * @typedef {Object} DefaultPorts
- * @property {number} http
- * @property {number} https
- * @property {number} ftp
+ * @ignore
+ * The pathname, beginning with "/"
+ * @type {string}
  */
+let $$path;
 
 /**
- * Represents the configuration options for HTML5 mode.
- *
- * @typedef {Object} Html5Mode
- * @property {boolean} enabled - (default: false) If true, will rely on `history.pushState` to
- *     change URLs where supported. Falls back to hash-prefixed paths in browsers that do not
- *     support `pushState`.
- * @property {boolean} requireBase - (default: `true`) When html5Mode is enabled, specifies
- *     whether or not a `<base>` tag is required to be present. If both `enabled` and `requireBase`
- *     are true, and a `<base>` tag is not present, an error will be thrown when `$location` is injected.
- *     See the {@link guide/$location $location guide} for more information.
- * @property {boolean|string} rewriteLinks - (default: `true`) When html5Mode is enabled, enables or
- *     disables URL rewriting for relative links. If set to a string, URL rewriting will only apply to links
- *     with an attribute that matches the given string. For example, if set to `'internal-link'`, URL rewriting
- *     will only occur for `<a internal-link>` links. Note that [attribute name normalization](guide/directive#normalization)
- *     does not apply here, so `'internalLink'` will **not** match `'internal-link'`.
+ * @type {Object.<string,boolean|Array>}
  */
-
-/** @type {DefaultPorts} */
-const DEFAULT_PORTS = { http: 80, https: 443, ftp: 21 };
-const PATH_MATCH = /^([^?#]*)(\?([^#]*))?(#(.*))?$/;
-const $locationMinErr = minErr("$location");
+let $$search;
 
 /**
- * @abstract
+ * @ignore
+ * The hash string, minus the hash symbol
+ * @type {string}
  */
+let $$hash;
+
 export class Location {
   /**
    * @param {string} appBase application base URL
    * @param {string} appBaseNoFile application base URL stripped of any filename
+   * @param {boolean} [html5] Defaults to true
+   * @param {string} [prefix] URL path prefix for html5 mode or hash prefix for hashbang mode
    */
-  constructor(appBase, appBaseNoFile) {
-    const parsedUrl = urlResolve(appBase);
-
+  constructor(appBase, appBaseNoFile, html5 = true, prefix) {
     /** @type {string} */
     this.appBase = appBase;
 
     /** @type {string} */
     this.appBaseNoFile = appBaseNoFile;
 
-    /**
-     * An absolute URL is the full URL, including protocol (http/https ), the optional subdomain (e.g. www ), domain (example.com), and path (which includes the directory and slug).
-     * @type {string}
-     */
-    this.$$absUrl = "";
+    /** @type {boolean} */
+    this.html5 = html5;
 
-    /**
-     * If html5 mode is enabled
-     * @type {boolean}
-     */
-    this.$$html5 = false;
+    /** @type {string | undefined} */
+    this.basePrefix = html5 ? prefix || "" : undefined;
 
-    /**
-     * Has any change been replacing?
-     * @type {boolean}
-     */
-    this.$$replace = false;
-
-    /** @type {string} */
-    this.$$protocol = parsedUrl.protocol;
-
-    /** @type {string} */
-    this.$$host = parsedUrl.hostname;
-
-    /**
-     * The port, without ":"
-     * @type {number}
-     */
-    this.$$port =
-      toInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
+    /** @type {string | undefined} */
+    this.hashPrefix = html5 ? undefined : prefix;
 
     /**
-     * The pathname, beginning with "/"
+     * An absolute URL is the full URL, including protocol (http/https ), the optional subdomain (e.g. www ), domain (example.com), and path (which includes the directory and slug)
+     * with all segments encoded according to rules specified in [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
      * @type {string}
      */
-    this.$$path = undefined;
+    this.absUrl = "";
 
     /**
-     * The hash string, minus the hash symbol
+     * @ignore
+     * Current url
      * @type {string}
      */
-    this.$$hash = undefined;
+    this.$$url = undefined;
 
     /**
-     * Helper property for scope watch changes
-     * @type {boolean}
+     * @ignore
+     * Callback to update browser url
+     * @type {Function}
      */
-    this.$$urlUpdatedByLocation = false;
+    this.$$updateBrowser = undefined;
   }
 
   /**
-   * Return full URL representation with all segments encoded according to rules specified in
-   * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
-   *
-   * @return {string} full URL
-   */
-  absUrl() {
-    return this.$$absUrl;
-  }
-
-  /**
-   * This method is getter / setter.
-   *
-   * Return URL (e.g. `/path?a=b#hash`) when called without any parameter.
    * Change path, search and hash, when called with parameter and return `$location`.
    *
-   * @param {string=} url New URL without base prefix (e.g. `/path?a=b#hash`)
-   * @return {Location|string} url
+   * @param {string} url New URL without base prefix (e.g. `/path?a=b#hash`)
+   * @return {Location} url
    */
-  url(url) {
-    if (isUndefined(url)) {
-      return this.$$url;
-    }
-
+  setUrl(url) {
     const match = PATH_MATCH.exec(url);
-    if (match[1] || url === "") this.path(decodeURIComponent(match[1]));
-    if (match[2] || match[1] || url === "") this.search(match[3] || "");
-    this.hash(match[5] || "");
+    if (match[1] || url === "") this.setPath(decodeURIComponent(match[1]));
+    if (match[2] || match[1] || url === "") this.setSearch(match[3] || "");
+    this.setHash(match[5] || "");
 
     return this;
   }
 
   /**
+   * Return URL (e.g. `/path?a=b#hash`) when called without any parameter.
    *
-   * Return protocol of current URL.
-   * @return {string} protocol of current URL
-   */
-  protocol() {
-    return this.$$protocol;
-  }
-
-  /**
-   * This method is getter only.
-   *
-   * Return host of current URL.
-   *
-   * Note: compared to the non-AngularTS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
-   *
-   *
-   * @return {string} host of current URL.
+   * @return {string} url
    */
-  host() {
-    return this.$$host;
+  getUrl() {
+    return this.$$url;
   }
 
   /**
-   * This method is getter only.
-   *
-   * Return port of current URL.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let port = $location.port();
-   * // => 80
-   * ```
+   * Change path parameter and return `$location`.
    *
-   * @return {number} port
+   * @param {(string|number)} path New path
+   * @return {Location}
    */
-  port() {
-    return this.$$port;
+  setPath(path) {
+    let newPath = path !== null ? path.toString() : "";
+    $$path = newPath.charAt(0) === "/" ? newPath : `/${newPath}`;
+    this.$$compose();
+    return this;
   }
 
   /**
-   * This method is getter / setter.
-   *
-   * Return path of current URL when called without any parameter.
    *
-   * Change path when called with parameter and return `$location`.
+   * Return path of current URL
    *
-   * Note: Path should always begin with forward slash (/), this method will add the forward slash
-   * if it is missing.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let path = $location.path();
-   * // => "/some/path"
-   * ```
-   *
-   * @param {(string|number)=} path New path
-   * @return {(string|object)} path if called with no parameters, or `$location` if called with a parameter
+   * @return {string}
    */
-  path(path) {
-    if (isUndefined(path)) {
-      return this.$$path;
-    }
-    let newPath = path !== null ? path.toString() : "";
-    this.$$path = newPath.charAt(0) === "/" ? newPath : `/${newPath}`;
-    this.$$compose();
-    return this;
+  getPath() {
+    return $$path;
   }
 
   /**
-   * This method is getter / setter.
-   *
-   * Returns the hash fragment when called without any parameters.
-   *
    * Changes the hash fragment when called with a parameter and returns `$location`.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue
-   * let hash = $location.hash();
-   * // => "hashValue"
-   * ```
-   *
-   * @param {(string|number)=} hash New hash fragment
-   * @return {string|Location} hash
+   * @param {(string|number)} hash New hash fragment
+   * @return {Location} hash
    */
-  hash(hash) {
-    if (isUndefined(hash)) {
-      return this.$$hash;
-    }
-
-    this.$$hash = hash !== null ? hash.toString() : "";
+  setHash(hash) {
+    $$hash = hash !== null ? hash.toString() : "";
     this.$$compose();
     return this;
   }
 
   /**
-   * If called, all changes to $location during the current `$digest` will replace the current history
-   * record, instead of adding a new one.
+   * Returns the hash fragment when called without any parameters.
+   * @return {string} hash
    */
-  replace() {
-    this.$$replace = true;
-    return this;
+  getHash() {
+    return $$hash;
   }
 
   /**
-   * Returns or sets the search part (as object) of current URL when called without any parameter
+   * Sets the search part (as object) of current URL
    *
-   * @param {string|Object=} search New search params - string or hash object.
+   * @param {string|Object} search New search params - string or hash object.
    * @param {(string|number|Array<string>|boolean)=} paramValue If search is a string or number, then paramValue will override only a single search property.
-   * @returns {Object|Location} Search object or Location object
+   * @returns {Object} Search object or Location object
    */
-  search(search, paramValue) {
+  setSearch(search, paramValue) {
     switch (arguments.length) {
-      case 0:
-        return this.$$search;
       case 1:
         if (isString(search) || isNumber(search)) {
           search = search.toString();
-          this.$$search = parseKeyValue(search);
+          $$search = parseKeyValue(search);
         } else if (isObject(search)) {
           search = structuredClone(search, {});
           // remove object undefined or null properties
@@ -273,7 +170,7 @@ export class Location {
             if (value == null) delete search[key];
           });
 
-          this.$$search = search;
+          $$search = search;
         } else {
           throw $locationMinErr(
             "isrcharg",
@@ -283,9 +180,10 @@ export class Location {
         break;
       default:
         if (isUndefined(paramValue) || paramValue === null) {
-          delete this.$$search[search];
+          delete $$search[search];
         } else {
-          this.$$search[search] = paramValue;
+          // @ts-ignore
+          $$search[search] = paramValue;
         }
     }
 
@@ -294,28 +192,28 @@ export class Location {
   }
 
   /**
-   * Compose url and update `url` and `absUrl` property
-   * @returns {void}
+   * Returns the search part (as object) of current URL
+   *
+   * @returns {Object} Search object or Location object
    */
-  $$compose() {
-    this.$$url = normalizePath(this.$$path, this.$$search, this.$$hash);
-    this.$$absUrl = this.$$normalizeUrl(this.$$url);
-    this.$$urlUpdatedByLocation = true;
+  getSearch() {
+    return $$search;
   }
 
   /**
-   * @param {string} _url
-   * @returns {string}
+   * @private
+   * Compose url and update `url` and `absUrl` property
    */
-  $$normalizeUrl(_url) {
-    throw new Error(`Method not implemented ${_url}`);
+  $$compose() {
+    this.$$url = normalizePath($$path, $$search, $$hash);
+    this.absUrl = this.html5
+      ? this.appBaseNoFile + this.$$url.substring(1)
+      : this.appBase + (this.$$url ? this.hashPrefix + this.$$url : "");
+    urlUpdatedByLocation = true;
+    setTimeout(() => this.$$updateBrowser && this.$$updateBrowser());
   }
 
   /**
-   * This method is getter / setter.
-   *
-   * Return the history state object when called without any parameter.
-   *
    * Change the history state object when called with one parameter and return `$location`.
    * The state object is later passed to `pushState` or `replaceState`.
    * See {@link https://developer.mozilla.org/en-US/docs/Web/API/History/pushState#state|History.state}
@@ -323,85 +221,30 @@ export class Location {
    * NOTE: This method is supported only in HTML5 mode and only in browsers supporting
    * the HTML5 History API (i.e. methods `pushState` and `replaceState`). If you need to support
    * older browsers (like IE9 or Android < 4.0), don't use this method.
-   *
-   * @param {any} state State object for pushState or replaceState
-   * @return {any} state
+   * @param {any} state
+   * @returns {Location}
    */
-  state(state) {
-    if (!arguments.length) {
-      return this.$$state;
-    }
-
-    if (!(this instanceof LocationHtml5Url) || !this.$$html5) {
+  setState(state) {
+    if (!this.html5) {
       throw $locationMinErr(
         "nostate",
-        "History API state support is available only " +
-          "in HTML5 mode and only in browsers supporting HTML5 History API",
+        "History API state support is available only in HTML5 mode",
       );
     }
-    // The user might modify `stateObject` after invoking `$location.state(stateObject)`
+    // The user might modify `stateObject` after invoking `$location.setState(stateObject)`
     // but we're changing the $$state reference to $browser.state() during the $digest
     // so the modification window is narrow.
     this.$$state = isUndefined(state) ? null : state;
-    this.$$urlUpdatedByLocation = true;
+    urlUpdatedByLocation = true;
     return this;
   }
 
   /**
-   * @param {string} _url
-   * @param {string} _url2
-   * @returns {boolean}
-   */
-  $$parseLinkUrl(_url, _url2) {
-    throw new Error(`Method not implemented ${_url} ${_url2}`);
-  }
-
-  $$parse(_url) {
-    throw new Error(`Method not implemented ${_url}`);
-  }
-}
-
-/**
- * This object is exposed as $location service when HTML5 mode is enabled and supported
- */
-export class LocationHtml5Url extends Location {
-  /**
-   * @param {string} appBase application base URL
-   * @param {string} appBaseNoFile application base URL stripped of any filename
-   * @param {string} basePrefix URL path prefix
-   */
-  constructor(appBase, appBaseNoFile, basePrefix) {
-    super(appBase, appBaseNoFile);
-    this.$$html5 = true;
-    this.basePrefix = basePrefix || "";
-  }
-
-  /**
-   * Parse given HTML5 (regular) URL string into properties
-   * @param {string} url HTML5 URL
+   * Return the history state object
+   * @returns {any}
    */
-  $$parse(url) {
-    const pathUrl = stripBaseUrl(this.appBaseNoFile, url);
-    if (!isString(pathUrl)) {
-      throw $locationMinErr(
-        "ipthprfx",
-        'Invalid url "{0}", missing path prefix "{1}".',
-        url,
-        this.appBaseNoFile,
-      );
-    }
-
-    parseAppUrl(pathUrl, this, true);
-
-    if (!this.$$path) {
-      this.$$path = "/";
-    }
-
-    this.$$compose();
-  }
-
-  $$normalizeUrl(url) {
-    return this.appBaseNoFile + url.substring(1); // first char is always '/'
+  getState() {
+    return this.$$state;
   }
 
   /**
@@ -409,149 +252,139 @@ export class LocationHtml5Url extends Location {
    * @param {string} relHref
    * @returns {boolean}
    */
-  $$parseLinkUrl(url, relHref) {
-    if (relHref && relHref[0] === "#") {
-      // special case for links to hash fragments:
-      // keep the old url and only replace the hash fragment
-      this.hash(relHref.slice(1));
-      return true;
-    }
-    let appUrl;
-    let prevAppUrl;
-    let rewrittenUrl;
-
-    if (isDefined((appUrl = stripBaseUrl(this.appBase, url)))) {
-      prevAppUrl = appUrl;
-      if (
-        this.basePrefix &&
-        isDefined((appUrl = stripBaseUrl(this.basePrefix, appUrl)))
-      ) {
-        rewrittenUrl =
-          this.appBaseNoFile + (stripBaseUrl("/", appUrl) || appUrl);
-      } else {
-        rewrittenUrl = this.appBase + prevAppUrl;
+  parseLinkUrl(url, relHref) {
+    if (this.html5) {
+      if (relHref && relHref[0] === "#") {
+        // special case for links to hash fragments:
+        // keep the old url and only replace the hash fragment
+        this.setHash(relHref.slice(1));
+        return true;
       }
-    } else if (isDefined((appUrl = stripBaseUrl(this.appBaseNoFile, url)))) {
-      rewrittenUrl = this.appBaseNoFile + appUrl;
-    } else if (this.appBaseNoFile === `${url}/`) {
-      rewrittenUrl = this.appBaseNoFile;
-    }
-    if (rewrittenUrl) {
-      this.$$parse(rewrittenUrl);
+      let appUrl;
+      let prevAppUrl;
+      let rewrittenUrl;
+
+      if (isDefined((appUrl = stripBaseUrl(this.appBase, url)))) {
+        prevAppUrl = appUrl;
+        if (
+          this.basePrefix &&
+          isDefined((appUrl = stripBaseUrl(this.basePrefix, appUrl)))
+        ) {
+          rewrittenUrl =
+            this.appBaseNoFile + (stripBaseUrl("/", appUrl) || appUrl);
+        } else {
+          rewrittenUrl = this.appBase + prevAppUrl;
+        }
+      } else if (isDefined((appUrl = stripBaseUrl(this.appBaseNoFile, url)))) {
+        rewrittenUrl = this.appBaseNoFile + appUrl;
+      } else if (this.appBaseNoFile === `${url}/`) {
+        rewrittenUrl = this.appBaseNoFile;
+      }
+      if (rewrittenUrl) {
+        this.parse(rewrittenUrl);
+      }
+      return !!rewrittenUrl;
+    } else {
+      if (stripHash(this.appBase) === stripHash(url)) {
+        this.parse(url);
+        return true;
+      }
+      return false;
     }
-    return !!rewrittenUrl;
   }
-}
 
-/**
- * LocationHashbangUrl represents URL
- * This object is exposed as $location service when developer doesn't opt into html5 mode.
- * It also serves as the base class for html5 mode fallback on legacy browsers.
- *
- */
-export class LocationHashbangUrl extends Location {
   /**
-   * @param {string} appBase application base URL
-   * @param {string} appBaseNoFile application base URL stripped of any filename
-   * @param {string} hashPrefix hashbang prefix
+   * Parse given HTML5 (regular) URL string into properties
+   * @param {string} url HTML5 URL
    */
-  constructor(appBase, appBaseNoFile, hashPrefix) {
-    super(appBase, appBaseNoFile);
-    this.hashPrefix = hashPrefix;
-  }
+  parse(url) {
+    if (this.html5) {
+      const pathUrl = stripBaseUrl(this.appBaseNoFile, url);
+      if (!isString(pathUrl)) {
+        throw $locationMinErr(
+          "ipthprfx",
+          'Invalid url "{0}", missing path prefix "{1}".',
+          url,
+          this.appBaseNoFile,
+        );
+      }
 
-  /**
-   * Parse given hashbang URL into properties
-   * @param {string} url Hashbang URL
-   */
-  $$parse(url) {
-    const withoutBaseUrl =
-      stripBaseUrl(this.appBase, url) || stripBaseUrl(this.appBaseNoFile, url);
-    let withoutHashUrl;
-
-    if (!isUndefined(withoutBaseUrl) && withoutBaseUrl.charAt(0) === "#") {
-      // The rest of the URL starts with a hash so we have
-      // got either a hashbang path or a plain hash fragment
-      withoutHashUrl = stripBaseUrl(this.hashPrefix, withoutBaseUrl);
-      if (isUndefined(withoutHashUrl)) {
-        // There was no hashbang prefix so we just have a hash fragment
-        withoutHashUrl = withoutBaseUrl;
+      parseAppUrl(pathUrl, true);
+
+      if (!$$path) {
+        $$path = "/";
       }
+
+      this.$$compose();
     } else {
-      // There was no hashbang path nor hash fragment:
-      // If we are in HTML5 mode we use what is left as the path;
-      // Otherwise we ignore what is left
-      if (this.$$html5) {
-        withoutHashUrl = withoutBaseUrl;
+      const withoutBaseUrl =
+        stripBaseUrl(this.appBase, url) ||
+        stripBaseUrl(this.appBaseNoFile, url);
+      let withoutHashUrl;
+
+      if (!isUndefined(withoutBaseUrl) && withoutBaseUrl.charAt(0) === "#") {
+        // The rest of the URL starts with a hash so we have
+        // got either a hashbang path or a plain hash fragment
+        withoutHashUrl = stripBaseUrl(this.hashPrefix, withoutBaseUrl);
+        if (isUndefined(withoutHashUrl)) {
+          // There was no hashbang prefix so we just have a hash fragment
+          withoutHashUrl = withoutBaseUrl;
+        }
       } else {
-        withoutHashUrl = "";
-        if (isUndefined(withoutBaseUrl)) {
-          this.appBase = url;
-          /** @type {?} */ (this).replace();
+        // There was no hashbang path nor hash fragment:
+        // If we are in HTML5 mode we use what is left as the path;
+        // Otherwise we ignore what is left
+        if (this.html5) {
+          withoutHashUrl = withoutBaseUrl;
+        } else {
+          withoutHashUrl = "";
+          if (isUndefined(withoutBaseUrl)) {
+            this.appBase = url;
+          }
         }
       }
-    }
 
-    parseAppUrl(withoutHashUrl, this, false);
+      parseAppUrl(withoutHashUrl, false);
 
-    this.$$path = removeWindowsDriveName(
-      this.$$path,
-      withoutHashUrl,
-      this.appBase,
-    );
+      $$path = removeWindowsDriveName($$path, withoutHashUrl, this.appBase);
 
-    this.$$compose();
+      this.$$compose();
 
-    /*
-     * In Windows, on an anchor node on documents loaded from
-     * the filesystem, the browser will return a pathname
-     * prefixed with the drive name ('/C:/path') when a
-     * pathname without a drive is set:
-     *  * a.setAttribute('href', '/foo')
-     *   * a.pathname === '/C:/foo' //true
-     *
-     * Inside of AngularTS, we're always using pathnames that
-     * do not include drive names for routing.
-     */
-    function removeWindowsDriveName(path, url, base) {
       /*
-      Matches paths for file protocol on windows,
-      such as /C:/foo/bar, and captures only /foo/bar.
-      */
-      const windowsFilePathExp = /^\/[A-Z]:(\/.*)/;
-
-      let firstPathSegmentMatch;
+       * In Windows, on an anchor node on documents loaded from
+       * the filesystem, the browser will return a pathname
+       * prefixed with the drive name ('/C:/path') when a
+       * pathname without a drive is set:
+       *  * a.setAttribute('href', '/foo')
+       *   * a.pathname === '/C:/foo' //true
+       *
+       * Inside of AngularTS, we're always using pathnames that
+       * do not include drive names for routing.
+       */
+      function removeWindowsDriveName(path, url, base) {
+        /*
+        Matches paths for file protocol on windows,
+        such as /C:/foo/bar, and captures only /foo/bar.
+        */
+        const windowsFilePathExp = /^\/[A-Z]:(\/.*)/;
+
+        let firstPathSegmentMatch;
+
+        // Get the relative path from the input URL.
+        if (startsWith(url, base)) {
+          url = url.replace(base, "");
+        }
 
-      // Get the relative path from the input URL.
-      if (startsWith(url, base)) {
-        url = url.replace(base, "");
-      }
+        // The input URL intentionally contains a first path segment that ends with a colon.
+        if (windowsFilePathExp.exec(url)) {
+          return path;
+        }
 
-      // The input URL intentionally contains a first path segment that ends with a colon.
-      if (windowsFilePathExp.exec(url)) {
-        return path;
+        firstPathSegmentMatch = windowsFilePathExp.exec(path);
+        return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
       }
-
-      firstPathSegmentMatch = windowsFilePathExp.exec(path);
-      return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
     }
   }
-
-  $$normalizeUrl(url) {
-    return this.appBase + (url ? this.hashPrefix + url : "");
-  }
-
-  /**
-   * @param {string} url
-   * @returns {boolean}
-   */
-  $$parseLinkUrl(url) {
-    if (stripHash(this.appBase) === stripHash(url)) {
-      this.$$parse(url);
-      return true;
-    }
-    return false;
-  }
 }
 
 export class LocationProvider {
@@ -559,20 +392,20 @@ export class LocationProvider {
     /** @type {string} */
     this.hashPrefixConf = "!";
 
-    /** @type {Html5Mode} */
+    /** @type {import("./interface.ts").Html5Mode} */
     this.html5ModeConf = {
-      enabled: false,
-      requireBase: true,
+      enabled: true,
+      requireBase: false,
       rewriteLinks: true,
     };
 
-    /** @type {Array<import("./interface.js").UrlChangeListener>} */
+    /** @type {Array<import("./interface.ts").UrlChangeListener>} */
     this.urlChangeListeners = [];
     this.urlChangeInit = false;
 
     /** @type {History['state']} */
     this.cachedState = null;
-    /** @typeof {History.state} */
+    /** @type {History['state']} */
     this.lastHistoryState = null;
     /** @type {string} */
     this.lastBrowserUrl = window.location.href;
@@ -583,14 +416,19 @@ export class LocationProvider {
   // URL API
   /// ///////////////////////////////////////////////////////////
 
+  /**
+   * Updates the browser's current URL and history state.
+   *
+   * @param {string|undefined} url - The target URL to navigate to.
+   * @param {*} [state=null] - Optional history state object to associate with the new URL.
+   * @returns {LocationProvider}
+   */
   setUrl(url, state) {
     if (state === undefined) {
       state = null;
     }
-
-    // setter
     if (url) {
-      url = urlResolve(url).href;
+      url = new URL(url).href;
 
       if (this.lastBrowserUrl === url && this.lastHistoryState === state) {
         return this;
@@ -607,7 +445,7 @@ export class LocationProvider {
    * Returns the current URL with any empty hash (`#`) removed.
    * @return {string}
    */
-  getUrl() {
+  getBrowserUrl() {
     return trimEmptyHash(window.location.href);
   }
 
@@ -635,19 +473,17 @@ export class LocationProvider {
 
   /**
    * Fires the state or URL change event.
-   *
-   * @private
    */
-  fireStateOrUrlChange() {
+  #fireStateOrUrlChange() {
     const prevLastHistoryState = this.lastHistoryState;
     this.cacheState();
     if (
-      this.lastBrowserUrl === this.getUrl() &&
+      this.lastBrowserUrl === this.getBrowserUrl() &&
       prevLastHistoryState === this.cachedState
     ) {
       return;
     }
-    this.lastBrowserUrl = this.getUrl();
+    this.lastBrowserUrl = this.getBrowserUrl();
     this.lastHistoryState = this.cachedState;
     this.urlChangeListeners.forEach((listener) => {
       listener(trimEmptyHash(window.location.href), this.cachedState);
@@ -660,131 +496,75 @@ export class LocationProvider {
    * @param {import("./interface.js").UrlChangeListener} callback - The callback function to register.
    * @returns void
    */
-  onUrlChange(callback) {
+  #onUrlChange(callback) {
     if (!this.urlChangeInit) {
-      window.addEventListener("popstate", this.fireStateOrUrlChange.bind(this));
+      window.addEventListener(
+        "popstate",
+        this.#fireStateOrUrlChange.bind(this),
+      );
       window.addEventListener(
         "hashchange",
-        this.fireStateOrUrlChange.bind(this),
+        this.#fireStateOrUrlChange.bind(this),
       );
       this.urlChangeInit = true;
     }
     this.urlChangeListeners.push(callback);
   }
 
-  /**
-   * The default value for the prefix is `'!'`.
-   * @param {string=} prefix Prefix for hash part (containing path and search)
-   * @returns {void}
-   */
-  setHashPrefix(prefix) {
-    this.hashPrefixConf = prefix;
-  }
-
-  /**
-   * Current hash prefix
-   * @returns {string}
-   */
-  getHashPrefix() {
-    return this.hashPrefixConf;
-  }
-
-  /**
-   * Configures html5 mode
-   * @param {(boolean|Html5Mode)=} mode If boolean, sets `html5Mode.enabled` to value. Otherwise, accepts html5Mode object
-   *
-   * @returns {void}
-   */
-  setHtml5Mode(mode) {
-    if (isBoolean(mode)) {
-      this.html5ModeConf.enabled = /** @type {boolean} */ (mode);
-    }
-    if (isObject(mode)) {
-      const html5Mode = /** @type {Html5Mode} */ (mode);
-      if (isDefined(html5Mode.enabled) && isBoolean(html5Mode.enabled)) {
-        this.html5ModeConf.enabled = html5Mode.enabled;
-      }
-
-      if (
-        isDefined(html5Mode.requireBase) &&
-        isBoolean(html5Mode.requireBase)
-      ) {
-        this.html5ModeConf.requireBase = html5Mode.requireBase;
-      }
-
-      if (
-        isDefined(html5Mode.rewriteLinks) &&
-        (isBoolean(html5Mode.rewriteLinks) || isString(html5Mode.rewriteLinks))
-      ) {
-        this.html5ModeConf.rewriteLinks = html5Mode.rewriteLinks;
-      }
-    }
-  }
-
-  /**
-   * Returns html5 mode cofiguration
-   * @returns {Html5Mode}
-   */
-  getHtml5Mode() {
-    return this.html5ModeConf;
-  }
-
   $get = [
-    "$rootScope",
-    "$rootElement",
+    $t.$rootScope,
+    $t.$rootElement,
     /**
      *
      * @param {import('../../core/scope/scope.js').Scope} $rootScope
      * @param {Element} $rootElement
-     * @returns
+     * @returns {Location}
      */
     ($rootScope, $rootElement) => {
       /** @type {Location} */
       let $location;
-      let LocationMode;
       const baseHref = getBaseHref(); // if base[href] is undefined, it defaults to ''
       const initialUrl = trimEmptyHash(window.location.href);
       let appBase;
 
-      if (this.getHtml5Mode().enabled) {
-        if (!baseHref && this.getHtml5Mode().requireBase) {
+      if (this.html5ModeConf.enabled) {
+        if (!baseHref && this.html5ModeConf.requireBase) {
           throw $locationMinErr(
             "nobase",
             "$location in HTML5 mode requires a <base> tag to be present!",
           );
         }
         appBase = serverBase(initialUrl) + (baseHref || "/");
-        LocationMode = LocationHtml5Url;
       } else {
         appBase = stripHash(initialUrl);
-        LocationMode = LocationHashbangUrl;
       }
       const appBaseNoFile = stripFile(appBase);
 
-      $location = new LocationMode(
+      $location = new Location(
         appBase,
         appBaseNoFile,
-        `#${this.getHashPrefix()}`,
+        this.html5ModeConf.enabled,
+        `#${this.hashPrefixConf}`,
       );
-      $location.$$parseLinkUrl(initialUrl, initialUrl);
+      $location.parseLinkUrl(initialUrl, initialUrl);
 
       $location.$$state = this.state();
 
       const IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i;
 
       const setBrowserUrlWithFallback = (url, state) => {
-        const oldUrl = $location.url();
+        const oldUrl = $location.getUrl();
         const oldState = $location.$$state;
         try {
           this.setUrl(url, state);
 
-          // Make sure $location.state() returns referentially identical (not just deeply equal)
+          // Make sure $location.getState() returns referentially identical (not just deeply equal)
           // state object; this makes possible quick checking if the state changed in the digest
           // loop. Checking deep equality would be too expensive.
           $location.$$state = this.state();
         } catch (e) {
           // Restore old values if pushState fails
-          $location.url(/** @type {string} */ (oldUrl));
+          $location.setUrl(/** @type {string} */ (oldUrl));
           $location.$$state = oldState;
 
           throw e;
@@ -795,7 +575,7 @@ export class LocationProvider {
         "click",
         /** @param {MouseEvent} event */
         (event) => {
-          const rewriteLinks = this.getHtml5Mode().rewriteLinks;
+          const rewriteLinks = this.html5ModeConf.rewriteLinks;
           // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
           // currently we open nice url link and redirect then
 
@@ -804,7 +584,6 @@ export class LocationProvider {
             event.ctrlKey ||
             event.metaKey ||
             event.shiftKey ||
-            event.which === 2 ||
             event.button === 2
           ) {
             return;
@@ -839,7 +618,7 @@ export class LocationProvider {
             // an animation.
 
             const scvAnimatedString = /** @type {unknown} */ (absHref);
-            absHref = urlResolve(
+            absHref = new URL(
               /** @type {SVGAnimatedString } */ (scvAnimatedString).animVal,
             ).href;
           }
@@ -852,7 +631,7 @@ export class LocationProvider {
             !elm.getAttribute("target") &&
             !event.defaultPrevented
           ) {
-            if ($location.$$parseLinkUrl(absHref, relHref)) {
+            if ($location.parseLinkUrl(absHref, relHref)) {
               // We do a preventDefault for all urls that are part of the AngularTS application,
               // in html5mode and also without, so that we are able to abort navigation without
               // getting double entries in the location history.
@@ -863,14 +642,14 @@ export class LocationProvider {
       );
 
       // rewrite hashbang url <> html5 url
-      if ($location.absUrl() !== initialUrl) {
-        this.setUrl($location.absUrl(), true);
+      if ($location.absUrl !== initialUrl) {
+        this.setUrl($location.absUrl, true);
       }
 
       let initializing = true;
 
       // update $location when $browser url changes
-      this.onUrlChange((newUrl, newState) => {
+      this.#onUrlChange((newUrl, newState) => {
         if (!startsWith(newUrl, appBaseNoFile)) {
           // If we are navigating outside of the app then force a reload
           window.location.href = newUrl;
@@ -878,10 +657,10 @@ export class LocationProvider {
         }
 
         Promise.resolve().then(() => {
-          const oldUrl = $location.absUrl();
+          const oldUrl = $location.absUrl;
           const oldState = $location.$$state;
           let defaultPrevented;
-          $location.$$parse(newUrl);
+          $location.parse(newUrl);
           $location.$$state = newState;
 
           defaultPrevented = $rootScope.$broadcast(
@@ -894,10 +673,10 @@ export class LocationProvider {
 
           // if the location was changed by a `$locationChangeStart` handler then stop
           // processing this location change
-          if ($location.absUrl() !== newUrl) return;
+          if ($location.absUrl !== newUrl) return;
 
           if (defaultPrevented) {
-            $location.$$parse(oldUrl);
+            $location.parse(oldUrl);
             $location.$$state = oldState;
             setBrowserUrlWithFallback(oldUrl, oldState);
           } else {
@@ -909,21 +688,21 @@ export class LocationProvider {
 
       // update browser
       const updateBrowser = () => {
-        if (initializing || $location.$$urlUpdatedByLocation) {
-          $location.$$urlUpdatedByLocation = false;
+        if (initializing || urlUpdatedByLocation) {
+          urlUpdatedByLocation = false;
 
-          const oldUrl = /** @type {string} */ (this.getUrl());
-          const newUrl = $location.absUrl();
+          const oldUrl = /** @type {string} */ (this.getBrowserUrl());
+          const newUrl = $location.absUrl;
           const oldState = this.state();
           const urlOrStateChanged =
             !urlsEqual(oldUrl, newUrl) ||
-            ($location.$$html5 && oldState !== $location.$$state);
+            ($location.html5 && oldState !== $location.$$state);
 
           if (initializing || urlOrStateChanged) {
             initializing = false;
 
             setTimeout(() => {
-              const newUrl = $location.absUrl();
+              const newUrl = $location.absUrl;
               const { defaultPrevented } = $rootScope.$broadcast(
                 "$locationChangeStart",
                 newUrl,
@@ -934,10 +713,10 @@ export class LocationProvider {
 
               // if the location was changed by a `$locationChangeStart` handler then stop
               // processing this location change
-              if ($location.absUrl() !== newUrl) return;
+              if ($location.absUrl !== newUrl) return;
 
               if (defaultPrevented) {
-                $location.$$parse(oldUrl);
+                $location.parse(oldUrl);
                 $location.$$state = oldState;
               } else {
                 if (urlOrStateChanged) {
@@ -951,13 +730,8 @@ export class LocationProvider {
             });
           }
         }
-
-        $location.$$replace = false;
-
-        // we don't need to return anything because $evalAsync will make the digest loop dirty when
-        // there is a change
       };
-
+      $location.$$updateBrowser = updateBrowser;
       updateBrowser();
       $rootScope.$on("$updateBrowser", updateBrowser);
 
@@ -966,7 +740,7 @@ export class LocationProvider {
       function afterLocationChange(oldUrl, oldState) {
         $rootScope.$broadcast(
           "$locationChangeSuccess",
-          $location.absUrl(),
+          $location.absUrl,
           oldUrl,
           $location.$$state,
           oldState,
@@ -978,29 +752,64 @@ export class LocationProvider {
 
 /**
  * ///////////////////////////
- *          HELPERS
+ *     PRIVATE HELPERS
  * ///////////////////////////
  */
 
 /**
- * Encode path using encodeUriSegment, ignoring forward slashes
+ * @ignore
+ * Encodes a URL path by encoding each path segment individually using `encodeUriSegment`,
+ * while preserving forward slashes (`/`) as segment separators.
  *
- * @param {string} path Path to encode
- * @returns {string}
+ * This function first decodes any existing percent-encodings (such as `%20` or `%2F`)
+ * in each segment to prevent double encoding, except for encoded forward slashes (`%2F`),
+ * which are replaced with literal slashes before decoding to keep path boundaries intact.
+ *
+ * After decoding, each segment is re-encoded with `encodeUriSegment` according to RFC 3986,
+ * encoding only characters that must be encoded in a path segment.
+ *
+ * The encoded segments are then rejoined with `/` to form the encoded path.
+ *
+ * @param {string} path - The URL path string to encode. May contain multiple segments separated by `/`.
+ * @returns {string} The encoded path, where each segment is encoded, but forward slashes are preserved.
+ *
+ * @example
+ * encodePath("user profile/images/pic 1.jpg")
+ * // returns "user%20profile/images/pic%201.jpg"
+ *
+ * @example
+ * encodePath("folder1%2Fsub/folder2")
+ * // returns "folder1%2Fsub/folder2"
  */
-function encodePath(path) {
+export function encodePath(path) {
   const segments = path.split("/");
   let i = segments.length;
 
   while (i--) {
-    // decode forward slashes to prevent them from being double encoded
-    segments[i] = encodeUriSegment(segments[i].replace(/%2F/g, "/"));
+    // Decode any existing encodings (e.g. %20, %2F) to prevent double-encoding
+    // But keep slashes intact (they were split on)
+    const decodedSegment = decodeURIComponent(
+      segments[i].replace(/%2F/gi, "/"),
+    );
+    segments[i] = encodeUriSegment(decodedSegment);
   }
 
   return segments.join("/");
 }
 
-function decodePath(path, html5Mode) {
+/**
+ * @ignore
+ * Decodes each segment of a URL path.
+ *
+ * Splits the input path by "/", decodes each segment using decodeURIComponent,
+ * and if html5Mode is enabled, re-encodes any forward slashes inside segments
+ * as "%2F" to avoid confusion with path separators.
+ *
+ * @param {string} path - The URL path to decode.
+ * @param {boolean} html5Mode - If true, encodes forward slashes in segments as "%2F".
+ * @returns {string} The decoded path with segments optionally encoding slashes.
+ */
+export function decodePath(path, html5Mode) {
   const segments = path.split("/");
   let i = segments.length;
 
@@ -1015,7 +824,34 @@ function decodePath(path, html5Mode) {
   return segments.join("/");
 }
 
-function normalizePath(pathValue, searchValue, hashValue) {
+/**
+ * @ignore
+ * Normalizes a URL path by encoding the path segments, query parameters, and hash fragment.
+ *
+ * - Path segments are encoded using `encodePath`, which encodes each segment individually.
+ * - Query parameters (`searchValue`) are converted to a query string using `toKeyValue`.
+ * - Hash fragment (`hashValue`) is encoded using `encodeUriSegment` and prefixed with `#`.
+ *
+ * This function returns a fully constructed URL path with optional query and hash components.
+ *
+ * @param {string} pathValue - The base URL path (e.g., "folder/item name").
+ * @param {Object.<string, any> | string | null} searchValue - An object or string representing query parameters.
+ *   - If an object, it can contain strings, numbers, booleans, or arrays of values.
+ *   - If a string, it is assumed to be a raw query string.
+ *   - If null or undefined, no query string is added.
+ * @param {string | null} hashValue - The URL fragment (everything after `#`). If null or undefined, no hash is added.
+ *
+ * @returns {string} The normalized URL path including encoded path, optional query string, and optional hash.
+ *
+ * @example
+ * normalizePath("products/list", { category: "books", page: 2 }, "section1")
+ * // returns "products/list?category=books&page=2#section1"
+ *
+ * @example
+ * normalizePath("user profile/images", null, null)
+ * // returns "user%20profile/images"
+ */
+export function normalizePath(pathValue, searchValue, hashValue) {
   const search = toKeyValue(searchValue);
   const hash = hashValue ? `#${encodeUriSegment(hashValue)}` : "";
   const path = encodePath(pathValue);
@@ -1023,7 +859,15 @@ function normalizePath(pathValue, searchValue, hashValue) {
   return path + (search ? `?${search}` : "") + hash;
 }
 
-function parseAppUrl(url, locationObj, html5Mode) {
+/**
+ * @ignore
+ * Parses the application URL and updates the location object with path, search, and hash.
+ *
+ * @param {string} url - The URL string to parse.
+ * @param {boolean} html5Mode - Whether HTML5 mode is enabled (affects decoding).
+ * @throws Will throw an error if the URL starts with invalid slashes.
+ */
+export function parseAppUrl(url, html5Mode) {
   if (/^\s*[\\/]{2,}/.test(url)) {
     throw $locationMinErr("badpath", 'Invalid url "{0}".', url);
   }
@@ -1037,22 +881,20 @@ function parseAppUrl(url, locationObj, html5Mode) {
     prefixed && match.pathname.charAt(0) === "/"
       ? match.pathname.substring(1)
       : match.pathname;
-  locationObj.$$path = decodePath(path, html5Mode);
-  locationObj.$$search = parseKeyValue(match.search);
-  locationObj.$$hash = decodeURIComponent(match.hash);
+  $$path = decodePath(path, html5Mode);
+  $$search = parseKeyValue(match.search);
+  $$hash = decodeURIComponent(match.hash);
 
   // make sure path starts with '/';
-  if (locationObj.$$path && locationObj.$$path.charAt(0) !== "/") {
-    locationObj.$$path = `/${locationObj.$$path}`;
+  if ($$path && $$path.charAt(0) !== "/") {
+    $$path = `/${$$path}`;
   }
 }
 
-function startsWith(str, search) {
-  return str.slice(0, search.length) === search;
-}
-
 /**
- *
+ * @ignore
+ * Returns the substring of `url` after the `base` string if `url` starts with `base`.
+ * Returns `undefined` if `url` does not start with `base`.
  * @param {string} base
  * @param {string} url
  * @returns {string} returns text from `url` after `base` or `undefined` if it does not begin with
@@ -1064,23 +906,94 @@ export function stripBaseUrl(base, url) {
   }
 }
 
+/**
+ * @ignore
+ * Removes the hash fragment (including the '#') from the given URL string.
+ *
+ * @param {string} url - The URL string to process.
+ * @returns {string} The URL without the hash fragment.
+ */
 export function stripHash(url) {
   const index = url.indexOf("#");
   return index === -1 ? url : url.substring(0, index);
 }
 
+/**
+ * @ignore
+ * Removes the file name (and any hash) from a URL, returning the base directory path.
+ *
+ * For example:
+ * - Input: "https://example.com/path/to/file.js"
+ *   Output: "https://example.com/path/to/"
+ *
+ * - Input: "https://example.com/path/to/file.js#section"
+ *   Output: "https://example.com/path/to/"
+ *
+ * @param {string} url - The URL from which to strip the file name and hash.
+ * @returns {string} The base path of the URL, ending with a slash.
+ */
 export function stripFile(url) {
   return url.substring(0, stripHash(url).lastIndexOf("/") + 1);
 }
 
-/* return the server only (scheme://host:port) */
+/**
+ * @ignore
+ * Extracts the base server URL (scheme, host, and optional port) from a full URL.
+ *
+ * If no path is present, returns the full URL.
+ *
+ * For example:
+ * - Input: "https://example.com/path/to/file"
+ *   Output: "https://example.com"
+ *
+ * - Input: "http://localhost:3000/api/data"
+ *   Output: "http://localhost:3000"
+ *
+ * @param {string} url - The full URL to extract the server base from.
+ * @returns {string} The server base, including scheme and host (and port if present).
+ */
 export function serverBase(url) {
-  return url.substring(0, url.indexOf("/", url.indexOf("//") + 2));
+  const start = url.indexOf("//") + 2;
+  const slashIndex = url.indexOf("/", start);
+  return slashIndex === -1 ? url : url.substring(0, slashIndex);
+}
+
+/**
+ * @ignore
+ * Determine if two URLs are equal despite potential differences in encoding,
+ * trailing slashes, or empty hash fragments, such as between $location.absUrl() and $browser.url().
+ *
+ * @param {string} a - First URL to compare.
+ * @param {string} b - Second URL to compare.
+ * @returns {boolean} True if URLs are equivalent after normalization.
+ */
+export function urlsEqual(a, b) {
+  return normalizeUrl(a) === normalizeUrl(b);
 }
 
-// Determine if two URLs are equal despite potentially having different encoding/normalizing
-//  such as $location.absUrl() vs $browser.url()
-// See https://github.com/angular/angular.js/issues/16592
-function urlsEqual(a, b) {
-  return a === b || urlResolve(a).href === urlResolve(b).href;
+/**
+ * @ignore
+ * Normalize a URL by resolving it via a DOM anchor element,
+ * removing trailing slashes (except root), and trimming empty hashes.
+ *
+ * @param {string} url - URL to normalize.
+ * @returns {string} Normalized URL string.
+ */
+function normalizeUrl(url) {
+  const anchor = document.createElement("a");
+  anchor.href = url;
+
+  let normalized = anchor.href;
+
+  // Remove trailing slash unless it's root (e.g., https://example.com/)
+  if (normalized.endsWith("/") && !/^https?:\/\/[^/]+\/$/.test(normalized)) {
+    normalized = normalized.slice(0, -1);
+  }
+
+  // Remove empty hash (e.g., https://example.com/foo# -> https://example.com/foo)
+  if (normalized.endsWith("#")) {
+    normalized = normalized.slice(0, -1);
+  }
+
+  return normalized;
 }