@angular-wave/angular.ts 0.16.0 → 0.17.0

package/@types/core/scope/scope.d.ts

@@ -46,9 +46,8 @@ export class Scope {
    * @param {Scope} [parent] - Custom parent.
    */
   constructor(context?: Scope, parent?: Scope);
-  context: Scope;
-  /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
-  watchers: Map<string, Array<import("./interface.ts").Listener>>;
+  /** @ignore @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
+  _watchers: Map<string, Array<import("./interface.ts").Listener>>;
   /** @private @type {Map<String, Function[]>} Event listeners */
   private _listeners;
   /** @private @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
@@ -59,25 +58,26 @@ export class Scope {
   private _objectListeners;
   /** @type {Proxy<Scope>} Current proxy being operated on */
   $proxy: ProxyConstructor;
-  /** @type {Scope} The actual proxy */
+  /** @type {Scope} This is the reference to the Scope object with acts as the actual proxy */
   $handler: Scope;
   /** @type {*} Current target being called on */
   $target: any;
-  /** @type {*} Value wrapped by the proxy */
-  $value: any;
   /**
-   * @type {Scope[]}
+   * @ignore @type {Scope[]}
    */
-  $children: Scope[];
+  _children: Scope[];
   /**
    * @type {number} Unique model ID (monotonically increasing) useful for debugging.
    */
   $id: number;
   /**
-   * @type {Scope}
+   * @type {ng.RootScopeService}
    */
-  $root: Scope;
-  $parent: Scope;
+  $root: ng.RootScopeService;
+  /**
+   * @type {Scope | undefined}
+   */
+  $parent: Scope | undefined;
   /** @ignore @type {boolean} */
   _destroyed: boolean;
   /** @private @type {import("./interface.ts").Listener[]} A list of scheduled Event listeners */
@@ -90,14 +90,14 @@ export class Scope {
    * Intercepts and handles property assignments on the target object. If a new value is
    * an object, it will be recursively proxied.
    *
-   * @param {Object} target - The target object.
+   * @param {Object & Record<string, any>} target - The target object.
    * @param {string} property - The name of the property being set.
    * @param {*} value - The new value being assigned to the property.
    * @param {Proxy<Scope>} proxy - The proxy intercepting property access
    * @returns {boolean} - Returns true to indicate success of the operation.
    */
   set(
-    target: any,
+    target: any & Record<string, any>,
     property: string,
     value: any,
     proxy: ProxyConstructor,
@@ -107,17 +107,21 @@ export class Scope {
    * properties (`watch` and `sync`) and binds their methods. For other properties,
    * it returns the value directly.
    *
-   * @param {Object} target - The target object.
+   * @param {Object & Record<string, any>} target - The target object.
    * @param {string|number|symbol} property - The name of the property being accessed.
    * @param {Proxy<Scope>} proxy - The proxy object being invoked
    * @returns {*} - The value of the property or a method if accessing `watch` or `sync`.
    */
   get(
-    target: any,
+    target: any & Record<string, any>,
     property: string | number | symbol,
     proxy: ProxyConstructor,
   ): any;
-  deleteProperty(target: any, property: any): boolean;
+  /**
+   * @param {Object & Record<string, any>} target - The target object.
+   * @param {string} property - The name of the property being deleted
+   */
+  deleteProperty(target: any & Record<string, any>, property: string): boolean;
   /**
    * Registers a watcher for a property along with a listener function. The listener
    * function is invoked when changes to that property are detected.
@@ -131,10 +135,42 @@ export class Scope {
     listenerFn?: ng.ListenerFn,
     lazy?: boolean,
   ): () => void;
-  $new(childInstance: any): any;
-  $newIsolate(instance: any): any;
-  $transcluded(parentInstance: any): any;
-  $eval(expr: any, locals: any): any;
+  /**
+   * @param {ng.Scope} [childInstance]
+   * @returns {Proxy<ng.Scope> & ng.Scope}
+   */
+  $new(childInstance?: ng.Scope): ProxyConstructor & ng.Scope;
+  /**
+   * @param {ng.Scope} [instance]
+   * @returns {Proxy<ng.Scope> & ng.Scope}
+   */
+  $newIsolate(instance?: ng.Scope): ProxyConstructor & ng.Scope;
+  /**
+   * @param {ng.Scope} parentInstance
+   * @returns {Proxy<ng.Scope> & ng.Scope}
+   */
+  $transcluded(parentInstance: ng.Scope): ProxyConstructor & ng.Scope;
+  /**
+   * @param {string} key
+   * @param {import("./interface.ts").Listener} listener
+   */
+  _registerForeignKey(
+    key: string,
+    listener: import("./interface.ts").Listener,
+  ): void;
+  /**
+   * @param {string} key
+   * @param {number} id
+   */
+  _deregisterForeignKey(key: string, id: number): boolean;
+  /**
+   * Evaluates an Angular expression in the context of this scope.
+   *
+   * @param {string} expr - Angular expression to evaluate
+   * @param {Record<string, any>} [locals] - Optional local variables
+   * @returns {any}
+   */
+  $eval(expr: string, locals?: Record<string, any>): any;
   /**
    * @param {Object} newTarget
    */
@@ -153,9 +189,9 @@ export class Scope {
   /**
    * @param {string} name
    * @param  {...any} args
-   * @returns {void}
+   * @returns {ng.ScopeEvent | undefined}
    */
-  $emit(name: string, ...args: any[]): void;
+  $emit(name: string, ...args: any[]): ng.ScopeEvent | undefined;
   /**
    * @param {string} name
    * @param  {...any} args
@@ -182,3 +218,10 @@ export class Scope {
   $searchByName(name: string): ng.Scope | undefined;
   #private;
 }
+export type ExpressionNode = import("../parse/ast/ast-node.ts").ExpressionNode;
+export type LiteralNode = import("../parse/ast/ast-node.ts").LiteralNode;
+export type BodyNode = import("../parse/ast/ast-node.ts").BodyNode;
+export type ArrayNode = import("../parse/ast/ast-node.ts").ArrayNode;
+export type ObjectNode = import("../parse/ast/ast-node.ts").ObjectNode;
+export type ObjectPropertyNode =
+  import("../parse/ast/ast-node.ts").ObjectPropertyNode;

package/@types/directive/form/form.d.ts

@@ -1,4 +1,14 @@
 export function setupValidity(instance: any): void;
+/**
+ * @param {FormController|ng.NgModelController} ctrl
+ * @param {string} className
+ * @param {boolean} switchValue
+ */
+export function cachedToggleClass(
+  ctrl: FormController | ng.NgModelController,
+  className: string,
+  switchValue: boolean,
+): void;
 /**
  * @type {{
  *   $nonscope: boolean,
@@ -74,21 +84,23 @@ export class FormController {
   static $nonscope: boolean;
   static $inject: string[];
   /**
-   * @param {Element} $element
+   * @param {HTMLFormElement} $element
    * @param {ng.Attributes} $attrs
    * @param {ng.Scope} $scope
    * @param {ng.AnimateService} $animate
    * @param {ng.InterpolateService} $interpolate
    */
   constructor(
-    $element: Element,
+    $element: HTMLFormElement,
     $attrs: ng.Attributes,
     $scope: ng.Scope,
     $animate: ng.AnimateService,
     $interpolate: ng.InterpolateService,
   );
+  /** @type {boolean} */
+  _isAnimated: boolean;
   _controls: any[];
-  $name: string;
+  $name: any;
   /**
    * @property {boolean} $dirty True if user has already interacted with the form.
    */
@@ -102,7 +114,7 @@ export class FormController {
   $submitted: boolean;
   /** @type {FormController|Object} */
   _parentForm: FormController | any;
-  _element: Element;
+  _element: HTMLFormElement;
   _animate: import("../../animations/interface.ts").AnimateService;
   $error: {};
   _success: {};

package/@types/directive/model/model.d.ts

@@ -52,7 +52,7 @@ export class NgModelController {
    * @param {ng.Scope} $scope
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {ng.Attributes} $attr
-   * @param {Element} $element
+   * @param {HTMLElement} $element
    * @param {ng.ParseService} $parse
    * @param {ng.AnimateService} $animate
    * @param {ng.InterpolateService} $interpolate
@@ -61,11 +61,13 @@ export class NgModelController {
     $scope: ng.Scope,
     $exceptionHandler: ng.ExceptionHandlerService,
     $attr: ng.Attributes,
-    $element: Element,
+    $element: HTMLElement,
     $parse: ng.ParseService,
     $animate: ng.AnimateService,
     $interpolate: ng.InterpolateService,
   );
+  /** @type {boolean} */
+  _isAnimated: boolean;
   /** @type {any} The actual value from the control's view  */
   $viewValue: any;
   /** @type {any} The value in the model that the control is bound to. */
@@ -97,7 +99,7 @@ export class NgModelController {
   $error: {};
   _success: {};
   $pending: any;
-  $name: string;
+  $name: any;
   _parentForm: {
     $nonscope: boolean;
     $addControl: Function;
@@ -144,7 +146,7 @@ export class NgModelController {
   /** @type {ng.Scope} */
   _scope: ng.Scope;
   _attr: ng.Attributes;
-  _element: Element;
+  _element: HTMLElement;
   _animate: import("../../animations/interface.ts").AnimateService;
   _parse: import("../../core/parse/interface.ts").ParseService;
   _exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;

package/@types/filters/order-by.d.ts

@@ -6,3 +6,16 @@ export function orderByFilter($parse: ng.ParseService): ng.FilterFn;
 export namespace orderByFilter {
   let $inject: string[];
 }
+export type ComparisonObject = {
+  value: any;
+  tieBreaker: {
+    value: number;
+    type: string;
+    index: number;
+  };
+  predicateValues: Array<{
+    value: any;
+    type: string;
+    index: number;
+  }>;
+};

package/@types/interface.d.ts

@@ -65,7 +65,7 @@ export interface AngularBootstrapConfig {
    * This helps find bugs that would break under minified code.
    * Defaults to `false`.
    */
-  strictDi?: boolean;
+  strictDi: boolean;
 }
 /**
  * A JavaScript expression represented as a string, typically used in interpolation bindings.
@@ -474,7 +474,7 @@ export interface TemplateLinkingFunction {
   ): Element;
 }
 export interface TemplateLinkingFunctionOptions {
-  parentBoundTranscludeFn?: TranscludeFunctionObject | undefined;
+  _parentBoundTranscludeFn?: TranscludeFunctionObject | undefined;
   transcludeControllers?:
     | {
         [controller: string]: {
@@ -482,7 +482,7 @@ export interface TemplateLinkingFunctionOptions {
         };
       }
     | undefined;
-  futureParentElement?: Element | undefined;
+  _futureParentElement?: Element | undefined;
 }
 /**
  * Configuration for ngModel behavior.

package/@types/router/path/path-node.d.ts

@@ -16,7 +16,7 @@ export class PathNode {
   /** Sets [[paramValues]] for the node, from the values of an object hash */
   applyRawParams(params: any): this;
   /** Gets a specific [[Param]] metadata that belongs to the node */
-  parameter(name: any): undefined;
+  parameter(name: any): any;
   /**
    * @returns true if the state and parameter values for another PathNode are
    * equal to the state and param values for this PathNode

package/@types/router/resolve/resolve-context.d.ts

@@ -80,7 +80,7 @@ export class ResolveContext {
    * @returns {Promise<any>|any}
    */
   resolvePath(when: string, trans: any): Promise<any> | any;
-  findNode(resolvable: any): undefined;
+  findNode(resolvable: any): any;
   /**
    * Gets the async dependencies of a Resolvable
    *

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

@@ -93,7 +93,7 @@ export class RegisteredHook {
    *   retained: true,
    * }
    */
-  _getDefaultMatchCriteria(): any;
+  _getDefaultMatchCriteria(): boolean[] | Record<string, boolean>;
   /**
    * Gets matching nodes as [[IMatchingNodes]]
    *

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

@@ -51,7 +51,7 @@
  */
 export class UrlMatcher {
   /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
-  static pathSegmentsAndParams(matcher: any): any;
+  static pathSegmentsAndParams(matcher: any): any[];
   /** @internal Given a matcher, return an array with the matcher's query params */
   static queryParams(matcher: any): any;
   /**

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

@@ -8,19 +8,16 @@ 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;
   getTrustedMediaUrl(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;
@@ -29,5 +26,5 @@ export interface SCEService {
 export interface SCEDelegateService {
   getTrusted(type: string, mayBeTrusted: any): any;
   trustAs(type: string, value: any): any;
-  valueOf(value: any): any;
+  valueOf(value?: any): any;
 }

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

@@ -18,7 +18,13 @@ export class SceProvider {
    * Enables/disables SCE and returns the current value.
    */
   enabled: (value?: boolean | undefined, ...args: any[]) => boolean;
-  $get: (string | (($parse: ng.ParseService, $sceDelegate: any) => any))[];
+  $get: (
+    | string
+    | ((
+        $parse: ng.ParseService,
+        $sceDelegate: ng.SCEDelegateService,
+      ) => ng.SCEService)
+  )[];
 }
 export namespace SCE_CONTEXTS {
   let HTML: string;
@@ -26,7 +32,6 @@ export namespace SCE_CONTEXTS {
   let MEDIA_URL: string;
   let URL: string;
   let RESOURCE_URL: string;
-  let JS: string;
 }
 /**
  * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict

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

@@ -67,36 +67,83 @@ export function defaults(
  * var foo = { a: 1, b: 2, c: 3 };
  * var ab = pick(foo, ['a', 'b']); // { a: 1, b: 2 }
  * ```
- * @param obj the source object
- * @param propNames an Array of strings, which are the whitelisted property names
+ * @param {any} obj the source object
+ * @param {string | any[]} propNames an Array of strings, which are the whitelisted property names
  */
-export function pick(obj: any, propNames: any): {};
+export function pick(obj: any, propNames: string | any[]): Record<string, any>;
 /**
  * Return a copy of the object omitting the blacklisted properties.
+ * @example ```
+
+var foo = { a: 1, b: 2, c: 3 };
+var ab = omit(foo, ['a', 'b']); // { c: 3 }
+```
+ * @param {{ [x: string]: any; }} obj the source object
+ * @param {string | any[]} propNames an Array of strings, which are the blacklisted property names
+ */
+export function omit(
+  obj: {
+    [x: string]: any;
+  },
+  propNames: string | any[],
+): Record<string, any>;
+/**
+ * Filters an Array or an Object's properties based on a predicate
+ * @param {Record<string, any> | ArrayLike<any>} collection
+ * @param {{ (x: any): boolean; (item: any): boolean; (val: any, key: any): boolean; (arg0: any, arg1: string): any; }} callback
+ */
+export function filter(
+  collection: Record<string, any> | ArrayLike<any>,
+  callback: {
+    (x: any): boolean;
+    (item: any): boolean;
+    (val: any, key: any): boolean;
+    (arg0: any, arg1: string): any;
+  },
+): Record<string, any>;
+/**
+ * Finds an object from an array, or a property of an object, that matches a predicate
+ * @param {{ [s: string]: any; } | ArrayLike<any>} collection
+ * @param {function} callback
+ */
+export function find(
+  collection:
+    | {
+        [s: string]: any;
+      }
+    | ArrayLike<any>,
+  callback: Function,
+): any;
+/**
+ * Maps over an array or object and returns a new collection
+ * with the same shape.
  *
- * @example
- * ```
- *
- * var foo = { a: 1, b: 2, c: 3 };
- * var ab = omit(foo, ['a', 'b']); // { c: 3 }
- * ```
- * @param obj the source object
- * @param propNames an Array of strings, which are the blacklisted property names
+ * @template T
+ * @template R
+ * @param {T[] | Record<string, T>} collection
+ * @param {(value: T, key: string | number) => R} callback
+ * @param {R[] | Record<string, R>} [target]
+ * @returns {R[] | Record<string, R>}
  */
-export function omit(obj: any, propNames: any): {};
-/** Filters an Array or an Object's properties based on a predicate */
-export function filter(collection: any, callback: any): {};
-/** Finds an object from an array, or a property of an object, that matches a predicate */
-export function find(collection: any, callback: any): undefined;
-/** Maps an array or object properties using a callback function */
-export function map(collection: any, callback: any, target: any): any;
+export function map<T, R>(
+  collection: T[] | Record<string, T>,
+  callback: (value: T, key: string | number) => R,
+  target?: R[] | Record<string, R>,
+): R[] | Record<string, R>;
 /**
  * Reduce function that pushes an object to an array, then returns the array.
  * Mostly just for [[flattenR]] and [[uniqR]]
+ * @param {any[]} arr
+ * @param {unknown} obj
+ */
+export function pushR(arr: any[], obj: unknown): any[];
+/**
+ * @param {(arg0: any) => any} predicateOrMap
+ * @param {string} errMsg
+ * @return {(obj:any) => any}
  */
-export function pushR(arr: any, obj: any): any;
 export function assertFn(
-  predicateOrMap: any,
+  predicateOrMap: (arg0: any) => any,
   errMsg?: string,
 ): (obj: any) => any;
 /**
@@ -119,21 +166,28 @@ export function arrayTuples(...args: any[][]): any[][];
  * Each iteration sets the key/val pair on the memo object, then returns the memo for the next iteration.
  *
  * Each keyValueTuple should be an array with values [ key: string, value: any ]
- *
- * @example
- * ```
- *
- * var pairs = [ ["fookey", "fooval"], ["barkey", "barval"] ]
- *
- * var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})
- * // pairsToObj == { fookey: "fooval", barkey: "barval" }
- *
- * // Or, more simply:
- * var pairsToObj = pairs.reduce(applyPairs, {})
- * // pairsToObj == { fookey: "fooval", barkey: "barval" }
- * ```
+ * @example ```
+
+    var pairs = [ ["fookey", "fooval"], ["barkey", "barval"] ]
+
+    var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})
+    // pairsToObj == { fookey: "fooval", barkey: "barval" }
+
+    // Or, more simply:
+    var pairsToObj = pairs.reduce(applyPairs, {})
+    // pairsToObj == { fookey: "fooval", barkey: "barval" }
+```
+ * @param {{ [x: string]: any; }} memo
+ * @param {any[]} keyValTuple
  */
-export function applyPairs(memo: any, keyValTuple: any): any;
+export function applyPairs(
+  memo: {
+    [x: string]: any;
+  },
+  keyValTuple: any[],
+): {
+  [x: string]: any;
+};
 /**
  * Returns the last element of an array, or undefined if the array is empty.
  * @template T
@@ -143,15 +197,22 @@ export function applyPairs(memo: any, keyValTuple: any): any;
 export function tail<T>(arr: any[] | string): T | undefined;
 /**
  * shallow copy from src to dest
+ * @param {any} src
+ * @param {any} dest
  */
 export function copy(src: any, dest: any): any;
 export function allTrueR(memo: any, elem: any): any;
 export function anyTrueR(memo: any, elem: any): any;
-export function unnestR(memo: any, elem: any): any;
-export function flattenR(memo: any, elem: any): any;
-export function uniqR(acc: any, token: any): any;
-export function unnest(arr: any): any;
+export function unnestR<T>(memo: T[], elem: T | T[]): T[];
+export function flattenR<T>(memo: T[], elem: any): T[];
+export function uniqR(acc: any[], token: any): any[];
+export function unnest(arr: any[]): any;
+/**
+ * @param {(arg0: any) => any} predicateOrMap
+ * @param {string} errMsg
+ * @return {(obj:any) => any}
+ */
 export function assertPredicate(
-  predicateOrMap: any,
+  predicateOrMap: (arg0: any) => any,
   errMsg?: string,
 ): (obj: any) => any;

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

@@ -1,8 +1,8 @@
 export type NodeType = number;
 export namespace NodeType {
-  let _ELEMENT_NODE: 1;
-  let _DOCUMENT_NODE: 9;
-  let _TEXT_NODE: 3;
-  let _COMMENT_NODE: 8;
-  let _DOCUMENT_FRAGMENT_NODE: 11;
+  let _ELEMENT_NODE: number;
+  let _DOCUMENT_NODE: number;
+  let _TEXT_NODE: number;
+  let _COMMENT_NODE: number;
+  let _DOCUMENT_FRAGMENT_NODE: number;
 }

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

@@ -64,8 +64,8 @@ export function splitOnDelim(
  * let arr = ["foo", "bar", 1, "baz", "", "qux" ];
  * arr.reduce(joinNeighborsR, []) // ["foobar", 1, "bazqux" ]
  * ```
- * @param {string | any[]} acc
+ * @param {any[]} acc
  * @param {unknown} str
  */
-export function joinNeighborsR(acc: string | any[], str: unknown): any;
+export function joinNeighborsR(acc: any[], str: unknown): any[];
 export function stripLastPathElement(str: string): string;