@angular-wave/angular.ts 0.0.35 → 0.0.37

package/types/directive/attrs.d.ts

@@ -0,0 +1,176 @@
+/**
+ * @ngdoc directive
+ * @name ngHref
+ * @restrict A
+ * @priority 99
+ *
+ * @description
+ * Using AngularJS markup like `{{hash}}` in an href attribute will
+ * make the link go to the wrong URL if the user clicks it before
+ * AngularJS has a chance to replace the `{{hash}}` markup with its
+ * value. Until AngularJS replaces the markup the link will be broken
+ * and will most likely return a 404 error. The `ngHref` directive
+ * solves this problem.
+ *
+ * The wrong way to write it:
+ * ```html
+ * <a href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
+ * ```
+ *
+ * The correct way to write it:
+ * ```html
+ * <a ng-href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
+ * ```
+ *
+ * @element A
+ * @param {template} ngHref any string which can contain `{{}}` markup.
+ *
+ */
+export const REGEX_STRING_REGEXP: RegExp;
+/**
+ * @ngdoc directive
+ * @name ngSrc
+ * @restrict A
+ * @priority 99
+ *
+ * @description
+ * Using AngularJS markup like `{{hash}}` in a `src` attribute doesn't
+ * work right: The browser will fetch from the URL with the literal
+ * text `{{hash}}` until AngularJS replaces the expression inside
+ * `{{hash}}`. The `ngSrc` directive solves this problem.
+ *
+ * The buggy way to write it:
+ * ```html
+ * <img src="http://www.gravatar.com/avatar/{{hash}}" alt="Description"/>
+ * ```
+ *
+ * The correct way to write it:
+ * ```html
+ * <img ng-src="http://www.gravatar.com/avatar/{{hash}}" alt="Description" />
+ * ```
+ *
+ * @element IMG
+ * @param {template} ngSrc any string which can contain `{{}}` markup.
+ */
+/**
+ * @ngdoc directive
+ * @name ngSrcset
+ * @restrict A
+ * @priority 99
+ *
+ * @description
+ * Using AngularJS markup like `{{hash}}` in a `srcset` attribute doesn't
+ * work right: The browser will fetch from the URL with the literal
+ * text `{{hash}}` until AngularJS replaces the expression inside
+ * `{{hash}}`. The `ngSrcset` directive solves this problem.
+ *
+ * The buggy way to write it:
+ * ```html
+ * <img srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description"/>
+ * ```
+ *
+ * The correct way to write it:
+ * ```html
+ * <img ng-srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description" />
+ * ```
+ *
+ * @element IMG
+ * @param {template} ngSrcset any string which can contain `{{}}` markup.
+ */
+/**
+ * @ngdoc directive
+ * @name ngDisabled
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ *
+ * This directive sets the `disabled` attribute on the element (typically a form control,
+ * e.g. `input`, `button`, `select` etc.) if the
+ * {@link guide/expression expression} inside `ngDisabled` evaluates to truthy.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `disabled`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * @param {string} ngDisabled If the {@link guide/expression expression} is truthy,
+ *     then the `disabled` attribute will be set on the element
+ */
+/**
+ * @ngdoc directive
+ * @name ngChecked
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ * Sets the `checked` attribute on the element, if the expression inside `ngChecked` is truthy.
+ *
+ * Note that this directive should not be used together with {@link ngModel `ngModel`},
+ * as this can lead to unexpected behavior.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `checked`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * @element INPUT
+ * @param {string} ngChecked If the {@link guide/expression expression} is truthy,
+ *     then the `checked` attribute will be set on the element
+ */
+/**
+ *
+ * @description
+ *
+ * Sets the `readonly` attribute on the element, if the expression inside `ngReadonly` is truthy.
+ * Note that `readonly` applies only to `input` elements with specific types. [See the input docs on
+ * MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly) for more information.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `readonly`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ * @element INPUT
+ * @param {string} ngReadonly If the {@link guide/expression expression} is truthy,
+ *     then special attribute "readonly" will be set on the element
+ */
+/**
+ * @ngdoc directive
+ * @name ngSelected
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ *
+ * Sets the `selected` attribute on the element, if the expression inside `ngSelected` is truthy.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `selected`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * <div class="alert alert-warning">
+ *   **Note:** `ngSelected` does not interact with the `select` and `ngModel` directives, it only
+ *   sets the `selected` attribute on the element. If you are using `ngModel` on the select, you
+ *   should not use `ngSelected` on the options, as `ngModel` will set the select value and
+ *   selected options.
+ * </div>
+ * @element OPTION
+ * @param {string} ngSelected If the {@link guide/expression expression} is truthy,
+ *     then special attribute "selected" will be set on the element
+ */
+/**
+ * @ngdoc directive
+ * @name ngOpen
+ * @restrict A
+ * @priority 100
+ *
+ * @description
+ *
+ * Sets the `open` attribute on the element, if the expression inside `ngOpen` is truthy.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `open`
+ * attribute. See the {@link guide/interpolation interpolation guide} for more info.
+ *
+ * ## A note about browser compatibility
+ *
+ * Internet Explorer and Edge do not support the `details` element, it is
+ * recommended to use {@link ng.ngShow} and {@link ng.ngHide} instead.
+ *
+ * @element DETAILS
+ * @param {string} ngOpen If the {@link guide/expression expression} is truthy,
+ *     then special attribute "open" will be set on the element
+ */
+export const ngAttributeAliasDirectives: {};

package/types/directive/bind.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @returns {angular.IDirective}
+ */
+export function ngBindDirective(): angular.IDirective;
+/**
+ * @returns {angular.IDirective}
+ */
+export function ngBindTemplateDirective(): angular.IDirective;
+/**
+ * TODO: add type
+ */
+export const ngBindHtmlDirective: (
+  | string
+  | (($parse: any) => {
+      restrict: string;
+      compile: (
+        _tElement: any,
+        tAttrs: any,
+      ) => (scope: any, element: any) => void;
+    })
+)[];

package/types/directive/change.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {angular.IDirective}
+ */
+export function ngChangeDirective(): angular.IDirective;

package/types/directive/class.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @ngdoc directive
+ * @name ngClass
+ * @restrict AC
+ * @element ANY
+ *
+ * @description
+ * The `ngClass` directive allows you to dynamically set CSS classes on an HTML element by databinding
+ * an expression that represents all classes to be added.
+ *
+ * The directive operates in three different ways, depending on which of three types the expression
+ * evaluates to:
+ *
+ * 1. If the expression evaluates to a string, the string should be one or more space-delimited class
+ * names.
+ *
+ * 2. If the expression evaluates to an object, then for each key-value pair of the
+ * object with a truthy value the corresponding key is used as a class name.
+ *
+ * 3. If the expression evaluates to an array, each element of the array should either be a string as in
+ * type 1 or an object as in type 2. This means that you can mix strings and objects together in an array
+ * to give you more control over what CSS classes appear. See the code below for an example of this.
+ *
+ *
+ * The directive won't add duplicate classes if a particular class was already set.
+ *
+ * When the expression changes, the previously added classes are removed and only then are the
+ * new classes added.
+ *
+ * @knownIssue
+ * You should not use {@link guide/interpolation interpolation} in the value of the `class`
+ * attribute, when using the `ngClass` directive on the same element.
+ * See {@link guide/interpolation#known-issues here} for more info.
+ *
+ * @animations
+ * | Animation                        | Occurs                              |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#addClass addClass}       | just before the class is applied to the element   |
+ * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
+ * | {@link ng.$animate#setClass setClass} | just before classes are added and classes are removed from the element at the same time |
+ *
+ * ### ngClass and pre-existing CSS3 Transitions/Animations
+   The ngClass directive still supports CSS3 Transitions/Animations even if they do not follow the ngAnimate CSS naming structure.
+   Upon animation ngAnimate will apply supplementary CSS classes to track the start and end of an animation, but this will not hinder
+   any pre-existing CSS transitions already on the element. To get an idea of what happens during a class-based animation, be sure
+   to view the step by step details of {@link $animate#addClass $animate.addClass} and
+   {@link $animate#removeClass $animate.removeClass}.
+ *
+ * @param {String} ngClass {@link guide/expression Expression} to eval. The result
+ *   of the evaluation can be a string representing space delimited class
+ *   names, an array, or a map of class names to boolean values. In the case of a map, the
+ *   names of the properties whose values are truthy will be added as css classes to the
+ *   element.
+ *
+ */
+export const ngClassDirective: (
+  | string
+  | (($parse: any) => {
+      restrict: string;
+      link(scope: any, element: any, attr: any): void;
+    })
+)[];
+/**
+ * @ngdoc directive
+ * @name ngClassOdd
+ * @restrict AC
+ *
+ * @description
+ * The `ngClassOdd` and `ngClassEven` directives work exactly as
+ * {@link ng.directive:ngClass ngClass}, except they work in
+ * conjunction with `ngRepeat` and take effect only on odd (even) rows.
+ *
+ * This directive can be applied only within the scope of an
+ * {@link ng.directive:ngRepeat ngRepeat}.
+ *
+ * @animations
+ * | Animation                        | Occurs                              |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#addClass addClass}       | just before the class is applied to the element   |
+ * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
+ *
+ * @element ANY
+ * @param {String} ngClassOdd {@link guide/expression Expression} to eval. The result
+ *   of the evaluation can be a string representing space delimited class names or an array.
+ *
+ *
+ */
+export const ngClassOddDirective: (
+  | string
+  | (($parse: any) => {
+      restrict: string;
+      link(scope: any, element: any, attr: any): void;
+    })
+)[];
+/**
+ * @ngdoc directive
+ * @name ngClassEven
+ * @restrict AC
+ *
+ * @description
+ * The `ngClassOdd` and `ngClassEven` directives work exactly as
+ * {@link ng.directive:ngClass ngClass}, except they work in
+ * conjunction with `ngRepeat` and take effect only on odd (even) rows.
+ *
+ * This directive can be applied only within the scope of an
+ * {@link ng.directive:ngRepeat ngRepeat}.
+ *
+ * @animations
+ * | Animation                        | Occurs                              |
+ * |----------------------------------|-------------------------------------|
+ * | {@link ng.$animate#addClass addClass}       | just before the class is applied to the element   |
+ * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
+ *
+ * @element ANY
+ * @param {String} ngClassEven {@link guide/expression Expression} to eval. The
+ *   result of the evaluation can be a string representing space delimited class names or an array.
+ *
+ */
+export const ngClassEvenDirective: (
+  | string
+  | (($parse: any) => {
+      restrict: string;
+      link(scope: any, element: any, attr: any): void;
+    })
+)[];

package/types/directive/cloak.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {angular.IDirective}
+ */
+export function ngCloakDirective(): angular.IDirective;

package/types/directive/controller.d.ts

@@ -0,0 +1,6 @@
+export const ngControllerDirective: (() => {
+  restrict: string;
+  scope: boolean;
+  controller: string;
+  priority: number;
+})[];

package/types/directive/events.d.ts

@@ -0,0 +1,12 @@
+export function createEventDirective(
+  $parse: any,
+  $rootScope: any,
+  $exceptionHandler: any,
+  directiveName: any,
+  eventName: any,
+  forceAsync: any,
+): {
+  restrict: string;
+  compile(_element: any, attr: any): (scope: any, element: any) => void;
+};
+export const ngEventDirectives: {};

package/types/directive/form.d.ts

@@ -0,0 +1,230 @@
+export function FormController(
+  $element: any,
+  $attrs: any,
+  $scope: any,
+  $animate: any,
+  $interpolate: any,
+): void;
+export class FormController {
+  constructor(
+    $element: any,
+    $attrs: any,
+    $scope: any,
+    $animate: any,
+    $interpolate: any,
+  );
+  $$controls: any[];
+  $error: {};
+  $$success: {};
+  $pending: any;
+  $name: any;
+  $dirty: boolean;
+  $pristine: boolean;
+  $valid: boolean;
+  $invalid: boolean;
+  $submitted: boolean;
+  $$parentForm: {
+    $addControl: () => void;
+    $getControls: () => any;
+    $$renameControl: typeof nullFormRenameControl;
+    $removeControl: () => void;
+    $setValidity: () => void;
+    $setDirty: () => void;
+    $setPristine: () => void;
+    $setSubmitted: () => void;
+    $$setSubmitted: () => void;
+  };
+  $$element: any;
+  $$animate: any;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$rollbackViewValue
+   *
+   * @description
+   * Rollback all form controls pending updates to the `$modelValue`.
+   *
+   * Updates may be pending by a debounced event or because the input is waiting for a some future
+   * event defined in `ng-model-options`. This method is typically needed by the reset button of
+   * a form that uses `ng-model-options` to pend updates.
+   */
+  $rollbackViewValue(): void;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$commitViewValue
+   *
+   * @description
+   * Commit all form controls pending updates to the `$modelValue`.
+   *
+   * Updates may be pending by a debounced event or because the input is waiting for a some future
+   * event defined in `ng-model-options`. This method is rarely needed as `NgModelController`
+   * usually handles calling this in response to input events.
+   */
+  $commitViewValue(): void;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$addControl
+   * @param {object} control control object, either a {@link form.FormController} or an
+   * {@link ngModel.NgModelController}
+   *
+   * @description
+   * Register a control with the form. Input elements using ngModelController do this automatically
+   * when they are linked.
+   *
+   * Note that the current state of the control will not be reflected on the new parent form. This
+   * is not an issue with normal use, as freshly compiled and linked controls are in a `$pristine`
+   * state.
+   *
+   * However, if the method is used programmatically, for example by adding dynamically created controls,
+   * or controls that have been previously removed without destroying their corresponding DOM element,
+   * it's the developers responsibility to make sure the current state propagates to the parent form.
+   *
+   * For example, if an input control is added that is already `$dirty` and has `$error` properties,
+   * calling `$setDirty()` and `$validate()` afterwards will propagate the state to the parent form.
+   */
+  $addControl(control: object): void;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$getControls
+   * @returns {Array} the controls that are currently part of this form
+   *
+   * @description
+   * This method returns a **shallow copy** of the controls that are currently part of this form.
+   * The controls can be instances of {@link form.FormController `FormController`}
+   * ({@link ngForm "child-forms"}) and of {@link ngModel.NgModelController `NgModelController`}.
+   * If you need access to the controls of child-forms, you have to call `$getControls()`
+   * recursively on them.
+   * This can be used for example to iterate over all controls to validate them.
+   *
+   * The controls can be accessed normally, but adding to, or removing controls from the array has
+   * no effect on the form. Instead, use {@link form.FormController#$addControl `$addControl()`} and
+   * {@link form.FormController#$removeControl `$removeControl()`} for this use-case.
+   * Likewise, adding a control to, or removing a control from the form is not reflected
+   * in the shallow copy. That means you should get a fresh copy from `$getControls()` every time
+   * you need access to the controls.
+   */
+  $getControls(): any[];
+  $$renameControl(control: any, newName: any): void;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$removeControl
+   * @param {object} control control object, either a {@link form.FormController} or an
+   * {@link ngModel.NgModelController}
+   *
+   * @description
+   * Deregister a control from the form.
+   *
+   * Input elements using ngModelController do this automatically when they are destroyed.
+   *
+   * Note that only the removed control's validation state (`$errors`etc.) will be removed from the
+   * form. `$dirty`, `$submitted` states will not be changed, because the expected behavior can be
+   * different from case to case. For example, removing the only `$dirty` control from a form may or
+   * may not mean that the form is still `$dirty`.
+   */
+  $removeControl(control: object): void;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$setDirty
+   *
+   * @description
+   * Sets the form to a dirty state.
+   *
+   * This method can be called to add the 'ng-dirty' class and set the form to a dirty
+   * state (ng-dirty class). This method will also propagate to parent forms.
+   */
+  $setDirty(): void;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$setPristine
+   *
+   * @description
+   * Sets the form to its pristine state.
+   *
+   * This method sets the form's `$pristine` state to true, the `$dirty` state to false, removes
+   * the `ng-dirty` class and adds the `ng-pristine` class. Additionally, it sets the `$submitted`
+   * state to false.
+   *
+   * This method will also propagate to all the controls contained in this form.
+   *
+   * Setting a form back to a pristine state is often useful when we want to 'reuse' a form after
+   * saving or resetting it.
+   */
+  $setPristine(): void;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$setUntouched
+   *
+   * @description
+   * Sets the form to its untouched state.
+   *
+   * This method can be called to remove the 'ng-touched' class and set the form controls to their
+   * untouched state (ng-untouched class).
+   *
+   * Setting a form controls back to their untouched state is often useful when setting the form
+   * back to its pristine state.
+   */
+  $setUntouched(): void;
+  /**
+   * @ngdoc method
+   * @name form.FormController#$setSubmitted
+   *
+   * @description
+   * Sets the form to its `$submitted` state. This will also set `$submitted` on all child and
+   * parent forms of the form.
+   */
+  $setSubmitted(): void;
+  $$setSubmitted(): void;
+}
+export namespace FormController {
+  let $inject: string[];
+}
+export function setupValidity(instance: any): void;
+export function addSetValidityMethod(context: any): void;
+export namespace nullFormCtrl {
+  export function $addControl(): void;
+  export let $getControls: () => any;
+  export { nullFormRenameControl as $$renameControl };
+  export function $removeControl(): void;
+  export function $setValidity(): void;
+  export function $setDirty(): void;
+  export function $setPristine(): void;
+  export function $setSubmitted(): void;
+  export function $$setSubmitted(): void;
+}
+export const formDirective: (
+  | string
+  | ((
+      $timeout: any,
+      $parse: any,
+    ) => {
+      name: string;
+      restrict: string;
+      require: string[];
+      controller: typeof FormController;
+      compile: (
+        formElement: any,
+        attr: any,
+      ) => {
+        pre: (scope: any, formElement: any, attr: any, ctrls: any) => void;
+      };
+    })
+)[];
+export const ngFormDirective: (
+  | string
+  | ((
+      $timeout: any,
+      $parse: any,
+    ) => {
+      name: string;
+      restrict: string;
+      require: string[];
+      controller: typeof FormController;
+      compile: (
+        formElement: any,
+        attr: any,
+      ) => {
+        pre: (scope: any, formElement: any, attr: any, ctrls: any) => void;
+      };
+    })
+)[];
+declare function nullFormRenameControl(control: any, name: any): void;
+export {};

package/types/directive/if.d.ts

@@ -0,0 +1,17 @@
+export const ngIfDirective: (
+  | string
+  | (($animate: any) => {
+      multiElement: boolean;
+      transclude: string;
+      priority: number;
+      terminal: boolean;
+      restrict: string;
+      link(
+        $scope: any,
+        $element: any,
+        $attr: any,
+        ctrl: any,
+        $transclude: any,
+      ): void;
+    })
+)[];

package/types/directive/include.d.ts

@@ -0,0 +1,33 @@
+export const ngIncludeDirective: (
+  | string
+  | ((
+      $templateRequest: any,
+      $anchorScroll: any,
+      $animate: any,
+    ) => {
+      restrict: string;
+      priority: number;
+      terminal: boolean;
+      transclude: string;
+      controller: () => void;
+      compile(
+        element: any,
+        attr: any,
+      ): (
+        scope: any,
+        $element: any,
+        $attr: any,
+        ctrl: any,
+        $transclude: any,
+      ) => void;
+    })
+)[];
+export const ngIncludeFillContentDirective: (
+  | string
+  | (($compile: any) => {
+      restrict: string;
+      priority: number;
+      require: string;
+      link(scope: any, $element: any, $attr: any, ctrl: any): void;
+    })
+)[];

package/types/directive/init.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {angular.IDirective}
+ */
+export function ngInitDirective(): angular.IDirective;