@angular-wave/angular.ts 0.14.3 → 0.15.0

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

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

@@ -11,9 +11,9 @@ export class NodeRef {
   constructor(element: Node | Element | string | NodeList | Node[]);
   /** @private @type {Node | ChildNode | null} */
   private _node;
-  /** @private @type {Element | undefined} */
-  private _element;
-  /** @private @type {Array<Node>} a stable list on nodes */
+  /** @type {Element | undefined} */
+  _element: Element | undefined;
+  /** @private @type {Array<Node> | undefined} a stable list on nodes */
   private _nodes;
   /** @type {boolean} */
   _isList: boolean;

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

@@ -15,13 +15,25 @@ export function maxLength(max: number, str: string): string;
  * If the string is already longer than the desired length, return the string.
  * Else returns the string, with extra spaces on the end, such that it reaches `length` characters.
  *
- * @param length the desired length of the string to return
- * @param str the input string
+ * @param {number} length the desired length of the string to return
+ * @param {string} str the input string
+ */
+export function padString(length: number, str: string): string;
+/**
+ * @param {string} camelCase
+ * @returns {string}
+ */
+export function kebobString(camelCase: string): string;
+/**
+ * @param {Function} fn
+ * @returns {string}
+ */
+export function functionToString(fn: Function): string;
+/**
+ * @param {[]|Function} fn
+ * @returns {string}
  */
-export function padString(length: any, str: any): any;
-export function kebobString(camelCase: any): any;
-export function functionToString(fn: any): any;
-export function fnToString(fn: any): any;
+export function fnToString(fn: [] | Function): string;
 export function stringify(value: any): any;
 /**
  * Splits on a delimiter, but returns the delimiters in the array

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

@@ -1,9 +1,22 @@
 /**
+ * @param {any} value
+ * @returns {value is Proxy<ng.Scope> | ng.Scope}
+ */
+export function isProxy(value: any): value is ProxyConstructor | ng.Scope;
+/**
+ * Unwraps a proxy if the value is a proxy, otherwise returns the value as-is.
  *
- * @param {*} value
- * @returns {boolean}
+ * @template T
+ * @param {T | (T & { $target: T })} val - A value that might be a proxy.
+ * @returns {T} The unproxied value.
  */
-export function isProxy(value: any): boolean;
+export function deProxy<T>(
+  val:
+    | T
+    | (T & {
+        $target: T;
+      }),
+): T;
 /**
  * @returns {number} an unique alpha-numeric string
  */
@@ -23,11 +36,11 @@ export function lowercase(string: string): string;
  */
 export function uppercase(string: string): string;
 /**
- * @param {*} obj Reference to check.
+ * @param {unknown} obj Reference to check.
  * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
  *                   String ...)
  */
-export function isArrayLike(obj: any): boolean;
+export function isArrayLike(obj: unknown): boolean;
 /**
  * Determines if a reference is undefined.
  *
@@ -36,28 +49,38 @@ export function isArrayLike(obj: any): boolean;
  */
 export function isUndefined(value: any): boolean;
 /**
- * Determines if a reference is defined.
+ * Determines if a reference is defined (not `undefined`).
  *
- * @param {*} value Reference to check.
- * @returns {boolean} True if `value` is defined.
+ * @template T
+ * @param {T | undefined} value - Reference to check.
+ * @returns {value is T} True if `value` is defined.
  */
-export function isDefined(value: any): boolean;
+export function isDefined<T>(value: T | undefined): value is T;
 /**
- * Wrapper for minification
- *
  * @template T
  * @param {any} array
  * @returns {array is T[]} true if array is an Array
  */
 export function isArray<T>(array: any): array is T[];
+/**
+ * @template T
+ * @param {any} val
+ * @param {new (...args: any[]) => T} type  The constructor to test against
+ * @returns {val is T}
+ */
+export function isIntanceOf<T>(
+  val: any,
+  type: new (...args: any[]) => T,
+): val is T;
 /**
  * Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
  * considered to be objects. Note that JavaScript arrays are objects.
  *
- * @param {*} value Reference to check.
- * @returns {boolean} True if `value` is an `Object` but not `null`.
+ * @template T
+ * @param {T} value - Reference to check.
+ * @returns {value is T & object} True if `value` is an `Object` but not `null`.
  */
-export function isObject(value: any): boolean;
+export function isObject<T>(value: T): value is T & object;
 /**
  * Determines if a value is an object with a null prototype
  *
@@ -65,21 +88,27 @@ export function isObject(value: any): boolean;
  * @returns {boolean} True if `value` is an `Object` with a null prototype
  */
 export function isBlankObject(value: any): boolean;
-export function isString(value: unknown): boolean;
+/**
+ * Determines if a reference is a `string`.
+ *
+ * @param value - The value to check.
+ * @returns {value is string} True if `value` is a string.
+ */
+export function isString(value: any): value is string;
 /**
  * Determines if a reference is a null.
  *
- * @param {*} value Reference to check.
- * @returns {boolean} True if `value` is a null.
+ * @param {unknown} value Reference to check.
+ * @returns {value is null} True if `value` is a null.
  */
-export function isNull(value: any): boolean;
+export function isNull(value: unknown): value is null;
 /**
  * Determines if a reference is null or undefined.
  *
- * @param {*} obj Reference to check.
- * @returns {boolean} True if `value` is null or undefined.
+ * @param {unknown} obj Reference to check.
+ * @returns {obj is null | undefined} True if `value` is null or undefined.
  */
-export function isNullOrUndefined(obj: any): boolean;
+export function isNullOrUndefined(obj: unknown): obj is null | undefined;
 /**
  * Determines if a reference is not null or undefined.
  *
@@ -96,10 +125,10 @@ export function notNullOrUndefined(obj: any): boolean;
  * [`isFinite'](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
  * method.
  *
- * @param {*} value Reference to check.
- * @returns {boolean} True if `value` is a `Number`.
+ * @param {unknown} value Reference to check.
+ * @returns {value is number} True if `value` is a `Number`.
  */
-export function isNumber(value: any): boolean;
+export function isNumber(value: unknown): value is number;
 /**
  *
  * Determines if a value is a date.
@@ -113,9 +142,9 @@ export function isDate(value: any): boolean;
  * Loosely based on https://www.npmjs.com/package/iserror
  *
  * @param {*} value Reference to check.
- * @returns {boolean} True if `value` is an `Error`.
+ * @returns {value is Error} True if `value` is an `Error`.
  */
-export function isError(value: any): boolean;
+export function isError(value: any): value is Error;
 /**
  * Determines if a reference is a `Function`.
  *
@@ -133,10 +162,10 @@ export function isRegExp(value: any): boolean;
 /**
  * Checks if `obj` is a window object.
  *
- * @param {*} obj Object to check
- * @returns {boolean} True if `obj` is a window obj.
+ * @param {unknown} obj Object to check
+ * @returns {obj is Window} True if `obj` is a window obj.
  */
-export function isWindow(obj: any): boolean;
+export function isWindow(obj: unknown): obj is Window;
 /**
  * @param {*} obj
  * @returns {boolean}
@@ -426,7 +455,6 @@ export function encodeUriSegment(val: string): string;
  *                     / "*" / "+" / "," / ";" / "="
  */
 export function encodeUriQuery(val: any, pctEncodeSpaces: any): string;
-export function getNgAttribute(element: any, ngAttr: any): any;
 /**
  * Creates a shallow copy of an object, an array or a primitive.
  *
@@ -486,7 +514,14 @@ export function errorHandlingConfig(
  * @returns {function(string, ...*): Error} minErr instance
  */
 export function minErr(module: string): (arg0: string, ...args: any[]) => Error;
-export function toDebugString(obj: any): any;
+/**
+ * Converts a value into a simplified debug-friendly string.
+ *
+ * @template T
+ * @param {T|ng.Scope} obj
+ * @returns {string}
+ */
+export function toDebugString<T>(obj: T | ng.Scope): string;
 /**
  * Computes a hash of an 'obj'.
  * Hash of a:
@@ -565,18 +600,30 @@ export function entries<T>(
  * Wraps a function so it can only be called once.
  * Subsequent calls do nothing and return undefined.
  *
- * @param {Function} fn - The function to wrap.
- * @returns {Function} A new function that will call `fn` only once.
+ * @template {(...args: any[]) => any} F
+ * @param {F} fn - The function to wrap.
+ * @returns {(this: ThisParameterType<F>, ...args: Parameters<F>) => ReturnType<F> | undefined}
  */
-export function callBackOnce(fn: Function): Function;
+export function callBackOnce<F extends (...args: any[]) => any>(
+  fn: F,
+): (
+  this: ThisParameterType<F>,
+  ...args: Parameters<F>
+) => ReturnType<F> | undefined;
 /**
  * Wraps a function so it will only be called starting from the second invocation.
  * The first call does nothing and returns undefined.
  *
- * @param {Function} fn - The function to wrap.
- * @returns {Function} A new function that will skip the first call.
+ * @template {(...args: any[]) => any} F
+ * @param {F} fn - The function to wrap.
+ * @returns {(this: ThisParameterType<F>, ...args: Parameters<F>) => ReturnType<F> | undefined}
  */
-export function callBackAfterFirst(fn: Function): Function;
+export function callBackAfterFirst<F extends (...args: any[]) => any>(
+  fn: F,
+): (
+  this: ThisParameterType<F>,
+  ...args: Parameters<F>
+) => ReturnType<F> | undefined;
 /**
  * Delays execution for a specified number of milliseconds.
  *
@@ -614,10 +661,12 @@ export function startsWith(str: string, search: string): boolean;
 /**
  * Loads and instantiates a WebAssembly module.
  * Tries streaming first, then falls back.
+ * @param {string} src
+ * @param {WebAssembly.Imports} imports
  */
 export function instantiateWasm(
-  src: any,
-  imports?: {},
+  src: string,
+  imports?: WebAssembly.Imports,
 ): Promise<{
   instance: WebAssembly.Instance;
   exports: WebAssembly.Exports;

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

@@ -31,6 +31,19 @@ export function validateArray(arg: any, name: string): any;
  * @throws {TypeError} If the value does not satisfy the validator.
  */
 export function validateIsString(arg: any, name: string): any;
+/**
+ * @template T
+ * @param {unknown} arg - The value to validate.
+ * @param {new (...args: any[]) => T} type - The constructor to check against.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {T} The validated instance.
+ * @throws {TypeError} If the value is not an instance of the specified type.
+ */
+export function validateInstanceOf<T>(
+  arg: unknown,
+  type: new (...args: any[]) => T,
+  name: string,
+): T;
 export const BADARG: "badarg";
 export const BADARGKEY: "badarg: key";
 export const BADARGVALUE: "badarg: value";