@mandujs/core 0.53.2 → 0.54.0

package/src/change/snapshot.ts

@@ -13,19 +13,19 @@ import { validateAndReport } from "../config";
 const MANDU_DIR = ".mandu";
 const SPEC_DIR = "spec";
 const MANIFEST_FILE = "routes.manifest.json";
-const SLOTS_DIR = "slots";
-const HISTORY_DIR = "history";
-const SNAPSHOTS_DIR = "snapshots";
-
-function reverseCopy<T>(items: readonly T[]): T[] {
-  const reversed: T[] = [];
-  for (let index = items.length - 1; index >= 0; index -= 1) {
-    reversed.push(items[index] as T);
-  }
-  return reversed;
-}
-
-/**
+const SLOTS_DIR = "slots";
+const HISTORY_DIR = "history";
+const SNAPSHOTS_DIR = "snapshots";
+
+function reverseCopy<T>(items: readonly T[]): T[] {
+  const reversed: T[] = [];
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    reversed.push(items[index] as T);
+  }
+  return reversed;
+}
+
+/**
  * 스냅샷 ID 생성 (YYYYMMDD-HHmmss-xxx)
  */
 function generateSnapshotId(): string {
@@ -258,11 +258,11 @@ export async function listSnapshotIds(rootDir: string): Promise<string[]> {
       })
     );
 
-    return reverseCopy(
-      entries
-        .map((entry) => entry.replace(".snapshot.json", ""))
-        .sort()
-    ); // 최신 순
+    return reverseCopy(
+      entries
+        .map((entry) => entry.replace(".snapshot.json", ""))
+        .sort()
+    ); // 최신 순
   } catch {
     return [];
   }

package/src/client/Form.tsx

@@ -1,105 +1,105 @@
-/**
- * Mandu <Form> Component
- * Progressive Enhancement: JS 없으면 일반 HTML form, JS 있으면 fetch 기반 제출
- */
-
-import { useState, useCallback, useRef, type FormEvent, type ReactNode } from "react";
-import { submitAction, type ActionResult } from "./router";
-
-export interface FormState {
-  submitting: boolean;
-  error: string | null;
-}
-
-export interface FormProps extends Omit<React.FormHTMLAttributes<HTMLFormElement>, "action" | "children"> {
-  /** 제출 대상 URL */
-  action: string;
-  /** Action 이름 (서버의 filling.action(name)과 매칭) */
-  actionName?: string;
-  /** HTTP 메서드 */
-  method?: "post" | "put" | "patch" | "delete";
-  /** JS에서 fetch 방식으로 전환 (기본: true, false면 일반 HTML form 제출) */
-  enhance?: boolean;
-  /** Action 성공 후 콜백 */
-  onActionSuccess?: (result: ActionResult) => void;
-  /** Action 실패 후 콜백 */
-  onActionError?: (error: Error) => void;
-  /** render props 또는 일반 children */
-  children: ReactNode | ((state: FormState) => ReactNode);
-}
-
-/**
- * Progressive Enhancement Form 컴포넌트
- *
- * @example
- * ```tsx
- * <Form action="/api/todos" actionName="create">
- *   <input name="title" required />
- *   <button type="submit">추가</button>
- * </Form>
- *
- * // render props로 제출 상태 접근
- * <Form action="/api/todos" actionName="create">
- *   {({ submitting, error }) => (
- *     <>
- *       <input name="title" required />
- *       <button type="submit" disabled={submitting}>
- *         {submitting ? "처리 중..." : "추가"}
- *       </button>
- *       {error && <p>{error}</p>}
- *     </>
- *   )}
- * </Form>
- * ```
- */
-export function Form({
-  action,
-  actionName = "default",
-  method = "post",
-  enhance = true,
-  onActionSuccess,
-  onActionError,
-  children,
-  ...rest
-}: FormProps) {
-  const [state, setState] = useState<FormState>({ submitting: false, error: null });
-  const submittingRef = useRef(false);
-  const formMethod = method === "post" ? "post" : "post";
-
-  const handleSubmit = useCallback(async (e: FormEvent<HTMLFormElement>) => {
-    if (!enhance) return;
-    if (submittingRef.current) return; // 이중 제출 방지
-
-    e.preventDefault();
-    submittingRef.current = true;
-    setState({ submitting: true, error: null });
-
-    try {
-      const formData = new FormData(e.currentTarget);
-      const result = await submitAction(action, formData, actionName, method);
-
-      if (result.ok) {
-        setState({ submitting: false, error: null });
-        onActionSuccess?.(result);
-      } else {
-        const message = "요청이 실패했습니다.";
-        setState({ submitting: false, error: message });
-        onActionError?.(new Error(message));
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "요청 실패";
-      setState({ submitting: false, error: message });
-      onActionError?.(error instanceof Error ? error : new Error(message));
-    } finally {
-      submittingRef.current = false;
-    }
-  }, [action, actionName, enhance, method, onActionSuccess, onActionError]);
-
-  return (
-    <form action={action} method={formMethod} onSubmit={handleSubmit} {...rest}>
-      <input type="hidden" name="_action" value={actionName} />
-      {method !== "post" && <input type="hidden" name="_method" value={method.toUpperCase()} />}
-      {typeof children === "function" ? children(state) : children}
-    </form>
-  );
-}
+/**
+ * Mandu <Form> Component
+ * Progressive Enhancement: JS 없으면 일반 HTML form, JS 있으면 fetch 기반 제출
+ */
+
+import { useState, useCallback, useRef, type FormEvent, type ReactNode } from "react";
+import { submitAction, type ActionResult } from "./router";
+
+export interface FormState {
+  submitting: boolean;
+  error: string | null;
+}
+
+export interface FormProps extends Omit<React.FormHTMLAttributes<HTMLFormElement>, "action" | "children"> {
+  /** 제출 대상 URL */
+  action: string;
+  /** Action 이름 (서버의 filling.action(name)과 매칭) */
+  actionName?: string;
+  /** HTTP 메서드 */
+  method?: "post" | "put" | "patch" | "delete";
+  /** JS에서 fetch 방식으로 전환 (기본: true, false면 일반 HTML form 제출) */
+  enhance?: boolean;
+  /** Action 성공 후 콜백 */
+  onActionSuccess?: (result: ActionResult) => void;
+  /** Action 실패 후 콜백 */
+  onActionError?: (error: Error) => void;
+  /** render props 또는 일반 children */
+  children: ReactNode | ((state: FormState) => ReactNode);
+}
+
+/**
+ * Progressive Enhancement Form 컴포넌트
+ *
+ * @example
+ * ```tsx
+ * <Form action="/api/todos" actionName="create">
+ *   <input name="title" required />
+ *   <button type="submit">추가</button>
+ * </Form>
+ *
+ * // render props로 제출 상태 접근
+ * <Form action="/api/todos" actionName="create">
+ *   {({ submitting, error }) => (
+ *     <>
+ *       <input name="title" required />
+ *       <button type="submit" disabled={submitting}>
+ *         {submitting ? "처리 중..." : "추가"}
+ *       </button>
+ *       {error && <p>{error}</p>}
+ *     </>
+ *   )}
+ * </Form>
+ * ```
+ */
+export function Form({
+  action,
+  actionName = "default",
+  method = "post",
+  enhance = true,
+  onActionSuccess,
+  onActionError,
+  children,
+  ...rest
+}: FormProps) {
+  const [state, setState] = useState<FormState>({ submitting: false, error: null });
+  const submittingRef = useRef(false);
+  const formMethod = method === "post" ? "post" : "post";
+
+  const handleSubmit = useCallback(async (e: FormEvent<HTMLFormElement>) => {
+    if (!enhance) return;
+    if (submittingRef.current) return; // 이중 제출 방지
+
+    e.preventDefault();
+    submittingRef.current = true;
+    setState({ submitting: true, error: null });
+
+    try {
+      const formData = new FormData(e.currentTarget);
+      const result = await submitAction(action, formData, actionName, method);
+
+      if (result.ok) {
+        setState({ submitting: false, error: null });
+        onActionSuccess?.(result);
+      } else {
+        const message = "요청이 실패했습니다.";
+        setState({ submitting: false, error: message });
+        onActionError?.(new Error(message));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "요청 실패";
+      setState({ submitting: false, error: message });
+      onActionError?.(error instanceof Error ? error : new Error(message));
+    } finally {
+      submittingRef.current = false;
+    }
+  }, [action, actionName, enhance, method, onActionSuccess, onActionError]);
+
+  return (
+    <form action={action} method={formMethod} onSubmit={handleSubmit} {...rest}>
+      <input type="hidden" name="_action" value={actionName} />
+      {method !== "post" && <input type="hidden" name="_method" value={method.toUpperCase()} />}
+      {typeof children === "function" ? children(state) : children}
+    </form>
+  );
+}

package/src/client/Link.tsx

@@ -88,10 +88,10 @@ export function Link({
       } catch {
         return;
       }
-
-      // Client-side 네비게이션
-      event.preventDefault();
-      void navigate(href, { replace, scroll });
+
+      // Client-side 네비게이션
+      event.preventDefault();
+      void navigate(href, { replace, scroll });
     },
     [href, replace, scroll, onClick]
   );
@@ -101,11 +101,11 @@ export function Link({
     if (!shouldPrefetch || prefetchedRef.current) return;
 
     try {
-      const url = new URL(href, window.location.origin);
-      if (url.origin === window.location.origin) {
-        void prefetch(href);
-        prefetchedRef.current = true;
-      }
+      const url = new URL(href, window.location.origin);
+      if (url.origin === window.location.origin) {
+        void prefetch(href);
+        prefetchedRef.current = true;
+      }
     } catch {
       // 무시
     }

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 전역 타입 선언
  * 클라이언트 측 전역 상태의 타입 정의