Add support for mode:jsonl in stringifyInfo

Author: lahmatiy

CHANGELOG.md

@@ -11,6 +11,8 @@
     - Fixed various issues with parsing of malformed JSON
 - `stringifyChunked()`:
     - Added `mode` option with `"json"` (default) and `"jsonl"` values; `mode: "jsonl"` serializes iterable input into newline-delimited JSON values
+- `stringifyInfo()`:
+    - Added `mode` option with `"json"` (default) and `"jsonl"` values; `mode: "jsonl"` computes byte size for newline-delimited JSON values
 
 ## 0.6.3 (2024-10-24)
 

README.md

@@ -261,6 +261,7 @@ export function stringifyInfo(value: any, options?: StringifyInfoOptions): Strin
 type StringifyInfoOptions = {
     replacer?: Replacer;
     space?: Space;
+    mode?: 'json' | 'jsonl';
     continueOnCircular?: boolean;
 }
 type StringifyInfoResult = {

index.d.ts

@@ -31,6 +31,7 @@ declare module '@discoveryjs/json-ext' {
     type StringifyInfoOptions = {
         replacer?: Replacer;
         space?: Space;
+        mode?: 'json' | 'jsonl';
         continueOnCircular?: boolean;
     }
     type StringifyInfoResult = {

src/stringify-chunked.js

@@ -1,12 +1,4 @@
-import { normalizeStringifyOptions, replaceValue } from './utils.js';
-
-function resolveStringifyMode(mode = 'json') {
-    if (mode === 'json' || mode === 'jsonl') {
-        return mode;
-    }
-
-    throw new TypeError('Invalid options: `mode` should be "json" or "jsonl"');
-}
+import { normalizeStringifyOptions, replaceValue, resolveStringifyMode } from './utils.js';
 
 function encodeString(value) {
     if (/[^\x20\x21\x23-\x5B\x5D-\uD799]/.test(value)) { // [^\x20-\uD799]|[\x22\x5c]

src/stringify-info.js

@@ -1,4 +1,4 @@
-import { normalizeStringifyOptions, replaceValue } from './utils.js';
+import { normalizeStringifyOptions, replaceValue, resolveStringifyMode } from './utils.js';
 
 const hasOwn = typeof Object.hasOwn === 'function'
     ? Object.hasOwn
@@ -125,21 +125,27 @@ export function stringifyInfo(value, ...args) {
     const { replacer, getKeys, ...options } = normalizeStringifyOptions(...args);
     const continueOnCircular = Boolean(options.continueOnCircular);
     const space = options.space?.length || 0;
+    const roots = resolveStringifyMode(options.mode) === 'jsonl' && Array.isArray(value) ? value : [value];
 
     const keysLength = new Map();
     const visited = new Map();
     const circular = new Set();
     const stack = [];
-    const root = { '': value };
     let stop = false;
     let bytes = 0;
     let spaceBytes = 0;
     let objects = 0;
 
-    walk(root, '', value);
+    for (let i = 0; i < roots.length; i++) {
+        if (i > 0) {
+            bytes += 1; // newline separator
+        }
+
+        walk({ '': roots[i] }, '', roots[i]);
+    }
 
     // when value is undefined or replaced for undefined
-    if (bytes === 0) {
+    if (bytes === 0 && roots.length === 1) {
         bytes += 9; // FIXME: that's the length of undefined, should we normalize behaviour to convert it to null?
     }
 

src/stringify-info.test.js

@@ -72,6 +72,74 @@ describe('stringifyInfo()', () => {
         });
     });
 
+    describe('mode option', () => {
+        it('json by default', () => {
+            assert.deepStrictEqual(stringifyInfo([{ a: 1 }, { a: 2 }]), {
+                bytes: '[{"a":1},{"a":2}]'.length,
+                spaceBytes: 0,
+                circular: []
+            });
+        });
+
+        it('jsonl mode computes newline-delimited sizes', () => {
+            // {"a":1}\n{"a":2}\n3 = 7+1+7+1+1 = 17
+            assert.deepStrictEqual(stringifyInfo([{ a: 1 }, { a: 2 }, 3], { mode: 'jsonl' }), {
+                bytes: 17,
+                spaceBytes: 0,
+                circular: []
+            });
+        });
+
+        it('jsonl mode with non-array value treats as single value', () => {
+            assert.deepStrictEqual(stringifyInfo({ a: 1 }, { mode: 'jsonl' }), {
+                bytes: '{"a":1}'.length,
+                spaceBytes: 0,
+                circular: []
+            });
+        });
+
+        it('jsonl mode with empty array', () => {
+            assert.deepStrictEqual(stringifyInfo([], { mode: 'jsonl' }), {
+                bytes: 0,
+                spaceBytes: 0,
+                circular: []
+            });
+        });
+
+        it('jsonl mode with single element array', () => {
+            assert.deepStrictEqual(stringifyInfo([42], { mode: 'jsonl' }), {
+                bytes: 2,
+                spaceBytes: 0,
+                circular: []
+            });
+        });
+
+        it('jsonl mode with space option', () => {
+            // Each root is formatted independently
+            const info = stringifyInfo([{ a: 1 }, { b: 2 }], { mode: 'jsonl', space: 2 });
+            const root1 = JSON.stringify({ a: 1 }, null, 2);
+            const root2 = JSON.stringify({ b: 2 }, null, 2);
+            const expected = root1 + '\n' + root2;
+
+            assert.strictEqual(info.bytes, Buffer.byteLength(expected, 'utf8'));
+        });
+
+        it('jsonl mode with replacer', () => {
+            assert.deepStrictEqual(stringifyInfo([{ a: 1, b: 2 }, { a: 3, b: 4 }], { mode: 'jsonl', replacer: ['a'] }), {
+                bytes: '{"a":1}\n{"a":3}'.length,
+                spaceBytes: 0,
+                circular: []
+            });
+        });
+
+        it('throws on invalid mode', () => {
+            assert.throws(
+                () => stringifyInfo([1, 2], { mode: 'auto' }),
+                /Invalid options: `mode` should be "json" or "jsonl"/
+            );
+        });
+    });
+
     describe('circular', () => {
         it('should stop on first circular reference by default', () => {
             const circularRef = {};

src/utils.js

@@ -98,3 +98,11 @@ export function normalizeStringifyOptions(optionsOrReplacer, space) {
         space: normalizeSpace(optionsOrReplacer.space)
     };
 }
+
+export function resolveStringifyMode(mode = 'json') {
+    if (mode === 'json' || mode === 'jsonl') {
+        return mode;
+    }
+
+    throw new TypeError('Invalid options: `mode` should be "json" or "jsonl"');
+}