@konoui/mjimage 0.0.1 → 0.0.2

package/dist/mjs/lib/parser.js

@@ -1,6 +1,30 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = exports.Block = exports.Tile = exports.isKind = exports.tileSortFunc = void 0;
+exports.Parser = exports.blockWrapper = exports.BlockIsolated = exports.BlockRun = exports.BlockThree = exports.BlockPair = exports.BlockShoKan = exports.BlockDaiKan = exports.BlockAnKan = exports.BlockPon = exports.BlockChi = exports.Block = exports.Tile = exports.isKind = exports.tileSortFunc = void 0;
 var lexer_1 = require("./lexer");
 var constants_1 = require("./constants");
 var tileSortFunc = function (i, j) {
@@ -18,7 +42,6 @@ var tileSortFunc = function (i, j) {
         _a[constants_1.KIND.S] = 3,
         _a[constants_1.KIND.Z] = 4,
         _a[constants_1.KIND.BACK] = 5,
-        _a[constants_1.KIND.SEPARATOR] = 6,
         _a);
     return lookup[i.k] - lookup[j.k];
 };
@@ -34,23 +57,41 @@ function isKind(v) {
 }
 exports.isKind = isKind;
 var Tile = (function () {
-    function Tile(k, n, op) {
+    function Tile(k, n, ops) {
+        if (ops === void 0) { ops = []; }
         this.k = k;
         this.n = n;
-        this.op = op;
+        this.ops = ops;
     }
     Tile.prototype.toString = function () {
-        if (this.k === constants_1.KIND.BACK || this.k === constants_1.KIND.SEPARATOR)
+        if (this.k === constants_1.KIND.BACK)
             return this.k;
-        var op = this.op != null ? this.op : "";
-        return "".concat(op).concat(this.n).concat(this.k);
+        return "".concat(this.ops.join("")).concat(this.n).concat(this.k);
+    };
+    Tile.prototype.clone = function () {
+        return new Tile(this.k, this.n, __spreadArray([], this.ops, true));
+    };
+    Tile.prototype.has = function (op) {
+        return this.ops.includes(op);
+    };
+    Tile.prototype.add = function (op) {
+        this.ops.push(op);
+        this.ops = Array.from(new Set(this.ops));
+        return this;
+    };
+    Tile.prototype.remove = function (op) {
+        this.ops = this.ops.filter(function (v) { return v != op; });
+        return this;
+    };
+    Tile.prototype.isNum = function () {
+        return this.k == constants_1.KIND.M || this.k == constants_1.KIND.P || this.k == constants_1.KIND.S;
     };
     Tile.prototype.equals = function (t, ignoreRed) {
         if (ignoreRed === void 0) { ignoreRed = false; }
-        var ok = this.n === t.n;
+        var ok = this.n == t.n;
         if (ignoreRed)
             ok || (ok = (this.n == 5 && t.n == 0) || (this.n == 0 && t.n == 5));
-        return this.k === t.k && ok;
+        return this.k == t.k && ok;
     };
     return Tile;
 }());
@@ -61,40 +102,204 @@ var Block = (function () {
         this.type = type;
         if (type == constants_1.BLOCK.CHI) {
             tiles.sort(function (a, b) {
-                if (a.op == constants_1.OPERATOR.HORIZONTAL)
+                if (a.has(constants_1.OPERATOR.HORIZONTAL))
                     return -1;
-                if (b.op == constants_1.OPERATOR.HORIZONTAL)
+                if (b.has(constants_1.OPERATOR.HORIZONTAL))
                     return 1;
                 return (0, exports.tileSortFunc)(a, b);
             });
             return;
         }
+        if (type == constants_1.BLOCK.SHO_KAN) {
+            return;
+        }
         if (type != constants_1.BLOCK.DISCARD) {
             tiles.sort(exports.tileSortFunc);
         }
     }
     Block.prototype.toString = function () {
-        var result = "";
-        for (var _i = 0, _a = this.tiles; _i < _a.length; _i++) {
-            var t = _a[_i];
-            result += t.toString();
+        var _a = this.tiles.reduce(function (a, b) {
+            return [a[0] && a[1].k == b.k, b];
+        }, [true, this.tiles[0]]), sameAll = _a[0], _ = _a[1];
+        var ret = "";
+        if (sameAll) {
+            for (var _i = 0, _b = this.tiles; _i < _b.length; _i++) {
+                var v = _b[_i];
+                ret += v.toString().slice(0, -1);
+            }
+            return "".concat(ret).concat(this.tiles[0].k);
+        }
+        for (var _c = 0, _d = this.tiles; _c < _d.length; _c++) {
+            var t = _d[_c];
+            ret += t.toString();
+        }
+        return ret;
+    };
+    Block.prototype.is = function (type) {
+        return this.type == type;
+    };
+    Block.prototype.isCalled = function () {
+        return [
+            constants_1.BLOCK.PON.toString(),
+            constants_1.BLOCK.CHI.toString(),
+            constants_1.BLOCK.AN_KAN.toString(),
+            constants_1.BLOCK.DAI_KAN.toString(),
+            constants_1.BLOCK.SHO_KAN.toString(),
+        ].includes(this.type.toString());
+    };
+    Block.prototype.equals = function (b) {
+        if (this.tiles.length != b.tiles.length)
+            return false;
+        var ab = this.tiles;
+        var bb = b.tiles;
+        if (this.is(constants_1.BLOCK.CHI) || b.is(constants_1.BLOCK.CHI)) {
+            ab = b.clone().tiles.sort(exports.tileSortFunc);
+            bb = this.clone().tiles.sort(exports.tileSortFunc);
         }
-        return result;
+        for (var i = 0; i < b.tiles.length; i++) {
+            if (!ab[i].equals(bb[i], true))
+                return false;
+        }
+        return true;
+    };
+    Block.prototype.minTile = function () {
+        if (this.is(constants_1.BLOCK.CHI))
+            return this.clone().tiles.sort(exports.tileSortFunc)[0];
+        return this.tiles[0];
+    };
+    Block.prototype.clone = function () {
+        var tiles = this.tiles.map(function (t) { return new Tile(t.k, t.n, __spreadArray([], t.ops, true)); });
+        return (0, exports.blockWrapper)(tiles, this.type);
     };
     return Block;
 }());
 exports.Block = Block;
+var BlockChi = (function (_super) {
+    __extends(BlockChi, _super);
+    function BlockChi(tiles) {
+        return _super.call(this, tiles, constants_1.BLOCK.CHI) || this;
+    }
+    return BlockChi;
+}(Block));
+exports.BlockChi = BlockChi;
+var BlockPon = (function (_super) {
+    __extends(BlockPon, _super);
+    function BlockPon(tiles) {
+        return _super.call(this, tiles, constants_1.BLOCK.PON) || this;
+    }
+    return BlockPon;
+}(Block));
+exports.BlockPon = BlockPon;
+var BlockAnKan = (function (_super) {
+    __extends(BlockAnKan, _super);
+    function BlockAnKan(tiles) {
+        return _super.call(this, tiles, constants_1.BLOCK.AN_KAN) || this;
+    }
+    BlockAnKan.prototype.toString = function () {
+        var tiles = this.tiles.map(function (t) { return t.clone(); });
+        tiles[1] = new Tile(constants_1.KIND.BACK, 0);
+        tiles[2] = new Tile(constants_1.KIND.BACK, 0);
+        return tiles.reduce(function (s, t) {
+            return "".concat(s).concat(t.toString());
+        }, "");
+    };
+    return BlockAnKan;
+}(Block));
+exports.BlockAnKan = BlockAnKan;
+var BlockDaiKan = (function (_super) {
+    __extends(BlockDaiKan, _super);
+    function BlockDaiKan(tiles) {
+        return _super.call(this, tiles, constants_1.BLOCK.DAI_KAN) || this;
+    }
+    return BlockDaiKan;
+}(Block));
+exports.BlockDaiKan = BlockDaiKan;
+var BlockShoKan = (function (_super) {
+    __extends(BlockShoKan, _super);
+    function BlockShoKan(tiles) {
+        return _super.call(this, tiles, constants_1.BLOCK.SHO_KAN) || this;
+    }
+    return BlockShoKan;
+}(Block));
+exports.BlockShoKan = BlockShoKan;
+var BlockPair = (function (_super) {
+    __extends(BlockPair, _super);
+    function BlockPair(tile1, tile2) {
+        return _super.call(this, [tile1, tile2], constants_1.BLOCK.PAIR) || this;
+    }
+    return BlockPair;
+}(Block));
+exports.BlockPair = BlockPair;
+var BlockSet = (function (_super) {
+    __extends(BlockSet, _super);
+    function BlockSet(tiles) {
+        return _super.call(this, tiles, constants_1.BLOCK.SET) || this;
+    }
+    return BlockSet;
+}(Block));
+var BlockThree = (function (_super) {
+    __extends(BlockThree, _super);
+    function BlockThree(tiles) {
+        return _super.call(this, tiles) || this;
+    }
+    return BlockThree;
+}(BlockSet));
+exports.BlockThree = BlockThree;
+var BlockRun = (function (_super) {
+    __extends(BlockRun, _super);
+    function BlockRun(tiles) {
+        return _super.call(this, tiles) || this;
+    }
+    return BlockRun;
+}(BlockSet));
+exports.BlockRun = BlockRun;
+var BlockIsolated = (function (_super) {
+    __extends(BlockIsolated, _super);
+    function BlockIsolated(tile) {
+        return _super.call(this, [tile], constants_1.BLOCK.ISOLATED) || this;
+    }
+    return BlockIsolated;
+}(Block));
+exports.BlockIsolated = BlockIsolated;
+var blockWrapper = function (tiles, type) {
+    switch (type) {
+        case constants_1.BLOCK.CHI:
+            return new BlockChi([tiles[0], tiles[1], tiles[2]]);
+        case constants_1.BLOCK.PON:
+            return new BlockPon([tiles[0], tiles[1], tiles[2]]);
+        case constants_1.BLOCK.AN_KAN:
+            return new BlockAnKan(tiles);
+        case constants_1.BLOCK.DAI_KAN:
+            return new BlockDaiKan(tiles);
+        case constants_1.BLOCK.SHO_KAN:
+            return new BlockShoKan(tiles);
+        case constants_1.BLOCK.SET:
+            if (tiles[0].equals(tiles[1], true))
+                return new BlockThree(tiles);
+            return new BlockRun(tiles);
+        case constants_1.BLOCK.PAIR:
+            return new BlockPair(tiles[0], tiles[1]);
+        case constants_1.BLOCK.ISOLATED:
+            return new BlockIsolated(tiles[0]);
+        default:
+            return new Block(tiles, type);
+    }
+};
+exports.blockWrapper = blockWrapper;
 var Parser = (function () {
     function Parser(input) {
         this.input = input;
-        this.maxInputLength = 128;
+        this.maxInputLength = 600;
         this.input = input.replace(/\s/g, "");
     }
     Parser.prototype.parse = function () {
-        var parsed = this.parseInput();
+        var parsed = this.tileSeparators();
         return this.makeBlocks(parsed);
     };
-    Parser.prototype.parseInput = function () {
+    Parser.prototype.tiles = function () {
+        return this.tileSeparators().filter(function (v) { return v != constants_1.INPUT_SEPARATOR; });
+    };
+    Parser.prototype.tileSeparators = function () {
         var l = new lexer_1.Lexer(this.input);
         var res = [];
         var cluster = [];
@@ -104,6 +309,11 @@ var Parser = (function () {
             var char = l.char;
             if (char === l.eof)
                 break;
+            if (char == constants_1.INPUT_SEPARATOR) {
+                res.push(constants_1.INPUT_SEPARATOR);
+                l.readChar();
+                continue;
+            }
             var _a = isKindAlias(char, cluster), k = _a[0], isKind_1 = _a[1];
             if (isKind_1) {
                 if (k == constants_1.KIND.BACK) {
@@ -111,11 +321,6 @@ var Parser = (function () {
                     l.readChar();
                     continue;
                 }
-                if (k == constants_1.KIND.SEPARATOR) {
-                    res.push(new Tile(k, -1));
-                    l.readChar();
-                    continue;
-                }
                 res.push.apply(res, makeTiles(cluster, k));
                 cluster = [];
                 l.readChar();
@@ -124,14 +329,13 @@ var Parser = (function () {
             else {
                 var _b = isOperator(l), t = _b[0], isOp = _b[1];
                 if (isOp) {
-                    l.readChar();
                     cluster.push(t);
                     l.readChar();
                     continue;
                 }
                 var _c = isNumber(char), n = _c[0], isNum = _c[1];
                 if (!isNum)
-                    throw new Error("encounter unexpected number: ".concat(n, " ").concat(char));
+                    throw new Error("encounter unexpected number. n: ".concat(n, ", current: ").concat(char, ", input: ").concat(l.input));
                 cluster.push(new Tile(constants_1.KIND.BACK, n));
             }
             l.readChar();
@@ -147,9 +351,9 @@ var Parser = (function () {
             return res;
         for (var _i = 0, tiles_1 = tiles; _i < tiles_1.length; _i++) {
             var t = tiles_1[_i];
-            if (t.k === constants_1.KIND.SEPARATOR) {
+            if (t == constants_1.INPUT_SEPARATOR) {
                 var type_1 = detectBlockType(cluster);
-                var b_1 = new Block(cluster, type_1);
+                var b_1 = (0, exports.blockWrapper)(cluster, type_1);
                 res.push(b_1);
                 cluster = [];
                 continue;
@@ -157,7 +361,7 @@ var Parser = (function () {
             cluster.push(t);
         }
         var type = detectBlockType(cluster);
-        var b = new Block(cluster, type);
+        var b = (0, exports.blockWrapper)(cluster, type);
         res.push(b);
         cluster = [];
         return res;
@@ -166,7 +370,7 @@ var Parser = (function () {
         if (input.length == 0)
             return;
         if (input.length > this.maxInputLength)
-            throw new Error("exceeded maximum input length");
+            throw new Error("exceeded maximum input length(".concat(input.length, ")"));
         var lastChar = input.charAt(input.length - 1);
         var _a = isKindAlias(lastChar, [new Tile(constants_1.KIND.BACK, 1)]), _ = _a[0], isKind = _a[1];
         if (!isKind)
@@ -179,22 +383,28 @@ function detectBlockType(tiles) {
     if (tiles.length === 0)
         return constants_1.BLOCK.UNKNOWN;
     if (tiles.length === 1) {
-        if (tiles[0].op === constants_1.OPERATOR.DORA)
+        if (tiles[0].has(constants_1.OPERATOR.DORA))
             return constants_1.BLOCK.DORA;
-        if (tiles[0].op === constants_1.OPERATOR.TSUMO)
+        if (tiles[0].has(constants_1.OPERATOR.TSUMO))
             return constants_1.BLOCK.TSUMO;
         return constants_1.BLOCK.HAND;
     }
     var sameAll = tiles.filter(function (v) { return v.equals(tiles[0], true); }).length == tiles.length;
-    var numOfHorizontals = tiles.filter(function (v) { return v.op == constants_1.OPERATOR.HORIZONTAL; }).length;
-    var numOfTsumoDoraTiles = tiles.filter(function (v) { return v.op == constants_1.OPERATOR.TSUMO || v.op == constants_1.OPERATOR.DORA; }).length;
+    var numOfHorizontals = tiles.filter(function (v) {
+        return v.has(constants_1.OPERATOR.HORIZONTAL);
+    }).length;
+    var numOfTsumoDoraTiles = tiles.filter(function (v) { return v.has(constants_1.OPERATOR.TSUMO) || v.has(constants_1.OPERATOR.DORA); }).length;
     var numOfBackTiles = tiles.filter(function (v) { return v.k == constants_1.KIND.BACK; }).length;
     if (numOfTsumoDoraTiles > 0)
         return constants_1.BLOCK.UNKNOWN;
     if (numOfHorizontals == 0 && numOfBackTiles == 0)
         return constants_1.BLOCK.HAND;
     if (tiles.length === 3) {
-        return sameAll ? constants_1.BLOCK.PON : constants_1.BLOCK.CHI;
+        if (sameAll)
+            return constants_1.BLOCK.PON;
+        if (numOfHorizontals == 1 && areConsecutiveTiles(tiles))
+            return constants_1.BLOCK.CHI;
+        return constants_1.BLOCK.DISCARD;
     }
     if (tiles.length == 4 && numOfBackTiles == 2)
         return constants_1.BLOCK.AN_KAN;
@@ -208,9 +418,25 @@ function detectBlockType(tiles) {
         return constants_1.BLOCK.DISCARD;
     return constants_1.BLOCK.UNKNOWN;
 }
+function areConsecutiveTiles(tiles) {
+    tiles = tiles.map(function (t) { return t.clone(); }).sort(exports.tileSortFunc);
+    for (var i = 0; i < tiles.length - 1; i++) {
+        var n = tiles[i].n, np = tiles[i + 1].n;
+        var k = tiles[i].k, kp = tiles[i + 1].k;
+        if (n == 0)
+            n = 5;
+        if (np == 0)
+            np = 5;
+        if (k !== kp)
+            return false;
+        if (n + 1 !== np)
+            return false;
+    }
+    return true;
+}
 function makeTiles(cluster, k) {
     return cluster.map(function (v) {
-        return new Tile(k, v.n, v.op);
+        return new Tile(k, v.n, v.ops);
     });
 }
 function isKindAlias(s, cluster) {
@@ -232,13 +458,21 @@ function isNumber(v) {
     return [Number(v), valid.includes(v)];
 }
 function isOperator(l) {
-    for (var _i = 0, _a = Object.values(constants_1.OPERATOR); _i < _a.length; _i++) {
-        var op = _a[_i];
-        if (op == l.char) {
-            var _b = isNumber(l.peekChar()), n = _b[0], ok = _b[1];
+    var ops = Object.values(constants_1.OPERATOR);
+    if (!ops.includes(l.char))
+        return [new Tile(constants_1.KIND.BACK, 0), false];
+    var found = [];
+    for (var i = 0; i < 4; i++) {
+        var c = l.peekCharN(i);
+        if (ops.includes(c))
+            found.push(c);
+        else {
+            var _a = isNumber(c), n = _a[0], ok = _a[1];
             if (!ok)
-                return [new Tile(constants_1.KIND.BACK, 0), false];
-            return [new Tile(constants_1.KIND.BACK, n, op), true];
+                break;
+            for (var i_1 = 0; i_1 < found.length; i_1++)
+                l.readChar();
+            return [new Tile(constants_1.KIND.BACK, n, found), true];
         }
     }
     return [new Tile(constants_1.KIND.BACK, 0), false];

package/dist/mjs/lib/table-parser.d.ts

@@ -55,7 +55,7 @@ declare const tableInputSchema: z.ZodObject<{
         score?: number | undefined;
     }>>>;
     board: z.ZodObject<{
-        round: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4">, z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4">, ...z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4">[]]>>>;
+        round: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4">, z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4">, ...z.ZodLiteral<"1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4">[]]>>>;
         sticks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
             reach: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
             dead: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -69,7 +69,7 @@ declare const tableInputSchema: z.ZodObject<{
         doras: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
         front: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"1w" | "2w" | "3w" | "4w">, z.ZodLiteral<"1w" | "2w" | "3w" | "4w">, ...z.ZodLiteral<"1w" | "2w" | "3w" | "4w">[]]>>>;
     }, "strict", z.ZodTypeAny, {
-        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4";
+        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4";
         sticks: {
             reach: number;
             dead: number;
@@ -77,7 +77,7 @@ declare const tableInputSchema: z.ZodObject<{
         doras: string[];
         front: "1w" | "2w" | "3w" | "4w";
     }, {
-        round?: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | undefined;
+        round?: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4" | undefined;
         sticks?: {
             reach?: number | undefined;
             dead?: number | undefined;
@@ -107,7 +107,7 @@ declare const tableInputSchema: z.ZodObject<{
         score: number;
     };
     board: {
-        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4";
+        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4";
         sticks: {
             reach: number;
             dead: number;
@@ -117,7 +117,7 @@ declare const tableInputSchema: z.ZodObject<{
     };
 }, {
     board: {
-        round?: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | undefined;
+        round?: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4" | undefined;
         sticks?: {
             reach?: number | undefined;
             dead?: number | undefined;
@@ -174,6 +174,8 @@ export interface ScoreBoardInput {
     };
     frontPlace: BoardWind;
 }
+export type TableWind = keyof typeof WIND_MAP;
+export type TableRound = keyof typeof ROUND_MAP;
 type BoardRound = (typeof ROUND_MAP)[keyof typeof ROUND_MAP];
 type BoardWind = (typeof WIND_MAP)[keyof typeof WIND_MAP];
 export declare const parse: (s: string) => {
@@ -203,7 +205,7 @@ export declare const parseTableInput: (s: string) => {
         score: number;
     };
     board: {
-        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4";
+        round: "1w1" | "1w2" | "1w3" | "1w4" | "2w1" | "2w2" | "2w3" | "2w4" | "3w1" | "3w2" | "3w3" | "3w4" | "4w1" | "4w2" | "4w3" | "4w4";
         sticks: {
             reach: number;
             dead: number;

package/dist/mjs/lib/table-parser.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertInput = exports.parseTableInput = exports.parse = void 0;
 var js_yaml_1 = require("js-yaml");
@@ -15,12 +16,12 @@ var windInputSchema = zod_1.z
     .optional()
     .default({ discard: "", hand: "", score: 25000 });
 var windInputsSchema = zod_1.z
-    .object({
-    "1w": windInputSchema,
-    "2w": windInputSchema,
-    "3w": windInputSchema,
-    "4w": windInputSchema,
-})
+    .object((_a = {},
+    _a[constants_1.WIND.EAST] = windInputSchema,
+    _a[constants_1.WIND.SOUTH] = windInputSchema,
+    _a[constants_1.WIND.WEST] = windInputSchema,
+    _a[constants_1.WIND.NORTH] = windInputSchema,
+    _a))
     .strict();
 function unionOfLiterals(constants) {
     var literals = constants.map(function (x) { return zod_1.z.literal(x); });
@@ -68,10 +69,10 @@ var convertInput = function (i) {
         return i[w].discard.replace(/\r?\n/g, "");
     };
     var discards = {
-        front: new parser_1.Parser(f(m.front)).parseInput(),
-        right: new parser_1.Parser(f(m.right)).parseInput(),
-        opposite: new parser_1.Parser(f(m.opposite)).parseInput(),
-        left: new parser_1.Parser(f(m.left)).parseInput(),
+        front: new parser_1.Parser(f(m.front)).tiles(),
+        right: new parser_1.Parser(f(m.right)).tiles(),
+        opposite: new parser_1.Parser(f(m.opposite)).tiles(),
+        left: new parser_1.Parser(f(m.left)).tiles(),
     };
     var hands = {
         front: new parser_1.Parser(i[m.front].hand).parse(),
@@ -84,7 +85,7 @@ var convertInput = function (i) {
         frontPlace: constants_1.WIND_MAP[frontPlace],
         sticks: i.board.sticks,
         doras: i.board.doras.map(function (v) {
-            return new parser_1.Parser(v).parseInput()[0];
+            return new parser_1.Parser(v).tiles()[0];
         }),
         scores: {
             front: i[m.front].score,

package/dist/mjs/lib/table.d.ts

@@ -1,6 +1,6 @@
 import { ImageHelper, ImageHelperConfig } from "./image";
 import { Svg, G } from "@svgdotjs/svg.js";
-import { FontContext } from "./context";
+import { FontContext } from "./measure-text";
 import { ScoreBoardInput, DiscardsInput, HandsInput } from "./table-parser";
 export declare const createTable: (helper: ImageHelper, fontCtx: FontContext, handsProps: HandsInput, discardsProps: DiscardsInput, scoreBoardProps: ScoreBoardInput) => {
     e: G;

package/package.json

@@ -1,15 +1,26 @@
 {
     "name": "@konoui/mjimage",
-    "version": "0.0.1",
-    "description": "",
+    "version": "0.0.2",
+    "description": "Generates Mahjong tiles in SVG format.",
+    "author": "konoui",
+    "license": "MIT",
+    "repository": "github.com/konoui/mjimage",
+    "keywords": [
+        "mahjong"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
     "scripts": {
         "start": "parcel",
         "build": "parcel build",
         "dev": "parcel src/index.html",
         "test": "jest",
+        "cmd": "ts-node ./src/cmd/index.ts",
         "svg-sprite": "svg-sprite -C svg-sprite.config.json -shape-transform-svgo svgo.json static/svg/*.svg",
         "tsc": "tsc --declaration --outDir ./dist/mjs",
-        "prepublishOnly": "rm -rf ./dist && npm run tsc && cp -rf ./static/svg ./dist/mjs/svg/"
+        "prepublishOnly": "rm -rf ./dist && npm run tsc && cp -rf ./static/svg ./dist/mjs/svg/",
+        "deploy": "./scripts/sync.sh personal"
     },
     "types": "dist/mjs/index.d.ts",
     "files": [
@@ -39,11 +50,6 @@
         "staticPath": "static/svg",
         "staticOutPath": "svg"
     },
-    "author": "konoui",
-    "license": "MIT",
-    "publishConfig": {
-        "access": "public"
-    },
     "devDependencies": {
         "@parcel/transformer-inline-string": "^2.9.3",
         "@parcel/transformer-typescript-tsc": "^2.9.3",
@@ -65,7 +71,9 @@
     },
     "dependencies": {
         "@svgdotjs/svg.js": "^3.2.0",
+        "eventmit": "^2.0.4",
         "js-yaml": "^4.1.0",
+        "xstate": "^5.7.0",
         "zod": "^3.22.4"
     }
 }