From 7ae38906926dc09bc10670c361af0d2bf0050426 Mon Sep 17 00:00:00 2001
From: Hsuan Lee <hsuan@cobinhood.com>
Date: Sat, 19 Jan 2019 18:42:04 +0800
Subject: Update dependency packages

---
 packages/assert/src/globals.d.ts |  6 ---
 packages/assert/src/index.ts     | 97 ----------------------------------------
 2 files changed, 103 deletions(-)
 delete mode 100644 packages/assert/src/globals.d.ts
 delete mode 100644 packages/assert/src/index.ts

(limited to 'packages/assert/src')

diff --git a/packages/assert/src/globals.d.ts b/packages/assert/src/globals.d.ts
deleted file mode 100644
index 94e63a32d..000000000
--- a/packages/assert/src/globals.d.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-declare module '*.json' {
-    const json: any;
-    /* tslint:disable */
-    export default json;
-    /* tslint:enable */
-}
diff --git a/packages/assert/src/index.ts b/packages/assert/src/index.ts
deleted file mode 100644
index 741bd78e1..000000000
--- a/packages/assert/src/index.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { Schema, SchemaValidator } from '@0x/json-schemas';
-import { addressUtils, BigNumber } from '@0x/utils';
-import * as _ from 'lodash';
-import * as validUrl from 'valid-url';
-
-const HEX_REGEX = /^0x[0-9A-F]*$/i;
-
-export const assert = {
-    isBigNumber(variableName: string, value: BigNumber): void {
-        const isBigNumber = BigNumber.isBigNumber(value);
-        assert.assert(isBigNumber, assert.typeAssertionMessage(variableName, 'BigNumber', value));
-    },
-    isValidBaseUnitAmount(variableName: string, value: BigNumber): void {
-        assert.isBigNumber(variableName, value);
-        const isNegative = value.isLessThan(0);
-        assert.assert(!isNegative, `${variableName} cannot be a negative number, found value: ${value.toNumber()}`);
-        const hasDecimals = value.decimalPlaces() !== 0;
-        assert.assert(
-            !hasDecimals,
-            `${variableName} should be in baseUnits (no decimals), found value: ${value.toNumber()}`,
-        );
-    },
-    isString(variableName: string, value: string): void {
-        assert.assert(_.isString(value), assert.typeAssertionMessage(variableName, 'string', value));
-    },
-    isFunction(variableName: string, value: any): void {
-        assert.assert(_.isFunction(value), assert.typeAssertionMessage(variableName, 'function', value));
-    },
-    isHexString(variableName: string, value: string): void {
-        assert.assert(
-            _.isString(value) && HEX_REGEX.test(value),
-            assert.typeAssertionMessage(variableName, 'HexString', value),
-        );
-    },
-    isETHAddressHex(variableName: string, value: string): void {
-        assert.assert(_.isString(value), assert.typeAssertionMessage(variableName, 'string', value));
-        assert.assert(addressUtils.isAddress(value), assert.typeAssertionMessage(variableName, 'ETHAddressHex', value));
-    },
-    doesBelongToStringEnum(
-        variableName: string,
-        value: string,
-        stringEnum: any /* There is no base type for every string enum */,
-    ): void {
-        const enumValues = _.values(stringEnum);
-        const doesBelongToStringEnum = _.includes(enumValues, value);
-        const enumValuesAsStrings = _.map(enumValues, enumValue => `'${enumValue}'`);
-        const enumValuesAsString = enumValuesAsStrings.join(', ');
-        assert.assert(
-            doesBelongToStringEnum,
-            `Expected ${variableName} to be one of: ${enumValuesAsString}, encountered: ${value}`,
-        );
-    },
-    hasAtMostOneUniqueValue(value: any[], errMsg: string): void {
-        assert.assert(_.uniq(value).length <= 1, errMsg);
-    },
-    isNumber(variableName: string, value: number): void {
-        assert.assert(_.isFinite(value), assert.typeAssertionMessage(variableName, 'number', value));
-    },
-    isBoolean(variableName: string, value: boolean): void {
-        assert.assert(_.isBoolean(value), assert.typeAssertionMessage(variableName, 'boolean', value));
-    },
-    isWeb3Provider(variableName: string, value: any): void {
-        const isWeb3Provider = _.isFunction(value.send) || _.isFunction(value.sendAsync);
-        assert.assert(isWeb3Provider, assert.typeAssertionMessage(variableName, 'Provider', value));
-    },
-    doesConformToSchema(variableName: string, value: any, schema: Schema, subSchemas?: Schema[]): void {
-        if (_.isUndefined(value)) {
-            throw new Error(`${variableName} can't be undefined`);
-        }
-        const schemaValidator = new SchemaValidator();
-        if (!_.isUndefined(subSchemas)) {
-            _.map(subSchemas, schemaValidator.addSchema.bind(schemaValidator));
-        }
-        const validationResult = schemaValidator.validate(value, schema);
-        const hasValidationErrors = validationResult.errors.length > 0;
-        const msg = `Expected ${variableName} to conform to schema ${schema.id}
-Encountered: ${JSON.stringify(value, null, '\t')}
-Validation errors: ${validationResult.errors.join(', ')}`;
-        assert.assert(!hasValidationErrors, msg);
-    },
-    isWebUri(variableName: string, value: any): void {
-        const isValidUrl = !_.isUndefined(validUrl.isWebUri(value));
-        assert.assert(isValidUrl, assert.typeAssertionMessage(variableName, 'web uri', value));
-    },
-    isUri(variableName: string, value: any): void {
-        const isValidUri = !_.isUndefined(validUrl.isUri(value));
-        assert.assert(isValidUri, assert.typeAssertionMessage(variableName, 'uri', value));
-    },
-    assert(condition: boolean, message: string): void {
-        if (!condition) {
-            throw new Error(message);
-        }
-    },
-    typeAssertionMessage(variableName: string, type: string, value: any): string {
-        return `Expected ${variableName} to be of type ${type}, encountered: ${value}`;
-    },
-};
-- 
cgit v1.2.3