@konoui/mjimage 0.0.13 → 0.0.15

package/dist/mjs/index.d.ts

@@ -1,10 +1,6 @@
 export * from "./lib/mjimage";
-export * from "./lib/constants";
-export * from "./lib/measure-text";
-export * from "./lib/lexer";
-export * from "./lib/image";
-export * from "./lib/parser";
-export * from "./lib/table";
-export * from "./lib/table-parser";
-export * from "./lib/calculator";
-export * from "./lib/controller";
+export * from "./lib/measure-text/";
+export * from "./lib/core/";
+export * from "./lib/table/";
+export * from "./lib/calculator/";
+export * from "./lib/controller/";

package/dist/mjs/index.js

@@ -15,12 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib/mjimage"), exports);
-__exportStar(require("./lib/constants"), exports);
-__exportStar(require("./lib/measure-text"), exports);
-__exportStar(require("./lib/lexer"), exports);
-__exportStar(require("./lib/image"), exports);
-__exportStar(require("./lib/parser"), exports);
-__exportStar(require("./lib/table"), exports);
-__exportStar(require("./lib/table-parser"), exports);
-__exportStar(require("./lib/calculator"), exports);
-__exportStar(require("./lib/controller"), exports);
+__exportStar(require("./lib/measure-text/"), exports);
+__exportStar(require("./lib/core/"), exports);
+__exportStar(require("./lib/table/"), exports);
+__exportStar(require("./lib/calculator/"), exports);
+__exportStar(require("./lib/controller/"), exports);

package/dist/mjs/lib/calculator/calc.d.ts

@@ -0,0 +1,263 @@
+import { TYPE, Round, Wind } from "../core/constants";
+import { Tile, BlockPon, BlockChi, BlockShoKan, BlockAnKan, BlockDaiKan, Type, Block } from "../core/parser";
+export type TupleOfSize<T, N extends number, R extends unknown[] = []> = R["length"] extends N ? R : TupleOfSize<T, N, [T, ...R]>;
+export interface HandData {
+    [TYPE.M]: TupleOfSize<number, 10>;
+    [TYPE.S]: TupleOfSize<number, 10>;
+    [TYPE.P]: TupleOfSize<number, 10>;
+    [TYPE.Z]: TupleOfSize<number, 8>;
+    [TYPE.BACK]: [string, number];
+    called: (BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan)[];
+    tsumo: Tile | null;
+    reached: boolean;
+}
+export declare class Hand {
+    private data;
+    constructor(input: string, allowBackBlock?: boolean);
+    private init;
+    get hands(): Tile[];
+    toString(): string;
+    get called(): (BlockChi | BlockPon | BlockAnKan | BlockDaiKan | BlockShoKan)[];
+    get reached(): boolean;
+    get drawn(): Tile | null;
+    get menzen(): boolean;
+    getArrayLen(t: Type): 2 | 8 | 10;
+    sum(t: Type): number;
+    get(t: Type, n: number): number;
+    inc(tiles: Tile[]): Tile[];
+    dec(tiles: Tile[]): Tile[];
+    draw(t: Tile): void;
+    discard(t: Tile): void;
+    reach(): void;
+    call(b: BlockPon | BlockChi | BlockDaiKan): void;
+    kan(b: BlockAnKan | BlockShoKan): void;
+    clone(): Hand;
+}
+export declare class ShantenCalculator {
+    hand: Hand;
+    constructor(hand: Hand);
+    calc(): number;
+    sevenPairs(): number;
+    thirteenOrphans(): number;
+    fourSetsOnePair(): number;
+    private commonByType;
+    private groupRemainingTiles;
+    private calcCommon;
+}
+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[][];
+    private commonAll;
+    private commonByType;
+}
+export interface BoardParams {
+    doraMarkers: Tile[];
+    blindDoraMarkers?: Tile[];
+    round: Round;
+    myWind: Wind;
+    ronWind?: Wind;
+    sticks?: {
+        reach: number;
+        dead: number;
+    };
+    reached?: 1 | 2;
+    replacementWin?: boolean;
+    quadWin?: boolean;
+    finalWallWin?: boolean;
+    finalDiscardWin?: boolean;
+    oneShotWin?: boolean;
+}
+export interface WinResult {
+    deltas: {
+        [w in Wind]: number;
+    };
+    sum: number;
+    fu: number;
+    points: {
+        name: string;
+        double: number;
+    }[];
+    point: number;
+    hand: Block[];
+    params: BoardParams;
+}
+export declare class DoubleCalculator {
+    hand: Hand;
+    cfg: {
+        doras: Tile[];
+        blindDoras: Tile[];
+        roundWind: Tile;
+        myWind: Tile;
+        reached: 0 | 1 | 2;
+        sticks: {
+            reach: number;
+            dead: number;
+        };
+        replacementWin: boolean;
+        quadWin: boolean;
+        finalWallWin: boolean;
+        finalDiscardWin: boolean;
+        oneShotWin: boolean;
+        orig: BoardParams;
+    };
+    constructor(hand: Hand, params: BoardParams);
+    calc(hands: Block[][]): WinResult | false;
+    calcPatterns(hands: Block[][]): {
+        points: {
+            name: string;
+            double: number;
+        }[];
+        fu: number;
+        hand: Block[];
+    }[];
+    private minus;
+    dA1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dK1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dX1(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ2(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC3(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA6(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dA13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dB13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dC13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dD13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dE13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dF13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dG13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dH13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dI13(h: Block[]): {
+        name: string;
+        double: number;
+    }[];
+    dJ13(h: Block[]): never[];
+    dK13(h: Block[]): never[];
+    calcFu(h: Block[]): number;
+}