soseki 0.0.1

package/tests/core/_is-error.test.ts

@@ -0,0 +1,108 @@
+import { describe, test } from "vitest";
+import isError from "../../src/core/_is-error.js";
+
+describe("Error オブジェクトの判定", () => {
+  test("Error インスタンスを渡したとき、true になる", ({ expect }) => {
+    // Arrange
+    const input = new Error("test error");
+
+    // Act
+    const result = isError(input);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("Error を継承したクラスのインスタンスを渡したとき、true になる", ({ expect }) => {
+    // Arrange
+    class CustomError extends Error {}
+    const input = new CustomError("custom error");
+
+    // Act
+    const result = isError(input);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+});
+
+// describe("Error に類似したオブジェクトの判定", () => {
+//   test("name と message を持つプレーンなオブジェクトを渡したとき、true になる", ({ expect }) => {
+//     // Arrange
+//     const input = { name: "CustomError", message: "something went wrong" };
+
+//     // Act
+//     const result = isError(input);
+
+//     // Assert
+//     expect(result).toBe(true);
+//   });
+// });
+
+describe("Error ではない値の判定", () => {
+  test("null を渡したとき、false になる", ({ expect }) => {
+    // Arrange
+    const input = null;
+
+    // Act
+    const result = isError(input);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("undefined を渡したとき、false になる", ({ expect }) => {
+    // Arrange
+    const input = undefined;
+
+    // Act
+    const result = isError(input);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("文字列を渡したとき、false になる", ({ expect }) => {
+    // Arrange
+    const input = "some error message";
+
+    // Act
+    const result = isError(input);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("name のみが定義されたオブジェクトを渡したとき、false になる", ({ expect }) => {
+    // Arrange
+    const input = { name: "Error" };
+
+    // Act
+    const result = isError(input);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("message のみが定義されたオブジェクトを渡したとき、false になる", ({ expect }) => {
+    // Arrange
+    const input = { message: "error occurred" };
+
+    // Act
+    const result = isError(input);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("name が string ではないオブジェクトを渡したとき、false になる", ({ expect }) => {
+    // Arrange
+    const input = { name: 123, message: "error" };
+
+    // Act
+    const result = isError(input);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+});

package/tests/core/_is-promise-like.test.ts

@@ -0,0 +1,100 @@
+import { describe, test } from "vitest";
+import isPromiseLike from "../../src/core/_is-promise-like.js";
+
+describe("値が PromiseLike である場合", () => {
+  test("Promise インスタンスを渡したとき、 true を返す", ({ expect }) => {
+    // Arrange
+    const value = Promise.resolve("test");
+
+    // Act
+    const result = isPromiseLike(value);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("then メソッドを持つオブジェクトを渡したとき、 true を返す", ({ expect }) => {
+    // Arrange
+    const value = {
+      then: () => {},
+    };
+
+    // Act
+    const result = isPromiseLike(value);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+});
+
+describe("値が PromiseLike ではない場合", () => {
+  test("null を渡したとき、 false を返す", ({ expect }) => {
+    // Arrange
+    const value = null;
+
+    // Act
+    const result = isPromiseLike(value);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("undefined を渡したとき、 false を返す", ({ expect }) => {
+    // Arrange
+    const value = undefined;
+
+    // Act
+    const result = isPromiseLike(value);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("then プロパティを持たないオブジェクトを渡したとき、 false を返す", ({ expect }) => {
+    // Arrange
+    const value = {
+      other: "property",
+    };
+
+    // Act
+    const result = isPromiseLike(value);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("then プロパティが関数ではないオブジェクトを渡したとき、 false を返す", ({ expect }) => {
+    // Arrange
+    const value = {
+      then: "not a function",
+    };
+
+    // Act
+    const result = isPromiseLike(value);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("プリミティブな数値を渡したとき、 false を返す", ({ expect }) => {
+    // Arrange
+    const value = 123;
+
+    // Act
+    const result = isPromiseLike(value);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("プリミティブな文字列を渡したとき、 false を返す", ({ expect }) => {
+    // Arrange
+    const value = "string";
+
+    // Act
+    const result = isPromiseLike(value);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+});

package/tests/core/_match-route-path.test.ts

@@ -0,0 +1,74 @@
+import { describe, test } from "vitest";
+import matchPath from "../../src/core/_match-route-path.js";
+
+describe("パス名がルートのパターンに合致する場合", () => {
+  test("パスから動的パラメーターが抽出され、MatchPathResult オブジェクトが返される", ({ expect }) => {
+    // Arrange
+    const route = {
+      // path: "/users/:id",
+      pathPattern: /^\/users\/([^/]+?)(?:\/)?$/i,
+      paramKeys: ["id"],
+    };
+    const pathname = "/users/123";
+
+    // Act
+    const result = matchPath(route, pathname);
+
+    // Assert
+    expect(result).not.toBeNull();
+    expect(result?.params).toStrictEqual({ id: "123" });
+  });
+
+  test("複数の動的パラメーターが含まれるとき、すべてのパラメーターが正しく抽出される", ({ expect }) => {
+    // Arrange
+    const route = {
+      // path: "/posts/:year/:month",
+      pathPattern: /^\/posts\/([^/]+?)\/([^/]+?)(?:\/)?$/i,
+      paramKeys: ["year", "month"],
+    };
+    const pathname = "/posts/2025/12";
+
+    // Act
+    const result = matchPath(route, pathname);
+
+    // Assert
+    expect(result?.params).toStrictEqual({
+      year: "2025",
+      month: "12",
+    });
+  });
+
+  test("パスに動的パラメーターが含まれないとき、空の params を持つオブジェクトが返される", ({ expect }) => {
+    // Arrange
+    const route = {
+      // path: "/about",
+      pathPattern: /^\/about(?:\/)?$/i,
+      paramKeys: [],
+    };
+    const pathname = "/about";
+
+    // Act
+    const result = matchPath(route, pathname);
+
+    // Assert
+    expect(result?.params).toStrictEqual({});
+  });
+});
+
+describe("パス名がルートのパターンに合致しない場合", () => {
+  test("マッチングに失敗したとき、null が返される", ({ expect }) => {
+    // Arrange
+    const route = {
+      // path: "/users/:id",
+      pathPattern: /^\/users\/([^/]+?)(?:\/)?$/i,
+      paramKeys: ["id"],
+    };
+    const pathname = "/other/123";
+
+    // Act
+    const result = matchPath(route, pathname);
+
+    // Assert
+    expect(result).toBeNull();
+  });
+});

package/tests/core/_process-routes.test.ts

@@ -0,0 +1,146 @@
+import { describe, test } from "vitest";
+import preprocessRoutes from "../../src/core/_process-routes.js";
+import type { RouteDefinition } from "../../src/core/route.types.js";
+
+describe("パスの正規化とマッチング", () => {
+  test("階層構造を持つルート定義を渡したとき、親のパスを引き継いで正規化される", ({ expect }) => {
+    // Arrange
+    const routes: RouteDefinition[] = [
+      {
+        path: "parent",
+        children: [
+          { path: "child" },
+        ],
+      },
+    ];
+
+    // Act
+    const result = preprocessRoutes(routes);
+
+    // Assert
+    expect(result[0]?.path).toBe("/parent");
+    expect(result[0]?.children[0]?.path).toBe("/parent/child");
+  });
+
+  test("ルート定義が入れ子になっているとき、パスパターンの正規表現が適切に生成される", ({ expect }) => {
+    // Arrange
+    const routes: RouteDefinition[] = [
+      {
+        path: "/users",
+        children: [
+          { path: ":id" },
+        ],
+      },
+    ];
+
+    // Act
+    const result = preprocessRoutes(routes);
+    const childRoute = result[0]?.children[0];
+
+    // Assert
+    expect(childRoute?.pathPattern).toBeInstanceOf(RegExp);
+    expect(childRoute?.pathPattern.test("/users/123")).toBe(true);
+    expect(childRoute?.paramKeys).toStrictEqual(["id"]);
+  });
+
+  test("複数のルートが存在するとき、パスの文字列順でソートされる", ({ expect }) => {
+    // Arrange
+    const routes: RouteDefinition[] = [
+      { path: "/zebra" },
+      { path: "/apple" },
+    ];
+
+    // Act
+    const result = preprocessRoutes(routes);
+
+    // Assert
+    expect(result[0]?.path).toBe("/apple");
+    expect(result[1]?.path).toBe("/zebra");
+  });
+});
+
+describe("データ操作関数の補完", () => {
+  test("dataFunctions が未定義の場合、空の配列として処理される", ({ expect }) => {
+    // Arrange
+    const routes: RouteDefinition[] = [
+      { path: "/" },
+    ];
+
+    // Act
+    const result = preprocessRoutes(routes);
+
+    // Assert
+    expect(result[0]?.dataFuncs).toStrictEqual([]);
+  });
+
+  test("shouldAction または shouldReload が未定義のとき、常にデフォルト判定を返す関数が設定される", ({ expect }) => {
+    // Arrange
+    const routes: RouteDefinition[] = [
+      {
+        path: "/",
+        dataFunctions: [
+          {
+            loader: async () => ({}),
+            // shouldReload と shouldAction は省略
+          },
+        ],
+      },
+    ];
+
+    // Act
+    const result = preprocessRoutes(routes);
+    const dataFunc = result[0]?.dataFuncs[0];
+
+    // Assert
+    expect(dataFunc?.shouldAction({ defaultShouldAction: true } as any)).toBe(true);
+    expect(dataFunc?.shouldReload({ defaultShouldReload: false } as any)).toBe(false);
+  });
+
+  test("定義された action や loader がそのまま保持される", ({ expect }) => {
+    // Arrange
+    const mockLoader = async () => ({ message: "hello" });
+    const routes: RouteDefinition[] = [
+      {
+        path: "/",
+        dataFunctions: [{ loader: mockLoader }],
+      },
+    ];
+
+    // Act
+    const result = preprocessRoutes(routes);
+
+    // Assert
+    expect(result[0]?.dataFuncs[0]?.loader).toBe(mockLoader);
+  });
+});
+
+describe("ルートの属性判定", () => {
+  test("子ルートを持たないルートは、index 属性が true になる", ({ expect }) => {
+    // Arrange
+    const routes: RouteDefinition[] = [
+      { path: "/leaf" },
+    ];
+
+    // Act
+    const result = preprocessRoutes(routes);
+
+    // Assert
+    expect(result[0]?.index).toBe(true);
+  });
+
+  test("子ルートを持つルートは、index 属性が false になる", ({ expect }) => {
+    // Arrange
+    const routes: RouteDefinition[] = [
+      {
+        path: "/parent",
+        children: [{ path: "child" }],
+      },
+    ];
+
+    // Act
+    const result = preprocessRoutes(routes);
+
+    // Assert
+    expect(result[0]?.index).toBe(false);
+  });
+});

package/tests/core/_singleton.test.ts

@@ -0,0 +1,102 @@
+import { afterEach, describe, test } from "vitest";
+import singleton from "../../src/core/_singleton.js";
+
+afterEach(() => {
+  // テスト後にキャッシュをクリーンアップする。
+  globalThis.soseki__singleton = undefined;
+});
+
+describe("同期関数の場合", () => {
+  test("初回呼び出しのとき、ファクトリー関数の戻り値を返す", ({ expect }) => {
+    // Arrange
+    const key = "test-key";
+    const expectedValue = { id: 1 };
+
+    // Act
+    const result = singleton(key, () => expectedValue);
+
+    // Assert
+    expect(result).toBe(expectedValue);
+  });
+
+  test("同じキーで複数回呼び出したとき、常に最初に生成されたインスタンスを返す", ({ expect }) => {
+    // Arrange
+    const key = "stable-key";
+    let callCount = 0;
+    const factory = () => {
+      callCount++;
+      return { count: callCount };
+    };
+
+    // Act
+    const firstResult = singleton(key, factory);
+    const secondResult = singleton(key, factory);
+
+    // Assert
+    expect(secondResult).toBe(firstResult);
+    expect(callCount).toBe(1);
+  });
+
+  test("異なるキーで呼び出したとき、それぞれ個別のインスタンスを返す", ({ expect }) => {
+    // Arrange
+    const keyA = "key-a";
+    const keyB = "key-b";
+
+    // Act
+    const resultA = singleton(keyA, () => ({ name: "A" }));
+    const resultB = singleton(keyB, () => ({ name: "B" }));
+
+    // Assert
+    expect(resultA).not.toBe(resultB);
+  });
+});
+
+describe("非同期関数の場合", () => {
+  test("初回呼び出しのとき、解決された値を返す Promise を返す", async ({ expect }) => {
+    // Arrange
+    const key = "async-key";
+    const expectedValue = "resolved-value";
+
+    // Act
+    const resultPromise = singleton(key, async () => expectedValue);
+    const result = await resultPromise;
+
+    // Assert
+    expect(result).toBe(expectedValue);
+  });
+
+  test("解決待ちの間に再度呼び出されたとき、同一の Promise インスタンスを返す", ({ expect }) => {
+    // Arrange
+    const key = "pending-key";
+    const factory = async () => "value";
+
+    // Act
+    const firstPromise = singleton(key, factory);
+    const secondPromise = singleton(key, factory);
+
+    // Assert
+    expect(firstPromise).toBe(secondPromise);
+  });
+
+  test("Promise が拒絶されたとき、次に呼び出された際にファクトリー関数を再実行する", async ({ expect }) => {
+    // Arrange
+    const key = "error-key";
+    let callCount = 0;
+    const factory = async () => {
+      callCount++;
+      if (callCount === 1) {
+        throw new Error("初回失敗");
+      }
+      return "成功";
+    };
+
+    // Act & Assert
+    // 1 回目の呼び出し：エラーになることを確認する。
+    await expect(singleton(key, factory)).rejects.toThrow("初回失敗");
+
+    // 2 回目の呼び出し：キャッシュが削除されており、再試行されることを確認する。
+    const secondResult = await singleton(key, factory);
+    expect(secondResult).toBe("成功");
+    expect(callCount).toBe(2);
+  });
+});

package/tests/core/_unreachable.test.ts

@@ -0,0 +1,38 @@
+import { describe, test } from "vitest";
+import unreachable from "../../src/core/_unreachable.js";
+import { UnreachableError } from "../../src/core/errors.js";
+
+describe("引数なしで呼び出した場合", () => {
+  test("UnreachableError がスローされる", ({ expect }) => {
+    // Arrange
+    const act = () => {
+      unreachable();
+    };
+
+    // Act & Assert
+    expect(act).toThrow(UnreachableError);
+  });
+});
+
+describe("switch 文の網羅性チェックなどで予期しない値が渡された場合", () => {
+  test("渡された値を含む UnreachableError がスローされる", ({ expect }) => {
+    // Arrange
+    type Shape = "circle" | "square";
+    const shape = "triangle" as unknown as Shape;
+
+    // Act
+    const act = () => {
+      switch (shape) {
+        case "circle":
+          return 1;
+        case "square":
+          return 2;
+        default:
+          return unreachable(shape);
+      }
+    };
+
+    // Assert
+    expect(act).toThrow(UnreachableError);
+  });
+});

package/tests/core/_use-singleton.test.ts

@@ -0,0 +1,47 @@
+import { test, vi } from "vitest";
+import { renderHook } from "vitest-browser-react";
+import useSingleton from "../../src/core/_use-singleton.js";
+
+test("最初のレンダリング時に、初期化関数が実行されてその結果を返す", async ({ expect }) => {
+  // Arrange
+  const expectedValue = "initial value";
+  const initFn = () => expectedValue;
+
+  // Act
+  const { result } = await renderHook(() => useSingleton(initFn));
+
+  // Assert
+  expect(result.current).toBe(expectedValue);
+});
+
+test("再レンダリングが発生しても、初期化関数は二度目以降の実行はされない", async ({ expect }) => {
+  // Arrange
+  const initFn = vi.fn(() => ({ id: Math.random() }));
+
+  // Act
+  const { rerender } = await renderHook(() => useSingleton(initFn));
+
+  // 再レンダリングを実行する。
+  await rerender();
+  await rerender();
+
+  // Assert
+  expect(initFn).toHaveBeenCalledTimes(1);
+});
+
+test("再レンダリングが発生しても、最初に生成されたオブジェクトと同一のインスタンスを返し続ける", async ({ expect }) => {
+  // Arrange
+  // 毎回新しいオブジェクトを生成する初期化関数を準備
+  const initFn = () => ({ timestamp: Date.now() });
+
+  // Act
+  const { result, rerender } = await renderHook(() => useSingleton(initFn));
+  const firstResult = result.current;
+
+  await rerender();
+  const secondResult = result.current;
+
+  // Assert
+  // 参照が同一であることを確認し、シングルトンとしての振る舞いを保証
+  expect(secondResult).toBe(firstResult);
+});