kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-05-31 11:07:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into react-icons

Browse Source
This commit is contained in:
Alexandre Pare
2017-01-31 14:16:55 -08:00
parent 5e88519fcb 8cb9653398
commit 6504302fb3
422 changed files with 10854 additions and 474 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
ISSUE_TEMPLATE.md
View File

@@ -1,5 +1,5 @@
- [ ] I tried using the latest `xxxx/xxxx.d.ts` file in this repo and had problems.
- [ ] I tried using the `@types/xxxx` package and had problems.
- [ ] I tried using the latest stable version of tsc. https://www.npmjs.com/package/typescript
- [ ] I have a question that is inappropriate for [StackOverflow](https://stackoverflow.com/). (Please ask any appropriate questions there).
- [ ] I want to talk about `xxxx/xxxx.d.ts`.
- The authors of that type definition are cc/ @....
- [ ] [Mention](https://github.com/blog/821-mention-somebody-they-re-notified) the authors (see `Definitions by:` in `index.d.ts`) so they can respond.
- Authors: @....

8
angular-gridster/index.d.ts vendored
View File

@@ -32,7 +32,7 @@ declare module "angular" {
// width of grid columns. "auto" will divide the width of the grid evenly among the columns
colWidth?: string;
// height of grid rows. 'match' will make it the same as the column width, a numeric value will be interpreted as pixels,
// height of grid rows. 'match' will make it the same as the column width, a numeric value will be interpreted as pixels,
// '/2' is half the column width, '*5' is five times the column width, etc.
rowHeight?: string;
@@ -84,7 +84,7 @@ declare module "angular" {
// options to pass to resizable handler
resizable?: {
// whether the items are resizable
// whether the items are resizable
enabled?: boolean;
// location of the resize handles
@@ -104,7 +104,7 @@ declare module "angular" {
// options to pass to draggable handler
draggable?: {
// whether the items are resizable
// whether the items are resizable
enabled?: boolean;
// Distance in pixels from the edge of the viewport after which the viewport should scroll, relative to pointer
@@ -142,4 +142,4 @@ declare module "angular" {
col: number;
}
}
}
}

4
angular/angular-component-router.d.ts vendored
View File

@@ -1,9 +1,9 @@
/* tslint:disable:dt-header variable-name */
// Type definitions for Angular JS 1.5 component router
// Project: http://angularjs.org
// Definitions by: David Reher <http://github.com/davidreher>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare namespace angular {
/**
* `Instruction` is a tree of {@link ComponentInstruction}s with all the information needed
@@ -263,7 +263,7 @@ declare namespace angular {
/**
* Subscribe to URL updates from the router
*/
subscribe(onNext: (value: any) => void): Object;
subscribe(onNext: (value: any) => void): {};
/**
* Removes the contents of this router's outlet and all descendant outlets

448
angular/angular-tests.ts
View File

@@ -1,4 +1,3 @@
// issue: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/369
// https://github.com/witoldsz/angular-http-auth/blob/master/src/angular-http-auth.js
/**
@@ -7,12 +6,14 @@
* License: MIT
*/
/* tslint:disable:no-empty no-shadowed-variable */
class AuthService {
/**
* Holds all the requests which failed due to 401 response,
* so they can be re-requested in future, once login is completed.
*/
buffer: { config: ng.IRequestConfig; deferred: ng.IDeferred<any>; }[] = [];
buffer: Array<{ config: ng.IRequestConfig; deferred: ng.IDeferred<any>; }> = [];
/**
* Required by HTTP interceptor.
@@ -20,34 +21,35 @@ class AuthService {
*/
pushToBuffer = function(config: ng.IRequestConfig, deferred: ng.IDeferred<any>) {
this.buffer.push({
config: config,
deferred: deferred
config,
deferred
});
}
};
$get = [
'$rootScope', '$injector', <any>function($rootScope: ng.IScope, $injector: ng.auto.IInjectorService) {
var $http: ng.IHttpService; //initialized later because of circular dependency problem
'$rootScope', '$injector', function($rootScope: ng.IScope, $injector: ng.auto.IInjectorService) {
let $http: ng.IHttpService; //initialized later because of circular dependency problem
function retry(config: ng.IRequestConfig, deferred: ng.IDeferred<any>) {
$http = $http || $injector.get<ng.IHttpService>('$http');
$http(config).then(function (response) {
$http(config).then(function(response) {
deferred.resolve(response);
});
}
function retryAll() {
for (var i = 0; i < this.buffer.length; ++i) {
retry(this.buffer[i].config, this.buffer[i].deferred);
for (const request of this.buffer) {
retry(request.config, request.deferred);
}
this.buffer = [];
}
return {
loginConfirmed: function () {
loginConfirmed() {
$rootScope.$broadcast('event:auth-loginConfirmed');
retryAll();
}
}
}
};
} as any
];
}
@@ -59,20 +61,20 @@ angular.module('http-auth-interceptor', [])
* $http interceptor.
* On 401 response - it stores the request and broadcasts 'event:angular-auth-loginRequired'.
*/
.config(['$httpProvider', 'authServiceProvider', <any>function ($httpProvider: ng.IHttpProvider, authServiceProvider: any) {
.config(['$httpProvider', 'authServiceProvider', function($httpProvider: ng.IHttpProvider, authServiceProvider: any) {
$httpProvider.defaults.headers.common = {'Authorization': 'Bearer token'};
$httpProvider.defaults.headers.common = {Authorization: 'Bearer token'};
$httpProvider.defaults.headers.get['Authorization'] = 'Bearer token';
$httpProvider.defaults.headers.post['Authorization'] = function (config:ng.IRequestConfig):string { return 'Bearer token'; }
$httpProvider.defaults.headers.post['Authorization'] = function(config: ng.IRequestConfig): string { return 'Bearer token'; };
var interceptor = ['$rootScope', '$q', <any>function ($rootScope: ng.IScope, $q: ng.IQService) {
const interceptor = ['$rootScope', '$q', function($rootScope: ng.IScope, $q: ng.IQService) {
function success(response: ng.IHttpPromiseCallbackArg<any>) {
return response;
}
function error(response: ng.IHttpPromiseCallbackArg<any>) {
if (response.status === 401) {
var deferred = $q.defer<void>();
const deferred = $q.defer<void>();
authServiceProvider.pushToBuffer(response.config, deferred);
$rootScope.$broadcast('event:auth-loginRequired');
return deferred.promise;
@@ -81,14 +83,13 @@ angular.module('http-auth-interceptor', [])
return $q.reject(response);
}
return function (promise: ng.IHttpPromise<any>) {
return function(promise: ng.IHttpPromise<any>) {
return promise.then(success, error);
}
};
}];
} as any];
$httpProvider.interceptors.push(interceptor);
}]);
} as any]);
namespace HttpAndRegularPromiseTests {
interface Person {
@@ -96,7 +97,7 @@ namespace HttpAndRegularPromiseTests {
lastName: string;
}
interface ExpectedResponse extends Person { }
type ExpectedResponse = Person;
interface SomeControllerScope extends ng.IScope {
person: Person;
@@ -106,13 +107,13 @@ namespace HttpAndRegularPromiseTests {
nothing?: string;
}
var someController: Function = ($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) => {
$http.get<ExpectedResponse>("http://somewhere/some/resource")
function someController($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) {
$http.get<ExpectedResponse>('http://somewhere/some/resource')
.success((data: ExpectedResponse) => {
$scope.person = data;
});
$http.get<ExpectedResponse>("http://somewhere/some/resource")
$http.get<ExpectedResponse>('http://somewhere/some/resource')
.then((response: ng.IHttpPromiseCallbackArg<ExpectedResponse>) => {
// typing lost, so something like
// var i: number = response.data
@@ -120,7 +121,7 @@ namespace HttpAndRegularPromiseTests {
$scope.person = response.data;
});
$http.get<ExpectedResponse>("http://somewhere/some/resource")
$http.get<ExpectedResponse>('http://somewhere/some/resource')
.then((response: ng.IHttpPromiseCallbackArg<ExpectedResponse>) => {
// typing lost, so something like
// var i: number = response.data
@@ -128,47 +129,48 @@ namespace HttpAndRegularPromiseTests {
$scope.person = response.data;
});
var aPromise: ng.IPromise<Person> = $q.when({ firstName: "Jack", lastName: "Sparrow" });
const aPromise: ng.IPromise<Person> = $q.when({ firstName: 'Jack', lastName: 'Sparrow' });
aPromise.then((person: Person) => {
$scope.person = person;
});
var bPromise: ng.IPromise<number> = $q.when(42);
const bPromise: ng.IPromise<number> = $q.when(42);
bPromise.then((answer: number) => {
$scope.theAnswer = answer;
});
var cPromise: ng.IPromise<string[]> = $q.when(["a", "b", "c"]);
const cPromise: ng.IPromise<string[]> = $q.when(['a', 'b', 'c']);
cPromise.then((letters: string[]) => {
$scope.letters = letters;
});
// When $q.when is passed an IPromise<T>, it returns an IPromise<T>
var dPromise: ng.IPromise<string> = $q.when($q.when("ALBATROSS!"));
const dPromise: ng.IPromise<string> = $q.when($q.when('ALBATROSS!'));
dPromise.then((snack: string) => {
$scope.snack = snack;
});
// $q.when may be called without arguments
var ePromise: ng.IPromise<void> = $q.when();
const ePromise: ng.IPromise<void> = $q.when();
ePromise.then(() => {
$scope.nothing = "really nothing";
$scope.nothing = 'really nothing';
});
}
// Test that we can pass around a type-checked success/error Promise Callback
var anotherController: Function = ($scope: SomeControllerScope, $http:
ng.IHttpService, $q: ng.IQService) => {
var buildFooData: Function = () => 42;
var doFoo: Function = (callback: ng.IHttpPromiseCallback<ExpectedResponse>) => {
$http.get<ExpectedResponse>('/foo', buildFooData())
.success(callback);
// Test that we can pass around a type-checked success/error Promise Callback
function anotherController($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) {
function buildFooData(): ng.IRequestShortcutConfig {
return {};
}
doFoo((data: any) => console.log(data));
}
function doFoo(callback: ng.IHttpPromiseCallback<ExpectedResponse>) {
$http
.get<ExpectedResponse>('/foo', buildFooData())
.success(callback);
};
doFoo((data: any) => console.log(data));
};
}
// Test for AngularJS Syntax
@@ -178,9 +180,9 @@ namespace My.Namespace {
}
// IModule Registering Test
var mod = angular.module('tests', []);
mod.controller('name', function ($scope: ng.IScope) { });
mod.controller('name', ['$scope', function ($scope: ng.IScope) { }]);
let mod = angular.module('tests', []);
mod.controller('name', function($scope: ng.IScope) { });
mod.controller('name', ['$scope', function($scope: ng.IScope) { }]);
mod.controller('name', class {
// Uncommenting the next line should lead to a type error because this signature isn't compatible
// with the signature of the `$onChanges` hook:
@@ -188,7 +190,7 @@ mod.controller('name', class {
});
mod.controller({
MyCtrl: class{},
MyCtrl2: function() {},
MyCtrl2: function() {}, // tslint:disable-line:object-literal-shorthand
MyCtrl3: ['$fooService', function($fooService: any) { }]
});
mod.directive('myDirectiveA', ($rootScope: ng.IRootScopeService) => {
@@ -201,7 +203,7 @@ mod.directive('myDirectiveA', ($rootScope: ng.IRootScopeService) => {
scope.$watch(() => foo, () => el.text(foo));
};
});
mod.directive('myDirectiveB', ['$rootScope', function ($rootScope: ng.IRootScopeService) {
mod.directive('myDirectiveB', ['$rootScope', function($rootScope: ng.IRootScopeService) {
return {
link(scope, el, attrs) {
el.click(e => {
@@ -218,38 +220,37 @@ mod.directive({
template: 'my-bar-dir.tpl.html'
})]
});
mod.factory('name', function ($scope: ng.IScope) { })
mod.factory('name', ['$scope', function ($scope: ng.IScope) { }])
mod.factory('name', function($scope: ng.IScope) { });
mod.factory('name', ['$scope', function($scope: ng.IScope) { }]);
mod.factory({
name1: function (foo: any) { },
name2: ['foo', function (foo: any) { }]
name1: function(foo: any) { }, // tslint:disable-line:object-literal-shorthand
name2: ['foo', function(foo: any) { }]
});
mod.filter('name', function ($scope: ng.IScope) { })
mod.filter('name', ['$scope', function ($scope: ng.IScope) { }])
mod.filter('name', function($scope: ng.IScope) { });
mod.filter('name', ['$scope', function($scope: ng.IScope) { }]);
mod.filter({
name1: function (foo: any) { },
name2: ['foo', function (foo: any) { }]
name1: function(foo: any) { }, // tslint:disable-line:object-literal-shorthand
name2: ['foo', function(foo: any) { }]
});
mod.provider('name', function ($scope: ng.IScope) { return { $get: () => { } } })
mod.provider('name', function($scope: ng.IScope) { return { $get: () => { } }; });
mod.provider('name', TestProvider);
mod.provider('name', ['$scope', <any>function ($scope: ng.IScope) { }])
mod.provider('name', ['$scope', function($scope: ng.IScope) { } as any]);
mod.provider(My.Namespace);
mod.service('name', function ($scope: ng.IScope) { })
mod.service('name', ['$scope', <any>function ($scope: ng.IScope) { }])
mod.service('name', function($scope: ng.IScope) { });
mod.service('name', ['$scope', function($scope: ng.IScope) { } as any]);
mod.service({
MyCtrl: class{},
MyCtrl2: function() {},
MyCtrl2: function() {}, // tslint:disable-line:object-literal-shorthand
MyCtrl3: ['$fooService', function($fooService: any) { }]
});
mod.constant('name', 23);
mod.constant('name', "23");
mod.constant('name', '23');
mod.constant(My.Namespace);
mod.value('name', 23);
mod.value('name', "23");
mod.value('name', '23');
mod.value(My.Namespace);
mod.decorator('name', function($scope:ng.IScope){ });
mod.decorator('name', ['$scope', <any>function($scope: ng.IScope){ }]);
mod.decorator('name', function($scope: ng.IScope) {});
mod.decorator('name', ['$scope', function($scope: ng.IScope) {} as any]);
class TestProvider implements ng.IServiceProvider {
constructor(private $scope: ng.IScope) {
@@ -261,23 +262,23 @@ class TestProvider implements ng.IServiceProvider {
// QProvider tests
angular.module('qprovider-test', [])
.config(['$qProvider', function ($qProvider: ng.IQProvider) {
.config(['$qProvider', function($qProvider: ng.IQProvider) {
const provider: ng.IQProvider = $qProvider.errorOnUnhandledRejections(false);
const currentValue: boolean = $qProvider.errorOnUnhandledRejections();
}]);
// Promise signature tests
var foo: ng.IPromise<number>;
let foo: ng.IPromise<number>;
foo.then((x) => {
// x is inferred to be a number
return "asdf";
return 'asdf';
}).then((x) => {
// x is inferred to be string
x.length;
const len = x.length;
return 123;
}).then((x) => {
// x is infered to be a number
x.toFixed();
const fixed = x.toFixed();
return;
}).then((x) => {
// x is infered to be void
@@ -336,15 +337,14 @@ namespace TestQ {
result = $q.all<TResult>([promiseAny, promiseAny]);
}
{
let result: angular.IPromise<{[id: string]: any;}>;
let result: angular.IPromise<{[id: string]: any; }>;
result = $q.all({a: promiseAny, b: promiseAny});
}
{
let result: angular.IPromise<{a: number; b: string;}>;
result = $q.all<{a: number; b: string;}>({a: promiseAny, b: promiseAny});
let result: angular.IPromise<{a: number; b: string; }>;
result = $q.all<{a: number; b: string; }>({a: promiseAny, b: promiseAny});
}
// $q.defer
{
let result: angular.IDeferred<TResult>;
@@ -397,11 +397,10 @@ namespace TestQ {
}
}
var httpFoo: ng.IHttpPromise<number>;
let httpFoo: ng.IHttpPromise<number>;
httpFoo.then((x) => {
// When returning a promise the generic type must be inferred.
var innerPromise : ng.IPromise<number>;
var innerPromise: ng.IPromise<number>;
return innerPromise;
}).then((x) => {
// must still be number.
@@ -409,13 +408,12 @@ httpFoo.then((x) => {
});
httpFoo.success((data, status, headers, config) => {
var h = headers("test");
const h = headers('test');
h.charAt(0);
var hs = headers();
hs["content-type"].charAt(1);
const hs = headers();
hs['content-type'].charAt(1);
});
// Deferred signature tests
namespace TestDeferred {
var any: any;
@@ -432,8 +430,8 @@ namespace TestDeferred {
// deferred.resolve
{
let result: void;
result = <void>deferred.resolve();
result = <void>deferred.resolve(tResult);
result = deferred.resolve() as void;
result = deferred.resolve(tResult) as void;
}
// deferred.reject
@@ -458,7 +456,7 @@ namespace TestDeferred {
}
namespace TestInjector {
let $injector: angular.auto.IInjectorService;
var $injector: angular.auto.IInjectorService;
$injector.strictDi = true;
@@ -466,10 +464,9 @@ namespace TestInjector {
$injector.annotate(() => {}, true);
}
// Promise signature tests
namespace TestPromise {
var result: any;
let result: any;
var any: any;
interface TResult {
@@ -494,63 +491,61 @@ namespace TestPromise {
var promise: angular.IPromise<TResult>;
// promise.then
result = <angular.IPromise<any>>promise.then((result) => any);
result = <angular.IPromise<any>>promise.then((result) => any, (any) => any);
result = <angular.IPromise<any>>promise.then((result) => any, (any) => any, (any) => any);
result = promise.then((result) => any) as angular.IPromise<any>;
result = promise.then((result) => any, (any) => any) as angular.IPromise<any>;
result = promise.then((result) => any, (any) => any, (any) => any) as angular.IPromise<any>;
result = <angular.IPromise<TResult>>promise.then((result) => result);
result = <angular.IPromise<TResult>>promise.then((result) => result, (any) => any);
result = <angular.IPromise<TResult>>promise.then((result) => result, (any) => any, (any) => any);
result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise);
result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise, (any) => any);
result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise, (any) => any, (any) => any);
result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise);
result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise, (any) => any);
result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise, (any) => any, (any) => any);
result = promise.then((result) => result) as angular.IPromise<TResult>;
result = promise.then((result) => result, (any) => any) as angular.IPromise<TResult>;
result = promise.then((result) => result, (any) => any, (any) => any) as angular.IPromise<TResult>;
result = promise.then((result) => tresultPromise) as angular.IPromise<TResult>;
result = promise.then((result) => tresultPromise, (any) => any) as angular.IPromise<TResult>;
result = promise.then((result) => tresultPromise, (any) => any, (any) => any) as angular.IPromise<TResult>;
result = promise.then((result) => tresultHttpPromise) as angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>;
result = promise.then((result) => tresultHttpPromise, (any) => any) as angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>;
result = promise.then((result) => tresultHttpPromise, (any) => any, (any) => any) as angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>;
result = <angular.IPromise<TOther>>promise.then((result) => tother);
result = <angular.IPromise<TOther>>promise.then((result) => tother, (any) => any);
result = <angular.IPromise<TOther>>promise.then((result) => tother, (any) => any, (any) => any);
result = <angular.IPromise<TOther>>promise.then((result) => totherPromise);
result = <angular.IPromise<TOther>>promise.then((result) => totherPromise, (any) => any);
result = <angular.IPromise<TOther>>promise.then((result) => totherPromise, (any) => any, (any) => any);
result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise);
result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise, (any) => any);
result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise, (any) => any, (any) => any);
result = promise.then((result) => tother) as angular.IPromise<TOther>;
result = promise.then((result) => tother, (any) => any) as angular.IPromise<TOther>;
result = promise.then((result) => tother, (any) => any, (any) => any) as angular.IPromise<TOther>;
result = promise.then((result) => totherPromise) as angular.IPromise<TOther>;
result = promise.then((result) => totherPromise, (any) => any) as angular.IPromise<TOther>;
result = promise.then((result) => totherPromise, (any) => any, (any) => any) as angular.IPromise<TOther>;
result = promise.then((result) => totherHttpPromise) as angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>;
result = promise.then((result) => totherHttpPromise, (any) => any) as angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>;
result = promise.then((result) => totherHttpPromise, (any) => any, (any) => any) as angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>;
// promise.catch
result = <angular.IPromise<any>>promise.catch((err) => any);
result = <angular.IPromise<TResult>>promise.catch((err) => tresult);
result = <angular.IPromise<TResult>>promise.catch((err) => tresultPromise);
result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.catch((err) => tresultHttpPromise);
result = <angular.IPromise<TOther>>promise.catch((err) => tother);
result = <angular.IPromise<TOther>>promise.catch((err) => totherPromise);
result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.catch((err) => totherHttpPromise);
result = promise.catch((err) => any) as angular.IPromise<any>;
result = promise.catch((err) => tresult) as angular.IPromise<TResult>;
result = promise.catch((err) => tresultPromise) as angular.IPromise<TResult>;
result = promise.catch((err) => tresultHttpPromise) as angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>;
result = promise.catch((err) => tother) as angular.IPromise<TOther>;
result = promise.catch((err) => totherPromise) as angular.IPromise<TOther>;
result = promise.catch((err) => totherHttpPromise) as angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>;
// promise.finally
result = <angular.IPromise<TResult>>promise.finally(() => any);
result = <angular.IPromise<TResult>>promise.finally(() => tresult);
result = <angular.IPromise<TResult>>promise.finally(() => tother);
result = promise.finally(() => any) as angular.IPromise<TResult>;
result = promise.finally(() => tresult) as angular.IPromise<TResult>;
result = promise.finally(() => tother) as angular.IPromise<TResult>;
}
function test_angular_forEach() {
var values: { [key: string]: string } = { name: 'misko', gender: 'male' };
var log: string[] = [];
angular.forEach(values, function (value, key) {
const values: { [key: string]: string } = { name: 'misko', gender: 'male' };
const log: string[] = [];
angular.forEach(values, function(value, key) {
this.push(key + ': ' + value);
}, log);
//expect(log).toEqual(['name: misko', 'gender: male']);
}
// angular.element() tests
var element = angular.element("div.myApp");
var scope: ng.IScope = element.scope();
var isolateScope: ng.IScope = element.isolateScope();
let element = angular.element('div.myApp');
let scope: ng.IScope = element.scope();
let isolateScope: ng.IScope = element.isolateScope();
isolateScope = element.find('div.foo').isolateScope();
isolateScope = element.children().isolateScope();
// $timeout signature tests
namespace TestTimeout {
interface TResult {
@@ -590,25 +585,24 @@ namespace TestTimeout {
}
}
function test_IAttributes(attributes: ng.IAttributes){
function test_IAttributes(attributes: ng.IAttributes) {
return attributes;
}
test_IAttributes({
$normalize: function (classVal){ return "foo" },
$addClass: function (classVal){},
$removeClass: function(classVal){},
$updateClass: function(newClass, oldClass){},
$set: function(key, value){},
$observe: function(name: any, fn: any){
$normalize(classVal) { return 'foo'; },
$addClass(classVal) {},
$removeClass(classVal) {},
$updateClass(newClass, oldClass) {},
$set(key, value) {},
$observe(name: any, fn: any) {
return fn;
},
$attr: {}
});
class SampleDirective implements ng.IDirective {
public restrict = 'A';
restrict = 'A';
name = 'doh';
compile(templateElement: ng.IAugmentedJQuery) {
@@ -617,7 +611,7 @@ class SampleDirective implements ng.IDirective {
};
}
static instance():ng.IDirective {
static instance(): ng.IDirective {
return new SampleDirective();
}
@@ -627,7 +621,7 @@ class SampleDirective implements ng.IDirective {
}
class SampleDirective2 implements ng.IDirective {
public restrict = 'EAC';
restrict = 'EAC';
compile(templateElement: ng.IAugmentedJQuery) {
return {
@@ -635,7 +629,7 @@ class SampleDirective2 implements ng.IDirective {
};
}
static instance():ng.IDirective {
static instance(): ng.IDirective {
return new SampleDirective2();
}
@@ -654,7 +648,7 @@ angular.module('AnotherSampleDirective', []).directive('myDirective', ['$interpo
$interpolate('', true)(scope);
$interpolate('', true, 'html')(scope);
$interpolate('', true, 'html', true)(scope);
var defer = $q.defer();
const defer = $q.defer();
defer.reject();
defer.resolve();
defer.promise.then(function(d) {
@@ -670,7 +664,7 @@ angular.module('AnotherSampleDirective', []).directive('myDirective', ['$interpo
.finally((): any => {
return null;
});
var promise = new $q((resolve) => {
let promise = new $q((resolve) => {
resolve();
});
@@ -785,25 +779,25 @@ angular.module('docsTimeDirective', [])
.directive('myCurrentTime', ['$interval', 'dateFilter', function($interval: any, dateFilter: any) {
return {
link: function(scope: ng.IScope, element: ng.IAugmentedJQuery, attrs:ng.IAttributes) {
var format: any,
link(scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) {
let format: any,
timeoutId: any;
function updateTime() {
element.text(dateFilter(new Date(), format));
}
scope.$watch(attrs['myCurrentTime'], function (value: any) {
scope.$watch(attrs['myCurrentTime'], function(value: any) {
format = value;
updateTime();
});
element.on('$destroy', function () {
element.on('$destroy', function() {
$interval.cancel(timeoutId);
});
// start the UI update process; save the timeoutId for canceling
timeoutId = $interval(function () {
timeoutId = $interval(function() {
updateTime(); // update DOM
}, 1000);
}
@@ -832,19 +826,18 @@ angular.module('docsTransclusionExample', [])
transclude: true,
scope: {},
templateUrl: 'my-dialog.html',
link: function (scope: ng.IScope, element: ng.IAugmentedJQuery) {
link(scope: ng.IScope, element: ng.IAugmentedJQuery) {
scope['name'] = 'Jeff';
}
};
});
angular.module('docsIsoFnBindExample', [])
.controller('Controller', ['$scope', '$timeout', function($scope: any, $timeout: any) {
$scope.name = 'Tobias';
$scope.hideDialog = function () {
$scope.hideDialog = function() {
$scope.dialogIsHidden = true;
$timeout(function () {
$timeout(function() {
$scope.dialogIsHidden = false;
}, 2000);
};
@@ -854,7 +847,7 @@ angular.module('docsIsoFnBindExample', [])
restrict: 'E',
transclude: true,
scope: {
'close': '&onClose'
close: '&onClose'
},
templateUrl: 'my-dialog-close.html'
};
@@ -863,7 +856,7 @@ angular.module('docsIsoFnBindExample', [])
angular.module('dragModule', [])
.directive('myDraggable', ['$document', function($document: any) {
return function(scope: any, element: any, attr: any) {
var startX = 0, startY = 0, x = 0, y = 0;
let startX = 0, startY = 0, x = 0, y = 0;
element.css({
position: 'relative',
@@ -903,8 +896,8 @@ angular.module('docsTabsExample', [])
restrict: 'E',
transclude: true,
scope: {},
controller: function($scope: ng.IScope) {
var panes: any = $scope['panes'] = [];
controller($scope: ng.IScope) {
const panes: any = $scope['panes'] = [];
$scope['select'] = function(pane: any) {
angular.forEach(panes, function(pane: any) {
@@ -931,7 +924,7 @@ angular.module('docsTabsExample', [])
scope: {
title: '@'
},
link: function(scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes, tabsCtrl: any) {
link(scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes, tabsCtrl: any) {
tabsCtrl.addPane(scope);
},
templateUrl: 'my-pane.html'
@@ -945,7 +938,7 @@ angular.module('multiSlotTranscludeExample', [])
button: 'button',
list: 'ul',
},
link: function(scope, element, attrs, ctrl, transclude) {
link(scope, element, attrs, ctrl, transclude) {
// without scope
transclude().appendTo(element);
transclude(clone => clone.appendTo(element));
@@ -960,52 +953,52 @@ angular.module('multiSlotTranscludeExample', [])
angular.module('componentExample', [])
.component('counter', {
require: {'ctrl': '^ctrl'},
require: {ctrl: '^ctrl'},
bindings: {
count: '='
},
controller: 'CounterCtrl',
controllerAs: 'counterCtrl',
template: function () {
template() {
return '';
},
transclude: {
'el': 'target'
el: 'target'
}
})
.component('anotherCounter', {
controller: function(){},
controller() {},
require: {
'parent': '^parentCtrl'
parent: '^parentCtrl'
},
template: '',
transclude: true
});
interface copyExampleUser {
interface ICopyExampleUser {
name?: string;
email?: string;
gender?: string;
}
interface copyExampleScope {
interface ICopyExampleScope {
user: copyExampleUser;
master: copyExampleUser;
update: (copyExampleUser: copyExampleUser) => any;
user: ICopyExampleUser;
master: ICopyExampleUser;
update: (copyExampleUser: ICopyExampleUser) => any;
reset: () => any;
}
angular.module('copyExample', [])
.controller('ExampleController', ['$scope', function ($scope: copyExampleScope) {
.controller('ExampleController', ['$scope', function($scope: ICopyExampleScope) {
$scope.master = { };
$scope.update = function (user) {
$scope.update = function(user) {
// Example with 1 argument
$scope.master = angular.copy(user);
};
$scope.reset = function () {
$scope.reset = function() {
// Example with 2 arguments
angular.copy($scope.master, $scope.user);
};
@@ -1022,9 +1015,14 @@ namespace locationTests {
*/
// given url http://example.com/#/some/path?foo=bar&baz=xoxo
var searchObject = $location.search();
const searchObject = $location.search();
// => {foo: 'bar', baz: 'xoxo'}
function assert(condition: boolean) {
if (!condition) {
throw new Error();
}
}
// set foo to 'yipee'
$location.search('foo', 'yipee');
@@ -1041,29 +1039,29 @@ namespace locationTests {
// in browser with HTML5 history support:
// open http://example.com/#!/a -> rewrite to http://example.com/a
// (replacing the http://example.com/#!/a history record)
$location.path() == '/a'
assert($location.path() === '/a');
$location.path('/foo');
$location.absUrl() == 'http://example.com/foo'
assert($location.absUrl() === 'http://example.com/foo');
$location.search() == {}
assert($location.search() === {});
$location.search({ a: 'b', c: true });
$location.absUrl() == 'http://example.com/foo?a=b&c'
assert($location.absUrl() === 'http://example.com/foo?a=b&c');
$location.path('/new').search('x=y');
$location.url() == 'new?x=y'
$location.absUrl() == 'http://example.com/new?x=y'
assert($location.url() === 'new?x=y');
assert($location.absUrl() === 'http://example.com/new?x=y');
// in browser without html5 history support:
// open http://example.com/new?x=y -> redirect to http://example.com/#!/new?x=y
// (again replacing the http://example.com/new?x=y history item)
$location.path() == '/new'
$location.search() == { x: 'y' }
assert($location.path() === '/new');
assert($location.search() === { x: 'y' });
$location.path('/foo/bar');
$location.path() == '/foo/bar'
$location.url() == '/foo/bar?x=y'
$location.absUrl() == 'http://example.com/#!/foo/bar?x=y'
assert($location.path() === '/foo/bar');
assert($location.url() === '/foo/bar?x=y');
assert($location.absUrl() === 'http://example.com/#!/foo/bar?x=y');
}
// NgModelController
@@ -1074,7 +1072,7 @@ function NgModelControllerTyping() {
// See https://docs.angularjs.org/api/ng/type/ngModel.NgModelController#$validators
ngModel.$validators['validCharacters'] = function(modelValue, viewValue) {
var value = modelValue || viewValue;
const value = modelValue || viewValue;
return /[0-9]+/.test(value) &&
/[a-z]+/.test(value) &&
/[A-Z]+/.test(value) &&
@@ -1082,7 +1080,7 @@ function NgModelControllerTyping() {
};
ngModel.$asyncValidators['uniqueUsername'] = function(modelValue, viewValue) {
var value = modelValue || viewValue;
const value = modelValue || viewValue;
return $http.get('/api/users/' + value).
then(function resolved() {
return $q.reject('exists');
@@ -1092,67 +1090,67 @@ function NgModelControllerTyping() {
};
}
var $filter: angular.IFilterService;
let $filter: angular.IFilterService;
function testFilter() {
var items: string[];
$filter("filter")(items, "test");
$filter("filter")(items, {name: "test"});
$filter("filter")(items, (val, index, array) => {
$filter('filter')(items, 'test');
$filter('filter')(items, {name: 'test'});
$filter('filter')(items, (val, index, array) => {
return true;
});
$filter("filter")(items, (val, index, array) => {
$filter('filter')(items, (val, index, array) => {
return true;
}, (actual, expected) => {
return actual == expected;
return actual === expected;
});
}
function testCurrency() {
$filter("currency")(126);
$filter("currency")(126, "$", 2);
$filter('currency')(126);
$filter('currency')(126, '$', 2);
}
function testNumber() {
$filter("number")(167);
$filter("number")(167, 2);
$filter('number')(167);
$filter('number')(167, 2);
}
function testDate() {
$filter("date")(new Date());
$filter("date")(new Date(), 'yyyyMMdd');
$filter("date")(new Date(), 'yyyyMMdd', '+0430');
$filter('date')(new Date());
$filter('date')(new Date(), 'yyyyMMdd');
$filter('date')(new Date(), 'yyyyMMdd', '+0430');
}
function testJson() {
var json: string = $filter("json")({test:true}, 2);
const json: string = $filter('json')({test: true}, 2);
}
function testLowercase() {
var lower: string = $filter("lowercase")('test');
const lower: string = $filter('lowercase')('test');
}
function testUppercase() {
var lower: string = $filter("uppercase")('test');
const lower: string = $filter('uppercase')('test');
}
function testLimitTo() {
var limitTo = $filter("limitTo");
var filtered: number[] = $filter("limitTo")([1,2,3], 5);
filtered = $filter("limitTo")([1,2,3], 5, 2);
const limitTo = $filter('limitTo');
let filtered: number[] = $filter('limitTo')([1, 2, 3], 5);
filtered = $filter('limitTo')([1, 2, 3], 5, 2);
var filteredString: string = $filter("limitTo")("124", 4);
filteredString = $filter("limitTo")(124, 4);
let filteredString: string = $filter('limitTo')('124', 4);
filteredString = $filter('limitTo')(124, 4);
}
function testOrderBy() {
var filtered: number[] = $filter("orderBy")([1,2,3], "test");
filtered = $filter("orderBy")([1,2,3], "test", true);
filtered = $filter("orderBy")([1,2,3], ['prop1', 'prop2']);
filtered = $filter("orderBy")([1,2,3], (val: number) => 1);
var filtered2: string[] = $filter("orderBy")(["1","2","3"], (val: string) => 1);
filtered2 = $filter("orderBy")(["1","2","3"], [
let filtered: number[] = $filter('orderBy')([1, 2, 3], 'test');
filtered = $filter('orderBy')([1, 2, 3], 'test', true);
filtered = $filter('orderBy')([1, 2, 3], ['prop1', 'prop2']);
filtered = $filter('orderBy')([1, 2, 3], (val: number) => 1);
let filtered2: string[] = $filter('orderBy')(['1', '2', '3'], (val: string) => 1);
filtered2 = $filter('orderBy')(['1', '2', '3'], [
(val: string) => 1,
(val: string) => 2
]);
@@ -1160,28 +1158,26 @@ function testOrderBy() {
function testDynamicFilter() {
// Test with separate variables
var dateFilter = $filter("date");
var myDate = new Date();
dateFilter(myDate , "EEE, MMM d");
const dateFilter = $filter('date');
const myDate = new Date();
dateFilter(myDate , 'EEE, MMM d');
// Test with dynamic name
var filterName = 'date';
var dynDateFilter = $filter<ng.IFilterDate>(filterName);
const filterName = 'date';
const dynDateFilter = $filter<ng.IFilterDate>(filterName);
dynDateFilter(new Date());
}
interface MyCustomFilter {
(value: string): string;
}
type MyCustomFilter = (value: string) => string;
function testCustomFilter() {
var filterCustom = $filter<MyCustomFilter>('custom');
var filtered: string = filterCustom("test");
const filterCustom = $filter<MyCustomFilter>('custom');
const filtered: string = filterCustom('test');
}
function parseTyping() {
var $parse: angular.IParseService;
var compiledExp = $parse('a.b.c');
const compiledExp = $parse('a.b.c');
if (compiledExp.constant) {
return compiledExp({});
} else if (compiledExp.literal) {
@@ -1191,8 +1187,8 @@ function parseTyping() {
function parseWithParams() {
var $parse: angular.IParseService;
var compiledExp = $parse('a.b.c', () => null);
var compiledExp = $parse('a.b.c', null, false);
const compiledExp1 = $parse('a.b.c', () => null);
const compiledExp2 = $parse('a.b.c', null, false);
}
function doBootstrap(element: Element | JQuery, mode: string): ng.auto.IInjectorService {
@@ -1211,8 +1207,8 @@ function doBootstrap(element: Element | JQuery, mode: string): ng.auto.IInjector
}
function testIHttpParamSerializerJQLikeProvider() {
let serializer: angular.IHttpParamSerializer;
var serializer: angular.IHttpParamSerializer;
serializer({
a: "b"
a: 'b'
});
}

91
angular/index.d.ts vendored
View File

@@ -27,7 +27,7 @@ import ng = angular;
///////////////////////////////////////////////////////////////////////////////
declare namespace angular {
type Injectable<T extends Function> = T | (string | T)[];
type Injectable<T extends Function> = T | Array<string | T>;
// not directly implemented, but ensures that constructed class implements $get
interface IServiceProviderClass {
@@ -64,7 +64,7 @@ declare namespace angular {
* @param config an object for defining configuration options for the application. The following keys are supported:
* - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
*/
bootstrap(element: string|Element|JQuery|Document, modules?: (string|Function|any[])[], config?: IAngularBootstrapConfig): auto.IInjectorService;
bootstrap(element: string|Element|JQuery|Document, modules?: Array<string|Function|any[]>, config?: IAngularBootstrapConfig): auto.IInjectorService;
/**
* Creates a deep copy of source, which should be an object or an array.
@@ -122,7 +122,7 @@ declare namespace angular {
fromJson(json: string): any;
identity<T>(arg?: T): T;
injector(modules?: any[], strictDi?: boolean): auto.IInjectorService;
isArray(value: any): value is Array<any>;
isArray(value: any): value is any[];
isDate(value: any): value is Date;
isDefined(value: any): boolean;
isElement(value: any): boolean;
@@ -514,7 +514,7 @@ declare namespace angular {
$watchCollection<T>(watchExpression: (scope: IScope) => T, listener: (newValue: T, oldValue: T, scope: IScope) => any): () => void;
$watchGroup(watchExpressions: any[], listener: (newValue: any, oldValue: any, scope: IScope) => any): () => void;
$watchGroup(watchExpressions: { (scope: IScope): any }[], listener: (newValue: any, oldValue: any, scope: IScope) => any): () => void;
$watchGroup(watchExpressions: Array<{ (scope: IScope): any }>, listener: (newValue: any, oldValue: any, scope: IScope) => any): () => void;
$parent: IScope;
$root: IRootScopeService;
@@ -662,9 +662,9 @@ declare namespace angular {
}
interface IFilterOrderByItem {
value: any,
type: string,
index: any
value: any;
type: string;
index: any;
}
interface IFilterOrderByComparatorFunc {
@@ -756,7 +756,7 @@ declare namespace angular {
* @param comparator Function used to determine the relative order of value pairs.
* @return An array containing the items from the specified collection, ordered by a comparator function based on the values computed using the expression predicate.
*/
<T>(array: T[], expression: string|((value: T) => any)|(((value: T) => any)|string)[], reverse?: boolean, comparator?: IFilterOrderByComparatorFunc): T[];
<T>(array: T[], expression: string|((value: T) => any)|Array<((value: T) => any)|string>, reverse?: boolean, comparator?: IFilterOrderByComparatorFunc): T[];
}
/**
@@ -1023,7 +1023,7 @@ declare namespace angular {
all<T1, T2, T3, T4>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>]): IPromise<[T1, T2, T3, T4]>;
all<T1, T2, T3>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>]): IPromise<[T1, T2, T3]>;
all<T1, T2>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>]): IPromise<[T1, T2]>;
all<TAll>(promises: IPromise<TAll>[]): IPromise<TAll[]>;
all<TAll>(promises: Array<IPromise<TAll>>): IPromise<TAll[]>;
/**
* Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.
*
@@ -1284,11 +1284,11 @@ declare namespace angular {
}
interface ITemplateLinkingFunctionOptions {
parentBoundTranscludeFn?: ITranscludeFunction,
parentBoundTranscludeFn?: ITranscludeFunction;
transcludeControllers?: {
[controller: string]: { instance: IController }
},
futureParentElement?: JQuery
};
futureParentElement?: JQuery;
}
/**
@@ -1510,7 +1510,9 @@ declare namespace angular {
(data: any, headersGetter: IHttpHeadersGetter, status: number): any;
}
type HttpHeaderType = {[requestType: string]:string|((config:IRequestConfig) => string)};
interface HttpHeaderType {
[requestType: string]: string|((config: IRequestConfig) => string);
}
interface IHttpRequestConfigHeaders {
[requestType: string]: any;
@@ -1593,7 +1595,7 @@ declare namespace angular {
* Register service factories (names or implementations) for interceptors which are called before and after
* each request.
*/
interceptors: (string | Injectable<IHttpInterceptorFactory>)[];
interceptors: Array<string | Injectable<IHttpInterceptorFactory>>;
useApplyAsync(): boolean;
useApplyAsync(value: boolean): IHttpProvider;
@@ -1603,7 +1605,7 @@ declare namespace angular {
* @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining.
* otherwise, returns the current configured value.
*/
useLegacyPromiseExtensions(value:boolean) : boolean | IHttpProvider;
useLegacyPromiseExtensions(value: boolean): boolean | IHttpProvider;
}
///////////////////////////////////////////////////////////////////////////
@@ -1687,16 +1689,15 @@ declare namespace angular {
valueOf(value: any): any;
}
///////////////////////////////////////////////////////////////////////////
// SCEDelegateProvider
// see http://docs.angularjs.org/api/ng.$sceDelegateProvider
///////////////////////////////////////////////////////////////////////////
interface ISCEDelegateProvider extends IServiceProvider {
resourceUrlBlacklist(blacklist: any[]): void;
resourceUrlWhitelist(whitelist: any[]): void;
resourceUrlBlacklist(): any[];
resourceUrlBlacklist(blacklist: any[]): void;
resourceUrlWhitelist(): any[];
resourceUrlWhitelist(whitelist: any[]): void;
}
/**
@@ -1936,33 +1937,33 @@ declare namespace angular {
annotate(fn: Function, strictDi?: boolean): string[];
annotate(inlineAnnotatedFunction: any[]): string[];
get<T>(name: string, caller?: string): T;
get(name: '$anchorScroll'): IAnchorScrollService
get(name: '$cacheFactory'): ICacheFactoryService
get(name: '$compile'): ICompileService
get(name: '$controller'): IControllerService
get(name: '$document'): IDocumentService
get(name: '$exceptionHandler'): IExceptionHandlerService
get(name: '$filter'): IFilterService
get(name: '$http'): IHttpService
get(name: '$httpBackend'): IHttpBackendService
get(name: '$httpParamSerializer'): IHttpParamSerializer
get(name: '$httpParamSerializerJQLike'): IHttpParamSerializer
get(name: '$interpolate'): IInterpolateService
get(name: '$interval'): IIntervalService
get(name: '$locale'): ILocaleService
get(name: '$location'): ILocationService
get(name: '$log'): ILogService
get(name: '$parse'): IParseService
get(name: '$q'): IQService
get(name: '$rootElement'): IRootElementService
get(name: '$rootScope'): IRootScopeService
get(name: '$sce'): ISCEService
get(name: '$sceDelegate'): ISCEDelegateService
get(name: '$templateCache'): ITemplateCacheService
get(name: '$templateRequest'): ITemplateRequestService
get(name: '$timeout'): ITimeoutService
get(name: '$window'): IWindowService
get<T>(name: '$xhrFactory'): IXhrFactory<T>
get(name: '$anchorScroll'): IAnchorScrollService;
get(name: '$cacheFactory'): ICacheFactoryService;
get(name: '$compile'): ICompileService;
get(name: '$controller'): IControllerService;
get(name: '$document'): IDocumentService;
get(name: '$exceptionHandler'): IExceptionHandlerService;
get(name: '$filter'): IFilterService;
get(name: '$http'): IHttpService;
get(name: '$httpBackend'): IHttpBackendService;
get(name: '$httpParamSerializer'): IHttpParamSerializer;
get(name: '$httpParamSerializerJQLike'): IHttpParamSerializer;
get(name: '$interpolate'): IInterpolateService;
get(name: '$interval'): IIntervalService;
get(name: '$locale'): ILocaleService;
get(name: '$location'): ILocationService;
get(name: '$log'): ILogService;
get(name: '$parse'): IParseService;
get(name: '$q'): IQService;
get(name: '$rootElement'): IRootElementService;
get(name: '$rootScope'): IRootScopeService;
get(name: '$sce'): ISCEService;
get(name: '$sceDelegate'): ISCEDelegateService;
get(name: '$templateCache'): ITemplateCacheService;
get(name: '$templateRequest'): ITemplateRequestService;
get(name: '$timeout'): ITimeoutService;
get(name: '$window'): IWindowService;
get<T>(name: '$xhrFactory'): IXhrFactory<T>;
has(name: string): boolean;
instantiate<T>(typeConstructor: Function, locals?: any): T;
invoke(inlineAnnotatedFunction: any[]): any;

20
angular/tslint.json Normal file
View File

@@ -0,0 +1,20 @@
{
"extends": "../tslint.json",
"rules": {
"class-name": true,
"curly": true,
"no-consecutive-blank-lines": true,
"no-shadowed-variable": true,
"quotemark": [true, "single"],
"align": true,
"callable-types": false,
"forbidden-types": false,
"indent": [true, "spaces"],
"interface-name": false,
"linebreak-style": [true, "LF"],
"no-empty-interface": false,
"unified-signatures": false,
"variable-name": [true, "check-format"],
"void-return": false
}
}

1
bookshelf/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://bookshelfjs.org/
// Definitions by: Andrew Schurman <http://github.com/arcticwaters>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import Knex = require('knex');
import knex = require('knex');

20
chai-json-schema/chai-json-schema-tests.ts
View File

@@ -9,19 +9,19 @@ import ChaiJsonSchema = require('chai-json-schema');
chai.use(ChaiJsonSchema);
chai.should();
let goodApple = {
const goodApple = {
skin: 'thin',
colors: ['red', 'green', 'yellow'],
taste: 10
};
let badApple = {
const badApple = {
colors: ['brown'],
taste: 0,
worms: 2
};
let fruitSchema = {
const fruitSchema = {
title: 'fresh fruit schema v1',
type: 'object',
required: ['skin', 'colors', 'taste'],
@@ -54,3 +54,17 @@ badApple.should.not.be.jsonSchema(fruitSchema);
//tdd style
assert.jsonSchema(goodApple, fruitSchema);
assert.notJsonSchema(badApple, fruitSchema);
// tv4
const schema = {
items: {
type: 'boolean'
}
};
const data1 = [true, false];
const data2 = [true, 123];
expect(chai.tv4.validate(data1, schema)).to.be.true;
expect(chai.tv4.validate(data2, schema)).to.be.false;

5
chai-json-schema/index.d.ts vendored
View File

@@ -5,6 +5,7 @@
// <reference types="node"/>
// <reference types="chai" />
import tv4 = require('tv4');
declare global {
namespace Chai {
@@ -16,6 +17,10 @@ declare global {
export interface LanguageChains {
jsonSchema(schema: any, msg?: string): void;
}
export interface ChaiStatic {
tv4: tv4.TV4;
}
}
}

16
comment-json/comment-json-tests.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as commentJson from 'comment-json';
const result = commentJson.parse(`
/**
block comment at the top
*/
// comment at the top
{
// comment for a
// comment line 2 for a
/* block comment */
"a": 1 // comment at right
}
// comment at the bottom
`);
const str = commentJson.stringify(result);

8
comment-json/index.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
// Type definitions for comment-json 1.1
// Project: https://github.com/kaelzhang/node-comment-json
// Definitions by: Jason Dent <https://github.com/Jason3S>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export type Reviver = (k: number | string, v: any) => any;
export function parse(json: string, reviver?: Reviver, removes_comments?: boolean): any;
export function stringify(value: any, replacer?: any, space?: string | number): string;

20
comment-json/tsconfig.json Normal file
View File

@@ -0,0 +1,20 @@
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"comment-json-tests.ts"
]
}

1
comment-json/tslint.json Normal file
View File

@@ -0,0 +1 @@
{ "extends": "../tslint.json" }

3
credit-card-type/index.d.ts vendored
View File

@@ -10,7 +10,8 @@ declare namespace creditCardType {
interface CreditCardTypeInfo {
niceType?: string
type?: CardBrand
pattern?: RegExp
prefixPattern?: RegExp
exactPattern?: RegExp
gaps?: Array<number>
lengths?: Array<number>
code?: {

3
crypto-js/aes/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { AES } from '../index';
export = AES;

3
crypto-js/core/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import * as Core from '../index';
export = Core;

4
crypto-js/enc-base64/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { enc } from '../index';
declare const Base64: typeof enc.Base64;
export = Base64;

4
crypto-js/enc-hex/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { enc } from '../index';
declare const Hex: typeof enc.Hex;
export = Hex;

4
crypto-js/enc-latin1/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { enc } from '../index';
declare const Latin1: typeof enc.Latin1;
export = Latin1;

4
crypto-js/enc-utf16/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { enc } from '../index';
declare const Utf16: typeof enc.Utf16;
export = Utf16;

4
crypto-js/enc-utf8/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { enc } from '../index';
declare const Utf8: typeof enc.Utf8;
export = Utf8;

3
crypto-js/evpkdf/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { EvpKDF } from '../index';
export = EvpKDF;

4
crypto-js/format-hex/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { format } from '../index';
declare const Hex: typeof format.Hex;
export = Hex;

4
crypto-js/format-openssl/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { format } from '../index';
declare const OpenSSL: typeof format.OpenSSL;
export = OpenSSL;

3
crypto-js/hmac-md5/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { HmacMD5 } from '../index';
export = HmacMD5;

3
crypto-js/hmac-ripemd160/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { HmacRIPEMD160 } from '../index';
export = HmacRIPEMD160;

3
crypto-js/hmac-sha1/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { HmacSHA1 } from '../index';
export = HmacSHA1;

3
crypto-js/hmac-sha224/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { HmacSHA224 } from '../index';
export = HmacSHA224;

3
crypto-js/hmac-sha256/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { HmacSHA256 } from '../index';
export = HmacSHA256;

3
crypto-js/hmac-sha3/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { HmacSHA3 } from '../index';
export = HmacSHA3;

3
crypto-js/hmac-sha384/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { HmacSHA384 } from '../index';
export = HmacSHA384;

3
crypto-js/hmac-sha512/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { HmacSHA512 } from '../index';
export = HmacSHA512;

1
crypto-js/index.d.ts vendored
View File

@@ -114,4 +114,3 @@ declare namespace CryptoJS {
};
}
}

2
crypto-js/lib-typedarrays/index.d.ts vendored Normal file
View File

@@ -0,0 +1,2 @@
declare const LibTypedarrays: any;
export = LibTypedarrays;

3
crypto-js/md5/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { MD5 } from '../index';
export = MD5;

4
crypto-js/mode-cfb/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { mode } from '../index';
declare const CFB: typeof mode.CFB;
export = CFB;

4
crypto-js/mode-ctr-gladman/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { mode } from '../index';
declare const CTRGladman: typeof mode.CTRGladman;
export = CTRGladman;

4
crypto-js/mode-ctr/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { mode } from '../index';
declare const CTR: typeof mode.CTR;
export = CTR;

4
crypto-js/mode-ecb/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { mode } from '../index';
declare const ECB: typeof mode.ECB;
export = ECB;

4
crypto-js/mode-ofb/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { mode } from '../index';
declare const OFB: typeof mode.OFB;
export = OFB;

4
crypto-js/pad-ansix923/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { pad } from '../index';
declare const AnsiX923: typeof pad.AnsiX923;
export = AnsiX923;

4
crypto-js/pad-iso10126/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { pad } from '../index';
declare const Iso10126: typeof pad.Iso10126;
export = Iso10126;

4
crypto-js/pad-iso97971/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { pad } from '../index';
declare const Iso97971: typeof pad.Iso97971;
export = Iso97971;

4
crypto-js/pad-nopadding/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { pad } from '../index';
declare const NoPadding: typeof pad.NoPadding;
export = NoPadding;

4
crypto-js/pad-pkcs7/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { pad } from '../index';
declare const Pkcs7: typeof pad.Pkcs7;
export = Pkcs7;

4
crypto-js/pad-zeropadding/index.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { pad } from '../index';
declare const ZeroPadding: typeof pad.ZeroPadding;
export = ZeroPadding;

3
crypto-js/pbkdf2/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { PBKDF2 } from '../index';
export = PBKDF2;

3
crypto-js/rabbit-legacy/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { RabbitLegacy } from '../index';
export = RabbitLegacy;

3
crypto-js/rabbit/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { Rabbit } from '../index';
export = Rabbit;

3
crypto-js/rc4/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { RC4 } from '../index';
export = RC4;

3
crypto-js/ripemd160/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { RIPEMD160 } from '../index';
export = RIPEMD160;

3
crypto-js/sha1/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { SHA1 } from '../index';
export = SHA1;

3
crypto-js/sha224/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { SHA224 } from '../index';
export = SHA224;

3
crypto-js/sha256/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { SHA256 } from '../index';
export = SHA256;

3
crypto-js/sha3/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { SHA3 } from '../index';
export = SHA3;

3
crypto-js/sha384/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { SHA384 } from '../index';
export = SHA384;

3
crypto-js/sha512/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { SHA512 } from '../index';
export = SHA512;

184
crypto-js/test/submodule-tests.ts Normal file
View File

@@ -0,0 +1,184 @@
import Core = require('../core');
import X64Core = require('../x64-core');
import LibTypedarrays = require('../lib-typedarrays');
// ---
import MD5 = require('../md5');
import SHA1 = require('../sha1');
import SHA256 = require('../sha256');
import SHA224 = require('../sha224');
import SHA512 = require('../sha512');
import SHA384 = require('../sha384');
import SHA3 = require('../sha3');
import RIPEMD160 = require('../ripemd160');
// ---
import HmacMD5 = require('../hmac-md5');
import HmacSHA1 = require('../hmac-sha1');
import HmacSHA256 = require('../hmac-sha256');
import HmacSHA224 = require('../hmac-sha224');
import HmacSHA512 = require('../hmac-sha512');
import HmacSHA384 = require('../hmac-sha384');
import HmacSHA3 = require('../hmac-sha3');
import HmacRIPEMD160 = require('../hmac-ripemd160');
// ---
import PBKDF2 = require('../pbkdf2');
// ---
import AES = require('../aes');
import TripleDES = require('../tripledes');
import RC4 = require('../rc4');
import Rabbit = require('../rabbit');
import RabbitLegacy = require('../rabbit-legacy');
import EvpKDF = require('../evpkdf');
// ---
import FormatOpenSSL = require('../format-openssl');
import FormatHex = require('../format-hex');
// ---
import EncLatin1 = require('../enc-latin1');
import EncUtf8 = require('../enc-utf8');
import EncHex = require('../enc-hex');
import EncUtf16 = require('../enc-utf16');
import EncBase64 = require('../enc-base64');
// ---
import ModeCFB = require('../mode-cfb');
import ModeCTR = require('../mode-ctr');
import ModeCTRGladman = require('../mode-ctr-gladman');
import ModeOFB = require('../mode-ofb');
import ModeECB = require('../mode-ecb');
// ---
import PadPkcs7 = require('../pad-pkcs7');
import PadAnsiX923 = require('../pad-ansix923');
import PadIso10126 = require('../pad-iso10126');
import PadIso97971 = require('../pad-iso97971');
import PadZeroPadding = require('../pad-zeropadding');
import PadNoPadding = require('../pad-nopadding');
// Hashers
var str: string;
str = MD5('some message');
str = MD5('some message', 'some key');
str = SHA1('some message');
str = SHA1('some message', 'some key', { any: true });
str = FormatOpenSSL('some message');
str = FormatOpenSSL('some message', 'some key');
// Ciphers
var encrypted: CryptoJS.WordArray;
var decrypted: CryptoJS.DecryptedMessage;
encrypted = <CryptoJS.WordArray>AES.encrypt("Message", "Secret Passphrase");
decrypted = AES.decrypt(encrypted, "Secret Passphrase");
encrypted = <CryptoJS.WordArray>Core.DES.encrypt("Message", "Secret Passphrase");
decrypted = Core.DES.decrypt(encrypted, "Secret Passphrase");
encrypted = TripleDES.encrypt("Message", "Secret Passphrase");
decrypted = TripleDES.decrypt(encrypted, "Secret Passphrase");
encrypted = Rabbit.encrypt("Message", "Secret Passphrase");
decrypted = Rabbit.decrypt(encrypted, "Secret Passphrase");
encrypted = RC4.encrypt("Message", "Secret Passphrase");
decrypted = RC4.decrypt(encrypted, "Secret Passphrase");
encrypted = Core.RC4Drop.encrypt("Message", "Secret Passphrase");
encrypted = Core.RC4Drop.encrypt("Message", "Secret Passphrase", { drop: 3072 / 4 });
decrypted = Core.RC4Drop.decrypt(encrypted, "Secret Passphrase", { drop: 3072 / 4 });
var key = EncHex.parse('000102030405060708090a0b0c0d0e0f');
var iv = EncHex.parse('101112131415161718191a1b1c1d1e1f');
encrypted = AES.encrypt("Message", key, { iv: iv });
encrypted = AES.encrypt("Message", "Secret Passphrase", {
mode: ModeCFB,
padding: PadAnsiX923
});
// The Cipher Output
encrypted = AES.encrypt("Message", "Secret Passphrase");
alert(encrypted.key);
// 74eb593087a982e2a6f5dded54ecd96d1fd0f3d44a58728cdcd40c55227522223
alert(encrypted.iv);
// 7781157e2629b094f0e3dd48c4d786115
alert(encrypted.salt);
// 7a25f9132ec6a8b34
alert(encrypted.ciphertext);
// 73e54154a15d1beeb509d9e12f1e462a0
alert(encrypted);
// U2FsdGVkX1+iX5Ey7GqLND5UFUoV0b7rUJ2eEvHkYqA=
var JsonFormatter = {
stringify: function(cipherParams: any) {
// create json object with ciphertext
var jsonObj: any = {
ct: cipherParams.ciphertext.toString(EncBase64)
};
// optionally add iv and salt
if (cipherParams.iv) {
jsonObj.iv = cipherParams.iv.toString();
}
if (cipherParams.salt) {
jsonObj.s = cipherParams.salt.toString();
}
// stringify json object
return JSON.stringify(jsonObj);
},
parse: function (jsonStr: any) {
// parse json string
var jsonObj = JSON.parse(jsonStr);
// extract ciphertext from json object, and create cipher params object
var cipherParams = (<any>Core).lib.CipherParams.create({
ciphertext: EncBase64.parse(jsonObj.ct)
});
// optionally extract iv and salt
if (jsonObj.iv) {
cipherParams.iv = EncHex.parse(jsonObj.iv);
}
if (jsonObj.s) {
cipherParams.salt = EncHex.parse(jsonObj.s);
} return cipherParams;
}
};
encrypted = AES.encrypt("Message", "Secret Passphrase", {
format: JsonFormatter
});
alert(encrypted);
// {"ct":"tZ4MsEnfbcDOwqau68aOrQ==","iv":"8a8c8fd8fe33743d3638737ea4a00698","s":"ba06373c8f57179c"}
decrypted = AES.decrypt(encrypted, "Secret Passphrase", {
format: JsonFormatter
});
alert(decrypted.toString(EncUtf8)); // Message
// Progressive Ciphering
var key = EncHex.parse('000102030405060708090a0b0c0d0e0f');
var iv = EncHex.parse('101112131415161718191a1b1c1d1e1f');
var aesEncryptor = Core.algo.AES.createEncryptor(key, { iv: iv });
var ciphertextPart1 = aesEncryptor.process("Message Part 1");
var ciphertextPart2 = aesEncryptor.process("Message Part 2");
var ciphertextPart3 = aesEncryptor.process("Message Part 3");
var ciphertextPart4 = aesEncryptor.finalize();
var aesDecryptor = Core.algo.AES.createDecryptor(key, { iv: iv });
var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
var plaintextPart2 = aesDecryptor.process(ciphertextPart2);
var plaintextPart3 = aesDecryptor.process(ciphertextPart3);
var plaintextPart4 = aesDecryptor.process(ciphertextPart4);
var plaintextPart5 = aesDecryptor.finalize();
// Encoders
var words = EncBase64.parse('SGVsbG8sIFdvcmxkIQ==');
var base64 = EncBase64.stringify(words);
var words = EncLatin1.parse('Hello, World!');
var latin1 = EncLatin1.stringify(words);
var words = EncHex.parse('48656c6c6f2c20576f726c6421');
var hex = EncHex.stringify(words);
var words = EncUtf8.parse('𤭢');
var utf8 = EncUtf8.stringify(words);
var words = EncUtf16.parse('Hello, World!');
var utf16 = EncUtf16.stringify(words);
var words = Core.enc.Utf16LE.parse('Hello, World!');
var utf16 = Core.enc.Utf16LE.stringify(words);

3
crypto-js/tripledes/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import { TripleDES } from '../index';
export = TripleDES;

49
crypto-js/tsconfig.json
View File

@@ -18,6 +18,51 @@
},
"files": [
"index.d.ts",
"crypto-js-tests.ts"
"crypto-js-tests.ts",
"test/submodule-tests.ts",
"core/index.d.ts",
"x64-core/index.d.ts",
"lib-typedarrays/index.d.ts",
"md5/index.d.ts",
"sha1/index.d.ts",
"sha256/index.d.ts",
"sha224/index.d.ts",
"sha512/index.d.ts",
"sha384/index.d.ts",
"sha3/index.d.ts",
"ripemd160/index.d.ts",
"hmac-md5/index.d.ts",
"hmac-sha1/index.d.ts",
"hmac-sha256/index.d.ts",
"hmac-sha224/index.d.ts",
"hmac-sha512/index.d.ts",
"hmac-sha384/index.d.ts",
"hmac-sha3/index.d.ts",
"hmac-ripemd160/index.d.ts",
"pbkdf2/index.d.ts",
"aes/index.d.ts",
"tripledes/index.d.ts",
"rc4/index.d.ts",
"rabbit/index.d.ts",
"rabbit-legacy/index.d.ts",
"evpkdf/index.d.ts",
"format-openssl/index.d.ts",
"format-hex/index.d.ts",
"enc-latin1/index.d.ts",
"enc-utf8/index.d.ts",
"enc-hex/index.d.ts",
"enc-utf16/index.d.ts",
"enc-base64/index.d.ts",
"mode-cfb/index.d.ts",
"mode-ctr/index.d.ts",
"mode-ctr-gladman/index.d.ts",
"mode-ofb/index.d.ts",
"mode-ecb/index.d.ts",
"pad-pkcs7/index.d.ts",
"pad-ansix923/index.d.ts",
"pad-iso10126/index.d.ts",
"pad-iso97971/index.d.ts",
"pad-zeropadding/index.d.ts",
"pad-nopadding/index.d.ts"
]
}
}

3
crypto-js/x64-core/index.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
import * as X64Core from '../index';
export = X64Core;

7
dragster/dragster-tests.ts Normal file
View File

@@ -0,0 +1,7 @@
import Dragster = require("dragster");
var dropzone = document.getElementById("my-dropzone") as HTMLElement;
var dragster = new Dragster(dropzone);
dragster.removeListeners();
dragster.reset();

12
dragster/index.d.ts vendored Normal file
View File

@@ -0,0 +1,12 @@
// Type definitions for dragster 0.1
// Project: https://github.com/bensmithett/dragster
// Definitions by: Zsolt Kovacs <https://github.com/zskovacs>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare class Dragster {
constructor(elem: HTMLElement);
removeListeners(): void;
reset(): void;
}
export = Dragster;

23
dragster/tsconfig.json Normal file
View File

@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"dragster-tests.ts"
]
}

1
dragster/tslint.json Normal file
View File

@@ -0,0 +1 @@
{ "extends": "../tslint.json" }

13
express-mysql-session/express-mysql-session-tests.ts Normal file
View File

@@ -0,0 +1,13 @@
import MySQLStore = require('express-mysql-session');
const options = {
host: 'localhost',
port: 3306,
user: 'root',
password: '',
database: 'session_test'
};
const sessionStore = new MySQLStore(options);
sessionStore.close();

136
express-mysql-session/index.d.ts vendored Normal file
View File

@@ -0,0 +1,136 @@
// Type definitions for express-mysql-session 1.2
// Project: https://github.com/chill117/express-mysql-session#readme
// Definitions by: Akim95 <https://github.com/Akim95>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export = MySQLStore;
declare namespace MySQLStore {
interface Options {
host?: string;
port?: number;
user?: string;
password?: string;
database?: string;
checkExpirationInterval?: number;
expiration?: number;
createDatabaseTable?: boolean;
connectionLimit?: number;
schema?: Schema;
}
interface Schema {
tableName: string;
columnNames: ColumnNames;
}
interface ColumnNames {
session_id: string;
expires: string;
data: string;
}
}
declare class MySQLStore {
/**
* @param {MySQLStore.Options} options
* @param {any} connection?
* @param {(error:any)=>void} callback?
*/
constructor(options: MySQLStore.Options, connection?: any, callback?: (error: any) => void);
/**
* @returns void
*/
setDefaultOptions(): void;
/**
* @param {(error:any)=>void} callback?
* @returns void
*/
createDatabaseTable(callback?: (error: any) => void): void;
/**
* @param {string} sessionId
* @param {(error:any,session:any)=>void} callback?
* @returns void
*/
get(sessionId: string, callback?: (error: any, session: any) => void): void;
/**
* @param {string} sessionId
* @param {any} data
* @param {(error:any)=>void} callback?
* @returns void
*/
set(sessionId: string, data: any, callback?: (error: any) => void): void;
/**
* @param {string} sessionId
* @param {any} data
* @param {(error:any)=>void} callback?
* @returns void
*/
touch(sessionId: string, data: any, callback?: (error: any) => void): void;
/**
* @param {string} sessionId
* @param {(error:any)=>void} callback?
* @returns void
*/
destroy(sessionId: string, callback?: (error: any) => void): void;
/**
* @param {(error:any,count:any)=>void} callback?
* @returns void
*/
length(callback?: (error: any, count: any) => void): void;
/**
* @param {(error:any)=>void} callback?
* @returns void
*/
clear(callback?: (error: any) => void): void;
/**
* @param {(error:any)=>void} callback?
* @returns void
*/
clearExpiredSessions(callback?: (error: any) => void): void;
/**
* @param {number} interval
* @returns void
*/
setExpirationInterval(interval: number): void;
/**
* @returns void
*/
clearExpirationInterval(): void;
/**
* @param {()=>void} callback?
* @returns void
*/
close(callback?: () => void): void;
/**
* @param {any} object
* @param {any} defaultValues
* @param {any} options?
* @returns void
*/
default(object: any, defaultValues: any, options?: any): void;
/**
* @param {any} object
* @returns void
*/
clone(object: any): void;
/**
* @param {any} value
* @returns void
*/
isObject(value: any): void;
}

20
express-mysql-session/tsconfig.json Normal file
View File

@@ -0,0 +1,20 @@
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"express-mysql-session-tests.ts"
]
}

1
express-mysql-session/tslint.json Normal file
View File

@@ -0,0 +1 @@
{ "extends": "../tslint.json" }

23
forever-monitor/forever-monitor-tests.ts Normal file
View File

@@ -0,0 +1,23 @@
// Test from https://github.com/foreverjs/forever-monitor
import * as forever from "forever-monitor";
forever.start('script')
.on("start", () => console.log("started"));
forever.kill(10, true);
const child = new (forever.Monitor)('your-filename.js', {
max: 3,
silent: true,
args: []
});
child.on('exit', function() {
console.log('your-filename.js has exited after 3 restarts');
});
child.start()
.on("start", () => console.log("started"))
.restart()
.stop()
.on("exit", () => console.log("STOPPED"))

93
forever-monitor/index.d.ts vendored Normal file
View File

@@ -0,0 +1,93 @@
// Type definitions for forever-monitor 1.7
// Project: https://github.com/nodejitsu/forever-monitor#readme
// Definitions by: Shun Takahashi <https://github.com/shuntksh>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node" />
export interface SpawnWith {
customFds: number[];
setsid: boolean;
uid: number;
gid: number;
}
export interface Options {
silent?: boolean;
uid?: string;
pidFile?: string;
max?: number;
killTree?: boolean;
minUptime?: number;
spinSleepTime?: number;
command?: string;
args?: string[];
sourceDir?: string;
watch?: boolean;
watchIgnoreDotFiles?: boolean;
watchIgnorePatters?: string[];
watchDirectory?: string;
spawnWith?: SpawnWith;
env?: { [envKey: string]: string; };
cwd?: string;
logFile?: string;
outFile?: string;
errFile?: string;
parser?: (command: string, args: string[]) => { command: string, args: string[] };
}
export function start(script: string, options?: Options): Monitor;
export function kill(pid: number, killTree?: boolean, signal?: string, callback?: () => any): void;
export function checkProcess(pid: number): boolean;
export const version: string;
export class Monitor extends NodeJS.EventEmitter {
/**
* @param script - Location of the target script to run.
* @param [options] - Configuration for this instance.
*/
constructor(script: string, options?: Options);
/**
* @description Start the process that this instance is configured for
* @param [restart] - Value indicating whether this is a restart.
*/
start(restart?: boolean): this;
/**
* @description Tries to spawn the target Forever child process.
*/
trySpawn(): boolean;
/**
* @description Restarts the target script associated with this instance.
*/
restart(): this;
/**
* @description Stops the target script associated with this instance. Prevents it from auto-respawning
*/
stop(): this;
/**
* @description Kills the ChildProcess object associated with this instance
* @param [forceStop] - Value indicating whether short circuit forever auto-restart
*/
kill(forceStop?: boolean): this;
/**
* @description Sends a message to a forked ChildProcess object associated with this instance
*/
send(msg?: any): this;
/**
* respond with JSON for this instance
*/
toString(): string;
/**
* @param command - Command string to parse
* @param args - Additional default arguments
*/
parseCommand(command: string, args?: string[]): (false | { command: string, args?: string[]});
}

20
forever-monitor/tsconfig.json Normal file
View File

@@ -0,0 +1,20 @@
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"forever-monitor-tests.ts"
]
}

1
forever-monitor/tslint.json Normal file
View File

@@ -0,0 +1 @@
{ "extends": "../tslint.json" }

2
html-to-text/index.d.ts vendored
View File

@@ -39,7 +39,7 @@ interface HtmlToTextOptions {
* Defines after how many chars a line break should follow in p elements.
* Set to null or false to disable word-wrapping. Default: 80
*/
wordwrap?: number;
wordwrap?: number | false | null;
/**
* Allows to select certain tables by the class or id attribute from the HTML

123
jest/index.d.ts vendored
View File

@@ -1,7 +1,8 @@
// Type definitions for Jest 16.0.0
// Type definitions for Jest 18.1.0
// Project: http://facebook.github.io/jest/
// Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>
// Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>, Alexey Svetliakov <https://github.com/asvetliakov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
declare var beforeAll: jest.Lifecycle;
declare var beforeEach: jest.Lifecycle;
@@ -16,7 +17,7 @@ declare var xit: jest.It;
declare var test: jest.It;
declare var xtest: jest.It;
declare function expect(actual: any): jest.Matchers;
declare const expect: jest.Expect;
interface NodeRequire {
/** Returns the actual module instead of a mock, bypassing all checks on whether the module should receive a mock implementation or not. */
@@ -26,13 +27,18 @@ interface NodeRequire {
}
declare namespace jest {
/** Provides a way to add Jasmine-compatible matchers into your Jest context. */
function addMatchers(matchers: jasmine.CustomMatcherFactories): typeof jest;
/** Disables automatic mocking in the module loader. */
function autoMockOff(): typeof jest;
/** Enables automatic mocking in the module loader. */
function autoMockOn(): typeof jest;
/** Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function. */
/**
* @deprecated use resetAllMocks instead
*/
function clearAllMocks(): typeof jest;
/** Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function. */
function resetAllMocks(): typeof jest;
/** Removes any pending timers from the timer system. If any timers have been scheduled, they will be cleared and will never have the opportunity to execute in the future. */
function clearAllTimers(): typeof jest;
/** Indicates that the module system should never return a mocked version of the specified module, including all of the specificied module's dependencies. */
@@ -46,6 +52,7 @@ declare namespace jest {
/** Enables automatic mocking in the module loader. */
function enableAutomock(): typeof jest;
/** Creates a mock function. Optionally takes a mock implementation. */
function fn<T extends {}>(implementation: (...args: any[]) => T): Mock<T>;
function fn<T>(implementation?: Function): Mock<T>;
/** Use the automatic mocking system to generate a mocked version of the given module. */
function genMockFromModule<T>(moduleName: string): T;
@@ -98,8 +105,16 @@ declare namespace jest {
(fn: ProvidesCallback): any;
}
/** Creates a test closure */
interface It {
/**
* Creates a test closure.
*
* @param {string} name The name of your test
* @param {fn?} ProvidesCallback The function for your test
*/
(name: string, fn?: ProvidesCallback): void;
/** Only runs this test in the current file. */
only: It;
skip: It;
concurrent: It;
@@ -111,35 +126,113 @@ declare namespace jest {
skip: Describe;
}
interface MatcherUtils {
readonly isNot: boolean;
utils: {
readonly EXPECTED_COLOR: string;
readonly RECEIVED_COLOR: string;
ensureActualIsNumber(actual: any, matcherName?: string): void;
ensureExpectedIsNumber(actual: any, matcherName?: string): void;
ensureNoExpected(actual: any, matcherName?: string): void;
ensureNumbers(actual: any, expected: any, matcherName?: string): void;
/** get the type of a value with handling of edge cases like `typeof []` and `typeof null` */
getType(value: any): string;
matcherHint(matcherName: string, received?: string, expected?: string, options?: { secondArgument?: string, isDirectExpectCall?: boolean }): string;
pluralize(word: string, count: number): string;
printExpected(value: any): string;
printReceived(value: any): string;
printWithType(name: string, received: any, print: (value: any) => string): string;
stringify(object: {}, maxDepth?: number): string;
}
}
interface ExpectExtendMap {
[key: string]: (this: MatcherUtils, received: any, actual: any) => { message: () => string, pass: boolean };
}
/** The `expect` function is used every time you want to test a value. You will rarely call `expect` by itself. */
interface Expect {
/**
* The `expect` function is used every time you want to test a value. You will rarely call `expect` by itself.
*
* @param {any} actual The value to apply matchers against.
*/
(actual: any): Matchers;
anything(): void;
/** Matches anything that was created with the given constructor. You can use it inside `toEqual` or `toBeCalledWith` instead of a literal value. */
any(classType: any): void;
/** Matches any array made up entirely of elements in the provided array. You can use it inside `toEqual` or `toBeCalledWith` instead of a literal value. */
arrayContaining(arr: any[]): void;
/** Verifies that a certain number of assertions are called during a test. This is often useful when testing asynchronous code, in order to make sure that assertions in a callback actually got called. */
assertions(num: number): void;
/** You can use `expect.extend` to add your own matchers to Jest. */
extend(obj: ExpectExtendMap): void;
/** Matches any object that recursively matches the provided keys. This is often handy in conjunction with other asymmetric matchers. */
objectContaining(obj: {}): void;
/** Matches any string that contains the exact provided string */
stringMatching(str: string | RegExp): void;
}
interface Matchers {
/** If you know how to test something, `.not` lets you test its opposite. */
not: Matchers;
lastCalledWith(...args: any[]): void;
/** Checks that a value is what you expect. It uses `===` to check strict equality. Don't use `toBe` with floating-point numbers. */
toBe(expected: any): void;
/** Ensures that a mock function is called. */
toBeCalled(): void;
/** Ensure that a mock function is called with specific arguments. */
toBeCalledWith(...args: any[]): void;
toBeCloseTo(expected: number, delta: number): void;
/** Using exact equality with floating point numbers is a bad idea. Rounding means that intuitive things fail. */
toBeCloseTo(expected: number, delta?: number): void;
/** Ensure that a variable is not undefined. */
toBeDefined(): void;
/** When you don't care what a value is, you just want to ensure a value is false in a boolean context. */
toBeFalsy(): void;
/** For comparing floating point numbers. */
toBeGreaterThan(expected: number): void;
/** For comparing floating point numbers. */
toBeGreaterThanOrEqual(expected: number): void;
/** Ensure that an object is an instance of a class. This matcher uses `instanceof` underneath. */
toBeInstanceOf(expected: any): void
/** For comparing floating point numbers. */
toBeLessThan(expected: number): void;
/** For comparing floating point numbers. */
toBeLessThanOrEqual(expected: number): void;
/** This is the same as `.toBe(null)` but the error messages are a bit nicer. So use `.toBeNull()` when you want to check that something is null. */
toBeNull(): void;
/** Use when you don't care what a value is, you just want to ensure a value is true in a boolean context. In JavaScript, there are six falsy values: `false`, `0`, `''`, `null`, `undefined`, and `NaN`. Everything else is truthy. */
toBeTruthy(): void;
/** Used to check that a variable is undefined. */
toBeUndefined(): void;
/** Used when you want to check that an item is in a list. For testing the items in the list, this uses `===`, a strict equality check. */
toContain(expected: any): void;
/** Used when you want to check that an item is in a list. For testing the items in the list, this matcher recursively checks the equality of all fields, rather than checking for object identity. */
toContainEqual(expected: any): void;
/** Used when you want to check that two objects have the same value. This matcher recursively checks the equality of all fields, rather than checking for object identity. */
toEqual(expected: any): void;
/** Ensures that a mock function is called. */
toHaveBeenCalled(): boolean;
/** Ensures that a mock function is called an exact number of times. */
toHaveBeenCalledTimes(expected: number): boolean;
/** Ensure that a mock function is called with specific arguments. */
toHaveBeenCalledWith(...params: any[]): boolean;
/** If you have a mock function, you can use `.toHaveBeenLastCalledWith` to test what arguments it was last called with. */
toHaveBeenLastCalledWith(...params: any[]): boolean;
/** Used to check that an object has a `.length` property and it is set to a certain numeric value. */
toHaveLength(expected: number): void;
toHaveProperty(propertyPath: string, value?: any): void;
/** Check that a string matches a regular expression. */
toMatch(expected: string | RegExp): void;
/** Used to check that a JavaScript object matches a subset of the properties of an objec */
toMatchObject(expected: {}): void;
toMatchSnapshot(): void;
/** This ensures that a value matches the most recent snapshot. Check out [the Snapshot Testing guide](http://facebook.github.io/jest/docs/snapshot-testing.html) for more information. */
toMatchSnapshot(snapshotName?: string): void;
/** Used to test that a function throws when it is called. */
toThrow(): void;
/** If you want to test that a specific error is thrown inside a function. */
toThrowError(error?: string | Constructable | RegExp): void;
/** Used to test that a function throws a error matching the most recent snapshot when it is called. */
toThrowErrorMatchingSnapshot(): void;
}
@@ -147,9 +240,25 @@ declare namespace jest {
new (...args: any[]): any
}
interface Mock<T> extends Function {
interface Mock<T> extends Function, MockInstance<T> {
new (): T;
(...args: any[]): any;
}
/**
* Wrap module with mock definitions
* @example
* jest.mock("../api");
* import { Api } from "../api";
*
* const myApi: jest.Mocked<Api> = new Api() as any;
* myApi.myApiMethod.mockImplementation(() => "test");
*/
type Mocked<T> = {
[P in keyof T]: T[P] & MockInstance<T>;
};
interface MockInstance<T> {
mock: MockContext<T>;
mockClear(): void;
mockReset(): void;

118
jest/jest-tests.ts
View File

@@ -147,6 +147,10 @@ describe('compartion', function () {
it('works sanely with simple decimals', function () {
expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
});
it('works sanely with simple decimals and the default delta', function () {
expect(0.2 + 0.1).toBeCloseTo(0.3);
});
});
describe('toThrow API', function () {
@@ -171,6 +175,60 @@ describe('toThrow API', function () {
});
});
describe('Assymetric matchers', function () {
it('works', function () {
expect({
timestamp: 1480807810388,
text: 'Some text content, but we care only about *this part*'
}).toEqual({
timestamp: expect.any(Number),
text: expect.stringMatching('*this part*')
});
const callback = jest.fn();
expect(callback).toEqual(expect.any(Function));
callback(5, "test");
expect(callback).toBeCalledWith(expect.any(Number), expect.any(String))
const obj = {
items: [1]
};
expect(obj).toEqual(expect.objectContaining({
items: expect.arrayContaining([
expect.any(Number)
])
}));
expect.assertions(4);
});
});
describe('Extending extend', function () {
it('works', function () {
expect.extend({
toBeNumber(received: any, actual: any) {
const pass = received === actual;
const message =
() => `expected ${received} ${pass ? 'not ' : ''} to be ${actual}`;
return { message, pass };
},
toBeTest(received: any, actual: any) {
this.utils.ensureNoExpected(received);
this.utils.ensureActualIsNumber(received);
this.utils.ensureExpectedIsNumber(actual);
this.utils.ensureNumbers(received, actual);
return {
message: () => `
${this.utils.getType(received).toLowerCase()} \n\n
${this.utils.matcherHint(".not.toBe")} ${this.utils.printExpected(actual)} ${this.utils.printReceived(received)}\n\n
`,
pass: true
};
}
});
});
});
describe('missing tests', function () {
it('creates closures', function () {
class Closure<T> {
@@ -208,7 +266,7 @@ describe('missing tests', function () {
expect(getFruits()).toContain('Orange');
mock.mockReturnValueOnce(['Apple', 'Plum']);
expect(mock()).not.toContain('Orange');
const myBeverage: any = {delicious: true, sour: false};
const myBeverage: any = {delicious: true, sour: false};
expect(myBeverage).toContainEqual({delicious: true, sour: false});
mock.mockReturnValue([]); //Deprecated: Use jest.fn(() => value) instead.
mock.mockClear();
@@ -248,6 +306,10 @@ describe('toMatchSnapshot', function () {
it('compares snapshots', function () {
expect({ type: 'a', props: { href: 'https://www.facebook.com/' }, children: [ 'Facebook' ] }).toMatchSnapshot();
});
it('can give name to snapshot', function () {
expect({ type: 'a', props: { href: 'https://www.facebook.com/' }, children: [ 'Facebook' ] }).toMatchSnapshot('given name');
});
});
describe('toThrowErrorMatchingSnapshot', function () {
@@ -367,3 +429,57 @@ describe('strictNullChecks', function () {
done();
})
});
class TestApi {
constructor() { };
testProp: boolean;
testMethod(a: number): string { return ""; }
}
declare function mockedFunc(a: number): string;
declare function mockedFuncWithApi(api: TestApi): void;
describe('Mocked type', function () {
it('Works', function () {
const mock: jest.Mocked<TestApi> = new TestApi() as any;
mock.testProp;
mock.testMethod.mockImplementation(() => 'test');
mock.testMethod(5).toUpperCase();
mockedFuncWithApi(mock);
});
});
describe('Mocks', function () {
it('jest.fn() without args is a function type', function () {
const test = jest.fn();
test();
new test();
test.mock.instances[0];
test.mockImplementation(() => { });
});
it('jest.fn() with returned object infers type', function () {
const testMock = jest.fn(() => ({ a: 5, test: jest.fn() }));
testMock(5, 5, 'a');
testMock.mockImplementation(() => { });
testMock.caller;
const ins = new testMock();
ins.a;
ins.test();
ins.test.mockImplementation(() => 5);
ins.test.mock.calls;
const anotherMock = jest.fn(() => {
const api: Partial<TestApi> = {
testMethod: jest.fn()
};
return api;
});
const anotherIns: jest.Mocked<TestApi> = new anotherMock() as any;
anotherIns.testMethod.mockImplementation(() => 1);
});
});

303
jest/v16/index.d.ts vendored Normal file
View File

@@ -0,0 +1,303 @@
// Type definitions for Jest 16.0.0
// Project: http://facebook.github.io/jest/
// Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare var beforeAll: jest.Lifecycle;
declare var beforeEach: jest.Lifecycle;
declare var afterAll: jest.Lifecycle;
declare var afterEach: jest.Lifecycle;
declare var describe: jest.Describe;
declare var fdescribe: jest.Describe;
declare var xdescribe: jest.Describe;
declare var it: jest.It;
declare var fit: jest.It;
declare var xit: jest.It;
declare var test: jest.It;
declare var xtest: jest.It;
declare function expect(actual: any): jest.Matchers;
interface NodeRequire {
/** Returns the actual module instead of a mock, bypassing all checks on whether the module should receive a mock implementation or not. */
requireActual(moduleName: string): any;
/** Returns a mock module instead of the actual module, bypassing all checks on whether the module should be required normally or not. */
requireMock(moduleName: string): any;
}
declare namespace jest {
function addMatchers(matchers: jasmine.CustomMatcherFactories): typeof jest;
/** Disables automatic mocking in the module loader. */
function autoMockOff(): typeof jest;
/** Enables automatic mocking in the module loader. */
function autoMockOn(): typeof jest;
/** Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function. */
function clearAllMocks(): typeof jest;
/** Removes any pending timers from the timer system. If any timers have been scheduled, they will be cleared and will never have the opportunity to execute in the future. */
function clearAllTimers(): typeof jest;
/** Indicates that the module system should never return a mocked version of the specified module, including all of the specificied module's dependencies. */
function deepUnmock(moduleName: string): typeof jest;
/** Disables automatic mocking in the module loader. */
function disableAutomock(): typeof jest;
/** Mocks a module with an auto-mocked version when it is being required. */
function doMock(moduleName: string): typeof jest;
/** Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module). */
function dontMock(moduleName: string): typeof jest;
/** Enables automatic mocking in the module loader. */
function enableAutomock(): typeof jest;
/** Creates a mock function. Optionally takes a mock implementation. */
function fn<T>(implementation?: Function): Mock<T>;
/** Use the automatic mocking system to generate a mocked version of the given module. */
function genMockFromModule<T>(moduleName: string): T;
/** Returns whether the given function is a mock function. */
function isMockFunction(fn: any): fn is Mock<any>;
/** Mocks a module with an auto-mocked version when it is being required. */
function mock(moduleName: string, factory?: any, options?: MockOptions): typeof jest;
/** Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests. */
function resetModuleRegistry(): typeof jest;
/** Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests. */
function resetModules(): typeof jest;
/** Exhausts tasks queued by setImmediate(). */
function runAllImmediates(): typeof jest;
/** Exhausts the micro-task queue (usually interfaced in node via process.nextTick). */
function runAllTicks(): typeof jest;
/** Exhausts the macro-task queue (i.e., all tasks queued by setTimeout() and setInterval()). */
function runAllTimers(): typeof jest;
/** Executes only the macro-tasks that are currently pending (i.e., only the tasks that have been queued by setTimeout() or setInterval() up to this point).
* If any of the currently pending macro-tasks schedule new macro-tasks, those new tasks will not be executed by this call. */
function runOnlyPendingTimers(): typeof jest;
/** Executes only the macro task queue (i.e. all tasks queued by setTimeout() or setInterval() and setImmediate()). */
function runTimersToTime(msToRun: number): typeof jest;
/** Explicitly supplies the mock object that the module system should return for the specified module. */
function setMock<T>(moduleName: string, moduleExports: T): typeof jest;
/** Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module). */
function unmock(moduleName: string): typeof jest;
/** Instructs Jest to use fake versions of the standard timer functions. */
function useFakeTimers(): typeof jest;
/** Instructs Jest to use the real versions of the standard timer functions. */
function useRealTimers(): typeof jest;
interface MockOptions {
virtual?: boolean;
}
interface EmptyFunction {
(): void;
}
interface DoneCallback {
(...args: any[]): any
fail(error?: string | { message: string }): any;
}
interface ProvidesCallback {
(cb: DoneCallback): any;
}
interface Lifecycle {
(fn: ProvidesCallback): any;
}
interface It {
(name: string, fn?: ProvidesCallback): void;
only: It;
skip: It;
concurrent: It;
}
interface Describe {
(name: string, fn: EmptyFunction): void
only: Describe;
skip: Describe;
}
interface Matchers {
not: Matchers;
lastCalledWith(...args: any[]): void;
toBe(expected: any): void;
toBeCalled(): void;
toBeCalledWith(...args: any[]): void;
toBeCloseTo(expected: number, delta: number): void;
toBeDefined(): void;
toBeFalsy(): void;
toBeGreaterThan(expected: number): void;
toBeGreaterThanOrEqual(expected: number): void;
toBeInstanceOf(expected: any): void
toBeLessThan(expected: number): void;
toBeLessThanOrEqual(expected: number): void;
toBeNull(): void;
toBeTruthy(): void;
toBeUndefined(): void;
toContain(expected: any): void;
toContainEqual(expected: any): void;
toEqual(expected: any): void;
toHaveBeenCalled(): boolean;
toHaveBeenCalledTimes(expected: number): boolean;
toHaveBeenCalledWith(...params: any[]): boolean;
toHaveBeenLastCalledWith(...params: any[]): boolean;
toMatch(expected: string | RegExp): void;
toMatchObject(expected: {}): void;
toMatchSnapshot(): void;
toThrow(): void;
toThrowError(error?: string | Constructable | RegExp): void;
toThrowErrorMatchingSnapshot(): void;
}
interface Constructable {
new (...args: any[]): any
}
interface Mock<T> extends Function {
new (): T;
(...args: any[]): any;
mock: MockContext<T>;
mockClear(): void;
mockReset(): void;
mockImplementation(fn: Function): Mock<T>;
mockImplementationOnce(fn: Function): Mock<T>;
mockReturnThis(): Mock<T>;
mockReturnValue(value: any): Mock<T>;
mockReturnValueOnce(value: any): Mock<T>;
}
interface MockContext<T> {
calls: any[][];
instances: T[];
}
}
//Jest ships with a copy of Jasmine. They monkey-patch its APIs and divergence/deprecation are expected.
//Relevant parts of Jasmine's API are below so they can be changed and removed over time.
//This file can't reference jasmine.d.ts since the globals aren't compatible.
declare function spyOn(object: any, method: string): jasmine.Spy;
/** If you call the function pending anywhere in the spec body, no matter the expectations, the spec will be marked pending. */
declare function pending(reason?: string): void;
/** Fails a test when called within one. */
declare function fail(error?: any): void;
declare namespace jasmine {
var clock: () => Clock;
function any(aclass: any): Any;
function anything(): Any;
function arrayContaining(sample: any[]): ArrayContaining;
function objectContaining(sample: any): ObjectContaining;
function createSpy(name: string, originalFn?: Function): Spy;
function createSpyObj(baseName: string, methodNames: any[]): any;
function createSpyObj<T>(baseName: string, methodNames: any[]): T;
function pp(value: any): string;
function addCustomEqualityTester(equalityTester: CustomEqualityTester): void;
function addMatchers(matchers: CustomMatcherFactories): void;
function stringMatching(value: string | RegExp): Any;
interface Clock {
install(): void;
uninstall(): void;
/** Calls to any registered callback are triggered when the clock is ticked forward via the jasmine.clock().tick function, which takes a number of milliseconds. */
tick(ms: number): void;
mockDate(date?: Date): void;
}
interface Any {
new (expectedClass: any): any;
jasmineMatches(other: any): boolean;
jasmineToString(): string;
}
interface ArrayContaining {
new (sample: any[]): any;
asymmetricMatch(other: any): boolean;
jasmineToString(): string;
}
interface ObjectContaining {
new (sample: any): any;
jasmineMatches(other: any, mismatchKeys: any[], mismatchValues: any[]): boolean;
jasmineToString(): string;
}
interface Spy {
(...params: any[]): any;
identity: string;
and: SpyAnd;
calls: Calls;
mostRecentCall: { args: any[]; };
argsForCall: any[];
wasCalled: boolean;
}
interface SpyAnd {
/** By chaining the spy with and.callThrough, the spy will still track all calls to it but in addition it will delegate to the actual implementation. */
callThrough(): Spy;
/** By chaining the spy with and.returnValue, all calls to the function will return a specific value. */
returnValue(val: any): Spy;
/** By chaining the spy with and.returnValues, all calls to the function will return specific values in order until it reaches the end of the return values list. */
returnValues(...values: any[]): Spy;
/** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function. */
callFake(fn: Function): Spy;
/** By chaining the spy with and.throwError, all calls to the spy will throw the specified value. */
throwError(msg: string): Spy;
/** When a calling strategy is used for a spy, the original stubbing behavior can be returned at any time with and.stub. */
stub(): Spy;
}
interface Calls {
/** By chaining the spy with calls.any(), will return false if the spy has not been called at all, and then true once at least one call happens. */
any(): boolean;
/** By chaining the spy with calls.count(), will return the number of times the spy was called */
count(): number;
/** By chaining the spy with calls.argsFor(), will return the arguments passed to call number index */
argsFor(index: number): any[];
/** By chaining the spy with calls.allArgs(), will return the arguments to all calls */
allArgs(): any[];
/** By chaining the spy with calls.all(), will return the context (the this) and arguments passed all calls */
all(): CallInfo[];
/** By chaining the spy with calls.mostRecent(), will return the context (the this) and arguments for the most recent call */
mostRecent(): CallInfo;
/** By chaining the spy with calls.first(), will return the context (the this) and arguments for the first call */
first(): CallInfo;
/** By chaining the spy with calls.reset(), will clears all tracking for a spy */
reset(): void;
}
interface CallInfo {
/** The context (the this) for the call */
object: any;
/** All arguments passed to the call */
args: any[];
/** The return value of the call */
returnValue: any;
}
interface CustomMatcherFactories {
[index: string]: CustomMatcherFactory;
}
interface CustomMatcherFactory {
(util: MatchersUtil, customEqualityTesters: Array<CustomEqualityTester>): CustomMatcher;
}
interface MatchersUtil {
equals(a: any, b: any, customTesters?: Array<CustomEqualityTester>): boolean;
contains<T>(haystack: ArrayLike<T> | string, needle: any, customTesters?: Array<CustomEqualityTester>): boolean;
buildFailureMessage(matcherName: string, isNot: boolean, actual: any, ...expected: Array<any>): string;
}
interface CustomEqualityTester {
(first: any, second: any): boolean;
}
interface CustomMatcher {
compare<T>(actual: T, expected: T): CustomMatcherResult;
compare(actual: any, expected: any): CustomMatcherResult;
}
interface CustomMatcherResult {
pass: boolean;
message: string | (() => string);
}
interface ArrayLike<T> {
length: number;
[n: number]: T;
}
}

369
jest/v16/jest-tests.ts Normal file
View File

@@ -0,0 +1,369 @@
/// <reference types="node" />
// Tests based on the Jest website
jest.unmock('../sum');
describe('sum', function() {
it('adds 1 + 2 to equal 3', function() {
var sum: (a: number, b: number) => number = require('../sum');
expect(sum(1, 2)).toBe(3);
});
});
describe('fetchCurrentUser', function() {
it('calls the callback when $.ajax requests are finished', function() {
var $ = require('jquery');
var fetchCurrentUser = require('../fetchCurrentUser');
// Create a mock function for our callback
var callback = jest.fn();
fetchCurrentUser(callback);
// Now we emulate the process by which `$.ajax` would execute its own
// callback
$.ajax.mock.calls[0 /*first call*/][0 /*first argument*/].success({
firstName: 'Bobby',
lastName: '");DROP TABLE Users;--'
});
// And finally we assert that this emulated call by `$.ajax` incurred a
// call back into the mock function we provided as a callback
expect(callback.mock.calls[0/*first call*/][0/*first arg*/]).toEqual({
loggedIn: true,
fullName: 'Bobby ");DROP TABLE Users;--'
});
});
});
// unmock is the recommended approach for unmocking...
jest.unmock('../displayUser.js')
describe('displayUser', function() {
it('displays a user after a click', function() {
// Set up our document body
document.body.innerHTML =
'<div>' +
' <span id="username" />' +
' <button id="button" />' +
'</div>';
var displayUser = require.requireActual('../displayUser');
var $ = require('jquery');
var fetchCurrentUser = require('../fetchCurrentUser');
// Tell the fetchCurrentUser mock function to automatically invoke
// its callback with some data
fetchCurrentUser.mockImplementation(function(cb: Function) {
cb({
loggedIn: true,
fullName: 'Johnny Cash'
});
});
// Use jquery to emulate a click on our button
$('#button').click();
// Assert that the fetchCurrentUser function was called, and that the
// #username span's innter text was updated as we'd it expect.
expect(fetchCurrentUser).toBeCalled();
expect($('#username').text()).toEqual('Johnny Cash - Logged In');
});
});
jest.unmock('../CheckboxWithLabel.js');
describe('CheckboxWithLabel', function() {
it('changes the text after click', function() {
var React = require('react/addons');
var CheckboxWithLabel = require('../CheckboxWithLabel.js');
var TestUtils = React.addons.TestUtils;
// Render a checkbox with label in the document
var checkbox = TestUtils.renderIntoDocument(
CheckboxWithLabel({
labelOn: "On",
labelOff: "Off"
})
);
// Verify that it's Off by default
var label = TestUtils.findRenderedDOMComponentWithTag(
checkbox, 'label');
expect(label.getDOMNode().textContent).toEqual('Off');
// Simulate a click and verify that it is now On
var input = TestUtils.findRenderedDOMComponentWithTag(
checkbox, 'input');
TestUtils.Simulate.change(input);
expect(label.getDOMNode().textContent).toEqual('On');
});
});
jest.runAllTicks();
xdescribe('Hooks and Suits', function () {
let tested: boolean;
beforeEach(function () {
tested = false;
});
afterEach(function () {
tested = true;
});
test('tested', function () {
expect(tested).toBeTruthy();
expect(tested).not.toBeFalsy();
});
fit('tested', function () {
expect(tested).toBeDefined();
expect(tested).not.toBeUndefined();
});
xit('expect null to be null', function () {
expect(null).toBeNull();
});
});
describe('compartion', function () {
var sum: (a: number, b: number) => number = require.requireMock('../sum');
it('compares is 7 + 2 greater than 3', function () {
expect(sum(7, 2)).toBeGreaterThan(3);
});
it('compares is 2 + 7 greater than or equal to 3', function () {
expect(sum(2, 7)).toBeGreaterThanOrEqual(3);
});
it('compares is 3 less than 3 + 4', function () {
expect(3).toBeLessThan(sum(3, 4));
});
it('compares is 3 less than or equal to 4 + 3', function () {
expect(3).toBeLessThanOrEqual(sum(4, 3));
});
it('works sanely with simple decimals', function () {
expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
});
});
describe('toThrow API', function () {
function throwTypeError(): void {
throw new TypeError('toThrow Definition was out of date');
}
it('throws', function () {
expect(throwTypeError()).toThrow();
});
it('throws TypeError', function () {
expect(throwTypeError()).toThrowError(TypeError);
});
it('throws \'Definition was out of date\'', function () {
expect(throwTypeError()).toThrowError(/Definition was out of date/);
});
it('throws \'toThorow Definition was out of date\'', function () {
expect(throwTypeError()).toThrowError('toThrow Definition was out of date');
});
});
describe('missing tests', function () {
it('creates closures', function () {
class Closure<T> {
private arg: T;
public constructor(private fn: (arg: T) => void) {
this.fn = fn;
}
public bind(arg: T): void {
this.arg = arg;
}
public call(): void {
this.fn(this.arg);
}
}
type StringClosure = (arg: string) => void;
let spy: jest.Mock<StringClosure> = jest.fn<StringClosure>();
let closure: Closure<string> = new Closure<string>(spy);
closure.bind('jest');
closure.call();
expect(spy).lastCalledWith('jest');
expect(spy).toBeCalledWith('jest');
expect(jest.isMockFunction(spy)).toBeTruthy();
});
it('tests all mising Mocks functionality', function () {
type FruitsGetter = () => Array<string>;
let mock: jest.Mock<FruitsGetter> = jest.fn<FruitsGetter>();
mock.mockImplementationOnce(() => ['Orange', 'Apple', 'Plum'])
jest.setMock('./../tesks/getFruits', mock);
const getFruits: FruitsGetter = require('./../tesks/getFruits');
expect(getFruits()).toContain('Orange');
mock.mockReturnValueOnce(['Apple', 'Plum']);
expect(mock()).not.toContain('Orange');
const myBeverage: any = {delicious: true, sour: false};
expect(myBeverage).toContainEqual({delicious: true, sour: false});
mock.mockReturnValue([]); //Deprecated: Use jest.fn(() => value) instead.
mock.mockClear();
let thisMock: jest.Mock<any> = jest.fn<any>().mockReturnThis();
expect(thisMock()).toBe(this);
});
it('creates snapshoter', function () {
jest.disableAutomock().mock('./render', () => jest.fn((): string => "{Link to: \"facebook\"}"), { virtual: true });
const render: () => string = require('./render');
expect(render()).toMatch(/Link/);
jest.enableAutomock();
});
it('runs only pending timers', function () {
jest.useRealTimers();
setTimeout(() => expect(1).not.toEqual(0), 3000);
jest.runOnlyPendingTimers().runTimersToTime(300);
});
it('runs all timers', function () {
jest.clearAllTimers();
jest.useFakeTimers();
setTimeout(() => expect(0).not.toEqual(1), 3000);
jest.runAllTimers();
});
it('cleares cache', function () {
const sum1 = require('../sum');
jest.resetModules();
const sum2 = require('../sum');
expect(sum1).not.toBe(sum2);
})
});
describe('toMatchSnapshot', function () {
it('compares snapshots', function () {
expect({ type: 'a', props: { href: 'https://www.facebook.com/' }, children: [ 'Facebook' ] }).toMatchSnapshot();
});
});
describe('toThrowErrorMatchingSnapshot', function () {
it('compares snapshots', function () {
expect(() => { throw new Error('descriptiton') }).toThrowErrorMatchingSnapshot();
});
});
function testInstances() {
var mockFn = jest.fn<Function>();
var a = new mockFn();
var b = new mockFn();
mockFn.mock.instances[0] === a; // true
mockFn.mock.instances[1] === b; // true
}
function testMockImplementation() {
var mockFn = jest.fn<Function>().mockImplementation(function (scalar:number):number {
return 42 + scalar;
});
var a = mockFn(0);
var b = mockFn(1);
a === 42; // true
b === 43; // true
mockFn.mock.calls[0][0] === 0; // true
mockFn.mock.calls[1][0] === 1; // true
}
// Test from jest Docs: <http://facebook.github.io/jest/docs/manual-mocks.html#content>
describe('genMockFromModule', function () {
// Interfaces:
interface MockFiles {
[index: string]: string;
}
interface MockedFS {
readdirSync: (dir: string) => string[];
__setMockFiles: (newMockFiles: MockFiles) => void ;
}
// ------------------------------------------------------------------------------------
// FileSummarizer.ts
const fs = require('fs');
function summarizeFilesInDirectorySync(directory: string): string[] {
return fs.readdirSync(directory).map((fileName: string) => ({
fileName,
directory,
}));
}
//export default summarizeFilesInDirectorySync; // For sake of compilation
// ------------------------------------------------------------------------------------
// __mocks__/fs.js
const path = require('path');
const mockedFS: MockedFS = jest.genMockFromModule<MockedFS>('fs');
let mockFiles: any = Object.create(null);
function __setMockFiles(newMockFiles: MockFiles): void {
mockFiles = Object.create(null);
for(const file in newMockFiles) {
const dir: string = path.dirname(file);
if (!mockFiles[dir]) {
mockFiles[dir] = [];
}
mockFiles[dir].push(path.basename(file));
}
}
function readdirSync(directoryPath: string): string[] {
return mockFiles[directoryPath] || [];
}
mockedFS.readdirSync = readdirSync;
mockedFS.__setMockFiles = __setMockFiles;
//export = mockedFS; // For sake of compilation
// ------------------------------------------------------------------------------------
// __tests__/FileSummarizer-test.js
jest.mock('fs');
describe('listFilesInDirectorySync', () => {
const MOCK_FILE_INFO: MockFiles = {
'/path/to/file1.js': 'console.log("file1 contents");',
'/path/to/file2.txt': 'file2 contents',
};
beforeEach(() => {
// Set up some mocked out file info before each test
(require('fs') as MockedFS).__setMockFiles(MOCK_FILE_INFO);
});
it('includes all files in the directory in the summary', () => {
const FileSummarizer: (dir: string) => string[] = require('../FileSummarizer');
const fileSummary = FileSummarizer('/path/to');
expect(fileSummary.length).toBe(2);
});
});
});
/**
* Pass strictNullChecks
*/
describe('strictNullChecks', function () {
it('does not complain when using done callback', (done) => {
done();
})
});

27
jest/v16/tsconfig.json Normal file
View File

@@ -0,0 +1,27 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": false,
"strictNullChecks": true,
"baseUrl": "../../",
"typeRoots": [
"../../"
],
"paths": {
"jest": ["jest/v16"],
"jest/*": ["jest/v16/*"]
},
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"jest-tests.ts"
]
}

5
jquery.fileupload/index.d.ts vendored
View File

@@ -198,7 +198,7 @@ interface JQueryFileInputOptions {
* handlers using jQuery's Deferred callbacks:
* data.submit().done(func).fail(func).always(func);
*/
add?: any;
add?: (e: JQueryEventObject, data: JQueryFileInputOptions) => void;
// The plugin options are used as settings object for the ajax calls.
// The following are jQuery ajax settings required for the file uploads:
@@ -228,7 +228,7 @@ interface JQueryFileInputOptions {
// Other callbacks:
submit?: Function;
done?: (e: JQueryEventObject, data: JQueryFileUploadDone) => void;
fail?: (e: JQueryEventObject, data: JQueryFileInputOptions) => void;
fail?: (e: JQueryEventObject, data: JQueryFileUploadDone) => void;
always?: (e: JQueryEventObject, data: JQueryFileInputOptions) => void;
progressall?: (e: JQueryEventObject, data: JQueryFileUploadProgressAllObject) => void;
start?: (e: JQueryEventObject) => void;
@@ -284,6 +284,7 @@ interface JQueryFileUploadXhr {
jqXHR: JQueryXHR;
result: any;
textStatus: string;
errorThrown: any;
headers: {[key: string]: any};
}

9
jquery/index.d.ts vendored
View File

@@ -786,6 +786,15 @@ interface JQueryStatic {
*/
ajaxPrefilter(handler: (opts: any, originalOpts: JQueryAjaxSettings, jqXHR: JQueryXHR) => any): void;
/**
* Creates an object that handles the actual transmission of Ajax data.
*
* @param dataType A string identifying the data type to use.
* @param handler A handler to return the new transport object to use with the data type provided in the first argument.
* @see {@link https://api.jquery.com/jQuery.ajaxTransport/}
*/
ajaxTransport(dataType: string, handler: (opts: any, originalOpts: JQueryAjaxSettings, jqXHR: JQueryXHR) => any): void;
ajaxSettings: JQueryAjaxSettings;
/**

1
lodash-decorators/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: https://github.com/steelsojka/lodash-decorators
// Definitions by: Qubo <https://github.com/tkqubo>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
/// <reference types="lodash" />

1
lodash-es/index.d.ts vendored
View File

@@ -2,3 +2,4 @@
// Project: http://lodash.com/
// Definitions by: Stephen Lautier <https://github.com/stephenlautier>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1

34
lodash-webpack-plugin/index.d.ts vendored Normal file
View File

@@ -0,0 +1,34 @@
// Type definitions for lodash-webpack-plugin 0.11
// Project: https://github.com/lodash/lodash-webpack-plugin#readme
// Definitions by: Benjamin Lim <https://github.com/bumbleblym>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Plugin, Webpack } from 'webpack';
export = LodashModuleReplacementPlugin;
declare class LodashModuleReplacementPlugin implements Plugin {
constructor(options?: LodashModuleReplacementPlugin.Options);
apply(thisArg: Webpack, ...args: any[]): void;
}
declare namespace LodashModuleReplacementPlugin {
export interface Options {
caching?: boolean;
chaining?: boolean;
cloning?: boolean;
coercions?: boolean;
collections?: boolean;
currying?: boolean;
deburring?: boolean;
exotics?: boolean;
flattening?: boolean;
guards?: boolean;
memoizing?: boolean;
metadata?: boolean;
paths?: boolean;
placeholders?: boolean;
shorthands?: boolean;
unicode?: boolean;
}
}

27
lodash-webpack-plugin/lodash-webpack-plugin-tests.ts Normal file
View File

@@ -0,0 +1,27 @@
import * as LodashModuleReplacementPlugin from 'lodash-webpack-plugin'
new LodashModuleReplacementPlugin()
new LodashModuleReplacementPlugin({
collections: true,
paths: true,
})
new LodashModuleReplacementPlugin({
caching: true,
chaining: true,
cloning: true,
coercions: true,
collections: true,
currying: true,
deburring: true,
exotics: true,
flattening: true,
guards: true,
memoizing: true,
metadata: true,
paths: true,
placeholders: true,
shorthands: true,
unicode: true,
})

20
lodash-webpack-plugin/tsconfig.json Normal file
View File

@@ -0,0 +1,20 @@
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"lodash-webpack-plugin-tests.ts"
]
}

1
lodash-webpack-plugin/tslint.json Normal file
View File

@@ -0,0 +1 @@
{ "extends": "../tslint.json" }

1
lodash.add/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { add } from "lodash";
export = add;

1
lodash.after/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { after } from "lodash";
export = after;

1
lodash.ary/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { ary } from "lodash";
export = ary;

1
lodash.assign/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { assign } from "lodash";
export = assign;

1
lodash.assignin/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { assignIn } from "lodash";
export = assignIn;

1
lodash.assigninwith/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { assignInWith } from "lodash";
export = assignInWith;

1
lodash.assignwith/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { assignWith } from "lodash";
export = assignWith;

1
lodash.at/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { at } from "lodash";
export = at;

1
lodash.attempt/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { attempt } from "lodash";
export = attempt;

1
lodash.before/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { before } from "lodash";
export = before;

1
lodash.bind/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { bind } from "lodash";
export = bind;

1
lodash.bindall/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { bindAll } from "lodash";
export = bindAll;

1
lodash.bindkey/index.d.ts vendored
View File

@@ -2,6 +2,7 @@
// Project: http://lodash.com/
// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { bindKey } from "lodash";
export = bindKey;

Some files were not shown because too many files have changed in this diff Show More