@axiapps/gw2-data 0.1.0 → 0.1.2

package/src/wiki/parser.js

@@ -11,7 +11,11 @@ const WIKI_ATTR_MAP = {
   "Critical Damage": "CritDamage",
 };
 function normalizeAttr(name) {
-  return WIKI_ATTR_MAP[name] || name;
+  if (!name) return name;
+  // Wiki templates inconsistently use lowercase ("power") or capitalized ("Power")
+  // attribute names. Title-case before lookup so both forms produce the API stat key.
+  const titleCased = name.replace(/\b\w/g, (c) => c.toUpperCase());
+  return WIKI_ATTR_MAP[titleCased] || titleCased;
 }
 
 // Fact types to silently ignore
@@ -61,14 +65,14 @@ const BOONS = new Set([
 
 const CONDITIONS = new Set([
   "bleeding",
-  "blind",
+  "blind", "blinded",
   "burning",
-  "chilled",
+  "chill", "chilled",
   "confusion",
-  "crippled",
+  "cripple", "crippled",
   "fear",
-  "immobilize",
-  "poison",
+  "immobilize", "immobilized",
+  "poison", "poisoned",
   "slow",
   "taunt",
   "torment",
@@ -199,9 +203,13 @@ function mapWikiFactToApiFact(factType, positional, params, isWvw, isUniversal)
     const rawCoefficient = params.coefficient || positional[0] || "0";
     const coefficient = parseFloat(stripWikiMarkup(rawCoefficient));
     const hits = parseInt(stripWikiMarkup(params.hits) || "1", 10);
+    // `alt=` carries the conditional damage label (e.g. "Damage to Controlled Foes").
+    // Without this, the conditional variant collapses with the base "Damage" fact
+    // during dedup, hiding bonus-damage values from the tooltip.
+    const label = params.alt ? stripWikiMarkup(params.alt).trim() : "Damage";
     return {
       type: "Damage",
-      text: "Damage",
+      text: label,
       dmg_multiplier: coefficient,
       hit_count: hits,
     };
@@ -392,13 +400,13 @@ function mapWikiFactToApiFact(factType, positional, params, isWvw, isUniversal)
   // Many wiki fact types carry a percentage value (e.g. "damage reduction|33").
   // Without this, they fall through to generic Number and lose the % suffix.
   if (PERCENT_TYPES.has(type)) {
-    const label = type.replace(/\b\w/g, (c) => c.toUpperCase());
+    const label = params.alt ? stripWikiMarkup(params.alt).trim() : type.replace(/\b\w/g, (c) => c.toUpperCase());
     return { type: "Percent", text: label, percent: pos0Num() };
   }
 
   // ── Unknown but has a numeric value ────────────────────────────────
   if (positional[0] && !isNaN(parseFloat(stripWikiMarkup(positional[0])))) {
-    const label = type.replace(/\b\w/g, (c) => c.toUpperCase());
+    const label = params.alt ? stripWikiMarkup(params.alt).trim() : type.replace(/\b\w/g, (c) => c.toUpperCase());
     // Heuristic: fact type names containing "increase", "reduction", "chance",
     // or "rate" are almost always percentages in GW2 wiki templates.
     if (/(?:increase|reduction|chance|rate|cost|drain)$/.test(type)) {

package/scripts/generate-fixtures.js

@@ -1,242 +0,0 @@
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const { computeAttributes } = require("../src/engine/attributes");
-const { hydrateCatalogs } = require("../tests/engine/test-utils");
-
-const FIXTURE_DIR = path.join(__dirname, "../tests/engine/fixtures");
-
-const fixtures = [
-  {
-    name: "Berserker Warrior",
-    description: "Heavy armor, 3-stat, full ascended, signets, Might+Fury assumed",
-    ctx: {
-      profession: "Warrior",
-      specializations: [
-        { id: 4, majorChoices: { 1: 1444, 2: 1449, 3: 1437 } },
-      ],
-      equipment: {
-        slots: {
-          head: "Berserker's", shoulders: "Berserker's", chest: "Berserker's",
-          gloves: "Berserker's", legs: "Berserker's", boots: "Berserker's",
-          mainhand1: "Berserker's", offhand1: "Berserker's",
-          back: "Berserker's", accessory1: "Berserker's", accessory2: "Berserker's",
-          amulet: "Berserker's", ring1: "Berserker's", ring2: "Berserker's",
-        },
-        weapons: { mainhand1: "greatsword" },
-        runes: {},
-        infusions: {},
-        enrichment: null,
-        food: null,
-        utility: null,
-      },
-      gameMode: "pve",
-      underwaterMode: false,
-      activeWeaponSet: 1,
-      skills: { healId: null, utilityIds: [9093], eliteId: null },
-      assumedBoons: { might: 25, fury: true },
-      sigilStacks: null,
-    },
-    catalogs: {
-      traits: [
-        { id: 1444, facts: [{ type: "AttributeAdjust", target: "Power", value: 120 }] },
-        { id: 1449, facts: [] },
-        { id: 1437, facts: [] },
-      ],
-      specializations: [{ id: 4, minorTraits: [] }],
-      skills: [],
-      runes: [],
-      foods: [],
-      utilities: [],
-      infusions: [],
-      enrichments: [],
-    },
-  },
-  {
-    name: "Viper Mirage",
-    description: "Medium armor, 4-stat, trait conversions, food + utility",
-    ctx: {
-      profession: "Mesmer",
-      specializations: [
-        { id: 24, majorChoices: { 1: 700 } },
-      ],
-      equipment: {
-        slots: {
-          head: "Viper's", shoulders: "Viper's", chest: "Viper's",
-          gloves: "Viper's", legs: "Viper's", boots: "Viper's",
-          mainhand1: "Viper's",
-          back: "Viper's", accessory1: "Viper's", accessory2: "Viper's",
-          amulet: "Viper's", ring1: "Viper's", ring2: "Viper's",
-        },
-        weapons: { mainhand1: "axe" },
-        runes: {},
-        infusions: {},
-        enrichment: null,
-        food: 91805,
-        utility: null,
-      },
-      gameMode: "pve",
-      underwaterMode: false,
-      activeWeaponSet: 1,
-      skills: { healId: null, utilityIds: [], eliteId: null },
-      assumedBoons: null,
-      sigilStacks: null,
-    },
-    catalogs: {
-      traits: [
-        { id: 700, facts: [{ type: "BuffConversion", source: "Vitality", target: "ConditionDamage", percent: 10 }] },
-      ],
-      specializations: [{ id: 24, minorTraits: [] }],
-      skills: [],
-      runes: [],
-      foods: [{ id: 91805, name: "Plate of Beef Rendang", buff: "+100 Expertise\n+70 Condition Damage" }],
-      utilities: [],
-      infusions: [],
-      enrichments: [],
-    },
-  },
-  {
-    name: "Celestial Firebrand WvW",
-    description: "Heavy armor, 9-stat, WvW Celestial exclusion, rune bonuses",
-    ctx: {
-      profession: "Guardian",
-      specializations: [],
-      equipment: {
-        slots: {
-          head: "Celestial", shoulders: "Celestial", chest: "Celestial",
-          gloves: "Celestial", legs: "Celestial", boots: "Celestial",
-          mainhand1: "Celestial",
-          back: "Celestial", accessory1: "Celestial", accessory2: "Celestial",
-          amulet: "Celestial", ring1: "Celestial", ring2: "Celestial",
-        },
-        weapons: { mainhand1: "axe" },
-        runes: {
-          head: 24836, shoulders: 24836, chest: 24836,
-          gloves: 24836, legs: 24836, boots: 24836,
-        },
-        infusions: {},
-        enrichment: null,
-        food: null,
-        utility: null,
-      },
-      gameMode: "wvw",
-      underwaterMode: false,
-      activeWeaponSet: 1,
-      skills: { healId: null, utilityIds: [], eliteId: null },
-      assumedBoons: null,
-      sigilStacks: null,
-    },
-    catalogs: {
-      traits: [],
-      specializations: [],
-      skills: [],
-      runes: [{ id: 24836, name: "Superior Rune of the Scholar", bonuses: ["+25 Power", "+35 Ferocity", "+50 Power", "+65 Ferocity", "+100 Power", "+125 Ferocity"] }],
-      foods: [],
-      utilities: [],
-      infusions: [],
-      enrichments: [],
-    },
-  },
-  {
-    name: "Harrier Druid",
-    description: "Medium armor, 3-stat healing, enrichment, infusions",
-    ctx: {
-      profession: "Ranger",
-      specializations: [],
-      equipment: {
-        slots: {
-          head: "Harrier's", shoulders: "Harrier's", chest: "Harrier's",
-          gloves: "Harrier's", legs: "Harrier's", boots: "Harrier's",
-          mainhand1: "Harrier's",
-          back: "Harrier's", accessory1: "Harrier's", accessory2: "Harrier's",
-          amulet: "Harrier's", ring1: "Harrier's", ring2: "Harrier's",
-        },
-        weapons: { mainhand1: "staff" },
-        runes: {},
-        infusions: {
-          head: [49432], shoulders: [49432], chest: [49432],
-          gloves: [49432], legs: [49432], boots: [49432],
-        },
-        enrichment: 78061,
-        food: null,
-        utility: null,
-      },
-      gameMode: "pve",
-      underwaterMode: false,
-      activeWeaponSet: 1,
-      skills: { healId: null, utilityIds: [], eliteId: null },
-      assumedBoons: null,
-      sigilStacks: null,
-    },
-    catalogs: {
-      traits: [],
-      specializations: [],
-      skills: [],
-      runes: [],
-      foods: [],
-      utilities: [],
-      infusions: [{ id: 49432, name: "+5 Healing Power Infusion", infixUpgrade: { attributes: [{ attribute: "Healing", modifier: 5 }] } }],
-      enrichments: [{ id: 78061, name: "+10 Concentration Enrichment", infixUpgrade: { attributes: [{ attribute: "BoonDuration", modifier: 10 }] } }],
-    },
-  },
-  {
-    name: "Berserker Thief",
-    description: "Medium armor, sparse gear (testing empty slots gracefully)",
-    ctx: {
-      profession: "Thief",
-      specializations: [],
-      equipment: {
-        slots: { chest: "Berserker's", legs: "Berserker's" },
-        weapons: {},
-        runes: {},
-        infusions: {},
-        enrichment: null,
-        food: null,
-        utility: null,
-      },
-      gameMode: "pve",
-      underwaterMode: false,
-      activeWeaponSet: 1,
-      skills: { healId: null, utilityIds: [], eliteId: null },
-      assumedBoons: null,
-      sigilStacks: null,
-    },
-    catalogs: {
-      traits: [],
-      specializations: [],
-      skills: [],
-      runes: [],
-      foods: [],
-      utilities: [],
-      infusions: [],
-      enrichments: [],
-    },
-  },
-];
-
-// Generate fixtures
-if (!fs.existsSync(FIXTURE_DIR)) {
-  fs.mkdirSync(FIXTURE_DIR, { recursive: true });
-}
-
-for (const fixture of fixtures) {
-  const catalogs = hydrateCatalogs(fixture.catalogs);
-  const result = computeAttributes(fixture.ctx, catalogs);
-  const output = {
-    name: fixture.name,
-    description: fixture.description,
-    ctx: fixture.ctx,
-    catalogs: fixture.catalogs,
-    expected: {
-      total: result.total,
-      derived: result.derived,
-    },
-  };
-  const filename = fixture.name.toLowerCase().replace(/\s+/g, "-") + ".json";
-  const filepath = path.join(FIXTURE_DIR, filename);
-  fs.writeFileSync(filepath, JSON.stringify(output, null, 2) + "\n");
-  console.log(`Generated: ${filename}`);
-}
-
-console.log("Done!");

package/tests/api-client.test.js

@@ -1,138 +0,0 @@
-"use strict";
-
-const { Gw2ApiClient } = require("../src/api/client");
-const { MemoryCache } = require("../src/wiki/cache");
-
-describe("Gw2ApiClient", () => {
-  let client;
-  let mockFetch;
-
-  beforeEach(() => {
-    mockFetch = jest.fn();
-    client = new Gw2ApiClient({
-      cache: new MemoryCache(),
-      fetch: mockFetch,
-    });
-  });
-
-  describe("fetchJson", () => {
-    test("returns parsed JSON on success", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({ name: "Fireball" }),
-      });
-      const result = await client.fetchJson("https://api.guildwars2.com/v2/skills/5489");
-      expect(result).toEqual({ name: "Fireball" });
-    });
-
-    test("retries on 429 with delay", async () => {
-      mockFetch
-        .mockResolvedValueOnce({ ok: false, status: 429, statusText: "Too Many Requests" })
-        .mockResolvedValueOnce({
-          ok: true,
-          json: async () => ({ name: "Fireball" }),
-        });
-      const result = await client.fetchJson("https://api.guildwars2.com/v2/skills/5489");
-      expect(result).toEqual({ name: "Fireball" });
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-    });
-
-    test("throws after max retries", async () => {
-      mockFetch.mockResolvedValue({ ok: false, status: 500, statusText: "Server Error" });
-      await expect(
-        client.fetchJson("https://api.guildwars2.com/v2/skills/5489")
-      ).rejects.toThrow("500");
-    });
-
-    test("throws immediately on 4xx (non-429) without retrying", async () => {
-      mockFetch.mockResolvedValueOnce({ ok: false, status: 404, statusText: "Not Found" });
-      await expect(
-        client.fetchJson("https://api.guildwars2.com/v2/skills/99999")
-      ).rejects.toThrow("404");
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("fetchByIds", () => {
-    test("fetches single chunk of IDs", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => [
-          { id: 1, name: "Skill A" },
-          { id: 2, name: "Skill B" },
-        ],
-      });
-      const result = await client.fetchByIds("/v2/skills", [1, 2]);
-      expect(result).toHaveLength(2);
-      expect(result[0].name).toBe("Skill A");
-    });
-
-    test("chunks large ID lists into batches of 180", async () => {
-      const ids = Array.from({ length: 200 }, (_, i) => i + 1);
-      mockFetch
-        .mockResolvedValueOnce({
-          ok: true,
-          json: async () => ids.slice(0, 180).map((id) => ({ id })),
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          json: async () => ids.slice(180).map((id) => ({ id })),
-        });
-      const result = await client.fetchByIds("/v2/skills", ids);
-      expect(result).toHaveLength(200);
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-    });
-
-    test("deduplicates IDs before fetching", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => [{ id: 1, name: "Skill A" }],
-      });
-      const result = await client.fetchByIds("/v2/skills", [1, 1, 1]);
-      expect(result).toHaveLength(1);
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      expect(mockFetch.mock.calls[0][0]).toContain("ids=1");
-      expect(mockFetch.mock.calls[0][0]).not.toContain("ids=1,1");
-    });
-  });
-
-  describe("fetchCached", () => {
-    test("returns cached value on hit", async () => {
-      const cache = new MemoryCache();
-      cache.set("test-key", { cached: true }, 60000);
-      client = new Gw2ApiClient({ cache, fetch: mockFetch });
-
-      const result = await client.fetchCached("test-key", "https://example.com", 60000);
-      expect(result).toEqual({ cached: true });
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
-
-    test("fetches and caches on miss", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({ fresh: true }),
-      });
-      const result = await client.fetchCached("test-key", "https://example.com", 60000);
-      expect(result).toEqual({ fresh: true });
-      const result2 = await client.fetchCached("test-key", "https://example.com", 60000);
-      expect(result2).toEqual({ fresh: true });
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("constructor defaults", () => {
-    test("defaults to MemoryCache when no cache provided", async () => {
-      const defaultClient = new Gw2ApiClient({ fetch: mockFetch });
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({ id: 1 }),
-      });
-      const result = await defaultClient.fetchCached("k", "https://example.com", 60000);
-      expect(result).toEqual({ id: 1 });
-      // Second call should hit cache
-      const result2 = await defaultClient.fetchCached("k", "https://example.com", 60000);
-      expect(result2).toEqual({ id: 1 });
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-  });
-});

package/tests/cache.test.js

@@ -1,108 +0,0 @@
-"use strict";
-
-const { MemoryCache } = require("../src/wiki/cache");
-
-describe("MemoryCache", () => {
-  let cache;
-
-  beforeEach(() => {
-    cache = new MemoryCache();
-  });
-
-  test("get returns null for missing key", () => {
-    expect(cache.get("missing")).toBeNull();
-  });
-
-  test("set and get round-trips a value", () => {
-    cache.set("key1", { data: "hello" }, 60000);
-    expect(cache.get("key1")).toEqual({ data: "hello" });
-  });
-
-  test("get returns null for expired entry", () => {
-    cache.set("key1", "value", 1); // 1ms TTL
-    // Advance past TTL
-    jest.useFakeTimers();
-    jest.advanceTimersByTime(10);
-    expect(cache.get("key1")).toBeNull();
-    jest.useRealTimers();
-  });
-
-  test("invalidate removes a specific key", () => {
-    cache.set("key1", "value1", 60000);
-    cache.set("key2", "value2", 60000);
-    cache.invalidate("key1");
-    expect(cache.get("key1")).toBeNull();
-    expect(cache.get("key2")).toBe("value2");
-  });
-
-  test("clear removes all entries", () => {
-    cache.set("key1", "value1", 60000);
-    cache.set("key2", "value2", 60000);
-    cache.clear();
-    expect(cache.get("key1")).toBeNull();
-    expect(cache.get("key2")).toBeNull();
-  });
-
-  test("has returns true for valid entry, false for missing/expired", () => {
-    cache.set("key1", "value", 60000);
-    expect(cache.has("key1")).toBe(true);
-    expect(cache.has("missing")).toBe(false);
-  });
-});
-
-const fs = require("node:fs/promises");
-const path = require("node:path");
-const os = require("node:os");
-const { DiskCache } = require("../src/wiki/cache");
-
-describe("DiskCache", () => {
-  let cache;
-  let tmpDir;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "gw2-data-cache-"));
-    cache = new DiskCache(tmpDir);
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  test("get returns null for missing key", async () => {
-    expect(await cache.get("missing")).toBeNull();
-  });
-
-  test("set and get round-trips a value", async () => {
-    await cache.set("key1", { data: "hello" }, 60000);
-    expect(await cache.get("key1")).toEqual({ data: "hello" });
-  });
-
-  test("get returns null for expired entry", async () => {
-    await cache.set("key1", "value", 1);
-    // Wait for TTL to expire
-    await new Promise((r) => setTimeout(r, 10));
-    expect(await cache.get("key1")).toBeNull();
-  });
-
-  test("invalidate removes a specific key", async () => {
-    await cache.set("key1", "value1", 60000);
-    await cache.set("key2", "value2", 60000);
-    await cache.invalidate("key1");
-    expect(await cache.get("key1")).toBeNull();
-    expect(await cache.get("key2")).toBe("value2");
-  });
-
-  test("clear removes all entries", async () => {
-    await cache.set("key1", "value1", 60000);
-    await cache.set("key2", "value2", 60000);
-    await cache.clear();
-    expect(await cache.get("key1")).toBeNull();
-    expect(await cache.get("key2")).toBeNull();
-  });
-
-  test("persists across instances", async () => {
-    await cache.set("key1", "value1", 60000);
-    const cache2 = new DiskCache(tmpDir);
-    expect(await cache2.get("key1")).toBe("value1");
-  });
-});