@angular-wave/angular.ts 0.0.35 → 0.0.37

package/types/animations/raf-scheduler.d.ts

@@ -0,0 +1,5 @@
+export const $$rAFSchedulerFactory: (() => {
+  (tasks: any): void;
+  queue: any[];
+  waitUntilQuiet(fn: any): void;
+})[];

package/types/animations/shared.d.ts

@@ -0,0 +1,65 @@
+export function assertArg(arg: any, name: any, reason: any): any;
+export function mergeClasses(a: any, b: any): any;
+export function packageStyles(options: any): {
+  to: any;
+  from: any;
+};
+export function pendClasses(classes: any, fix: any, isPrefix: any): string;
+export function removeFromArray(arr: any, val: any): void;
+export function stripCommentsFromElement(element: any): any;
+export function extractElementNode(element: any): any;
+export function applyAnimationClassesFactory(): (
+  element: any,
+  options: any,
+) => void;
+export function prepareAnimationOptions(options: any): any;
+export function applyAnimationStyles(element: any, options: any): void;
+export function applyAnimationFromStyles(element: any, options: any): void;
+export function applyAnimationToStyles(element: any, options: any): void;
+export function mergeAnimationDetails(
+  element: any,
+  oldAnimation: any,
+  newAnimation: any,
+): any;
+export function resolveElementClasses(
+  existing: any,
+  toAdd: any,
+  toRemove: any,
+): {
+  addClass: string;
+  removeClass: string;
+};
+export function getDomNode(element: any): any;
+export function applyGeneratedPreparationClasses(
+  element: any,
+  event: any,
+  options: any,
+): void;
+export function clearGeneratedClasses(element: any, options: any): void;
+export function blockKeyframeAnimations(node: any, applyBlock: any): string[];
+export function applyInlineStyle(node: any, styleTuple: any): void;
+export function concatWithSpace(a: any, b: any): any;
+export const ADD_CLASS_SUFFIX: "-add";
+export const REMOVE_CLASS_SUFFIX: "-remove";
+export const EVENT_CLASS_PREFIX: "ng-";
+export const ACTIVE_CLASS_SUFFIX: "-active";
+export const PREPARE_CLASS_SUFFIX: "-prepare";
+export const NG_ANIMATE_CLASSNAME: "ng-animate";
+export const NG_ANIMATE_CHILDREN_DATA: "$$ngAnimateChildren";
+export let CSS_PREFIX: string;
+export let TRANSITION_PROP: any;
+export let TRANSITIONEND_EVENT: any;
+export let ANIMATION_PROP: any;
+export let ANIMATIONEND_EVENT: any;
+export const DURATION_KEY: "Duration";
+export const PROPERTY_KEY: "Property";
+export const DELAY_KEY: "Delay";
+export const TIMING_KEY: "TimingFunction";
+export const ANIMATION_ITERATION_COUNT_KEY: "IterationCount";
+export const ANIMATION_PLAYSTATE_KEY: "PlayState";
+export const SAFE_FAST_FORWARD_DURATION_VALUE: 9999;
+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;

package/types/constants.d.ts

@@ -0,0 +1,18 @@
+export const VALID_CLASS: "ng-valid";
+export const INVALID_CLASS: "ng-invalid";
+export const PRISTINE_CLASS: "ng-pristine";
+export const DIRTY_CLASS: "ng-dirty";
+export const UNTOUCHED_CLASS: "ng-untouched";
+export const TOUCHED_CLASS: "ng-touched";
+export const EMPTY_CLASS: "ng-empty";
+export const NOT_EMPTY_CLASS: "ng-not-empty";
+export const PREFIX_REGEXP: RegExp;
+export const SPECIAL_CHARS_REGEXP: RegExp;
+export namespace ALIASED_ATTR {
+  let ngMinlength: string;
+  let ngMaxlength: string;
+  let ngMin: string;
+  let ngMax: string;
+  let ngPattern: string;
+  let ngStep: string;
+}

package/types/core/animate-css.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @ngdoc service
+ * @name $animateCss
+ * @kind object
+ *
+ *
+ * @description
+ * This is the core version of `$animateCss`. By default, only when the `ngAnimate` is included,
+ * then the `$animateCss` service will actually perform animations.
+ *
+ * Click here {@link ngAnimate.$animateCss to read the documentation for $animateCss}.
+ */
+export function CoreAnimateCssProvider(): void;
+export class CoreAnimateCssProvider {
+  $get: (
+    | string
+    | (($$AnimateRunner: any) => (
+        element: any,
+        initialOptions: any,
+      ) => {
+        start: () => any;
+        end: () => any;
+      })
+  )[];
+}

package/types/core/cache.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @typedef {Object} ExpandoStore
+ *
+ * @property {!Object<string, any>} data
+ * @property {!Object} events
+ * @property {?Function} handle
+ *
+ */
+export const EXPANDO: "ngId";
+/**
+ * Expando cache for adding properties to DOM nodes with JavaScript.
+ * This used to be an Object in JQLite decorator, but swapped out for a Map
+ * for performance reasons and convenience methods. A proxy is available for
+ * additional logic handling.
+ *
+ * @type {Map<number, ExpandoStore>}
+ */
+export const CACHE: Map<number, ExpandoStore>;
+export type ExpandoStore = {
+  data: {
+    [x: string]: any;
+  };
+  events: any;
+  handle: Function | null;
+};

package/types/core/compile.d.ts

@@ -0,0 +1,206 @@
+export function $CompileProvider(
+  $provide: any,
+  $$sanitizeUriProvider: any,
+): void;
+export class $CompileProvider {
+  constructor($provide: any, $$sanitizeUriProvider: any);
+  /**
+   * @ngdoc method
+   * @name $compileProvider#directive
+   * @kind function
+   *
+   * @description
+   * Register a new directive with the compiler.
+   *
+   * @param {string|Object} name Name of the directive in camel-case (i.e. `ngBind` which will match
+   *    as `ng-bind`), or an object map of directives where the keys are the names and the values
+   *    are the factories.
+   * @param {Function|Array} directiveFactory An injectable directive factory function. See the
+   *    {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
+   * @returns {ng.ICompileProvider} Self for chaining.
+   */
+  directive: (
+    name: string | any,
+    directiveFactory: Function | any[],
+  ) => ng.ICompileProvider;
+  /**
+   * @ngdoc method
+   * @name $compileProvider#component
+   * @module ng
+   * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
+   *    or an object map of components where the keys are the names and the values are the component definition objects.
+   * @param {Object} options Component definition object (a simplified
+   *    {@link ng.$compile#directive-definition-object directive definition object}),
+   *    with the following properties (all optional):
+   *
+   *    - `controller` – `{(string|function()=}` – controller constructor function that should be
+   *      associated with newly created scope or the name of a {@link ng.$compile#-controller-
+   *      registered controller} if passed as a string. An empty `noop` function by default.
+   *    - `controllerAs` – `{string=}` – identifier name for to reference the controller in the component's scope.
+   *      If present, the controller will be published to scope under the `controllerAs` name.
+   *      If not present, this will default to be `$ctrl`.
+   *    - `template` – `{string=|function()=}` – html template as a string or a function that
+   *      returns an html template as a string which should be used as the contents of this component.
+   *      Empty string by default.
+   *
+   *      If `template` is a function, then it is {@link auto.$injector#invoke injected} with
+   *      the following locals:
+   *
+   *      - `$element` - Current element
+   *      - `$attrs` - Current attributes object for the element
+   *
+   *    - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
+   *      template that should be used  as the contents of this component.
+   *
+   *      If `templateUrl` is a function, then it is {@link auto.$injector#invoke injected} with
+   *      the following locals:
+   *
+   *      - `$element` - Current element
+   *      - `$attrs` - Current attributes object for the element
+   *
+   *    - `bindings` – `{object=}` – defines bindings between DOM attributes and component properties.
+   *      Component properties are always bound to the component controller and not to the scope.
+   *      See {@link ng.$compile#-bindtocontroller- `bindToController`}.
+   *    - `transclude` – `{boolean=}` – whether {@link $compile#transclusion content transclusion} is enabled.
+   *      Disabled by default.
+   *    - `require` - `{Object<string, string>=}` - requires the controllers of other directives and binds them to
+   *      this component's controller. The object keys specify the property names under which the required
+   *      controllers (object values) will be bound. See {@link ng.$compile#-require- `require`}.
+   *    - `$...` – additional properties to attach to the directive factory function and the controller
+   *      constructor function. (This is used by the component router to annotate)
+   *
+   * @returns {ng.$compileProvider} the compile provider itself, for chaining of function calls.
+   * @description
+   * Register a **component definition** with the compiler. This is a shorthand for registering a special
+   * type of directive, which represents a self-contained UI component in your application. Such components
+   * are always isolated (i.e. `scope: {}`) and are always restricted to elements (i.e. `restrict: 'E'`).
+   *
+   * Component definitions are very simple and do not require as much configuration as defining general
+   * directives. Component definitions usually consist only of a template and a controller backing it.
+   *
+   * In order to make the definition easier, components enforce best practices like use of `controllerAs`,
+   * `bindToController`. They always have **isolate scope** and are restricted to elements.
+   *
+   * Here are a few examples of how you would usually define components:
+   *
+   * ```js
+   *   let myMod = angular.module(...);
+   *   myMod.component('myComp', {
+   *     template: '<div>My name is {{$ctrl.name}}</div>',
+   *     controller: function() {
+   *       this.name = 'shahar';
+   *     }
+   *   });
+   *
+   *   myMod.component('myComp', {
+   *     template: '<div>My name is {{$ctrl.name}}</div>',
+   *     bindings: {name: '@'}
+   *   });
+   *
+   *   myMod.component('myComp', {
+   *     templateUrl: 'views/my-comp.html',
+   *     controller: 'MyCtrl',
+   *     controllerAs: 'ctrl',
+   *     bindings: {name: '@'}
+   *   });
+   *
+   * ```
+   * For more examples, and an in-depth guide, see the {@link guide/component component guide}.
+   *
+   * <br />
+   * See also {@link ng.$compileProvider#directive $compileProvider.directive()}.
+   */
+  component: (name: string | any, options: any) => ng.$compileProvider;
+  /**
+   * @ngdoc method
+   * @name $compileProvider#aHrefSanitizationTrustedUrlList
+   * @kind function
+   *
+   * @description
+   * Retrieves or overrides the default regular expression that is used for determining trusted safe
+   * urls during a[href] sanitization.
+   *
+   * The sanitization is a security measure aimed at preventing XSS attacks via html links.
+   *
+   * Any url about to be assigned to a[href] via data-binding is first normalized and turned into
+   * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationTrustedUrlList`
+   * regular expression. If a match is found, the original url is written into the dom. Otherwise,
+   * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
+   *
+   * @param {RegExp=} regexp New regexp to trust urls with.
+   * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+   *    chaining otherwise.
+   */
+  aHrefSanitizationTrustedUrlList: (
+    regexp?: RegExp | undefined,
+  ) => RegExp | ng.ICompileProvider;
+  /**
+   * @ngdoc method
+   * @name $compileProvider#imgSrcSanitizationTrustedUrlList
+   * @kind function
+   *
+   * @description
+   * Retrieves or overrides the default regular expression that is used for determining trusted safe
+   * urls during img[src] sanitization.
+   *
+   * The sanitization is a security measure aimed at prevent XSS attacks via html links.
+   *
+   * Any url about to be assigned to img[src] via data-binding is first normalized and turned into
+   * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationTrustedUrlList`
+   * regular expression. If a match is found, the original url is written into the dom. Otherwise,
+   * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
+   *
+   * @param {RegExp=} regexp New regexp to trust urls with.
+   * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+   *    chaining otherwise.
+   */
+  imgSrcSanitizationTrustedUrlList: (
+    regexp?: RegExp | undefined,
+  ) => RegExp | ng.ICompileProvider;
+  debugInfoEnabled: (enabled: any) => boolean | this;
+  strictComponentBindingsEnabled: (enabled: any) => boolean | this;
+  /**
+   * @ngdoc method
+   * @name $compileProvider#addPropertySecurityContext
+   * @description
+   *
+   * Defines the security context for DOM properties bound by ng-prop-*.
+   *
+   * @param {string} elementName The element name or '*' to match any element.
+   * @param {string} propertyName The DOM property name.
+   * @param {string} ctx The {@link $sce} security context in which this value is safe for use, e.g. `$sce.URL`
+   * @returns {object} `this` for chaining
+   */
+  addPropertySecurityContext: (
+    elementName: string,
+    propertyName: string,
+    ctx: string,
+  ) => object;
+  $get: (
+    | string
+    | ((
+        $injector: any,
+        $interpolate: any,
+        $exceptionHandler: any,
+        $templateRequest: any,
+        $parse: any,
+        $controller: any,
+        $rootScope: any,
+        $sce: any,
+        $animate: any,
+      ) => (
+        $compileNodes: string | NodeList,
+        transcludeFn: any,
+        maxPriority: any,
+        ignoreDirective: any,
+        previousCompileContext: any,
+      ) => (scope: any, cloneConnectFn: any, options: any) => any)
+  )[];
+}
+export namespace $CompileProvider {
+  let $inject: string[];
+}
+/**
+ * Function that aggregates all linking fns for a compilation root (nodeList)
+ */
+export type CompositeLinkFn = Function;

package/types/core/controller.d.ts

@@ -0,0 +1,42 @@
+export function identifierForController(controller: any, ident: any): any;
+/**
+ * @ngdoc provider
+ * @name $controllerProvider
+ *
+ *
+ * @description
+ * The {@link ng.$controller $controller service} is used by AngularJS to create new
+ * controllers.
+ *
+ * This provider allows controller registration via the
+ * {@link ng.$controllerProvider#register register} method.
+ */
+export function $ControllerProvider(): void;
+export class $ControllerProvider {
+  /**
+   * @ngdoc method
+   * @name $controllerProvider#has
+   * @param {string} name Controller name to check.
+   */
+  has: (name: string) => any;
+  /**
+   * @ngdoc method
+   * @name $controllerProvider#register
+   * @param {string|Object} name Controller name, or an object map of controllers where the keys are
+   *    the names and the values are the constructors.
+   * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
+   *    annotations in the array notation).
+   */
+  register: (name: string | any, constructor: Function | any[]) => void;
+  $get: (
+    | string
+    | ((
+        $injector: any,
+      ) => (
+        expression: Function | string,
+        locals: any,
+        later: any,
+        ident: any,
+      ) => any)
+  )[];
+}

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

@@ -0,0 +1,46 @@
+/**
+ * @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.
+ *
+ */
+export function $ExceptionHandlerProvider(): void;
+export class $ExceptionHandlerProvider {
+  $get: (string | (($log: any) => (...args: any[]) => void))[];
+}

package/types/core/filter.d.ts

@@ -0,0 +1,9 @@
+export function $FilterProvider($provide: any): void;
+export class $FilterProvider {
+  constructor($provide: any);
+  register: (name: any, factory: any) => any;
+  $get: (string | (($injector: any) => (name: any) => any))[];
+}
+export namespace $FilterProvider {
+  let $inject: string[];
+}

package/types/core/interpolate.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @ngdoc provider
+ * @name $interpolateProvider
+ *
+ *
+ * @description
+ *
+ * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
+ *
+ * <div class="alert alert-danger">
+ * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularJS
+ * template within a Python Jinja template (or any other template language). Mixing templating
+ * languages is **very dangerous**. The embedding template language will not safely escape AngularJS
+ * expressions, so any user-controlled values in the template will cause Cross Site Scripting (XSS)
+ * security bugs!
+ * </div>
+ */
+export function $InterpolateProvider(): void;
+export class $InterpolateProvider {
+  /**
+   * @ngdoc method
+   * @name $interpolateProvider#startSymbol
+   * @description
+   * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
+   *
+   * @param {string=} value new value to set the starting symbol to.
+   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+   */
+  startSymbol: (
+    value?: string | undefined,
+  ) => string | (Window & typeof globalThis);
+  /**
+   * @ngdoc method
+   * @name $interpolateProvider#endSymbol
+   * @description
+   * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
+   *
+   * @param {string=} value new value to set the ending symbol to.
+   * @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,
+      ) => {
+        (
+          text: string,
+          mustHaveExpression?: boolean | undefined,
+          trustedContext?: string | undefined,
+          allOrNothing?: boolean | undefined,
+        ): (arg0: context) => any;
+        /**
+         * @ngdoc method
+         * @name $interpolate#startSymbol
+         * @description
+         * Symbol to denote the start of expression in the interpolated string. Defaults to `{{`.
+         *
+         * Use {@link ng.$interpolateProvider#startSymbol `$interpolateProvider.startSymbol`} to change
+         * the symbol.
+         *
+         * @returns {string} start symbol.
+         */
+        startSymbol(): string;
+        /**
+         * @ngdoc method
+         * @name $interpolate#endSymbol
+         * @description
+         * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
+         *
+         * Use {@link ng.$interpolateProvider#endSymbol `$interpolateProvider.endSymbol`} to change
+         * the symbol.
+         *
+         * @returns {string} end symbol.
+         */
+        endSymbol(): string;
+      })
+  )[];
+}

package/types/core/interval-factory.d.ts

@@ -0,0 +1,21 @@
+export function $$IntervalFactoryProvider(): void;
+export class $$IntervalFactoryProvider {
+  $get: (
+    | string
+    | ((
+        $browser: any,
+        $q: any,
+        $$q: any,
+        $rootScope: any,
+      ) => (
+        setIntervalFn: any,
+        clearIntervalFn: any,
+      ) => (
+        fn: any,
+        delay: any,
+        count: any,
+        invokeApply: any,
+        ...args: any[]
+      ) => any)
+  )[];
+}

package/types/core/interval.d.ts

@@ -0,0 +1,4 @@
+export function $IntervalProvider(): void;
+export class $IntervalProvider {
+  $get: (string | (($$intervalFactory: any) => any))[];
+}