@angular-wave/angular.ts 0.15.0 → 0.15.2

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

@@ -182,13 +182,13 @@ export class Location {
    * Current url
    * @type {string}
    */
-  $$url: string;
+  _url: string;
   /**
    * @ignore
    * Callback to update browser url
-   * @type {Function}
+   * @type {Function | undefined}
    */
-  $$updateBrowser: Function;
+  _updateBrowser: Function | undefined;
   /**
    * Change path, search and hash, when called with parameter and return `$location`.
    *
@@ -249,7 +249,7 @@ export class Location {
    * @private
    * Compose url and update `url` and `absUrl` property
    */
-  private $$compose;
+  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`.
@@ -285,15 +285,16 @@ export class LocationProvider {
   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;
+  /** @private @type {Array<import("./interface.ts").UrlChangeListener>} */
+  private _urlChangeListeners;
+  /** @private */
+  private _urlChangeInit;
+  /** @private @type {History['state']} */
+  private _cachedState;
+  /** @private @type {History['state']} */
+  private _lastHistoryState;
+  /** @private @type {string} */
+  private _lastBrowserUrl;
   /**
    * Updates the browser's current URL and history state.
    *

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

@@ -0,0 +1,25 @@
+export interface SCEService {
+  getTrusted(type: string, mayBeTrusted: any): any;
+  getTrustedCss(value: any): any;
+  getTrustedHtml(value: any): any;
+  getTrustedJs(value: any): any;
+  getTrustedResourceUrl(value: any): any;
+  getTrustedUrl(value: any): any;
+  parse(type: string, expression: string): (context: any, locals: any) => any;
+  parseAsCss(expression: string): (context: any, locals: any) => any;
+  parseAsHtml(expression: string): (context: any, locals: any) => any;
+  parseAsJs(expression: string): (context: any, locals: any) => any;
+  parseAsResourceUrl(expression: string): (context: any, locals: any) => any;
+  parseAsUrl(expression: string): (context: any, locals: any) => any;
+  trustAs(type: string, value: any): any;
+  trustAsHtml(value: any): any;
+  trustAsJs(value: any): any;
+  trustAsResourceUrl(value: any): any;
+  trustAsUrl(value: any): any;
+  isEnabled(): boolean;
+}
+export interface SCEDelegateService {
+  getTrusted(type: string, mayBeTrusted: any): any;
+  trustAs(type: string, value: any): any;
+  valueOf(value: any): any;
+}

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

@@ -32,11 +32,18 @@ export interface SseConfig {
 export interface SseConnection {
   /** Manually close the SSE connection and stop all reconnect attempts */
   close(): void;
-  /** Manually restart the SSE connection */
+  /**
+   * Manually restart the SSE connection.
+   * @remarks
+   * Any previous event listeners are preserved; reconnects use the original configuration.
+   */
   connect(): void;
 }
 /**
  * $sse service type
  * Returns a managed SSE connection that automatically reconnects when needed.
+ * @param url - The endpoint to connect to
+ * @param config - Optional configuration object
+ * @throws {URIError} If the URL is invalid
  */
 export type SseService = (url: string, config?: SseConfig) => SseConnection;

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

@@ -1,23 +1,15 @@
-/**
- * SSE Provider
- *
- * Usage:
- *   const source = $sse('/events', {
- *     onMessage: (data) => console.log(data),
- *     onError: (err) => console.error(err),
- *     retryDelay: 2000,
- *     heartbeatTimeout: 10000,
- *   });
- *
- *   source.close();
- */
 export class SseProvider {
-  /**
-   * Optional provider-level defaults
-   * @type {ng.SseConfig}
-   */
+  /** @type {ng.SseConfig} */
   defaults: ng.SseConfig;
-  $get: (string | ((log: ng.LogService) => ng.SseService))[];
+  $get: (
+    | string
+    | ((
+        log: ng.LogService,
+      ) => (
+        url: string,
+        config?: import("./interface.ts").SseConfig,
+      ) => import("./interface.ts").SseConnection)
+  )[];
   _$log: import("../log/interface.ts").LogService;
   #private;
 }

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

@@ -2,18 +2,18 @@
  * Creates a proxy that automatically persists an object's state
  * into a storage backend whenever a property is set.
  *
- * @param {object} target - The object to wrap
+ * @param {Record<PropertyKey, any>} target - The object to wrap
  * @param {string} key - The storage key
- * @param {object} storage - Any storage-like object with getItem/setItem/removeItem
+ * @param {import("../../core/di/inteface").StorageLike & import("../../core/di/inteface").PersistentStoreConfig} storage - Any storage-like object with getItem/setItem/removeItem
  * @param {{serialize?: function, deserialize?: function}} [options] - Optional custom (de)serialization
- * @returns {Proxy}
+ * @returns {Record<PropertyKey, any>}
  */
 export function createPersistentProxy(
-  target: object,
+  target: Record<PropertyKey, any>,
   key: string,
-  storage: object,
+  storage: any & any,
   options?: {
     serialize?: Function;
     deserialize?: Function;
   },
-): ProxyConstructor;
+): Record<PropertyKey, any>;

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

@@ -2,7 +2,7 @@ export interface StreamConnectionConfig {
   /** Called when the connection opens */
   onOpen?: (event: Event) => void;
   /** Called when a message is received */
-  onMessage?: (data: any, event: Event) => void;
+  onMessage?: (data: any, event: Event | MessageEvent) => void;
   /** Called when an error occurs */
   onError?: (err: any) => void;
   /** Called when a reconnect attempt happens */

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

@@ -0,0 +1,98 @@
+/**
+ * Shared Stream Connection Manager
+ * Handles reconnect, heartbeat, and event callbacks for SSE or WebSocket
+ */
+export class StreamConnection {
+  /**
+   * @param {() => EventSource | WebSocket} createFn - Function that creates a new EventSource or WebSocket.
+   * @param {ng.StreamConnectionConfig} config - Configuration object with callbacks, retries, heartbeat, transformMessage.
+   * @param {ng.LogService} log - Optional logger (default: console).
+   */
+  constructor(
+    createFn: () => EventSource | WebSocket,
+    config?: ng.StreamConnectionConfig,
+    log?: ng.LogService,
+  );
+  /** @private @type {() => EventSource | WebSocket} */
+  private _createFn;
+  _config: {
+    onOpen?: (event: Event) => void;
+    onMessage?: (data: any, event: Event | MessageEvent) => void;
+    onError?: (err: any) => void;
+    onReconnect?: (attempt: number) => void;
+    retryDelay: number;
+    maxRetries: number;
+    heartbeatTimeout: number;
+    transformMessage: (data: string) => any;
+  };
+  _log: import("../log/interface.ts").LogService;
+  _retryCount: number;
+  _closed: boolean;
+  _heartbeatTimer: number;
+  /** @type {EventSource | WebSocket | null} */
+  _connection: EventSource | WebSocket | null;
+  /**
+   * Establishes a new connection using the provided createFn.
+   * Closes any existing connection before creating a new one.
+   */
+  connect(): void;
+  /**
+   * Sends data over a WebSocket connection.
+   * Logs a warning if called on a non-WebSocket connection.
+   * @param {any} data - Data to send.
+   */
+  send(data: any): void;
+  /**
+   * Closes the connection manually and clears the heartbeat timer.
+   */
+  close(): void;
+  /**
+   * @private
+   * Binds event handlers to the underlying connection (EventSource or WebSocket)
+   * for open, message, error, and close events.
+   */
+  private _bindEvents;
+  /**
+   * @private
+   * Handles the open event from the connection.
+   * @param {Event} event - The open event.
+   */
+  private _handleOpen;
+  /**
+   * @private
+   * Handles incoming messages, applies the transformMessage function,
+   * and calls the onMessage callback.
+   * @param {any} data - Raw message data.
+   * @param {Event} event - The message event.
+   */
+  private _handleMessage;
+  /**
+   * @private
+   * Handles errors emitted from the connection.
+   * Calls onError callback and schedules a reconnect.
+   * @param {any} err - Error object or message.
+   */
+  private _handleError;
+  /**
+   * @private
+   * Handles close events for WebSocket connections.
+   * Triggers reconnect logic.
+   */
+  private _handleClose;
+  /**
+   * @private
+   * Schedules a reconnect attempt based on retryCount and config.maxRetries.
+   * Calls onReconnect callback if reconnecting.
+   */
+  private _scheduleReconnect;
+  /**
+   * @private
+   * Resets the heartbeat timer. If the timer expires, the connection is closed
+   * and a reconnect is attempted.
+   */
+  private _resetHeartbeat;
+  /**
+   * @private
+   */
+  private _closeInternal;
+}

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

@@ -7,16 +7,9 @@ export interface TemplateRequestService {
    * empty then a $compile error will be thrown (unless
    * {ignoreRequestError} is set to true).
    *
-   * @param tpl                  The template URL.
-   * @param ignoreRequestError   Whether or not to ignore the exception
-   *                             when the request fails or the template is
-   *                             empty.
+   * @param templateUrl The template URL.
    *
    * @return   A promise whose value is the template content.
    */
-  (tpl: string, ignoreRequestError?: boolean): Promise<string>;
-  /**
-   * total amount of pending template requests being downloaded.
-   */
-  totalPendingRequests: number;
+  (templateUrl: string): Promise<string>;
 }

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

@@ -1,52 +1,19 @@
 /**
- * Used to configure the options passed to the {@link $http} service when making a template request.
+ * Provider for the `$templateRequest` service.
  *
- * For example, it can be used for specifying the "Accept" header that is sent to the server, when
- * requesting a template.
+ * Fetches templates via HTTP and caches them in `$templateCache`.
+ * Templates are assumed trusted. This provider allows configuring
+ * per-request `$http` options such as headers, timeout, or transform functions.
  */
-export function TemplateRequestProvider(): void;
 export class TemplateRequestProvider {
-  /**
-   * The options to be passed to the {@link $http} service when making the request.
-   * You can use this to override options such as the "Accept" header for template requests.
-   * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
-   * options if not overridden here.
-   *
-   * @param {string=} val new value for the {@link $http} options.
-   * @returns {string|TemplateRequestProvider} Returns the {@link $http} options when used as getter and self if used as setter.
-   */
-  httpOptions: (val?: string | undefined) => string | TemplateRequestProvider;
-  /**
-   * The `$templateRequest` service runs security checks then downloads the provided template using
-   * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
-   * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
-   * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
-   * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
-   * when `tpl` is of type string and `$templateCache` has the matching entry.
-   *
-   * If you want to pass custom options to the `$http` service, such as setting the Accept header you
-   * can configure this via {@link $templateRequestProvider#httpOptions}.
-   *
-   * `$templateRequest` is used internally by {@link $compile}, {@link ngRoute.$route}, and directives such
-   * as {@link ngInclude} to download and cache templates.
-   *
-   * 3rd party modules should use `$templateRequest` if their services or directives are loading
-   * templates.
-   *
-   * @param {string} tpl The HTTP request template URL
-   * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
-   *
-   * @return {Promise} a promise for the HTTP response data of the given URL.
-   *
-   * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
-   */
+  /** @type {ng.RequestShortcutConfig|undefined} */
+  httpOptions: ng.RequestShortcutConfig | undefined;
+  /** @returns {Array} DI tokens for Angular.ts injection */
   $get: (
     | string
     | ((
-        $exceptionHandler: ng.ExceptionHandlerService,
         $templateCache: ng.TemplateCacheService,
         $http: ng.HttpService,
-        $sce: any,
       ) => ng.TemplateRequestService)
   )[];
 }

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

@@ -113,10 +113,10 @@ export function applyPairs(memo: any, keyValTuple: any): any;
 /**
  * Returns the last element of an array, or undefined if the array is empty.
  * @template T
- * @param {T[]} arr - The input array.
+ * @param {any[]|string} arr - The input array.
  * @returns {T | undefined} The last element or undefined.
  */
-export function tail<T>(arr: T[]): T | undefined;
+export function tail<T>(arr: any[] | string): T | undefined;
 /**
  * shallow copy from src to dest
  */

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

@@ -37,16 +37,6 @@ export function getExpando(
  * @returns {boolean} True if the string is plain text, false if it contains HTML tags or entities.
  */
 export function isTextNode(html: string): boolean;
-/**
- * @param {string} html
- * @returns {DocumentFragment}
- */
-export function buildFragment(html: string): DocumentFragment;
-/**
- * @param {string} html
- * @returns {NodeListOf<ChildNode> | HTMLElement[]}
- */
-export function parseHtml(html: string): NodeListOf<ChildNode> | HTMLElement[];
 /**
  * @param {Element} element
  * @param {boolean} [onlyDescendants]
@@ -144,18 +134,6 @@ export function getController(
  * @returns
  */
 export function getInheritedData(element: Node, name: string): any;
-/**
- *
- * @param {Node} element
- * @param {string|string[]} name
- * @param {any} [value]
- * @returns {any|undefined}
- */
-export function setInheritedData(
-  element: Node,
-  name: string | string[],
-  value?: any,
-): any | undefined;
 /**
  *
  * @param {Element} element
@@ -172,9 +150,9 @@ export function startingTag(elementOrStr: string | Element | Node): string;
 /**
  * Return the DOM siblings between the first and last node in the given array.
  * @param {Array<Node>} nodes An array-like object
- * @returns {Element} the inputted object or a JQLite collection containing the nodes
+ * @returns {*[]|Array<Node>} the inputted object or a JQLite collection containing the nodes
  */
-export function getBlockNodes(nodes: Array<Node>): Element;
+export function getBlockNodes(nodes: Array<Node>): any[] | Array<Node>;
 /**
  * Gets the name of a boolean attribute if it exists on a given element.
  *
@@ -210,26 +188,11 @@ export function createElementFromHTML(htmlString: string): Element;
  * @returns {NodeList} - The parsed DOM element.
  */
 export function createNodelistFromHTML(htmlString: string): NodeList;
-/**
- * Appends nodes or an HTML string to a given DOM element.
- * @param {Element} element - The element to append nodes to.
- * @param {Node | Node[] | string} nodes - Nodes or HTML string to append.
- */
-export function appendNodesToElement(
-  element: Element,
-  nodes: Node | Node[] | string,
-): void;
 /**
  * Remove element from the DOM and clear Cache data, associated with the node.
  * @param {Element} element
  */
 export function emptyElement(element: Element): void;
-/**
- * Checks if the element is root
- * @param {Element} element
- * @returns {boolean}
- */
-export function isRoot(element: Element): boolean;
 /**
  * Inserts a DOM element before or at the beginning of a parent element.
  *
@@ -239,7 +202,7 @@ export function isRoot(element: Element): boolean;
  * @param {HTMLElement | Element} parentElement
  *   The parent element that will receive the inserted element.
  *
- * @param {HTMLElement | Element | null} [afterElement]
+ * @param {ChildNode | Element | null} [afterElement]
  *   An optional sibling element — if present and valid, `element`
  *   will be inserted after it. If omitted or invalid, `element`
  *   is prepended to `parentElement`.
@@ -249,15 +212,31 @@ export function isRoot(element: Element): boolean;
 export function domInsert(
   element: HTMLElement | Element,
   parentElement: HTMLElement | Element,
-  afterElement?: HTMLElement | Element | null,
+  afterElement?: ChildNode | Element | null,
+): void;
+/**
+ * @param {HTMLElement} element
+ * @param {HTMLElement} parent
+ * @param {ChildNode | null | undefined} after
+ */
+export function animatedomInsert(
+  element: HTMLElement,
+  parent: HTMLElement,
+  after: ChildNode | null | undefined,
 ): void;
-export function animatedomInsert(element: any, parent: any, after: any): void;
 /**
  * Returns the base href of the document.
  *
  * @returns {string} The base href.
  */
 export function getBaseHref(): string;
+/**
+ * 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
+ *
+ * @type {Map<number, import('../interface.ts').ExpandoStore>}
+ */
+export const Cache: Map<number, import("../interface.ts").ExpandoStore>;
 /**
  * A list of boolean attributes in HTML.
  * @type {string[]}

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

@@ -36,17 +36,10 @@
  *
  * ```
  *
- * @param fn
+ * @param {Function} fn
  * @returns {*|function(): (*|any)}
  */
-export function curry(fn: any): any | (() => any | any);
-/**
- * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left
- * given: f(x), g(x), h(x)
- * let composed = compose(f,g,h)
- * then, composed is: f(g(h(x)))
- */
-export function compose(...fns: any[]): (...args: any[]) => any;
+export function curry(fn: Function): any | (() => any | any);
 /**
  * Given a class constructor, returns a predicate function that checks
  * whether a given object is an instance of that class.
@@ -69,33 +62,30 @@ export function is(ctor: new (...args: any[]) => any): (obj: any) => boolean;
  * of size 2: [ predicate, mapFn ]
  *
  * These 2-tuples should be put in an outer array.
- *
- * @example
- * ```
- *
- * // Here's a 2-tuple where the first element is the isString predicate
- * // and the second element is a function that returns a description of the input
- * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
- *
- * // Second tuple: predicate "isNumber", mapfn returns a description
- * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
- *
- * let third = [ (input) => input === null,  (input) => `Oh, null...` ];
- *
- * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
- *
- * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
- *
- * console.log(descriptionOf(undefined)); // 'notdefined'
- * console.log(descriptionOf(55)); // '(55) That's a number!'
- * console.log(descriptionOf("foo")); // 'Here's your string foo'
- * ```
- *
- * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,
- * with a Predicate and a mapping/output function
- * @returns {function(any): *}
+ * @example ```
+
+// Here's a 2-tuple where the first element is the isString predicate
+// and the second element is a function that returns a description of the input
+let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
+
+// Second tuple: predicate "isNumber", mapfn returns a description
+let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
+
+let third = [ (input) => input === null,  (input) => `Oh, null...` ];
+
+let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
+
+let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
+
+console.log(descriptionOf(undefined)); // 'notdefined'
+console.log(descriptionOf(55)); // '(55) That's a number!'
+console.log(descriptionOf("foo")); // 'Here's your string foo'
+```
+ * @param {string | any[]} struct A 2D array.  Each element of the array should be an array, a 2-tuple,
+with a Predicate and a mapping/output function
+ * @returns {function(any):*}
  */
-export function pattern(struct: any): (arg0: any) => any;
+export function pattern(struct: string | any[]): (arg0: any) => any;
 /**
  * Given a property name and a value, returns a function that returns a boolean based on whether
  * the passed object has a property that matches the value
@@ -104,5 +94,5 @@ export function pattern(struct: any): (arg0: any) => any;
  * getName(obj) === true
  */
 export const propEq: any;
-export function parse(path: any): (obj: any) => any;
-export function val(value: any): () => any;
+export function parse(path: string): (/** @type {any} */ obj: any) => any;
+export function val<T>(value: T): () => T;

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

@@ -9,11 +9,11 @@ export class NodeRef {
    * @throws {Error} If the argument is invalid or cannot be wrapped properly.
    */
   constructor(element: Node | Element | string | NodeList | Node[]);
-  /** @private @type {Node | ChildNode | null} */
+  /** @private @type {Node | ChildNode | undefined} */
   private _node;
   /** @type {Element | undefined} */
   _element: Element | undefined;
-  /** @private @type {Array<Node> | undefined} a stable list on nodes */
+  /** @private @type {Array<Node>} a stable list on nodes */
   private _nodes;
   /** @type {boolean} */
   _isList: boolean;

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

@@ -34,7 +34,11 @@ export function functionToString(fn: Function): string;
  * @returns {string}
  */
 export function fnToString(fn: [] | Function): string;
-export function stringify(value: any): any;
+/**
+ * @param {any} value
+ * @returns {string|*|string}
+ */
+export function stringify(value: any): string | any | string;
 /**
  * Splits on a delimiter, but returns the delimiters in the array
  *
@@ -44,8 +48,11 @@ export function stringify(value: any): any;
  * splitOnSlashes("/foo"); // ["/", "foo"]
  * splitOnSlashes("/foo/"); // ["/", "foo", "/"]
  * ```
+ * @param {string} delim
  */
-export function splitOnDelim(delim: any): (str: any) => any;
+export function splitOnDelim(
+  delim: string,
+): (/** @type {string} */ str: string) => string[];
 /**
  * Reduce fn that joins neighboring strings
  *
@@ -57,6 +64,8 @@ export function splitOnDelim(delim: any): (str: any) => any;
  * let arr = ["foo", "bar", 1, "baz", "", "qux" ];
  * arr.reduce(joinNeighborsR, []) // ["foobar", 1, "bazqux" ]
  * ```
+ * @param {string | any[]} acc
+ * @param {unknown} str
  */
-export function joinNeighborsR(acc: any, str: any): any;
-export function stripLastPathElement(str: any): any;
+export function joinNeighborsR(acc: string | any[], str: unknown): any;
+export function stripLastPathElement(str: string): string;