@angular-wave/angular.ts 0.14.2 → 0.15.0

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,20 +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<T>(value: T | undefined): value is T;
+/**
+ * @template T
+ * @param {any} array
+ * @returns {array is T[]} true if array is an Array
  */
-export function isDefined(value: any): boolean;
+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
  *
@@ -57,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.
  *
@@ -88,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.
@@ -105,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`.
  *
@@ -125,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}
@@ -418,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.
  *
@@ -431,39 +467,6 @@ export function shallowCopy(src: any, dst: any): any;
  * @param {string} errorMsg
  */
 export function assert(argument: boolean, errorMsg?: string): void;
-/**
- * Validate a value using a predicate function.
- * Throws if the predicate returns false.
- * IMPORTANT: use this function only for developper errors and not for user/data errors
- *
- * @param {ng.Validator} fn - Predicate validator function.
- * @param {*} arg - The value to validate.
- * @param {string} name - Parameter name (included in error message).
- * @returns {*} The validated value.
- * @throws {TypeError} If the value does not satisfy the validator.
- */
-export function validate(fn: ng.Validator, arg: any, name: string): any;
-/**
- * @param {*} arg - The value to validate.
- * @param {string} name - Parameter name (included in error message).
- * @returns {*} The validated value.
- * @throws {TypeError} If the value does not satisfy the validator.
- */
-export function validateRequired(arg: any, name: string): any;
-/**
- * @param {*} arg - The value to validate.
- * @param {string} name - Parameter name (included in error message).
- * @returns {*} The validated value.
- * @throws {TypeError} If the value does not satisfy the validator.
- */
-export function validateArray(arg: any, name: string): any;
-/**
- * @param {*} arg - The value to validate.
- * @param {string} name - Parameter name (included in error message).
- * @returns {*} The validated value.
- * @throws {TypeError} If the value does not satisfy the validator.
- */
-export function validateIsString(arg: any, name: string): any;
 /**
  * Throw error if the argument is falsy.
  */
@@ -511,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:
@@ -569,22 +579,51 @@ export function isObjectEmpty(obj: any | null | undefined): boolean;
  * hasOwn({}, 'bar'); // false
  */
 export function hasOwn(obj: object, key: string | number | symbol): boolean;
+/**
+ * @param {Object} obj
+ * @returns {string[]}
+ */
+export function keys(obj: any): string[];
+/**
+ * @template T
+ * @param {{ [s: string]: T; } | ArrayLike<T>} obj
+ * @returns {[string, T][]}
+ */
+export function entries<T>(
+  obj:
+    | {
+        [s: string]: T;
+      }
+    | ArrayLike<T>,
+): [string, 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.
  *
@@ -622,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;
@@ -637,7 +678,4 @@ export function instantiateWasm(
  */
 export function isArrowFunction(fn: any): boolean;
 export const isProxySymbol: unique symbol;
-export const BADARG: "badarg";
-export const BADARGKEY: "badarg: key";
-export const BADARGVALUE: "badarg: value";
 export const ngAttrPrefixes: string[];

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

@@ -0,0 +1,49 @@
+/**
+ * Validate a value using a predicate function.
+ * Throws if the predicate returns false.
+ * IMPORTANT: use this function only for developper errors and not for user/data errors
+ *
+ * @param {ng.Validator} fn - Predicate validator function.
+ * @param {*} arg - The value to validate.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {*} The validated value.
+ * @throws {TypeError} If the value does not satisfy the validator.
+ */
+export function validate(fn: ng.Validator, arg: any, name: string): any;
+/**
+ * @param {*} arg - The value to validate.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {*} The validated value.
+ * @throws {TypeError} If the value does not satisfy the validator.
+ */
+export function validateRequired(arg: any, name: string): any;
+/**
+ * @param {*} arg - The value to validate.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {*} The validated value.
+ * @throws {TypeError} If the value does not satisfy the validator.
+ */
+export function validateArray(arg: any, name: string): any;
+/**
+ * @param {*} arg - The value to validate.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {*} The validated value.
+ * @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";