@angular-wave/angular.ts 0.0.35 → 0.0.37

package/types/services/http.d.ts

@@ -0,0 +1,157 @@
+export function $HttpParamSerializerProvider(): void;
+export class $HttpParamSerializerProvider {
+  /**
+   * @ngdoc service
+   * @name $httpParamSerializer
+   * @description
+   *
+   * Default {@link $http `$http`} params serializer that converts objects to strings
+   * according to the following rules:
+   *
+   * * `{'foo': 'bar'}` results in `foo=bar`
+   * * `{'foo': Date.now()}` results in `foo=2015-04-01T09%3A50%3A49.262Z` (`toISOString()` and encoded representation of a Date object)
+   * * `{'foo': ['bar', 'baz']}` results in `foo=bar&foo=baz` (repeated key for each array element)
+   * * `{'foo': {'bar':'baz'}}` results in `foo=%7B%22bar%22%3A%22baz%22%7D` (stringified and encoded representation of an object)
+   *
+   * Note that serializer will sort the request parameters alphabetically.
+   */
+  $get: () => (params: any) => string;
+}
+export function $HttpParamSerializerJQLikeProvider(): void;
+export class $HttpParamSerializerJQLikeProvider {
+  /**
+   * @ngdoc service
+   * @name $httpParamSerializerJQLike
+   *
+   * @description
+   *
+   * Alternative {@link $http `$http`} params serializer that follows
+   * jQuery's [`param()`](http://api.jquery.com/jquery.param/) method logic.
+   * The serializer will also sort the params alphabetically.
+   *
+   * To use it for serializing `$http` request parameters, set it as the `paramSerializer` property:
+   *
+   * ```js
+   * $http({
+   *   url: myUrl,
+   *   method: 'GET',
+   *   params: myParams,
+   *   paramSerializer: '$httpParamSerializerJQLike'
+   * });
+   * ```
+   *
+   * It is also possible to set it as the default `paramSerializer` in the
+   * {@link $httpProvider#defaults `$httpProvider`}.
+   *
+   * Additionally, you can inject the serializer and use it explicitly, for example to serialize
+   * form data for submission:
+   *
+   * ```js
+   * .controller(function($http, $httpParamSerializerJQLike) {
+   *   //...
+   *
+   *   $http({
+   *     url: myUrl,
+   *     method: 'POST',
+   *     data: $httpParamSerializerJQLike(myData),
+   *     headers: {
+   *       'Content-Type': 'application/x-www-form-urlencoded'
+   *     }
+   *   });
+   *
+   * });
+   * ```
+   *
+   */
+  $get: () => (params: any) => string;
+}
+export function defaultHttpResponseTransform(data: any, headers: any): any;
+/**
+ * @ngdoc provider
+ * @name $httpProvider
+ *
+ *
+ * @description
+ * Use `$httpProvider` to change the default behavior of the {@link ng.$http $http} service.
+ */
+export function $HttpProvider(): void;
+export class $HttpProvider {
+  defaults: {
+    transformResponse: (typeof defaultHttpResponseTransform)[];
+    transformRequest: ((d: any) => any)[];
+    headers: {
+      common: {
+        Accept: string;
+      };
+      post: any;
+      put: any;
+      patch: any;
+    };
+    xsrfCookieName: string;
+    xsrfHeaderName: string;
+    paramSerializer: string;
+  };
+  /**
+   * @ngdoc method
+   * @name $httpProvider#useApplyAsync
+   * @description
+   *
+   * Configure $http service to combine processing of multiple http responses received at around
+   * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
+   * significant performance improvement for bigger applications that make many HTTP requests
+   * concurrently (common during application bootstrap).
+   *
+   * Defaults to false. If no value is specified, returns the current configured value.
+   *
+   * @param {boolean=} value If true, when requests are loaded, they will schedule a deferred
+   *    "apply" on the next tick, giving time for subsequent requests in a roughly ~10ms window
+   *    to load and share the same digest cycle.
+   *
+   * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining.
+   *    otherwise, returns the current configured value.
+   */
+  useApplyAsync: (value?: boolean | undefined) => boolean | any;
+  interceptors: any[];
+  xsrfTrustedOrigins: any[];
+  $get: (
+    | string
+    | ((
+        $browser: any,
+        $httpBackend: any,
+        $$cookieReader: any,
+        $cacheFactory: any,
+        $rootScope: any,
+        $q: any,
+        $injector: any,
+        $sce: any,
+      ) => {
+        (requestConfig: any): HttpPromise;
+        pendingRequests: any[];
+        /**
+         * @ngdoc property
+         * @name $http#defaults
+         *
+         * @description
+         * Runtime equivalent of the `$httpProvider.defaults` property. Allows configuration of
+         * default headers, withCredentials as well as request and response transformations.
+         *
+         * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
+         */
+        defaults: {
+          transformResponse: (typeof defaultHttpResponseTransform)[];
+          transformRequest: ((d: any) => any)[];
+          headers: {
+            common: {
+              Accept: string;
+            };
+            post: any;
+            put: any;
+            patch: any;
+          };
+          xsrfCookieName: string;
+          xsrfHeaderName: string;
+          paramSerializer: string;
+        };
+      })
+  )[];
+}

package/types/services/log.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @ngdoc provider
+ * @name $logProvider
+ * @type {ng.ILogProvider}
+ *
+ * @description
+ * Use the `$logProvider` to configure how the application logs messages
+ */
+export class $LogProvider {
+  debug: boolean;
+  /**
+   * @ngdoc method
+   * @name $logProvider#debugEnabled
+   * @description
+   * @param {boolean=} flag enable or disable debug level messages
+   * @returns {*} current value if used as getter or itself (chaining) if used as setter
+   */
+  debugEnabled(flag?: boolean | undefined): any;
+  formatError(arg: any): any;
+  consoleLog(type: any): (...args: any[]) => any;
+  $get(): {
+    /**
+     * @ngdoc method
+     * @name $log#log
+     *
+     * @description
+     * Write a log message
+     */
+    log: (...args: any[]) => any;
+    /**
+     * @ngdoc method
+     * @name $log#info
+     *
+     * @description
+     * Write an information message
+     */
+    info: (...args: any[]) => any;
+    /**
+     * @ngdoc method
+     * @name $log#warn
+     *
+     * @description
+     * Write a warning message
+     */
+    warn: (...args: any[]) => any;
+    /**
+     * @ngdoc method
+     * @name $log#error
+     *
+     * @description
+     * Write an error message
+     */
+    error: (...args: any[]) => any;
+    /**
+     * @ngdoc method
+     * @name $log#debug
+     *
+     * @description
+     * Write a debug message
+     */
+    debug: (...args: any[]) => void;
+  };
+}

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

@@ -0,0 +1,69 @@
+/**
+ * @ngdoc provider
+ * @name $templateRequestProvider
+ * @this
+ *
+ * @description
+ * Used to configure the options passed to the {@link $http} service when making a template request.
+ *
+ * For example, it can be used for specifying the "Accept" header that is sent to the server, when
+ * requesting a template.
+ */
+export function TemplateRequestProvider(this: any): void;
+export class TemplateRequestProvider {
+  /**
+   * @ngdoc method
+   * @name $templateRequestProvider#httpOptions
+   * @description
+   * The options to be passed to the {@link $http} service when making the request.
+   * You can use this to override options such as the "Accept" header for template requests.
+   *
+   * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
+   * options if not overridden here.
+   *
+   * @param {string=} value new value for the {@link $http} options.
+   * @returns {string|self} Returns the {@link $http} options when used as getter and self if used as setter.
+   */
+  httpOptions: (val: any) => string | (Window & typeof globalThis);
+  /**
+   * @ngdoc service
+   * @name $templateRequest
+   *
+   * @description
+   * The `$templateRequest` service runs security checks then downloads the provided 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, a `$compile` error will be thrown (the
+   * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
+   * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
+   * when `tpl` is of type string and `$templateCache` has the matching entry.
+   *
+   * If you want to pass custom options to the `$http` service, such as setting the Accept header you
+   * can configure this via {@link $templateRequestProvider#httpOptions}.
+   *
+   * `$templateRequest` is used internally by {@link $compile}, {@link ngRoute.$route}, and directives such
+   * as {@link ngInclude} to download and cache templates.
+   *
+   * 3rd party modules should use `$templateRequest` if their services or directives are loading
+   * templates.
+   *
+   * @param {string|TrustedResourceUrl} tpl The HTTP request template URL
+   * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
+   *
+   * @return {Promise} a promise for the HTTP response data of the given URL.
+   *
+   * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
+   */
+  $get: (
+    | string
+    | ((
+        $exceptionHandler: any,
+        $templateCache: any,
+        $http: any,
+        $q: any,
+        $sce: any,
+      ) => {
+        (tpl: any, ignoreRequestError: any): any;
+        totalPendingRequests: number;
+      })
+  )[];
+}

package/types/shared/common.d.ts

@@ -0,0 +1,216 @@
+export function identity(x: 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
+ */
+/**
+ * prototypal inheritance helper.
+ * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it.
+ *
+ * @param {Object} parent - The object to be used as the prototype.
+ * @param {Object} [extra] - The object containing additional properties to be copied.
+ * @returns {Object} - A new object with `parent` as its prototype and properties from `extra`.
+ */
+export function inherit(parent: any, extra?: any): any;
+export function _inArray(array: any, obj: any): any;
+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.
+ * Earlier objects in the defaultsList take precedence when applying defaults.
+ */
+export function defaults(opts: any, ...defaultsList: any[]): any;
+/**
+ * Finds the common ancestor path between two states.
+ *
+ * @param {Object} first The first state.
+ * @param {Object} second The second state.
+ * @return {Array} Returns an array of state names in descending order, not including the root.
+ */
+export function ancestors(first: any, second: any): any[];
+/**
+ * Return a copy of the object only containing the whitelisted properties.
+ *
+ * #### Example:
+ * ```
+ * var foo = { a: 1, b: 2, c: 3 };
+ * var ab = pick(foo, ['a', 'b']); // { a: 1, b: 2 }
+ * ```
+ * @param obj the source object
+ * @param propNames an Array of strings, which are the whitelisted property names
+ */
+export function pick(obj: any, propNames: any): {};
+/**
+ * Return a copy of the object omitting the blacklisted properties.
+ *
+ * @example
+ * ```
+ *
+ * var foo = { a: 1, b: 2, c: 3 };
+ * var ab = omit(foo, ['a', 'b']); // { c: 3 }
+ * ```
+ * @param obj the source object
+ * @param propNames an Array of strings, which are the blacklisted property names
+ */
+export function omit(obj: any, propNames: any): {};
+/**
+ * Maps an array, or object to a property (by name)
+ */
+export function pluck(collection: any, propName: any): any;
+/** Filters an Array or an Object's properties based on a predicate */
+export function filter(collection: any, callback: any): {};
+/** Finds an object from an array, or a property of an object, that matches a predicate */
+export function find(collection: any, callback: any): undefined;
+/** Maps an array or object properties using a callback function */
+export function map(collection: any, callback: any, target: any): any;
+/**
+ * Reduce function that pushes an object to an array, then returns the array.
+ * Mostly just for [[flattenR]] and [[uniqR]]
+ */
+export function pushR(arr: any, obj: any): any;
+export function assertFn(
+  predicateOrMap: any,
+  errMsg?: string,
+): (obj: any) => any;
+/**
+ * Given two or more parallel arrays, returns an array of tuples where
+ * each tuple is composed of [ a[i], b[i], ... z[i] ]
+ *
+ * @example
+ * ```
+ *
+ * let foo = [ 0, 2, 4, 6 ];
+ * let bar = [ 1, 3, 5, 7 ];
+ * let baz = [ 10, 30, 50, 70 ];
+ * arrayTuples(foo, bar);       // [ [0, 1], [2, 3], [4, 5], [6, 7] ]
+ * arrayTuples(foo, bar, baz);  // [ [0, 1, 10], [2, 3, 30], [4, 5, 50], [6, 7, 70] ]
+ * ```
+ */
+export function arrayTuples(...args: any[]): any[][];
+/**
+ * Reduce function which builds an object from an array of [key, value] pairs.
+ *
+ * Each iteration sets the key/val pair on the memo object, then returns the memo for the next iteration.
+ *
+ * Each keyValueTuple should be an array with values [ key: string, value: any ]
+ *
+ * @example
+ * ```
+ *
+ * var pairs = [ ["fookey", "fooval"], ["barkey", "barval"] ]
+ *
+ * var pairsToObj = pairs.reduce((memo, pair) => applyPairs(memo, pair), {})
+ * // pairsToObj == { fookey: "fooval", barkey: "barval" }
+ *
+ * // Or, more simply:
+ * var pairsToObj = pairs.reduce(applyPairs, {})
+ * // pairsToObj == { fookey: "fooval", barkey: "barval" }
+ * ```
+ */
+export function applyPairs(memo: any, keyValTuple: any): any;
+/** Get the last element of an array */
+export function tail(arr: any): any;
+/**
+ * shallow copy from src to dest
+ */
+export function copy(src: any, dest: any): any;
+export const root: typeof globalThis;
+export const fromJson: any;
+export const toJson: any;
+/** Naive forEach implementation works with Objects or Arrays */
+export function forEach(obj: any, cb: any, _this: any): void;
+export function equals(o1: any, o2: any): any;
+/** Given an array, returns true if the object is found in the array, (using includes) */
+export const inArray: 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;
+/** pushes a values to an array and returns the value */
+export const pushTo: any;
+export function deregAll(functions: any): any;
+export function mergeR(memo: any, item: any): any;
+/** Maps an array or object properties using a callback function */
+export function mapObj(collection: any, callback: any, target: any): 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;
+export function flattenR(memo: any, elem: any): any;
+export function uniqR(acc: any, token: any): any;
+export function unnest(arr: any): any;
+export function flatten(arr: any): any;
+export function assertPredicate(
+  predicateOrMap: any,
+  errMsg?: string,
+): (obj: any) => any;
+export function assertMap(
+  predicateOrMap: any,
+  errMsg?: string,
+): (obj: any) => any;
+export function pairs(obj: any): any[][];
+export function silenceUncaughtInPromise(promise: any): any;
+export function silentRejection(error: any): any;

package/types/shared/hof.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Higher order functions
+ *
+ * These utility functions are exported, but are subject to change without notice.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Returns a new function for [Partial Application](https://en.wikipedia.org/wiki/Partial_application) of the original function.
+ *
+ * Given a function with N parameters, returns a new function that supports partial application.
+ * The new function accepts anywhere from 1 to N parameters.  When that function is called with M parameters,
+ * where M is less than N, it returns a new function that accepts the remaining parameters.  It continues to
+ * accept more parameters until all N parameters have been supplied.
+ *
+ *
+ * This contrived example uses a partially applied function as an predicate, which returns true
+ * if an object is found in both arrays.
+ * @example
+ * ```
+ * // returns true if an object is in both of the two arrays
+ * function inBoth(array1, array2, object) {
+ *   return array1.indexOf(object) !== -1 &&
+ *          array2.indexOf(object) !== 1;
+ * }
+ * let obj1, obj2, obj3, obj4, obj5, obj6, obj7
+ * let foos = [obj1, obj3]
+ * let bars = [obj3, obj4, obj5]
+ *
+ * // A curried "copy" of inBoth
+ * let curriedInBoth = curry(inBoth);
+ * // Partially apply both the array1 and array2
+ * let inFoosAndBars = curriedInBoth(foos, bars);
+ *
+ * // Supply the final argument; since all arguments are
+ * // supplied, the original inBoth function is then called.
+ * let obj1InBoth = inFoosAndBars(obj1); // false
+ *
+ * // Use the inFoosAndBars as a predicate.
+ * // Filter, on each iteration, supplies the final argument
+ * let allObjs = [ obj1, obj2, obj3, obj4, obj5, obj6, obj7 ];
+ * let foundInBoth = allObjs.filter(inFoosAndBars); // [ obj3 ]
+ *
+ * ```
+ *
+ * @param fn
+ * @returns {*|function(): (*|any)}
+ */
+export function curry(fn: any): any | (() => any | any);
+/**
+ * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left
+ * given: f(x), g(x), h(x)
+ * let composed = compose(f,g,h)
+ * then, composed is: f(g(h(x)))
+ */
+export function compose(...args: any[]): (...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)))
+ */
+export function pipe(...args: any[]): any;
+/**
+ * Given two functions that return truthy or falsey values, returns a function that returns truthy
+ * if both functions return truthy for the given arguments
+ */
+export function and(fn1: any, fn2: any): (...args: any[]) => any;
+/**
+ * Given two functions that return truthy or falsey values, returns a function that returns truthy
+ * if at least one of the functions returns truthy for the given arguments
+ */
+export function or(fn1: any, fn2: any): (...args: any[]) => any;
+export function invoke(fnName: any, args: any): (obj: any) => any;
+/**
+ * Sorta like Pattern Matching (a functional programming conditional construct)
+ *
+ * See http://c2.com/cgi/wiki?PatternMatching
+ *
+ * This is a conditional construct which allows a series of predicates and output functions
+ * to be checked and then applied.  Each predicate receives the input.  If the predicate
+ * returns truthy, then its matching output function (mapping function) is provided with
+ * the input and, then the result is returned.
+ *
+ * Each combination (2-tuple) of predicate + output function should be placed in an array
+ * of size 2: [ predicate, mapFn ]
+ *
+ * These 2-tuples should be put in an outer array.
+ *
+ * @example
+ * ```
+ *
+ * // Here's a 2-tuple where the first element is the isString predicate
+ * // and the second element is a function that returns a description of the input
+ * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
+ *
+ * // Second tuple: predicate "isNumber", mapfn returns a description
+ * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
+ *
+ * let third = [ (input) => input === null,  (input) => `Oh, null...` ];
+ *
+ * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
+ *
+ * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
+ *
+ * console.log(descriptionOf(undefined)); // 'notdefined'
+ * console.log(descriptionOf(55)); // '(55) That's a number!'
+ * console.log(descriptionOf("foo")); // 'Here's your string foo'
+ * ```
+ *
+ * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,
+ * with a Predicate and a mapping/output function
+ * @returns {function(any): *}
+ */
+export function pattern(struct: any): (arg0: any) => any;
+export function prop(name: any): (obj: any) => any;
+/**
+ * Given a property name and a value, returns a function that returns a boolean based on whether
+ * the passed object has a property that matches the value
+ * let obj = { foo: 1, name: "blarg" };
+ * let getName = propEq("name", "blarg");
+ * getName(obj) === true
+ */
+export const propEq: any;
+export function parse(name: any): any;
+export function not(fn: any): (...args: any[]) => boolean;
+export function all(fn1: any): (arr: any) => any;
+export function any(fn1: any): (arr: any) => any;
+export function is(ctor: any): (obj: any) => boolean;
+export function eq(value: any): (other: any) => boolean;
+export function val(v: any): () => any;

package/types/shared/predicates.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Predicate which checks if a value is injectable
+ *
+ * A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array
+ * where all the elements in the array are Strings, except the last one, which is a Function
+ */
+export function isInjectable(val: any): boolean;
+export function isNull(o: any): boolean;
+export const isNullOrUndefined: (...args: any[]) => any;
+/**
+ * Predicate which checks if a value looks like a Promise
+ *
+ * It is probably a Promise if it's an object, and it has a `then` property which is a Function
+ */
+export const isPromise: (...args: any[]) => any;