@angular-wave/angular.ts 0.7.7 → 0.8.0

package/@types/services/http-backend/http-backend.d.ts

@@ -1,53 +1,58 @@
 /**
- * @param {import('../browser.js').Browser} $browser
  * @returns
  */
-export function createHttpBackend(
-  $browser: import("../browser.js").Browser,
-): (
-  method: any,
-  url: any,
-  post: any,
-  callback: any,
-  headers: any,
-  timeout: any,
-  withCredentials: any,
-  responseType: any,
-  eventHandlers: any,
-  uploadEventHandlers: any,
+export function createHttpBackend(): (
+  method: string,
+  url?: string,
+  post?: any,
+  callback?: (
+    arg0: number,
+    arg1: any,
+    arg2: string | null,
+    arg3: string,
+    arg4: string,
+  ) => void,
+  headers?: {
+    [x: string]: string;
+  },
+  timeout?: number | Promise<any>,
+  withCredentials?: boolean,
+  responseType?: XMLHttpRequestResponseType,
+  eventHandlers?: {
+    [x: string]: EventListener;
+  },
+  uploadEventHandlers?: {
+    [x: string]: EventListener;
+  },
 ) => void;
 /**
- * HTTP backend used by the {@link ng.$http service} that delegates to
+ * HTTP backend used by the `$http` that delegates to
  * XMLHttpRequest object and deals with browser incompatibilities.
- *
- * You should never need to use this service directly, instead use the higher-level abstractions:
- * {@link ng.$http $http}.
- *
- */
-/**
- * HTTP backend used by the {@link ng.$http service} that delegates to
- * XMLHttpRequest object and deals with browser incompatibilities.
- *
- * You should never need to use this service directly, instead use the higher-level abstractions:
- * {@link ng.$http $http}.
- *
+ * You should never need to use this service directly.
  */
 export class HttpBackendProvider {
-  $get: (
-    | string
-    | ((
-        $browser: import("../browser.js").Browser,
-      ) => (
-        method: any,
-        url: any,
-        post: any,
-        callback: any,
-        headers: any,
-        timeout: any,
-        withCredentials: any,
-        responseType: any,
-        eventHandlers: any,
-        uploadEventHandlers: any,
-      ) => void)
-  )[];
+  $get: () => (
+    method: string,
+    url?: string,
+    post?: any,
+    callback?: (
+      arg0: number,
+      arg1: any,
+      arg2: string | null,
+      arg3: string,
+      arg4: string,
+    ) => void,
+    headers?: {
+      [x: string]: string;
+    },
+    timeout?: number | Promise<any>,
+    withCredentials?: boolean,
+    responseType?: XMLHttpRequestResponseType,
+    eventHandlers?: {
+      [x: string]: EventListener;
+    },
+    uploadEventHandlers?: {
+      [x: string]: EventListener;
+    },
+  ) => void;
 }

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

@@ -0,0 +1,63 @@
+/**
+ * A callback function that gets called when the browser URL or state changes.
+ *
+ * @param url - The new URL after the change (with trailing `#` removed).
+ * @param state - The new history state associated with the URL (`history.state`).
+ * @returns void
+ */
+export type UrlChangeListener = (url: string, state: History["state"]) => void;
+/**
+ * Represents the configuration options for HTML5 mode.
+ */
+export interface Html5Mode {
+  /**
+   * 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`.
+   * @default false
+   */
+  enabled: boolean;
+  /**
+   * 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.
+   * @default true
+   */
+  requireBase: boolean;
+  /**
+   * 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.
+   * Attribute name normalization does not apply here.
+   * @default true
+   */
+  rewriteLinks: boolean | string;
+}
+/**
+ * Represents default port numbers for various protocols.
+ */
+export interface DefaultPorts {
+  http: number;
+  https: number;
+  ftp: number;
+}
+/**
+ * Represents the individual components of a URL.
+ */
+export interface UrlParts {
+  /**
+   * The URL path (e.g. `/dashboard`, `/users/123`).
+   */
+  path: string;
+  /**
+   * The parsed query string as an object.
+   * Mirrors AngularJS’s `$location.setSearch()` format.
+   */
+  search: Record<
+    string,
+    string | number | boolean | (string | number | boolean)[]
+  >;
+  /**
+   * The fragment identifier (everything after `#`, not including the `#` itself).
+   */
+  hash: string;
+}

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

@@ -0,0 +1,330 @@
+/**
+ * ///////////////////////////
+ *     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;
+/**
+ * @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
+   * @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;
+  /** @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}
+   */
+  absUrl: string;
+  /**
+   * @ignore
+   * Current url
+   * @type {string}
+   */
+  $$url: string;
+  /**
+   * @ignore
+   * Callback to update browser url
+   * @type {Function}
+   */
+  $$updateBrowser: Function;
+  /**
+   * 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} url
+   */
+  setUrl(url: string): Location;
+  /**
+   * Return URL (e.g. `/path?a=b#hash`) when called without any parameter.
+   *
+   * @return {string} url
+   */
+  getUrl(): string;
+  /**
+   * Change path parameter and return `$location`.
+   *
+   * @param {(string|number)} path New path
+   * @return {Location}
+   */
+  setPath(path: string | number): Location;
+  /**
+   *
+   * Return path of current URL
+   *
+   * @return {string}
+   */
+  getPath(): string;
+  /**
+   * Changes the hash fragment when called with a parameter and returns `$location`.
+   * @param {(string|number)} hash New hash fragment
+   * @return {Location} hash
+   */
+  setHash(hash: string | number): Location;
+  /**
+   * Returns the hash fragment when called without any parameters.
+   * @return {string} hash
+   */
+  getHash(): string;
+  /**
+   * Sets the search part (as object) of current URL
+   *
+   * @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} Search object or Location object
+   */
+  setSearch(
+    search: string | any,
+    paramValue?: (string | number | Array<string> | boolean) | undefined,
+    ...args: any[]
+  ): any;
+  /**
+   * Returns the search part (as object) of current URL
+   *
+   * @returns {Object} Search object or Location object
+   */
+  getSearch(): any;
+  /**
+   * @private
+   * Compose url and update `url` and `absUrl` property
+   */
+  private $$compose;
+  /**
+   * 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}
+   *
+   * 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
+   * @returns {Location}
+   */
+  setState(state: any): Location;
+  $$state: any;
+  /**
+   * Return the history state object
+   * @returns {any}
+   */
+  getState(): any;
+  /**
+   * @param {string} url
+   * @param {string} relHref
+   * @returns {boolean}
+   */
+  parseLinkUrl(url: string, relHref: string): boolean;
+  /**
+   * Parse given HTML5 (regular) URL string into properties
+   * @param {string} url HTML5 URL
+   */
+  parse(url: string): void;
+}
+export class LocationProvider {
+  /** @type {string} */
+  hashPrefixConf: string;
+  /** @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"];
+  /** @type {History['state']} */
+  lastHistoryState: History["state"];
+  /** @type {string} */
+  lastBrowserUrl: string;
+  /**
+   * 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}
+   */
+  getBrowserUrl(): string;
+  /**
+   * Returns the cached state.
+   * @returns {History['state']} The cached state.
+   */
+  state(): History["state"];
+  /**
+   * Caches the current state.
+   *
+   * @private
+   */
+  private cacheState;
+  lastCachedState: any;
+  $get: (
+    | string
+    | ((
+        $rootScope: import("../../core/scope/scope.js").Scope,
+        $rootElement: Element,
+      ) => Location)
+  )[];
+  #private;
+}

package/@types/{core → services}/sce/sce.d.ts

@@ -243,4 +243,4 @@ export class SceDelegateProvider {
       })
   )[];
 }
-export type ErrorHandler = import("../error-handler.ts").ErrorHandler;
+export type ErrorHandler = import("../exception/interface.ts").Interface;

package/@types/services/template-cache/interface.d.ts

@@ -1,4 +1,10 @@
 /**
- * A cache for mapping template names to their respective content.
+ * A cache interface for mapping template urls to their XHR responses.
  */
-export type TemplateCache = Map<string, string>;
+export interface TemplateCache {
+  get(key: string): any | undefined;
+  set(key: string, value: any): this;
+  has(key: string): boolean;
+  delete(key: string): boolean;
+  clear(): void;
+}

package/@types/services/template-cache/template-cache.d.ts

@@ -7,5 +7,5 @@ export class TemplateCacheProvider {
   /**
    * @returns {import('./interface.ts').TemplateCache}
    */
-  $get: () => import("./interface.ts").TemplateCache;
+  $get(): import("./interface.ts").TemplateCache;
 }

package/@types/services/template-request.d.ts

@@ -43,7 +43,7 @@ export class TemplateRequestProvider {
   $get: (
     | string
     | ((
-        $exceptionHandler: import("../core/exception-handler.js").ErrorHandler,
+        $exceptionHandler: import("./exception/exception-handler.js").ErrorHandler,
         $templateCache: import("../services/template-cache/interface.ts").TemplateCache,
         $http: any,
         $sce: any,

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

@@ -1,8 +1,6 @@
 /**
  * Expando cache for adding properties to DOM nodes with JavaScript.
  * This used to be an Object in JQLite decorator, but swapped out for a Map
- * for performance reasons and convenience methods. A proxy is available for
- * additional logic handling.
  *
  * @type {Map<number, import('../interface.ts').ExpandoStore>}
  */

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/dom.d.ts

@@ -240,6 +240,12 @@ export function domInsert(
   parentElement: any,
   afterElement: any,
 ): void;
+/**
+ * Returns the base href of the document.
+ *
+ * @returns {string} The base href.
+ */
+export function getBaseHref(): string;
 /**
  * A list of boolean attributes in HTML.
  * @type {string[]}

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/test-utils.d.ts

@@ -6,6 +6,7 @@
 export function browserTrigger(element: HTMLElement, options: any): void;
 /**
  * Delays execution for a specified number of milliseconds.
+ * TODO remove
  *
  * @param {number} [t=0] - The number of milliseconds to wait. Defaults to 0.
  * @returns {Promise<void>} A promise that resolves after the delay.

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

@@ -0,0 +1,46 @@
+/**
+ * A normalized representation of a parsed URL.
+ */
+export interface ParsedUrl {
+  /**
+   * The full URL string, including protocol, host, path, query, and hash.
+   * Example: "https://example.com:8080/path?query=1#section"
+   */
+  href: string;
+  /**
+   * The protocol scheme of the URL, without the trailing colon.
+   * Example: "http" or "https"
+   */
+  protocol: string;
+  /**
+   * The host part of the URL, including hostname and port (if specified).
+   * Example: "example.com:8080"
+   */
+  host: string;
+  /**
+   * The query string portion of the URL, without the leading "?".
+   * Example: "query=1&sort=asc"
+   */
+  search: string;
+  /**
+   * The fragment identifier (hash) of the URL, without the leading "#".
+   * Example: "section2"
+   */
+  hash: string;
+  /**
+   * The domain or IP address (including IPv6 in brackets) of the URL.
+   * Example: "example.com" or "[::1]"
+   */
+  hostname: string;
+  /**
+   * The port number of the URL as a string, or an empty string if not specified.
+   * Example: "8080" or ""
+   */
+  port: string;
+  /**
+   * The path of the URL, always beginning with a leading slash.
+   * Example: "/path/to/resource"
+   */
+  pathname: string;
+}
+export type ResolvableUrl = string | ParsedUrl;