@casual-simulation/fast-json-stable-stringify 2.0.12

package/LICENSE

@@ -0,0 +1,21 @@
+This software is released under the MIT license:
+
+Copyright (c) 2017 Evgeny Poberezkin
+Copyright (c) 2013 James Halliday
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,126 @@
+# fast-json-stable-stringify
+
+> Forked from https://github.com/epoberezkin/fast-json-stable-stringify.
+> Changes include converting to TypeScript and adding the ability to indent JSON output.
+
+Deterministic `JSON.stringify()` - a faster version of [@substack](https://github.com/substack)'s json-stable-strigify without [jsonify](https://github.com/substack/jsonify).
+
+You can also pass in a custom comparison function.
+
+# example
+
+```js
+var stringify = require('fast-json-stable-stringify');
+var obj = { c: 8, b: [{ z: 6, y: 5, x: 4 }, 7], a: 3 };
+console.log(stringify(obj));
+```
+
+output:
+
+```
+{"a":3,"b":[{"x":4,"y":5,"z":6},7],"c":8}
+```
+
+# methods
+
+```js
+var stringify = require('fast-json-stable-stringify');
+```
+
+## var str = stringify(obj, opts)
+
+Return a deterministic stringified string `str` from the object `obj`.
+
+## options
+
+### cmp
+
+If `opts` is given, you can supply an `opts.cmp` to have a custom comparison
+function for object keys. Your function `opts.cmp` is called with these
+parameters:
+
+```js
+opts.cmp({ key: akey, value: avalue }, { key: bkey, value: bvalue });
+```
+
+For example, to sort on the object key names in reverse order you could write:
+
+```js
+var stringify = require('fast-json-stable-stringify');
+
+var obj = { c: 8, b: [{ z: 6, y: 5, x: 4 }, 7], a: 3 };
+var s = stringify(obj, function (a, b) {
+    return a.key < b.key ? 1 : -1;
+});
+console.log(s);
+```
+
+which results in the output string:
+
+```
+{"c":8,"b":[{"z":6,"y":5,"x":4},7],"a":3}
+```
+
+Or if you wanted to sort on the object values in reverse order, you could write:
+
+```
+var stringify = require('fast-json-stable-stringify');
+
+var obj = { d: 6, c: 5, b: [{z:3,y:2,x:1},9], a: 10 };
+var s = stringify(obj, function (a, b) {
+    return a.value < b.value ? 1 : -1;
+});
+console.log(s);
+```
+
+which outputs:
+
+```
+{"d":6,"c":5,"b":[{"z":3,"y":2,"x":1},9],"a":10}
+```
+
+### cycles
+
+Pass `true` in `opts.cycles` to stringify circular property as `__cycle__` - the result will not be a valid JSON string in this case.
+
+TypeError will be thrown in case of circular object without this option.
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install fast-json-stable-stringify
+```
+
+# benchmark
+
+To run benchmark (requires Node.js 6+):
+
+```
+node benchmark
+```
+
+Results:
+
+```
+fast-json-stable-stringify x 17,189 ops/sec ±1.43% (83 runs sampled)
+json-stable-stringify x 13,634 ops/sec ±1.39% (85 runs sampled)
+fast-stable-stringify x 20,212 ops/sec ±1.20% (84 runs sampled)
+faster-stable-stringify x 15,549 ops/sec ±1.12% (84 runs sampled)
+The fastest is fast-stable-stringify
+```
+
+## Enterprise support
+
+fast-json-stable-stringify package is a part of [Tidelift enterprise subscription](https://tidelift.com/subscription/pkg/npm-fast-json-stable-stringify?utm_source=npm-fast-json-stable-stringify&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) - it provides a centralised commercial support to open-source software users, in addition to the support provided by software maintainers.
+
+## Security contact
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerability via GitHub issues.
+
+# license
+
+[MIT](https://github.com/epoberezkin/fast-json-stable-stringify/blob/master/LICENSE)

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,GAAG,CAAC;CACd;AAED,oBAAY,eAAe,GAAG,CAC1B,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,YAAY,KACnB,MAAM,CAAC;AAEZ,MAAM,WAAW,gBAAgB;IAC7B,GAAG,CAAC,EAAE,eAAe,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B;AAED,MAAM,CAAC,OAAO,WACV,IAAI,EAAE,GAAG,EACT,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe,UAuE/C"}

package/index.js

@@ -0,0 +1,119 @@
+export default function (data, options) {
+    if (!options)
+        options = {};
+    if (typeof options === 'function')
+        options = { cmp: options };
+    let cycles = typeof options.cycles === 'boolean' ? options.cycles : false;
+    options.space = options.space || '';
+    let space = typeof options.space === 'number'
+        ? Array(options.space + 1).join(' ')
+        : options.space;
+    let cmp = options.cmp &&
+        ((f) => {
+            return (node) => {
+                return (a, b) => {
+                    let aobj = { key: a, value: node[a] };
+                    let bobj = { key: b, value: node[b] };
+                    return f(aobj, bobj);
+                };
+            };
+        })(options.cmp);
+    let seen = [];
+    return (function stringify(node, level) {
+        let indent = space ? '\n' + new Array(level + 1).join(space) : '';
+        let colonSeparator = space ? ': ' : ':';
+        if (node && node.toJSON && typeof node.toJSON === 'function') {
+            node = node.toJSON();
+        }
+        if (node === undefined)
+            return;
+        if (typeof node === 'number')
+            return isFinite(node) ? '' + node : 'null';
+        if (typeof node !== 'object')
+            return JSON.stringify(node, undefined, space);
+        let i;
+        let out;
+        if (Array.isArray(node)) {
+            out = '[';
+            for (i = 0; i < node.length; i++) {
+                if (i)
+                    out += ',';
+                out +=
+                    indent + space + (stringify(node[i], level + 1) || 'null');
+            }
+            return out + indent + ']';
+        }
+        if (node === null)
+            return 'null';
+        if (seen.indexOf(node) !== -1) {
+            if (cycles)
+                return JSON.stringify('__cycle__');
+            throw new TypeError('Converting circular structure to JSON');
+        }
+        let seenIndex = seen.push(node) - 1;
+        let keys = Object.keys(node).sort(cmp && cmp(node));
+        out = '';
+        for (i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            let value = stringify(node[key], level + 1);
+            if (!value)
+                continue;
+            if (out)
+                out += ',';
+            out +=
+                indent + space + JSON.stringify(key) + colonSeparator + value;
+        }
+        seen.splice(seenIndex, 1);
+        return '{' + out + indent + '}';
+    })(data, 0);
+}
+// module.exports = function (data, opts) {
+//     if (!opts) opts = {};
+//     if (typeof opts === 'function') opts = { cmp: opts };
+//     var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;
+//     var cmp = opts.cmp && (function (f) {
+//         return function (node) {
+//             return function (a, b) {
+//                 var aobj = { key: a, value: node[a] };
+//                 var bobj = { key: b, value: node[b] };
+//                 return f(aobj, bobj);
+//             };
+//         };
+//     })(opts.cmp);
+//     var seen = [];
+//     return (function stringify (node) {
+//         if (node && node.toJSON && typeof node.toJSON === 'function') {
+//             node = node.toJSON();
+//         }
+//         if (node === undefined) return;
+//         if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';
+//         if (typeof node !== 'object') return JSON.stringify(node);
+//         var i, out;
+//         if (Array.isArray(node)) {
+//             out = '[';
+//             for (i = 0; i < node.length; i++) {
+//                 if (i) out += ',';
+//                 out += stringify(node[i]) || 'null';
+//             }
+//             return out + ']';
+//         }
+//         if (node === null) return 'null';
+//         if (seen.indexOf(node) !== -1) {
+//             if (cycles) return JSON.stringify('__cycle__');
+//             throw new TypeError('Converting circular structure to JSON');
+//         }
+//         var seenIndex = seen.push(node) - 1;
+//         var keys = Object.keys(node).sort(cmp && cmp(node));
+//         out = '';
+//         for (i = 0; i < keys.length; i++) {
+//             var key = keys[i];
+//             var value = stringify(node[key]);
+//             if (!value) continue;
+//             if (out) out += ',';
+//             out += JSON.stringify(key) + ':' + value;
+//         }
+//         seen.splice(seenIndex, 1);
+//         return '{' + out + '}';
+//     })(data);
+// };
+//# sourceMappingURL=index.js.map

package/index.spec.ts

@@ -0,0 +1,109 @@
+import stringify from './index';
+
+describe('fast-json-stable-stringify', () => {
+    it('should support nested objects', () => {
+        var obj = { c: 8, b: [{ z: 6, y: 5, x: 4 }, 7], a: 3 };
+        expect(stringify(obj)).toBe(
+            '{"a":3,"b":[{"x":4,"y":5,"z":6},7],"c":8}'
+        );
+    });
+
+    it('should error on cyclic objects', () => {
+        expect(() => {
+            let one: any = { a: 1 };
+            let two: any = { a: 2, one: one };
+            one.two = two;
+            stringify(one);
+        }).toThrowError(new TypeError('Converting circular structure to JSON'));
+    });
+
+    it('should support cyclic objects when specified', () => {
+        let one: any = { a: 1 };
+        let two: any = { a: 2, one: one };
+        one.two = two;
+        expect(stringify(one, { cycles: true })).toBe(
+            '{"a":1,"two":{"a":2,"one":"__cycle__"}}'
+        );
+    });
+
+    it('should support repeated non-cyclic values', () => {
+        let one = { x: 1 };
+        let two = { a: one, b: one };
+        expect(stringify(two)).toBe('{"a":{"x":1},"b":{"x":1}}');
+    });
+
+    it('should support non-cyclic objects with reused obj-property pointers', () => {
+        let x = { a: 1 };
+        let y = { b: x, c: x };
+        expect(stringify(y)).toBe('{"b":{"a":1},"c":{"a":1}}');
+    });
+
+    it('should support custom comparision functions', () => {
+        var obj = { c: 8, b: [{ z: 6, y: 5, x: 4 }, 7], a: 3 };
+        var s = stringify(obj, function (a, b) {
+            return a.key < b.key ? 1 : -1;
+        });
+        expect(s).toBe('{"c":8,"b":[{"z":6,"y":5,"x":4},7],"a":3}');
+    });
+
+    const cases = [
+        [
+            'simple object',
+            { c: 6, b: [4, 5], a: 3, z: null },
+            '{"a":3,"b":[4,5],"c":6,"z":null}',
+        ],
+        ['object with undefined', { a: 3, z: undefined }, '{"a":3}'],
+        ['object with null', { a: 3, z: null }, '{"a":3,"z":null}'],
+        [
+            'object with NaN and Infinity',
+            { a: 3, b: NaN, c: Infinity },
+            '{"a":3,"b":null,"c":null}',
+        ],
+        ['array with undefined', [4, undefined, 6], '[4,null,6]'],
+        ['object with empty string', { a: 3, z: '' }, '{"a":3,"z":""}'],
+        ['array with empty string', [4, '', 6], '[4,"",6]'],
+    ] as [string, any, string][];
+
+    it.each(cases)('should stringify %s', (name, obj, expected) => {
+        expect(stringify(obj)).toBe(expected);
+    });
+
+    it('should support toJSON that returns object', () => {
+        var obj = {
+            one: 1,
+            two: 2,
+            toJSON: function () {
+                return { one: 1 };
+            },
+        };
+        expect(stringify(obj)).toBe('{"one":1}');
+    });
+
+    it('should support toJSON that returns string', () => {
+        var obj = {
+            one: 1,
+            two: 2,
+            toJSON: function () {
+                return { one: 1 };
+            },
+        };
+        expect(stringify(obj)).toBe('{"one":1}');
+    });
+
+    it('should support toJSON that returns array', () => {
+        var obj = {
+            one: 1,
+            two: 2,
+            toJSON: function () {
+                return ['one'];
+            },
+        };
+        expect(stringify(obj)).toBe('["one"]');
+    });
+
+    it('should pretty format objects when specified', () => {
+        expect(stringify({ a: 1, b: 2 }, { space: 2 })).toBe(
+            '{\n  "a": 1,\n  "b": 2\n}'
+        );
+    });
+});

package/index.ts

@@ -0,0 +1,148 @@
+export interface CompareValue {
+    key: string;
+    value: any;
+}
+
+export type CompareFunction = (
+    first: CompareValue,
+    second: CompareValue
+) => number;
+
+export interface StringifyOptions {
+    cmp?: CompareFunction;
+    cycles?: boolean;
+    space?: string | number;
+}
+
+export default function (
+    data: any,
+    options?: StringifyOptions | CompareFunction
+) {
+    if (!options) options = {};
+    if (typeof options === 'function') options = { cmp: options };
+    let cycles = typeof options.cycles === 'boolean' ? options.cycles : false;
+    options.space = options.space || '';
+    let space =
+        typeof options.space === 'number'
+            ? Array(options.space + 1).join(' ')
+            : options.space;
+
+    let cmp =
+        options.cmp &&
+        ((f) => {
+            return (node: any) => {
+                return (a: string, b: string) => {
+                    let aobj = { key: a, value: node[a] };
+                    let bobj = { key: b, value: node[b] };
+                    return f(aobj, bobj);
+                };
+            };
+        })(options.cmp);
+
+    let seen: any[] = [];
+    return (function stringify(node: any, level: number) {
+        let indent = space ? '\n' + new Array(level + 1).join(space) : '';
+        let colonSeparator = space ? ': ' : ':';
+        if (node && node.toJSON && typeof node.toJSON === 'function') {
+            node = node.toJSON();
+        }
+
+        if (node === undefined) return;
+        if (typeof node === 'number')
+            return isFinite(node) ? '' + node : 'null';
+        if (typeof node !== 'object')
+            return JSON.stringify(node, undefined, space);
+
+        let i: number;
+        let out: string;
+        if (Array.isArray(node)) {
+            out = '[';
+            for (i = 0; i < node.length; i++) {
+                if (i) out += ',';
+                out +=
+                    indent + space + (stringify(node[i], level + 1) || 'null');
+            }
+            return out + indent + ']';
+        }
+
+        if (node === null) return 'null';
+
+        if (seen.indexOf(node) !== -1) {
+            if (cycles) return JSON.stringify('__cycle__');
+            throw new TypeError('Converting circular structure to JSON');
+        }
+
+        let seenIndex = seen.push(node) - 1;
+        let keys = Object.keys(node).sort(cmp && cmp(node));
+        out = '';
+        for (i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            let value = stringify(node[key], level + 1);
+
+            if (!value) continue;
+            if (out) out += ',';
+            out +=
+                indent + space + JSON.stringify(key) + colonSeparator + value;
+        }
+        seen.splice(seenIndex, 1);
+        return '{' + out + indent + '}';
+    })(data, 0);
+}
+
+// module.exports = function (data, opts) {
+//     if (!opts) opts = {};
+//     if (typeof opts === 'function') opts = { cmp: opts };
+//     var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;
+
+//     var cmp = opts.cmp && (function (f) {
+//         return function (node) {
+//             return function (a, b) {
+//                 var aobj = { key: a, value: node[a] };
+//                 var bobj = { key: b, value: node[b] };
+//                 return f(aobj, bobj);
+//             };
+//         };
+//     })(opts.cmp);
+
+//     var seen = [];
+//     return (function stringify (node) {
+//         if (node && node.toJSON && typeof node.toJSON === 'function') {
+//             node = node.toJSON();
+//         }
+
+//         if (node === undefined) return;
+//         if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';
+//         if (typeof node !== 'object') return JSON.stringify(node);
+
+//         var i, out;
+//         if (Array.isArray(node)) {
+//             out = '[';
+//             for (i = 0; i < node.length; i++) {
+//                 if (i) out += ',';
+//                 out += stringify(node[i]) || 'null';
+//             }
+//             return out + ']';
+//         }
+
+//         if (node === null) return 'null';
+
+//         if (seen.indexOf(node) !== -1) {
+//             if (cycles) return JSON.stringify('__cycle__');
+//             throw new TypeError('Converting circular structure to JSON');
+//         }
+
+//         var seenIndex = seen.push(node) - 1;
+//         var keys = Object.keys(node).sort(cmp && cmp(node));
+//         out = '';
+//         for (i = 0; i < keys.length; i++) {
+//             var key = keys[i];
+//             var value = stringify(node[key]);
+
+//             if (!value) continue;
+//             if (out) out += ',';
+//             out += JSON.stringify(key) + ':' + value;
+//         }
+//         seen.splice(seenIndex, 1);
+//         return '{' + out + '}';
+//     })(data);
+// };

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@casual-simulation/fast-json-stable-stringify",
+    "version": "2.0.12",
+    "description": "deterministic `JSON.stringify()` - a faster version of substack's json-stable-strigify without jsonify",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "module": "index.js",
+    "scripts": {
+        "eslint": "eslint index.js test",
+        "test-spec": "tape test/*.js",
+        "test": "npm run eslint && nyc npm run test-spec"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git@github.com:casual-simulation/casualos.git"
+    },
+    "homepage": "https://github.com/casual-simulation/casualos/tree/develop/src/fast-json-stable-stringify",
+    "keywords": [
+        "json",
+        "stringify",
+        "deterministic",
+        "hash",
+        "stable"
+    ],
+    "author": {
+        "name": "James Halliday",
+        "email": "mail@substack.net",
+        "url": "http://substack.net"
+    },
+    "license": "MIT",
+    "nyc": {
+        "exclude": [
+            "test",
+            "node_modules"
+        ],
+        "reporter": [
+            "lcov",
+            "text-summary"
+        ]
+    },
+    "engines": {
+        "node": ">=8"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "gitHead": "fdcd097e87afbd35b7cf9050c8b8c0cde73c1b2b"
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "baseUrl": ".",
+        "outDir": ".",
+        "declaration": true,
+        "declarationMap": true,
+        "composite": true,
+        "incremental": true
+    },
+    "include": ["./**/*"],
+    "exclude": ["node_modules", "lib", "**/*.spec.ts"],
+    "references": []
+}