@angular-wave/angular.ts 0.7.8 → 0.8.1

package/@types/services/location/location.d.ts

@@ -1,188 +1,256 @@
 /**
+ * ///////////////////////////
+ *     PRIVATE HELPERS
+ * ///////////////////////////
+ */
+/**
+ * @ignore
+ * Encodes a URL path by encoding each path segment individually using `encodeUriSegment`,
+ * while preserving forward slashes (`/`) as segment separators.
+ *
+ * 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"
+ */
+export function encodePath(path: string): string;
+/**
+ * @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: string, html5Mode: boolean): string;
+/**
+ * @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: string,
+  searchValue:
+    | {
+        [x: string]: any;
+      }
+    | string
+    | null,
+  hashValue: string | null,
+): string;
+/**
+ * @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: string, html5Mode: boolean): void;
+/**
+ * @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
  *                   the expected string.
  */
 export function stripBaseUrl(base: string, url: string): string;
-export function stripHash(url: any): any;
-export function stripFile(url: any): any;
-export function serverBase(url: any): any;
 /**
- * @abstract
+ * @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: string): string;
+/**
+ * @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: string): string;
+/**
+ * @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: string): string;
+/**
+ * @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: string, b: string): boolean;
 export class Location {
   /**
    * @param {string} appBase application base URL
    * @param {string} appBaseNoFile application base URL stripped of any filename
-   */
-  constructor(appBase: string, appBaseNoFile: string);
+   * @param {boolean} [html5] Defaults to true
+   * @param {string} [prefix] URL path prefix for html5 mode or hash prefix for hashbang mode
+   */
+  constructor(
+    appBase: string,
+    appBaseNoFile: string,
+    html5?: boolean,
+    prefix?: string,
+  );
   /** @type {string} */
   appBase: string;
   /** @type {string} */
   appBaseNoFile: string;
-  /**
-   * 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}
-   */
-  $$absUrl: string;
-  /**
-   * If html5 mode is enabled
-   * @type {boolean}
-   */
-  $$html5: boolean;
-  /**
-   * Has any change been replacing?
-   * @type {boolean}
-   */
-  $$replace: boolean;
-  /** @type {string} */
-  $$protocol: string;
-  /** @type {string} */
-  $$host: string;
-  /**
-   * The port, without ":"
-   * @type {number}
-   */
-  $$port: number;
-  /**
-   * The pathname, beginning with "/"
+  /** @type {boolean} */
+  html5: boolean;
+  /** @type {string | undefined} */
+  basePrefix: string | undefined;
+  /** @type {string | undefined} */
+  hashPrefix: string | undefined;
+  /**
+   * 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}
    */
-  $$path: string;
+  absUrl: string;
   /**
-   * The hash string, minus the hash symbol
+   * @ignore
+   * Current url
    * @type {string}
    */
-  $$hash: string;
-  /**
-   * Helper property for scope watch changes
-   * @type {boolean}
-   */
-  $$urlUpdatedByLocation: boolean;
+  $$url: string;
   /**
-   * 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
+   * @ignore
+   * Callback to update browser url
+   * @type {Function}
    */
-  absUrl(): string;
+  $$updateBrowser: Function;
   /**
-   * 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?: string | undefined): Location | string;
+  setUrl(url: string): Location;
   /**
+   * 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(): string;
-  /**
-   * 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(): string;
+  getUrl(): string;
   /**
-   * This method is getter only.
+   * Change path parameter and return `$location`.
    *
-   * Return port of current URL.
-   *
-   *
-   * ```js
-   * // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-   * let port = $location.port();
-   * // => 80
-   * ```
-   *
-   * @return {number} port
+   * @param {(string|number)} path New path
+   * @return {Location}
    */
-  port(): number;
+  setPath(path: string | number): Location;
   /**
-   * 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?: (string | number) | undefined): string | object;
+  getPath(): string;
   /**
-   * 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?: (string | number) | undefined): string | Location;
+  setHash(hash: string | number): Location;
   /**
-   * 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;
+  getHash(): string;
   /**
-   * 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?: (string | any) | undefined,
+  setSearch(
+    search: string | any,
     paramValue?: (string | number | Array<string> | boolean) | undefined,
     ...args: any[]
-  ): any | Location;
-  $$search: any;
+  ): any;
   /**
-   * 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(): void;
-  $$url: string;
+  getSearch(): any;
   /**
-   * @param {string} _url
-   * @returns {string}
+   * @private
+   * Compose url and update `url` and `absUrl` property
    */
-  $$normalizeUrl(_url: string): string;
+  private $$compose;
   /**
-   * 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}
@@ -190,84 +258,55 @@ 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: any, ...args: any[]): any;
+  setState(state: any): Location;
   $$state: any;
   /**
-   * @param {string} _url
-   * @param {string} _url2
-   * @returns {boolean}
+   * Return the history state object
+   * @returns {any}
    */
-  $$parseLinkUrl(_url: string, _url2: string): boolean;
-  $$parse(_url: any): void;
-}
-/**
- * This object is exposed as $location service when HTML5 mode is enabled and supported
- */
-export class LocationHtml5Url extends Location {
+  getState(): any;
   /**
-   * @param {string} appBase application base URL
-   * @param {string} appBaseNoFile application base URL stripped of any filename
-   * @param {string} basePrefix URL path prefix
+   * @param {string} url
+   * @param {string} relHref
+   * @returns {boolean}
    */
-  constructor(appBase: string, appBaseNoFile: string, basePrefix: string);
-  basePrefix: string;
+  parseLinkUrl(url: string, relHref: string): boolean;
   /**
    * Parse given HTML5 (regular) URL string into properties
    * @param {string} url HTML5 URL
    */
-  $$parse(url: string): void;
-  $$normalizeUrl(url: any): string;
-}
-/**
- * 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
-   */
-  constructor(appBase: string, appBaseNoFile: string, hashPrefix: string);
-  hashPrefix: string;
-  /**
-   * Parse given hashbang URL into properties
-   * @param {string} url Hashbang URL
-   */
-  $$parse(url: string): void;
-  $$normalizeUrl(url: any): string;
-  /**
-   * @param {string} url
-   * @returns {boolean}
-   */
-  $$parseLinkUrl(url: string): boolean;
+  parse(url: string): void;
 }
 export class LocationProvider {
   /** @type {string} */
   hashPrefixConf: string;
-  /** @type {Html5Mode} */
-  html5ModeConf: Html5Mode;
-  /** @type {Array<import("./interface.js").UrlChangeListener>} */
-  urlChangeListeners: Array<import("./interface.js").UrlChangeListener>;
+  /** @type {import("./interface.ts").Html5Mode} */
+  html5ModeConf: import("./interface.ts").Html5Mode;
+  /** @type {Array<import("./interface.ts").UrlChangeListener>} */
+  urlChangeListeners: Array<import("./interface.ts").UrlChangeListener>;
   urlChangeInit: boolean;
   /** @type {History['state']} */
   cachedState: History["state"];
-  /** @typeof {History.state} */
-  lastHistoryState: any;
+  /** @type {History['state']} */
+  lastHistoryState: History["state"];
   /** @type {string} */
   lastBrowserUrl: string;
-  setUrl(url: any, state: any): this;
+  /**
+   * 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: string | undefined, state?: any): LocationProvider;
   /**
    * Returns the current URL with any empty hash (`#`) removed.
    * @return {string}
    */
-  getUrl(): string;
+  getBrowserUrl(): string;
   /**
    * Returns the cached state.
    * @returns {History['state']} The cached state.
@@ -280,42 +319,6 @@ export class LocationProvider {
    */
   private cacheState;
   lastCachedState: any;
-  /**
-   * Fires the state or URL change event.
-   *
-   * @private
-   */
-  private fireStateOrUrlChange;
-  /**
-   * Registers a callback to be called when the URL changes.
-   *
-   * @param {import("./interface.js").UrlChangeListener} callback - The callback function to register.
-   * @returns void
-   */
-  onUrlChange(callback: import("./interface.js").UrlChangeListener): void;
-  /**
-   * The default value for the prefix is `'!'`.
-   * @param {string=} prefix Prefix for hash part (containing path and search)
-   * @returns {void}
-   */
-  setHashPrefix(prefix?: string | undefined): void;
-  /**
-   * Current hash prefix
-   * @returns {string}
-   */
-  getHashPrefix(): string;
-  /**
-   * Configures html5 mode
-   * @param {(boolean|Html5Mode)=} mode If boolean, sets `html5Mode.enabled` to value. Otherwise, accepts html5Mode object
-   *
-   * @returns {void}
-   */
-  setHtml5Mode(mode?: (boolean | Html5Mode) | undefined): void;
-  /**
-   * Returns html5 mode cofiguration
-   * @returns {Html5Mode}
-   */
-  getHtml5Mode(): Html5Mode;
   $get: (
     | string
     | ((
@@ -323,35 +326,5 @@ export class LocationProvider {
         $rootElement: Element,
       ) => Location)
   )[];
+  #private;
 }
-export type DefaultPorts = {
-  http: number;
-  https: number;
-  ftp: number;
-};
-/**
- * Represents the configuration options for HTML5 mode.
- */
-export type Html5Mode = {
-  /**
-   * - (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`.
-   */
-  enabled: boolean;
-  /**
-   * - (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.
-   */
-  requireBase: boolean;
-  /**
-   * - (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'`.
-   */
-  rewriteLinks: boolean | string;
-};

package/@types/shared/common.d.ts

@@ -182,8 +182,6 @@ export function copy(src: any, dest: any): any;
  * The same array is returned
  */
 export const removeFrom: any;
-/** pushes a values to an array and returns the value */
-export const pushTo: any;
 export function allTrueR(memo: any, elem: any): any;
 export function anyTrueR(memo: any, elem: any): any;
 export function unnestR(memo: any, elem: any): any;

package/@types/shared/hof.d.ts

@@ -54,11 +54,6 @@ export function compose(...args: any[]): () => any;
  * then, piped is: h(g(f(x)))
  */
 export function pipe(...args: any[]): any;
-/**
- * Given two functions that return truthy or falsey values, returns a function that returns truthy
- * if at least one of the functions returns truthy for the given arguments
- */
-export function or(fn1: any, fn2: any): (...args: any[]) => any;
 /**
  * Sorta like Pattern Matching (a functional programming conditional construct)
  *
@@ -109,6 +104,5 @@ export function pattern(struct: any): (arg0: any) => any;
  */
 export const propEq: any;
 export function parse(name: any): any;
-export function all(fn1: any): (arr: any) => any;
 export function is(ctor: any): (obj: any) => boolean;
 export function val(v: any): () => any;

package/@types/shared/interface.d.ts

@@ -1,6 +1,2 @@
-export type Mapper<X, T> = (x: X, key?: string | number) => T;
-export interface TypedMap<T> {
-  [key: string]: T;
-}
 export type Predicate<X> = (x?: X) => boolean;
 export type PredicateBinary<X, Y> = (x?: X, y?: Y) => boolean;

package/@types/{router/common → shared}/queue.d.ts

@@ -16,9 +16,9 @@ export class Queue<T> {
   _evictListeners: Array<(item: T) => void>;
   /**
    * Register a listener that will be called with the evicted item.
-   * @type {(listener: (item: T) => void) => void}
+   * @param {(item: T) => void} listener
    */
-  onEvict: (listener: (item: T) => void) => void;
+  onEvict(listener: (item: T) => void): void;
   /**
    * Adds an item to the end of the queue, evicting the head if over limit.
    * @param {T} item

package/@types/shared/url-utils/interface.d.ts

@@ -1,4 +1,3 @@
-export type HttpProtocol = "http" | "https";
 /**
  * A normalized representation of a parsed URL.
  */

package/@types/shared/url-utils/url-utils.d.ts

@@ -55,11 +55,6 @@ export function urlsAreSameOrigin(
   url1: import("./interface.js").ResolvableUrl,
   url2: import("./interface.js").ResolvableUrl,
 ): boolean;
-/**
- * Returns the current document base URL.
- * @returns {string}
- */
-export function getBaseUrl(): string;
 /**
  * Removes a trailing hash ('#') from the given URL if it exists.
  *