kol.js 0.3.0 → 0.4.0

package/src/Player.test.ts

@@ -17,104 +17,105 @@ vi.mock("./Client.js", async (importOriginal) => {
 
 const client = new Client("", "");
 
-describe("Player searching", () => {
-  test("Can search for a player by name", async () => {
-    vi.mocked(text).mockResolvedValueOnce(
-      await loadFixture(__dirname, "searchplayer_mad_carew.html"),
-    );
+describe("Player.parseSearch", () => {
+  test("Can parse a player search result", async () => {
+    const html = await loadFixture(__dirname, "searchplayer_mad_carew.html");
+    const result = Player.parseSearch(html);
+
+    expectNotNull(result);
+    expect(result.id).toBe(263717);
+    expect(result.name).toBe("Mad Carew");
+  });
+
+  test("Can parse a player in Valhalla", async () => {
+    const html = await loadFixture(__dirname, "searchplayer_beldur.html");
+    const result = Player.parseSearch(html);
 
-    const player = await Player.fromName(client, "mad carew");
+    expectNotNull(result);
+    expect(result.id).toBe(1046951);
+    expect(result.name).toBe("Beldur");
+    expect(result.level).toBe(0);
+    expect(result.kolClass).toBe("Astral Spirit");
+  });
+});
 
-    expectNotNull(player);
+describe("Player.Profiled.parseProfile", () => {
+  test("Can parse a profile picture", async () => {
+    const html = await loadFixture(__dirname, "showplayer_regular.html");
+    const result = await Player.Profiled.parseProfile(html);
 
-    expect(player.id).toBe(263717);
-    // Learns correct capitalisation
-    expect(player.name).toBe("Mad Carew");
+    expectNotNull(result);
+    expect(result.avatar).toContain("<svg");
   });
 
-  test("Can search for a player in Valhalla by name ", async () => {
-    vi.mocked(text).mockResolvedValueOnce(
-      await loadFixture(__dirname, "searchplayer_beldur.html"),
-    );
+  test("Can parse a profile picture on dependence day", async () => {
+    const html = await loadFixture(__dirname, "showplayer_dependence_day.html");
+    const result = await Player.Profiled.parseProfile(html);
 
-    const player = await Player.fromName(client, "Beldur");
+    expectNotNull(result);
+    expect(result.avatar).toContain("<svg");
+  });
 
-    expectNotNull(player);
+  test("Can parse an avatar when the player has been painted gold", async () => {
+    const html = await loadFixture(__dirname, "showplayer_golden_gun.html");
+    const result = await Player.Profiled.parseProfile(html);
 
-    expect(player.id).toBe(1046951);
-    // Learns correct capitalisation
-    expect(player.name).toBe("Beldur");
-    expect(player.level).toBe(0);
-    // We display Astral Spirit even though the search page says Seal Clubber.
-    expect(player.kolClass).toBe("Astral Spirit");
+    expectNotNull(result);
+    expect(result.avatar).toContain("<svg");
   });
 });
 
-describe("Profile parsing", () => {
-  test("Can parse a profile picture", async () => {
-    vi.mocked(text).mockResolvedValueOnce(
-      await loadFixture(__dirname, "showplayer_regular.html"),
-    );
-
-    const player = await new Player(
-      client,
-      2264486,
-      "SSBBHax",
-      1,
-      "Sauceror",
-    ).full();
-
-    expectNotNull(player);
-    expect(player.avatar).toContain("<svg");
+describe("Player class", () => {
+  test("toString returns formatted string", () => {
+    const player = new Player(client, 1197090, "gausie");
+    expect(player.toString()).toBe("gausie (#1197090)");
   });
 
-  test("Can parse a profile picture on dependence day", async () => {
-    vi.mocked(text).mockResolvedValueOnce(
-      await loadFixture(__dirname, "showplayer_dependence_day.html"),
-    );
-
-    const player = await new Player(
-      client,
-      3019702,
-      "Name Guy Man",
-      1,
-      "Sauceror",
-    ).full();
-
-    expectNotNull(player);
-    expect(player.avatar).toContain("<svg");
+  test("matches by id", () => {
+    const player = new Player(client, 1197090, "gausie");
+    expect(player.matches(1197090)).toBe(true);
+    expect(player.matches(999)).toBe(false);
   });
 
-  test("Can parse an avatar when the player has been painted gold", async () => {
-    vi.mocked(text).mockResolvedValueOnce(
-      await loadFixture(__dirname, "showplayer_golden_gun.html"),
-    );
-
-    const player = await new Player(
-      client,
-      1197090,
-      "gAUSIE",
-      15,
-      "Sauceror",
-    ).full();
-
-    expectNotNull(player);
-    expect(player.avatar).toContain("<svg");
+  test("matches by name case-insensitively", () => {
+    const player = new Player(client, 1197090, "gausie");
+    expect(player.matches("gausie")).toBe(true);
+    expect(player.matches("GAUSIE")).toBe(true);
+    expect(player.matches("other")).toBe(false);
   });
 
-  test("Can resolve KoL images", () => {
-    expect(resolveKoLImage("/iii/otherimages/classav31_f.gif")).toBe(
-      "https://s3.amazonaws.com/images.kingdomofloathing.com/otherimages/classav31_f.gif",
-    );
-    expect(resolveKoLImage("/itemimages/oaf.gif")).toBe(
-      "https://s3.amazonaws.com/images.kingdomofloathing.com/itemimages/oaf.gif",
-    );
-    expect(
-      resolveKoLImage(
-        "https://s3.amazonaws.com/images.kingdomofloathing.com/itemimages/oaf.gif",
-      ),
-    ).toBe(
-      "https://s3.amazonaws.com/images.kingdomofloathing.com/itemimages/oaf.gif",
-    );
+  test("Profiled.fetch() returns itself", async () => {
+    const profiled = new Player.Profiled(client, {
+      id: 1,
+      name: "test",
+      level: 15,
+      kolClass: "Sauceror",
+      avatar: "test.gif",
+      ascensions: 100,
+      trophies: 5,
+      tattoos: 3,
+      favoriteFood: null,
+      favoriteBooze: null,
+      createdDate: new Date(),
+      lastLogin: new Date(),
+      hasDisplayCase: false,
+    });
+    expect(await profiled.fetch()).toBe(profiled);
   });
 });
+
+test("Can resolve KoL images", () => {
+  expect(resolveKoLImage("/iii/otherimages/classav31_f.gif")).toBe(
+    "https://s3.amazonaws.com/images.kingdomofloathing.com/otherimages/classav31_f.gif",
+  );
+  expect(resolveKoLImage("/itemimages/oaf.gif")).toBe(
+    "https://s3.amazonaws.com/images.kingdomofloathing.com/itemimages/oaf.gif",
+  );
+  expect(
+    resolveKoLImage(
+      "https://s3.amazonaws.com/images.kingdomofloathing.com/itemimages/oaf.gif",
+    ),
+  ).toBe(
+    "https://s3.amazonaws.com/images.kingdomofloathing.com/itemimages/oaf.gif",
+  );
+});

package/src/Player.ts

@@ -1,215 +1,146 @@
-import { Client } from "./Client.js";
+import type { Client } from "./Client.js";
 import { generateAvatarSvg } from "./utils/avatar.js";
 import { parsePlayerDate } from "./utils/utils.js";
 
-export type If<
-  Value extends boolean,
-  TrueResult,
-  FalseResult = null,
-> = Value extends true
-  ? TrueResult
-  : Value extends false
-    ? FalseResult
-    : TrueResult | FalseResult;
-
-export class Player<IsFull extends boolean = boolean> {
-  #client: Client;
-
+export type ProfileData = {
   id: number;
   name: string;
+  level: number;
+  kolClass: string;
+  avatar: string;
+  ascensions: number;
+  trophies: number;
+  tattoos: number;
+  favoriteFood: string | null;
+  favoriteBooze: string | null;
+  createdDate: Date;
+  lastLogin: Date;
+  hasDisplayCase: boolean;
+};
+
+export class Player {
+  readonly id: number;
+  readonly name: string;
+  #client: Client;
 
-  level: If<IsFull, number>;
-  kolClass: If<IsFull, string>;
-  avatar: If<IsFull, string>;
-  ascensions: If<IsFull, number>;
-  trophies: If<IsFull, number>;
-  tattoos: If<IsFull, number>;
-  favoriteFood: If<IsFull, string | null>;
-  favoriteBooze: If<IsFull, string | null>;
-  createdDate: If<IsFull, Date>;
-  lastLogin: If<IsFull, Date>;
-  hasDisplayCase: If<IsFull, boolean>;
-
-  constructor(
-    client: Client,
-    id: number,
-    name: string,
-    level: number | null = null,
-    kolClass: string | null = null,
-  ) {
+  constructor(client: Client, id: number, name: string) {
     this.#client = client;
     this.id = id;
     this.name = name;
-    this.level = level as If<IsFull, number>;
-    this.kolClass = kolClass as If<IsFull, string>;
-    this.avatar = null as If<IsFull, string>;
-    this.ascensions = null as If<IsFull, number>;
-    this.trophies = null as If<IsFull, number>;
-    this.tattoos = null as If<IsFull, number>;
-    this.favoriteFood = null as If<IsFull, string>;
-    this.favoriteBooze = null as If<IsFull, string>;
-    this.createdDate = null as If<IsFull, Date>;
-    this.lastLogin = null as If<IsFull, Date>;
-    this.hasDisplayCase = null as If<IsFull, boolean>;
   }
 
-  isFull(): this is Player<true> {
-    return this.createdDate !== null;
+  async fetch(): Promise<Player.Profiled | null> {
+    if (this instanceof Player.Profiled) return this;
+    return this.#client.players.fetch(this.id);
   }
 
-  isPartial(): this is Player<false> {
-    return this.createdDate === null;
+  async isOnline(): Promise<boolean> {
+    const response = await this.#client.useChatMacro(`/whois ${this.name}`);
+    return response.output.includes("This player is currently online");
   }
 
-  static async getNameFromId(
-    client: Client,
-    id: number,
-  ): Promise<string | null> {
-    try {
-      const profile = await client.fetchText("submitnewchat.php", {
-        searchParams: { graf: `/whois ${id}` },
-      });
-      const name = profile.match(/<a.*?><b.*?>(.*?) \(#(\d+)\)<\/b><\/a>/)?.[1];
-      return name ?? null;
-    } catch {
-      return null;
+  matches(identifier: string | number): boolean {
+    const id = Number(identifier);
+    if (!Number.isNaN(id) || typeof identifier === "number") {
+      return this.id === id;
     }
+    return this.name.toLowerCase() === identifier.toLowerCase();
   }
 
-  static async fromName(
-    client: Client,
-    name: string,
-  ): Promise<Player<false> | null> {
-    try {
-      const matcher =
-        /<tr><td class=small><b><a target=mainpane href="showplayer\.php\?who=(?<playerId>\d+)">(?<playerName>[^<]+)<\/a><\/b>.*?<\/td><td valign=top class=small>\d*<\/td><td valign=top class=small>(?:<img src=".*?">|(?<level>\d+))<\/td><td class=small valign=top>(?<class>[^<]*)<\/td><\/tr>/i;
-      const search = await client.fetchText("searchplayer.php", {
-        searchParams: {
-          searchstring: name.replace(/_/g, "\\_"),
-          searching: "Yep.",
-          for: "",
-          startswith: 1,
-          hardcoreonly: 0,
-        },
-      });
-      const match = matcher.exec(search)?.groups;
-
-      if (!match) {
-        return null;
-      }
-
-      const clazz = match.level ? match.class : "Astral Spirit";
-
-      return new Player(
-        client,
-        Number(match.playerId),
-        match.playerName,
-        parseInt(match.level) || 0,
-        clazz,
-      );
-    } catch (error) {
-      return null;
-    }
+  toString(): string {
+    return `${this.name} (#${this.id})`;
   }
 
-  static async fromId(
-    client: Client,
-    id: number,
-  ): Promise<Player<false> | null> {
-    const name = await Player.getNameFromId(client, id);
-    if (!name) return null;
-    return await Player.fromName(client, name);
+  static parseSearch(
+    html: string,
+  ): { id: number; name: string; level: number; kolClass: string } | null {
+    const matcher =
+      /<tr><td class=small><b><a target=mainpane href="showplayer\.php\?who=(?<playerId>\d+)">(?<playerName>[^<]+)<\/a><\/b>.*?<\/td><td valign=top class=small>\d*<\/td><td valign=top class=small>(?:<img src=".*?">|(?<level>\d+))<\/td><td class=small valign=top>(?<class>[^<]*)<\/td><\/tr>/i;
+    const match = matcher.exec(html)?.groups;
+    if (!match) return null;
+
+    return {
+      id: Number(match.playerId),
+      name: match.playerName,
+      level: parseInt(match.level) || 0,
+      kolClass: match.level ? match.class : "Astral Spirit",
+    };
   }
 
-  static async from(
-    client: Client,
-    identifier: string | number,
-  ): Promise<Player<false> | null> {
-    const id = Number(identifier);
-
-    if (!Number.isNaN(id) || typeof identifier === "number") {
-      return await Player.fromId(client, id);
-    }
-
-    return await Player.fromName(client, identifier);
+  static parseNameFromWhois(html: string): string | null {
+    return html.match(/<a.*?><b.*?>(.*?) \(#(\d+)\)<\/b><\/a>/)?.[1] ?? null;
   }
+}
 
-  matchesIdentifier(identifier: string | number) {
-    const id = Number(identifier);
-    if (!Number.isNaN(id) || typeof identifier === "number") {
-      return this.id === identifier;
+export namespace Player {
+  export class Profiled extends Player {
+    readonly level: number;
+    readonly kolClass: string;
+    readonly avatar: string;
+    readonly ascensions: number;
+    readonly trophies: number;
+    readonly tattoos: number;
+    readonly favoriteFood: string | null;
+    readonly favoriteBooze: string | null;
+    readonly createdDate: Date;
+    readonly lastLogin: Date;
+    readonly hasDisplayCase: boolean;
+
+    constructor(client: Client, data: ProfileData) {
+      super(client, data.id, data.name);
+      this.level = data.level;
+      this.kolClass = data.kolClass;
+      this.avatar = data.avatar;
+      this.ascensions = data.ascensions;
+      this.trophies = data.trophies;
+      this.tattoos = data.tattoos;
+      this.favoriteFood = data.favoriteFood;
+      this.favoriteBooze = data.favoriteBooze;
+      this.createdDate = data.createdDate;
+      this.lastLogin = data.lastLogin;
+      this.hasDisplayCase = data.hasDisplayCase;
     }
 
-    return this.name.toLowerCase() === identifier.toLowerCase();
-  }
-
-  async full(): Promise<Player<true> | null> {
-    const t = this as unknown as Player<true>;
-
-    if (this.isFull()) return this;
+    override async fetch(): Promise<Player.Profiled> {
+      return this;
+    }
 
-    try {
-      const profile = await this.#client.fetchText("showplayer.php", {
-        searchParams: {
-          who: this.id,
-        },
-      });
-      const header = profile.match(
+    static async parseProfile(
+      html: string,
+    ): Promise<Omit<ProfileData, "id" | "name" | "level" | "kolClass"> | null> {
+      const header = html.match(
         /<center><table><tr><td><center>.*?<img.*?src="(.*?)".*?<b>([^>]*?)<\/b> \(#(\d+)\)<br>/,
       );
       if (!header) return null;
 
-      t.avatar = (await generateAvatarSvg(profile)) || header[1];
-
-      t.ascensions =
-        Number(
-          profile
-            .match(/>Ascensions<\/a>:<\/b><\/td><td>(.*?)<\/td>/)?.[1]
-            ?.replace(/,/g, ""),
-        ) || 0;
-
-      t.trophies = Number(
-        profile.match(/>Trophies Collected:<\/b><\/td><td>(.*?)<\/td>/)?.[1] ??
-          0,
-      );
-
-      t.tattoos = Number(
-        profile.match(/>Tattoos Collected:<\/b><\/td><td>(.*?)<\/td>/)?.[1] ??
-          0,
-      );
-
-      t.favoriteFood =
-        profile.match(/>Favorite Food:<\/b><\/td><td>(.*?)<\/td>/)?.[1] ?? null;
-      t.favoriteBooze =
-        profile.match(/>Favorite Booze:<\/b><\/td><td>(.*?)<\/td>/)?.[1] ??
-        null;
-
-      t.createdDate = parsePlayerDate(
-        profile.match(/>Account Created:<\/b><\/td><td>(.*?)<\/td>/)?.[1],
-      );
-
-      t.lastLogin = parsePlayerDate(
-        profile.match(/>Last Login:<\/b><\/td><td>(.*?)<\/td>/)?.[1],
-      );
-
-      t.hasDisplayCase =
-        profile.match(/Display Case<\/b><\/a> in the Museum<\/td>/) !== null;
-
-      return t;
-    } catch (error) {
-      console.error(error);
-      return null;
+      return {
+        avatar: (await generateAvatarSvg(html)) || header[1],
+        ascensions:
+          Number(
+            html
+              .match(/>Ascensions<\/a>:<\/b><\/td><td>(.*?)<\/td>/)?.[1]
+              ?.replace(/,/g, ""),
+          ) || 0,
+        trophies: Number(
+          html.match(/>Trophies Collected:<\/b><\/td><td>(.*?)<\/td>/)?.[1] ??
+            0,
+        ),
+        tattoos: Number(
+          html.match(/>Tattoos Collected:<\/b><\/td><td>(.*?)<\/td>/)?.[1] ?? 0,
+        ),
+        favoriteFood:
+          html.match(/>Favorite Food:<\/b><\/td><td>(.*?)<\/td>/)?.[1] ?? null,
+        favoriteBooze:
+          html.match(/>Favorite Booze:<\/b><\/td><td>(.*?)<\/td>/)?.[1] ?? null,
+        createdDate: parsePlayerDate(
+          html.match(/>Account Created:<\/b><\/td><td>(.*?)<\/td>/)?.[1],
+        ),
+        lastLogin: parsePlayerDate(
+          html.match(/>Last Login:<\/b><\/td><td>(.*?)<\/td>/)?.[1],
+        ),
+        hasDisplayCase:
+          html.match(/Display Case<\/b><\/a> in the Museum<\/td>/) !== null,
+      };
     }
   }
-
-  async isOnline() {
-    const response = await this.#client.useChatMacro(`/whois ${this.name}`);
-    return (
-      response?.output.includes("This player is currently online") ?? false
-    );
-  }
-
-  toString() {
-    return `${this.name} (#${this.id})`;
-  }
 }

package/src/domains/AutomatedFuture.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "vitest";
+
+import { loadFixture } from "../testUtils.js";
+import { parseScores } from "./AutomatedFuture.js";
+
+test("Can read scores", async () => {
+  const page = await loadFixture(import.meta.dirname, "automated_future.html");
+
+  const scores = parseScores(page);
+
+  expect(scores).toHaveProperty("solenoids", 1001268);
+  expect(scores).toHaveProperty("bearings", 1001028);
+});
+
+test("Returns null if scores cannot be read", () => {
+  const scores = parseScores("");
+
+  expect(scores).toBe(null);
+});

package/src/domains/AutomatedFuture.ts

@@ -0,0 +1,46 @@
+import type { Client } from "../Client.js";
+
+export type TTTScores = {
+  solenoids: number;
+  bearings: number;
+};
+
+export function parseScores(page: string): TTTScores | null {
+  const pattern = /title='(-?\d+)' href=adventure.php\?snarfblat=(581|582)/gs;
+  const matches = [...page.matchAll(pattern)];
+
+  if (matches.length !== 2) return null;
+
+  const scores = matches.reduce<Record<string, number>>(
+    (acc, m) => ({ ...acc, [m[2]]: Number(m[1]) }),
+    {},
+  );
+
+  return {
+    solenoids: scores["581"] ?? 0,
+    bearings: scores["582"] ?? 0,
+  };
+}
+
+export class AutomatedFuture {
+  #client: Client;
+
+  constructor(client: Client) {
+    this.#client = client;
+  }
+
+  async visit(): Promise<string> {
+    return await this.#client.actionMutex.runExclusive(async () => {
+      await this.#client.fetchText("town.php");
+      return this.#client.fetchText("place.php", {
+        query: { whichplace: "twitch" },
+      });
+    });
+  }
+
+  async getScores(): Promise<TTTScores | null> {
+    const page = await this.visit();
+    if (page.includes("faded back into the swirling mists")) return null;
+    return parseScores(page);
+  }
+}

package/src/domains/Bookmobile.test.ts

@@ -0,0 +1,20 @@
+import { expect, test } from "vitest";
+
+import { loadFixture } from "../testUtils.js";
+import { Bookmobile } from "./Bookmobile.js";
+
+test("Can read relevant information", async () => {
+  const page = await loadFixture(import.meta.dirname, "bookmobile_spooky.html");
+
+  const info = Bookmobile.parse(page);
+
+  expect(info).toHaveProperty("copies", "quite a few");
+  expect(info).toHaveProperty("title", "Pocket Guide to Mild Evil");
+  expect(info).toHaveProperty("price", 9932000);
+});
+
+test("Returns null if data cannot be read", () => {
+  const info = Bookmobile.parse("");
+
+  expect(info).toBe(null);
+});

package/src/domains/Bookmobile.ts

@@ -0,0 +1,66 @@
+import type { Client } from "../Client.js";
+
+export type BookmobileStatus = {
+  copies: string;
+  title: string;
+  price: number;
+};
+
+export class BookmobileNotInTownError extends Error {
+  constructor() {
+    super("The Bookmobile is not in town");
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class BookmobileParseError extends Error {
+  constructor() {
+    super("Could not parse the Bookmobile page");
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class Bookmobile {
+  #client: Client;
+
+  constructor(client: Client) {
+    this.#client = client;
+  }
+
+  async visit(): Promise<BookmobileStatus> {
+    const page = await this.#client.actionMutex.runExclusive(async () => {
+      await this.#client.fetchText("town.php");
+      const p = await this.#client.fetchText("place.php", {
+        query: { whichplace: "town_market", action: "town_bookmobile" },
+      });
+      if (p.includes("name=whichchoice")) {
+        await this.#client.fetchText("choice.php", {
+          form: {
+            whichchoice: 1200,
+            option: 2,
+          },
+        });
+      }
+      return p;
+    });
+
+    if (!page.includes("name=whichchoice")) {
+      throw new BookmobileNotInTownError();
+    }
+
+    const result = Bookmobile.parse(page);
+    if (!result) throw new BookmobileParseError();
+    return result;
+  }
+
+  static parse(page: string): BookmobileStatus | null {
+    const pattern =
+      /this week, I've got (.*?) copies of(?: the)? <b>(.*?)<\/b>.*?<b>([0-9,]+) Meat<\/b>/s;
+    const match = page.match(pattern);
+
+    if (!match) return null;
+    const [, copies, title, price] = match;
+
+    return { copies, title, price: Number(price.replaceAll(",", "")) };
+  }
+}