@pai-forge/riichi-mahjong 0.1.0

package/dist/features/yaku/utils.d.ts

@@ -0,0 +1,19 @@
+import { type HaiKindId, type Kazehai, type Tehai14 } from "../../types";
+/**
+ * 手牌が門前（メンゼン）かどうかを判定する。
+ *
+ * 門前の定義:
+ * - 明刻、明順、明槓などの「晒し」が含まれていないこと。
+ * - 暗槓は門前として扱う。
+ *
+ * @param tehai 判定対象の手牌
+ * @returns 門前であれば true、そうでなければ false
+ */
+export declare function isMenzen(tehai: Tehai14): boolean;
+/**
+ * 指定された牌が風牌かどうかを判定する。
+ *
+ * @param id 判定対象の牌種ID
+ * @returns 風牌（東・南・西・北）であれば true
+ */
+export declare function isKazehai(id: HaiKindId): id is Kazehai;

package/dist/features/yaku/utils.js

@@ -0,0 +1,34 @@
+import { HaiKind, } from "../../types";
+/**
+ * 手牌が門前（メンゼン）かどうかを判定する。
+ *
+ * 門前の定義:
+ * - 明刻、明順、明槓などの「晒し」が含まれていないこと。
+ * - 暗槓は門前として扱う。
+ *
+ * @param tehai 判定対象の手牌
+ * @returns 門前であれば true、そうでなければ false
+ */
+export function isMenzen(tehai) {
+    // exposed（副露ブロック）が空なら門前
+    if (tehai.exposed.length === 0) {
+        return true;
+    }
+    // 副露ブロックがある場合、全てが「暗槓」であれば門前とみなす
+    // 暗槓の定義: typeが"Kantsu"かつfuro情報を持たない（現状のデータ構造における定義）
+    return tehai.exposed.every((m) => {
+        return m.type === "Kantsu" && !m.furo;
+    });
+}
+/**
+ * 指定された牌が風牌かどうかを判定する。
+ *
+ * @param id 判定対象の牌種ID
+ * @returns 風牌（東・南・西・北）であれば true
+ */
+export function isKazehai(id) {
+    return (id === HaiKind.Ton ||
+        id === HaiKind.Nan ||
+        id === HaiKind.Sha ||
+        id === HaiKind.Pei);
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Riichi Mahjong Library
+ */
+export { HaiKind, Tacha, FuroType, MentsuType, HaiType } from "./types";
+export type { HaiId, HaiKindId, Furo, Shuntsu, Koutsu, Kantsu, CompletedMentsu, Tehai, Tehai13, Tehai14, Mentsu, IncompletedMentsu, Kazehai, } from "./types";
+export type { YakuResult, YakuName, Hansu } from "./features/yaku";
+export { calculateShanten } from "./features/shanten";
+export { getUkeire } from "./features/machi";
+export { detectYaku } from "./features/yaku";
+export { parseMspz, parseExtendedMspz } from "./features/parser";
+export { calculateScore } from "./features/points";
+export type { ScoreResult, ScoreLevel, ScorePayment, ScoreCalculationConfig, } from "./features/points/types";

package/dist/index.js

@@ -0,0 +1,9 @@
+/**
+ * Riichi Mahjong Library
+ */
+export { HaiKind, Tacha, FuroType, MentsuType, HaiType } from "./types";
+export { calculateShanten } from "./features/shanten";
+export { getUkeire } from "./features/machi";
+export { detectYaku } from "./features/yaku";
+export { parseMspz, parseExtendedMspz } from "./features/parser";
+export { calculateScore } from "./features/points";

package/dist/types.d.ts

@@ -0,0 +1,280 @@
+/**
+ * 牌種IDの定数セット
+ *
+ * - 0-8: 萬子 (ManZu)
+ * - 9-17: 筒子 (PinZu)
+ * - 18-26: 索子 (SouZu)
+ * - 27-33: 字牌 (JiHai)
+ */
+export declare const HAI_KIND_IDS: readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33];
+type TupleOf<T, N extends number, R extends unknown[] = []> = R["length"] extends N ? R : TupleOf<T, N, [T, ...R]>;
+/**
+ * 牌の種類の総数 (34)
+ */
+export type HaiKindCount = (typeof HAI_KIND_IDS)["length"];
+/**
+ * 特定の種類の牌の所持数 (0-4枚)
+ * 各種類の牌は最大4枚まで存在します。
+ */
+export type HaiQuantity = 0 | 1 | 2 | 3 | 4;
+/**
+ * 全34種類の牌の所持数分布配列。
+ * インデックスは HaiKindId (0-33) に対応します。
+ * 各要素はその種類の牌の所持数 (0-4) です。
+ *
+ * @example
+ * // "113m 1z" (MPSZ形式) に対応
+ * const dist: HaiKindDistribution = [
+ *   2, 0, 1, 0, 0, 0, 0, 0, 0, // 萬子 (1m x2, 3m x1)
+ *   0, 0, 0, 0, 0, 0, 0, 0, 0, // 筒子
+ *   0, 0, 0, 0, 0, 0, 0, 0, 0, // 索子
+ *   1, 0, 0, 0, 0, 0, 0        // 字牌 (1z x1)
+ * ];
+ */
+export type HaiKindDistribution = Readonly<TupleOf<HaiQuantity, HaiKindCount>>;
+/**
+ * 物理的な牌の一意な識別子 (HaiId)
+ *
+ * 麻雀セットに含まれる136枚の牌それぞれに一意のIDが割り当てられます (0-135)。
+ *
+ * - 0-35: 萬子
+ * - 36-71: 筒子
+ * - 72-107: 索子
+ * - 108-135: 字牌
+ *
+ * Branded Type を使用して通常の number と区別します。
+ */
+export type HaiId = number & {
+    readonly __brand: "HaiId";
+};
+/**
+ * 牌種ID (HaiKindId)
+ *
+ * 麻雀の34種類の牌を一意に識別するID。
+ */
+export type HaiKindId = (typeof HAI_KIND_IDS)[number];
+/**
+ * 牌種 (HaiKind)
+ *
+ * 牌種IDに対応する定数定義。
+ */
+export declare const HaiKind: {
+    readonly ManZu1: 0;
+    readonly ManZu2: 1;
+    readonly ManZu3: 2;
+    readonly ManZu4: 3;
+    readonly ManZu5: 4;
+    readonly ManZu6: 5;
+    readonly ManZu7: 6;
+    readonly ManZu8: 7;
+    readonly ManZu9: 8;
+    readonly PinZu1: 9;
+    readonly PinZu2: 10;
+    readonly PinZu3: 11;
+    readonly PinZu4: 12;
+    readonly PinZu5: 13;
+    readonly PinZu6: 14;
+    readonly PinZu7: 15;
+    readonly PinZu8: 16;
+    readonly PinZu9: 17;
+    readonly SouZu1: 18;
+    readonly SouZu2: 19;
+    readonly SouZu3: 20;
+    readonly SouZu4: 21;
+    readonly SouZu5: 22;
+    readonly SouZu6: 23;
+    readonly SouZu7: 24;
+    readonly SouZu8: 25;
+    readonly SouZu9: 26;
+    readonly Ton: 27;
+    readonly Nan: 28;
+    readonly Sha: 29;
+    readonly Pei: 30;
+    readonly Haku: 31;
+    readonly Hatsu: 32;
+    readonly Chun: 33;
+};
+export type HaiKind = (typeof HaiKind)[keyof typeof HaiKind];
+/**
+ * 牌種タイプ (HaiType)
+ */
+export declare const HaiType: {
+    readonly Manzu: "Manzu";
+    readonly Pinzu: "Pinzu";
+    readonly Souzu: "Souzu";
+    readonly Jihai: "Jihai";
+};
+export type HaiType = (typeof HaiType)[keyof typeof HaiType];
+export type Suupai = typeof HaiType.Manzu | typeof HaiType.Pinzu | typeof HaiType.Souzu;
+export type Jihai = typeof HaiType.Jihai;
+/**
+ * シャンテン数 (ShantenNumber)
+ *
+ * 和了までの手数 - 1 を表す数値。
+ *
+ * - 0: テンパイ (Tenpai) - 次の1手で和了できる状態
+ * - 1: 1シャンテン - テンパイまであと1手
+ * - ...
+ * - 13: 理論上の最大値 (例: 13面待ちでない国士無双の初期状態など)
+ *
+ * ※ 本ライブラリでは、ツモる前の13枚の手牌に対する計算を前提とするため、
+ *    和了 (-1) はこの型には含めない。
+ */
+export type ShantenNumber = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13;
+/**
+ * 他家 (Tacha)
+ *
+ * 自分から見た他家の位置関係（相対席）。
+ * 副露（鳴き）の発生元などを表現するために使用する。
+ *
+ * - 1: 下家 (Shimocha) - 右側
+ * - 2: 対面 (Toimen) - 正面
+ * - 3: 上家 (Kamicha) - 左側
+ */
+export declare const Tacha: {
+    readonly Shimocha: 1;
+    readonly Toimen: 2;
+    readonly Kamicha: 3;
+};
+export type Tacha = (typeof Tacha)[keyof typeof Tacha];
+/**
+ * 副露種別 (FuroType)
+ */
+export declare const FuroType: {
+    readonly Chi: "Chi";
+    readonly Pon: "Pon";
+    readonly Daiminkan: "Daiminkan";
+    readonly Kakan: "Kakan";
+};
+export type FuroType = (typeof FuroType)[keyof typeof FuroType];
+/**
+ * 副露 (Furo)
+ *
+ * 面子に対する「鳴き」のメタ情報。
+ * ここでは副露を「自分の手牌が不足している面子を、他家が捨てた牌を取って完成させる行為」と定義し、
+ * 暗槓（自力で4枚揃える行為）はここには含めない。
+ *
+ * 構成する牌自体はここには含めず、この型を持つ親（Mentsuなど）が保持することを想定する。
+ */
+export type Furo = {
+    readonly type: typeof FuroType.Chi;
+    readonly from: Tacha;
+} | {
+    readonly type: typeof FuroType.Pon;
+    readonly from: Tacha;
+} | {
+    readonly type: typeof FuroType.Daiminkan;
+    readonly from: Tacha;
+} | {
+    readonly type: typeof FuroType.Kakan;
+    readonly from: Tacha;
+};
+/**
+ * 面子種別 (MentsuType)
+ */
+export declare const MentsuType: {
+    readonly Shuntsu: "Shuntsu";
+    readonly Koutsu: "Koutsu";
+    readonly Kantsu: "Kantsu";
+    readonly Toitsu: "Toitsu";
+    readonly Tatsu: "Tatsu";
+};
+export type MentsuType = (typeof MentsuType)[keyof typeof MentsuType];
+/**
+ * 基本的な面子構造 (ジェネリック)
+ *
+ * 牌の型をジェネリクス `T` で抽象化することで、以下の両方のユースケースに対応します：
+ * 1. `HaiKindId`: MPSZ形式の手牌をもとにシャンテン計算を行うなど、牌の種類のみに関心がある場合（抽象的な計算）。
+ * 2. `HaiId`: 実際のゲームの牌譜など、牌の物理的なIDを処理対象とする場合（具象的な計算）。
+ */
+interface BaseMentsu<T extends HaiKindId | HaiId> {
+    readonly type: MentsuType;
+    /**
+     * 構成する牌のリスト。
+     *
+     * 各面子型（Shuntsu等）において固定長タプル（例: `[T, T, T]`）として再定義することで、
+     * 面子の種類ごとの正しい牌枚数（順子なら3枚、槓子なら4枚など）を型レベルで強制します。
+     */
+    hais: readonly T[];
+}
+/**
+ * 順子 (Shuntsu)
+ */
+export type Shuntsu<T extends HaiKindId | HaiId = HaiKindId> = BaseMentsu<T> & {
+    readonly type: typeof MentsuType.Shuntsu;
+    readonly hais: readonly [T, T, T];
+    readonly furo?: Furo;
+};
+/**
+ * 刻子 (Koutsu)
+ */
+export type Koutsu<T extends HaiKindId | HaiId = HaiKindId> = BaseMentsu<T> & {
+    readonly type: typeof MentsuType.Koutsu;
+    readonly hais: readonly [T, T, T];
+    readonly furo?: Furo;
+};
+/**
+ * 槓子 (Kantsu)
+ */
+export type Kantsu<T extends HaiKindId | HaiId = HaiKindId> = BaseMentsu<T> & {
+    readonly type: typeof MentsuType.Kantsu;
+    readonly hais: readonly [T, T, T, T];
+    readonly furo?: Furo;
+};
+/**
+ * 対子 (Toitsu)
+ */
+export type Toitsu<T extends HaiKindId | HaiId = HaiKindId> = BaseMentsu<T> & {
+    readonly type: typeof MentsuType.Toitsu;
+    readonly hais: readonly [T, T];
+    readonly furo?: never;
+};
+/**
+ * 塔子 (Tatsu)
+ */
+export type Tatsu<T extends HaiKindId | HaiId = HaiKindId> = BaseMentsu<T> & {
+    readonly type: typeof MentsuType.Tatsu;
+    readonly hais: readonly [T, T];
+    readonly furo?: never;
+};
+/**
+ * 完成面子 (CompletedMentsu)
+ * - 順子 (Shuntsu)
+ * - 刻子 (Koutsu)
+ * - 槓子 (Kantsu)
+ */
+export type CompletedMentsu<T extends HaiKindId | HaiId = HaiKindId> = Shuntsu<T> | Koutsu<T> | Kantsu<T>;
+/**
+ * 未完成面子 (IncompletedMentsu)
+ * - 対子 (Toitsu)
+ * - 塔子 (Tatsu)
+ */
+export type IncompletedMentsu<T extends HaiKindId | HaiId = HaiKindId> = Toitsu<T> | Tatsu<T>;
+/**
+ * 面子 (Mentsu)
+ *
+ * 広義の面子（ブロック）。指定がない場合は HaiKindId のリストを持つ。
+ */
+export type Mentsu<T extends HaiKindId | HaiId = HaiKindId> = CompletedMentsu<T> | IncompletedMentsu<T>;
+/** 自風・場風を表す牌 (東・南・西・北) */
+export type Kazehai = typeof HaiKind.Ton | typeof HaiKind.Nan | typeof HaiKind.Sha | typeof HaiKind.Pei;
+export type HaiIsYaocyu<ID extends HaiKindId | HaiId> = ID extends 0 | 8 | 9 ? true : false;
+/**
+ * 手牌 (Tehai)
+ *
+ * 純手牌と副露を合わせたもの。
+ * @template T 牌の型 (HaiKindId | HaiId)
+ */
+export interface Tehai<T extends HaiKindId | HaiId = HaiKindId> {
+    readonly closed: readonly T[];
+    readonly exposed: readonly CompletedMentsu<T>[];
+}
+/**
+ * ツモる前の手牌 (13枚)
+ */
+export type Tehai13<T extends HaiKindId | HaiId = HaiKindId> = Tehai<T>;
+/**
+ * ツモった後の手牌 (14枚)
+ */
+export type Tehai14<T extends HaiKindId | HaiId = HaiKindId> = Tehai<T>;
+export {};

package/dist/types.js

@@ -0,0 +1,97 @@
+/**
+ * 牌種IDの定数セット
+ *
+ * - 0-8: 萬子 (ManZu)
+ * - 9-17: 筒子 (PinZu)
+ * - 18-26: 索子 (SouZu)
+ * - 27-33: 字牌 (JiHai)
+ */
+export const HAI_KIND_IDS = [
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+    22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
+];
+/**
+ * 牌種 (HaiKind)
+ *
+ * 牌種IDに対応する定数定義。
+ */
+export const HaiKind = {
+    ManZu1: 0,
+    ManZu2: 1,
+    ManZu3: 2,
+    ManZu4: 3,
+    ManZu5: 4,
+    ManZu6: 5,
+    ManZu7: 6,
+    ManZu8: 7,
+    ManZu9: 8,
+    PinZu1: 9,
+    PinZu2: 10,
+    PinZu3: 11,
+    PinZu4: 12,
+    PinZu5: 13,
+    PinZu6: 14,
+    PinZu7: 15,
+    PinZu8: 16,
+    PinZu9: 17,
+    SouZu1: 18,
+    SouZu2: 19,
+    SouZu3: 20,
+    SouZu4: 21,
+    SouZu5: 22,
+    SouZu6: 23,
+    SouZu7: 24,
+    SouZu8: 25,
+    SouZu9: 26,
+    Ton: 27,
+    Nan: 28,
+    Sha: 29,
+    Pei: 30,
+    Haku: 31,
+    Hatsu: 32,
+    Chun: 33,
+};
+/**
+ * 牌種タイプ (HaiType)
+ */
+export const HaiType = {
+    Manzu: "Manzu",
+    Pinzu: "Pinzu",
+    Souzu: "Souzu",
+    Jihai: "Jihai",
+};
+/**
+ * 他家 (Tacha)
+ *
+ * 自分から見た他家の位置関係（相対席）。
+ * 副露（鳴き）の発生元などを表現するために使用する。
+ *
+ * - 1: 下家 (Shimocha) - 右側
+ * - 2: 対面 (Toimen) - 正面
+ * - 3: 上家 (Kamicha) - 左側
+ */
+export const Tacha = {
+    Shimocha: 1,
+    Toimen: 2,
+    Kamicha: 3,
+};
+/**
+ * 副露種別 (FuroType)
+ */
+export const FuroType = {
+    Chi: "Chi",
+    Pon: "Pon",
+    Daiminkan: "Daiminkan",
+    Kakan: "Kakan",
+};
+/**
+ * 面子種別 (MentsuType)
+ */
+export const MentsuType = {
+    Shuntsu: "Shuntsu", // 順子 (123)
+    Koutsu: "Koutsu", // 刻子 (111)
+    Kantsu: "Kantsu", // 槓子 (1111)
+    Toitsu: "Toitsu", // 対子 (11)
+    Tatsu: "Tatsu", // 塔子 (12, 13)
+};
+// ... types existing ...

package/dist/utils/assertions.d.ts

@@ -0,0 +1,22 @@
+import { type HaiId, type HaiKindId } from "../types";
+/**
+ * Checks if the array has exactly 2 elements and narrows the type to a tuple.
+ */
+export declare function isTuple2<T>(arr: readonly T[]): arr is readonly [T, T];
+/**
+ * Checks if the array has exactly 3 elements and narrows the type to a tuple.
+ */
+export declare function isTuple3<T>(arr: readonly T[]): arr is readonly [T, T, T];
+/**
+ * Checks if the array has exactly 4 elements and narrows the type to a tuple.
+ */
+export declare function isTuple4<T>(arr: readonly T[]): arr is readonly [T, T, T, T];
+/**
+ * Casts a number to HaiKindId safely (conceptually).
+ * Use this only when you are sure the number is a valid HaiKindId.
+ */
+export declare function asHaiKindId(id: number): HaiKindId;
+/**
+ * Casts a number to HaiId safely (conceptually).
+ */
+export declare function asHaiId(id: number): HaiId;

package/dist/utils/assertions.js

@@ -0,0 +1,33 @@
+/**
+ * Checks if the array has exactly 2 elements and narrows the type to a tuple.
+ */
+export function isTuple2(arr) {
+    return arr.length === 2;
+}
+/**
+ * Checks if the array has exactly 3 elements and narrows the type to a tuple.
+ */
+export function isTuple3(arr) {
+    return arr.length === 3;
+}
+/**
+ * Checks if the array has exactly 4 elements and narrows the type to a tuple.
+ */
+export function isTuple4(arr) {
+    return arr.length === 4;
+}
+/**
+ * Casts a number to HaiKindId safely (conceptually).
+ * Use this only when you are sure the number is a valid HaiKindId.
+ */
+export function asHaiKindId(id) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return id;
+}
+/**
+ * Casts a number to HaiId safely (conceptually).
+ */
+export function asHaiId(id) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return id;
+}

package/dist/utils/test-helpers.d.ts

@@ -0,0 +1,55 @@
+import type { HaiId, HaiKindId, Tehai13, Tehai14, Mentsu, MentsuType } from "../types";
+import type { Shuntsu, Koutsu, Toitsu, CompletedMentsu } from "../types";
+import type { HouraStructure } from "../features/yaku/types";
+/**
+ * テスト用の Tehai13 オブジェクトを作成します。
+ * 作成時に validateTehai13 を実行し、不正な場合はエラーをスローします。
+ * これにより、テストデータが正しい Tehai13 であることを保証します。
+ */
+export declare function createTehai13<T extends HaiKindId | HaiId>(closed: readonly T[]): Tehai13<T>;
+/**
+ * テスト用の Mentsu オブジェクトを作成します。
+ */
+export declare function createMentsu<T extends HaiKindId | HaiId>(type: MentsuType, hais: readonly T[]): Mentsu<T>;
+/**
+ * テスト用の Tehai14 (和了手など) オブジェクトを作成します。
+ * Extended MSPZ形式の文字列をサポートし、副露や暗槓を含む手牌を簡単に作成できます。
+ *
+ * @param mspzString Extended MSPZ形式、または通常のMSPZ形式の文字列
+ * @returns Tehai14 オブジェクト
+ */
+export declare function createTehai(mspzString: string): Tehai14;
+/**
+ * MSPZ形式の文字列から HaiKindId の配列を作成します。
+ * テストデータの期待値作成などで使用します。
+ *
+ * @param mspzString MSPZ形式の文字列 (例: "123m")
+ * @returns HaiKindId の配列
+ */
+export declare function createHaiKindIds(mspzString: string): HaiKindId[];
+/**
+ * テスト用の順子 (Shuntsu) を作成します。
+ * isValidShuntsu によるバリデーションを行います。
+ */
+/**
+ * テスト用の順子 (Shuntsu) を作成します。
+ * isValidShuntsu によるバリデーションを行います。
+ */
+export declare function createShuntsu(mspz: string): Shuntsu;
+/**
+ * テスト用の刻子 (Koutsu) を作成します。
+ */
+export declare function createKoutsu(mspz: string): Koutsu;
+/**
+ * テスト用の対子 (Toitsu) を作成します。
+ */
+export declare function createToitsu(mspz: string): Toitsu;
+/**
+ * テスト用の HaiKindId を取得します。
+ */
+export declare function getHaiKindId(mspz: string): HaiKindId;
+/**
+ * テスト用のモック手牌 (HouraStructure) を作成します。
+ * 指定された面子と雀頭を使用し、残りはダミーの順子で埋めます。
+ */
+export declare function createMockHand(targetMentsu: CompletedMentsu, jantou: Toitsu): HouraStructure;

package/dist/utils/test-helpers.js

@@ -0,0 +1,124 @@
+import { validateTehai13 } from "../core/tehai";
+import { isExtendedMspz, parseExtendedMspz, parseMspz, } from "../features/parser";
+import { isValidShuntsu } from "../core/mentsu";
+import { isTuple2, isTuple3 } from "./assertions";
+/**
+ * テスト用の Tehai13 オブジェクトを作成します。
+ * 作成時に validateTehai13 を実行し、不正な場合はエラーをスローします。
+ * これにより、テストデータが正しい Tehai13 であることを保証します。
+ */
+export function createTehai13(closed) {
+    const tehai = {
+        closed,
+        exposed: [],
+    };
+    validateTehai13(tehai);
+    return tehai;
+}
+/**
+ * テスト用の Mentsu オブジェクトを作成します。
+ */
+export function createMentsu(type, hais) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return { type, hais };
+}
+/**
+ * テスト用の Tehai14 (和了手など) オブジェクトを作成します。
+ * Extended MSPZ形式の文字列をサポートし、副露や暗槓を含む手牌を簡単に作成できます。
+ *
+ * @param mspzString Extended MSPZ形式、または通常のMSPZ形式の文字列
+ * @returns Tehai14 オブジェクト
+ */
+export function createTehai(mspzString) {
+    if (isExtendedMspz(mspzString)) {
+        return parseExtendedMspz(mspzString);
+    }
+    // 通常のMSPZ形式の場合
+    return parseMspz(mspzString);
+}
+/**
+ * MSPZ形式の文字列から HaiKindId の配列を作成します。
+ * テストデータの期待値作成などで使用します。
+ *
+ * @param mspzString MSPZ形式の文字列 (例: "123m")
+ * @returns HaiKindId の配列
+ */
+export function createHaiKindIds(mspzString) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return parseMspz(mspzString).closed;
+}
+/**
+ * テスト用の順子 (Shuntsu) を作成します。
+ * isValidShuntsu によるバリデーションを行います。
+ */
+/**
+ * テスト用の順子 (Shuntsu) を作成します。
+ * isValidShuntsu によるバリデーションを行います。
+ */
+export function createShuntsu(mspz) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const ids = parseMspz(mspz).closed;
+    // Use core validation
+    if (!isValidShuntsu(ids)) {
+        throw new Error(`Invalid Shuntsu: ${mspz}`);
+    }
+    // isValidShuntsu ensures it is a valid Tuple3 of HaiKindId
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+    const validIds = ids;
+    return {
+        type: "Shuntsu",
+        hais: validIds,
+    };
+}
+/**
+ * テスト用の刻子 (Koutsu) を作成します。
+ */
+export function createKoutsu(mspz) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const ids = parseMspz(mspz).closed;
+    if (!isTuple3(ids))
+        throw new Error(`Invalid Koutsu: ${mspz}`);
+    return {
+        type: "Koutsu",
+        hais: ids,
+    };
+}
+/**
+ * テスト用の対子 (Toitsu) を作成します。
+ */
+export function createToitsu(mspz) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const ids = parseMspz(mspz).closed;
+    if (!isTuple2(ids))
+        throw new Error(`Invalid Toitsu: ${mspz}`);
+    return {
+        type: "Toitsu",
+        hais: ids,
+    };
+}
+/**
+ * テスト用の HaiKindId を取得します。
+ */
+export function getHaiKindId(mspz) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const ids = parseMspz(mspz).closed;
+    if (ids.length === 0)
+        throw new Error(`Invalid HaiKindId: ${mspz}`);
+    const id = ids[0];
+    if (id === undefined)
+        throw new Error(`Internal Error: id is undefined`);
+    return id;
+}
+/**
+ * テスト用のモック手牌 (HouraStructure) を作成します。
+ * 指定された面子と雀頭を使用し、残りはダミーの順子で埋めます。
+ */
+export function createMockHand(targetMentsu, jantou) {
+    // Fill rest with dummy
+    const dummyShuntsu = createShuntsu("123s");
+    return {
+        type: "Mentsu",
+        fourMentsu: [targetMentsu, dummyShuntsu, dummyShuntsu, dummyShuntsu],
+        jantou,
+    };
+}