Merge pull request #319 from 0xProject/feature/final-monorepo

Import last TS packages into the monorepo

README.md

@@ -19,8 +19,11 @@ This repository contains all the 0x developer tools written in TypeScript. Our h
 ### Published Packages
 
 | Package                                                                                | Version                                                                                                                                           | Description                                                        |
-| ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
+| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
 | [`0x.js`](/packages/0x.js)                                                             | [![npm](https://img.shields.io/npm/v/0x.js.svg)](https://www.npmjs.com/package/0x.js)                                                             | A Javascript library for interacting with the 0x protocol          |
+| [`chai-as-promised-typescript-typings`](/packages/chai-as-promised-typescript-typings) | [![npm](https://img.shields.io/npm/v/chai-as-promised-typescript-typings.svg)](https://www.npmjs.com/package/chai-as-promised-typescript-typings) | Chai as promised typescript typings                                |
+| [`chai-typescript-typings`](/packages/chai-typescript-typings)                         | [![npm](https://img.shields.io/npm/v/chai-typescript-typings.svg)](https://www.npmjs.com/package/chai-typescript-typings)                         | Chai typescript typings                                            |
+| [`web3-typescript-typings`](/packages/web3-typescript-typings)                         | [![npm](https://img.shields.io/npm/v/web3-typescript-typings.svg)](https://www.npmjs.com/package/web3-typescript-typings)                         | Web3 typescript typings                                            |
 | [`@0xproject/abi-gen`](/packages/abi-gen)                                              | [![npm](https://img.shields.io/npm/v/@0xproject/abi-gen.svg)](https://www.npmjs.com/package/@0xproject/abi-gen)                                   | Tool to generate TS wrappers from smart contract ABIs              |
 | [`@0xproject/assert`](/packages/assert)                                                | [![npm](https://img.shields.io/npm/v/@0xproject/assert.svg)](https://www.npmjs.com/package/@0xproject/assert)                                     | Type and schema assertions used by our packages                    |
 | [`@0xproject/connect`](/packages/connect)                                              | [![npm](https://img.shields.io/npm/v/@0xproject/connect.svg)](https://www.npmjs.com/package/@0xproject/connect)                                   | A Javascript library for interacting with the standard relayer api |
@@ -29,7 +32,7 @@ This repository contains all the 0x developer tools written in TypeScript. Our h
 | [`@0xproject/tslint-config`](/packages/tslint-config)                                  | [![npm](https://img.shields.io/npm/v/@0xproject/tslint-config.svg)](https://www.npmjs.com/package/@0xproject/tslint-config)                       | Custom 0x development TSLint rules                                 |
 | [`@0xproject/types`](/packages/types)                                                  | [![npm](https://img.shields.io/npm/v/@0xproject/types.svg)](https://www.npmjs.com/package/@0xproject/types)                                       | Shared type declarations                                           |
 | [`@0xproject/utils`](/packages/utils)                                                  | [![npm](https://img.shields.io/npm/v/@0xproject/utils.svg)](https://www.npmjs.com/package/@0xproject/utils)                                       | Shared utilities                                                   |
-| [`@0xproject/web3-wrapper`](/packages/web3-wrapper)   | [![npm](https://img.shields.io/npm/v/@0xproject/web3-wrapper.svg)](https://www.npmjs.com/package/@0xproject/web3-wrapper)   | Web3 wrapper                                                       |
+| [`@0xproject/web3-wrapper`](/packages/web3-wrapper)                                    | [![npm](https://img.shields.io/npm/v/@0xproject/web3-wrapper.svg)](https://www.npmjs.com/package/@0xproject/web3-wrapper)                         | Web3 wrapper                                                       |  |
 
 ### Private Packages
 

packages/0x.js/scripts/postpublish.js

@@ -8,26 +8,21 @@ const S3BucketPath = 's3://0xjs-docs-jsons/';
 
 let tag;
 let version;
-postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
     .then(function(result) {
         tag = result.tag;
         version = result.version;
         const releaseName = postpublish_utils.getReleaseName(subPackageName, version);
-         const assets = [
+        const assets = [__dirname + '/../_bundles/index.js', __dirname + '/../_bundles/index.min.js'];
-             __dirname + '/../_bundles/index.js',
-             __dirname + '/../_bundles/index.min.js',
-         ];
         return postpublish_utils.publishReleaseNotes(tag, releaseName, assets);
     })
     .then(function(release) {
         console.log('POSTPUBLISH: Release successful, generating docs...');
         const jsonFilePath = __dirname + '/../' + postpublish_utils.generatedDocsDirectoryName + '/index.json';
-        return execAsync(
+        return execAsync('JSON_FILE_PATH=' + jsonFilePath + ' PROJECT_DIR=' + __dirname + '/.. yarn docs:json', {
-            'JSON_FILE_PATH=' + jsonFilePath + ' PROJECT_DIR=' + __dirname + '/.. yarn docs:json',
-            {
             cwd,
-            }
+        });
-        );
     })
     .then(function(result) {
         if (result.stderr !== '') {
@@ -39,6 +34,7 @@ postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
         return execAsync('S3_URL=' + s3Url + ' yarn upload_docs_json', {
             cwd,
         });
-    }).catch (function(err) {
+    })
+    .catch(function(err) {
         throw err;
     });

packages/0x.js/src/globals.d.ts

@@ -1,5 +1,3 @@
-/// <reference types='chai-typescript-typings' />
-/// <reference types='chai-as-promised-typescript-typings' />
 declare module 'web3_beta';
 declare module 'chai-bignumber';
 declare module 'dirty-chai';

packages/0x.js/webpack.config.js

@@ -7,10 +7,10 @@ const path = require('path');
 const production = process.env.NODE_ENV === 'production';
 
 let entry = {
-    'index': './src/index.ts',
+    index: './src/index.ts',
 };
 if (production) {
-    entry = _.assign({}, entry, {'index.min': './src/index.ts'});
+    entry = _.assign({}, entry, { 'index.min': './src/index.ts' });
 }
 
 module.exports = {

packages/abi-gen/scripts/postpublish.js

@@ -3,12 +3,13 @@ const packageJSON = require('../package.json');
 
 const subPackageName = packageJSON.name;
 
-postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
     .then(function(result) {
         const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
         const assets = [];
         return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
     })
-    .catch (function(err) {
+    .catch(function(err) {
         throw err;
     });

packages/assert/scripts/postpublish.js

@@ -3,12 +3,13 @@ const packageJSON = require('../package.json');
 
 const subPackageName = packageJSON.name;
 
-postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
     .then(function(result) {
         const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
         const assets = [];
         return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
     })
-    .catch (function(err) {
+    .catch(function(err) {
         throw err;
     });

packages/chai-as-promised-typescript-typings/CHANGELOG.md

@@ -0,0 +1,3 @@
+# CHANGELOG
+
+## v0.x.x - _TBD, 2018_

packages/chai-as-promised-typescript-typings/README.md

@@ -0,0 +1,43 @@
+## chai-as-promised-typescript-typings
+
+Fork of type definitions for chai-as-promised that includes changes made by dirty-chai
+
+## Installation
+
+```bash
+yarn add -D chai-as-promised-typescript-typings
+```
+
+## Usage
+
+Add the following line within an `include` section of your `tsconfig.json`
+
+```json
+"./node_modules/chai-as-promised-typescript-typings/index.d.ts"
+```
+
+## Contributing
+
+We strongly encourage that the community help us make improvements and determine the future direction of the protocol. To report bugs within this package, please create an issue in this repository.
+
+Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
+
+### Install Dependencies
+
+If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them:
+
+```bash
+yarn config set workspaces-experimental true
+```
+
+Then install dependencies
+
+```bash
+yarn install
+```
+
+### Lint
+
+```bash
+yarn lint
+```

packages/chai-as-promised-typescript-typings/index.d.ts

@@ -0,0 +1,268 @@
+// Type definitions for chai-as-promised
+// Project: https://github.com/domenic/chai-as-promised/
+// Definitions by: jt000 <https://github.com/jt000>, Yuki Kokubun <https://github.com/Kuniwak>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module 'chai-as-promised' {
+    function chaiAsPromised(chai: any, utils: any): void;
+    namespace chaiAsPromised {
+
+    }
+    export = chaiAsPromised;
+}
+
+// tslint:disable:no-namespace ban-types member-ordering
+declare namespace Chai {
+    // For BDD API
+    interface Assertion extends LanguageChains, NumericComparison, TypeComparison {
+        eventually: PromisedAssertion;
+        fulfilled: PromisedAssertion;
+        become(expected: any): PromisedAssertion;
+        rejected(): PromisedAssertion;
+        rejectedWith(expected: any, message?: string | RegExp): PromisedAssertion;
+        notify(fn: Function): PromisedAssertion;
+    }
+
+    // Eventually does not have .then(), but PromisedAssertion have.
+    interface Eventually extends PromisedLanguageChains, PromisedNumericComparison, PromisedTypeComparison {
+        // From chai-as-promised
+        become(expected: PromiseLike<any>): PromisedAssertion;
+        fulfilled: PromisedAssertion;
+        rejected: () => PromisedAssertion;
+        rejectedWith(expected: any, message?: string | RegExp): PromisedAssertion;
+        notify(fn: Function): PromisedAssertion;
+
+        // From chai
+        not: PromisedAssertion;
+        deep: PromisedDeep;
+        all: PromisedKeyFilter;
+        a: PromisedTypeComparison;
+        an: PromisedTypeComparison;
+        include: PromisedInclude;
+        contain: PromisedInclude;
+        ok: PromisedAssertion;
+        true: () => PromisedAssertion;
+        false: () => PromisedAssertion;
+        null: PromisedAssertion;
+        undefined: PromisedAssertion;
+        exist: PromisedAssertion;
+        empty: PromisedAssertion;
+        arguments: PromisedAssertion;
+        Arguments: PromisedAssertion;
+        equal: PromisedEqual;
+        equals: PromisedEqual;
+        eq: PromisedEqual;
+        eql: PromisedEqual;
+        eqls: PromisedEqual;
+        property: PromisedProperty;
+        ownProperty: PromisedOwnProperty;
+        haveOwnProperty: PromisedOwnProperty;
+        length: PromisedLength;
+        lengthOf: PromisedLength;
+        match(regexp: RegExp | string, message?: string): PromisedAssertion;
+        string(string: string, message?: string): PromisedAssertion;
+        keys: PromisedKeys;
+        key(string: string): PromisedAssertion;
+        throw: PromisedThrow;
+        throws: PromisedThrow;
+        Throw: PromisedThrow;
+        respondTo(method: string, message?: string): PromisedAssertion;
+        itself: PromisedAssertion;
+        satisfy(matcher: Function, message?: string): PromisedAssertion;
+        closeTo(expected: number, delta: number, message?: string): PromisedAssertion;
+        members: PromisedMembers;
+    }
+
+    interface PromisedAssertion extends Eventually, PromiseLike<any> {}
+
+    interface PromisedLanguageChains {
+        eventually: Eventually;
+
+        // From chai
+        to: PromisedAssertion;
+        be: PromisedAssertion;
+        been: PromisedAssertion;
+        is: PromisedAssertion;
+        that: PromisedAssertion;
+        which: PromisedAssertion;
+        and: PromisedAssertion;
+        has: PromisedAssertion;
+        have: PromisedAssertion;
+        with: PromisedAssertion;
+        at: PromisedAssertion;
+        of: PromisedAssertion;
+        same: PromisedAssertion;
+    }
+
+    interface PromisedNumericComparison {
+        above: PromisedNumberComparer;
+        gt: PromisedNumberComparer;
+        greaterThan: PromisedNumberComparer;
+        least: PromisedNumberComparer;
+        gte: PromisedNumberComparer;
+        below: PromisedNumberComparer;
+        lt: PromisedNumberComparer;
+        lessThan: PromisedNumberComparer;
+        most: PromisedNumberComparer;
+        lte: PromisedNumberComparer;
+        within(start: number, finish: number, message?: string): PromisedAssertion;
+    }
+
+    type PromisedNumberComparer = (value: number, message?: string) => PromisedAssertion;
+
+    interface PromisedTypeComparison {
+        (type: string, message?: string): PromisedAssertion;
+        instanceof: PromisedInstanceOf;
+        instanceOf: PromisedInstanceOf;
+    }
+
+    type PromisedInstanceOf = (constructor: Object, message?: string) => PromisedAssertion;
+
+    interface PromisedDeep {
+        equal: PromisedEqual;
+        include: PromisedInclude;
+        property: PromisedProperty;
+    }
+
+    interface PromisedKeyFilter {
+        keys: PromisedKeys;
+    }
+
+    type PromisedEqual = (value: any, message?: string) => PromisedAssertion;
+
+    type PromisedProperty = (name: string, value?: any, message?: string) => PromisedAssertion;
+
+    type PromisedOwnProperty = (name: string, message?: string) => PromisedAssertion;
+
+    interface PromisedLength extends PromisedLanguageChains, PromisedNumericComparison {
+        (length: number, message?: string): PromisedAssertion;
+    }
+
+    interface PromisedInclude {
+        (value: Object | string | number, message?: string): PromisedAssertion;
+        keys: PromisedKeys;
+        members: PromisedMembers;
+        all: PromisedKeyFilter;
+    }
+
+    interface PromisedKeys {
+        (...keys: string[]): PromisedAssertion;
+        (keys: any[]): PromisedAssertion;
+    }
+
+    interface PromisedThrow {
+        (): PromisedAssertion;
+        (expected: string | RegExp, message?: string): PromisedAssertion;
+        (constructor: Error | Function, expected?: string | RegExp, message?: string): PromisedAssertion;
+    }
+
+    type PromisedMembers = (set: any[], message?: string) => PromisedAssertion;
+
+    // For Assert API
+    interface Assert {
+        eventually: PromisedAssert;
+        isFulfilled(promise: PromiseLike<any>, message?: string): PromiseLike<void>;
+        becomes(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
+        doesNotBecome(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
+        isRejected(promise: PromiseLike<any>, message?: string): PromiseLike<void>;
+        isRejected(promise: PromiseLike<any>, expected: any | RegExp, message?: string): PromiseLike<void>;
+        notify(fn: Function): PromiseLike<void>;
+    }
+
+    export interface PromisedAssert {
+        fail(actual?: any, expected?: any, msg?: string, operator?: string): PromiseLike<void>;
+
+        ok(val: any, msg?: string): PromiseLike<void>;
+        notOk(val: any, msg?: string): PromiseLike<void>;
+
+        equal(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+
+        strictEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notStrictEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+
+        deepEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notDeepEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+
+        isTrue(val: any, msg?: string): PromiseLike<void>;
+        isFalse(val: any, msg?: string): PromiseLike<void>;
+
+        isNull(val: any, msg?: string): PromiseLike<void>;
+        isNotNull(val: any, msg?: string): PromiseLike<void>;
+
+        isUndefined(val: any, msg?: string): PromiseLike<void>;
+        isDefined(val: any, msg?: string): PromiseLike<void>;
+
+        isFunction(val: any, msg?: string): PromiseLike<void>;
+        isNotFunction(val: any, msg?: string): PromiseLike<void>;
+
+        isObject(val: any, msg?: string): PromiseLike<void>;
+        isNotObject(val: any, msg?: string): PromiseLike<void>;
+
+        isArray(val: any, msg?: string): PromiseLike<void>;
+        isNotArray(val: any, msg?: string): PromiseLike<void>;
+
+        isString(val: any, msg?: string): PromiseLike<void>;
+        isNotString(val: any, msg?: string): PromiseLike<void>;
+
+        isNumber(val: any, msg?: string): PromiseLike<void>;
+        isNotNumber(val: any, msg?: string): PromiseLike<void>;
+
+        isBoolean(val: any, msg?: string): PromiseLike<void>;
+        isNotBoolean(val: any, msg?: string): PromiseLike<void>;
+
+        typeOf(val: any, type: string, msg?: string): PromiseLike<void>;
+        notTypeOf(val: any, type: string, msg?: string): PromiseLike<void>;
+
+        instanceOf(val: any, type: Function, msg?: string): PromiseLike<void>;
+        notInstanceOf(val: any, type: Function, msg?: string): PromiseLike<void>;
+
+        include(exp: string | any[], inc: any, msg?: string): PromiseLike<void>;
+
+        notInclude(exp: string | any[], inc: any, msg?: string): PromiseLike<void>;
+
+        match(exp: any, re: RegExp, msg?: string): PromiseLike<void>;
+        notMatch(exp: any, re: RegExp, msg?: string): PromiseLike<void>;
+
+        property(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        notProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        deepProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        notDeepProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+
+        propertyVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+        propertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+
+        deepPropertyVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+        deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+
+        lengthOf(exp: any, len: number, msg?: string): PromiseLike<void>;
+        // alias frenzy
+        throw(fn: Function, msg?: string): PromiseLike<void>;
+        throw(fn: Function, regExp: RegExp): PromiseLike<void>;
+        throw(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        throw(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
+
+        throws(fn: Function, msg?: string): PromiseLike<void>;
+        throws(fn: Function, regExp: RegExp): PromiseLike<void>;
+        throws(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        throws(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
+
+        Throw(fn: Function, msg?: string): PromiseLike<void>;
+        Throw(fn: Function, regExp: RegExp): PromiseLike<void>;
+        Throw(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        Throw(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
+
+        doesNotThrow(fn: Function, msg?: string): PromiseLike<void>;
+        doesNotThrow(fn: Function, regExp: RegExp): PromiseLike<void>;
+        doesNotThrow(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        doesNotThrow(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
+
+        operator(val: any, operator: string, val2: any, msg?: string): PromiseLike<void>;
+        closeTo(act: number, exp: number, delta: number, msg?: string): PromiseLike<void>;
+
+        sameMembers(set1: any[], set2: any[], msg?: string): PromiseLike<void>;
+        includeMembers(set1: any[], set2: any[], msg?: string): PromiseLike<void>;
+
+        ifError(val: any, msg?: string): PromiseLike<void>;
+    }
+}

packages/chai-as-promised-typescript-typings/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "chai-as-promised-typescript-typings",
+    "version": "0.0.3",
+    "description": "Typescript type definitions for chai-as-promised",
+    "main": "index.d.ts",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/0xProject/0x.js.git"
+    },
+    "author": "Fabio Berger",
+    "contributors": ["Leonid Logvinov <logvinov.leon@gmail.com>"],
+    "license": "Apache-2.0",
+    "bugs": {
+        "url": "https://github.com/0xProject/0x.js/issues"
+    },
+    "homepage": "https://github.com/0xProject/0x.js/packages/chai-as-promised-typescript-typings#readme",
+    "dependencies": {
+        "chai-typescript-typings": "^0.0.0"
+    }
+}

packages/chai-as-promised-typescript-typings/scripts/postpublish.js

@@ -0,0 +1,15 @@
+const postpublish_utils = require('../../../scripts/postpublish_utils');
+const packageJSON = require('../package.json');
+
+const subPackageName = packageJSON.name;
+
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
+    .then(function(result) {
+        const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
+        const assets = [];
+        return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
+    })
+    .catch(function(err) {
+        throw err;
+    });

packages/chai-as-promised-typescript-typings/tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": ["tslint-config-0xproject"]
+}

packages/chai-typescript-typings/CHANGELOG.md

@@ -0,0 +1,3 @@
+# CHANGELOG
+
+## v0.x.x - _TBD, 2018_

packages/chai-typescript-typings/README.md

@@ -0,0 +1,43 @@
+## chai-typescript-typings
+
+Fork of type definitions for chai that includes changes made by dirty-chai
+
+## Installation
+
+```bash
+yarn add -D chai-typescript-typings
+```
+
+## Usage
+
+Add the following line within an `include` section of your `tsconfig.json`
+
+```json
+"./node_modules/chai-typescript-typings/index.d.ts"
+```
+
+## Contributing
+
+We strongly encourage that the community help us make improvements and determine the future direction of the protocol. To report bugs within this package, please create an issue in this repository.
+
+Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.
+
+### Install Dependencies
+
+If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them:
+
+```bash
+yarn config set workspaces-experimental true
+```
+
+Then install dependencies
+
+```bash
+yarn install
+```
+
+### Lint
+
+```bash
+yarn lint
+```

packages/chai-typescript-typings/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "chai-typescript-typings",
+    "version": "0.0.1",
+    "description": "Typescript type definitions for chai",
+    "main": "index.d.ts",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/0xProject/0x.js.git"
+    },
+    "license": "Apache-2.0",
+    "bugs": {
+        "url": "https://github.com/0xProject/0x.js/issues"
+    },
+    "homepage": "https://github.com/0xProject/0x.js/packages/chai-typescript-typings#readme"
+}

packages/chai-typescript-typings/scripts/postpublish.js

@@ -0,0 +1,15 @@
+const postpublish_utils = require('../../../scripts/postpublish_utils');
+const packageJSON = require('../package.json');
+
+const subPackageName = packageJSON.name;
+
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
+    .then(function(result) {
+        const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
+        const assets = [];
+        return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
+    })
+    .catch(function(err) {
+        throw err;
+    });

packages/chai-typescript-typings/tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": ["tslint-config-0xproject"]
+}

packages/connect/scripts/postpublish.js

@@ -8,7 +8,8 @@ const S3BucketPath = 's3://connect-docs-jsons/';
 
 let tag;
 let version;
-postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
     .then(function(result) {
         tag = result.tag;
         version = result.version;
@@ -18,12 +19,9 @@ postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
     .then(function(release) {
         console.log('POSTPUBLISH: Release successful, generating docs...');
         const jsonFilePath = __dirname + '/../' + postpublish_utils.generatedDocsDirectoryName + '/index.json';
-        return execAsync(
+        return execAsync('JSON_FILE_PATH=' + jsonFilePath + ' PROJECT_DIR=' + __dirname + '/.. yarn docs:json', {
-            'JSON_FILE_PATH=' + jsonFilePath + ' PROJECT_DIR=' + __dirname + '/.. yarn docs:json',
-            {
             cwd,
-            }
+        });
-        );
     })
     .then(function(result) {
         if (result.stderr !== '') {
@@ -35,6 +33,7 @@ postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
         return execAsync('S3_URL=' + s3Url + ' yarn upload_docs_json', {
             cwd,
         });
-    }).catch (function(err) {
+    })
+    .catch(function(err) {
         throw err;
     });

packages/dev-utils/scripts/postpublish.js

@@ -0,0 +1,15 @@
+const postpublish_utils = require('../../../scripts/postpublish_utils');
+const packageJSON = require('../package.json');
+
+const subPackageName = packageJSON.name;
+
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
+    .then(function(result) {
+        const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
+        const assets = [];
+        return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
+    })
+    .catch(function(err) {
+        throw err;
+    });

packages/json-schemas/scripts/postpublish.js

@@ -3,12 +3,13 @@ const packageJSON = require('../package.json');
 
 const subPackageName = packageJSON.name;
 
-postpublish_utils.getLatestTagAndVersionAsync(subPackageName)
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
     .then(function(result) {
         const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
         const assets = [];
         return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
     })
-    .catch (function(err) {
+    .catch(function(err) {
         throw err;
     });

packages/kovan-faucets/scripts/postpublish.js

@@ -0,0 +1,15 @@
+const postpublish_utils = require('../../../scripts/postpublish_utils');
+const packageJSON = require('../package.json');
+
+const subPackageName = packageJSON.name;
+
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
+    .then(function(result) {
+        const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
+        const assets = [];
+        return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
+    })
+    .catch(function(err) {
+        throw err;
+    });

packages/kovan-faucets/src/ts/error_reporter.ts

@@ -12,9 +12,9 @@ export const errorReporter = {
 
         rollbar.handleUncaughtExceptions(configs.ROLLBAR_ACCESS_KEY);
 
-        process.on('unhandledRejection', (err: Error) => {
+        process.on('unhandledRejection', async (err: Error) => {
             utils.consoleLog(`Uncaught exception ${err}. Stack: ${err.stack}`);
-            this.report(err);
+            await this.reportAsync(err);
             process.exit(1);
         });
     },

packages/monorepo-scripts/scripts/postpublish.js

@@ -0,0 +1,15 @@
+const postpublish_utils = require('../../../scripts/postpublish_utils');
+const packageJSON = require('../package.json');
+
+const subPackageName = packageJSON.name;
+
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
+    .then(function(result) {
+        const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
+        const assets = [];
+        return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
+    })
+    .catch(function(err) {
+        throw err;
+    });

packages/subproviders/src/globals.d.ts

@@ -1,5 +1,3 @@
-/// <reference types='chai-typescript-typings' />
-/// <reference types='chai-as-promised-typescript-typings' />
 declare module 'dirty-chai';
 declare module 'es6-promisify';
 

packages/web3-typescript-typings/package.json

@@ -9,15 +9,15 @@
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/0xProject/web3-typescript-typings.git"
+        "url": "git+https://github.com/0xProject/0x.js.git"
     },
     "author": "Fabio Berger",
     "contributors": ["Leonid Logvinov <logvinov.leon@gmail.com>"],
     "license": "Apache-2.0",
     "bugs": {
-        "url": "https://github.com/0xProject/web3-typescript-typings/issues"
+        "url": "https://github.com/0xProject/0x.js/issues"
     },
-    "homepage": "https://github.com/0xProject/web3-typescript-typings#readme",
+    "homepage": "https://github.com/0xProject/0x.js/packages/web3-typescript-typings#readme",
     "devDependencies": {
         "@types/bignumber.js": "^4.0.2",
         "tslint": "^5.5.0",

packages/web3-typescript-typings/scripts/postpublish.js

@@ -0,0 +1,15 @@
+const postpublish_utils = require('../../../scripts/postpublish_utils');
+const packageJSON = require('../package.json');
+
+const subPackageName = packageJSON.name;
+
+postpublish_utils
+    .getLatestTagAndVersionAsync(subPackageName)
+    .then(function(result) {
+        const releaseName = postpublish_utils.getReleaseName(subPackageName, result.version);
+        const assets = [];
+        return postpublish_utils.publishReleaseNotes(result.tag, releaseName, assets);
+    })
+    .catch(function(err) {
+        throw err;
+    });

yarn.lock

@@ -1680,12 +1680,6 @@ center-align@^0.1.1:
     align-text "^0.1.3"
     lazy-cache "^1.0.3"
 
-chai-as-promised-typescript-typings@^0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/chai-as-promised-typescript-typings/-/chai-as-promised-typescript-typings-0.0.3.tgz#8694287ebe2dd6c18a96667c38151d714d6ecbb6"
-  dependencies:
-    chai-typescript-typings "^0.0.0"
-
 chai-as-promised@^7.1.0:
   version "7.1.1"
   resolved "https://registry.yarnpkg.com/chai-as-promised/-/chai-as-promised-7.1.1.tgz#08645d825deb8696ee61725dbf590c012eb00ca0"
@@ -1700,10 +1694,6 @@ chai-typescript-typings@^0.0.0:
   version "0.0.0"
   resolved "https://registry.yarnpkg.com/chai-typescript-typings/-/chai-typescript-typings-0.0.0.tgz#52e076d72cf29129c94ab1dba6e33ce3828a0724"
 
-chai-typescript-typings@^0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/chai-typescript-typings/-/chai-typescript-typings-0.0.1.tgz#433dee303b0b2978ad0dd03129df0a5afb791274"
-
 chai@^4.0.1:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/chai/-/chai-4.1.2.tgz#0f64584ba642f0f2ace2806279f4f06ca23ad73c"