@angular-wave/angular.ts 0.0.39 → 0.0.40

package/src/shared/strings.js

@@ -7,7 +7,7 @@
  */
 import { isInjectable, isNull, isPromise } from "./predicates";
 import { isUndefined, isFunction, isString, isObject } from "./utils";
-import { identity, pushR, tail } from "./common";
+import { pushR, tail } from "./common";
 import { pattern, val } from "./hof";
 /**
  * Returns a string shortened to a maximum length
@@ -75,7 +75,7 @@ export function stringify(o) {
     [isRejection, (x) => x._transitionRejection.toString()],
     [hasToString, (x) => x.toString()],
     [isInjectable, functionToString],
-    [val(true), identity],
+    [val(true), (x) => x],
   ]);
   function format(value) {
     if (isObject(value)) {

package/src/shared/test-utils.js

@@ -1,11 +1,11 @@
-import { jqLite } from "./jqlite/jqlite";
+import { JQLite } from "./jqlite/jqlite";
 
 /**
  * @param {HTMLElement} element
  * @param {string} event
  */
 export function browserTrigger(element, event) {
-  jqLite(element)[0].dispatchEvent(
+  JQLite(element)[0].dispatchEvent(
     new Event(event, { bubbles: true, cancelable: true }),
   );
 }

package/src/shared/utils.js

@@ -52,8 +52,8 @@ export function isArrayLike(obj) {
   if (obj == null || isWindow(obj)) return false;
 
   // arrays, strings and jQuery/jqLite objects are array like
-  // * we have to check the existence of jqLite first as this method is called
-  //   via the forEach method when constructing the jqLite object in the first place
+  // * we have to check the existence of JQLite first as this method is called
+  //   via the forEach method when constructing the JQLite object in the first place
   if (Array.isArray(obj) || obj instanceof Array || isString(obj)) return true;
 
   // Support: iOS 8.2 (not reproducible in simulator)
@@ -1174,6 +1174,8 @@ export function assertArgFn(arg, name, acceptArrayAnnotation) {
   return arg;
 }
 
+export const minErrConfig = {};
+
 /**
  * @description
  *
@@ -1201,21 +1203,16 @@ export function assertArgFn(arg, name, acceptArrayAnnotation) {
  * @param {string} module The namespace to use for the new minErr instance.
  * @returns {function(string, string, ...*): Error} minErr instance
  */
-
-export const minErrConfig = {};
-
 export function minErr(module) {
   const url = 'https://errors.angularjs.org/"NG_VERSION_FULL"/';
   const regex = `${url.replace(".", "\\.")}[\\s\\S]*`;
   const errRegExp = new RegExp(regex, "g");
 
-  return function () {
-    const code = arguments[0];
-    const template = arguments[1];
+  return function (...args) {
+    const code = args[0];
+    const template = args[1];
     let message = `[${module ? `${module}:` : ""}${code}] `;
-    const templateArgs = sliceArgs(arguments, 2).map((arg) =>
-      toDebugString(arg),
-    );
+    const templateArgs = sliceArgs(args, 2).map((arg) => toDebugString(arg));
     let paramPrefix;
     let i;
 

package/types/animations/shared.d.ts

@@ -47,4 +47,4 @@ export const ANIMATION_DELAY_PROP: string;
 export const ANIMATION_DURATION_PROP: string;
 export const TRANSITION_DELAY_PROP: string;
 export const TRANSITION_DURATION_PROP: string;
-export const ngMinErr: (...args: any[]) => Error;
+export const ngMinErr: (arg0: string, arg1: string, ...arg2: any[]) => Error;

package/types/core/exception-handler.d.ts

@@ -1,46 +1,13 @@
 /**
- * @ngdoc service
- * @name $exceptionHandler
- * @requires ng.$log
- *
- *
- * @description
- * Any uncaught exception in AngularJS expressions is delegated to this service.
- * The default implementation simply delegates to `$log.error` which logs it into
- * the browser console.
- *
- *
- * ## Example:
- *
- * The example below will overwrite the default `$exceptionHandler` in order to (a) log uncaught
- * errors to the backend for later inspection by the developers and (b) to use `$log.warn()` instead
- * of `$log.error()`.
- *
- * ```js
- *   angular.
- *     module('exceptionOverwrite', []).
- *     factory('$exceptionHandler', ['$log', 'logErrorsToBackend', function($log, logErrorsToBackend) {
- *       return function myExceptionHandler(exception, cause) {
- *         logErrorsToBackend(exception, cause);
- *         $log.warn(exception, cause);
- *       };
- *     }]);
- * ```
- *
- * <hr />
- * Note, that code executed in event-listeners (even those registered using jqLite's `on`/`bind`
- * methods) does not delegate exceptions to the {@link ng.$exceptionHandler $exceptionHandler}
- * (unless executed during a digest).
- *
- * If you wish, you can manually delegate exceptions, e.g.
- * `try { ... } catch(e) { $exceptionHandler(e); }`
- *
- * @param {Error} exception Exception associated with the error.
- * @param {string=} cause Optional information about the context in which
- *       the error was thrown.
- *
+ * @constructor
+ * @this {angular.ExceptionHandlerProvider}
  */
-export function $ExceptionHandlerProvider(): void;
+export function $ExceptionHandlerProvider(this: import("../index").angular.ServiceProvider): void;
 export class $ExceptionHandlerProvider {
-    $get: (string | (($log: any) => (...args: any[]) => void))[];
+    $get: (string | (($log: import("../services/log").angular.LogService) => angular.ErrorHandler))[];
+}
+export function errorHandler(exception: any, cause: any): void;
+export namespace angular {
+    type ExceptionHandlerProvider = import("../index").angular.ServiceProvider;
+    type ErrorHandler = (exception: Error, cause?: string) => void;
 }

package/types/core/interpolate/interpolate.d.ts

@@ -37,7 +37,7 @@ export class $InterpolateProvider {
      * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
      */
     endSymbol: (value?: string | undefined) => string | (Window & typeof globalThis);
-    $get: (string | (($parse: any, $exceptionHandler: any, $sce: any) => {
+    $get: (string | (($parse: any, $exceptionHandler: import("../exception-handler").angular.ErrorHandler, $sce: any) => {
         (text: string, mustHaveExpression?: boolean | undefined, trustedContext?: string | undefined, allOrNothing?: boolean | undefined): (arg0: context) => any;
         /**
          * @ngdoc method

package/types/core/q/q.d.ts

@@ -7,7 +7,7 @@
  */
 export function $QProvider(): void;
 export class $QProvider {
-    $get: (string | (($rootScope: any, $exceptionHandler: any) => any))[];
+    $get: (string | (($rootScope: any, $exceptionHandler: import("../exception-handler").angular.ErrorHandler) => any))[];
     /**
      * @ngdoc method
      * @name $qProvider#errorOnUnhandledRejections
@@ -29,3 +29,37 @@ export class $$QProvider {
     errorOnUnhandledRejections: (value: any) => boolean | this;
 }
 export function markQExceptionHandled(q: any): void;
+export namespace angular {
+    type QPromise<T> = {
+        /**
+         * - Calls one of the success or error callbacks asynchronously as soon as the result is available.
+         */
+        then: (arg0: ((value: T) => (PromiseLike<never> | PromiseLike<T> | T)) | null, arg1: ((reason: any) => (PromiseLike<never> | PromiseLike<T> | T)) | null, arg2: ((state: any) => any)) => angular.QPromise<T | never>;
+        /**
+         * - Shorthand for promise.then(null, errorCallback).
+         */
+        catch: (arg0: ((reason: any) => (PromiseLike<never> | PromiseLike<T> | T)) | null) => angular.QPromise<T> | T;
+        /**
+         * - Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value.
+         */
+        finally: (arg0: () => void) => angular.QPromise<T>;
+    };
+    type Deferred<T> = {
+        /**
+         * - Resolves the promise with a value or another promise.
+         */
+        resolve: (arg0: T | angular.QPromise<T>) => void;
+        /**
+         * - Rejects the promise with a reason.
+         */
+        reject: (arg0: any) => void;
+        /**
+         * - Provides a progress notification.
+         */
+        notify: (arg0: any) => void;
+        /**
+         * - The promise associated with this deferred object.
+         */
+        promise: angular.QPromise<T>;
+    };
+}

package/types/core/task-tracker-factory.d.ts

@@ -1,3 +1,7 @@
+export function $$TaskTrackerFactoryProvider(): void;
+export class $$TaskTrackerFactoryProvider {
+    $get: (string | ((log: import("../services/log").angular.LogService) => TaskTracker))[];
+}
 /**
  * ! This is a private undocumented service !
  *
@@ -7,19 +11,22 @@
  *
  * A `TaskTracker` can keep track of pending tasks (grouped by type) and can notify interested
  * parties when all pending tasks (or tasks of a specific type) have been completed.
- *
- * @param {$log} log - A logger instance (such as `$log`). Used to log error during callback
- *     execution.
- *
- *
+ * @param {import('../services/log').angular.LogService} log
  */
-export function $$TaskTrackerFactoryProvider(): void;
-export class $$TaskTrackerFactoryProvider {
-    $get: () => any;
-}
-export function TaskTracker(log: any): void;
+export function TaskTracker(log: import("../services/log").angular.LogService): void;
 export class TaskTracker {
-    constructor(log: any);
+    /**
+     * ! This is a private undocumented service !
+     *
+     * @name $$taskTrackerFactory
+     * @description
+     * A function to create `TaskTracker` instances.
+     *
+     * A `TaskTracker` can keep track of pending tasks (grouped by type) and can notify interested
+     * parties when all pending tasks (or tasks of a specific type) have been completed.
+     * @param {import('../services/log').angular.LogService} log
+     */
+    constructor(log: import("../services/log").angular.LogService);
     ALL_TASKS_TYPE: string;
     DEFAULT_TASK_TYPE: string;
     /**

package/types/core/timeout/timeout.d.ts

@@ -1,4 +1,13 @@
-export function $timeout($rootScope: any, $browser: any, $q: any, $$q: any, $exceptionHandler: any): {
+/**
+ *
+ * @param {*} $rootScope
+ * @param {*} $browser
+ * @param {*} $q
+ * @param {*} $$q
+ * @param {import('../exception-handler').angular.ErrorHandler} $exceptionHandler
+ * @returns
+ */
+export function $timeout($rootScope: any, $browser: any, $q: any, $$q: any, $exceptionHandler: import("../exception-handler").angular.ErrorHandler): {
     (fn?: (() => any) | undefined, delay?: number | undefined, invokeApply?: boolean | undefined, ...args: any[]): Promise<any>;
     /**
      * @ngdoc method

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

@@ -1,6 +1,30 @@
-export function NgModelController($scope: any, $exceptionHandler: any, $attr: any, $element: any, $parse: any, $animate: any, $timeout: any, $q: any, $interpolate: any): void;
+/**
+ *
+ * @param {*} $scope
+ * @param {import('../../core/exception-handler').angular.ErrorHandler} $exceptionHandler
+ * @param {*} $attr
+ * @param {*} $element
+ * @param {*} $parse
+ * @param {*} $animate
+ * @param {*} $timeout
+ * @param {*} $q
+ * @param {*} $interpolate
+ */
+export function NgModelController($scope: any, $exceptionHandler: import("../../core/exception-handler").angular.ErrorHandler, $attr: any, $element: any, $parse: any, $animate: any, $timeout: any, $q: any, $interpolate: any): void;
 export class NgModelController {
-    constructor($scope: any, $exceptionHandler: any, $attr: any, $element: any, $parse: any, $animate: any, $timeout: any, $q: any, $interpolate: any);
+    /**
+     *
+     * @param {*} $scope
+     * @param {import('../../core/exception-handler').angular.ErrorHandler} $exceptionHandler
+     * @param {*} $attr
+     * @param {*} $element
+     * @param {*} $parse
+     * @param {*} $animate
+     * @param {*} $timeout
+     * @param {*} $q
+     * @param {*} $interpolate
+     */
+    constructor($scope: any, $exceptionHandler: import("../../core/exception-handler").angular.ErrorHandler, $attr: any, $element: any, $parse: any, $animate: any, $timeout: any, $q: any, $interpolate: any);
     $viewValue: number;
     $modelValue: number;
     $$rawModelValue: any;
@@ -49,7 +73,7 @@ export class NgModelController {
     $$timeout: any;
     $$parse: any;
     $$q: any;
-    $$exceptionHandler: any;
+    $$exceptionHandler: import("../../core/exception-handler").angular.ErrorHandler;
     $$initGetterSetters(): void;
     $render: () => void;
     /**
@@ -448,7 +472,7 @@ export class NgModelController {
 export namespace NgModelController {
     let $inject: string[];
 }
-export const ngModelMinErr: (...args: any[]) => Error;
+export const ngModelMinErr: (arg0: string, arg1: string, ...arg2: any[]) => Error;
 /**
  * @ngdoc directive
  * @name ngModel