From 6458454951a595bc1fd93a6ae7f1c6ef57df56ff Mon Sep 17 00:00:00 2001 From: James Kyle Date: Mon, 5 Sep 2016 00:18:48 +0800 Subject: [PATCH] Add Flow type definition (#1007) --- index.js.flow | 218 ++++++++++++++++++++++++++++++++++++++++++++++++++ package.json | 1 + 2 files changed, 219 insertions(+) create mode 100644 index.js.flow diff --git a/index.js.flow b/index.js.flow new file mode 100644 index 000000000..7ee249c32 --- /dev/null +++ b/index.js.flow @@ -0,0 +1,218 @@ +/* @flow */ + +/** + * Misc Setup Types + */ + +type PromiseLike = { + then( + onFulfill?: (value: R) => Promise | U, + onReject?: (error: any) => Promise | U + ): Promise; +} + +type ObservableLike = { + subscribe(observer: (value: {}) => void): void; +}; + +type SpecialReturnTypes = + | PromiseLike + | Iterator + | ObservableLike; + +type Constructor = Class<{ + constructor(...args: Array): any +}>; + +type ErrorValidator = + | Constructor + | RegExp + | string + | ((error: any) => boolean); + +/** + * Asertion Types + */ + +type AssertContext = { + // Passing assertion. + pass(message?: string): void; + // Failing assertion. + fail(message?: string): void; + // Assert that value is truthy. + truthy(value: mixed, message?: string): void; + // Assert that value is falsy. + falsy(value: mixed, message?: string): void; + // DEPRECATED, use `truthy`. Assert that value is truthy. + ok(value: mixed, message?: string): void; + // DEPRECATED, use `falsy`. Assert that value is falsy. + notOk(value: mixed, message?: string): void; + // Assert that value is true. + true(value: boolean, message?: string): void; + // Assert that value is false. + false(value: boolean, message?: string): void; + // Assert that value is equal to expected. + is(value: U, expected: U, message?: string): void; + // Assert that value is not equal to expected. + not(value: U, expected: U, message?: string): void; + // Assert that value is deep equal to expected. + deepEqual(value: U, expected: U, message?: string): void; + // Assert that value is not deep equal to expected. + notDeepEqual(value: U, expected: U, message?: string): void; + // Assert that function throws an error or promise rejects. + // DEPRECATED, use `deepEqual`. Assert that value is deep equal to expected. + // @param error Can be a constructor, regex, error message or validation function. + same(value: U, expected: U, message?: string): void; + // DEPRECATED use `notDeepEqual`. Assert that value is not deep equal to expected. + notSame(value: U, expected: U, message?: string): void; + // Assert that function throws an error or promise rejects. + // @param error Can be a constructor, regex, error message or validation function. + throws(value: PromiseLike, error?: ErrorValidator, message?: string): Promise; + throws(value: () => void, error?: ErrorValidator, message?: string): mixed; + // Assert that function doesn't throw an error or promise resolves. + notThrows(value: PromiseLike, message?: string): Promise; + notThrows(value: () => void, message?: string): void; + // Assert that contents matches regex. + regex(contents: string, regex: RegExp, message?: string): void; + // Assert that contents does not match regex. + notRegex(contents: string, regex: RegExp, message?: string): void; + // Assert that error is falsy. + ifError(error: any, message?: string): void; +}; + +/** + * Context Types + */ + +type TestContext = AssertContext & { + plan(count: number): void; + skip: AssertContext; +}; +type CallbackTestContext = TestContext & { end(): void; }; +type ContextualTestContext = TestContext & { context: any; }; +type ContextualCallbackTestContext = CallbackTestContext & { context: any; }; + +/** + * Test Types + */ + +type Test = (t: TestContext) => SpecialReturnTypes | void; +type CallbackTest = (t: CallbackTestContext) => void; +type ContextualTest = (t: ContextualTestContext) => SpecialReturnTypes | void; +type ContextualCallbackTest = (t: ContextualCallbackTestContext) => void; + +/** + * Macro Types + */ + +type Macro = { + (t: T, ...args: Array): void; + title?: (providedTitle: string, ...args: Array) => string; +}; + +type Macros = + | Macro + | Array>; + +/** + * Method Types + */ + +type TestMethod = { + ( implementation: Test): void; + (name: string, implementation: Test): void; + ( implementation: Macros, ...args: Array): void; + (name: string, implementation: Macros, ...args: Array): void; + + serial : TestMethod; + before : TestMethod; + after : TestMethod; + skip : TestMethod; + todo : TestMethod; + failing : TestMethod; + only : TestMethod; + beforeEach : TestMethod; + afterEach : TestMethod; + cb : CallbackTestMethod; + always : TestMethod; +}; + +type CallbackTestMethod = { + ( implementation: CallbackTest): void; + (name: string, implementation: CallbackTest): void; + ( implementation: Macros, ...args: Array): void; + (name: string, implementation: Macros, ...args: Array): void; + + serial : CallbackTestMethod; + before : CallbackTestMethod; + after : CallbackTestMethod; + skip : CallbackTestMethod; + todo : CallbackTestMethod; + failing : CallbackTestMethod; + only : CallbackTestMethod; + beforeEach : CallbackTestMethod; + afterEach : CallbackTestMethod; + cb : CallbackTestMethod; + always : CallbackTestMethod; +}; + +type ContextualTestMethod = { + ( implementation: ContextualTest): void; + (name: string, implementation: ContextualTest): void; + ( implementation: Macros, ...args: Array): void; + (name: string, implementation: Macros, ...args: Array): void; + + serial : ContextualTestMethod; + before : ContextualTestMethod; + after : ContextualTestMethod; + skip : ContextualTestMethod; + todo : ContextualTestMethod; + failing : ContextualTestMethod; + only : ContextualTestMethod; + beforeEach : ContextualTestMethod; + afterEach : ContextualTestMethod; + cb : ContextualCallbackTestMethod; + always : ContextualTestMethod; +}; + +type ContextualCallbackTestMethod = { + ( implementation: ContextualCallbackTest): void; + (name: string, implementation: ContextualCallbackTest): void; + ( implementation: Macros, ...args: Array): void; + (name: string, implementation: Macros, ...args: Array): void; + + serial : ContextualCallbackTestMethod; + before : ContextualCallbackTestMethod; + after : ContextualCallbackTestMethod; + skip : ContextualCallbackTestMethod; + todo : ContextualCallbackTestMethod; + failing : ContextualCallbackTestMethod; + only : ContextualCallbackTestMethod; + beforeEach : ContextualCallbackTestMethod; + afterEach : ContextualCallbackTestMethod; + cb : ContextualCallbackTestMethod; + always : ContextualCallbackTestMethod; +}; + +/** + * Public API + */ + +declare module.exports: { + ( run: ContextualTest): void; + (name: string, run: ContextualTest): void; + ( run: Macros, ...args: Array): void; + (name: string, run: Macros, ...args: Array): void; + + beforeEach : TestMethod; + afterEach : TestMethod; + serial : ContextualTestMethod; + before : ContextualTestMethod; + after : ContextualTestMethod; + skip : ContextualTestMethod; + todo : ContextualTestMethod; + failing : ContextualTestMethod; + only : ContextualTestMethod; + cb : ContextualCallbackTestMethod; + always : ContextualTestMethod; +}; diff --git a/package.json b/package.json index dffb75cb2..612210003 100644 --- a/package.json +++ b/package.json @@ -52,6 +52,7 @@ "files": [ "lib", "*.js", + "*.js.flow", "types/generated.d.ts" ], "keywords": [