@konoui/mjimage 0.0.40 → 0.0.42

package/dist/index.d.cts

@@ -24,12 +24,12 @@ import { Use } from '@svgdotjs/svg.js';
 export declare class ActorHand extends Hand {
     isBackHand(): boolean;
     clone(): ActorHand;
-    dec(tiles: readonly Tile[]): Tile[];
+    dec(tiles: readonly Tile[]): readonly Tile[];
 }
 
 export declare abstract class BaseActor {
     id: string;
-    river: River;
+    river: IRiver;
     placeManager: PlaceManager;
     scoreManager: ScoreManager;
     hands: {
@@ -52,7 +52,7 @@ declare class BaseHelper {
     readonly tileHeight: number;
     readonly imageHostPath: string;
     readonly imageHostUrl: string;
-    readonly imageExt: string;
+    readonly imageExt: "svg" | "webp";
     readonly scale: number;
     readonly svgSprite: boolean;
     constructor(props?: ImageHelperConfig);
@@ -90,13 +90,13 @@ export declare abstract class Block {
     static deserialize(v: SerializedBlock): Block | BlockHand | BlockOther | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockThree | BlockRun | BlockIsolated | BlockPair;
     serialize(): {
         tiles: string;
-        type: "pon" | "chi" | "shokan" | "daikan" | "ankan" | "tsumo" | "pair" | "isolated" | "three" | "run" | "hand" | "dora" | "simple-discard" | "unknown";
+        type: BLOCK;
     };
     toJSON(): {
         tiles: string;
-        type: "pon" | "chi" | "shokan" | "daikan" | "ankan" | "tsumo" | "pair" | "isolated" | "three" | "run" | "hand" | "dora" | "simple-discard" | "unknown";
+        type: BLOCK;
     };
-    get type(): "pon" | "chi" | "shokan" | "daikan" | "ankan" | "tsumo" | "pair" | "isolated" | "three" | "run" | "hand" | "dora" | "simple-discard" | "unknown";
+    get type(): BLOCK;
     get tiles(): readonly Tile[];
     abstract toString(): string;
     is(type: BLOCK): boolean;
@@ -107,10 +107,6 @@ export declare abstract class Block {
             tile: Tile;
         };
     }): Block | BlockHand | BlockOther | BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan | BlockThree | BlockRun | BlockIsolated | BlockPair;
-    imageSize(scale: number): {
-        width: number;
-        height: number;
-    };
 }
 
 export declare class BlockAnKan extends Block {
@@ -123,12 +119,12 @@ export declare class BlockAnKan extends Block {
 export declare class BlockCalculator {
     hand: Hand;
     constructor(hand: Hand);
-    calc(lastTile: Tile): Block[][];
-    markDrawn(hands: Block[][], lastTile: Tile): Block[][];
-    sevenPairs(): Block[][];
-    thirteenOrphans(): Block[][];
-    nineGates(): Block[][];
-    fourSetsOnePair(): Block[][];
+    calc(lastTile: Tile): readonly Block[][];
+    markDrawn(hands: readonly Block[][], lastTile: Tile): readonly Block[][];
+    sevenPairs(): readonly Block[][];
+    thirteenOrphans(): readonly Block[][];
+    nineGates(): readonly Block[][];
+    fourSetsOnePair(): readonly Block[][];
     private commonAll;
     private commonByType;
 }
@@ -190,8 +186,8 @@ export declare class BlockThree extends Block {
 }
 
 export declare interface BoardContext {
-    doraMarkers: Tile[];
-    blindDoraMarkers?: Tile[];
+    doraMarkers: readonly Tile[];
+    blindDoraMarkers?: readonly Tile[];
     round: Round;
     myWind: Wind;
     ronWind?: Wind;
@@ -211,6 +207,8 @@ declare type BoardRound = (typeof ROUND_MAP)[keyof typeof ROUND_MAP];
 
 declare type BoardWind = (typeof WIND_MAP)[keyof typeof WIND_MAP];
 
+export declare const callBlockIndex: (caller: Wind, discardedBy: Wind, type: typeof BLOCK.PON | typeof BLOCK.DAI_KAN) => 0 | 1 | 2 | 3;
+
 export declare interface CallEvent {
     id: string;
     type: Extract<ChoiceEvent, "PON" | "CHI" | "AN_KAN" | "SHO_KAN" | "DAI_KAN">;
@@ -254,7 +252,7 @@ export declare interface ChoiceAfterDrawnEvent {
     choices: DrawnChoice;
 }
 
-declare type ChoiceEvent = "PON" | "CHI" | "RON" | "DISCARD" | "TSUMO" | "REACH" | "AN_KAN" | "SHO_KAN" | "DAI_KAN" | "DRAWN_GAME_BY_NINE_TILES";
+declare type ChoiceEvent = "PON" | "CHI" | "RON" | "DISCARD" | "TSUMO" | "REACH" | "AN_KAN" | "SHO_KAN" | "DAI_KAN" | "DRAWN_GAME_BY_NINE_ORPHANS";
 
 export declare interface ChoiceForChanKan {
     id: string;
@@ -267,8 +265,19 @@ export declare interface ChoiceForChanKan {
     choices: Pick<DiscardedChoice, "RON">;
 }
 
+export declare interface ChoiceForReachAcceptance {
+    id: string;
+    type: Extract<Event_2, "CHOICE_FOR_REACH_ACCEPTANCE">;
+    wind: Wind;
+    reacherInfo: {
+        wind: Wind;
+        tile: string;
+    };
+    choices: Pick<DiscardedChoice, "RON">;
+}
+
 export declare class Controller {
-    wall: Wall;
+    wall: IWall;
     playerIDs: string[];
     actor: Actor<StateMachine<    {
     currentWind: Wind;
@@ -307,6 +316,12 @@ export declare class Controller {
     tile: Tile;
     iam: Wind;
     } | {
+    type: "REACH_ACCEPT";
+    reacherInfo: {
+    tile: Tile;
+    wind: Wind;
+    };
+    } | {
     type: "DISCARD";
     tile: Tile;
     iam: Wind;
@@ -323,7 +338,7 @@ export declare class Controller {
     block: BlockDaiKan;
     iam: Wind;
     } | {
-    type: "DRAWN_GAME_BY_NINE_TILES";
+    type: "DRAWN_GAME_BY_NINE_ORPHANS";
     iam: Wind;
     }, Record<string, AnyActorRef>, ProvidedActor, ParameterizedObject, ParameterizedObject, never, StateValue, string, unknown, NonReducibleUnknown, EventObject, MetaObject, any>>;
     observer: Observer;
@@ -335,15 +350,15 @@ export declare class Controller {
     };
     histories: History_2[];
     debugMode: boolean;
-    snapshot?: string;
-    constructor(players: PlayerProps[], params?: {
+    constructor(players: PlayerConnection[], params?: {
         debug?: boolean;
+        shuffle?: boolean;
     });
     boardParams(w: Wind): BoardContext;
     hand(w: Wind): ActorHand;
     get placeManager(): PlaceManager;
     get scoreManager(): ScoreManager;
-    get river(): River;
+    get river(): IRiver;
     next(force?: boolean): void;
     emit(e: PlayerEvent): void;
     enqueue(event: PlayerEvent): void;
@@ -358,17 +373,17 @@ export declare class Controller {
         replacementWin?: boolean;
         oneShot?: boolean;
         missingRon?: boolean;
-        whoDiscarded?: Wind;
+        discardedBy?: Wind;
     }): WinResult | false;
-    doPon(w: Wind, whoDiscarded: Wind, t?: Tile): BlockPon[] | false;
-    doChi(w: Wind, whoDiscarded: Wind, t?: Tile): BlockChi[] | false;
-    redPattern(blocks: BlockChi[], hasRed: boolean): BlockChi[];
+    doPon(w: Wind, discardedBy: Wind, t?: Tile): BlockPon[] | false;
+    doChi(w: Wind, discardedBy: Wind, t?: Tile): BlockChi[] | false;
+    redPattern(blocks: BlockChi[]): BlockChi[];
     doReach(w: Wind): Candidate[] | false;
     doDiscard(w: Wind, called?: BlockChi | BlockPon): Tile[];
-    cannotDiscardTile(called: BlockChi): Tile[];
+    cannotDiscardTile(b: BlockChi): Tile[];
     doAnKan(w: Wind): BlockAnKan[] | false;
     doShoKan(w: Wind): BlockShoKan[] | false;
-    doDaiKan(w: Wind, whoDiscarded: Wind, t: Tile): BlockDaiKan | false;
+    doDaiKan(w: Wind, discardedBy: Wind, t: Tile): BlockDaiKan | false;
     canDrawnGame(w: Wind): boolean;
     initialHands(): {
         "1w": string;
@@ -453,6 +468,12 @@ type: "REACH";
 tile: Tile;
 iam: Wind;
 } | {
+type: "REACH_ACCEPT";
+reacherInfo: {
+tile: Tile;
+wind: Wind;
+};
+} | {
 type: "DISCARD";
 tile: Tile;
 iam: Wind;
@@ -469,7 +490,7 @@ type: "DAI_KAN";
 block: BlockDaiKan;
 iam: Wind;
 } | {
-type: "DRAWN_GAME_BY_NINE_TILES";
+type: "DRAWN_GAME_BY_NINE_ORPHANS";
 iam: Wind;
 }, Record<string, AnyActorRef>, ProvidedActor, ParameterizedObject, ParameterizedObject, never, StateValue, string, unknown, NonReducibleUnknown, EventObject, MetaObject, any>;
 
@@ -487,9 +508,21 @@ export declare const createHand: (helper: ImageHelper, blocks: Block[]) => {
 };
 
 export declare const createLocalGame: (params?: {
-    playerIDs?: string[];
     debug?: boolean;
-}) => Controller;
+    shuffle?: boolean;
+    playerInjection?: {
+        p1?: new (id: string, e: EventHandler) => Player;
+        p2?: new (id: string, e: EventHandler) => Player;
+        p3?: new (id: string, e: EventHandler) => Player;
+        p4?: new (id: string, e: EventHandler) => Player;
+    };
+}) => {
+    c: Controller;
+    p1: Player;
+    p2: Player;
+    p3: Player;
+    p4: Player;
+};
 
 export declare const createTable: (helper: ImageHelper, fontCtx: FontContext, handsProps: HandsInput, discardsProps: DiscardsInput, scoreBoardProps: ScoreBoardInput) => {
     e: G;
@@ -553,8 +586,8 @@ export declare interface DistributeEvent {
 export declare class DoubleCalculator {
     hand: Hand;
     cfg: {
-        doras: Tile[];
-        blindDoras: Tile[];
+        doras: readonly Tile[];
+        blindDoras: readonly Tile[];
         roundWind: Tile;
         myWind: Tile;
         reached: 0 | 1 | 2;
@@ -570,8 +603,8 @@ export declare class DoubleCalculator {
         orig: BoardContext;
     };
     constructor(hand: Hand, params: BoardContext);
-    calc(hands: Block[][]): WinResult | false;
-    calcPatterns(hands: Block[][]): {
+    calc(hands: readonly Block[][]): WinResult | false;
+    calcPatterns(hands: readonly Block[][]): {
         points: {
             name: string;
             double: number;
@@ -580,149 +613,149 @@ export declare class DoubleCalculator {
         hand: Block[];
     }[];
     private minus;
-    dA1(h: Block[]): {
+    dA1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dB1(h: Block[]): {
+    dB1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dC1(h: Block[]): {
+    dC1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dD1(h: Block[]): {
+    dD1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dE1(h: Block[]): {
+    dE1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dF1(h: Block[]): {
+    dF1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dG1(h: Block[]): {
+    dG1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dH1(h: Block[]): {
+    dH1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dI1(h: Block[]): {
+    dI1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dJ1(h: Block[]): {
+    dJ1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dK1(h: Block[]): {
+    dK1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dX1(h: Block[]): {
+    dX1(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dA2(h: Block[]): {
+    dA2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dB2(h: Block[]): {
+    dB2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dC2(h: Block[]): {
+    dC2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dD2(h: Block[]): {
+    dD2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dE2(h: Block[]): {
+    dE2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dF2(h: Block[]): {
+    dF2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dG2(h: Block[]): {
+    dG2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dH2(h: Block[]): {
+    dH2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dI2(h: Block[]): {
+    dI2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dJ2(h: Block[]): {
+    dJ2(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dA3(h: Block[]): {
+    dA3(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dB3(h: Block[]): {
+    dB3(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dC3(h: Block[]): {
+    dC3(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dA6(h: Block[]): {
+    dA6(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dA13(h: Block[]): {
+    dA13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dB13(h: Block[]): {
+    dB13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dC13(h: Block[]): {
+    dC13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dD13(h: Block[]): {
+    dD13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dE13(h: Block[]): {
+    dE13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dF13(h: Block[]): {
+    dF13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dG13(h: Block[]): {
+    dG13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dH13(h: Block[]): {
+    dH13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dI13(h: Block[]): {
+    dI13(h: readonly Block[]): {
         name: string;
         double: number;
     }[];
-    dJ13(h: Block[]): never[];
-    dK13(h: Block[]): never[];
-    calcFu(h: Block[]): number;
+    dJ13(h: readonly Block[]): never[];
+    dK13(h: readonly Block[]): never[];
+    calcFu(h: readonly Block[]): number;
 }
 
 export declare const drawBlocks: (svg: Svg, blocks: Block[], config?: ImageHelperConfig, params?: {
@@ -744,7 +777,7 @@ declare interface DrawnChoice {
     AN_KAN: false | SerializedBlock[];
     SHO_KAN: false | SerializedBlock[];
     DISCARD: false | string[];
-    DRAWN_GAME_BY_NINE_TILES: boolean;
+    DRAWN_GAME_BY_NINE_ORPHANS: boolean;
 }
 
 export declare const drawTable: (svg: Svg, tableInput: string, config: ImageHelperConfig | undefined, fontCtx: FontContext, params?: {
@@ -762,8 +795,8 @@ export declare class Efficiency {
         shanten: number;
         candidates: Tile[];
     };
-    static partialCandidateTiles(input: string, options: {
-        fourSetsOnePair: boolean;
+    static partialCandidateTiles(input: string, options?: {
+        fourSetsOnePair?: boolean;
     }): {
         shanten: number;
         candidates: Tile[];
@@ -791,7 +824,7 @@ export declare interface EndEvent {
     shouldContinue: boolean;
 }
 
-declare type Event_2 = CallEvent | "DRAW" | "CHOICE_AFTER_DRAWN" | "CHOICE_AFTER_DISCARDED" | "CHOICE_AFTER_CALLED" | "CHOICE_FOR_CHAN_KAN" | "DISTRIBUTE" | "NEW_DORA" | "END_GAME";
+declare type Event_2 = CallEvent | "DRAW" | "CHOICE_AFTER_DRAWN" | "CHOICE_AFTER_DISCARDED" | "CHOICE_AFTER_CALLED" | "CHOICE_FOR_CHAN_KAN" | "CHOICE_FOR_REACH_ACCEPTANCE" | "REACH_ACCEPTED" | "DISTRIBUTE" | "NEW_DORA" | "END_GAME";
 
 export declare interface EventHandler {
     emit(e: PlayerEvent): void;
@@ -826,8 +859,8 @@ export declare class Hand {
     getArrayLen(t: Type): 2 | 8 | 10;
     sum(t: Type): number;
     get(t: Type, n: number): number;
-    inc(tiles: readonly Tile[]): Tile[];
-    dec(tiles: readonly Tile[]): Tile[];
+    inc(tiles: readonly Tile[]): readonly Tile[];
+    dec(tiles: readonly Tile[]): readonly Tile[];
     draw(t: Tile): void;
     discard(t: Tile): void;
     reach(): void;
@@ -891,11 +924,40 @@ export declare function incrementalIDGenerator(start?: number): () => string;
 
 export declare const INPUT_SEPARATOR = ",";
 
-export declare function isNum0(t: Tile): boolean;
+export declare interface IRiver {
+    discard(t: Tile, w: Wind): void;
+    discards(w?: Wind): {
+        w: Wind;
+        t: Tile;
+        callMarker?: boolean;
+    }[];
+    lastTile: {
+        w: Wind;
+        t: Tile;
+        callMarker?: boolean;
+    };
+    markCalled(): void;
+    cannotContinue(): boolean;
+}
 
 export declare function isNum5(t: Tile): boolean;
 
-export declare function isNum5or0(t: Tile): boolean;
+export declare interface IWall {
+    kan(): Tile;
+    draw(): Tile;
+    openDoraMarker(): Tile;
+    doraMarkers: readonly Tile[];
+    blindDoraMarkers: readonly Tile[];
+    canKan: boolean;
+    canDraw: boolean;
+    export(): WallProps;
+    initialHands(): {
+        [WIND.E]: string;
+        [WIND.S]: string;
+        [WIND.W]: string;
+        [WIND.N]: string;
+    };
+}
 
 export declare class MeasureText {
     ctx: CanvasRenderingContext2D | null;
@@ -1045,18 +1107,18 @@ export declare interface PlayerCandidate {
     shanten: number;
 }
 
+export declare interface PlayerConnection {
+    id: string;
+    handler: EventHandler;
+}
+
 export declare class PlayerEfficiency {
     static calcPlayerCandidates(counter: Counter, candidates: Candidate[]): PlayerCandidate[];
     static selectMinPriority(c: Counter, playerCandidates: PlayerCandidate[], doras: Tile[]): PlayerCandidate;
     private static calcPriority;
 }
 
-export declare type PlayerEvent = DistributeEvent | EndEvent | CallEvent | RonEvent | TsumoEvent | DiscardEvent | DrawEvent | ReachEvent | NewDoraEvent | ChoiceAfterDrawnEvent | ChoiceAfterDiscardedEvent | ChoiceAfterCalled | ChoiceForChanKan;
-
-export declare interface PlayerProps {
-    id: string;
-    handler: EventHandler;
-}
+export declare type PlayerEvent = DistributeEvent | EndEvent | CallEvent | RonEvent | TsumoEvent | DiscardEvent | DrawEvent | ReachEvent | ReachAcceptedEvent | NewDoraEvent | ChoiceAfterDrawnEvent | ChoiceAfterDiscardedEvent | ChoiceAfterCalled | ChoiceForReachAcceptance | ChoiceForChanKan;
 
 export declare const prevRound: (r: Round) => Round;
 
@@ -1072,6 +1134,16 @@ export declare function prioritizeDrawnEvents(events: ChoiceAfterDrawnEvent[]):
     type: boolean | keyof DrawnChoice;
 };
 
+export declare interface ReachAcceptedEvent {
+    id: string;
+    type: Extract<Event_2, "REACH_ACCEPTED">;
+    wind: Wind;
+    reacherInfo: {
+        wind: Wind;
+        tile: string;
+    };
+}
+
 export declare interface ReachEvent {
     id: string;
     type: Extract<ChoiceEvent, "REACH">;
@@ -1101,16 +1173,16 @@ export declare class River {
     private m;
     constructor();
     discard(t: Tile, w: Wind): void;
-    get lastTile(): {
+    discards(w?: Wind): {
         w: Wind;
         t: Tile;
         callMarker?: boolean;
-    };
-    discards(w?: Wind): {
+    }[];
+    get lastTile(): {
         w: Wind;
         t: Tile;
         callMarker?: boolean;
-    }[];
+    };
     markCalled(): void;
     cannotContinue(): boolean;
 }
@@ -1125,7 +1197,6 @@ export declare interface RonEvent {
         wind: Wind;
         tile: string;
     };
-    pushBackReachStick: boolean;
 }
 
 export declare const ROUND: {
@@ -1239,6 +1310,8 @@ export declare class ShantenCalculator {
 
 export declare function shuffle<T>(array: T[]): T[];
 
+export declare const sortCalledTiles: (arr: readonly Tile[]) => Tile[];
+
 export declare const TABLE_CONTEXT: {
     readonly BASE: 40;
 };
@@ -1321,13 +1394,7 @@ export declare class Tile {
     }): Tile;
     has(op: Operator): boolean;
     isNum(): boolean;
-    equals(t: Tile, ignoreRed?: boolean): boolean;
-    imageSize(scale: number): {
-        width: number;
-        height: number;
-        baseWidth: number;
-        baseHeight: number;
-    };
+    equals(t: Tile): boolean;
 }
 
 export declare const TILE_CONTEXT: {
@@ -1372,6 +1439,12 @@ export declare class Wall {
     get blindDoraMarkers(): Tile[];
     get canKan(): boolean;
     get canDraw(): boolean;
+    initialHands(): {
+        "1w": string;
+        "2w": string;
+        "3w": string;
+        "4w": string;
+    };
     private init;
     export(): WallProps;
     static clone(walls: WallProps): WallProps;