@angular-wave/angular.ts 0.14.3 → 0.15.1

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

@@ -1,17 +1,20 @@
 export class UrlRuleFactory {
   /**
-   * @param {import('../url/url-service.js').UrlService} urlService
-   * @param {import('../state/state-service.js').StateProvider} stateService
-   * @param {import('../router.js').Router} routerGlobals
+   * @param {ng.UrlService} urlService
+   * @param {ng.StateService} stateService
+   * @param {ng.RouterService} routerGlobals
    */
   constructor(
-    urlService: import("../url/url-service.js").UrlService,
-    stateService: import("../state/state-service.js").StateProvider,
-    routerGlobals: import("../router.js").Router,
+    urlService: ng.UrlService,
+    stateService: ng.StateService,
+    routerGlobals: ng.RouterService,
   );
-  urlService: import("../url/url-service.js").UrlService;
-  stateService: import("../state/state-service.js").StateProvider;
-  routerGlobals: import("../router.js").Router;
+  /** @type {ng.UrlService} */
+  urlService: ng.UrlService;
+  /** @type {ng.StateService} */
+  stateService: ng.StateService;
+  /** @type {ng.RouterService} */
+  routerGlobals: ng.RouterService;
   /**
    *
    * @param {*} what

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

@@ -4,35 +4,37 @@
 export class UrlService {
   static $inject: string[];
   /**
-   * @param {import("../../services/location/location").LocationProvider} $locationProvider
-   * @param {import("../../router/state/state-service.js").StateProvider} stateService
-   * @param {import("../router.js").Router} globals
+   * @param {ng.LocationProvider} $locationProvider
+   * @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: any,
-    stateService: import("../../router/state/state-service.js").StateProvider,
-    globals: import("../router.js").Router,
+    $locationProvider: ng.LocationProvider,
+    stateProvider: import("../../router/state/state-service.js").StateProvider,
+    globals: import("../router.js").RouterProvider,
     urlConfigProvider: import("../../router/url/url-config.js").UrlConfigProvider,
   );
-  /** @type {import("../../services/location/location").Location} */
-  $location: any;
-  $locationProvider: any;
+  /** @type {ng.LocationService} */
+  $location: ng.LocationService;
+  /** @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
@@ -60,7 +62,10 @@ export class UrlService {
   getHash(): string;
   $get: (
     | string
-    | (($location: ng.LocationService, $rootScope: ng.Scope) => UrlService)
+    | ((
+        $location: ng.LocationService,
+        $rootScope: ng.RootScopeService,
+      ) => ng.UrlService)
   )[];
   /**
    * @returns {string}
@@ -118,7 +123,7 @@ export class UrlService {
    *
    * @return the url (after potentially being processed)
    */
-  url(newUrl?: string, state?: any): any;
+  url(newUrl?: string, state?: any): string;
   /**
    * @private
    *
@@ -196,7 +201,7 @@ export class UrlService {
    */
   match(url: any): any;
   update(read: any): void;
-  location: any;
+  location: string;
   /**
    * Internal API.
    *

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

@@ -4,20 +4,20 @@ export class ViewService {
   _listeners: any[];
   $get: () => this;
   /**
-   * @param {?import('../state/state-object.js').StateObject} context
+   * @param {?import('../state/state-object.js').StateObject} [context]
    * @return {?import('../state/state-object.js').StateObject}
    */
   rootViewContext(
-    context: import("../state/state-object.js").StateObject | null,
+    context?: import("../state/state-object.js").StateObject | null,
   ): import("../state/state-object.js").StateObject | null;
   _rootContext: any;
-  viewConfigFactory(factory: any): void;
+  _viewConfigFactory(factory: any): void;
   /**
    * @param path
    * @param decl
    * @return {import("../state/views.js").ViewConfig}
    */
-  createViewConfig(
+  _createViewConfig(
     path: any,
     decl: any,
   ): import("../state/views.js").ViewConfig;

package/@types/services/anchor-scroll/anchor-scroll.d.ts

@@ -1,25 +1,10 @@
-/**
- * @typedef {Object} AnchorScrollObject
- * @property {number|function|Element} yOffset
- */
-/**
- * @typedef {(string) => void} AnchorScrollFunction
- */
-/**
- * @typedef {AnchorScrollFunction | AnchorScrollObject} AnchorScrollService
- */
 export class AnchorScrollProvider {
   autoScrollingEnabled: boolean;
   $get: (
     | string
     | ((
-        $location: import("../../services/location/location.js").Location,
+        $location: ng.LocationService,
         $rootScope: ng.Scope,
-      ) => AnchorScrollFunction)
+      ) => import("./interface.ts").AnchorScrollFunction)
   )[];
 }
-export type AnchorScrollObject = {
-  yOffset: number | Function | Element;
-};
-export type AnchorScrollFunction = (string: any) => void;
-export type AnchorScrollService = AnchorScrollFunction | AnchorScrollObject;

package/@types/services/anchor-scroll/interface.d.ts

@@ -0,0 +1,15 @@
+export interface AnchorScrollObject {
+  /**
+   * Vertical scroll offset.
+   * Can be a number, a function returning a number,
+   * or an Element whose offsetTop will be used.
+   */
+  yOffset?: number | (() => number) | Element;
+}
+export type AnchorScrollFunction = (hash?: string) => void;
+/**
+ * AngularJS $anchorScroll service
+ *
+ * Callable as a function and also exposes properties.
+ */
+export type AnchorScrollService = AnchorScrollFunction | AnchorScrollObject;

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

@@ -3,11 +3,9 @@
  * @type {ng.ServiceProvider}
  */
 export class CookieProvider {
-  defaults: {};
-  $get: (
-    | string
-    | (($exceptionHandler: ng.ExceptionHandlerService) => CookieService)
-  )[];
+  /** @type {ng.CookieOptions} */
+  defaults: ng.CookieOptions;
+  $get: () => CookieService;
 }
 /**
  *
@@ -20,15 +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,
-  );
-  /** @type {ng.CookieOptions} */
-  _defaults: ng.CookieOptions;
-  _$exceptionHandler: import("../exception/interface.ts").ExceptionHandler;
+  constructor(defaults: ng.CookieOptions);
+  /** @private @type {ng.CookieOptions} */
+  private _defaults;
   /**
    * Retrieves a raw cookie value.
    *
@@ -59,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/exception/interface.d.ts

@@ -1,7 +1,7 @@
 /**
  * A callback type for handling errors.
  *
- * @param {Error} exception - The exception associated with the error.
- * @throws {Error}
+ * @param {unknown} exception - The exception associated with the error.
+ * @throws {unknown}
  */
-export type ExceptionHandler = (exception: Error) => never;
+export type ExceptionHandler = (exception: unknown) => never;

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

@@ -11,13 +11,17 @@ export class LogProvider {
    * @param {import("./interface.ts").LogServiceFactory} fn
    */
   setLogger(fn: import("./interface.ts").LogServiceFactory): void;
-  /** @private */
-  private formatError;
+  /**
+   * @private
+   * @param {unknown} arg
+   *
+   */
+  private _formatError;
   /**
    * @private
    * @param {string} type
    */
-  private consoleLog;
+  private _consoleLog;
   /**
    * @returns {ng.LogService}
    */

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

@@ -1,23 +1,34 @@
-/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider
-
 /**
  * Configurable provider for an injectable event bus
- * @extends {ServiceProvider}
+ * @implements {ng.ServiceProvider}
  */
-export class PubSubProvider {
+export class PubSubProvider implements ng.ServiceProvider {
+  static $inject: string[];
+  /**
+   * @param {ng.ExceptionHandlerProvider} $exceptionHandler
+   * @param {ng.ServiceProvider} angularProvider
+   */
+  constructor(
+    $exceptionHandler: ng.ExceptionHandlerProvider,
+    angularProvider: ng.ServiceProvider,
+  );
   /**
    * @type {PubSub}
    */
   eventBus: PubSub;
-  $get: any[];
+  $get: () => PubSub;
 }
 export class PubSub {
+  /**
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
+   */
+  constructor($exceptionHandler: ng.ExceptionHandlerService);
   /** @private {Object<string, Array<{fn: Function, context: any}>>} */
   private _topics;
   /** @private */
   private _disposed;
-  /** @type {ng.ExceptionHandlerService} */
-  _$exceptionHandler: ng.ExceptionHandlerService;
+  /** @public @type {ng.ExceptionHandlerService} */
+  public $exceptionHandler: ng.ExceptionHandlerService;
   /**
    * Set instance to initial state
    */
@@ -72,9 +83,3 @@ export class PubSub {
    */
   publish(topic: string, ...args: any[]): boolean;
 }
-export const EventBus: PubSub;
-/**
- * /**
- * Configurable provider for an injectable event bus
- */
-export type ServiceProvider = import("../../interface.ts").ServiceProvider;

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

@@ -97,10 +97,12 @@ export class RestProvider {
    */
   $get: (
     | string
-    | (($http: any) => {
-        (baseUrl: any, entityClass: any, options?: {}): RestService<any, any>;
-        get(name: any): any;
-        listNames(): any[];
-      })
+    | ((
+        $http: ng.HttpService,
+      ) => (
+        baseUrl: string,
+        entityClass?: ng.EntityClass<T>,
+        options?: object,
+      ) => RestService<T, ID>)
   )[];
 }

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

@@ -1,5 +1,13 @@
 export function escapeForRegexp(str: any): any;
-export function adjustMatcher(matcher: any): any;
+/**
+ * Adjusts a matcher string or RegExp into a proper RegExp.
+ *
+ * @param {string | RegExp | "self"} matcher
+ * @returns {RegExp | "self"}
+ */
+export function adjustMatcher(
+  matcher: string | RegExp | "self",
+): RegExp | "self";
 export function SceProvider(): void;
 export class SceProvider {
   /**

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;