@angular-wave/angular.ts 0.9.2 → 0.9.4

package/@types/services/template-cache/template-cache.d.ts

@@ -2,10 +2,10 @@
  * Provides an instance of a cache that can be used to store and retrieve template content.
  */
 export class TemplateCacheProvider {
-  /** @type {import('./interface.ts').TemplateCache} */
-  cache: import("./interface.ts").TemplateCache;
+  /** @type {ng.TemplateCacheService} */
+  cache: ng.TemplateCacheService;
   /**
-   * @returns {import('./interface.ts').TemplateCache}
+   * @returns {ng.TemplateCacheService}
    */
-  $get(): import("./interface.ts").TemplateCache;
+  $get(): ng.TemplateCacheService;
 }

package/@types/services/template-request/interface.d.ts

@@ -0,0 +1,22 @@
+export interface TemplateRequestService {
+  /**
+   * Downloads a template using $http and, upon success, stores the
+   * contents inside of $templateCache.
+   *
+   * If the HTTP request fails or the response data of the HTTP request is
+   * empty then a $compile error will be thrown (unless
+   * {ignoreRequestError} is set to true).
+   *
+   * @param tpl                  The template URL.
+   * @param ignoreRequestError   Whether or not to ignore the exception
+   *                             when the request fails or the template is
+   *                             empty.
+   *
+   * @return   A promise whose value is the template content.
+   */
+  (tpl: string, ignoreRequestError?: boolean): Promise<string>;
+  /**
+   * total amount of pending template requests being downloaded.
+   */
+  totalPendingRequests: number;
+}

package/@types/services/{template-request.d.ts → template-request/template-request.d.ts}

@@ -43,13 +43,10 @@ export class TemplateRequestProvider {
   $get: (
     | string
     | ((
-        $exceptionHandler: import("./exception/exception-handler.js").ErrorHandler,
-        $templateCache: import("../services/template-cache/interface.ts").TemplateCache,
-        $http: any,
+        $exceptionHandler: ng.ExceptionHandlerService,
+        $templateCache: ng.TemplateCacheService,
+        $http: ng.HttpService,
         $sce: any,
-      ) => {
-        (tpl: any, ignoreRequestError: any): any;
-        totalPendingRequests: number;
-      })
+      ) => ng.TemplateRequestService)
   )[];
 }

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

@@ -1,67 +1,4 @@
 export function equals(o1: any, o2: any): any;
-/**
- * Builds proxy functions on the `to` object which pass through to the `from` object.
- *
- * For each key in `fnNames`, creates a proxy function on the `to` object.
- * The proxy function calls the real function on the `from` object.
- *
- *
- * #### Example:
- * This example creates an new class instance whose functions are prebound to the new'd object.
- * ```js
- * class Foo {
- *   constructor(data) {
- *     // Binds all functions from Foo.prototype to 'this',
- *     // then copies them to 'this'
- *     bindFunctions(Foo.prototype, this, this);
- *     this.data = data;
- *   }
- *
- *   log() {
- *     console.log(this.data);
- *   }
- * }
- *
- * let myFoo = new Foo([1,2,3]);
- * var logit = myFoo.log;
- * logit(); // logs [1, 2, 3] from the myFoo 'this' instance
- * ```
- *
- * #### Example:
- * This example creates a bound version of a service function, and copies it to another object
- * ```
- *
- * var SomeService = {
- *   this.data = [3, 4, 5];
- *   this.log = function() {
- *     console.log(this.data);
- *   }
- * }
- *
- * // Constructor fn
- * function OtherThing() {
- *   // Binds all functions from SomeService to SomeService,
- *   // then copies them to 'this'
- *   bindFunctions(SomeService, this, SomeService);
- * }
- *
- * let myOtherThing = new OtherThing();
- * myOtherThing.log(); // logs [3, 4, 5] from SomeService's 'this'
- * ```
- *
- * @param source A function that returns the source object which contains the original functions to be bound
- * @param target A function that returns the target object which will receive the bound functions
- * @param bind A function that returns the object which the functions will be bound to
- * @param fnNames The function names which will be bound (Defaults to all the functions found on the 'from' object)
- * @param latebind If true, the binding of the function is delayed until the first time it's invoked
- */
-export function createProxyFunctions(
-  source: any,
-  target: any,
-  bind: any,
-  fnNames: any,
-  latebind?: boolean,
-): any;
 /**
  * prototypal inheritance helper.
  * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it
@@ -75,7 +12,14 @@ export function createProxyFunctions(
  * @returns {Object} - A new object with `parent` as its prototype and properties from `extra`.
  */
 export function inherit(parent: any, extra?: any): any;
-export function _removeFrom(array: any, obj: any): any;
+/**
+ * Given an array, and an item, if the item is found in the array, it removes it (in-place).
+ * The same array is returned
+ * @param {Array} array
+ * @param {any} obj
+ * @returns {Array}
+ */
+export function removeFrom(array: any[], obj: any): any[];
 /**
  * Applies a set of defaults to an options object.  The options object is filtered
  * to only those properties of the objects in the defaultsList.
@@ -177,11 +121,6 @@ export function tail<T>(arr: T[]): T | undefined;
  * shallow copy from src to dest
  */
 export function copy(src: any, dest: any): any;
-/**
- * Given an array, and an item, if the item is found in the array, it removes it (in-place).
- * The same array is returned
- */
-export const removeFrom: 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;

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

@@ -48,12 +48,13 @@ export function curry(fn: any): any | (() => any | any);
  */
 export function compose(...args: any[]): () => any;
 /**
- * Given a varargs list of functions, returns a function that is composes the argument functions, left-to-right
- * given: f(x), g(x), h(x)
- * let piped = pipe(f,g,h);
- * then, piped is: h(g(f(x)))
+ * Given a class constructor, returns a predicate function that checks
+ * whether a given object is an instance of that class.
+ *
+ * @param {new (...args: any[]) => any} ctor - The class constructor to check against.
+ * @returns {(obj: any) => boolean} A predicate function that returns true if the object is of the given class.
  */
-export function pipe(...args: any[]): any;
+export function is(ctor: new (...args: any[]) => any): (obj: any) => boolean;
 /**
  * Sorta like Pattern Matching (a functional programming conditional construct)
  *
@@ -103,6 +104,5 @@ export function pattern(struct: any): (arg0: any) => any;
  * getName(obj) === true
  */
 export const propEq: any;
-export function parse(name: any): any;
-export function is(ctor: any): (obj: any) => boolean;
+export function parse(path: any): (obj: any) => any;
 export function val(v: any): () => any;