@angular-wave/angular.ts 0.0.38 → 0.0.39

package/types-back/index.d.ts

@@ -9,13 +9,6 @@ declare global {
   }
 }
 
-export as namespace angular;
-export as namespace ng;
-
-// Support AMD require
-export = angular;
-
-import ng = angular;
 import { Obj } from "./router";
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -39,11 +32,6 @@ declare namespace angular {
     $get: any;
   }
 
-  interface IAngularBootstrapConfig {
-    debugInfoEnabled: boolean;
-    strictDi?: boolean | undefined;
-  }
-
   ///////////////////////////////////////////////////////////////////////////
   // Module
   // see http://docs.angularjs.org/api/angular.Module
@@ -185,53 +173,6 @@ declare namespace angular {
     requires: string[];
   }
 
-  ///////////////////////////////////////////////////////////////////////////
-  // Attributes
-  // see http://docs.angularjs.org/api/ng/type/$compile.directive.Attributes
-  ///////////////////////////////////////////////////////////////////////////
-  interface IAttributes {
-    /**
-     * this is necessary to be able to access the scoped attributes. it's not very elegant
-     * because you have to use attrs['foo'] instead of attrs.foo but I don't know of a better way
-     * this should really be limited to return string but it creates this problem: http://stackoverflow.com/q/17201854/165656
-     */
-    [name: string]: any;
-
-    /**
-     * Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with x- or data-) to its normalized, camelCase form.
-     *
-     * Also there is special case for Moz prefix starting with upper case letter.
-     *
-     * For further information check out the guide on @see https://docs.angularjs.org/guide/directive#matching-directives
-     */
-    $normalize(name: string): string;
-
-    /**
-     * Adds and removes the appropriate CSS class values to the element based on the difference between
-     * the new and old CSS class values (specified as newClasses and oldClasses).
-     */
-    $updateClass(newClasses: string, oldClasses: string): void;
-
-    /**
-     * Set DOM element attribute value.
-     */
-    $set(key: string, value: any): void;
-
-    /**
-     * Observes an interpolated attribute.
-     * The observer function will be invoked once during the next $digest
-     * following compilation. The observer is then invoked whenever the
-     * interpolated value changes.
-     */
-    $observe<T>(name: string, fn: (value?: T) => any): Function;
-
-    /**
-     * A map of DOM element attribute names to the normalized name. This is needed
-     * to do reverse lookup from normalized name back to actual name.
-     */
-    $attr: Object;
-  }
-
   /**
    * form.FormController - type in module ng
    * see https://docs.angularjs.org/api/ng/type/form.FormController
@@ -2139,59 +2080,6 @@ declare namespace angular {
     require?: { [controller: string]: string } | undefined;
   }
 
-  type IControllerConstructor =
-    | (new (...args: any[]) => IController) // Instead of classes, plain functions are often used as controller constructors, especially in examples.
-    | ((...args: any[]) => void | IController);
-
-  /**
-   * Directive controllers have a well-defined lifecycle. Each controller can implement "lifecycle hooks". These are methods that
-   * will be called by Angular at certain points in the life cycle of the directive.
-   * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
-   * https://docs.angularjs.org/guide/component
-   */
-  interface IController {
-    /**
-     * Called on each controller after all the controllers on an element have been constructed and had their bindings
-     * initialized (and before the pre & post linking functions for the directives on this element). This is a good
-     * place to put initialization code for your controller.
-     */
-    $onInit?(): void;
-    /**
-     * Called on each turn of the digest cycle. Provides an opportunity to detect and act on changes.
-     * Any actions that you wish to take in response to the changes that you detect must be invoked from this hook;
-     * implementing this has no effect on when `$onChanges` is called. For example, this hook could be useful if you wish
-     * to perform a deep equality check, or to check a `Dat`e object, changes to which would not be detected by Angular's
-     * change detector and thus not trigger `$onChanges`. This hook is invoked with no arguments; if detecting changes,
-     * you must store the previous value(s) for comparison to the current values.
-     */
-    $doCheck?(): void;
-    /**
-     * Called whenever one-way bindings are updated. The onChangesObj is a hash whose keys are the names of the bound
-     * properties that have changed, and the values are an {@link IChangesObject} object  of the form
-     * { currentValue, previousValue, isFirstChange() }. Use this hook to trigger updates within a component such as
-     * cloning the bound value to prevent accidental mutation of the outer value.
-     */
-    $onChanges?(onChangesObj: IOnChangesObject): void;
-    /**
-     * Called on a controller when its containing scope is destroyed. Use this hook for releasing external resources,
-     * watches and event handlers.
-     */
-    $onDestroy?(): void;
-    /**
-     * Called after this controller's element and its children have been linked. Similar to the post-link function this
-     * hook can be used to set up DOM event handlers and do direct DOM manipulation. Note that child elements that contain
-     * templateUrl directives will not have been compiled and linked since they are waiting for their template to load
-     * asynchronously and their own compilation and linking has been suspended until that occurs. This hook can be considered
-     * analogous to the ngAfterViewInit and ngAfterContentInit hooks in Angular 2. Since the compilation process is rather
-     * different in Angular 1 there is no direct mapping and care should be taken when upgrading.
-     */
-    $postLink?(): void;
-
-    // IController implementations frequently do not implement any of its methods.
-    // A string indexer indicates to TypeScript not to issue a weak type error in this case.
-    [s: string]: any;
-  }
-
   /**
    * Interface for the $onInit lifecycle hook
    * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
@@ -2263,26 +2151,12 @@ declare namespace angular {
     $postLink(): void;
   }
 
-  interface IOnChangesObject {
-    [property: string]: IChangesObject<any>;
-  }
-
-  interface IChangesObject<T> {
-    currentValue: T;
-    previousValue: T;
-    isFirstChange(): boolean;
-  }
-
   ///////////////////////////////////////////////////////////////////////////
   // Directive
   // see http://docs.angularjs.org/api/ng/provider/$compileProvider#directive
   // and http://docs.angularjs.org/guide/directive
   ///////////////////////////////////////////////////////////////////////////
 
-  type IDirectiveController =
-    | IController
-    | IController[]
-    | { [key: string]: IController };
 
   interface IDirectiveFactory<
     TScope extends Scope = Scope,
@@ -2297,102 +2171,9 @@ declare namespace angular {
       | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>;
   }
 
-  interface IDirectiveLinkFn<
-    TScope extends Scope = Scope,
-    TElement extends JQLite = JQLite,
-    TAttributes extends IAttributes = IAttributes,
-    TController extends IDirectiveController = IController,
-  > {
-    (
-      scope: TScope,
-      instanceElement: TElement,
-      instanceAttributes: TAttributes,
-      controller?: TController,
-      transclude?: ITranscludeFunction,
-    ): void;
-  }
+ 
 
-  interface IDirectivePrePost<
-    TScope extends Scope = Scope,
-    TElement extends JQLite = JQLite,
-    TAttributes extends IAttributes = IAttributes,
-    TController extends IDirectiveController = IController,
-  > {
-    pre?:
-      | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>
-      | undefined;
-    post?:
-      | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>
-      | undefined;
-  }
-
-  interface IDirectiveCompileFn<
-    TScope extends Scope = Scope,
-    TElement extends JQLite = JQLite,
-    TAttributes extends IAttributes = IAttributes,
-    TController extends IDirectiveController = IController,
-  > {
-    (
-      templateElement: TElement,
-      templateAttributes: TAttributes,
-      /**
-       * @deprecated
-       * Note: The transclude function that is passed to the compile function is deprecated,
-       * as it e.g. does not know about the right outer scope. Please use the transclude function
-       * that is passed to the link function instead.
-       */
-      transclude: ITranscludeFunction,
-    ):
-      | void
-      | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>
-      | IDirectivePrePost<TScope, TElement, TAttributes, TController>;
-  }
-
-  interface IDirective<
-    TScope extends Scope = Scope,
-    TElement extends JQLite = JQLite,
-    TAttributes extends IAttributes = IAttributes,
-    TController extends IDirectiveController = IController,
-  > {
-    compile?:
-      | IDirectiveCompileFn<TScope, TElement, TAttributes, TController>
-      | undefined;
-    controller?: string | Injectable<IControllerConstructor> | undefined;
-    controllerAs?: string | undefined;
-    /**
-     * Deprecation warning: although bindings for non-ES6 class controllers are currently bound to this before
-     * the controller constructor is called, this use is now deprecated. Please place initialization code that
-     * relies upon bindings inside a $onInit method on the controller, instead.
-     */
-    bindToController?:
-      | boolean
-      | { [boundProperty: string]: string }
-      | undefined;
-    link?:
-      | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>
-      | IDirectivePrePost<TScope, TElement, TAttributes, TController>
-      | undefined;
-    multiElement?: boolean | undefined;
-    priority?: number | undefined;
-    /**
-     * @deprecated
-     */
-    replace?: boolean | undefined;
-    require?: string | string[] | { [controller: string]: string } | undefined;
-    restrict?: string | undefined;
-    scope?: boolean | { [boundProperty: string]: string } | undefined;
-    template?:
-      | string
-      | ((tElement: TElement, tAttrs: TAttributes) => string)
-      | undefined;
-    templateNamespace?: string | undefined;
-    templateUrl?:
-      | string
-      | ((tElement: TElement, tAttrs: TAttributes) => string)
-      | undefined;
-    terminal?: boolean | undefined;
-    transclude?: boolean | "element" | { [slot: string]: string } | undefined;
-  }
+  
 
   /**
    * These interfaces are kept for compatibility with older versions of these type definitions.

package/types/core/compile.d.ts

@@ -1,206 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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/filter.d.ts

@@ -1,9 +0,0 @@
-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/interval-factory.d.ts

@@ -1,21 +0,0 @@
-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)
-  )[];
-}