[changed] updated flow ignore list and created interface files for al…

…l of the project dependencies

.flowconfig

@@ -1,17 +1,15 @@
 [ignore]
-.*/invalidPackageJson/*
-.*/build/*
-.*/node_modules/.*/test/*
-.*/node_modules/.*/spec/*
-config/*
-coverage/*
-docs/*
-interfaces/*
+.*/node_modules/*
+.*/lib/*
+.*/config/*
+.*/coverage/*
+.*/docs/*
+.*/interfaces/*
 
 [include]
 
 [libs]
 interfaces/
 
 [options]
-suppress_comment=.*@noflow.*
+suppress_comment=.*@flowignore.*

interfaces/autoprefixer.js

@@ -0,0 +1 @@
+declare module 'autoprefixer' {}

interfaces/babel-core.js

@@ -0,0 +1,4 @@
+declare module 'babel-core' {
+  declare function transformFile(file: string, options: Object,
+                                 callback: (error: ?string, result: {code: string, map: string}) => void): void;
+}

interfaces/clean-css.js

@@ -0,0 +1,8 @@
+type CleanCSSResult = {errors: Array<string>, warnings: Array<string>, styles: string, sourceMap: string};
+
+declare module 'clean-css' {
+  declare class exports {
+    constructor(config: Object): void;
+    minify(code: string): CleanCSSResult;
+  }
+}

interfaces/eslint.js

@@ -0,0 +1,10 @@
+type ESLintMessage = {message: string, ruleId?: string, line: number, column: number, filePath: string};
+type ESLintResult = {filePath: string, messages: Array<ESLintMessage>};
+
+declare module 'eslint' {
+  declare class CLIEngine {
+    options: {rules: Object};
+    constructor(config: Object): void;
+    executeOnFiles(files: Array<string>): {results: Array<ESLintResult>}
+  }
+}

interfaces/fb-watchman.js

@@ -0,0 +1,8 @@
+import EventEmitter from 'events';
+
+declare module 'fb-watchman' {
+  declare class Client extends EventEmitter {
+    capabilityCheck(config: Object, callback: (error: ?string) => void): void;
+    command(cmd: Array<any>, callback: (error: ?string, result: Object) => void): void;
+  }
+}

interfaces/jasmine.js

@@ -1,7 +1,28 @@
-declare function describe(title: string, callback: Function): any;
-declare function beforeEach(callback: Function): any;
-declare function afterEach(callback: Function): any;
-declare function it(title: string, callback: Function): any;
-declare function expect(obj: any): any;
-declare function spyOn(obj: any, fn: string): any;
-declare var jasmine: Object;
+type Spy = {
+  and: {
+    callFake: (callback: (...args: Array<any>) => any) => Spy,
+    returnValue: (obj: any) => Spy,
+    callThrough: () => Spy
+  },
+  calls: {count: () => number}
+};
+type Match = {
+  not: Match,
+  toBe: (obj: any) => void,
+  toEqual: (obj: any) => void,
+  toBeTruthy: () => void,
+  toHaveBeenCalled: () => void,
+  toHaveBeenCalledWith: (...args: Array<any>) => void
+};
+
+declare function describe(title: string, callback: () => void): void;
+declare function beforeEach(callback: () => void): void;
+declare function afterEach(callback: () => void): void;
+declare function it(title: string, callback: () => void): void;
+declare function expect(obj: any): Match;
+declare function spyOn(obj: any, fn: string): Spy;
+declare var jasmine: {
+  createSpy: (name: string) => Spy,
+  any: (obj: any) => any,
+  objectContaining: (obj: Object) => void
+};

interfaces/js-yaml.js

@@ -0,0 +1,3 @@
+declare module 'js-yaml' {
+  declare function safeLoad(yaml: string, config: {filename: string}): Object;
+}

interfaces/memory-fs.js

@@ -0,0 +1,5 @@
+declare module 'memory-fs' {
+  declare class exports {
+    readFileSync(path: string): {toString: () => string};
+  }
+}

interfaces/mkdirp.js

@@ -0,0 +1,3 @@
+declare module 'mkdirp' {
+  declare var exports: (path: string, callback: (error: ?string) => void) => void;
+}

interfaces/node-sass-import-once.js

@@ -0,0 +1 @@
+declare module 'node-sass-import-once' {}

interfaces/node-sass.js

@@ -0,0 +1,6 @@
+type NodeSassError = {message: string, file: string, line: number, column: number};
+type NodeSassCallback = (error: ?NodeSassError, result: {css: string, map: string}) => void;
+
+declare module 'node-sass' {
+  declare function render(options: Object, callback: NodeSassCallback): void;
+}

interfaces/postcss.js

@@ -0,0 +1,6 @@
+type PostCSSResult = {css: string, map: Object, warnings: () => Array<string>};
+type PostCSSPromise = {then: (callback: (result: PostCSSResult) => void) => void};
+
+declare module 'postcss' {
+  declare var exports: (plugins: Array<any>) => {process: (code: string, config: Object) => PostCSSPromise};
+}

interfaces/proxyquire.js

@@ -0,0 +1,3 @@
+declare module 'proxyquire' {
+  declare var exports: (name: string, options: Object) => any;
+}

interfaces/tiny-lr.js

@@ -0,0 +1,3 @@
+declare module 'tiny-lr' {
+  declare var exports: () => {changed: (config: Object) => void, listen: (port: number) => void};
+}

interfaces/uglify-js.js

@@ -0,0 +1,3 @@
+declare module 'uglify-js' {
+  declare function minify(file: string, config: Object): {code: string, map: string};
+}

interfaces/webcompiler.js

@@ -0,0 +1,71 @@
+type NativeProcessCallback = (stderr: ?string, stdout: string) => void;
+type DocumentationConfig = {inputDir?: string, outputDir?: string, readMe?: string, template?: string,
+  jsdocConfig: ?string};
+type YAMLCallback = (error: ?string, data: Object) => void;
+type JSLintError = {message: string, ruleId?: string, filePath: string, line: number, column: number};
+type JSLintCallback = (errors: ?Array<JSLintError>) => void;
+type ProgramData = {code: string, map: string};
+type AutoprefixCallback = (data: ProgramData) => void;
+
+declare module 'webcompiler' {
+
+  declare class NativeProcess {
+    constructor(task: string): void;
+    run(callback: ?NativeProcessCallback, args: ?Array<string>, opts: ?Object): void;
+    kill(): void;
+  }
+
+  declare class Documentation {
+    constructor(config: ?DocumentationConfig): void;
+    run(callback: () => void): void;
+  }
+
+  declare function watch(dir: string, type: string, callback: () => void): void;
+  declare function yaml(filename: string, callback: YAMLCallback): void;
+
+  declare class JS {
+    constructor(babelOptions: ?Object, lintRules: ?Object): void;
+    typecheck(callback: () => void): void;
+    lint(paths: Array<string>, callback: () => void): void;
+    be(inPath: string, outPath: string, lintPaths: ?Array<string>, callback: ?() => void): void;
+    fe(inPath: string, outPath: string, lintPaths: ?Array<string>, callback: ?() => void): void;
+  }
+
+  declare class SASS {
+    constructor(includePaths: ?Array<string>, excludeLinter: ?Array<string>, importOnceOptions: ?Object): void;
+    lint(paths: Array<string>, callback: () => void): void;
+    fe(inPath: string, outPath: string, lintPaths: ?Array<string>, callback: ?() => void): void;
+  }
+
+  declare class DevServer {
+    constructor(script: string, style: string, devDir: string, port: ?number, react: ?boolean): void;
+    watchSASS(watchDir: string): void;
+    watchJS(): void;
+    run(watchDir: string): void;
+  }
+
+  declare class JSLint {
+    constructor(rules: ?Object): void;
+    run(paths: Array<string>, callback: JSLintCallback): void;
+  }
+
+  declare class JSCompiler {
+    constructor(options: ?Object): void;
+    minify(path: string, data: ProgramData): ProgramData;
+    be(inPath: string, outPath: string, callback: ?() => void): void;
+    fe(inPath: string, outPath: string, callback: ?() => void): void;
+  }
+
+  declare class SASSLint {
+    constructor(...excludeLinter: Array<string>): void;
+    run(paths: Array<string>, callback: NativeProcessCallback): void;
+  }
+
+  declare class SASSCompiler {
+    constructor(includePaths: ?Array<string>, importOnceOptions: ?Object): void;
+    minify(path: string, data: ProgramData): ?ProgramData;
+    autoprefix(path: string, data: ProgramData, callback: AutoprefixCallback): void;
+    fe(inPath: string, outPath: string, callback: ?() => void): void;
+  }
+
+}

interfaces/webpack-dev-server.js

@@ -0,0 +1,7 @@
+declare module 'webpack-dev-server' {
+  declare class exports {
+    app: {get: (path: string, callback: (req: any, res: {send: (data: string) => void}) => void) => void};
+    constructor(webpack: Object): void;
+    listen(port: number, host: string, callback: (error: ?string) => void): void;
+  }
+}

interfaces/webpack.js

@@ -0,0 +1,6 @@
+type WebPackStats = {toJson: () => {errors: Array<string>, warnings: Array<string>}};
+type WebPackCallback = (error: ?string, stats: WebPackStats) => void;
+
+declare module 'webpack' {
+  declare var exports: (config: Object, callback: ?WebPackCallback) => Object;
+}