@konoui/mjimage 0.0.1

package/dist/mjs/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./lib/mjimage";
+export * from "./lib/constants";
+export * from "./lib/context";
+export * from "./lib/lexer";
+export * from "./lib/image";
+export * from "./lib/parser";
+export * from "./lib/table";
+export * from "./lib/table-parser";

package/dist/mjs/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/mjimage"), exports);
+__exportStar(require("./lib/constants"), exports);
+__exportStar(require("./lib/context"), 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);

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

@@ -0,0 +1,50 @@
+export declare const FONT_FAMILY = "MS Gothic, sans-serif";
+export declare const TILE_CONTEXT: {
+    WIDTH: number;
+    HEIGHT: number;
+};
+export declare const TABLE_CONTEXT: {
+    BASE: number;
+};
+export declare const KIND: {
+    readonly M: "m";
+    readonly P: "p";
+    readonly S: "s";
+    readonly Z: "z";
+    readonly BACK: "_";
+    readonly SEPARATOR: ",";
+};
+export declare const OPERATOR: {
+    readonly TSUMO: "t";
+    readonly DORA: "d";
+    readonly HORIZONTAL: "-";
+    readonly COLOR_GRAYSCALE: "g";
+};
+export declare const BLOCK: {
+    readonly PON: "pon";
+    readonly CHI: "chi";
+    readonly SHO_KAN: "shokan";
+    readonly DAI_KAN: "daikan";
+    readonly AN_KAN: "ankan";
+    readonly DORA: "dora";
+    readonly TSUMO: "tsumo";
+    readonly HAND: "hand";
+    readonly DISCARD: "simple-discard";
+    readonly UNKNOWN: "unknown";
+};
+export declare const ROUND_MAP: {
+    readonly "1w1": "東１局";
+    readonly "1w2": "東２局";
+    readonly "1w3": "東３局";
+    readonly "1w4": "東４局";
+    readonly "2w1": "南１局";
+    readonly "2w2": "南２局";
+    readonly "2w3": "南３局";
+    readonly "2w4": "南４局";
+};
+export declare const WIND_MAP: {
+    readonly "1w": "東";
+    readonly "2w": "南";
+    readonly "3w": "西";
+    readonly "4w": "北";
+};

package/dist/mjs/lib/constants.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WIND_MAP = exports.ROUND_MAP = exports.BLOCK = exports.OPERATOR = exports.KIND = exports.TABLE_CONTEXT = exports.TILE_CONTEXT = exports.FONT_FAMILY = void 0;
+exports.FONT_FAMILY = "MS Gothic, sans-serif";
+exports.TILE_CONTEXT = { WIDTH: 66, HEIGHT: 90 };
+exports.TABLE_CONTEXT = { BASE: 40 };
+exports.KIND = {
+    M: "m",
+    P: "p",
+    S: "s",
+    Z: "z",
+    BACK: "_",
+    SEPARATOR: ",",
+};
+exports.OPERATOR = {
+    TSUMO: "t",
+    DORA: "d",
+    HORIZONTAL: "-",
+    COLOR_GRAYSCALE: "g",
+};
+exports.BLOCK = {
+    PON: "pon",
+    CHI: "chi",
+    SHO_KAN: "shokan",
+    DAI_KAN: "daikan",
+    AN_KAN: "ankan",
+    DORA: "dora",
+    TSUMO: "tsumo",
+    HAND: "hand",
+    DISCARD: "simple-discard",
+    UNKNOWN: "unknown",
+};
+exports.ROUND_MAP = {
+    "1w1": "東１局",
+    "1w2": "東２局",
+    "1w3": "東３局",
+    "1w4": "東４局",
+    "2w1": "南１局",
+    "2w2": "南２局",
+    "2w3": "南３局",
+    "2w4": "南４局",
+};
+exports.WIND_MAP = {
+    "1w": "東",
+    "2w": "南",
+    "3w": "西",
+    "4w": "北",
+};

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

@@ -0,0 +1,12 @@
+export interface FontContext {
+    font: {
+        family: string;
+        size: number;
+    };
+    textWidth: number;
+    textHeight: number;
+    numWidth: number;
+    numHeight: number;
+}
+export declare const getFontContext: (ctx: CanvasRenderingContext2D, fontFamily: string, fontSize: number) => FontContext;
+export declare const getTableFontContext: (ctx: CanvasRenderingContext2D, scale: number) => FontContext;

package/dist/mjs/lib/context.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableFontContext = exports.getFontContext = void 0;
+var constants_1 = require("./constants");
+var getContext = function (ctx, str, font) {
+    ctx.font = font;
+    var metrics = ctx.measureText(str);
+    var width = metrics.width;
+    var height = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
+    return [width, height];
+};
+var getFontContext = function (ctx, fontFamily, fontSize) {
+    var font = { family: fontFamily, size: fontSize };
+    var fontString = "".concat(font.size, "px ").concat(font.family);
+    var _a = getContext(ctx, "東", fontString), textWidth = _a[0], textHeight = _a[1];
+    var _b = getContext(ctx, "2", fontString), numWidth = _b[0], numHeight = _b[1];
+    var ret = {
+        font: { family: fontFamily, size: fontSize },
+        textWidth: textWidth,
+        textHeight: textHeight,
+        numWidth: numWidth,
+        numHeight: numHeight,
+    };
+    return ret;
+};
+exports.getFontContext = getFontContext;
+var getTableFontContext = function (ctx, scale) {
+    var fontCtx = (0, exports.getFontContext)(ctx, constants_1.FONT_FAMILY, constants_1.TABLE_CONTEXT.BASE * scale);
+    fontCtx.textHeight = fontCtx.textWidth;
+    fontCtx.numHeight = fontCtx.numWidth;
+    return fontCtx;
+};
+exports.getTableFontContext = getTableFontContext;

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

@@ -0,0 +1,39 @@
+import { Tile, Block } from "./parser";
+import { Svg, G, Image, Use } from "@svgdotjs/svg.js";
+export interface ImageHelperConfig {
+    scale?: number;
+    imageHostPath?: string;
+    imageHostUrl?: string;
+    svgSprite?: boolean;
+}
+declare class BaseHelper {
+    readonly tileWidth: number;
+    readonly tileHeight: number;
+    readonly diffTileHeightWidth: number;
+    readonly textWidth: number;
+    readonly image_host_path: string;
+    readonly image_host_url: string;
+    readonly scale: number;
+    readonly svgSprite: boolean;
+    constructor(props?: ImageHelperConfig);
+    private image;
+    createImage(tile: Tile, x: number, y: number): Image | Use;
+    createTextImage(tile: Tile, x: number, y: number, t: string): G;
+    createStackImage(tile: Tile, x: number, y: number): G;
+    createRotate90Image(tile: Tile, x: number, y: number, adjustY?: boolean): G;
+    createStick(v: 100 | 1000): Image | Use;
+    buildID(tile: Tile | 100 | 1000): string;
+    buildURL(tile: Tile | 100 | 1000): string;
+}
+export declare class ImageHelper extends BaseHelper {
+    readonly blockMargin: number;
+    createBlockHandDiscard(tiles: Tile[]): G;
+    createBlockPonChiKan(block: Block): G;
+}
+export declare const createHand: (helper: ImageHelper, blocks: Block[]) => {
+    e: G;
+    width: number;
+    height: number;
+};
+export declare const drawBlocks: (svg: Svg, blocks: Block[], config?: ImageHelperConfig) => void;
+export {};

package/dist/mjs/lib/image.js

@@ -0,0 +1,303 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawBlocks = exports.createHand = exports.ImageHelper = void 0;
+var assert_1 = __importDefault(require("assert"));
+var parser_1 = require("./parser");
+var svg_js_1 = require("@svgdotjs/svg.js");
+var constants_1 = require("./constants");
+var BaseHelper = (function () {
+    function BaseHelper(props) {
+        if (props === void 0) { props = {}; }
+        var _a, _b, _c, _d;
+        this.scale = (_a = props.scale) !== null && _a !== void 0 ? _a : 1;
+        this.image_host_path = (_b = props.imageHostPath) !== null && _b !== void 0 ? _b : "";
+        this.image_host_url = (_c = props.imageHostUrl) !== null && _c !== void 0 ? _c : "";
+        this.tileWidth = constants_1.TILE_CONTEXT.WIDTH * this.scale;
+        this.tileHeight = constants_1.TILE_CONTEXT.HEIGHT * this.scale;
+        this.textWidth = this.tileWidth * 0.8;
+        this.diffTileHeightWidth = (this.tileHeight - this.tileWidth) / 2;
+        this.svgSprite = (_d = props.svgSprite) !== null && _d !== void 0 ? _d : false;
+    }
+    BaseHelper.prototype.image = function (tile) {
+        var img = new svg_js_1.Image().load(this.buildURL(tile));
+        if (this.svgSprite) {
+            img = new svg_js_1.Use().use(this.buildID(tile));
+        }
+        if (tile instanceof parser_1.Tile && tile.op == constants_1.OPERATOR.COLOR_GRAYSCALE) {
+            img.css({ filter: "contrast(65%)" });
+        }
+        return img;
+    };
+    BaseHelper.prototype.createImage = function (tile, x, y) {
+        var image = this.image(tile)
+            .dx(x)
+            .dy(y)
+            .size(this.tileWidth, this.tileHeight);
+        return image;
+    };
+    BaseHelper.prototype.createTextImage = function (tile, x, y, t) {
+        var image = this.createImage(tile, x, y);
+        var fontSize = this.tileHeight * 0.2;
+        var textX = this.tileWidth;
+        var textY = this.tileHeight;
+        var text = new svg_js_1.Text().text(t);
+        text
+            .width(this.tileWidth)
+            .height(this.tileHeight)
+            .font({
+            family: constants_1.FONT_FAMILY,
+            size: fontSize,
+        })
+            .dx(textX)
+            .dy(textY);
+        var g = new svg_js_1.G();
+        g.add(image).add(text).translate(x, y);
+        return g;
+    };
+    BaseHelper.prototype.createStackImage = function (tile, x, y) {
+        var base = this.createRotate90Image(tile, 0, 0, true);
+        var up = this.createRotate90Image(tile, 0, this.tileWidth, true);
+        var g = new svg_js_1.G().translate(x, y).add(base).add(up);
+        return g;
+    };
+    BaseHelper.prototype.createRotate90Image = function (tile, x, y, adjustY) {
+        if (adjustY === void 0) { adjustY = false; }
+        var image = this.createImage(tile, 0, 0);
+        var centerX = this.tileWidth / 2;
+        var centerY = this.tileHeight / 2;
+        var translatedX = x + this.diffTileHeightWidth;
+        var translatedY = adjustY ? y - this.diffTileHeightWidth : y;
+        var g = new svg_js_1.G();
+        g.add(image)
+            .translate(translatedX, translatedY)
+            .rotate(90, centerX, centerY);
+        return g;
+    };
+    BaseHelper.prototype.createStick = function (v) {
+        return this.image(v);
+    };
+    BaseHelper.prototype.buildID = function (tile) {
+        if (tile == 100 || tile == 1000) {
+            return tile == 100 ? "stick100" : "stick1000";
+        }
+        return "".concat(tile.k).concat(tile.n);
+    };
+    BaseHelper.prototype.buildURL = function (tile) {
+        var filename = "".concat(this.buildID(tile), ".svg");
+        if (this.image_host_url != "") {
+            return "".concat(this.image_host_url).concat(filename);
+        }
+        return "".concat(this.image_host_path).concat(filename);
+    };
+    return BaseHelper;
+}());
+var ImageHelper = (function (_super) {
+    __extends(ImageHelper, _super);
+    function ImageHelper() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.blockMargin = _this.tileWidth * 0.3;
+        return _this;
+    }
+    ImageHelper.prototype.createBlockHandDiscard = function (tiles) {
+        var g = new svg_js_1.G();
+        var pos = 0;
+        for (var _i = 0, tiles_1 = tiles; _i < tiles_1.length; _i++) {
+            var t = tiles_1[_i];
+            if (t.op == constants_1.OPERATOR.HORIZONTAL) {
+                var img_1 = this.createRotate90Image(t, pos, this.diffTileHeightWidth);
+                g.add(img_1);
+                pos += this.tileHeight;
+                continue;
+            }
+            var img = this.createImage(t, pos, 0);
+            g.add(img);
+            pos += this.tileWidth;
+        }
+        return g;
+    };
+    ImageHelper.prototype.createBlockPonChiKan = function (block) {
+        var idx = block.tiles.findIndex(function (d) { return d.op === constants_1.OPERATOR.HORIZONTAL; });
+        var pos = 0;
+        var g = new svg_js_1.G();
+        if (block.type == constants_1.BLOCK.SHO_KAN) {
+            var diff = this.tileWidth * 2 - this.tileHeight;
+            for (var i = 0; i < block.tiles.length; i++) {
+                if (i == idx + 1)
+                    continue;
+                if (i == idx) {
+                    var img_2 = this.createStackImage(block.tiles[idx], pos, 0);
+                    pos += this.tileHeight;
+                    g.add(img_2);
+                    continue;
+                }
+                var img = this.createImage(block.tiles[i], pos, diff);
+                pos += this.tileWidth;
+                g.add(img);
+            }
+            return g;
+        }
+        if (block.type == constants_1.BLOCK.CHI) {
+            var img = this.createRotate90Image(block.tiles[idx], pos, this.diffTileHeightWidth);
+            pos += this.tileHeight;
+            g.add(img);
+            for (var i = 0; i < block.tiles.length; i++) {
+                if (i == idx)
+                    continue;
+                var img_3 = this.createImage(block.tiles[i], pos, 0);
+                pos += this.tileWidth;
+                g.add(img_3);
+            }
+            return g;
+        }
+        for (var i = 0; i < block.tiles.length; i++) {
+            if (i == idx) {
+                var img_4 = this.createRotate90Image(block.tiles[i], pos, this.diffTileHeightWidth);
+                pos += this.tileHeight;
+                g.add(img_4);
+                continue;
+            }
+            var img = this.createImage(block.tiles[1], pos, 0);
+            pos += this.tileWidth;
+            g.add(img);
+        }
+        return g;
+    };
+    return ImageHelper;
+}(BaseHelper));
+exports.ImageHelper = ImageHelper;
+var getBlockCreators = function (h) {
+    var _a;
+    var lookup = (_a = {},
+        _a[constants_1.BLOCK.CHI] = function (block) {
+            var width = h.tileWidth * 2 + h.tileHeight;
+            var height = h.tileHeight;
+            var g = h.createBlockPonChiKan(block);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.PON] = function (block) {
+            var width = h.tileWidth * 2 + h.tileHeight;
+            var height = h.tileHeight;
+            var g = h.createBlockPonChiKan(block);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.DAI_KAN] = function (block) {
+            var width = h.tileWidth * 3 + h.tileHeight;
+            var height = h.tileHeight;
+            var g = h.createBlockPonChiKan(block);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.SHO_KAN] = function (block) {
+            var width = h.tileWidth * 2 + h.tileHeight;
+            var height = h.tileWidth * 2;
+            var g = h.createBlockPonChiKan(block);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.AN_KAN] = function (block) {
+            var width = h.tileWidth * 4;
+            var height = h.tileHeight;
+            var zp = block.tiles.filter(function (v) {
+                return v.k !== constants_1.KIND.BACK;
+            });
+            (0, assert_1.default)(zp != null && zp.length == 2);
+            var g = h.createBlockHandDiscard([
+                new parser_1.Tile(constants_1.KIND.BACK, 0),
+                zp[0],
+                zp[1],
+                new parser_1.Tile(constants_1.KIND.BACK, 0),
+            ]);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.DORA] = function (block) {
+            var width = h.tileWidth + h.textWidth;
+            var height = h.tileHeight;
+            var g = new svg_js_1.G();
+            var img = h.createTextImage(block.tiles[0], 0, 0, "(ドラ)");
+            g.add(img);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.TSUMO] = function (block) {
+            var width = h.tileWidth + h.textWidth;
+            var height = h.tileHeight;
+            var g = new svg_js_1.G();
+            var img = h.createTextImage(block.tiles[0], 0, 0, "(ツモ)");
+            g.add(img);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.HAND] = function (block) {
+            var width = h.tileWidth * block.tiles.length;
+            var height = h.tileHeight;
+            var g = h.createBlockHandDiscard(block.tiles);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.DISCARD] = function (block) {
+            var width = block.tiles
+                .map(function (v) { return (v.op == constants_1.OPERATOR.HORIZONTAL ? h.tileHeight : h.tileWidth); })
+                .reduce(function (prev, v) { return prev + v; });
+            var height = h.tileHeight;
+            var g = h.createBlockHandDiscard(block.tiles);
+            return { width: width, height: height, e: g };
+        },
+        _a[constants_1.BLOCK.UNKNOWN] = function (block) {
+            var width = 0;
+            var height = 0;
+            var g = new svg_js_1.G();
+            throw new Error("found unknown block");
+        },
+        _a);
+    return lookup;
+};
+var createHand = function (helper, blocks) {
+    var creators = getBlockCreators(helper);
+    var baseHeight = helper.tileWidth;
+    var sumOfWidth = 0;
+    var elms = [];
+    for (var _i = 0, blocks_1 = blocks; _i < blocks_1.length; _i++) {
+        var block = blocks_1[_i];
+        var fn = creators[block.type];
+        var elm = fn(block);
+        elms.push(elm);
+        sumOfWidth += elm.width;
+        if (elm.height > baseHeight)
+            baseHeight = elm.height;
+    }
+    var sizeHeight = baseHeight;
+    var sizeWidth = sumOfWidth + (blocks.length - 1) * helper.blockMargin;
+    var hand = new svg_js_1.G();
+    var pos = 0;
+    for (var _a = 0, elms_1 = elms; _a < elms_1.length; _a++) {
+        var elm = elms_1[_a];
+        var diff = baseHeight - elm.height;
+        var g = new svg_js_1.G().translate(pos, diff);
+        g.add(elm.e);
+        hand.add(g);
+        pos += elm.width + helper.blockMargin;
+    }
+    return { e: hand, width: sizeWidth, height: sizeHeight };
+};
+exports.createHand = createHand;
+var drawBlocks = function (svg, blocks, config) {
+    if (config === void 0) { config = {}; }
+    var helper = new ImageHelper(config);
+    var hand = (0, exports.createHand)(helper, blocks);
+    svg.size(hand.width, hand.height);
+    svg.add(hand.e);
+};
+exports.drawBlocks = drawBlocks;

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

@@ -0,0 +1,13 @@
+export declare class Lexer {
+    private input;
+    position: number;
+    private nextPosition;
+    char: string;
+    readonly eof = "\0";
+    constructor(input: string);
+    readChar(): string;
+    peekChar(): string;
+    prevChar(): string;
+    skipWhitespace(): void;
+    private isWhitespace;
+}

package/dist/mjs/lib/lexer.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lexer = void 0;
+var Lexer = (function () {
+    function Lexer(input) {
+        this.eof = "\0";
+        this.input = input;
+        this.position = 0;
+        this.nextPosition = 0;
+        this.char = this.readChar();
+    }
+    Lexer.prototype.readChar = function () {
+        if (this.nextPosition >= this.input.length) {
+            this.char = this.eof;
+            return this.char;
+        }
+        else {
+            this.char = this.input[this.nextPosition];
+        }
+        this.position = this.nextPosition;
+        this.nextPosition++;
+        return this.char;
+    };
+    Lexer.prototype.peekChar = function () {
+        if (this.nextPosition >= this.input.length)
+            return this.eof;
+        return this.input[this.nextPosition];
+    };
+    Lexer.prototype.prevChar = function () {
+        if (this.position >= this.input.length)
+            return this.eof;
+        if (this.position > 0)
+            return this.input[this.position - 1];
+        return this.eof;
+    };
+    Lexer.prototype.skipWhitespace = function () {
+        while (this.isWhitespace(this.char)) {
+            this.readChar();
+        }
+    };
+    Lexer.prototype.isWhitespace = function (char) {
+        return /\s/.test(char);
+    };
+    return Lexer;
+}());
+exports.Lexer = Lexer;

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

@@ -0,0 +1,11 @@
+import { ImageHelperConfig } from "./image";
+interface InitializeConfig extends Omit<ImageHelperConfig, "scale"> {
+    querySelector?: string | string[];
+    scale?: number;
+    tableScale?: number;
+}
+export declare class mjimage {
+    static svgURL: () => string;
+    static initialize: (props?: InitializeConfig) => void;
+}
+export {};