@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/getting-start-tdd/node/11-immutable-data-and-pipeline.md

@@ -1,216 +0,0 @@
----
-type: Article
-title: "第 11 章: 不変データとパイプライン処理"
-description: "前章では高階関数と関数合成を学びました。"
-tags: [article, getting-start-tdd, node]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 11 章: 不変データとパイプライン処理
-
-## 11.1 はじめに
-
-前章では高階関数と関数合成を学びました。この章では **不変データ** の原則をさらに深め、**パイプライン処理** でデータを流れるように変換するパターンを学びます。
-
-## 11.2 不変データの原則
-
-### 既存の不変設計
-
-第 3 部で実装した FizzBuzzList は既に不変性を備えています。
-
-| メカニズム | 実装方法 |
-|-----------|---------|
-| **フィールドの凍結** | `Object.freeze([...list])` |
-| **不変な追加** | `add()` は新しいインスタンスを返す |
-| **readonly 型** | `readonly FizzBuzzValue[]` で型レベルの保護 |
-| **private フィールド** | 外部から直接変更不可 |
-
-### TypeScript の不変性サポート
-
-| 手法 | 用途 |
-|------|------|
-| `readonly` 修飾子 | プロパティの再代入を防止 |
-| `ReadonlyArray<T>` | 配列の変更メソッドを型レベルで禁止 |
-| `Object.freeze()` | 実行時にオブジェクトの変更を防止 |
-| `as const` | リテラル型の推論と readonly 化 |
-| Spread 演算子 | `{...obj}` / `[...arr]` でシャローコピー |
-
-## 11.3 パイプライン処理メソッド
-
-### groupBy: 値の種類ごとにグループ化
-
-```typescript
-groupBy(fn: (value: FizzBuzzValue) => string): Map<string, FizzBuzzList> {
-  return this._list.reduce((groups, value) => {
-    const key = fn(value);
-    const group = groups.get(key) ?? new FizzBuzzList();
-    groups.set(key, group.add(value));
-    return groups;
-  }, new Map<string, FizzBuzzList>());
-}
-```
-
-### countBy: 種類ごとの出現回数をカウント
-
-```typescript
-countBy(fn: (value: FizzBuzzValue) => string): Map<string, number> {
-  return this._list.reduce((counts, value) => {
-    const key = fn(value);
-    counts.set(key, (counts.get(key) ?? 0) + 1);
-    return counts;
-  }, new Map<string, number>());
-}
-```
-
-### take / first / join
-
-```typescript
-take(n: number): FizzBuzzList {
-  return new FizzBuzzList(this._list.slice(0, Math.max(0, n)));
-}
-
-first(): FizzBuzzValue | undefined {
-  return this._list[0];
-}
-
-join(separator: string): string {
-  return this._list.map((value) => value.toString()).join(separator);
-}
-```
-
-## 11.4 ジェネレータベースの生成
-
-### ジェネレータ関数
-
-TypeScript の `function*` でジェネレータを定義し、遅延評価でシーケンスを生成します。
-
-```typescript
-private static *sequence(
-  type: FizzBuzzGenerator,
-  count: number,
-): Generator<FizzBuzzValue> {
-  for (let number = 1; number <= count; number += 1) {
-    yield type.generate(number);
-  }
-}
-
-static generate(type: FizzBuzzGenerator, count: number): FizzBuzzList {
-  return new FizzBuzzList([...FizzBuzzList.sequence(type, count)]);
-}
-```
-
-### 循環参照の回避
-
-`FizzBuzzType` を直接 import すると循環参照が発生するため、構造的型付けで回避します。
-
-```typescript
-type FizzBuzzGenerator = {
-  generate(number: number): FizzBuzzValue;
-};
-```
-
-TypeScript のダックタイピングにより、`FizzBuzzType` のインスタンスは `FizzBuzzGenerator` 型を自動的に満たします。
-
-## 11.5 テスト
-
-### パイプライン処理テスト
-
-```typescript
-describe("パイプライン処理", () => {
-  const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
-  const list = FizzBuzzList.generate(type, 15);
-
-  test("groupBy で値の種類ごとにグループ化する", () => {
-    const groups = list.groupBy((v) => {
-      if (v.value === "FizzBuzz") return "FizzBuzz";
-      if (v.value === "Fizz") return "Fizz";
-      if (v.value === "Buzz") return "Buzz";
-      return "number";
-    });
-    expect(groups.get("Fizz")?.size).toBe(4);
-    expect(groups.get("Buzz")?.size).toBe(2);
-    expect(groups.get("FizzBuzz")?.size).toBe(1);
-    expect(groups.get("number")?.size).toBe(8);
-  });
-
-  test("countBy で種類ごとの出現回数をカウントする", () => {
-    const counts = list.countBy((v) => {
-      if (v.value === "FizzBuzz") return "FizzBuzz";
-      if (v.value === "Fizz") return "Fizz";
-      if (v.value === "Buzz") return "Buzz";
-      return "number";
-    });
-    expect(counts.get("Fizz")).toBe(4);
-    expect(counts.get("FizzBuzz")).toBe(1);
-  });
-
-  test("take で先頭N件を取得する", () => {
-    expect(list.take(3).toStringArray()).toEqual(["1", "2", "Fizz"]);
-  });
-
-  test("first で最初の要素を取得する", () => {
-    expect(list.first()?.toString()).toBe("1");
-  });
-
-  test("join で文字列結合する", () => {
-    expect(list.take(5).join(", ")).toBe("1, 2, Fizz, 4, Buzz");
-  });
-
-  test("メソッドチェーンでパイプライン処理する", () => {
-    const result = list
-      .filter((v) => v.value === "Fizz")
-      .take(2)
-      .join(", ");
-    expect(result).toBe("Fizz, Fizz");
-  });
-});
-```
-
-### 静的生成メソッドテスト
-
-```typescript
-describe("静的生成メソッド", () => {
-  test("generate でリストを生成する", () => {
-    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
-    const list = FizzBuzzList.generate(type, 15);
-    expect(list.size).toBe(15);
-    expect(list.first()?.toString()).toBe("1");
-  });
-});
-```
-
-### テスト実行結果
-
-```
- ✓ test/fizzbuzz/domain/model/fizz-buzz-list.test.ts (15 tests) 10ms
- ✓ test/fizzbuzz/domain/model/fizz-buzz-value.test.ts (4 tests) 3ms
- ✓ test/fizzbuzz/domain/type/fizz-buzz-type.test.ts (16 tests) 7ms
- ✓ test/fizzbuzz/domain/type/fizz-buzz-util.test.ts (6 tests) 4ms
- ✓ test/fizzbuzz/application/fizz-buzz-command.test.ts (3 tests) 4ms
-
- Test Files  5 passed (5)
-      Tests  44 passed (44)
-```
-
-## 11.6 各言語のパイプライン比較
-
-| 概念 | TypeScript | Java | Python |
-|------|-----------|------|--------|
-| パイプライン | メソッドチェーン | Stream API | ジェネレータ + itertools |
-| グループ化 | `Map` + `reduce` | `Collectors.groupingBy()` | `dict` + ループ |
-| 遅延評価 | `function*` ジェネレータ | `Stream` の中間操作 | `yield` ジェネレータ |
-| 不変コピー | Spread `[...arr]` | `Collections.unmodifiableList()` | `tuple` / `frozenset` |
-| 結合 | `array.join()` | `Collectors.joining()` | `str.join()` |
-
-## 11.7 まとめ
-
-この章で学んだこと:
-
-1. **不変データ**: `Object.freeze()`、`readonly`、Spread 演算子で不変性を保証
-2. **パイプライン処理**: `groupBy`、`countBy`、`take`、`first`、`join` でデータを流れるように変換
-3. **メソッドチェーン**: `.filter().take().join()` の連鎖で宣言的なデータ処理
-4. **ジェネレータ**: `function*` と `yield` による遅延評価シーケンス
-5. **構造的型付け**: 循環参照を避けるダックタイピング
-
-次の章では、エラーハンドリングと型安全性の観点から、TypeScript の型システムを活用したより安全なコードを学びます。

package/lib/assets/docs/article/getting-start-tdd/node/12-error-handling-and-type-safety.md

@@ -1,304 +0,0 @@
----
-type: Article
-title: "第 12 章: エラーハンドリングと型安全性"
-description: "前章までに関数型のコレクション操作とパイプライン処理を学びました。"
-tags: [article, getting-start-tdd, node]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 12 章: エラーハンドリングと型安全性
-
-## 12.1 はじめに
-
-前章までに関数型のコレクション操作とパイプライン処理を学びました。この最終章では、TypeScript の型システムを活用した **型安全なエラーハンドリング** を実装します。
-
-## 12.2 現在の問題点
-
-### 数値ベースのファクトリメソッド
-
-```typescript
-// 現在の実装: 数値で型を指定
-static create(type: number = FizzBuzzType.TYPE_01): FizzBuzzType {
-  switch (type) {
-    case FizzBuzzType.TYPE_01: return new FizzBuzzType01();
-    // ...
-    default: throw new Error(`未定義のタイプ: ${type}`);
-  }
-}
-```
-
-**問題点**:
-
-- `number` 型は任意の数値を受け付ける（型安全でない）
-- 無効な値を渡すとランタイムエラーが発生
-- コンパイル時にミスを検出できない
-
-## 12.3 FizzBuzzTypeName enum
-
-### 型安全な列挙型
-
-```typescript
-export enum FizzBuzzTypeName {
-  TYPE_01 = "TYPE_01",
-  TYPE_02 = "TYPE_02",
-  TYPE_03 = "TYPE_03",
-}
-```
-
-### 型安全なファクトリメソッド
-
-`tryCreate` は例外を投げず、`undefined` を返すことで安全にエラーを表現します。
-
-```typescript
-static tryCreate(typeName: FizzBuzzTypeName): FizzBuzzType | undefined {
-  const typeMap: Record<FizzBuzzTypeName, () => FizzBuzzType> = {
-    [FizzBuzzTypeName.TYPE_01]: () => new FizzBuzzType01(),
-    [FizzBuzzTypeName.TYPE_02]: () => new FizzBuzzType02(),
-    [FizzBuzzTypeName.TYPE_03]: () => new FizzBuzzType03(),
-  };
-  return typeMap[typeName]?.();
-}
-```
-
-**利点**:
-
-| 観点 | `create(number)` | `tryCreate(FizzBuzzTypeName)` |
-|------|-----------------|------------------------------|
-| **型安全性** | 任意の数値を受容 | enum 値のみ受容 |
-| **エラー処理** | 例外を throw | `undefined` を返却 |
-| **コンパイル時チェック** | なし | 不正な値はコンパイルエラー |
-| **拡張時** | switch 文を修正 | `Record` に追加 |
-
-### テスト
-
-```typescript
-describe("型安全なファクトリメソッド", () => {
-  test("FizzBuzzTypeName.TYPE_01 を指定すると FizzBuzzType01 が返る", () => {
-    const type = FizzBuzzType.tryCreate(FizzBuzzTypeName.TYPE_01);
-    expect(type).toBeInstanceOf(FizzBuzzType01);
-  });
-
-  test("FizzBuzzTypeName.TYPE_02 を指定すると FizzBuzzType02 が返る", () => {
-    const type = FizzBuzzType.tryCreate(FizzBuzzTypeName.TYPE_02);
-    expect(type).toBeInstanceOf(FizzBuzzType02);
-  });
-
-  test("FizzBuzzTypeName.TYPE_03 を指定すると FizzBuzzType03 が返る", () => {
-    const type = FizzBuzzType.tryCreate(FizzBuzzTypeName.TYPE_03);
-    expect(type).toBeInstanceOf(FizzBuzzType03);
-  });
-});
-```
-
-## 12.4 検索メソッドと Union Types
-
-### FizzBuzzList の検索メソッド
-
-`find` は `FizzBuzzValue | undefined` を返す Union Type で、値が見つからない可能性を型で表現します。
-
-```typescript
-find(
-  predicate: (value: FizzBuzzValue) => boolean,
-): FizzBuzzValue | undefined {
-  return this._list.find(predicate);
-}
-
-some(predicate: (value: FizzBuzzValue) => boolean): boolean {
-  return this._list.some(predicate);
-}
-
-every(predicate: (value: FizzBuzzValue) => boolean): boolean {
-  return this._list.every(predicate);
-}
-```
-
-### Union Type の活用
-
-TypeScript の Union Type（`T | undefined`）は、Java の `Optional<T>` や Python の `T | None` に相当します。
-
-```typescript
-const result = list.find(isFizz);
-if (result !== undefined) {
-  // ここでは result は FizzBuzzValue 型に絞り込まれる
-  console.log(result.value);
-}
-```
-
-### テスト
-
-```typescript
-describe("検索メソッド", () => {
-  const list = FizzBuzzList.generate(
-    FizzBuzzType.create(FizzBuzzType.TYPE_01),
-    15,
-  );
-
-  test("find で条件に合う最初の要素を見つける", () => {
-    const result = list.find((v) => v.value === "Fizz");
-    expect(result?.toString()).toBe("Fizz");
-  });
-
-  test("find で見つからない場合 undefined を返す", () => {
-    const result = list.find((v) => v.value === "NotExist");
-    expect(result).toBeUndefined();
-  });
-
-  test("some で条件に合う要素があるか判定する", () => {
-    expect(list.some((v) => v.value === "Buzz")).toBe(true);
-    expect(list.some((v) => v.value === "NotExist")).toBe(false);
-  });
-
-  test("every で全要素が条件を満たすか判定する", () => {
-    const numberList = FizzBuzzList.generate(
-      FizzBuzzType.create(FizzBuzzType.TYPE_02),
-      5,
-    );
-    expect(numberList.every((v) => !isNaN(Number(v.value)))).toBe(true);
-    expect(list.every((v) => !isNaN(Number(v.value)))).toBe(false);
-  });
-});
-```
-
-## 12.5 Type Guards
-
-### カスタム Type Guard
-
-TypeScript の **Type Guard** 関数で、`unknown` 型から安全に型を絞り込みます。
-
-```typescript
-export function isFizzBuzzValue(value: unknown): value is FizzBuzzValue {
-  return value instanceof FizzBuzzValue;
-}
-
-export function isFizzBuzzList(value: unknown): value is FizzBuzzList {
-  return value instanceof FizzBuzzList;
-}
-```
-
-### 使用例
-
-```typescript
-function processResult(result: unknown): string {
-  if (isFizzBuzzValue(result)) {
-    return result.toString(); // FizzBuzzValue として安全にアクセス
-  }
-  if (isFizzBuzzList(result)) {
-    return result.join(", "); // FizzBuzzList として安全にアクセス
-  }
-  return "unknown";
-}
-```
-
-### テスト
-
-```typescript
-describe("型ガード", () => {
-  test("isFizzBuzzValue は FizzBuzzValue インスタンスで true を返す", () => {
-    expect(isFizzBuzzValue(new FizzBuzzValue("Fizz", 3))).toBe(true);
-  });
-
-  test("isFizzBuzzValue は非インスタンスで false を返す", () => {
-    expect(isFizzBuzzValue("Fizz")).toBe(false);
-    expect(isFizzBuzzValue(null)).toBe(false);
-  });
-});
-```
-
-## 12.6 エントリポイントの更新
-
-```typescript
-// src/index.ts
-export {
-  FizzBuzzValue,
-  FizzBuzzList,
-  FizzBuzzType,
-  FizzBuzzTypeName,
-  FizzBuzzType01,
-  FizzBuzzType02,
-  FizzBuzzType03,
-  isFizzBuzzList,
-  isFizzBuzzValue,
-  FizzBuzzValueCommand,
-  FizzBuzzListCommand,
-} from "./fizzbuzz/index.js";
-```
-
-### テスト実行結果
-
-```
- ✓ test/fizzbuzz/domain/model/fizz-buzz-value.test.ts (4 tests) 3ms
- ✓ test/fizzbuzz/application/fizz-buzz-command.test.ts (3 tests) 5ms
- ✓ test/fizzbuzz/domain/type/fizz-buzz-util.test.ts (8 tests) 5ms
- ✓ test/fizzbuzz/domain/type/fizz-buzz-type.test.ts (19 tests) 7ms
- ✓ test/fizzbuzz/domain/model/fizz-buzz-list.test.ts (19 tests) 10ms
-
- Test Files  5 passed (5)
-      Tests  53 passed (53)
-```
-
-## 12.7 各言語のエラーハンドリング比較
-
-| 概念 | TypeScript | Java | Python |
-|------|-----------|------|--------|
-| Null 安全 | `T \| undefined`、`?` 演算子 | `Optional<T>` | `T \| None`、型ヒント |
-| 列挙型 | `enum` | `enum` | `enum.Enum` |
-| 型ガード | `value is T` 述語 | `instanceof` | `isinstance()` |
-| パターンマッチ | （TC39 提案中） | switch 式 | `match` 文（3.10+） |
-| 型安全ファクトリ | `Record<Enum, () => T>` | switch 式 + enum | `dict[Enum, Callable]` |
-
-## 12.8 第 4 部のまとめ
-
-第 4 部（章 10〜12）を通じて、OOP 設計のコードに関数型プログラミングのパターンを適用しました。
-
-| 章 | テーマ | 適用した概念 |
-|---|--------|-----------|
-| 10 | 高階関数と関数合成 | map/filter/reduce、compose/pipe、述語関数 |
-| 11 | 不変データとパイプライン | groupBy/countBy/take/join、ジェネレータ、構造的型付け |
-| 12 | エラーハンドリングと型安全性 | enum ファクトリ、Union Types、Type Guards |
-
-### 全 12 章の旅
-
-| 部 | 章 | テーマ |
-|---|---|--------|
-| **第 1 部** | 1-3 | TDD の基本サイクル（Red-Green-Refactor） |
-| **第 2 部** | 4-6 | 開発環境と自動化（Git、ESLint、CI/CD） |
-| **第 3 部** | 7-9 | OOP 設計（Strategy、Command、SOLID、モジュール設計） |
-| **第 4 部** | 10-12 | 関数型プログラミング（高階関数、パイプライン、型安全性） |
-
-### 最終的なディレクトリ構成
-
-```
-src/fizzbuzz/
-├── index.ts                          (バレルファイル)
-├── domain/
-│   ├── model/
-│   │   ├── fizz-buzz-value.ts       (値オブジェクト)
-│   │   └── fizz-buzz-list.ts        (ファーストクラスコレクション + FP メソッド)
-│   └── type/
-│       ├── fizz-buzz-type.ts        (抽象クラス + ファクトリ)
-│       ├── fizz-buzz-type-name.ts   (型安全 enum)
-│       ├── fizz-buzz-type-01.ts     (タイプ 1)
-│       ├── fizz-buzz-type-02.ts     (タイプ 2)
-│       ├── fizz-buzz-type-03.ts     (タイプ 3)
-│       └── fizz-buzz-util.ts        (関数合成 + 述語 + Type Guards)
-└── application/
-    ├── fizz-buzz-command.ts         (コマンドインターフェース)
-    ├── fizz-buzz-value-command.ts   (単一値コマンド)
-    └── fizz-buzz-list-command.ts    (リストコマンド)
-
-test/fizzbuzz/
-├── domain/
-│   ├── model/
-│   │   ├── fizz-buzz-value.test.ts  (4 tests)
-│   │   └── fizz-buzz-list.test.ts   (19 tests)
-│   └── type/
-│       ├── fizz-buzz-type.test.ts   (19 tests)
-│       └── fizz-buzz-util.test.ts   (8 tests)
-└── application/
-    └── fizz-buzz-command.test.ts    (3 tests)
-```
-
-**テスト合計: 53 テスト、5 ファイル、全パス**
-
-FizzBuzz という単純な問題を題材に、TDD の基本から OOP 設計、関数型プログラミング、型安全性まで、段階的にソフトウェア設計の本質を学びました。

package/lib/assets/docs/article/getting-start-tdd/node/index.md

@@ -1,56 +0,0 @@
-# テスト駆動開発から始める TypeScript 入門
-
-TypeScript は JavaScript に静的型付けを加えた言語で、大規模アプリケーション開発における型安全性と開発者体験を向上させます。本シリーズでは、FizzBuzz 問題を題材に TDD（テスト駆動開発）の手法を TypeScript で実践します。
-
-## 特徴
-
-- **静的型付け**: コンパイル時の型チェックによりバグを早期発見
-- **JavaScript との互換性**: 既存の JavaScript コードとシームレスに連携
-- **マルチパラダイム**: オブジェクト指向、関数型を柔軟に組み合わせ可能
-- **豊富な型システム**: ジェネリクス、ユニオン型、型ガードによる表現力
-
-## 開発環境
-
-| ツール | 用途 |
-|--------|------|
-| [Vitest](https://vitest.dev/) | テスティングフレームワーク |
-| [npm](https://www.npmjs.com/) | パッケージマネージャ |
-| [ESLint](https://eslint.org/) | リンター |
-| [Prettier](https://prettier.io/) | フォーマッター |
-| [TypeScript](https://www.typescriptlang.org/) | 静的型チェック（tsc） |
-| [Gulp](https://gulpjs.com/) | タスクランナー |
-| [@vitest/coverage-v8](https://vitest.dev/guide/coverage.html) | コードカバレッジ |
-
-## 章構成
-
-### 第 1 部: TDD の基本サイクル
-
-| 章 | テーマ |
-|----|--------|
-| [第 1 章](01-todo-list-and-first-test.md) | TODO リストと最初のテスト |
-| [第 2 章](02-fake-it-and-triangulation.md) | 仮実装と三角測量 |
-| [第 3 章](03-obvious-implementation-and-refactoring.md) | 明白な実装とリファクタリング |
-
-### 第 2 部: 開発環境と自動化
-
-| 章 | テーマ |
-|----|--------|
-| [第 4 章](04-version-control-and-conventional-commits.md) | バージョン管理と Conventional Commits |
-| [第 5 章](05-package-management-and-static-analysis.md) | パッケージ管理と静的解析 |
-| [第 6 章](06-task-runner-and-ci-cd.md) | タスクランナーと CI/CD |
-
-### 第 3 部: オブジェクト指向設計
-
-| 章 | テーマ |
-|----|--------|
-| [第 7 章](07-encapsulation-and-polymorphism.md) | カプセル化とポリモーフィズム |
-| [第 8 章](08-design-patterns.md) | デザインパターンの適用 |
-| [第 9 章](09-solid-principles-and-module-design.md) | SOLID 原則とモジュール設計 |
-
-### 第 4 部: 関数型プログラミングへの展開
-
-| 章 | テーマ |
-|----|--------|
-| [第 10 章](10-higher-order-functions-and-composition.md) | 高階関数と関数合成 |
-| [第 11 章](11-immutable-data-and-pipeline.md) | 不変データとパイプライン処理 |
-| [第 12 章](12-error-handling-and-type-safety.md) | エラーハンドリングと型安全性 |