kol.js 0.0.2 → 0.1.0

package/src/utils/kmail.ts

@@ -0,0 +1,48 @@
+import { Player } from "../Player.js";
+
+export type KoLChatMessage = {
+  who?: Player<false>;
+  type?: string;
+  msg?: string;
+  link?: string;
+  channel?: string;
+  time: string;
+};
+
+type KoLMessageType = "private" | "system" | "public" | "kmail";
+
+export const isValidMessage = (
+  msg: KoLChatMessage,
+): msg is KoLChatMessage & {
+  type: KoLMessageType;
+  who: Player<false>;
+  msg: string;
+} => msg.who !== undefined && msg.msg !== undefined;
+
+export type KoLKmail = {
+  id: string;
+  type: string;
+  fromid: string;
+  fromname: string;
+  azunixtime: string;
+  message: string;
+  localtime: string;
+};
+
+export type BaseKoLMessage = {
+  type: KoLMessageType;
+  who: Player<false>;
+  msg: string;
+  time: Date;
+};
+
+export interface KmailMessage extends BaseKoLMessage {
+  type: "kmail";
+  id: number;
+}
+
+export interface ChatMessage extends BaseKoLMessage {
+  type: "public" | "private" | "system";
+}
+
+export type KoLMessage = KmailMessage | ChatMessage;

package/src/utils/leaderboard.ts

@@ -0,0 +1,84 @@
+import xpath, { select } from "xpath";
+import { DOMParser } from "@xmldom/xmldom";
+
+export type LeaderboardInfo = {
+  name: string;
+  boards: SubboardInfo[];
+};
+
+export type SubboardInfo = {
+  name: string;
+  runs: RunInfo[];
+  updated: Date | null;
+};
+
+type RunInfo = {
+  player: string;
+  days: string;
+  turns: string;
+};
+
+const parser = new DOMParser({
+  locator: {},
+  errorHandler: {
+    warning: () => {},
+    error: () => {},
+    fatalError: console.error,
+  },
+});
+
+const selectMulti = (expression: string, node: Node) => {
+  const selection = select(expression, node);
+  if (Array.isArray(selection)) return selection;
+  return selection instanceof Node ? [selection] : [];
+};
+
+export function parseLeaderboard(page: string): LeaderboardInfo {
+  const document = parser.parseFromString(page);
+  const [board, ...boards] = selectMulti("//table", document);
+
+  return {
+    name: selectMulti(".//text()", board.firstChild!)
+      .map((node) => node.nodeValue)
+      .join("")
+      .replace(/\s+/g, " ")
+      .trim(),
+    boards: boards
+      .slice(1)
+      .filter(
+        (board) =>
+          selectMulti("./tr//text()", board)[0]?.nodeValue?.match(
+            /^((Fast|Funn|B)est|Most (Goo|Elf))/,
+          ) && selectMulti("./tr", board).length > 1,
+      )
+      .map((subboard) => {
+        const rows = selectMulti("./tr", subboard);
+
+        return {
+          name: (selectMulti(".//text()", rows[0])[0]?.nodeValue || "").trim(),
+          runs: selectMulti("./td//tr", rows[1])
+            .slice(2)
+            .map((node) => {
+              const rowText = selectMulti(".//text()", node).map((text) =>
+                text.toString().replace(/ /g, ""),
+              );
+              const hasTwoNumbers = !!parseInt(rowText[rowText.length - 2]);
+              return {
+                player: rowText
+                  .slice(0, rowText.length - (hasTwoNumbers ? 2 : 1))
+                  .join("")
+                  .trim()
+                  .toString(),
+                days: hasTwoNumbers
+                  ? rowText[rowText.length - 2].toString() || "0"
+                  : "",
+                turns: rowText[rowText.length - 1].toString() || "0",
+              };
+            }),
+          updated: xpath.isComment(subboard.nextSibling)
+            ? new Date(subboard.nextSibling.data.slice(9, -1))
+            : null,
+        };
+      }),
+  };
+}

package/src/utils/utils.ts

@@ -0,0 +1,33 @@
+import { parse as parseDate } from "date-fns";
+import { decode } from "html-entities";
+
+export function parsePlayerDate(input?: string) {
+  if (!input) return new Date();
+  return parseDate(input, "MMMM dd, yyyy", new Date());
+}
+
+export function sanitiseBlueText(blueText: string | undefined): string {
+  if (!blueText) return "";
+  return decode(
+    blueText
+      .replace(/\r/g, "")
+      .replace(/\r/g, "")
+      .replace(/(<p><\/p>)|(<br>)|(<Br>)|(<br \/>)|(<Br \/>)/g, "\n")
+      .replace(/<[^<>]+>/g, "")
+      .replace(/(\n+)/g, "\n")
+      .replace(/(\n)+$/, ""),
+  ).trim();
+}
+
+export function resolveKoLImage(path: string) {
+  if (!/^https?:\/\//i.test(path))
+    return (
+      "https://s3.amazonaws.com/images.kingdomofloathing.com" +
+      path.replace(/^\/(iii|images)/, "")
+    );
+  return path;
+}
+
+export function wait(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}

package/dist/Cache.d.ts

@@ -1,11 +0,0 @@
-import { Client } from "./Client.js";
-import { Player } from "./Player.js";
-export declare class Cache<T> {
-    client: Client;
-    constructor(client: Client);
-    cache: T[];
-}
-export declare class PlayerCache extends Cache<Player<boolean>> {
-    fetch(identifier: string | number, full: true): Promise<Player<true>>;
-    fetch(identifier: string | number): Promise<Player<boolean>>;
-}

package/dist/Cache.js

@@ -1,26 +0,0 @@
-import { Player } from "./Player.js";
-export class Cache {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    cache = [];
-}
-export class PlayerCache extends Cache {
-    async fetch(identifier, full = false) {
-        const player = await (async () => {
-            const cached = this.cache.find((p) => p.matchesIdentifier(identifier));
-            if (cached) {
-                return cached;
-            }
-            const fetched = await Player.from(this.client, identifier);
-            if (!fetched)
-                return null;
-            this.cache.push(fetched);
-            return fetched;
-        })();
-        if (!player)
-            return player;
-        return full ? await player.full() : player;
-    }
-}

package/dist/Client.d.ts

@@ -1,84 +0,0 @@
-import { Mutex } from "async-mutex";
-import TypedEventEmitter, { EventMap } from "typed-emitter";
-import { KoLMessage } from "./utils/kmail.js";
-import { PlayerCache } from "./Cache.js";
-type TypedEmitter<T extends EventMap> = TypedEventEmitter.default<T>;
-type FetchOptions<Result> = {
-    params?: Record<string, string | number>;
-    body?: Record<string, string | number>;
-    method?: "POST" | "GET";
-    fallback?: Result;
-};
-type MallPrice = {
-    formattedMallPrice: string;
-    formattedLimitedMallPrice: string;
-    formattedMinPrice: string;
-    mallPrice: number;
-    limitedMallPrice: number;
-    minPrice: number | null;
-};
-type Events = {
-    kmail: (message: KoLMessage) => void;
-    whisper: (message: KoLMessage) => void;
-    system: (message: KoLMessage) => void;
-    public: (message: KoLMessage) => void;
-    rollover: () => void;
-};
-type Familiar = {
-    id: number;
-    name: string;
-    image: string;
-};
-declare const Client_base: new () => TypedEmitter<Events>;
-export declare class Client extends Client_base {
-    #private;
-    static loginMutex: Mutex;
-    actionMutex: Mutex;
-    session: import("fetch-cookie").FetchCookieImpl<string | URL | Request, RequestInit, Response>;
-    players: PlayerCache;
-    private lastFetchedMessages;
-    private postRolloverLatch;
-    constructor(username: string, password: string);
-    fetchText(path: string, options?: FetchOptions<string>): Promise<string>;
-    fetchJson<Result>(path: string, options?: FetchOptions<Result>): Promise<Result | null>;
-    login(): Promise<boolean>;
-    isRollover(): boolean;
-    checkLoggedIn(): Promise<boolean>;
-    startChatBot(): Promise<void>;
-    private loopChatBot;
-    checkMessages(): Promise<void>;
-    checkKmails(): Promise<void>;
-    sendChat(message: string): Promise<{
-        output: string;
-        msgs: string[];
-    } | null>;
-    useChatMacro(macro: string): Promise<{
-        output: string;
-        msgs: string[];
-    } | null>;
-    whisper(recipientId: number, message: string): Promise<void>;
-    kmail(recipientId: number, message: string): Promise<void>;
-    getMallPrice(itemId: number): Promise<MallPrice>;
-    getItemDescription(descId: number): Promise<{
-        melting: boolean;
-        singleEquip: boolean;
-        blueText: string;
-        effect?: {
-            name: string;
-            duration: number;
-            descid: string;
-        };
-    }>;
-    getEffectDescription(descId: string): Promise<{
-        blueText: string;
-    }>;
-    getSkillDescription(id: number): Promise<{
-        blueText: string;
-    }>;
-    joinClan(id: number): Promise<boolean>;
-    addToWhitelist(playerId: number, clanId: number): Promise<boolean>;
-    getLeaderboard(leaderboardId: number): Promise<import("./utils/leaderboard.js").LeaderboardInfo>;
-    useFamiliar(familiarId: number): Promise<boolean>;
-    getFamiliars(): Promise<Familiar[]>;
-}
-export {};

package/dist/Client.js

@@ -1,343 +0,0 @@
-import { Mutex } from "async-mutex";
-import { EventEmitter } from "node:events";
-import { sanitiseBlueText, wait } from "./utils/utils.js";
-import { Player } from "./Player.js";
-import { createBody, createSession, formatQuerystring } from "./utils/visit.js";
-import { parseLeaderboard } from "./utils/leaderboard.js";
-import { isValidMessage, } from "./utils/kmail.js";
-import { PlayerCache } from "./Cache.js";
-export class Client extends EventEmitter {
-    static loginMutex = new Mutex();
-    actionMutex = new Mutex();
-    session = createSession();
-    players = new PlayerCache(this);
-    #username;
-    #password;
-    #isRollover = false;
-    #chatBotStarted = false;
-    #pwd = "";
-    lastFetchedMessages = "0";
-    postRolloverLatch = false;
-    constructor(username, password) {
-        super();
-        this.#username = username;
-        this.#password = password;
-    }
-    async #fetch(path, options = {}) {
-        const { params, body, method } = {
-            params: {},
-            body: undefined,
-            method: "POST",
-            ...options,
-        };
-        const qs = formatQuerystring({ ...params, pwd: this.#pwd });
-        return await this.session(`https://www.kingdomofloathing.com/${path}${qs ? `?${qs}` : ""}`, {
-            method,
-            body: body ? createBody({ ...body, pwd: this.#pwd }) : undefined,
-        });
-    }
-    async fetchText(path, options = {}) {
-        if (!(await this.login()))
-            return options.fallback ?? "";
-        return (await this.#fetch(path, options)).text();
-    }
-    async fetchJson(path, options = {}) {
-        if (!(await this.login()))
-            return options.fallback ?? null;
-        return (await this.#fetch(path, options)).json();
-    }
-    async login() {
-        if (this.#isRollover)
-            return false;
-        return Client.loginMutex.runExclusive(async () => {
-            if (await this.checkLoggedIn())
-                return true;
-            if (this.#isRollover)
-                return false;
-            try {
-                const response = await this.#fetch("login.php", {
-                    body: {
-                        loggingin: "Yup.",
-                        loginname: this.#username,
-                        password: this.#password,
-                        secure: "0",
-                        submitbutton: "Log In",
-                    },
-                });
-                await response.text();
-                if (!(await this.checkLoggedIn()))
-                    return false;
-                if (this.postRolloverLatch) {
-                    this.postRolloverLatch = false;
-                    this.emit("rollover");
-                }
-                return true;
-            }
-            catch (error) {
-                console.log("error", error);
-                // Login failed, let's check if it is due to rollover
-                await this.#checkForRollover();
-                return false;
-            }
-        });
-    }
-    isRollover() {
-        return this.#isRollover;
-    }
-    async checkLoggedIn() {
-        try {
-            const response = await this.#fetch("api.php", {
-                params: { what: "status", for: `${this.#username} bot` },
-            });
-            const api = (await response.json());
-            this.#pwd = api.pwd;
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    async #checkForRollover() {
-        const isRollover = /The system is currently down for nightly maintenance/.test(await this.fetchText("/"));
-        if (this.#isRollover && !isRollover) {
-            // Set the post-rollover latch so the bot can react on next log in.
-            this.postRolloverLatch = true;
-        }
-        this.#isRollover = isRollover;
-        if (this.#isRollover) {
-            // Rollover appears to be in progress. Check again in one minute.
-            setTimeout(() => this.#checkForRollover(), 60000);
-        }
-    }
-    async startChatBot() {
-        if (this.#chatBotStarted)
-            return;
-        await this.useChatMacro("/join talkie");
-        this.loopChatBot();
-        this.#chatBotStarted = true;
-    }
-    async loopChatBot() {
-        await Promise.all([this.checkMessages(), this.checkKmails()]);
-        await wait(3000);
-        await this.loopChatBot();
-    }
-    async checkMessages() {
-        const newChatMessagesResponse = await this.fetchJson("newchatmessages.php", {
-            params: {
-                j: 1,
-                lasttime: this.lastFetchedMessages,
-            },
-        });
-        if (!newChatMessagesResponse || typeof newChatMessagesResponse !== "object")
-            return;
-        this.lastFetchedMessages = newChatMessagesResponse["last"];
-        newChatMessagesResponse["msgs"]
-            .filter(isValidMessage)
-            .map((msg) => ({
-            type: msg.type,
-            who: new Player(this, Number(msg.who.id), msg.who.name),
-            msg: msg.msg,
-            time: new Date(Number(msg.time) * 1000),
-        }))
-            .forEach((message) => {
-            switch (message.type) {
-                case "public":
-                    return void this.emit("public", message);
-                case "private":
-                    return void this.emit("whisper", message);
-                case "system":
-                    return void this.emit("system", message);
-            }
-        });
-    }
-    async checkKmails() {
-        const newKmailsResponse = await this.fetchJson("api.php", {
-            params: {
-                what: "kmail",
-                for: `${this.#username} bot`,
-            },
-        });
-        if (!Array.isArray(newKmailsResponse) || newKmailsResponse.length === 0)
-            return;
-        const newKmails = newKmailsResponse.map((msg) => ({
-            type: "kmail",
-            who: new Player(this, Number(msg.fromid), msg.fromname),
-            msg: msg.message,
-            time: new Date(Number(msg.azunixtime) * 1000),
-        }));
-        const data = {
-            the_action: "delete",
-            box: "Inbox",
-            ...Object.fromEntries(newKmailsResponse.map(({ id }) => [`sel${id}`, "on"])),
-        };
-        await this.fetchText("messages.php", { params: data });
-        newKmails.forEach((m) => this.emit("kmail", m));
-    }
-    async sendChat(message) {
-        return await this.fetchJson("submitnewchat.php", {
-            params: {
-                graf: message,
-                j: 1,
-            },
-        });
-    }
-    async useChatMacro(macro) {
-        return await this.sendChat(`/clan ${macro}`);
-    }
-    async whisper(recipientId, message) {
-        await this.useChatMacro(`/w ${recipientId} ${message}`);
-    }
-    async kmail(recipientId, message) {
-        await this.fetchText("sendmessage.php", {
-            params: {
-                action: "send",
-                j: 1,
-                towho: recipientId,
-                contact: 0,
-                message: message,
-                howmany1: 1,
-                whichitem1: 0,
-                sendmeat: 0,
-            },
-        });
-    }
-    async getMallPrice(itemId) {
-        const prices = await this.fetchText("backoffice.php", {
-            params: {
-                action: "prices",
-                ajax: 1,
-                iid: itemId,
-            },
-        });
-        const unlimitedMatch = prices.match(/<td>unlimited:<\/td><td><b>(?<unlimitedPrice>[\d,]+)/);
-        const limitedMatch = prices.match(/<td>limited:<\/td><td><b>(?<limitedPrice>[\d,]+)/);
-        const unlimitedPrice = unlimitedMatch
-            ? parseInt(unlimitedMatch[1].replace(/,/g, ""))
-            : 0;
-        const limitedPrice = limitedMatch
-            ? parseInt(limitedMatch[1].replace(/,/g, ""))
-            : 0;
-        let minPrice = limitedMatch ? limitedPrice : null;
-        minPrice = unlimitedMatch
-            ? !minPrice || unlimitedPrice < minPrice
-                ? unlimitedPrice
-                : minPrice
-            : minPrice;
-        const formattedMinPrice = minPrice
-            ? (minPrice === unlimitedPrice
-                ? unlimitedMatch?.[1]
-                : limitedMatch?.[1]) ?? ""
-            : "";
-        return {
-            mallPrice: unlimitedPrice,
-            limitedMallPrice: limitedPrice,
-            formattedMinPrice: formattedMinPrice,
-            minPrice: minPrice,
-            formattedMallPrice: unlimitedMatch ? unlimitedMatch[1] : "",
-            formattedLimitedMallPrice: limitedMatch ? limitedMatch[1] : "",
-        };
-    }
-    async getItemDescription(descId) {
-        const description = await this.fetchText("desc_item.php", {
-            params: {
-                whichitem: descId,
-            },
-        });
-        const blueText = description.match(/<center>\s*<b>\s*<font color="?[\w]+"?>(?<description>[\s\S]+)<\/center>/i);
-        const effect = description.match(/Effect: \s?<b>\s?<a[^>]+href="desc_effect\.php\?whicheffect=(?<descid>[^"]+)[^>]+>(?<effect>[\s\S]+)<\/a>[^(]+\((?<duration>[\d]+)/);
-        const melting = description.match(/This item will disappear at the end of the day\./);
-        const singleEquip = description.match(/ You may not equip more than one of these at a time\./);
-        return {
-            melting: !!melting,
-            singleEquip: !!singleEquip,
-            blueText: sanitiseBlueText(blueText?.groups?.description),
-            effect: effect?.groups
-                ? {
-                    name: effect.groups?.name,
-                    duration: Number(effect.groups?.duration) || 0,
-                    descid: effect.groups?.descid,
-                }
-                : undefined,
-        };
-    }
-    async getEffectDescription(descId) {
-        const description = await this.fetchText("desc_effect.php", {
-            params: {
-                whicheffect: descId,
-            },
-        });
-        const blueText = description.match(/<center><font color="?[\w]+"?>(?<description>[\s\S]+)<\/div>/m);
-        return { blueText: sanitiseBlueText(blueText?.groups?.description) };
-    }
-    async getSkillDescription(id) {
-        const description = await this.fetchText("desc_skill.php", {
-            params: {
-                whichskill: String(id),
-            },
-        });
-        const blueText = description.match(/<blockquote[\s\S]+<[Cc]enter>(?<description>[\s\S]+)<\/[Cc]enter>/);
-        return { blueText: sanitiseBlueText(blueText?.groups?.description) };
-    }
-    async joinClan(id) {
-        const result = await this.fetchText("showclan.php", {
-            params: {
-                whichclan: id,
-                action: "joinclan",
-                confirm: "on",
-            },
-        });
-        return (result.includes("clanhalltop.gif") ||
-            result.includes("a clan you're already in"));
-    }
-    async addToWhitelist(playerId, clanId) {
-        return await this.actionMutex.runExclusive(async () => {
-            if (!(await this.joinClan(clanId)))
-                return false;
-            await this.fetchText("clan_whitelist.php", {
-                params: {
-                    addwho: playerId,
-                    level: 2,
-                    title: "",
-                    action: "add",
-                },
-            });
-            return true;
-        });
-    }
-    async getLeaderboard(leaderboardId) {
-        const page = await this.fetchText("museum.php", {
-            params: {
-                floor: 1,
-                place: "leaderboards",
-                whichboard: leaderboardId,
-            },
-        });
-        return parseLeaderboard(page);
-    }
-    async useFamiliar(familiarId) {
-        const result = await this.fetchText("familiar.php", {
-            params: {
-                action: "newfam",
-                newfam: familiarId.toFixed(0),
-            },
-        });
-        return result.includes(`var currentfam = ${familiarId};`);
-    }
-    async getFamiliars() {
-        const terrarium = await this.fetchText("familiar.php");
-        const matches = terrarium.matchAll(/onClick='fam\((\d+)\)'(?:><img)? src=".*?\/(\w+\/\w+.(?:gif|png))".*?\d+-pound (.*?) \(/g);
-        const familiars = [...matches].map((m) => ({
-            id: Number(m[1]),
-            image: m[2],
-            name: m[3],
-        }));
-        if (terrarium.includes("fam(278)")) {
-            familiars.push({
-                id: 278,
-                image: "otherimages/righthandbody.png",
-                name: "Left-Hand Man",
-            });
-        }
-        return familiars;
-    }
-}

package/dist/Client.test.d.ts

@@ -1 +0,0 @@
-export {};