maidraw 0.11.15 → 0.12.0

package/dist/geki/lib/adapter/kamaiTachi/index.d.ts

@@ -1,17 +1,51 @@
 import { IScore } from "../../../type";
-import { ScoreTrackerAdapter } from "..";
-export declare class KamaiTachi extends ScoreTrackerAdapter {
+import { OngekiScoreAdapter } from "..";
+type IBest55ResponseData = {
+    "invalid-user": {
+        username: string;
+    };
+};
+type IBest60ResponseData = IBest55ResponseData & {};
+type IProfileResponseData = IBest55ResponseData & {
+    "invalid-type": {
+        type: string;
+    };
+};
+type IProfilePictureResponseData = IBest55ResponseData & {};
+type IScoreResponseData = IBest55ResponseData & {};
+type IResponseData = {
+    best55: IBest55ResponseData;
+    best60: IBest60ResponseData;
+    profile: IProfileResponseData;
+    profilePicture: IProfilePictureResponseData;
+    score: IScoreResponseData;
+};
+export declare class KamaiTachi extends OngekiScoreAdapter<IResponseData> {
     private readonly CURRENT_VERSION;
     constructor({ baseURL, currentVersion, }?: {
         baseURL?: string;
         currentVersion?: KamaiTachi.EGameVersions;
     });
     getPlayerScore(username: string, chartId: number): Promise<{
-        basic: IScore | null;
-        advanced: IScore | null;
-        expert: IScore | null;
-        master: IScore | null;
-        lunatic: IScore | null;
+        readonly status: "invalid-user";
+        readonly message: string;
+        readonly data: {
+            readonly username: string;
+        };
+    } | {
+        readonly status: "unknown";
+        readonly message: string;
+        readonly data: null;
+    } | {
+        readonly status: "success";
+        readonly message: "";
+        readonly data: {
+            readonly basic: IScore | null;
+            readonly advanced: IScore | null;
+            readonly expert: IScore | null;
+            readonly master: IScore | null;
+            readonly lunatic: IScore | null;
+        };
     }>;
     getPlatinumScore(score: KamaiTachi.IScore | KamaiTachi.IPb): number;
     getPlatinumScoreRatio(chart: KamaiTachi.IChart, score: KamaiTachi.IScore | KamaiTachi.IPb): number;
@@ -27,24 +61,86 @@ export declare class KamaiTachi extends ScoreTrackerAdapter {
     }> | undefined>;
     private getDatabaseDifficulty;
     private toMaiDrawScore;
-    getPlayerBest60(userId: string, currentVersion?: KamaiTachi.EGameVersions): Promise<{
-        new: IScore[];
-        old: IScore[];
-        plat: IScore[];
-        best: IScore[];
-    } | null>;
-    getPlayerBest55(userId: string, currentVersion?: KamaiTachi.EGameVersions): Promise<{
-        recent: IScore[];
-        new: IScore[];
-        old: IScore[];
-        best: IScore[];
-    } | null>;
+    getPlayerBest60(username: string, currentVersion?: KamaiTachi.EGameVersions): Promise<{
+        readonly status: "invalid-user";
+        readonly message: string;
+        readonly data: {
+            readonly username: string;
+        };
+    } | {
+        readonly status: "unknown";
+        readonly message: string;
+        readonly data: null;
+    } | {
+        readonly status: "success";
+        readonly message: "";
+        readonly data: {
+            readonly new: IScore[];
+            readonly old: IScore[];
+            readonly plat: IScore[];
+            readonly best: IScore[];
+        };
+    }>;
+    getPlayerBest55(username: string, currentVersion?: KamaiTachi.EGameVersions): Promise<{
+        readonly status: "invalid-user";
+        readonly message: string;
+        readonly data: {
+            readonly username: string;
+        };
+    } | {
+        readonly status: "unknown";
+        readonly message: string;
+        readonly data: null;
+    } | {
+        readonly status: "success";
+        readonly message: "";
+        readonly data: {
+            readonly recent: IScore[];
+            readonly new: IScore[];
+            readonly old: IScore[];
+            readonly best: IScore[];
+        };
+    }>;
     getPlayerInfo(userId: string, type: "refresh" | "classic"): Promise<{
-        name: string;
-        rating: number;
-    } | null>;
+        readonly status: "invalid-user";
+        readonly message: string;
+        readonly data: {
+            readonly username: string;
+        };
+    } | {
+        readonly status: "unknown";
+        readonly message: string;
+        readonly data: null;
+    } | {
+        readonly status: "success";
+        readonly message: "";
+        readonly data: {
+            readonly name: string;
+            readonly rating: number;
+        };
+    } | {
+        readonly status: "invalid-type";
+        readonly message: string;
+        readonly data: {
+            readonly type: string;
+        };
+    }>;
     private getPlayerProfileRaw;
-    getPlayerProfilePicture(userId: string): Promise<Buffer | null>;
+    getPlayerProfilePicture(userId: string): Promise<{
+        readonly status: "invalid-user";
+        readonly message: string;
+        readonly data: {
+            readonly username: string;
+        };
+    } | {
+        readonly status: "unknown";
+        readonly message: string;
+        readonly data: null;
+    } | {
+        readonly status: "success";
+        readonly message: "";
+        readonly data: Buffer;
+    }>;
     ongeki(): KamaiTachi;
     plus(): KamaiTachi;
     summer(): KamaiTachi;
@@ -58,12 +154,21 @@ export declare class KamaiTachi extends ScoreTrackerAdapter {
     refresh(): KamaiTachi;
 }
 export declare namespace KamaiTachi {
-    interface IResponse<T> {
+    interface IBaseResponse {
         success: boolean;
         description: string;
+    }
+    export interface ISuccessResponse<T> extends IBaseResponse {
+        success: true;
+        description: string;
         body: T;
     }
-    interface IChart {
+    export interface IFailureResponse extends IBaseResponse {
+        success: false;
+        description: string;
+    }
+    export type IResponse<T> = ISuccessResponse<T> | IFailureResponse;
+    export interface IChart {
         chartID: string;
         data: {
             inGameID: number;
@@ -79,7 +184,7 @@ export declare namespace KamaiTachi {
         songID: number;
         versions: string[];
     }
-    interface ISong {
+    export interface ISong {
         altTitles: string[];
         artist: string;
         data: {
@@ -89,7 +194,7 @@ export declare namespace KamaiTachi {
         searchTerms: string[];
         title: string;
     }
-    interface IScore {
+    export interface IScore {
         chartID: string;
         userID: number;
         comment: string | null;
@@ -144,7 +249,7 @@ export declare namespace KamaiTachi {
         timeAchieved: number;
         service: string;
     }
-    interface IPb {
+    export interface IPb {
         chartID: string;
         userID: number;
         calculatedData: {
@@ -199,7 +304,7 @@ export declare namespace KamaiTachi {
             scoreID: string;
         }[];
     }
-    enum EGameVersions {
+    export enum EGameVersions {
         REFRESH = "\u30AA\u30F3\u30B2\u30AD Re:Fresh",
         BRIGHT_MEMORY_ACT_3 = "\u30AA\u30F3\u30B2\u30AD bright MEMORY Act.3",
         BRIGHT_MEMORY_ACT_2 = "\u30AA\u30F3\u30B2\u30AD bright MEMORY Act.2",
@@ -219,5 +324,7 @@ export declare namespace KamaiTachi {
      * @param b Game version.
      * @returns positive if a is newer, negative if b is newer, 0 if they are the same.
      */
-    function compareGameVersions(a: EGameVersions, b: EGameVersions): number;
+    export function compareGameVersions(a: EGameVersions, b: EGameVersions): number;
+    export {};
 }
+export {};

package/dist/geki/lib/adapter/kamaiTachi/index.js

@@ -6,7 +6,7 @@ const __1 = require("..");
 const util_1 = require("../../../../lib/util");
 const util_2 = require("../../util");
 const database_1 = require("../../database");
-class KamaiTachi extends __1.ScoreTrackerAdapter {
+class KamaiTachi extends __1.OngekiScoreAdapter {
     CURRENT_VERSION;
     constructor({ baseURL = "https://kamai.tachi.ac/", currentVersion = KamaiTachi.EGameVersions.REFRESH, } = {}) {
         super({ baseURL });
@@ -14,14 +14,33 @@ class KamaiTachi extends __1.ScoreTrackerAdapter {
     }
     async getPlayerScore(username, chartId) {
         const rawPBs = await this.getPlayerPB(username);
-        if (!rawPBs?.body)
-            return {
-                basic: null,
-                advanced: null,
-                expert: null,
-                master: null,
-                lunatic: null,
+        if (!rawPBs) {
+            const res = {
+                status: "unknown",
+                message: "An unknown error occurred.",
+                data: null,
             };
+            return res;
+        }
+        if (!rawPBs.success) {
+            if (rawPBs.description.includes("does not exist")) {
+                const res = {
+                    status: "invalid-user",
+                    message: rawPBs.description ||
+                        `${username} is not a valid user.`,
+                    data: { username },
+                };
+                return res;
+            }
+            else {
+                const res = {
+                    status: "unknown",
+                    message: "An unknown error occurred: " + rawPBs.description,
+                    data: null,
+                };
+                return res;
+            }
+        }
         const pbs = [];
         for (const pb of rawPBs.body.pbs) {
             let chart = rawPBs.body.charts.find((v) => v.chartID == pb.chartID);
@@ -43,23 +62,28 @@ class KamaiTachi extends __1.ScoreTrackerAdapter {
             v.chart.data.inGameID == chartId);
         const lunatic = pbs.find((v) => difficultyCompare(v.chart, "Lunatic") &&
             v.chart.data.inGameID == chartId);
-        return {
-            basic: basic
-                ? this.toMaiDrawScore(basic.pb, basic.chart, basic.song)
-                : null,
-            advanced: advanced
-                ? this.toMaiDrawScore(advanced.pb, advanced.chart, advanced.song)
-                : null,
-            expert: expert
-                ? this.toMaiDrawScore(expert.pb, expert.chart, expert.song)
-                : null,
-            master: master
-                ? this.toMaiDrawScore(master.pb, master.chart, master.song)
-                : null,
-            lunatic: lunatic
-                ? this.toMaiDrawScore(lunatic.pb, lunatic.chart, lunatic.song)
-                : null,
+        const res = {
+            status: "success",
+            message: "",
+            data: {
+                basic: basic
+                    ? this.toMaiDrawScore(basic.pb, basic.chart, basic.song)
+                    : null,
+                advanced: advanced
+                    ? this.toMaiDrawScore(advanced.pb, advanced.chart, advanced.song)
+                    : null,
+                expert: expert
+                    ? this.toMaiDrawScore(expert.pb, expert.chart, expert.song)
+                    : null,
+                master: master
+                    ? this.toMaiDrawScore(master.pb, master.chart, master.song)
+                    : null,
+                lunatic: lunatic
+                    ? this.toMaiDrawScore(lunatic.pb, lunatic.chart, lunatic.song)
+                    : null,
+            },
         };
+        return res;
     }
     getPlatinumScore(score) {
         const ASSUMED_PLAT_SCORE_RATE = 0;
@@ -204,10 +228,35 @@ class KamaiTachi extends __1.ScoreTrackerAdapter {
             })(),
         };
     }
-    async getPlayerBest60(userId, currentVersion = this.CURRENT_VERSION) {
-        const rawPBs = await this.getPlayerPB(userId);
-        if (!rawPBs?.body)
-            return null;
+    async getPlayerBest60(username, currentVersion = this.CURRENT_VERSION) {
+        const rawPBs = await this.getPlayerPB(username);
+        if (!rawPBs) {
+            const res = {
+                status: "unknown",
+                message: "An unknown error occurred.",
+                data: null,
+            };
+            return res;
+        }
+        if (!rawPBs.success) {
+            if (rawPBs.description.includes("does not exist")) {
+                const res = {
+                    status: "invalid-user",
+                    message: rawPBs.description ||
+                        `${username} is not a valid user.`,
+                    data: { username },
+                };
+                return res;
+            }
+            else {
+                const res = {
+                    status: "unknown",
+                    message: "An unknown error occurred: " + rawPBs.description,
+                    data: null,
+                };
+                return res;
+            }
+        }
         const pbs = [];
         for (const pb of rawPBs.body.pbs) {
             let chart = rawPBs.body.charts.find((v) => v.chartID == pb.chartID);
@@ -221,31 +270,88 @@ class KamaiTachi extends __1.ScoreTrackerAdapter {
             KamaiTachi.compareGameVersions(currentVersion, v.chart.data.displayVersion) > 0);
         const bestScores = pbs.filter((v) => v.chart &&
             KamaiTachi.compareGameVersions(currentVersion, v.chart.data.displayVersion) >= 0);
-        return {
-            new: newScores
-                .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
-                .sort((a, b) => b.rating - a.rating || b.score - a.score)
-                .slice(0, 10),
-            old: oldScores
-                .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
-                .sort((a, b) => b.rating - a.rating || b.score - a.score)
-                .slice(0, 50),
-            plat: bestScores
-                .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
-                .sort((a, b) => b.starRating - a.starRating || b.score - a.score)
-                .filter((v) => v.starRating > 0)
-                .slice(0, 50),
-            best: bestScores
-                .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
-                .sort((a, b) => b.rating - a.rating || b.score - a.score)
-                .slice(0, 60),
+        const res = {
+            status: "success",
+            message: "",
+            data: {
+                new: newScores
+                    .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
+                    .sort((a, b) => b.rating - a.rating || b.score - a.score)
+                    .slice(0, 10),
+                old: oldScores
+                    .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
+                    .sort((a, b) => b.rating - a.rating || b.score - a.score)
+                    .slice(0, 50),
+                plat: bestScores
+                    .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
+                    .sort((a, b) => b.starRating - a.starRating || b.score - a.score)
+                    .filter((v) => v.starRating > 0)
+                    .slice(0, 50),
+                best: bestScores
+                    .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song))
+                    .sort((a, b) => b.rating - a.rating || b.score - a.score)
+                    .slice(0, 60),
+            },
         };
+        return res;
     }
-    async getPlayerBest55(userId, currentVersion = this.CURRENT_VERSION) {
-        const rawPBs = await this.getPlayerPB(userId);
-        const rawRecents = await this.getPlayerRecentScores(userId);
-        if (!rawPBs?.body || !rawRecents?.body)
-            return null;
+    async getPlayerBest55(username, currentVersion = this.CURRENT_VERSION) {
+        const rawPBs = await this.getPlayerPB(username);
+        if (!rawPBs) {
+            const res = {
+                status: "unknown",
+                message: "An unknown error occurred.",
+                data: null,
+            };
+            return res;
+        }
+        if (!rawPBs.success) {
+            if (rawPBs.description.includes("does not exist")) {
+                const res = {
+                    status: "invalid-user",
+                    message: rawPBs.description ||
+                        `${username} is not a valid user.`,
+                    data: { username },
+                };
+                return res;
+            }
+            else {
+                const res = {
+                    status: "unknown",
+                    message: "An unknown error occurred: " + rawPBs.description,
+                    data: null,
+                };
+                return res;
+            }
+        }
+        const rawRecents = await this.getPlayerRecentScores(username);
+        if (!rawRecents) {
+            const res = {
+                status: "unknown",
+                message: "An unknown error occurred.",
+                data: null,
+            };
+            return res;
+        }
+        if (!rawRecents.success) {
+            if (rawRecents.description.includes("does not exist")) {
+                const res = {
+                    status: "invalid-user",
+                    message: rawRecents.description ||
+                        `${username} is not a valid user.`,
+                    data: { username },
+                };
+                return res;
+            }
+            else {
+                const res = {
+                    status: "unknown",
+                    message: "An unknown error occurred: " + rawRecents.description,
+                    data: null,
+                };
+                return res;
+            }
+        }
         const pbs = [];
         const recents = [];
         for (const pb of rawPBs.body.pbs) {
@@ -324,66 +430,154 @@ class KamaiTachi extends __1.ScoreTrackerAdapter {
                 .slice(0, 10)
                 .map((v) => v.score);
         }
-        return {
-            recent: ratingGuardSimulation(recentScores
-                .reverse()
-                .map((v) => this.toMaiDrawScore(v.scores, v.chart, v.song, "classic"))
-                .filter((v) => v.chart.difficulty != type_1.EDifficulty.LUNATIC)),
-            new: newScores
-                .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song, "classic"))
-                .sort((a, b) => b.rating - a.rating || b.score - a.score)
-                .slice(0, 15),
-            old: oldScores
-                .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song, "classic"))
-                .sort((a, b) => b.rating - a.rating || b.score - a.score)
-                .slice(0, 30),
-            best: pbs
-                .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song, "classic"))
-                .sort((a, b) => b.rating - a.rating || b.score - a.score)
-                .slice(0, 45),
+        const res = {
+            status: "success",
+            message: "",
+            data: {
+                recent: ratingGuardSimulation(recentScores
+                    .reverse()
+                    .map((v) => this.toMaiDrawScore(v.scores, v.chart, v.song, "classic"))
+                    .filter((v) => v.chart.difficulty != type_1.EDifficulty.LUNATIC)),
+                new: newScores
+                    .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song, "classic"))
+                    .sort((a, b) => b.rating - a.rating || b.score - a.score)
+                    .slice(0, 15),
+                old: oldScores
+                    .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song, "classic"))
+                    .sort((a, b) => b.rating - a.rating || b.score - a.score)
+                    .slice(0, 30),
+                best: pbs
+                    .map((v) => this.toMaiDrawScore(v.pb, v.chart, v.song, "classic"))
+                    .sort((a, b) => b.rating - a.rating || b.score - a.score)
+                    .slice(0, 45),
+            },
         };
+        return res;
     }
     async getPlayerInfo(userId, type) {
         const profile = await this.getPlayerProfileRaw(userId);
+        if (!profile) {
+            const res = {
+                status: "unknown",
+                message: "An unknown error occurred.",
+                data: null,
+            };
+            return res;
+        }
+        if (!profile.success) {
+            if (profile.description.includes("does not exist")) {
+                const res = {
+                    status: "invalid-user",
+                    message: profile.description || `${userId} is not a valid user.`,
+                    data: { username: userId },
+                };
+                return res;
+            }
+            else {
+                const res = {
+                    status: "unknown",
+                    message: "An unknown error occurred: " + profile.description,
+                    data: null,
+                };
+                return res;
+            }
+        }
         if (type == "refresh") {
             const scores = await this.getPlayerBest60(userId);
-            if (!profile?.body || !scores)
-                return null;
-            const newRating = scores.new
+            if (!(scores.status == "success"))
+                return scores;
+            const newRating = scores.data.new
                 .map((v) => util_1.Util.truncateNumber(v.rating / 5, 3))
                 .reduce((sum, v) => sum + v, 0);
-            const oldRating = scores.old
+            const oldRating = scores.data.old
                 .map((v) => v.rating)
                 .reduce((sum, v) => sum + v, 0);
-            const platRating = scores.plat
+            const platRating = scores.data.plat
                 .map((v) => v.starRating)
                 .reduce((sum, v) => sum + v, 0);
-            return {
-                name: profile?.body.username,
-                rating: util_1.Util.truncateNumber(newRating / 10, 3) +
-                    util_1.Util.truncateNumber(oldRating / 50, 3) +
-                    util_1.Util.truncateNumber(platRating / 50, 3),
+            const res = {
+                status: "success",
+                message: "",
+                data: {
+                    name: profile?.body.username,
+                    rating: util_1.Util.truncateNumber(newRating / 10, 3) +
+                        util_1.Util.truncateNumber(oldRating / 50, 3) +
+                        util_1.Util.truncateNumber(platRating / 50, 3),
+                },
             };
+            return res;
         }
         else if (type == "classic") {
             const scores = await this.getPlayerBest55(userId);
-            if (!profile?.body || !scores)
-                return null;
+            if (!(scores.status == "success"))
+                return scores;
             let rating = 0;
-            [...scores.recent, ...scores.new, ...scores.old].forEach((v) => (rating += v.rating));
-            return {
-                name: profile?.body.username,
-                rating: util_1.Util.truncateNumber(rating / 55, 2),
+            [
+                ...scores.data.recent,
+                ...scores.data.new,
+                ...scores.data.old,
+            ].forEach((v) => (rating += v.rating));
+            const res = {
+                status: "success",
+                message: "",
+                data: {
+                    name: profile?.body.username,
+                    rating: util_1.Util.truncateNumber(rating / 55, 2),
+                },
             };
+            return res;
+        }
+        else {
+            const res = {
+                status: "invalid-type",
+                message: `${type} is not a valid type.`,
+                data: { type: type },
+            };
+            return res;
         }
-        else
-            return null;
     }
     async getPlayerProfileRaw(userId) {
         return this.get(`/api/v1/users/${userId}`);
     }
     async getPlayerProfilePicture(userId) {
-        return ((await this.get(`/api/v1/users/${userId}/pfp`, undefined, 2 * 60 * 60 * 1000, { responseType: "arraybuffer" })) || null);
+        const pfp = (await this.get(`/api/v1/users/${userId}/pfp`, undefined, 2 * 60 * 60 * 1000, { responseType: "arraybuffer" })) || null;
+        if (!pfp) {
+            const res = {
+                status: "unknown",
+                message: "An unknown error occurred.",
+                data: null,
+            };
+            return res;
+        }
+        function isFailureResponse(payload) {
+            return (typeof payload.success === "boolean" &&
+                payload.success === false &&
+                typeof payload.description === "string");
+        }
+        if (isFailureResponse(pfp)) {
+            if (pfp.description.includes("does not exist")) {
+                const res = {
+                    status: "invalid-user",
+                    message: pfp.description || `${userId} is not a valid user.`,
+                    data: { username: userId },
+                };
+                return res;
+            }
+            else {
+                const res = {
+                    status: "unknown",
+                    message: "An unknown error occurred: " + pfp.description,
+                    data: null,
+                };
+                return res;
+            }
+        }
+        const res = {
+            status: "success",
+            message: "",
+            data: pfp,
+        };
+        return res;
     }
     ongeki() {
         return new KamaiTachi({