waves_lib 0.1.0

data/js/node_modules/@waves/parse-json-bignumber/src/parse-json-bignumber.ts

@@ -0,0 +1,511 @@
+const create = function <T>(options?: IOptions<T>) {
+    'use strict';
+
+    var _options = {
+        'strict': false,  // not being strict means do not generate syntax errors for "duplicate key"
+    };
+
+    if (options !== undefined && options !== null) {
+        if (options.strict === true) {
+            _options.strict = true;
+        }
+    }
+
+
+    var at,     // The index of the current character
+        ch,     // The current character
+        escapee = {
+            '"': '"',
+            '\\': '\\',
+            '/': '/',
+            b: '\b',
+            f: '\f',
+            n: '\n',
+            r: '\r',
+            t: '\t'
+        },
+        text,
+
+        error = function (m) {
+
+            throw {
+                name: 'SyntaxError',
+                message: m,
+                at: at,
+                text: text
+            };
+        },
+
+        next = function (c?) {
+
+            if (c && c !== ch) {
+                error('Expected \'' + c + '\' instead of \'' + ch + '\'');
+            }
+
+            ch = text.charAt(at);
+            at += 1;
+            return ch;
+        },
+
+        number = function () {
+
+            var number,
+                string = '';
+
+            if (ch === '-') {
+                string = '-';
+                next('-');
+            }
+            while (ch >= '0' && ch <= '9') {
+                string += ch;
+                next();
+            }
+            if (ch === '.') {
+                string += '.';
+                while (next() && ch >= '0' && ch <= '9') {
+                    string += ch;
+                }
+            }
+            if (ch === 'e' || ch === 'E') {
+                string += ch;
+                next();
+                if (ch === '-' || ch === '+') {
+                    string += ch;
+                    next();
+                }
+                while (ch >= '0' && ch <= '9') {
+                    string += ch;
+                    next();
+                }
+            }
+            number = +string;
+            if (options && options.parse) {
+                return options.parse(string)
+            }
+            if (!isFinite(number)) {
+                error('Bad number');
+            } else {
+                if (string.length > 15) {
+                    return string;
+                } else {
+                    return number;
+                }
+            }
+        },
+
+        string = function () {
+
+            var hex,
+                i,
+                string = '',
+                uffff;
+
+            if (ch === '"') {
+                while (next()) {
+                    if (ch === '"') {
+                        next();
+                        return string;
+                    }
+                    if (ch === '\\') {
+                        next();
+                        if (ch === 'u') {
+                            uffff = 0;
+                            for (i = 0; i < 4; i += 1) {
+                                hex = parseInt(next(), 16);
+                                if (!isFinite(hex)) {
+                                    break;
+                                }
+                                uffff = uffff * 16 + hex;
+                            }
+                            string += String.fromCharCode(uffff);
+                        } else if (typeof escapee[ch] === 'string') {
+                            string += escapee[ch];
+                        } else {
+                            break;
+                        }
+                    } else {
+                        string += ch;
+                    }
+                }
+            }
+            error('Bad string');
+        },
+
+        white = function () {
+
+            while (ch && ch <= ' ') {
+                next();
+            }
+        },
+
+        word = function () {
+
+            switch (ch) {
+                case 't':
+                    next('t');
+                    next('r');
+                    next('u');
+                    next('e');
+                    return true;
+                case 'f':
+                    next('f');
+                    next('a');
+                    next('l');
+                    next('s');
+                    next('e');
+                    return false;
+                case 'n':
+                    next('n');
+                    next('u');
+                    next('l');
+                    next('l');
+                    return null;
+            }
+            error('Unexpected \'' + ch + '\'');
+        },
+
+        value,  // Place holder for the value function.
+
+        array = function () {
+
+            var array = [];
+
+            if (ch === '[') {
+                next('[');
+                white();
+                if (ch === ']') {
+                    next(']');
+                    return array;   // empty array
+                }
+                while (ch) {
+                    array.push(value());
+                    white();
+                    if (ch === ']') {
+                        next(']');
+                        return array;
+                    }
+                    next(',');
+                    white();
+                }
+            }
+            error('Bad array');
+        },
+
+        object = function () {
+
+            var key,
+                object = {};
+
+            if (ch === '{') {
+                next('{');
+                white();
+                if (ch === '}') {
+                    next('}');
+                    return object;   // empty object
+                }
+                while (ch) {
+                    key = string();
+                    white();
+                    next(':');
+                    if (_options.strict === true && Object.hasOwnProperty.call(object, key)) {
+                        error('Duplicate key "' + key + '"');
+                    }
+                    object[key] = value();
+                    white();
+                    if (ch === '}') {
+                        next('}');
+                        return object;
+                    }
+                    next(',');
+                    white();
+                }
+            }
+            error('Bad object');
+        };
+
+    value = function () {
+
+        white();
+        switch (ch) {
+            case '{':
+                return object();
+            case '[':
+                return array();
+            case '"':
+                return string();
+            case '-':
+                return number();
+            default:
+                return ch >= '0' && ch <= '9' ? number() : word();
+        }
+    };
+
+    var rx_escapable = /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
+    var gap;
+    var indent;
+    var meta = { // table of character substitutions
+        '\b': '\\b',
+        '\t': '\\t',
+        '\n': '\\n',
+        '\f': '\\f',
+        '\r': '\\r',
+        '"': '\\"',
+        '\\': '\\\\'
+    };
+    var rep;
+
+
+    function quote(string) {
+
+        // If the string contains no control characters, no quote characters, and no
+        // backslash characters, then we can safely slap some quotes around it.
+        // Otherwise we must also replace the offending characters with safe escape
+        // sequences.
+
+        rx_escapable.lastIndex = 0;
+        return rx_escapable.test(string) ?
+            '"' + string.replace(rx_escapable, function (a) {
+                var c = meta[a];
+                return typeof c === 'string' ?
+                    c :
+                    '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+            }) + '"' :
+            '"' + string + '"';
+    }
+
+    function str(key: string, holder: object): string {
+
+        // Produce a string from holder[key].
+
+        var i; // The loop counter.
+        var k; // The member key.
+        var v; // The member value.
+        var length;
+        var mind = gap;
+        var partial;
+        var value = holder[key];
+        var isBigNumber = options && options.isInstance && options.isInstance(value);
+
+        // Check for NaN and Infinity
+
+        if (isBigNumber && !value.isFinite()) {
+            value = null;
+        }
+
+        // If the value has a toJSON method, call it to obtain a replacement value.
+
+        if (isBigNumber) {
+            value = options.stringify(value);
+        }
+        else if (value && typeof value === 'object' &&
+            typeof value.toJSON === 'function') {
+            value = value.toJSON(key);
+        }
+
+        // If we were called with a replacer function, then call the replacer to
+        // obtain a replacement value.
+
+        if (typeof rep === 'function') {
+            value = rep.call(holder, key, value);
+        }
+
+        // What happens next depends on the value's type.
+
+        switch (typeof value) {
+            case 'string':
+                if (isBigNumber) {
+                    return value;
+                } else {
+                    return quote(value);
+                }
+
+            case 'number':
+
+                // JSON numbers must be finite. Encode non-finite numbers as null.
+
+                return isFinite(value) ?
+                    String(value) :
+                    'null';
+
+            case 'boolean':
+
+                // If the value is a boolean or null, convert it to a string. Note:
+                // typeof null does not produce "null". The case is included here in
+                // the remote chance that this gets fixed someday.
+
+                return String(value);
+
+            // If the type is "object", we might be dealing with an object or an array or
+            // null.
+
+            case 'object':
+
+                // Due to a specification blunder in ECMAScript, typeof null is "object",
+                // so watch out for that case.
+
+                if (!value) {
+                    return 'null';
+                }
+
+                // Make an array to hold the partial results of stringifying this object value.
+
+                gap += indent;
+                partial = [];
+
+                // Is the value an array?
+
+                if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+                    // The value is an array. Stringify every element. Use null as a placeholder
+                    // for non-JSON values.
+
+                    length = value.length;
+                    for (i = 0; i < length; i += 1) {
+                        partial[i] = str(i, value) || 'null';
+                    }
+
+                    // Join all of the elements together, separated with commas, and wrap them in
+                    // brackets.
+
+                    v = partial.length === 0 ?
+                        '[]' :
+                        gap ?
+                            '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
+                            '[' + partial.join(',') + ']';
+                    gap = mind;
+                    return v;
+                }
+
+                // If the replacer is an array, use it to select the members to be stringified.
+
+                if (rep && typeof rep === 'object') {
+                    length = rep.length;
+                    for (i = 0; i < length; i += 1) {
+                        if (typeof rep[i] === 'string') {
+                            k = rep[i];
+                            v = str(k, value);
+                            if (v) {
+                                partial.push(quote(k) + (
+                                    gap ?
+                                        ': ' :
+                                        ':'
+                                ) + v);
+                            }
+                        }
+                    }
+                } else {
+
+                    // Otherwise, iterate through all of the keys in the object.
+
+                    for (k in value) {
+                        if (Object.prototype.hasOwnProperty.call(value, k)) {
+                            v = str(k, value);
+                            if (v) {
+                                partial.push(quote(k) + (
+                                    gap ?
+                                        ': ' :
+                                        ':'
+                                ) + v);
+                            }
+                        }
+                    }
+                }
+
+                // Join all of the member texts together, separated with commas,
+                // and wrap them in braces.
+
+                v = partial.length === 0 ?
+                    '{}' :
+                    gap ?
+                        '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
+                        '{' + partial.join(',') + '}';
+                gap = mind;
+                return v;
+        }
+    }
+
+    const stringify = (value: any, replacer?: ((holder: object, key: string, value: any) => string) | string[], space?: number | string): string => {
+
+        // The stringify method takes a value and an optional replacer, and an optional
+        // space parameter, and returns a JSON text. The replacer can be a function
+        // that can replace values, or an array of strings that will select the keys.
+        // A default replacer method can be provided. Use of the space parameter can
+        // produce text that is more easily readable.
+
+        var i;
+        gap = '';
+        indent = '';
+
+        // If the space parameter is a number, make an indent string containing that
+        // many spaces.
+
+        if (typeof space === 'number') {
+            for (i = 0; i < space; i += 1) {
+                indent += ' ';
+            }
+
+            // If the space parameter is a string, it will be used as the indent string.
+
+        } else if (typeof space === 'string') {
+            indent = space;
+        }
+
+        // If there is a replacer, it must be a function or an array.
+        // Otherwise, throw an error.
+
+        rep = replacer;
+        if (replacer && typeof replacer !== 'function' &&
+            (typeof replacer !== 'object' ||
+                typeof replacer.length !== 'number')) {
+            throw new Error('JSON.stringify');
+        }
+
+        // Make a fake root object containing our value under the key of "".
+        // Return the result of stringifying the value.
+
+        return str('', {
+            '': value
+        });
+    };
+
+    const parse = function (source: string, reviver?: (holder: object, key: string, value: any) => any) {
+
+        var result;
+
+        text = source + '';
+        at = 0;
+        ch = ' ';
+        result = value();
+        white();
+        if (ch) {
+            error('Syntax error');
+        }
+        return typeof reviver === 'function'
+            ? (function walk(holder, key) {
+                var k, v, value = holder[key];
+                if (value && typeof value === 'object') {
+                    Object.keys(value).forEach(function (k) {
+                        v = walk(value, k);
+                        if (v !== undefined) {
+                            value[k] = v;
+                        } else {
+                            delete value[k];
+                        }
+                    });
+                }
+                return reviver.call(holder, key, value);
+            }({'': result}, ''))
+            : result;
+    };
+
+    return {parse, stringify};
+};
+
+export = create;
+
+interface IOptions<T> {
+    strict: boolean;
+    parse: (long: string) => T;
+    stringify: (long: T) => string;
+    isInstance: (some: any) => some is T;
+}

data/js/node_modules/@waves/parse-json-bignumber/test/index.ts

@@ -0,0 +1,130 @@
+import * as create from '../src/parse-json-bignumber';
+import BigNumber from 'bignumber.js';
+
+
+interface IOptions<T> {
+    strict: boolean;
+    parse: (long: string) => T;
+    stringify: (long: T) => string;
+    isInstance: (some: any) => some is T;
+}
+
+let options: IOptions<BigNumber> = {
+    strict: false,
+    parse: (long: string): BigNumber => new BigNumber(long),
+    stringify: (long: BigNumber): string => long.toFixed(),
+    isInstance: (some): some is BigNumber => some && (some instanceof BigNumber || BigNumber.isBigNumber(some))
+};
+
+describe('lib', () => {
+
+    describe('parse', () => {
+
+        let parse;
+        beforeEach(() => {
+            parse = create().parse;
+        });
+
+        it('without big num', () => {
+
+            const json = '{"a": 123}';
+            expect(parse(json)).toEqual({a: 123});
+        });
+
+        it('with big number', () => {
+
+            const json = '{"a": 12312312312321321312312312312312321321312312312312312321321312}';
+            expect(parse(json)).toEqual({a: '12312312312321321312312312312312321321312312312312312321321312'});
+        });
+    });
+
+
+    describe('parse to bigNum', () => {
+
+        let parse;
+        beforeEach(() => {
+            parse = create(options).parse;
+        });
+
+        it('with big number', () => {
+            const json = '{"a": 12312312312321321312312312312312321321312312312312312321321312}';
+            expect(parse(json)).toEqual({a: new BigNumber('12312312312321321312312312312312321321312312312312312321321312')});
+        });
+    });
+
+    describe('stringify', () => {
+
+        let stringify;
+        beforeEach(() => {
+            stringify = create().stringify;
+        });
+
+        it('stringify with quote', () => {
+            expect(stringify({a: '"'})).toBe('{"a":"\\\""}');
+        });
+
+        it('stringify with standard toJson', () => {
+            let date = new Date();
+            expect(stringify({a: date})).toBe(`{"a":"${date.toJSON()}"}`);
+        });
+
+        it('with big number', () => {
+
+            const data = {
+                a: new BigNumber(123)
+            };
+
+            const result = stringify(data);
+            expect(result).toBe(JSON.stringify({a: data.a}));
+        });
+
+        it('with big number', () => {
+
+            const data = {
+                a: new BigNumber('99999999999999999999999999999999999999999999999999999999.99999999999999')
+            };
+
+            const result = stringify(data);
+            expect(result).toBe(JSON.stringify({a: data.a}));
+        });
+
+    });
+
+    describe('stringify to big num', () => {
+
+        let stringify;
+        beforeEach(() => {
+            stringify = create(options).stringify;
+        });
+
+        it('stringify with quote', () => {
+            expect(stringify({a: '"'})).toBe('{"a":"\\\""}');
+        });
+
+        it('stringify with standard toJson', () => {
+            let date = new Date();
+            expect(stringify({a: date})).toBe(`{"a":"${date.toJSON()}"}`);
+        });
+
+        it('with big number', () => {
+
+            const data = {
+                a: new BigNumber(123)
+            };
+
+            expect(stringify(data)).toBe('{"a":123}');
+        });
+
+        it('with big number', () => {
+
+            const data = {
+                a: new BigNumber('9999999999999999999999999999999999.99999999999999')
+            };
+
+            const result = stringify(data);
+            expect(result).toBe('{"a":9999999999999999999999999999999999.99999999999999}');
+        });
+
+    });
+
+});

data/js/node_modules/@waves/parse-json-bignumber/test/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "sourceMap": true,
+    "module": "none",
+    "lib": [
+      "es2015.promise",
+      "es5"
+    ],
+    "typeRoots": [
+      "../node_modules/@types"
+    ]
+  }
+}

data/js/node_modules/@waves/parse-json-bignumber/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "sourceMap": false,
+    "declaration": true,
+    "outDir": "./dist"
+  },
+  "files": [
+    "src/parse-json-bignumber.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}