kol.js 0.0.2 → 0.1.1

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "kol.js",
-  "version": "0.0.2",
-  "main": "dist/index.js",
+  "version": "0.1.1",
+  "main": "src/index.ts",
   "type": "module",
   "files": [
-    "/dist"
+    "/src"
   ],
   "license": "MIT",
   "scripts": {
     "build": "tsc",
     "test": "vitest",
-    "format": "prettier --write .",
-    "prepack": "yarn run build"
+    "format": "prettier --write ."
   },
   "devDependencies": {
+    "@types/tough-cookie": "^4",
     "prettier": "^3.2.5",
     "typescript": "^5.4.5",
     "vitest": "^1.6.0"
@@ -22,9 +22,10 @@
     "@xmldom/xmldom": "^0.8.10",
     "async-mutex": "^0.5.0",
     "date-fns": "^3.6.0",
-    "fetch-cookie": "^3.0.1",
+    "got": "^14.3.0",
     "node-html-parser": "^6.1.13",
     "querystring": "^0.2.1",
+    "tough-cookie": "^4.1.4",
     "typed-emitter": "^2.1.0",
     "xpath": "^0.0.34"
   }

package/src/Cache.ts

@@ -0,0 +1,33 @@
+import { Client } from "./Client.js";
+import { Player } from "./Player.js";
+
+export class Cache<T> {
+  client: Client;
+
+  constructor(client: Client) {
+    this.client = client;
+  }
+
+  cache: T[] = [];
+}
+
+export class PlayerCache extends Cache<Player<boolean>> {
+  async fetch(identifier: string | number, full: true): Promise<Player<true>>;
+  async fetch(identifier: string | number): Promise<Player<boolean>>;
+  async fetch(identifier: string | number, 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/src/Client.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it, test, vi } from "vitest";
+
+import { Client } from "./Client.js";
+import { loadFixture } from "./testUtils.js";
+
+const { json, text } = vi.hoisted(() => ({ json: vi.fn(), text: vi.fn() }));
+
+vi.mock("./Client.js", async (importOriginal) => {
+  const client = await importOriginal<typeof import("./Client.js")>();
+  client.Client.prototype.login = async () => true;
+  client.Client.prototype.checkLoggedIn = async () => true;
+  client.Client.prototype.fetchText = text;
+  client.Client.prototype.fetchJson = json;
+  return client;
+});
+
+const client = new Client("", "");
+
+describe("LoathingChat", () => {
+  test("Can parse a regular message", async () => {
+    json.mockResolvedValue({});
+    json.mockResolvedValueOnce({
+      msgs: [
+        {
+          msg: "testing",
+          type: "public",
+          mid: "1538072797",
+          who: { name: "gAUSIE", id: "1197090", color: "black" },
+          format: "0",
+          channel: "talkie",
+          channelcolor: "green",
+          time: "1698787642",
+        },
+      ],
+    });
+
+    const messageSpy = vi.fn();
+
+    client.on("public", messageSpy);
+
+    await client.checkMessages();
+
+    expect(messageSpy).toHaveBeenCalledOnce();
+    const [message] = messageSpy.mock.calls[0];
+    expect(message).toMatchObject({
+      type: "public",
+      msg: "testing",
+      time: new Date(1698787642000),
+      who: { id: 1197090, name: "gAUSIE" },
+    });
+  });
+
+  test("Can parse a system message for rollover in 5 minutes", async () => {
+    json.mockResolvedValueOnce({
+      msgs: [
+        {
+          msg: "The system will go down for nightly maintenance in 5 minutes.",
+          type: "system",
+          mid: "1538084998",
+          who: { name: "System Message", id: "-1", color: "" },
+          format: "2",
+          channelcolor: "green",
+          time: "1698809101",
+        },
+      ],
+    });
+
+    const messageSpy = vi.fn();
+
+    client.on("system", messageSpy);
+
+    await client.checkMessages();
+
+    expect(messageSpy).toHaveBeenCalledOnce();
+    const [message] = messageSpy.mock.calls[0];
+    expect(message).toMatchObject({
+      type: "system",
+      who: { id: -1, name: "System Message" },
+      msg: "The system will go down for nightly maintenance in 5 minutes.",
+      time: new Date(1698809101000),
+    });
+  });
+
+  test("Can parse a system message for rollover in one minute", async () => {
+    json.mockResolvedValueOnce({
+      msgs: [
+        {
+          msg: "The system will go down for nightly maintenance in 1 minute.",
+          type: "system",
+          mid: "1538084998",
+          who: { name: "System Message", id: "-1", color: "" },
+          format: "2",
+          channelcolor: "green",
+          time: "1698809101",
+        },
+      ],
+    });
+
+    const messageSpy = vi.fn();
+
+    client.on("system", messageSpy);
+
+    await client.checkMessages();
+
+    expect(messageSpy).toHaveBeenCalledOnce();
+    const [message] = messageSpy.mock.calls[0];
+    expect(message).toMatchObject({
+      type: "system",
+      who: { id: -1, name: "System Message" },
+      msg: "The system will go down for nightly maintenance in 1 minute.",
+      time: new Date(1698809101000),
+    });
+  });
+
+  test("Can parse a system message for rollover complete", async () => {
+    json.mockResolvedValueOnce({
+      msgs: [
+        {
+          msg: "Rollover is over.",
+          type: "system",
+          mid: "1538085619",
+          who: { name: "System Message", id: "-1", color: "" },
+          format: "2",
+          channelcolor: "green",
+          time: "1698809633",
+        },
+      ],
+    });
+
+    const messageSpy = vi.fn();
+
+    client.on("system", messageSpy);
+
+    await client.checkMessages();
+
+    expect(messageSpy).toHaveBeenCalledOnce();
+    const [message] = messageSpy.mock.calls[0];
+    expect(message).toMatchObject({
+      type: "system",
+      who: { id: -1, name: "System Message" },
+      msg: "Rollover is over.",
+      time: new Date(1698809633000),
+    });
+  });
+});
+
+describe("Skill descriptions", () => {
+  test("can describe a Skill with no bluetext", async () => {
+    text.mockResolvedValueOnce(
+      await loadFixture(
+        __dirname,
+        "desc_skill_overload_discarded_refridgerator.html",
+      ),
+    );
+
+    const description = await client.getSkillDescription(7017);
+
+    expect(description).toStrictEqual({
+      blueText: "",
+    });
+  });
+
+  test("can describe a Skill with bluetext", async () => {
+    text.mockResolvedValueOnce(
+      await loadFixture(__dirname, "desc_skill_impetuous_sauciness.html"),
+    );
+
+    const description = await client.getSkillDescription(4015);
+
+    expect(description).toStrictEqual({
+      blueText: "Makes Sauce Potions last longer",
+    });
+  });
+});
+
+describe("Familiars", () => {
+  test("can fetch all familiars", async () => {
+    text.mockResolvedValueOnce(
+      await loadFixture(__dirname, "familiar_in_standard_run.html"),
+    );
+
+    const familiars = await client.getFamiliars();
+
+    // Current
+    expect(familiars).toContainEqual({
+      id: 294,
+      name: "Jill-of-All-Trades",
+      image: "itemimages/darkjill2f.gif",
+    });
+
+    // Problematic
+    expect(familiars).toContainEqual({
+      id: 278,
+      name: "Left-Hand Man",
+      image: "otherimages/righthandbody.png",
+    });
+    expect(familiars).toContainEqual({
+      id: 279,
+      name: "Melodramedary",
+      image: "otherimages/camelfam_left.gif",
+    });
+
+    // Just to be sure
+    expect(familiars).toHaveLength(206);
+  });
+});