@mandujs/core 0.54.31 → 0.55.0-beta.1

package/src/client/__tests__/use-sse.test.ts

@@ -1,153 +1,153 @@
-/**
- * Tests for useSSE hook and readStreamWithYield utility
- *
- * These tests verify the microtask-starvation-safe ReadableStream reading
- * utilities work correctly.
- */
-import { describe, test, expect, beforeEach, mock } from "bun:test";
-import { readStreamWithYield } from "../use-sse";
-
-// Note: useSSE is a React hook and would need a React testing environment.
-// We test the lower-level readStreamWithYield utility here since it contains
-// the core macrotask-yielding logic that prevents main thread blocking.
-
-/**
- * Helper: create a ReadableStream from an array of strings
- */
-function createMockStream(chunks: string[]): ReadableStream<Uint8Array> {
-  const encoder = new TextEncoder();
-  let index = 0;
-
-  return new ReadableStream({
-    pull(controller) {
-      if (index < chunks.length) {
-        controller.enqueue(encoder.encode(chunks[index++]));
-      } else {
-        controller.close();
-      }
-    },
-  });
-}
-
-describe("readStreamWithYield", () => {
-  test("should read all chunks from a stream", async () => {
-    const chunks = ["Hello", " ", "World"];
-    const stream = createMockStream(chunks);
-    const received: string[] = [];
-
-    await readStreamWithYield(stream, {
-      onChunk: (text) => received.push(text),
-      onDone: () => {},
-    });
-
-    expect(received).toEqual(chunks);
-  });
-
-  test("should call onDone when stream completes", async () => {
-    const stream = createMockStream(["a", "b"]);
-    let doneCalled = false;
-
-    await readStreamWithYield(stream, {
-      onChunk: () => {},
-      onDone: () => {
-        doneCalled = true;
-      },
-    });
-
-    expect(doneCalled).toBe(true);
-  });
-
-  test("should call onError on stream failure", async () => {
-    const stream = new ReadableStream({
-      start(controller) {
-        controller.error(new Error("test error"));
-      },
-    });
-
-    let errorCaught: Error | null = null;
-
-    await readStreamWithYield(stream, {
-      onChunk: () => {},
-      onError: (err) => {
-        errorCaught = err;
-      },
-    });
-
-    expect(errorCaught).not.toBeNull();
-    expect(errorCaught!.message).toBe("test error");
-  });
-
-  test("should respect abort signal", async () => {
-    const controller = new AbortController();
-    const chunks = ["a", "b", "c", "d", "e"];
-    const stream = createMockStream(chunks);
-    const received: string[] = [];
-
-    // Abort after first chunk
-    let chunkCount = 0;
-
-    await readStreamWithYield(stream, {
-      onChunk: (text) => {
-        received.push(text);
-        chunkCount++;
-        if (chunkCount >= 2) {
-          controller.abort();
-        }
-      },
-      signal: controller.signal,
-    });
-
-    // Should have received at most 2-3 chunks (abort may not be immediate)
-    expect(received.length).toBeLessThanOrEqual(3);
-    expect(received.length).toBeGreaterThanOrEqual(2);
-  });
-
-  test("should handle empty stream", async () => {
-    const stream = createMockStream([]);
-    const received: string[] = [];
-    let doneCalled = false;
-
-    await readStreamWithYield(stream, {
-      onChunk: (text) => received.push(text),
-      onDone: () => {
-        doneCalled = true;
-      },
-    });
-
-    expect(received).toEqual([]);
-    expect(doneCalled).toBe(true);
-  });
-
-  test("should yield between chunks (non-blocking)", async () => {
-    // Create a stream with many rapid chunks
-    const chunkCount = 50;
-    const chunks = Array.from({ length: chunkCount }, (_, i) => `chunk-${i}`);
-    const stream = createMockStream(chunks);
-    const received: string[] = [];
-
-    // Track that setTimeout(0) yields are happening by checking
-    // that the promise resolves in multiple event loop ticks
-    let macrotaskCount = 0;
-    const originalSetTimeout = globalThis.setTimeout;
-
-    // Count macrotask yields (setTimeout(0) calls from yieldToMacrotask)
-    const timeoutSpy = mock((fn: Function, ms: number) => {
-      if (ms === 0) macrotaskCount++;
-      return originalSetTimeout(fn, ms);
-    });
-    // @ts-expect-error - mock override
-    globalThis.setTimeout = timeoutSpy;
-
-    try {
-      await readStreamWithYield(stream, {
-        onChunk: (text) => received.push(text),
-      });
-
-      // Every chunk should cause a macrotask yield
-      expect(received.length).toBe(chunkCount);
-      expect(macrotaskCount).toBeGreaterThanOrEqual(chunkCount);
-    } finally {
-      globalThis.setTimeout = originalSetTimeout;
-    }
-  });
-});
+/**
+ * Tests for useSSE hook and readStreamWithYield utility
+ *
+ * These tests verify the microtask-starvation-safe ReadableStream reading
+ * utilities work correctly.
+ */
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import { readStreamWithYield } from "../use-sse";
+
+// Note: useSSE is a React hook and would need a React testing environment.
+// We test the lower-level readStreamWithYield utility here since it contains
+// the core macrotask-yielding logic that prevents main thread blocking.
+
+/**
+ * Helper: create a ReadableStream from an array of strings
+ */
+function createMockStream(chunks: string[]): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  let index = 0;
+
+  return new ReadableStream({
+    pull(controller) {
+      if (index < chunks.length) {
+        controller.enqueue(encoder.encode(chunks[index++]));
+      } else {
+        controller.close();
+      }
+    },
+  });
+}
+
+describe("readStreamWithYield", () => {
+  test("should read all chunks from a stream", async () => {
+    const chunks = ["Hello", " ", "World"];
+    const stream = createMockStream(chunks);
+    const received: string[] = [];
+
+    await readStreamWithYield(stream, {
+      onChunk: (text) => received.push(text),
+      onDone: () => {},
+    });
+
+    expect(received).toEqual(chunks);
+  });
+
+  test("should call onDone when stream completes", async () => {
+    const stream = createMockStream(["a", "b"]);
+    let doneCalled = false;
+
+    await readStreamWithYield(stream, {
+      onChunk: () => {},
+      onDone: () => {
+        doneCalled = true;
+      },
+    });
+
+    expect(doneCalled).toBe(true);
+  });
+
+  test("should call onError on stream failure", async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.error(new Error("test error"));
+      },
+    });
+
+    let errorCaught: Error | null = null;
+
+    await readStreamWithYield(stream, {
+      onChunk: () => {},
+      onError: (err) => {
+        errorCaught = err;
+      },
+    });
+
+    expect(errorCaught).not.toBeNull();
+    expect(errorCaught!.message).toBe("test error");
+  });
+
+  test("should respect abort signal", async () => {
+    const controller = new AbortController();
+    const chunks = ["a", "b", "c", "d", "e"];
+    const stream = createMockStream(chunks);
+    const received: string[] = [];
+
+    // Abort after first chunk
+    let chunkCount = 0;
+
+    await readStreamWithYield(stream, {
+      onChunk: (text) => {
+        received.push(text);
+        chunkCount++;
+        if (chunkCount >= 2) {
+          controller.abort();
+        }
+      },
+      signal: controller.signal,
+    });
+
+    // Should have received at most 2-3 chunks (abort may not be immediate)
+    expect(received.length).toBeLessThanOrEqual(3);
+    expect(received.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("should handle empty stream", async () => {
+    const stream = createMockStream([]);
+    const received: string[] = [];
+    let doneCalled = false;
+
+    await readStreamWithYield(stream, {
+      onChunk: (text) => received.push(text),
+      onDone: () => {
+        doneCalled = true;
+      },
+    });
+
+    expect(received).toEqual([]);
+    expect(doneCalled).toBe(true);
+  });
+
+  test("should yield between chunks (non-blocking)", async () => {
+    // Create a stream with many rapid chunks
+    const chunkCount = 50;
+    const chunks = Array.from({ length: chunkCount }, (_, i) => `chunk-${i}`);
+    const stream = createMockStream(chunks);
+    const received: string[] = [];
+
+    // Track that setTimeout(0) yields are happening by checking
+    // that the promise resolves in multiple event loop ticks
+    let macrotaskCount = 0;
+    const originalSetTimeout = globalThis.setTimeout;
+
+    // Count macrotask yields (setTimeout(0) calls from yieldToMacrotask)
+    const timeoutSpy = mock((fn: Function, ms: number) => {
+      if (ms === 0) macrotaskCount++;
+      return originalSetTimeout(fn, ms);
+    });
+    // @ts-expect-error - mock override
+    globalThis.setTimeout = timeoutSpy;
+
+    try {
+      await readStreamWithYield(stream, {
+        onChunk: (text) => received.push(text),
+      });
+
+      // Every chunk should cause a macrotask yield
+      expect(received.length).toBe(chunkCount);
+      expect(macrotaskCount).toBeGreaterThanOrEqual(chunkCount);
+    } finally {
+      globalThis.setTimeout = originalSetTimeout;
+    }
+  });
+});

package/src/client/globals.ts

@@ -1,4 +1,4 @@
-import type * as __ManduReactTypes0 from "react";
+import type * as __ManduReactTypes0 from "react";
 /**
  * Mandu 전역 타입 선언
  * 클라이언트 측 전역 상태의 타입 정의