rename

Author: skyrpex

src/test/jsonl-stream.test.ts src/test/json-lines-stream.test.tssrc/test/jsonl-stream.test.ts renamed to src/test/json-lines-stream.test.ts

@@ -1,68 +1,68 @@
 import * as assert from "node:assert";
 
-import { JsonlStream } from "../utils/jsonl-stream.js";
+import { JsonLinesStream } from "../utils/json-lines-stream.js";
 
 const setup = () => {
-	const jsonlStream = new JsonlStream();
+	const stream = new JsonLinesStream();
 
 	const callbackCalls: unknown[] = [];
-	jsonlStream.onJson((data: unknown) => {
+	stream.onJson((data: unknown) => {
 		callbackCalls.push(data);
 	});
 
 	return {
-		jsonlStream,
+		stream,
 		callbackCalls,
 	};
 };
 
-suite("JSONL Streams", () => {
-	test("should parse and emit complete JSONL messages", () => {
-		const { jsonlStream, callbackCalls } = setup();
+suite("JsonLinesStream Test Suite", () => {
+	test("should parse and emit complete JsonLines messages", () => {
+		const { stream, callbackCalls } = setup();
 
 		// Test with multiple JSON objects in a single write
 		const testData = Buffer.from('{"key1":"value1"}\n{"key2":"value2"}\n');
 
-		jsonlStream.write(testData);
+		stream.write(testData);
 
 		assert.strictEqual(callbackCalls.length, 2);
 		assert.deepStrictEqual(callbackCalls[0], { key1: "value1" });
 		assert.deepStrictEqual(callbackCalls[1], { key2: "value2" });
 	});
 
-	test("should handle incomplete JSONL messages across multiple writes", () => {
-		const { jsonlStream, callbackCalls } = setup();
+	test("should handle incomplete JsonLines messages across multiple writes", () => {
+		const { stream, callbackCalls } = setup();
 
 		// First write with partial message
 		const firstChunk = Buffer.from('{"key":"value');
-		jsonlStream.write(firstChunk);
+		stream.write(firstChunk);
 
 		// Shouldn't emit anything yet
 		assert.strictEqual(callbackCalls.length, 0);
 
 		// Complete the message in second write
 		const secondChunk = Buffer.from('1"}\n');
-		jsonlStream.write(secondChunk);
+		stream.write(secondChunk);
 
 		// Now it should emit the complete message
 		assert.strictEqual(callbackCalls.length, 1);
 		assert.deepStrictEqual(callbackCalls[0], { key: "value1" });
 	});
 
 	test("should handle multiple messages in chunks", () => {
-		const { jsonlStream, callbackCalls } = setup();
+		const { stream, callbackCalls } = setup();
 
 		// Write first message and part of second
 		const firstChunk = Buffer.from('{"first":1}\n{"second":');
-		jsonlStream.write(firstChunk);
+		stream.write(firstChunk);
 
 		// First message should be emitted
 		assert.strictEqual(callbackCalls.length, 1);
 		assert.deepStrictEqual(callbackCalls[0], { first: 1 });
 
 		// Complete second message and add third
 		const secondChunk = Buffer.from('2}\n{"third":3}\n');
-		jsonlStream.write(secondChunk);
+		stream.write(secondChunk);
 
 		// Should have all three messages now
 		assert.strictEqual(callbackCalls.length, 3);
@@ -71,23 +71,23 @@ suite("JSONL Streams", () => {
 	});
 
 	test("should ignore invalid JSON lines", () => {
-		const { jsonlStream, callbackCalls } = setup();
+		const { stream, callbackCalls } = setup();
 
 		const testData = Buffer.from('not json\n{"valid":true}\n{invalid}\n');
 
-		jsonlStream.write(testData);
+		stream.write(testData);
 
 		// Should only emit the valid JSON object
 		assert.strictEqual(callbackCalls.length, 1);
 		assert.deepStrictEqual(callbackCalls[0], { valid: true });
 	});
 
 	test("should handle empty lines", () => {
-		const { jsonlStream, callbackCalls } = setup();
+		const { stream, callbackCalls } = setup();
 
 		const testData = Buffer.from('\n\n{"key":"value"}\n\n');
 
-		jsonlStream.write(testData);
+		stream.write(testData);
 
 		// Should only emit the valid JSON object
 		assert.strictEqual(callbackCalls.length, 1);

src/utils/container-status.ts

@@ -4,7 +4,7 @@ import type { Disposable, LogOutputChannel } from "vscode";
 import * as z from "zod/v4-mini";
 
 import { createEmitter } from "./emitter.ts";
-import { JsonlStream } from "./jsonl-stream.ts";
+import { JsonLinesStream } from "./json-lines-stream.ts";
 
 export type ContainerStatus = "running" | "stopping" | "stopped";
 
@@ -123,7 +123,7 @@ function listenToContainerStatus(
 				throw new Error("Failed to get stdout from docker events process");
 			}
 
-			const jsonlStream = new JsonlStream();
+			const jsonlStream = new JsonLinesStream();
 			jsonlStream.onJson((json) => {
 				const parsed = DockerEventsSchema.safeParse(json);
 				if (!parsed.success) {

src/utils/jsonl-stream.ts src/utils/json-lines-stream.tssrc/utils/jsonl-stream.ts renamed to src/utils/json-lines-stream.ts

@@ -1,9 +1,9 @@
 import { Writable } from "node:stream";
 
 /**
- * Safely parses a JSON string, returning null if parsing fails.
+ * Safely parses a JSON string, returning undefined if parsing fails.
  * @param str - The JSON string to parse.
- * @returns The parsed object or null if invalid.
+ * @returns The parsed object or undefined if invalid.
  */
 export function safeJsonParse(str: string): unknown {
 	try {
@@ -17,7 +17,7 @@ export function safeJsonParse(str: string): unknown {
  * Writable stream that buffers data until a newline,
  * parses each line as JSON, and emits the parsed object.
  */
-export class JsonlStream extends Writable {
+export class JsonLinesStream extends Writable {
 	constructor() {
 		let buffer = "";
 		super({