maidraw 0.9.1 → 0.9.3

package/dist/chu/chart/index.js

@@ -22,10 +22,1042 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Chart = void 0;
+const sharp_1 = __importDefault(require("sharp"));
+const type_1 = require("../type");
 const database = __importStar(require("./database"));
-var Chart;
+const util_1 = require("../../lib/util");
+const canvas_1 = require("canvas");
+const color_1 = __importDefault(require("color"));
+const glob_1 = require("glob");
+const upath_1 = __importDefault(require("upath"));
+const fs_1 = __importDefault(require("fs"));
+const string_template_1 = __importDefault(require("string-template"));
+const lodash_1 = __importDefault(require("lodash"));
+class Chart {
+    static JPN_LATEST = 230;
+    static INT_LATEST = 140;
+    static CHN_LATEST = 120;
+    static CHUNITHM_VERSIONS = [
+        240, 230, 225, 220, 215, 210, 205, 200, 150, 145, 140, 135, 130, 125,
+        120, 115, 110, 105, 100,
+    ];
+    static CHUNITHM_INT_VERSIONS = [
+        140, 135, 130, 125, 120, 115, 110, 105, 100,
+    ];
+    static ZHONGERJIEZOU_VERSIONS = [120, 110, 100];
+    static findVersion(v, region) {
+        const target = (() => {
+            switch (region) {
+                case "INT":
+                    return this.CHUNITHM_INT_VERSIONS;
+                case "CHN":
+                    return this.ZHONGERJIEZOU_VERSIONS;
+                case "JPN":
+                default:
+                    return this.CHUNITHM_VERSIONS;
+            }
+        })();
+        for (const version of target) {
+            if (v >= version)
+                return version;
+        }
+        return -1;
+    }
+    static DEFAULT_THEME = "jp-verse";
+    static primaryTheme = null;
+    static get assetsPath() {
+        return upath_1.default.join(__dirname, "..", "..", "..", "assets");
+    }
+    static themes = {};
+    static hasTheme(name) {
+        return !!this.themes[name];
+    }
+    static {
+        const manifests = (0, glob_1.globSync)(upath_1.default.join(this.assetsPath, "themes", "chunithm", "chart", "**", "manifest.json"));
+        for (const manifestPath of manifests) {
+            const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, "utf-8"));
+            if (this.validateManifest(manifest, upath_1.default.dirname(manifestPath))) {
+                this.themes[manifest.name] = upath_1.default.dirname(manifestPath);
+            }
+        }
+        const loadThemeResult = this.loadTheme(this.DEFAULT_THEME);
+        if (!loadThemeResult) {
+            console.error("Failed to load default theme.");
+        }
+        (0, canvas_1.registerFont)(upath_1.default.join(this.assetsPath, "fonts", "gen-jyuu-gothic", "GenJyuuGothic-Bold.ttf"), {
+            family: "standard-font-title-jp",
+        });
+        (0, canvas_1.registerFont)(upath_1.default.join(this.assetsPath, "fonts", "comfortaa", "Comfortaa-Bold.ttf"), {
+            family: "standard-font-title-latin",
+            weight: "regular",
+        });
+        (0, canvas_1.registerFont)(upath_1.default.join(this.assetsPath, "fonts", "seurat-db", "FOT-Seurat Pro DB.otf"), {
+            family: "standard-font-username",
+            weight: "regular",
+        });
+    }
+    static validateManifest(payload, path) {
+        function assert(obj, path, condition) {
+            const deepValue = (o, p) => p.split(".").reduce((a, v) => a[v], o);
+            const payload = deepValue(obj, path);
+            const result = condition(payload);
+            if (result === true)
+                return true;
+            throw `Manifest validation failed at ${path}.${result == false ? "" : ` ${result}`}`;
+        }
+        function isFileExist(object, objectPath) {
+            return assert(object, objectPath, (p) => {
+                const filePath = upath_1.default.join(path, p);
+                if (typeof p == "string") {
+                    if (fs_1.default.existsSync(filePath)) {
+                        return true;
+                    }
+                    else {
+                        return `${filePath} does not exist.`;
+                    }
+                }
+                else
+                    return false;
+            });
+        }
+        function isOneOf(object, path, optional = false, args) {
+            return assert(object, path, (p) => args.includes(p) || (optional && p === undefined));
+        }
+        function isString(object, path, optional = false) {
+            return assert(object, path, (p) => typeof p == "string" || (optional && p === undefined));
+        }
+        function isNumber(object, path, optional = false) {
+            return assert(object, path, (p) => typeof p == "number" || (optional && p === undefined));
+        }
+        function isArray(object, path, optional = false) {
+            return assert(object, path, (p) => Array.isArray(p) || (optional && p === undefined));
+        }
+        function isObject(object, path, optional = false) {
+            return assert(object, path, (p) => typeof p == "object" || (optional && p === undefined));
+        }
+        function isHexColor(object, path, optional = false) {
+            return assert(object, path, (p) => {
+                if (typeof p == "string")
+                    return (/^(?:#[0-9A-F]{6}|#[0-9A-F]{8})$/i.test(p) ||
+                        (optional && p === undefined));
+                else
+                    return optional && p === undefined;
+            });
+        }
+        function isBoolean(object, path, optional = false) {
+            return assert(object, path, (p) => typeof p == "boolean" || (optional && p === undefined));
+        }
+        if (isString(payload, "displayName") &&
+            isString(payload, "name") &&
+            isNumber(payload, "width") &&
+            isNumber(payload, "height") &&
+            isObject(payload, "sprites") &&
+            isObject(payload, "sprites.achievement") &&
+            isFileExist(payload, "sprites.achievement.d") &&
+            isFileExist(payload, "sprites.achievement.c") &&
+            isFileExist(payload, "sprites.achievement.b") &&
+            isFileExist(payload, "sprites.achievement.bb") &&
+            isFileExist(payload, "sprites.achievement.bbb") &&
+            isFileExist(payload, "sprites.achievement.a") &&
+            isFileExist(payload, "sprites.achievement.aa") &&
+            isFileExist(payload, "sprites.achievement.aaa") &&
+            isFileExist(payload, "sprites.achievement.s") &&
+            isFileExist(payload, "sprites.achievement.sp") &&
+            isFileExist(payload, "sprites.achievement.ss") &&
+            isFileExist(payload, "sprites.achievement.ssp") &&
+            isFileExist(payload, "sprites.achievement.sss") &&
+            isFileExist(payload, "sprites.achievement.sssp") &&
+            isObject(payload, "sprites.milestone") &&
+            isFileExist(payload, "sprites.milestone.aj") &&
+            isFileExist(payload, "sprites.milestone.ajc") &&
+            isFileExist(payload, "sprites.milestone.fc") &&
+            isFileExist(payload, "sprites.milestone.none") &&
+            isObject(payload, "sprites.profile") &&
+            isFileExist(payload, "sprites.profile.icon") &&
+            isFileExist(payload, "sprites.profile.nameplate") &&
+            isFileExist(payload, "sprites.ratingNumberMap") &&
+            isObject(payload, "sprites.versions") &&
+            isObject(payload, "sprites.versions.JPN") &&
+            isFileExist(payload, "sprites.versions.JPN.100") &&
+            isFileExist(payload, "sprites.versions.JPN.105") &&
+            isFileExist(payload, "sprites.versions.JPN.110") &&
+            isFileExist(payload, "sprites.versions.JPN.115") &&
+            isFileExist(payload, "sprites.versions.JPN.120") &&
+            isFileExist(payload, "sprites.versions.JPN.125") &&
+            isFileExist(payload, "sprites.versions.JPN.130") &&
+            isFileExist(payload, "sprites.versions.JPN.135") &&
+            isFileExist(payload, "sprites.versions.JPN.140") &&
+            isFileExist(payload, "sprites.versions.JPN.145") &&
+            isFileExist(payload, "sprites.versions.JPN.150") &&
+            isFileExist(payload, "sprites.versions.JPN.155") &&
+            isFileExist(payload, "sprites.versions.JPN.200") &&
+            isFileExist(payload, "sprites.versions.JPN.205") &&
+            isFileExist(payload, "sprites.versions.JPN.210") &&
+            isFileExist(payload, "sprites.versions.JPN.215") &&
+            isFileExist(payload, "sprites.versions.JPN.220") &&
+            isFileExist(payload, "sprites.versions.JPN.225") &&
+            isFileExist(payload, "sprites.versions.JPN.230") &&
+            isFileExist(payload, "sprites.versions.JPN.240") &&
+            isObject(payload, "sprites.versions.INT") &&
+            isFileExist(payload, "sprites.versions.INT.100") &&
+            isFileExist(payload, "sprites.versions.INT.105") &&
+            isFileExist(payload, "sprites.versions.INT.110") &&
+            isFileExist(payload, "sprites.versions.INT.115") &&
+            isFileExist(payload, "sprites.versions.INT.120") &&
+            isFileExist(payload, "sprites.versions.INT.125") &&
+            isFileExist(payload, "sprites.versions.INT.130") &&
+            isFileExist(payload, "sprites.versions.INT.135") &&
+            isFileExist(payload, "sprites.versions.INT.140") &&
+            isObject(payload, "sprites.versions.CHN") &&
+            isFileExist(payload, "sprites.versions.CHN.100") &&
+            isFileExist(payload, "sprites.versions.CHN.110") &&
+            isFileExist(payload, "sprites.versions.CHN.120") &&
+            // isFileExist(payload, "sprites.versions.CHN.130") && // Ignore the yet to release 中二节奏2026
+            isArray(payload, "elements")) {
+            for (const element of payload.elements) {
+                if (isNumber(element, "x") && isNumber(element, "y")) {
+                    switch (element.type) {
+                        case "image": {
+                            if (isNumber(element, "width") &&
+                                isNumber(element, "height") &&
+                                isFileExist(element, "path")) {
+                                continue;
+                            }
+                            else
+                                return false;
+                        }
+                        case "chart-grid": {
+                            if (isNumber(element, "width") &&
+                                isNumber(element, "height") &&
+                                isNumber(element, "margin") &&
+                                isNumber(element, "gap") &&
+                                isObject(element, "bubble") &&
+                                isHexColor(element, "bubble.color.basic") &&
+                                isHexColor(element, "bubble.color.advanced") &&
+                                isHexColor(element, "bubble.color.expert") &&
+                                isHexColor(element, "bubble.color.master") &&
+                                isHexColor(element, "bubble.color.ultima") &&
+                                isHexColor(element, "bubble.color.worldsEnd") &&
+                                isObject(element, "color") &&
+                                isHexColor(element, "color.card")) {
+                                continue;
+                            }
+                            else
+                                return false;
+                        }
+                        case "profile": {
+                            if (isNumber(element, "height")) {
+                                continue;
+                            }
+                            else
+                                return false;
+                        }
+                        case "detail-info": {
+                            if (isNumber(element, "width") &&
+                                isNumber(element, "height") &&
+                                isNumber(element, "margin") &&
+                                isObject(element, "color") &&
+                                isHexColor(element, "color.card") &&
+                                isString(element, "font", true)) {
+                                continue;
+                            }
+                            else
+                                return false;
+                        }
+                        case "text": {
+                            if (isNumber(element, "size") &&
+                                isString(element, "content") &&
+                                isNumber(element, "width", true) &&
+                                isNumber(element, "height", true) &&
+                                isBoolean(element, "linebreak", true) &&
+                                isOneOf(element, "align", true, [
+                                    "left",
+                                    "center",
+                                    "right",
+                                ]) &&
+                                isString(element, "color", true) &&
+                                isString(element, "borderColor", true) &&
+                                isString(element, "font", true)) {
+                                continue;
+                            }
+                            else
+                                return false;
+                        }
+                        default:
+                            throw `Manifest validation failed at elements.type. Unsupported element type ${element.type}.`;
+                    }
+                }
+            }
+            return true;
+        }
+        else
+            return false;
+    }
+    static loadTheme(path) {
+        const theme = this.getTheme(path);
+        if (theme) {
+            this.primaryTheme = theme;
+            return true;
+        }
+        else
+            return false;
+    }
+    static getTheme(path) {
+        if (!fs_1.default.existsSync(upath_1.default.join(path, "manifest.json"))) {
+            path = this.themes[path] ?? "";
+        }
+        else
+            path = upath_1.default.join(this.assetsPath, path);
+        if (fs_1.default.existsSync(upath_1.default.join(path, "manifest.json"))) {
+            const manifest = JSON.parse(fs_1.default.readFileSync(upath_1.default.join(path, "manifest.json"), "utf-8"));
+            if (this.validateManifest(manifest, path)) {
+                return { manifest, path };
+            }
+        }
+        return null;
+    }
+    static getThemeFile(path, themePath) {
+        if (typeof path == "string" &&
+            fs_1.default.existsSync(upath_1.default.join(themePath ?? this.primaryTheme?.path ?? "", path)))
+            return fs_1.default.readFileSync(upath_1.default.join(themePath ?? this.primaryTheme?.path, path));
+        else
+            return Buffer.from([]);
+    }
+    /* Begin Draw Tools*/
+    static async drawImageModule(ctx, theme, element) {
+        const img = new canvas_1.Image();
+        img.src = this.getThemeFile(element.path, theme.path);
+        ctx.drawImage(img, element.x, element.y, element.width, element.height);
+    }
+    static async drawChartGridCard(ctx, theme, element, chart, difficulty, x, y, width, height, isShort, targetRegion = "JPN", score) {
+        let curColor = "#FFFFFF";
+        switch (difficulty) {
+            case type_1.EDifficulty.BASIC:
+                curColor = element.bubble.color.basic;
+                break;
+            case type_1.EDifficulty.ADVANCED:
+                curColor = element.bubble.color.advanced;
+                break;
+            case type_1.EDifficulty.EXPERT:
+                curColor = element.bubble.color.expert;
+                break;
+            case type_1.EDifficulty.MASTER:
+                curColor = element.bubble.color.master;
+                break;
+            case type_1.EDifficulty.ULTIMA:
+                curColor = element.bubble.color.ultima;
+                break;
+            case type_1.EDifficulty.WORLDS_END:
+                curColor = element.bubble.color.worldsEnd;
+                break;
+        }
+        /** Begin Card Draw */
+        ctx.save();
+        ctx.fillStyle = new color_1.default(curColor).lighten(0.4).hexa();
+        ctx.beginPath();
+        ctx.roundRect(x, y, width, height, (height * 0.806) / 7);
+        ctx.strokeStyle = new color_1.default(curColor).darken(0.3).hexa();
+        ctx.lineWidth = element.bubble.margin / 4;
+        ctx.stroke();
+        ctx.fill();
+        ctx.beginPath();
+        ctx.roundRect(x, y, width, height, (height * 0.806) / 7);
+        ctx.clip();
+        /** Begin Main Content Draw */
+        {
+            ctx.save();
+            ctx.beginPath();
+            ctx.rect(x, y, width, height);
+            ctx.clip();
+            ctx.fillStyle = curColor;
+            ctx.fill();
+            const titleSize = height * (47 / 256);
+            /** Begin Difficulty Text & Separation Line Draw */
+            {
+                let difficultiy = "";
+                switch (chart.difficulty) {
+                    case type_1.EDifficulty.BASIC:
+                        difficultiy = "BASIC";
+                        break;
+                    case type_1.EDifficulty.ADVANCED:
+                        difficultiy = "ADVANCED";
+                        break;
+                    case type_1.EDifficulty.EXPERT:
+                        difficultiy = "EXPERT";
+                        break;
+                    case type_1.EDifficulty.MASTER:
+                        difficultiy = "MASTER";
+                        break;
+                    case type_1.EDifficulty.ULTIMA:
+                        difficultiy = "ULTIMA";
+                        break;
+                    case type_1.EDifficulty.WORLDS_END:
+                        difficultiy = "WORLD'S END";
+                        break;
+                }
+                const levelTextSize = titleSize * (5 / 8);
+                util_1.Util.drawText(ctx, difficultiy, x + element.bubble.margin, y +
+                    element.bubble.margin +
+                    titleSize -
+                    element.bubble.margin * (1 / 4), titleSize, height * 0.806 * 0.04, Infinity, "left", "white", new color_1.default(curColor).darken(0.3).hexa());
+                const difficultyTextWidth = util_1.Util.measureText(ctx, difficultiy, titleSize, Infinity).width;
+                util_1.Util.drawText(ctx, `Lv. ${util_1.Util.truncate(chart.events
+                    .filter((v) => v.version.region == targetRegion)
+                    .reverse()
+                    .find((v) => v.type == "existence")?.data.level ||
+                    0, 1)}${score ? `　+${util_1.Util.truncate(score.rating, 1)}` : ""}`, x + element.bubble.margin * 2 + difficultyTextWidth, y +
+                    element.bubble.margin +
+                    titleSize -
+                    element.bubble.margin * (1 / 4), levelTextSize, height * 0.806 * 0.04, Infinity, "left", "white", new color_1.default(curColor).darken(0.3).hexa());
+                ctx.beginPath();
+                ctx.roundRect(x + element.bubble.margin, y +
+                    element.bubble.margin +
+                    titleSize +
+                    element.bubble.margin * (1 / 4), height * 2 - element.bubble.margin * 2, height * 0.806 * 0.02, height * 0.806 * 0.16);
+                ctx.fillStyle = new color_1.default(curColor).darken(0.3).hex();
+                ctx.fill();
+            }
+            /** End Difficulty Text & Separation Line Draw */
+            /** Begin Achievement Rate Draw */
+            {
+                const scoreSize = height * 0.806 * 0.208;
+                util_1.Util.drawText(ctx, score ? util_1.Util.truncate(score.score, 0) : "NO RECORD", x +
+                    height * 2 -
+                    element.bubble.margin -
+                    height * 0.806 * 0.02, y +
+                    element.bubble.margin +
+                    titleSize +
+                    element.bubble.margin * (5 / 8) +
+                    scoreSize, scoreSize, height * 0.806 * 0.04, Infinity, "right", "white", new color_1.default(curColor).darken(0.3).hexa());
+            }
+            /** End Achievement Rate Draw */
+            /** Begin Achievement Rank Draw */
+            {
+                if (score) {
+                    let rankImg;
+                    switch (score.rank) {
+                        case type_1.EAchievementTypes.D:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.d, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.C:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.c, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.B:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.b, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.BB:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.bb, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.BBB:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.bbb, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.A:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.a, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.AA:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.aa, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.AAA:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.aaa, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.S:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.s, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.SP:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.sp, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.SS:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.ss, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.SSP:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.ssp, theme.path);
+                            break;
+                        case type_1.EAchievementTypes.SSS:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.sss, theme.path);
+                            break;
+                        default:
+                            rankImg = this.getThemeFile(theme.manifest.sprites.achievement.sssp, theme.path);
+                    }
+                    const blockHeight = height * 0.806 * 0.3 * 0.85, blockWidth = blockHeight * (540 / 180);
+                    const img = new canvas_1.Image();
+                    img.src = rankImg;
+                    ctx.drawImage(img, x + element.bubble.margin * (1 / 2), y +
+                        element.bubble.margin +
+                        titleSize +
+                        element.bubble.margin * (1 / 2), blockWidth, blockHeight);
+                }
+            }
+            /** End Achievement Rank Draw */
+            /** Begin Milestone Draw */
+            {
+                const blockWidth = height * 0.806 * 0.32 * 3, blockHeight = (blockWidth * 40) / 268;
+                const curX = x - blockWidth + height * 2 - element.bubble.margin, curY = y + element.bubble.margin * 2 + titleSize * 2;
+                ctx.fillStyle = "#e8eaec";
+                ctx.roundRect(curX, curY, blockWidth, blockHeight, blockWidth / 56);
+                ctx.fill();
+                if (score) {
+                    let comboImg;
+                    switch (score.combo) {
+                        case type_1.EComboTypes.NONE:
+                            comboImg = this.getThemeFile(theme.manifest.sprites.milestone.none, theme.path);
+                            break;
+                        case type_1.EComboTypes.FULL_COMBO:
+                            comboImg = this.getThemeFile(theme.manifest.sprites.milestone.fc, theme.path);
+                            break;
+                        case type_1.EComboTypes.ALL_JUSTICE:
+                            comboImg = this.getThemeFile(theme.manifest.sprites.milestone.aj, theme.path);
+                            break;
+                        case type_1.EComboTypes.ALL_JUSTICE_CRITICAL:
+                            comboImg = this.getThemeFile(theme.manifest.sprites.milestone.ajc, theme.path);
+                            break;
+                    }
+                    const combo = new canvas_1.Image();
+                    combo.src = comboImg;
+                    ctx.drawImage(combo, curX, curY, blockWidth, blockHeight);
+                }
+            }
+            /** End Milestone Draw */
+            /** Begin Version Draw */
+            {
+                const version = {
+                    region: "JPN",
+                    version: undefined,
+                };
+                const VER = chart.difficulty == type_1.EDifficulty.ULTIMA
+                    ? chart.events.find((v) => v.type == "existence" &&
+                        v.version.region == targetRegion)?.version
+                    : chart.addVersion;
+                version.version = VER;
+                version.region = targetRegion;
+                const versionImageHeight = (height - element.bubble.margin * 2) *
+                    (isShort ? 9 / 16 : 1 / 2);
+                const versionImageWidth = (versionImageHeight / 160) * 201;
+                const curx = x + width - element.bubble.margin, cury = y + element.bubble.margin;
+                if (version.version) {
+                    const rawVersion = this.findVersion(util_1.Util.Chunithm.getNumberVersion(version.version), targetRegion);
+                    const versionImage = this.getThemeFile(theme.manifest.sprites.versions[version.region][rawVersion]);
+                    try {
+                        (0, sharp_1.default)(versionImage);
+                        if (versionImage) {
+                            const versionImg = new canvas_1.Image();
+                            versionImg.src = versionImage;
+                            ctx.drawImage(versionImg, curx - versionImageWidth, cury, versionImageWidth, versionImageHeight);
+                        }
+                    }
+                    catch { }
+                }
+                /** End Version Draw */
+                /** Begin Note Count Draw */
+                const noteCountTexts = Object.entries(chart.meta.notes).map(([k, v]) => `${util_1.Util.capitalize(k)}: ${v}`);
+                const noteCountTextSize = (height - element.bubble.margin * 4) /
+                    noteCountTexts.length;
+                let noteCountLength = 0;
+                noteCountTexts.forEach((v, i) => {
+                    util_1.Util.drawText(ctx, v, x + element.bubble.margin * (3 / 2) + height * 2, y +
+                        element.bubble.margin +
+                        noteCountTextSize +
+                        (noteCountTextSize +
+                            (element.bubble.margin * 2) /
+                                (noteCountTexts.length - 1)) *
+                            i, noteCountTextSize, height * 0.806 * 0.04, Infinity, "left", "white", new color_1.default(curColor).darken(0.3).hexa());
+                    const length = util_1.Util.measureText(ctx, v, noteCountTextSize, Infinity).width;
+                    if (length > noteCountLength)
+                        noteCountLength = length;
+                });
+                /** End Note Count Draw */
+                /** Begin Internal Level Trend Draw */
+                if (!isShort) {
+                    const CURRENT_VER = (() => {
+                        switch (targetRegion) {
+                            case "INT":
+                                return this.INT_LATEST;
+                            case "CHN":
+                                return this.CHN_LATEST;
+                            case "JPN":
+                            default:
+                                return this.JPN_LATEST;
+                        }
+                    })();
+                    const maxWidth = width -
+                        height * 2 -
+                        element.bubble.margin * 4 -
+                        noteCountLength -
+                        versionImageWidth;
+                    const maxFitTrendCount = Math.trunc(maxWidth / versionImageWidth);
+                    const trendEvents = chart.events.filter((v) => v.type == "existence" &&
+                        v.version.region == targetRegion);
+                    let actualEvents = lodash_1.default.uniqWith(trendEvents, (a, b) => {
+                        return lodash_1.default.isEqual(a.data.level, b.data.level);
+                    });
+                    if (actualEvents.length == maxFitTrendCount) {
+                    }
+                    else if (actualEvents.length > maxFitTrendCount) {
+                        while (actualEvents.length > maxFitTrendCount)
+                            actualEvents.shift();
+                        actualEvents.shift();
+                        actualEvents.shift();
+                        actualEvents.unshift(trendEvents[0]);
+                        actualEvents.push(trendEvents[trendEvents.length - 1]);
+                    }
+                    else if (trendEvents.length > maxFitTrendCount) {
+                        actualEvents = lodash_1.default.filter(actualEvents, (v) => !(lodash_1.default.isEqual(v.version.gameVersion, trendEvents[0].version.gameVersion) ||
+                            lodash_1.default.isEqual(v.version.gameVersion, trendEvents[trendEvents.length - 1]
+                                .version.gameVersion)));
+                        for (let i = trendEvents.length - 2; i > 0 && actualEvents.length < maxFitTrendCount - 2; --i) {
+                            const event = trendEvents[i];
+                            if (event)
+                                actualEvents.push(event);
+                            actualEvents = lodash_1.default.uniqWith(actualEvents, (a, b) => {
+                                return (lodash_1.default.isEqual(a.version.gameVersion.major, b.version.gameVersion.major) &&
+                                    lodash_1.default.isEqual(a.version.gameVersion.minor, b.version.gameVersion.minor));
+                            });
+                        }
+                        actualEvents.unshift(trendEvents[0]);
+                        actualEvents.push(trendEvents[trendEvents.length - 1]);
+                        actualEvents = lodash_1.default.uniqWith(actualEvents, (a, b) => {
+                            return (lodash_1.default.isEqual(a.version.gameVersion.major, b.version.gameVersion.major) &&
+                                lodash_1.default.isEqual(a.version.gameVersion.minor, b.version.gameVersion.minor));
+                        });
+                        actualEvents = lodash_1.default.sortBy(actualEvents, (v) => util_1.Util.Chunithm.getNumberVersion(v.version));
+                        if (trendEvents.length > 1) {
+                            if (actualEvents.length >= maxFitTrendCount)
+                                actualEvents.pop();
+                            actualEvents.push(trendEvents[trendEvents.length - 1]);
+                        }
+                        const removalEvent = chart.events.find((v) => v.type == "removal" &&
+                            v.version.region == targetRegion);
+                        if (removalEvent) {
+                            actualEvents.pop();
+                            actualEvents.push(removalEvent);
+                        }
+                    }
+                    else {
+                        actualEvents = [...trendEvents];
+                    }
+                    if (util_1.Util.Chunithm.getNumberVersion(actualEvents[actualEvents.length - 1].version) < CURRENT_VER) {
+                        while (actualEvents.length >= maxFitTrendCount)
+                            actualEvents.pop();
+                        actualEvents.push({
+                            type: "removal",
+                            version: util_1.Util.Chunithm.Version.toEventVersion(util_1.Util.Chunithm.Version.getNextVersion(trendEvents[trendEvents.length - 1].version)),
+                        });
+                    }
+                    actualEvents = lodash_1.default.uniqWith(actualEvents, (a, b) => {
+                        return (lodash_1.default.isEqual(a.version.gameVersion.major, b.version.gameVersion.major) &&
+                            lodash_1.default.isEqual(a.version.gameVersion.minor, b.version.gameVersion.minor) &&
+                            lodash_1.default.isEqual(a.type, b.type));
+                    });
+                    let positionAdjustment = 0;
+                    let addGap = (maxWidth - actualEvents.length * versionImageWidth) /
+                        (actualEvents.length - 1);
+                    if (addGap > maxWidth / 5) {
+                        addGap = maxWidth / 5;
+                        positionAdjustment =
+                            (maxWidth -
+                                (addGap * (actualEvents.length - 1) +
+                                    versionImageWidth * actualEvents.length)) /
+                                2;
+                    }
+                    for (let i = 0, curx = x +
+                        positionAdjustment +
+                        height * 2 +
+                        element.bubble.margin * (5 / 2) +
+                        noteCountLength, cury = y +
+                        element.bubble.margin +
+                        versionImageHeight * (1 / 2); i < actualEvents.length; ++i) {
+                        const event = actualEvents[i];
+                        const rawVersion = this.findVersion(util_1.Util.Chunithm.getNumberVersion(event.version), targetRegion);
+                        const versionImage = this.getThemeFile(theme.manifest.sprites.versions[targetRegion][rawVersion]);
+                        try {
+                            (0, sharp_1.default)(versionImage);
+                            if (versionImage) {
+                                const versionImg = new canvas_1.Image();
+                                versionImg.src = versionImage;
+                                ctx.drawImage(versionImg, curx, cury, versionImageWidth, versionImageHeight);
+                                if (event.type == "existence") {
+                                    let symbol = "";
+                                    if (i != 0) {
+                                        const lastEvent = actualEvents[i - 1];
+                                        if (lastEvent.type == "existence") {
+                                            if (lastEvent.data.level <
+                                                event.data.level)
+                                                symbol = "↑";
+                                            else if (lastEvent.data.level >
+                                                event.data.level)
+                                                symbol = "↓";
+                                            else if (lastEvent.data.level ==
+                                                event.data.level)
+                                                symbol = "→";
+                                        }
+                                    }
+                                    util_1.Util.drawText(ctx, `${symbol}${util_1.Util.truncate(event.data.level, 1)}`, curx + versionImageWidth / 2, cury +
+                                        versionImageHeight +
+                                        noteCountTextSize, noteCountTextSize, height * 0.806 * 0.04, Infinity, "center", "white", new color_1.default(curColor).darken(0.3).hexa());
+                                }
+                                else if (event.type == "removal") {
+                                    util_1.Util.drawText(ctx, `❌`, curx + versionImageWidth / 2, cury +
+                                        versionImageHeight +
+                                        noteCountTextSize, noteCountTextSize, height * 0.806 * 0.04, Infinity, "center", "white", new color_1.default(curColor).darken(0.3).hexa());
+                                }
+                                curx += versionImageWidth + addGap;
+                            }
+                        }
+                        catch { }
+                    }
+                }
+            }
+            /** End Internal Level Trend Draw */
+            ctx.restore();
+        }
+        /** End Main Content Draw */
+        ctx.fillStyle = new color_1.default(curColor).lighten(0.4).hexa();
+        ctx.beginPath();
+        ctx.roundRect(x, y + height * 0.742, height * 2, height * (1 - 0.742), [
+            0,
+            (height * 0.806) / 7,
+            0,
+            (height * 0.806) / 7,
+        ]);
+        ctx.fill();
+        /** Begin Difficulty & DX Rating Draw */
+        {
+            ctx.save();
+            ctx.clip();
+            util_1.Util.drawText(ctx, chart.designer || "-", x + element.bubble.margin, y + height * (0.806 + (1 - 0.806) / 2), height * 0.806 * 0.128, height * 0.806 * 0.04, Infinity, "left", "white", new color_1.default(curColor).darken(0.3).hexa());
+            ctx.restore();
+            // Util.drawText(
+            //     ctx,
+            //     `${score ? `${score.dxScore}/` : "MAX DX SCR: "}${chart.meta.maxDXScore}`,
+            //     x + height * 2 - element.bubble.margin,
+            //     y + height - element.bubble.margin * 3.1,
+            //     height * 0.806 * 0.128,
+            //     height * 0.806 * 0.04,
+            //     Infinity,
+            //     "right",
+            //     "white",
+            //     new Color(curColor).darken(0.3).hexa()
+            // );
+        }
+        /** End Difficulty & DX Rating Draw */
+        ctx.restore();
+        /** End Card Draw */
+    }
+    static async drawDetailInfoModule(ctx, theme, element, chartId) {
+        const jacketMargin = element.margin;
+        const textMargin = element.margin;
+        const chart = Chart.Database.getLocalChart(chartId, type_1.EDifficulty.BASIC);
+        const jacket = await Chart.Database.fecthJacket(chartId);
+        /* Begin Background Draw */
+        ctx.beginPath();
+        ctx.roundRect(element.x, element.y, element.width, element.height, Math.min(theme.manifest.width, theme.manifest.height) * (3 / 128));
+        ctx.fillStyle = element.color.card;
+        ctx.strokeStyle = new color_1.default(element.color.card).darken(0.6).hex();
+        ctx.lineWidth =
+            Math.min(theme.manifest.width, theme.manifest.height) * (3 / 512);
+        ctx.stroke();
+        ctx.fill();
+        /* End Background Draw */
+        /* Begin jacket draw */
+        if (jacket) {
+            const jacketImage = new canvas_1.Image();
+            const roundRadius = Math.min(theme.manifest.width, theme.manifest.height) *
+                (3 / 128);
+            jacketImage.src = jacket;
+            ctx.beginPath();
+            ctx.roundRect(element.x + jacketMargin, element.y + jacketMargin, element.width - jacketMargin * 2, element.width - jacketMargin * 2, [roundRadius, roundRadius, 0, 0]);
+            ctx.save();
+            ctx.clip();
+            ctx.drawImage(jacketImage, element.x + jacketMargin, element.y + jacketMargin, element.width - jacketMargin * 2, element.width - jacketMargin * 2);
+            ctx.restore();
+        }
+        /* End jacket draw */
+        /* Begin Detail Draw */
+        if (chart) {
+            const textSizeTitle = element.width * (1 / 16);
+            const textSizeSecondary = element.width * (1 / 24);
+            const { actualBoundingBoxAscent: ascent, actualBoundingBoxDescent: decent, } = util_1.Util.measureText(ctx, chart.name, textSizeTitle, Infinity);
+            const titleActualHeight = Math.abs(ascent - decent);
+            const textLineWidth = element.width * (7 / 512);
+            const textColor = new color_1.default(element.color.card).darken(0.5).hex();
+            const textTitleMaxWidth = element.width - textMargin * 2;
+            const titleMetrics = util_1.Util.measureText(ctx, chart.name, textSizeTitle, textTitleMaxWidth);
+            util_1.Util.drawText(ctx, chart.name, element.x + textMargin, element.y +
+                jacketMargin +
+                textMargin * (1 / 2) +
+                (element.width - jacketMargin * 2) +
+                textSizeTitle, textSizeTitle, textLineWidth, textTitleMaxWidth, "left", "white", textColor);
+            util_1.Util.drawText(ctx, chart.artist, element.x + textMargin, element.y +
+                jacketMargin +
+                textMargin * (1 / 2) +
+                (element.width - jacketMargin * 2) +
+                textSizeTitle * 2, textSizeSecondary, textLineWidth, element.width - textMargin * 2, "left", "white", textColor);
+            function getBpmRange(bpms) {
+                const uniqueBpms = lodash_1.default.uniq(bpms);
+                if (uniqueBpms.length <= 0)
+                    return "0";
+                else if (uniqueBpms.length == 1)
+                    return `${uniqueBpms[0]}`;
+                else {
+                    const minBpm = Math.min(...uniqueBpms);
+                    const maxBpm = Math.max(...uniqueBpms);
+                    return `${minBpm}-${maxBpm}`;
+                }
+            }
+            util_1.Util.drawText(ctx, `#${chart.id} BPM: ${getBpmRange(chart.bpms)}`, element.x + textMargin, element.y +
+                jacketMargin +
+                textMargin * (1 / 2) +
+                (element.width - jacketMargin * 2) +
+                textSizeTitle * 3, textSizeSecondary, textLineWidth, element.width - textMargin * 2, "left", "white", textColor);
+            const EVENT_JPN = chart.events
+                .filter((v) => v.version.region == "JPN" &&
+                util_1.Util.Chunithm.getNumberVersion(v.version) >=
+                    Chart.JPN_LATEST)
+                .map((v) => v.type);
+            const EVENT_INT = chart.events
+                .filter((v) => v.version.region == "INT" &&
+                util_1.Util.Chunithm.getNumberVersion(v.version) >=
+                    Chart.INT_LATEST)
+                .map((v) => v.type);
+            const EVENT_CHN = chart.events
+                .filter((v) => v.version.region == "CHN" &&
+                util_1.Util.Chunithm.getNumberVersion(v.version) >=
+                    Chart.CHN_LATEST)
+                .map((v) => v.type);
+            const EXIST_JPN = EVENT_JPN.includes("existence") &&
+                !EVENT_JPN.includes("removal")
+                ? "🇯🇵"
+                : "";
+            const EXIST_INT = EVENT_INT.includes("existence") &&
+                !EVENT_INT.includes("removal")
+                ? "🌏"
+                : "";
+            const EXIST_CHN = EVENT_CHN.includes("existence") &&
+                !EVENT_CHN.includes("removal")
+                ? "🇨🇳"
+                : "";
+            const title = [];
+            if (EXIST_JPN)
+                title.push(EXIST_JPN);
+            if (EXIST_INT)
+                title.push(EXIST_INT);
+            if (EXIST_CHN)
+                title.push(EXIST_CHN);
+            await util_1.Util.drawEmojiOrGlyph(ctx, title.join(" "), element.x + element.width - textMargin, element.y +
+                jacketMargin +
+                textMargin * (1 / 2) +
+                (element.width - jacketMargin * 2) +
+                textSizeTitle * 3, textSizeSecondary * (9 / 8), element.width - textMargin * 2, "right", "white", textColor);
+        }
+        /* End Detail Draw */
+    }
+    static async drawChartGridModule(ctx, theme, element, chartId, scores, region = "JPN") {
+        /* Begin Background Draw */
+        ctx.roundRect(element.x, element.y, element.width, element.height, Math.min(theme.manifest.width, theme.manifest.height) * (3 / 128));
+        ctx.fillStyle = element.color.card;
+        ctx.strokeStyle = new color_1.default(element.color.card).darken(0.6).hex();
+        ctx.lineWidth =
+            Math.min(theme.manifest.width, theme.manifest.height) * (3 / 512);
+        ctx.stroke();
+        ctx.fill();
+        /* End Background Draw */
+        const difficulties = [];
+        for (let i = type_1.EDifficulty.BASIC; i <= type_1.EDifficulty.ULTIMA; ++i) {
+            const chart = Chart.Database.getLocalChart(chartId, i);
+            if (chart)
+                difficulties.push(chart);
+        }
+        const cardWidth = element.width - element.margin * 2;
+        const cardHeight = (element.height - element.margin * 2 - element.gap * 3) / 4;
+        for (let y = element.y + element.margin, i = 0; i < difficulties.length; ++i, y += cardHeight + element.gap) {
+            const chart = difficulties[i];
+            if (chart)
+                if (difficulties.length > 4 && i == 0) {
+                    await this.drawChartGridCard(ctx, theme, element, chart, i, element.x + element.margin, y, (cardWidth - element.margin) / 2, cardHeight, true, region, scores[i]);
+                    i++;
+                    const chartA = difficulties[i];
+                    if (chartA)
+                        await this.drawChartGridCard(ctx, theme, element, chartA, i, element.x +
+                            element.margin +
+                            (cardWidth + element.margin) / 2, y, (cardWidth - element.margin) / 2, cardHeight, true, region, scores[i]);
+                }
+                else {
+                    await this.drawChartGridCard(ctx, theme, element, chart, i, element.x + element.margin, y, cardWidth, cardHeight, false, region, scores[i]);
+                }
+        }
+    }
+    static async drawProfileModule(ctx, theme, element, username, rating, profilePicture) {
+        const nameplate = new canvas_1.Image();
+        nameplate.src = this.getThemeFile(theme.manifest.sprites.profile.nameplate, theme.path);
+        ctx.drawImage(nameplate, element.x, element.y, element.height * 2.526, element.height);
+        /* Begin Profile Picture Draw */
+        {
+            ctx.save();
+            ctx.beginPath();
+            ctx.roundRect(element.x + element.height * 2.0, element.y + element.height * 0.3, element.height * 0.45, element.height * 0.45, 0);
+            ctx.clip();
+            ctx.fillStyle = "white";
+            ctx.fill();
+            const icon = new canvas_1.Image();
+            try {
+                (0, sharp_1.default)(profilePicture);
+            }
+            catch {
+                // Unknown profile picture binary
+                profilePicture = undefined;
+            }
+            const pfp = profilePicture ||
+                this.getThemeFile(theme.manifest.sprites.profile.icon, theme.path);
+            const { dominant } = await (0, sharp_1.default)(pfp).stats();
+            icon.src = await (0, sharp_1.default)(pfp).png().toBuffer();
+            const cropSize = Math.min(icon.width, icon.height);
+            ctx.drawImage(icon, (icon.width - cropSize) / 2, (icon.height - cropSize) / 2, cropSize, cropSize, element.x + element.height * 2.0, element.y + element.height * 0.3, element.height * 0.45, element.height * 0.45);
+            if (profilePicture) {
+                ctx.beginPath();
+                ctx.roundRect(element.x + element.height * 2.0, element.y + element.height * 0.3, element.height * 0.45, element.height * 0.45, 0);
+                ctx.strokeStyle = color_1.default.rgb(dominant).darken(0.3).hex();
+                ctx.lineWidth = element.height / 128;
+                ctx.stroke();
+            }
+            ctx.restore();
+        }
+        /* End Profile Picture Draw */
+        /* Begin Username Draw */
+        {
+            ctx.beginPath();
+            ctx.roundRect(element.x + element.height * (21 / 32), element.y + element.height * (11 / 32), element.height * (85 / 64), element.height * (13 / 32), 0);
+            ctx.fillStyle = "rgba(255, 255, 255, 0.45)";
+            ctx.fill();
+            // const ratingImgBuffer = await this.getRatingNumber(rating, theme);
+            // if (ratingImgBuffer) {
+            //     const { width, height } =
+            //         await sharp(ratingImgBuffer).metadata();
+            //     if (width && height) {
+            //         const aspectRatio = width / height;
+            //         const image = new Image();
+            //         image.src = ratingImgBuffer;
+            //         const drawHeight = (element.height * 7) / 32;
+            //         ctx.drawImage(
+            //             image,
+            //             element.x + element.height * 2.0,
+            //             element.y + element.height * 0.3,
+            //             drawHeight * aspectRatio * 0.8,
+            //             drawHeight
+            //         );
+            //     }
+            // }
+            util_1.Util.drawText(ctx, "Lv.", element.x + element.height * (43 / 64), element.y + element.height * (0.3 + 1 / 4), (element.height * 1) / 16, 0, ((element.height / 3) * 5.108 * 3.1) / 5, "left", "black", "black", "standard-font-username");
+            util_1.Util.drawText(ctx, "99", element.x + element.height * (49 / 64), element.y + element.height * (0.3 + 1 / 4), (element.height * 1) / 11, 0, ((element.height / 3) * 5.108 * 3.1) / 5, "left", "black", "black", "standard-font-username");
+            util_1.Util.drawText(ctx, util_1.Util.HalfFullWidthConvert.toFullWidth(username), element.x + element.height * (56 / 64), element.y + element.height * (0.3 + 1 / 4), (element.height * 1) / 8, 0, element.height * (65 / 64), "left", "black", "black", "standard-font-username");
+            util_1.Util.drawText(ctx, "RATING", element.x + element.height * (43 / 64), element.y + element.height * (47 / 64), (element.height * 7) / 88, 0, ((element.height / 3) * 5.108 * 3.1) / 5, "left", "black", "black", "standard-font-username");
+            util_1.Util.drawText(ctx, util_1.Util.truncate(rating, 2), element.x + element.height * (67 / 64), element.y + element.height * (47 / 64), (element.height * 5) / 44, 0, ((element.height / 3) * 5.108 * 3.1) / 5, "left", "black", "black", "standard-font-username");
+        }
+        /* End Username Draw*/
+    }
+    static async drawTextModule(ctx, theme, element, variables = {}) {
+        let naiveLines = (0, string_template_1.default)(element.content, variables).split("\n");
+        let lines = [];
+        if (element.linebreak) {
+            for (let originalContent of naiveLines) {
+                while (originalContent.length) {
+                    const line = util_1.Util.findMaxFitString(ctx, originalContent, element.width || Infinity, "");
+                    originalContent = originalContent.replace(line, "").trim();
+                    lines.push(line.trim());
+                }
+            }
+        }
+        else {
+            for (const originalContent of naiveLines) {
+                lines.push(util_1.Util.findMaxFitString(ctx, originalContent, element.width || Infinity));
+            }
+        }
+        for (let i = 0; i < lines.length; ++i) {
+            const line = lines[i];
+            util_1.Util.drawText(ctx, line, element.x, element.y + i * element.size * 1.3, element.size, element.size / 3.5, element.width || Infinity, element.align, element.color || "#FFFFFF", element.borderColor
+                ? element.borderColor
+                : color_1.default.rgb(element.color || "#FFFFFF")
+                    .darken(0.3)
+                    .hex(), element.font, element.linebreak ? "" : "...");
+        }
+    }
+    /* End Draw Tools*/
+    static async draw(name, rating, chartId, scores, type = "recents", options = {}) {
+        let currentTheme = this.primaryTheme;
+        if (options?.theme) {
+            const theme = this.getTheme(options.theme);
+            if (theme) {
+                currentTheme = theme;
+            }
+        }
+        const chart = Chart.Database.getLocalChart(chartId, type_1.EDifficulty.BASIC);
+        if (!chart)
+            return null;
+        if (currentTheme) {
+            await Chart.Database.cacheJackets([chartId]);
+            const canvas = new canvas_1.Canvas(currentTheme.manifest.width * (options?.scale ?? 1), currentTheme.manifest.height * (options?.scale ?? 1));
+            const ctx = canvas.getContext("2d");
+            if (options?.scale)
+                ctx.scale(options.scale, options.scale);
+            ctx.imageSmoothingEnabled = true;
+            for (const element of currentTheme.manifest.elements) {
+                switch (element.type) {
+                    case "image": {
+                        await this.drawImageModule(ctx, currentTheme, element);
+                        break;
+                    }
+                    case "chart-grid": {
+                        await this.drawChartGridModule(ctx, currentTheme, element, chartId, scores, options?.region);
+                        break;
+                    }
+                    case "detail-info": {
+                        await this.drawDetailInfoModule(ctx, currentTheme, element, chartId);
+                        break;
+                    }
+                    case "profile": {
+                        await this.drawProfileModule(ctx, currentTheme, element, name, rating, options?.profilePicture);
+                        break;
+                    }
+                    case "text": {
+                        await this.drawTextModule(ctx, currentTheme, element, {
+                            username: util_1.Util.HalfFullWidthConvert.toFullWidth(name),
+                            rating: util_1.Util.truncate(rating, 0),
+                        });
+                        break;
+                    }
+                }
+            }
+            return canvas.toBuffer();
+        }
+        else
+            return null;
+    }
+    static async drawWithScoreSource(source, username, chartId, type = "recents", options = {}) {
+        const profile = await source.getPlayerInfo(username, type);
+        const score = await source.getPlayerScore(username, chartId);
+        if (!profile || !score)
+            return null;
+        return this.draw(profile.name, profile.rating, chartId, [
+            score.basic,
+            score.advanced,
+            score.expert,
+            score.master,
+            score.ultima,
+            score.worldsEnd,
+        ], type, {
+            ...options,
+            profilePicture: options?.profilePicture === null
+                ? undefined
+                : options?.profilePicture ||
+                    (await source.getPlayerProfilePicture(username)) ||
+                    undefined,
+        });
+    }
+}
+exports.Chart = Chart;
 (function (Chart) {
     Chart.Database = database.Database;
 })(Chart || (exports.Chart = Chart = {}));