flip/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/FlipsideCrypto/DefinitelyTyped.git synced 2026-02-06 19:07:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[bluebird]Fix simple lint errors (#20222)

Browse Source 
* Fix lint-error dt-header

* Fix lint-error no-var-keyword

* Fix lint error no-padding

* Fix lint error only-arrow-functions

* Fix lint error space-before-function-paren

* Fix lint error prefer-method-signature

* Fix lint error typedef-whitespace

* Fic Lint ignore whitespace

* Fix lint error no-consecutive-blank-lines

* Fix lint error semicolon

* Fix lint error member-access

* Fix lint error comment-format
This commit is contained in:
segayuu 2017-10-10 06:47:48 +09:00 committed by Wesley Wigham
parent fff1399971
commit c7a368b276
3 changed files with 118 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

230
types/bluebird/bluebird-tests.ts
View File

@ -7,26 +7,26 @@
import Promise = require("bluebird");
var obj: Object;
var bool: boolean;
var num: number;
var str: string;
var err: Error;
var x: any;
var f: (...args: any[]) => any;
var asyncfunc: (...args: any[]) => Promise<any>;
var arr: any[];
var exp: RegExp;
var anyArr: any[];
var strArr: string[];
var numArr: number[];
var voidVar: void;
let obj: Object;
let bool: boolean;
let num: number;
let str: string;
let err: Error;
let x: any;
let f: (...args: any[]) => any;
let asyncfunc: (...args: any[]) => Promise<any>;
let arr: any[];
let exp: RegExp;
let anyArr: any[];
let strArr: string[];
let numArr: number[];
let voidVar: void;
// - - - - - - - - - - - - - - - - -
var value: any;
var reason: any;
var insanity: any;
let value: any;
let reason: any;
let insanity: any;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -43,120 +43,120 @@ interface Baz {
// - - - - - - - - - - - - - - - - -
interface StrFooMap {
[key:string]:Foo;
[key: string]: Foo;
}
interface StrBarMap {
[key:string]:Bar;
[key: string]: Bar;
}
// - - - - - - - - - - - - - - - - -
interface StrFooArrMap {
[key:string]:Foo[];
[key: string]: Foo[];
}
interface StrBarArrMap {
[key:string]:Bar[];
[key: string]: Bar[];
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
var foo: Foo;
var bar: Bar;
var baz: Baz;
let foo: Foo;
let bar: Bar;
let baz: Baz;
var fooArr: Foo[];
var barArr: Bar[];
let fooArr: Foo[];
let barArr: Bar[];
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
var numProm: Promise<number>;
var strProm: Promise<string>;
var anyProm: Promise<any>;
var boolProm: Promise<boolean>;
var objProm: Promise<Object>;
var voidProm: Promise<void>;
let numProm: Promise<number>;
let strProm: Promise<string>;
let anyProm: Promise<any>;
let boolProm: Promise<boolean>;
let objProm: Promise<Object>;
let voidProm: Promise<void>;
var fooProm: Promise<Foo>;
var barProm: Promise<Bar>;
var barOrVoidProm: Promise<Bar | void>;
var fooOrBarProm: Promise<Foo|Bar>;
var bazProm: Promise<Baz>;
let fooProm: Promise<Foo>;
let barProm: Promise<Bar>;
let barOrVoidProm: Promise<Bar | void>;
let fooOrBarProm: Promise<Foo|Bar>;
let bazProm: Promise<Baz>;
// - - - - - - - - - - - - - - - - -
var numThen: PromiseLike<number>;
var strThen: PromiseLike<string>;
var anyThen: PromiseLike<any>;
var boolThen: PromiseLike<boolean>;
var objThen: PromiseLike<Object>;
var voidThen: PromiseLike<void>;
let numThen: PromiseLike<number>;
let strThen: PromiseLike<string>;
let anyThen: PromiseLike<any>;
let boolThen: PromiseLike<boolean>;
let objThen: PromiseLike<Object>;
let voidThen: PromiseLike<void>;
var fooThen: PromiseLike<Foo>;
var barThen: PromiseLike<Bar>;
let fooThen: PromiseLike<Foo>;
let barThen: PromiseLike<Bar>;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
var numArrProm: Promise<number[]>;
var strArrProm: Promise<string[]>;
var anyArrProm: Promise<any[]>;
let numArrProm: Promise<number[]>;
let strArrProm: Promise<string[]>;
let anyArrProm: Promise<any[]>;
var fooArrProm: Promise<Foo[]>;
var barArrProm: Promise<Bar[]>;
let fooArrProm: Promise<Foo[]>;
let barArrProm: Promise<Bar[]>;
// - - - - - - - - - - - - - - - - -
var numArrThen: PromiseLike<number[]>;
var strArrThen: PromiseLike<string[]>;
var anyArrThen: PromiseLike<any[]>;
let numArrThen: PromiseLike<number[]>;
let strArrThen: PromiseLike<string[]>;
let anyArrThen: PromiseLike<any[]>;
var fooArrThen: PromiseLike<Foo[]>;
var barArrThen: PromiseLike<Bar[]>;
let fooArrThen: PromiseLike<Foo[]>;
let barArrThen: PromiseLike<Bar[]>;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
var numPromArr: Promise<number>[];
var strPromArr: Promise<string>[];
var anyPromArr: Promise<any>[];
let numPromArr: Promise<number>[];
let strPromArr: Promise<string>[];
let anyPromArr: Promise<any>[];
var fooPromArr: Promise<Foo>[];
var barPromArr: Promise<Bar>[];
let fooPromArr: Promise<Foo>[];
let barPromArr: Promise<Bar>[];
// - - - - - - - - - - - - - - - - -
var numThenArr: PromiseLike<number>[];
var strThenArr: PromiseLike<string>[];
var anyThenArr: PromiseLike<any>[];
let numThenArr: PromiseLike<number>[];
let strThenArr: PromiseLike<string>[];
let anyThenArr: PromiseLike<any>[];
var fooThenArr: PromiseLike<Foo>[];
var barThenArr: PromiseLike<Bar>[];
let fooThenArr: PromiseLike<Foo>[];
let barThenArr: PromiseLike<Bar>[];
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// booya!
var fooThenArrThen: PromiseLike<PromiseLike<Foo>[]>;
var barThenArrThen: PromiseLike<PromiseLike<Bar>[]>;
let fooThenArrThen: PromiseLike<PromiseLike<Foo>[]>;
let barThenArrThen: PromiseLike<PromiseLike<Bar>[]>;
var fooResolver: Promise.Resolver<Foo>;
var barResolver: Promise.Resolver<Bar>;
let fooResolver: Promise.Resolver<Foo>;
let barResolver: Promise.Resolver<Bar>;
var fooInspection: Promise.Inspection<Foo>;
var fooInspectionPromise: Promise<Promise.Inspection<Foo>>;
let fooInspection: Promise.Inspection<Foo>;
let fooInspectionPromise: Promise<Promise.Inspection<Foo>>;
var fooInspectionArrProm: Promise<Promise.Inspection<Foo>[]>;
var barInspectionArrProm: Promise<Promise.Inspection<Bar>[]>;
let fooInspectionArrProm: Promise<Promise.Inspection<Foo>[]>;
let barInspectionArrProm: Promise<Promise.Inspection<Bar>[]>;
var BlueBird: typeof Promise;
let BlueBird: typeof Promise;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
var version: string = Promise.version;
let version: string = Promise.version;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
var nodeCallbackFunc = (callback: (err: any, result: string) => void) => {}
var nodeCallbackFuncErrorOnly = (callback: (err: any) => void) => {}
let nodeCallbackFunc = (callback: (err: any, result: string) => void) => {};
let nodeCallbackFuncErrorOnly = (callback: (err: any) => void) => {};
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -200,9 +200,7 @@ fooResolver.resolve(foo);
fooResolver.reject(err);
fooResolver.callback = (err: any, value: Foo) => {
};
fooResolver.callback = (err: any, value: Foo) => {};
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -239,7 +237,7 @@ barProm = fooProm.then((value: Foo) => {
});
barProm = barProm.then((value: Bar) => {
if (value) return value;
var b:Bar;
let b: Bar;
return Promise.resolve(b);
});
@ -282,7 +280,7 @@ fooProm = fooProm.caught((error: any) => {
});
fooProm = fooProm.catch((reason: any) => {
//handle multiple valid return types simultaneously
// handle multiple valid return types simultaneously
if (foo === null) {
return;
} else if (!reason) {
@ -341,22 +339,22 @@ fooOrBarProm = fooProm.caught(Promise.CancellationError, (reason: any) => {
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class CustomError extends Error {
public customField: number;
customField: number;
}
fooProm = fooProm.catch(CustomError, reason => {
let a: number = reason.customField
})
let a: number = reason.customField;
});
{
class CustomErrorWithConstructor extends Error {
constructor(public arg1: boolean, public arg2: number) {
super();
};
}
}
fooProm = fooProm.catch(CustomErrorWithConstructor, reason => {
let a: boolean = reason.arg1;
let b: number = reason.arg2;
})
});
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -527,7 +525,7 @@ bool = fooProm.isResolved();
anyProm = fooProm.call(str);
anyProm = fooProm.call(str, 1, 2, 3);
//TODO enable get() test when implemented
// TODO enable get() test when implemented
// barProm = fooProm.get(str);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -573,7 +571,7 @@ barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar, twotwo: Foo) => {
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//TODO fix collection inference
// TODO fix collection inference
barArrProm = fooProm.all<Bar>();
fooInspectionPromise = fooProm.reflect();
@ -583,16 +581,16 @@ barProm = fooProm.race<Bar>();
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
var propsValue: { num: number, str: string };
Promise.resolve({ num: 1, str: Promise.resolve('a') }).props().then(val => { propsValue = val });
Promise.props({ num: 1, str: Promise.resolve('a') }).then(val => { propsValue = val });
Promise.props(Promise.props({ num: 1, str: Promise.resolve('a') })).then(val => { propsValue = val });
let propsValue: { num: number, str: string };
Promise.resolve({ num: 1, str: Promise.resolve('a') }).props().then(val => { propsValue = val; });
Promise.props({ num: 1, str: Promise.resolve('a') }).then(val => { propsValue = val; });
Promise.props(Promise.props({ num: 1, str: Promise.resolve('a') })).then(val => { propsValue = val; });
var propsMapValue: Map<number, string>;
Promise.resolve(new Map<number, string>()).props().then(val => { propsMapValue = val });
Promise.resolve(new Map<number, PromiseLike<string>>()).props().then(val => { propsMapValue = val });
Promise.props(new Map<number, string>()).then(val => { propsMapValue = val });
Promise.props(new Map<number, PromiseLike<string>>()).then(val => { propsMapValue = val });
let propsMapValue: Map<number, string>;
Promise.resolve(new Map<number, string>()).props().then(val => { propsMapValue = val; });
Promise.resolve(new Map<number, PromiseLike<string>>()).props().then(val => { propsMapValue = val; });
Promise.props(new Map<number, string>()).then(val => { propsMapValue = val; });
Promise.props(new Map<number, PromiseLike<string>>()).then(val => { propsMapValue = val; });
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -620,7 +618,7 @@ Promise.all([fooProm, barProm, fooProm]).then(result => {
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//TODO fix collection inference
// TODO fix collection inference
barArrProm = fooArrProm.map<Foo, Bar>((item: Foo, index: number, arrayLength: number) => {
return bar;
@ -649,7 +647,6 @@ barArrProm = fooArrProm.mapSeries<Foo, Bar>((item: Foo) => {
return bar;
});
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
barProm = fooArrProm.reduce<Foo, Bar>((memo: Bar, item: Foo, index: number, arrayLength: number) => {
@ -755,9 +752,7 @@ fooProm = Promise.attempt(() => {
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
asyncfunc = Promise.method(function () {
});
asyncfunc = Promise.method(() => {});
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@ -785,7 +780,7 @@ Promise.longStackTraces();
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//TODO enable delay
// TODO enable delay
fooProm = Promise.delay(num, fooThen);
fooProm = Promise.delay(num, foo);
@ -809,7 +804,7 @@ anyProm = Promise.fromCallback(callback => nodeCallbackFuncErrorOnly(callback),
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
declare var util: any;
declare let util: any;
function defaultFilter(name: string, func: Function) {
return util.isIdentifier(name) &&
@ -820,11 +815,11 @@ function defaultFilter(name: string, func: Function) {
function DOMPromisifier(originalMethod: Function) {
// return a function
return function promisified() {
var args = [].slice.call(arguments);
let args = [].slice.call(arguments);
// Needed so that the original method can be called with the correct receiver
var self = this;
let self = this;
// which returns a promise
return new Promise(function(resolve, reject) {
return new Promise((resolve, reject) => {
args.push(resolve, reject);
originalMethod.apply(self, args);
});
@ -839,11 +834,11 @@ obj = Promise.promisifyAll(obj, {
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const generator = function* (a: number, b: string) {return "string"}
const generator = function*(a: number, b: string) { return "string"; };
const coroutine = Promise.coroutine<string, number, string>(generator);
coroutine(5, "foo").then((x: string) => {});
const coroutineCustomYield = Promise.coroutine(generator, { yieldHandler: (value) => "whatever" })
const coroutineCustomYield = Promise.coroutine(generator, { yieldHandler: (value) => "whatever" });
/*
barProm = Promise.spawn<number>(f);
*/
@ -852,13 +847,11 @@ const coroutineCustomYield = Promise.coroutine(generator, { yieldHandler: (value
BlueBird = Promise.getNewLibraryCopy();
BlueBird = Promise.noConflict();
Promise.onPossiblyUnhandledRejection((reason: any) => {
});
Promise.onPossiblyUnhandledRejection((reason: any) => {});
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//TODO expand tests to overloads
// TODO expand tests to overloads
fooArrProm = Promise.all(fooThenArrThen);
fooArrProm = Promise.all(fooArrProm);
fooArrProm = Promise.all(fooThenArr);
@ -871,7 +864,7 @@ objProm = Promise.props(obj);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//TODO expand tests to overloads
// TODO expand tests to overloads
fooProm = Promise.any(fooThenArrThen);
fooProm = Promise.any(fooArrProm);
fooProm = Promise.any(fooThenArr);
@ -879,7 +872,7 @@ fooProm = Promise.any(fooArr);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//TODO expand tests to overloads
// TODO expand tests to overloads
fooProm = Promise.race(fooThenArrThen);
fooProm = Promise.race(fooArrProm);
fooProm = Promise.race(fooThenArr);
@ -887,7 +880,7 @@ fooProm = Promise.race(fooArr);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//TODO expand tests to overloads
// TODO expand tests to overloads
fooArrProm = Promise.some(fooThenArrThen, num);
fooArrProm = Promise.some(fooThenArr, num);
fooArrProm = Promise.some(fooArr, num);
@ -1090,7 +1083,6 @@ barArrProm = Promise.mapSeries(fooArrThen, (item: Foo, index: number, arrayLengt
return barThen;
});
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// fooThenArr
@ -1108,7 +1100,6 @@ barArrProm = Promise.mapSeries(fooThenArr, (item: Foo, index: number, arrayLengt
return barThen;
});
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// fooArr
@ -1126,7 +1117,6 @@ barArrProm = Promise.mapSeries(fooArr, (item: Foo, index: number, arrayLength: n
return barThen;
});
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// reduce()

13
types/bluebird/index.d.ts vendored
View File

@ -1,4 +1,4 @@
// Type definitions for bluebird 3.5.0
// Type definitions for bluebird 3.5
// Project: https://github.com/petkaantonov/bluebird
// Definitions by: Leonard Hecker <https://github.com/lhecker>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@ -1006,7 +1006,7 @@ declare class Bluebird<R> implements PromiseLike<R>, Bluebird.Inspection<R> {
* Create a new promise. The passed in function will receive functions `resolve` and `reject` as its arguments which can be called to seal the fate of the created promise.
* If promise cancellation is enabled, passed in function will receive one more function argument `onCancel` that allows to register an optional cancellation callback.
*/
static Promise: typeof Bluebird
static Promise: typeof Bluebird;
/**
* The version number of the library
@ -1030,12 +1030,12 @@ declare namespace Bluebird {
}
export interface PromisifyAllOptions extends PromisifyOptions {
suffix?: string;
filter?: (name: string, func: (...args: any[]) => any, target?: any, passesDefaultFilter?: boolean) => boolean;
filter?(name: string, func: (...args: any[]) => any, target?: any, passesDefaultFilter?: boolean): boolean;
// The promisifier gets a reference to the original method and should return a function which returns a promise
promisifier?: (originalMethod: (...args: any[]) => any, defaultPromisifer: (...args: any[]) => (...args: any[]) => Bluebird<any>) => () => PromiseLike<any>;
promisifier?(originalMethod: (...args: any[]) => any, defaultPromisifer: (...args: any[]) => (...args: any[]) => Bluebird<any>): () => PromiseLike<any>;
}
export interface CoroutineOptions {
yieldHandler: (value: any) => any;
yieldHandler(value: any): any;
}
/**
@ -1088,7 +1088,6 @@ declare namespace Bluebird {
reverse(): AggregateError;
}
/**
* returned by `Bluebird.disposer()`.
*/
@ -1123,7 +1122,7 @@ declare namespace Bluebird {
* If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values.
*/
// TODO specify resolver callback
callback: (err: any, value: R, ...values: R[]) => void;
callback(err: any, value: R, ...values: R[]): void;
}
export interface Inspection<R> {

16
types/bluebird/tslint.json
View File

@ -4,26 +4,14 @@
"adjacent-overload-signatures": false,
"array-type": false,
"ban-types": false,
"comment-format": false,
"dt-header": false,
"max-line-length": false,
"member-access": false,
"no-consecutive-blank-lines": false,
"no-padding": false,
"no-unnecessary-callback-wrapper": false,
"no-unnecessary-generics": false,
"no-var-keyword": false,
"no-void-expression": false,
"one-line": false,
"only-arrow-functions": false,
"prefer-const": false,
"prefer-method-signature": false,
"semicolon": false,
"space-before-function-paren": false,
"strict-export-declare-modifiers": false,
"typedef-whitespace": false,
"unified-signatures": false,
"void-return": false,
"whitespace": false
"void-return": false
}
}
}