@angular-wave/angular.ts 0.15.0 → 0.15.1

package/@types/router/state/state-object.d.ts

@@ -1,4 +1,3 @@
-/** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
 /**
  * Internal representation of a ng-router state.
  *
@@ -8,9 +7,9 @@
  *
  * This class prototypally inherits from the corresponding [[StateDeclaration]].
  * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
- * @implements {StateDeclaration}
+ * @implements {ng.StateDeclaration}
  */
-export class StateObject implements StateDeclaration {
+export class StateObject implements ng.StateDeclaration {
   /**
    * @param {import('./interface.ts').StateDeclaration} config
    */
@@ -27,7 +26,7 @@ export class StateObject implements StateDeclaration {
    * @type {ng.StateDeclaration|ng.BuiltStateDeclaration}
    */
   self: ng.StateDeclaration | ng.BuiltStateDeclaration;
-  __stateObjectCache: {
+  _stateObjectCache: {
     nameGlob: Glob;
   };
   /**
@@ -79,5 +78,4 @@ export namespace StateObject {
   /** Predicate which returns true if the object is an internal [[StateObject]] object */
   function isState(obj: any): boolean;
 }
-export type StateDeclaration = import("./interface.ts").StateDeclaration;
 import { Glob } from "../glob/glob.js";

package/@types/router/state/state-queue-manager.d.ts

@@ -1,21 +1,22 @@
 export class StateQueueManager {
   /**
    * @param {import("./state-registry.js").StateRegistryProvider} stateRegistry
-   * @param {*} urlServiceRules
-   * @param {Record<string, ng.StateObject>} states
+   * @param {import("../url/url-rules.js").UrlRules} urlServiceRules
+   * @param {import("./interface.ts").StateStore} states
    * @param {*} builder
    * @param {*} listeners
    */
   constructor(
     stateRegistry: import("./state-registry.js").StateRegistryProvider,
-    urlServiceRules: any,
-    states: Record<string, ng.StateObject>,
+    urlServiceRules: import("../url/url-rules.js").UrlRules,
+    states: import("./interface.ts").StateStore,
     builder: any,
     listeners: any,
   );
   stateRegistry: import("./state-registry.js").StateRegistryProvider;
-  urlServiceRules: any;
-  states: Record<string, StateObject>;
+  /** @type {import("../url/url-rules.js").UrlRules} */
+  urlServiceRules: import("../url/url-rules.js").UrlRules;
+  states: import("./interface.ts").StateStore;
   builder: any;
   listeners: any;
   /**
@@ -23,7 +24,12 @@ export class StateQueueManager {
    */
   queue: Array<StateObject>;
   register(stateDecl: any): StateObject;
-  flush(): Record<string, StateObject>;
-  attachRoute(state: any): void;
+  flush(): import("./interface.ts").StateStore;
+  /**
+   *
+   * @param {ng.StateDeclaration} state
+   * @returns {() => void} a function that deregisters the rule
+   */
+  attachRoute(state: ng.StateDeclaration): () => void;
 }
 import { StateObject } from "./state-object.js";

package/@types/router/state/state-registry.d.ts

@@ -19,8 +19,8 @@ export class StateRegistryProvider {
     globals: ng.RouterService,
     viewService: ng.ViewService,
   );
-  /** @type {Record<string, import("./state-object.js").StateObject>} */
-  states: Record<string, import("./state-object.js").StateObject>;
+  /** @type {import("./interface.ts").StateStore} */
+  states: import("./interface.ts").StateStore;
   urlService: import("../url/url-service.js").UrlService;
   urlServiceRules: import("../url/url-rules.js").UrlRules;
   $injector: any;
@@ -115,7 +115,16 @@ export class StateRegistryProvider {
    * @return {ng.BuiltStateDeclaration[]}
    */
   getAll(): ng.BuiltStateDeclaration[];
-  get(stateOrName: any, base: any, ...args: any[]): any;
+  get(
+    stateOrName: any,
+    base: any,
+    ...args: any[]
+  ):
+    | import("./interface.ts").StateDeclaration
+    | (
+        | import("./interface.ts").StateDeclaration
+        | import("./interface.ts").BuiltStateDeclaration
+      )[];
   /**
    * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
    * More than one BuilderFunction can be registered for a given property.

package/@types/router/state/state-service.d.ts

@@ -34,8 +34,14 @@ export class StateProvider {
    * @deprecated This is a passthrough through to [[Router.$current]]
    */
   get $current(): import("./state-object.js").StateObject;
-  globals: import("../router.js").RouterProvider;
-  transitionService: import("../transition/transition-service.js").TransitionProvider;
+  /**
+   * @type {ng.RouterProvider}
+   */
+  globals: ng.RouterProvider;
+  /**
+   * @type {ng.TransitionProvider}
+   */
+  transitionService: ng.TransitionProvider;
   stateRegistry: any;
   /** @type {ng.UrlService} */
   urlService: ng.UrlService;

package/@types/router/transition/hook-registry.d.ts

@@ -16,12 +16,22 @@ export function matchState(
   criterion: any,
   transition: any,
 ): boolean;
-/** Return a registration function of the requested type. */
+/**
+ * Return a registration function of the requested type.
+ * @param {ng.TransitionProvider| import("./transition.js").Transition} hookSource
+ * @param {ng.TransitionProvider} transitionService
+ * @param {import("./transition-event-type.js").TransitionEventType} eventType
+ * @returns {( matchObject: any, callback: Function, options?: Record<string, any> ) => () => void }
+ */
 export function makeEvent(
-  registry: any,
-  transitionService: any,
-  eventType: any,
-): (matchObject: any, callback: any, options?: {}) => any;
+  hookSource: ng.TransitionProvider | import("./transition.js").Transition,
+  transitionService: ng.TransitionProvider,
+  eventType: import("./transition-event-type.js").TransitionEventType,
+): (
+  matchObject: any,
+  callback: Function,
+  options?: Record<string, any>,
+) => () => void;
 /**
  * The registration data for a registered transition hook
  */

package/@types/router/transition/transition.d.ts

@@ -29,8 +29,10 @@ export class Transition implements HookRegistry {
    * @type {import('../router.js').RouterProvider}
    */
   _globals: import("../router.js").RouterProvider;
-  _transitionService: import("./transition-service.js").TransitionProvider;
-  _deferred: any;
+  /** @type {ng.TransitionProvider} */
+  _transitionProvider: ng.TransitionProvider;
+  /** @type {PromiseWithResolvers<any>} */
+  _deferred: PromiseWithResolvers<any>;
   /**
    * This promise is resolved or rejected based on the outcome of the Transition.
    *

package/@types/router/url/url-rules.d.ts

@@ -14,89 +14,7 @@ export class UrlRules {
   _sortFn: typeof defaultRuleSortFn;
   _rules: any[];
   _id: number;
-  urlRuleFactory: UrlRuleFactory;
-  /**
-   * Defines the initial state, path, or behavior to use when the app starts.
-   *
-   * This rule defines the initial/starting state for the application.
-   *
-   * This rule is triggered the first time the URL is checked (when the app initially loads).
-   * The rule is triggered only when the url matches either `""` or `"/"`.
-   *
-   * Note: The rule is intended to be used when the root of the application is directly linked to.
-   * When the URL is *not* `""` or `"/"` and doesn't match other rules, the [[otherwise]] rule is triggered.
-   * This allows 404-like behavior when an unknown URL is deep-linked.
-   *
-   * #### Example:
-   * Start app at `home` state.
-   * ```js
-   * .initial({ state: 'home' });
-   * ```
-   *
-   * #### Example:
-   * Start app at `/home` (by url)
-   * ```js
-   * .initial('/home');
-   * ```
-   *
-   * #### Example:
-   * When no other url rule matches, go to `home` state
-   * ```js
-   * .initial((matchValue, url, router) => {
-   *   console.log('initial state');
-   *   return { state: 'home' };
-   * })
-   * ```
-   *
-   * @param handler The initial state or url path, or a function which returns the state or url path (or performs custom logic).
-   */
-  initial(handler: any): void;
-  /**
-   * Defines the state, url, or behavior to use when no other rule matches the URL.
-   *
-   * This rule is matched when *no other rule* matches.
-   * It is generally used to handle unknown URLs (similar to "404" behavior, but on the client side).
-   *
-   * - If `handler` a string, it is treated as a url redirect
-   *
-   * #### Example:
-   * When no other url rule matches, redirect to `/index`
-   * ```js
-   * .otherwise('/index');
-   * ```
-   *
-   * - If `handler` is an object with a `state` property, the state is activated.
-   *
-   * #### Example:
-   * When no other url rule matches, redirect to `home` and provide a `dashboard` parameter value.
-   * ```js
-   * .otherwise({ state: 'home', params: { dashboard: 'default' } });
-   * ```
-   *
-   * - If `handler` is a function, the function receives the current url ([[UrlParts]]) and the [[UIRouter]] object.
-   *   The function can perform actions, and/or return a value.
-   *
-   * #### Example:
-   * When no other url rule matches, manually trigger a transition to the `home` state
-   * ```js
-   * .otherwise((matchValue, urlParts, router) => {
-   *   router.stateService.go('home');
-   * });
-   * ```
-   *
-   * #### Example:
-   * When no other url rule matches, go to `home` state
-   * ```js
-   * .otherwise((matchValue, urlParts, router) => {
-   *   return { state: 'home' };
-   * });
-   * ```
-   *
-   * @param handler The url path to redirect to, or a function which returns the url path (or performs custom logic).
-   */
-  otherwise(handler: any): void;
-  _otherwiseFn: import("./url-rule.js").BaseUrlRule;
-  _sorted: boolean;
+  _urlRuleFactory: UrlRuleFactory;
   /**
    * Remove a rule previously registered
    *
@@ -113,9 +31,10 @@ export class UrlRules {
    * A rule should have a `match` function which returns truthy if the rule matched.
    * It should also have a `handler` function which is invoked if the rule is the best match.
    *
-   * @return a function that deregisters the rule
+   * @returns {() => void } a function that deregisters the rule
    */
   rule(rule: any): () => void;
+  _sorted: boolean;
   /**
    * Gets all registered rules
    *

package/@types/router/url/url-service.d.ts

@@ -5,13 +5,13 @@ export class UrlService {
   static $inject: string[];
   /**
    * @param {ng.LocationProvider} $locationProvider
-   * @param {import("../../router/state/state-service.js").StateProvider} stateService
+   * @param {import("../../router/state/state-service.js").StateProvider} stateProvider
    * @param {import("../router.js").RouterProvider} globals
    * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
    */
   constructor(
     $locationProvider: ng.LocationProvider,
-    stateService: import("../../router/state/state-service.js").StateProvider,
+    stateProvider: import("../../router/state/state-service.js").StateProvider,
     globals: import("../router.js").RouterProvider,
     urlConfigProvider: import("../../router/url/url-config.js").UrlConfigProvider,
   );
@@ -20,20 +20,21 @@ export class UrlService {
   /** @private */
   private _locationProvider;
   stateService: import("../../router/state/state-service.js").StateProvider;
-  /** Provides services related to the URL */
-  urlRuleFactory: UrlRuleFactory;
+  /** @type {UrlRuleFactory} Provides services related to the URL */
+  _urlRuleFactory: UrlRuleFactory;
   /**
    * The nested [[UrlRules]] API for managing URL rules and rewrites
+   * @ignore
    * @type {UrlRules}
    */
-  rules: UrlRules;
+  _rules: UrlRules;
   /**
    * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
    * @type {import("./url-config.js").UrlConfigProvider}
    */
-  config: import("./url-config.js").UrlConfigProvider;
-  /** Creates a new [[Param]] for a given location (DefType) */
-  paramFactory: ParamFactory;
+  _config: import("./url-config.js").UrlConfigProvider;
+  /** @type {ParamFactory} Creates a new [[Param]] for a given location (DefType) */
+  _paramFactory: ParamFactory;
   _urlListeners: any[];
   /**
    * Gets the path part of the current url

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

@@ -5,10 +5,7 @@
 export class CookieProvider {
   /** @type {ng.CookieOptions} */
   defaults: ng.CookieOptions;
-  $get: (
-    | string
-    | (($exceptionHandler: ng.ExceptionHandlerService) => CookieService)
-  )[];
+  $get: () => CookieService;
 }
 /**
  *
@@ -21,16 +18,10 @@ export class CookieService {
   /**
    * @param {ng.CookieOptions} defaults
    *   Default cookie attributes defined by `$cookiesProvider.defaults`.
-   * @param {ng.ExceptionHandlerService} $exceptionHandler
    */
-  constructor(
-    defaults: ng.CookieOptions,
-    $exceptionHandler: ng.ExceptionHandlerService,
-  );
+  constructor(defaults: ng.CookieOptions);
   /** @private @type {ng.CookieOptions} */
   private _defaults;
-  /** @private @type {ng.ExceptionHandlerService} */
-  private _$exceptionHandler;
   /**
    * Retrieves a raw cookie value.
    *
@@ -61,6 +52,7 @@ export class CookieService {
    * @param {string} key
    * @param {string} value
    * @param {ng.CookieOptions} [options]
+   * @throws {URIError} if key or value cannot be encoded
    */
   put(key: string, value: string, options?: ng.CookieOptions): void;
   /**

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

@@ -23,21 +23,7 @@ export function defaultHttpResponseTransform(data: any, headers: any): any;
  */
 export function HttpProvider(): void;
 export class HttpProvider {
-  defaults: {
-    transformResponse: (typeof defaultHttpResponseTransform)[];
-    transformRequest: ((data: any) => any)[];
-    headers: {
-      common: {
-        Accept: string;
-      };
-      post: any;
-      put: any;
-      patch: any;
-    };
-    xsrfCookieName: string;
-    xsrfHeaderName: string;
-    paramSerializer: string;
-  };
+  defaults: import("./interface.ts").HttpProviderDefaults;
   /**
    * Configure $http service to combine processing of multiple http responses received at around
    * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
@@ -62,8 +48,11 @@ export class HttpProvider {
    * array, on request, but reverse order, on response.
    *
    * {@link ng.$http#interceptors Interceptors detailed info}
+   * @type {Array<string | ng.Injectable<import("./interface.ts").HttpInterceptorFactory>>}
    */
-  interceptors: any[];
+  interceptors: Array<
+    string | ng.Injectable<import("./interface.ts").HttpInterceptorFactory>
+  >;
   /**
    * Array containing URLs whose origins are trusted to receive the XSRF token. See the
    * {@link ng.$http#security-considerations Security Considerations} sections for more details on
@@ -118,21 +107,7 @@ export class HttpProvider {
          *
          * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
          */
-        defaults: {
-          transformResponse: (typeof defaultHttpResponseTransform)[];
-          transformRequest: ((data: any) => any)[];
-          headers: {
-            common: {
-              Accept: string;
-            };
-            post: any;
-            put: any;
-            patch: any;
-          };
-          xsrfCookieName: string;
-          xsrfHeaderName: string;
-          paramSerializer: string;
-        };
+        defaults: import("./interface.ts").HttpProviderDefaults;
       })
   )[];
 }

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

@@ -4,6 +4,14 @@ export interface HttpHeadersGetter {
   };
   (headerName: string): string;
 }
+export interface HttpPromiseCallback<T> {
+  (
+    data: T,
+    status: number,
+    headers: HttpHeadersGetter,
+    config: RequestConfig,
+  ): void;
+}
 export interface HttpRequestConfigHeaders {
   [requestType: string]: any;
   common?: any;
@@ -18,6 +26,9 @@ export interface HttpRequestTransformer {
 export interface HttpResponseTransformer {
   (data: any, headersGetter: HttpHeadersGetter, status: number): any;
 }
+export interface HttpHeaderType {
+  [requestType: string]: string | ((config: RequestConfig) => string);
+}
 /**
  * Object that controls the defaults for $http provider. Not all fields of RequestShortcutConfig can be configured
  * via defaults and the docs do not say which. The following is based on the inspection of the source code.
@@ -228,3 +239,14 @@ export type HttpParams = Record<
  * A function that serializes an object into a URL-encoded query string.
  */
 export type HttpParamSerializer = (params?: HttpParams) => string;
+export interface HttpInterceptor {
+  request?(config: RequestConfig): RequestConfig | Promise<RequestConfig>;
+  requestError?(rejection: any): RequestConfig | Promise<RequestConfig>;
+  response?<T>(
+    response: HttpResponse<T>,
+  ): Promise<HttpResponse<T>> | HttpResponse<T>;
+  responseError?<T>(rejection: any): Promise<HttpResponse<T>> | HttpResponse<T>;
+}
+export interface HttpInterceptorFactory {
+  (...args: any[]): HttpInterceptor;
+}

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 */