jsii-rosetta 1.78.1 → 1.80.0

package/lib/json.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { Readable, Writable } from 'node:stream';
+/**
+ * Asynchronously parses a single JSON value from the provided reader. The JSON
+ * text might be longer than what could fit in a single string value, since the
+ * processing is done in a streaming manner.
+ *
+ * Prefer using JSON.parse if you know the entire JSON text is always small
+ * enough to fit in a string value, as this would have better performance.
+ *
+ * @param reader the reader from which to consume JSON text.
+ *
+ * @returns the parse JSON value as a Javascript value.
+ */
+export declare function parse(reader: Readable): Promise<any>;
+/**
+ * Serializes a possibly large object into the provided writer. The object may
+ * be large enough that the JSON text cannot fit in a single string value.
+ *
+ * Prefer using JSON.stringify if you know the object is always small enough
+ * that the JSON text can fit in a single string value, as this would have
+ * better performance.
+ *
+ * @param value the value to be serialized.
+ * @param writer the write in which to write the JSON text.
+ */
+export declare function stringify(value: any, writer: Writable): Promise<void>;
+//# sourceMappingURL=json.d.ts.map

package/lib/json.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = exports.parse = void 0;
+const node_stream_1 = require("node:stream");
+const node_util_1 = require("node:util");
+const stream_json_1 = require("stream-json");
+const Assembler = require("stream-json/Assembler");
+const Disassembler_1 = require("stream-json/Disassembler");
+const Stringer_1 = require("stream-json/Stringer");
+// NB: In node 15+, there is a node:stream.promises object that has this built-in.
+const asyncPipeline = (0, node_util_1.promisify)(node_stream_1.pipeline);
+/**
+ * Asynchronously parses a single JSON value from the provided reader. The JSON
+ * text might be longer than what could fit in a single string value, since the
+ * processing is done in a streaming manner.
+ *
+ * Prefer using JSON.parse if you know the entire JSON text is always small
+ * enough to fit in a string value, as this would have better performance.
+ *
+ * @param reader the reader from which to consume JSON text.
+ *
+ * @returns the parse JSON value as a Javascript value.
+ */
+async function parse(reader) {
+    const assembler = new Assembler();
+    const jsonParser = (0, stream_json_1.parser)();
+    assembler.connectTo(jsonParser);
+    return asyncPipeline(reader, jsonParser).then(() => assembler.current);
+}
+exports.parse = parse;
+/**
+ * Serializes a possibly large object into the provided writer. The object may
+ * be large enough that the JSON text cannot fit in a single string value.
+ *
+ * Prefer using JSON.stringify if you know the object is always small enough
+ * that the JSON text can fit in a single string value, as this would have
+ * better performance.
+ *
+ * @param value the value to be serialized.
+ * @param writer the write in which to write the JSON text.
+ */
+async function stringify(value, writer) {
+    const reader = new node_stream_1.Readable({ objectMode: true });
+    reader.push(value);
+    reader.push(null);
+    return asyncPipeline(reader, (0, Disassembler_1.disassembler)(), (0, Stringer_1.stringer)(), writer);
+}
+exports.stringify = stringify;
+//# sourceMappingURL=json.js.map

package/lib/tablets/tablets.js

@@ -4,6 +4,7 @@ exports.TranslatedSnippet = exports.LanguageTablet = exports.CURRENT_SCHEMA_VERS
 const fs_1 = require("fs");
 const path = require("path");
 const zlib = require("zlib");
+const json_1 = require("../json");
 const logging = require("../logging");
 const snippet_1 = require("../snippet");
 const util_1 = require("../util");
@@ -124,14 +125,17 @@ class LanguageTablet {
      * compressed and decompress accordingly.
      */
     async load(filename) {
-        let data = await fs_1.promises.readFile(filename);
-        // Gzip objects start with 1f 8b 08
-        if (data[0] === 0x1f && data[1] === 0x8b && data[2] === 0x08) {
-            // This is a gz object, so we decompress it now...
-            data = zlib.gunzipSync(data);
+        let readStream;
+        if (await isGzipped(filename)) {
+            const gunzip = zlib.createGunzip();
+            (0, fs_1.createReadStream)(filename).pipe(gunzip, { end: true });
+            readStream = gunzip;
             this.compressedSource = true;
         }
-        const obj = JSON.parse(data.toString('utf-8'));
+        else {
+            readStream = (0, fs_1.createReadStream)(filename);
+        }
+        const obj = await (0, json_1.parse)(readStream);
         if (!obj.toolVersion || !obj.snippets) {
             throw new Error(`File '${filename}' does not seem to be a Tablet file`);
         }
@@ -154,11 +158,10 @@ class LanguageTablet {
      */
     async save(filename, compress = false) {
         await fs_1.promises.mkdir(path.dirname(filename), { recursive: true });
-        let schema = Buffer.from(JSON.stringify(this.toSchema(), null, 2));
-        if (compress) {
-            schema = zlib.gzipSync(schema);
-        }
-        await fs_1.promises.writeFile(filename, schema);
+        const writeStream = (0, fs_1.createWriteStream)(filename, { flags: 'w' });
+        const gzip = compress ? zlib.createGzip() : undefined;
+        gzip?.pipe(writeStream, { end: true });
+        return (0, json_1.stringify)(this.toSchema(), gzip ?? writeStream);
     }
     toSchema() {
         return {
@@ -262,4 +265,15 @@ class TranslatedSnippet {
     }
 }
 exports.TranslatedSnippet = TranslatedSnippet;
+async function isGzipped(filename) {
+    const openFile = await fs_1.promises.open(filename, 'r');
+    try {
+        // Assumes that we can always read 3 bytes if there's that many in the file...
+        const { bytesRead, buffer } = await openFile.read(Buffer.alloc(4), 0, 3, 0);
+        return bytesRead >= 3 && buffer[0] === 0x1f && buffer[1] === 0x8b && buffer[2] === 0x08;
+    }
+    finally {
+        await openFile.close();
+    }
+}
 //# sourceMappingURL=tablets.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-rosetta",
-  "version": "1.78.1",
+  "version": "1.80.0",
   "description": "Translate TypeScript code snippets to other languages",
   "main": "lib/index.js",
   "bin": {
@@ -16,27 +16,29 @@
     "package": "package-js"
   },
   "devDependencies": {
-    "@types/commonmark": "^0.27.5",
+    "@types/commonmark": "^0.27.6",
     "@types/mock-fs": "^4.13.1",
-    "@types/workerpool": "^6.1.1",
+    "@types/stream-json": "^1.7.3",
+    "@types/workerpool": "^6.4.0",
     "@types/semver": "^7.3.13",
-    "jsii-build-tools": "1.78.1",
+    "jsii-build-tools": "1.80.0",
     "jsii-calc": "3.20.120",
     "memory-streams": "^0.1.3",
     "mock-fs": "^5.2.0"
   },
   "dependencies": {
-    "@jsii/check-node": "1.78.1",
-    "@jsii/spec": "1.78.1",
+    "@jsii/check-node": "1.80.0",
+    "@jsii/spec": "1.80.0",
     "commonmark": "^0.30.0",
     "typescript": "~3.9.10",
     "@xmldom/xmldom": "^0.8.6",
     "workerpool": "^6.4.0",
     "yargs": "^16.2.0",
+    "stream-json": "^1.7.5",
     "semver": "^7.3.8",
     "semver-intersect": "^1.4.0",
     "fast-glob": "^3.2.12",
-    "jsii": "1.78.1"
+    "jsii": "1.80.0"
   },
   "license": "Apache-2.0",
   "author": {

package/test/json.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json.test.d.ts.map

package/test/json.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_buffer_1 = require("node:buffer");
+const node_stream_1 = require("node:stream");
+const json_1 = require("../lib/json");
+describe(json_1.parse, () => {
+    test('small value', async () => {
+        const value = { foo: 'bar', baz: 123 };
+        const jsonText = JSON.stringify(value);
+        const readable = new node_stream_1.PassThrough();
+        readable.end(jsonText);
+        expect(await (0, json_1.parse)(readable)).toEqual(value);
+    });
+    test('value is too large to fit in a single string', async () => {
+        // We'll leverage the fact JSON can contain multiple definitions of the same key multiple times...
+        const expected = { foo: 'bar', baz: 123, bool: true, null: null, long: 'X'.repeat(102400) };
+        const readable = node_stream_1.Readable.from((function* () {
+            const chunks = Object.entries(expected).map(([key, value]) => `  ${JSON.stringify(key)}: ${JSON.stringify(value)}`);
+            yield '{\n';
+            let counter = 2;
+            let emitComma = false;
+            while (counter < node_buffer_1.kStringMaxLength) {
+                for (const chunk of chunks) {
+                    if (emitComma) {
+                        yield ',\n';
+                        counter += 2;
+                    }
+                    yield chunk;
+                    counter += chunk.length;
+                    emitComma = true;
+                }
+            }
+            yield '\n}\n';
+        })());
+        const actual = await (0, json_1.parse)(readable);
+        expect(actual).toEqual(expected);
+    });
+    test('invalid JSON input', () => {
+        const readable = new node_stream_1.PassThrough();
+        readable.end('{"bad": "JSON",');
+        return expect((0, json_1.parse)(readable)).rejects.toThrowErrorMatchingInlineSnapshot(`"Parser cannot parse input: expected an object key"`);
+    });
+});
+describe(json_1.stringify, () => {
+    test('small value', async () => {
+        const value = { foo: 'bar', baz: 123 };
+        const jsonText = JSON.stringify(value);
+        const chunks = new Array();
+        const writable = new node_stream_1.Writable({
+            write: (chunk, _encoding, callback) => {
+                chunks.push(Buffer.from(chunk));
+                callback(null);
+            },
+        });
+        await (0, json_1.stringify)(value, writable);
+        expect(Buffer.concat(chunks).toString('utf-8')).toBe(jsonText);
+    });
+    test('value too large for JSON text to fit in a string', async () => {
+        const value = { key: 'X'.repeat(node_buffer_1.kStringMaxLength) };
+        const chunks = new Array();
+        const writable = new node_stream_1.Writable({
+            write: (chunk, _encoding, callback) => {
+                chunks.push(Buffer.from(chunk));
+                callback(null);
+            },
+        });
+        await (0, json_1.stringify)(value, writable);
+        expect(headBytes(chunks, 10).toString('utf-8')).toBe('{"key":"XX');
+        expect(tailBytes(chunks, 10).toString('utf-8')).toBe('XXXXXXXX"}');
+    });
+});
+function headBytes(chunks, count) {
+    if (chunks.length === 0) {
+        return Buffer.alloc(0);
+    }
+    const [head, ...tail] = chunks;
+    const headSlice = head.slice(0, count);
+    if (headSlice.length === count) {
+        return headSlice;
+    }
+    const tailSlice = headBytes(tail, count - headSlice.length);
+    return Buffer.concat([headSlice, tailSlice]);
+}
+function tailBytes(chunks, count) {
+    if (chunks.length === 0) {
+        return Buffer.alloc(0);
+    }
+    const tail = chunks[chunks.length - 1];
+    const tailSlice = tail.slice(Math.max(0, tail.length - count), tail.length);
+    if (tailSlice.length === count) {
+        return tailSlice;
+    }
+    const headSlice = tailBytes(chunks.slice(0, chunks.length - 1), count - tailSlice.length);
+    return Buffer.concat([headSlice, tailSlice]);
+}
+//# sourceMappingURL=json.test.js.map