@axiapps/gw2-data 0.1.1 → 0.1.3

package/tests/engine/attributes.test.js

@@ -1,252 +0,0 @@
-"use strict";
-
-const { computeAttributes, computeSlotStats, getExcludedSlots } = require("../../src/engine/attributes");
-
-function makeCtx(overrides = {}) {
-  return {
-    profession: "Warrior",
-    specializations: [],
-    equipment: {
-      slots: {},
-      weapons: {},
-      runes: {},
-      infusions: {},
-      enrichment: null,
-      food: null,
-      utility: null,
-    },
-    gameMode: "pve",
-    underwaterMode: false,
-    activeWeaponSet: 1,
-    skills: {},
-    assumedBoons: null,
-    sigilStacks: null,
-    ...overrides,
-  };
-}
-
-function makeCatalogs(overrides = {}) {
-  return {
-    traitById: new Map(),
-    skillById: new Map(),
-    specializationById: new Map(),
-    runeById: new Map(),
-    foodById: new Map(),
-    utilityById: new Map(),
-    infusionById: new Map(),
-    enrichmentById: new Map(),
-    ...overrides,
-  };
-}
-
-describe("getExcludedSlots", () => {
-  test("excludes aquatic slots in land mode", () => {
-    const excluded = getExcludedSlots(false, 1);
-    expect(excluded.has("breather")).toBe(true);
-    expect(excluded.has("aquatic1")).toBe(true);
-    expect(excluded.has("aquatic2")).toBe(true);
-    expect(excluded.has("head")).toBe(false);
-  });
-
-  test("excludes land weapon slots in land mode for inactive set", () => {
-    const excluded = getExcludedSlots(false, 1);
-    expect(excluded.has("mainhand2")).toBe(true);
-    expect(excluded.has("offhand2")).toBe(true);
-    expect(excluded.has("mainhand1")).toBe(false);
-  });
-
-  test("excludes land-only slots in underwater mode", () => {
-    const excluded = getExcludedSlots(true, 1);
-    expect(excluded.has("head")).toBe(true);
-    expect(excluded.has("mainhand1")).toBe(true);
-    expect(excluded.has("breather")).toBe(false);
-  });
-});
-
-describe("computeSlotStats", () => {
-  test("3-stat combo returns major + minor stats", () => {
-    const result = computeSlotStats("Berserker's", "chest", {}, "pve");
-    expect(result).toEqual([
-      { stat: "Power", value: 141 },
-      { stat: "Precision", value: 101 },
-      { stat: "Ferocity", value: 101 },
-    ]);
-  });
-
-  test("4-stat combo returns 2 major + 2 minor stats", () => {
-    const result = computeSlotStats("Marauder's", "chest", {}, "pve");
-    expect(result).toEqual([
-      { stat: "Power", value: 121 },
-      { stat: "Precision", value: 121 },
-      { stat: "Vitality", value: 66 },
-      { stat: "Ferocity", value: 66 },
-    ]);
-  });
-
-  test("Celestial uses c weight for all stats", () => {
-    const result = computeSlotStats("Celestial", "chest", {}, "pve");
-    expect(result.every((r) => r.value === 66)).toBe(true);
-    expect(result).toHaveLength(9);
-  });
-
-  test("WvW Celestial excludes Expertise and Concentration", () => {
-    const result = computeSlotStats("Celestial", "chest", {}, "wvw");
-    expect(result.find((r) => r.stat === "Expertise")).toBeUndefined();
-    expect(result.find((r) => r.stat === "Concentration")).toBeUndefined();
-    expect(result).toHaveLength(7);
-  });
-
-  test("two-handed weapon uses TWO_HAND_WEIGHTS", () => {
-    const weapons = { mainhand1: "greatsword" };
-    const result = computeSlotStats("Berserker's", "mainhand1", weapons, "pve");
-    expect(result[0]).toEqual({ stat: "Power", value: 251 });
-  });
-});
-
-describe("computeAttributes", () => {
-  test("empty build returns base stats only", () => {
-    const result = computeAttributes(makeCtx(), makeCatalogs());
-    expect(result.base.Power).toBe(1000);
-    expect(result.base.Precision).toBe(1000);
-    expect(result.base.Toughness).toBe(1000);
-    expect(result.base.Vitality).toBe(1000);
-    expect(result.base.Ferocity).toBe(0);
-    expect(result.total.Power).toBe(1000);
-  });
-
-  test("equipment slots contribute to total", () => {
-    const ctx = makeCtx({
-      equipment: { slots: { chest: "Berserker's" }, weapons: {}, runes: {}, infusions: {} },
-    });
-    const result = computeAttributes(ctx, makeCatalogs());
-    expect(result.equipment.Power).toBe(141);
-    expect(result.total.Power).toBe(1141);
-  });
-
-  test("food flat bonuses parsed from buff text", () => {
-    const catalogs = makeCatalogs({
-      foodById: new Map([[100, { name: "Steak", buff: "+100 Power" }]]),
-    });
-    const ctx = makeCtx({ equipment: { slots: {}, weapons: {}, runes: {}, infusions: {}, food: 100 } });
-    const result = computeAttributes(ctx, catalogs);
-    expect(result.food.Power).toBe(100);
-  });
-
-  test("food 'to All Attributes' adds to all stats", () => {
-    const catalogs = makeCatalogs({
-      foodById: new Map([[101, { name: "Feast", buff: "+50 to All Attributes" }]]),
-    });
-    const ctx = makeCtx({ equipment: { slots: {}, weapons: {}, runes: {}, infusions: {}, food: 101 } });
-    const result = computeAttributes(ctx, catalogs);
-    expect(result.food.Power).toBe(50);
-    expect(result.food.Ferocity).toBe(50);
-    expect(result.food.HealingPower).toBe(50);
-  });
-
-  test("rune bonuses are cumulative per piece", () => {
-    const catalogs = makeCatalogs({
-      runeById: new Map([[24836, { name: "Scholar", bonuses: ["+25 Power", "+35 Ferocity", "+50 Power"] }]]),
-    });
-    const ctx = makeCtx({
-      equipment: { slots: {}, weapons: {}, runes: { head: 24836, shoulders: 24836, chest: 24836 }, infusions: {} },
-    });
-    const result = computeAttributes(ctx, catalogs);
-    expect(result.runes.Power).toBe(75);
-    expect(result.runes.Ferocity).toBe(35);
-  });
-
-  test("infusion attributes added", () => {
-    const catalogs = makeCatalogs({
-      infusionById: new Map([[49431, { name: "+5 Power", infixUpgrade: { attributes: [{ attribute: "Power", modifier: 5 }] } }]]),
-    });
-    const ctx = makeCtx({
-      equipment: { slots: {}, weapons: {}, infusions: { chest: [49431, 49431] }, runes: {} },
-    });
-    const result = computeAttributes(ctx, catalogs);
-    expect(result.infusions.Power).toBe(10);
-  });
-
-  test("assumed Might boons add Power and ConditionDamage", () => {
-    const ctx = makeCtx({ assumedBoons: { might: 25 } });
-    const result = computeAttributes(ctx, makeCatalogs());
-    expect(result.boons.Power).toBe(750);
-    expect(result.boons.ConditionDamage).toBe(750);
-  });
-
-  test("derived health uses profession base HP", () => {
-    const ctx = makeCtx({ profession: "Warrior" });
-    const result = computeAttributes(ctx, makeCatalogs());
-    // Warrior base HP = 9212, base Vitality = 1000, health = 9212 + 1000*10 = 19212
-    expect(result.derived.health).toBe(19212);
-  });
-
-  test("derived crit chance formula", () => {
-    const ctx = makeCtx();
-    const result = computeAttributes(ctx, makeCatalogs());
-    // Base precision 1000: critChance = (1000 - 895) / 21 = 5%
-    expect(result.derived.critChance).toBeCloseTo(5, 0);
-  });
-
-  test("derived armor includes weight class defense", () => {
-    const ctx = makeCtx({ profession: "Warrior" });
-    const result = computeAttributes(ctx, makeCatalogs());
-    // Warrior = heavy = 1271 defense, base toughness 1000
-    expect(result.derived.armor).toBe(2271);
-  });
-
-  test("trait conversions applied after base stats", () => {
-    const catalogs = makeCatalogs({
-      traitById: new Map([[500, {
-        id: 500,
-        facts: [{ type: "BuffConversion", source: "Vitality", target: "Power", percent: 10 }],
-      }]]),
-      specializationById: new Map([[4, { id: 4, minorTraits: [] }]]),
-    });
-    const ctx = makeCtx({
-      specializations: [{ id: 4, majorChoices: { 1: 500 } }],
-    });
-    const result = computeAttributes(ctx, catalogs);
-    // base Vitality = 1000, 10% = floor(100) = 100
-    expect(result.conversions.Power).toBe(100);
-    expect(result.total.Power).toBe(1100);
-  });
-
-  test("berserk-conditional trait bonuses only apply when berserkActive", () => {
-    const catalogs = makeCatalogs({
-      traitById: new Map([[2046, {
-        id: 2046,
-        slot: "Minor",
-        description: "Fatal Frenzy",
-        facts: [
-          { type: "AttributeAdjust", target: "Power", value: 150 },
-          { type: "AttributeAdjust", target: "ConditionDamage", value: 300 },
-        ],
-      }]]),
-      specializationById: new Map([[18, { id: 18, minorTraits: [2046] }]]),
-    });
-    const baseCtx = {
-      specializations: [{ id: 18, majorChoices: {} }],
-    };
-
-    // Without berserk: bonuses NOT applied
-    const resultOff = computeAttributes(makeCtx({ ...baseCtx, berserkActive: false }), catalogs);
-    expect(resultOff.traits.Power).toBe(0);
-    expect(resultOff.traits.ConditionDamage).toBe(0);
-
-    // With berserk: bonuses applied
-    const resultOn = computeAttributes(makeCtx({ ...baseCtx, berserkActive: true }), catalogs);
-    expect(resultOn.traits.Power).toBe(150);
-    expect(resultOn.traits.ConditionDamage).toBe(300);
-  });
-
-  test("signet passive buffs added", () => {
-    const ctx = makeCtx({
-      skills: { healId: null, utilityIds: [], eliteId: null },
-      equipment: { slots: {}, weapons: {}, runes: {}, infusions: {} },
-    });
-    // Bane Signet (9093) = +180 Power
-    ctx.skills.utilityIds = [9093];
-    const result = computeAttributes(ctx, makeCatalogs());
-    expect(result.signets.Power).toBe(180);
-  });
-});

package/tests/engine/boons.test.js

@@ -1,129 +0,0 @@
-"use strict";
-
-const { analyzeBoons, isAllyTargeted, normalizeName } = require("../../src/engine/boons");
-
-describe("normalizeName", () => {
-  test("normalizes Blind to Blinded", () => {
-    expect(normalizeName("Blind")).toBe("Blinded");
-  });
-
-  test("normalizes Cripple to Crippled", () => {
-    expect(normalizeName("Cripple")).toBe("Crippled");
-  });
-
-  test("returns unknown names unchanged", () => {
-    expect(normalizeName("Might")).toBe("Might");
-  });
-});
-
-describe("isAllyTargeted", () => {
-  test("returns true when boon name appears in ally sentence", () => {
-    expect(isAllyTargeted("Grant Might to nearby allies.", "Might", [])).toBe(true);
-  });
-
-  test("returns false when boon is in description but not with ally word", () => {
-    expect(isAllyTargeted("Gain Might. Attack enemies.", "Might", [])).toBe(false);
-  });
-
-  test("returns false with no description", () => {
-    expect(isAllyTargeted(null, "Might", [])).toBe(false);
-  });
-
-  test("returns true for generic ally mention when boon not named", () => {
-    expect(isAllyTargeted("Grant boons to allies.", "Fury", [])).toBe(true);
-  });
-
-  test("returns false for unnamed boon when specific boons named with allies", () => {
-    expect(isAllyTargeted("Grant might to allies.", "Fury", ["Might"])).toBe(false);
-  });
-});
-
-describe("analyzeBoons", () => {
-  test("extracts boon from skill with Buff fact", () => {
-    const skills = [{
-      name: "For Great Justice!",
-      description: "Grant Might and Fury to yourself and allies.",
-      icon: "",
-      facts: [
-        { type: "Buff", status: "Might", apply_count: 3, duration: 8 },
-        { type: "Buff", status: "Fury", apply_count: 1, duration: 8 },
-      ],
-    }];
-    const result = analyzeBoons(skills, [], new Map());
-    expect(result.boons.length).toBe(2);
-    expect(result.boons.find((b) => b.name === "Might")).toBeDefined();
-    expect(result.boons.find((b) => b.name === "Fury")).toBeDefined();
-  });
-
-  test("extracts condition from skill", () => {
-    const skills = [{
-      name: "Sword of Justice",
-      description: "Create a Sword of Justice.",
-      icon: "",
-      facts: [{ type: "Buff", status: "Burning", apply_count: 2, duration: 3 }],
-    }];
-    const result = analyzeBoons(skills, [], new Map());
-    expect(result.conditions.length).toBe(1);
-    expect(result.conditions[0].name).toBe("Burning");
-  });
-
-  test("deduplicates by source + stacks + duration + context", () => {
-    const skill = {
-      name: "Skill A", description: "", icon: "",
-      facts: [
-        { type: "Buff", status: "Might", apply_count: 3, duration: 8 },
-        { type: "Buff", status: "Might", apply_count: 3, duration: 8 },
-      ],
-    };
-    const result = analyzeBoons([skill], [], new Map());
-    const might = result.boons.find((b) => b.name === "Might");
-    expect(might.sources).toHaveLength(1);
-  });
-
-  test("handles NoData section context for conditional facts", () => {
-    const skill = {
-      name: "Skill B", description: "", icon: "",
-      facts: [
-        { type: "NoData", text: "On Critical Hit" },
-        { type: "Buff", status: "Fury", apply_count: 1, duration: 4 },
-      ],
-    };
-    const result = analyzeBoons([skill], [], new Map());
-    const fury = result.boons.find((b) => b.name === "Fury");
-    expect(fury.sources[0].context).toBe("On Critical Hit");
-  });
-
-  test("applies Twisted Medicine ally override for Elixir skills", () => {
-    const overrides = new Map([
-      ["trait:2220", { allyTargeted: ["elixir"] }],
-    ]);
-    const skills = [{
-      name: "Elixir B", description: "Drink Elixir B.", icon: "",
-      categories: ["Elixir"],
-      facts: [{ type: "Buff", status: "Fury", apply_count: 1, duration: 5 }],
-    }];
-    const traits = [{ id: 2220, name: "Twisted Medicine", facts: [] }];
-    const result = analyzeBoons(skills, traits, overrides, new Set([2220]));
-    const fury = result.boons.find((b) => b.name === "Fury");
-    expect(fury.sources[0].isAlly).toBe(true);
-  });
-
-  test("sorts boons by display order, conditions alphabetically", () => {
-    const skills = [{
-      name: "Multi", description: "", icon: "",
-      facts: [
-        { type: "Buff", status: "Vigor", apply_count: 1, duration: 5 },
-        { type: "Buff", status: "Aegis", apply_count: 1, duration: 3 },
-        { type: "Buff", status: "Weakness", apply_count: 1, duration: 3 },
-        { type: "Buff", status: "Burning", apply_count: 1, duration: 3 },
-      ],
-    }];
-    const result = analyzeBoons(skills, [], new Map());
-    // Aegis comes before Vigor in GW2 display order
-    const boonNames = result.boons.map((b) => b.name);
-    expect(boonNames.indexOf("Aegis")).toBeLessThan(boonNames.indexOf("Vigor"));
-    // Conditions sorted alphabetically
-    const condNames = result.conditions.map((c) => c.name);
-    expect(condNames).toEqual([...condNames].sort());
-  });
-});

package/tests/engine/combos.test.js

@@ -1,76 +0,0 @@
-"use strict";
-
-const { analyzeCombos } = require("../../src/engine/combos");
-
-describe("analyzeCombos", () => {
-  test("extracts combo field from skill facts", () => {
-    const skills = [{
-      name: "Flame Wall", icon: "", description: "", facts: [
-        { type: "ComboField", field_type: "Fire" },
-        { type: "Time", duration: 5 },
-        { type: "Radius", distance: 240 },
-      ],
-    }];
-    const result = analyzeCombos(skills, []);
-    expect(result.fields).toHaveLength(1);
-    expect(result.fields[0]).toMatchObject({
-      fieldType: "Fire", sourceName: "Flame Wall", duration: 5, radius: 240,
-    });
-  });
-
-  test("extracts combo finisher from skill facts", () => {
-    const skills = [{
-      name: "Mighty Blow", icon: "", description: "", facts: [
-        { type: "ComboFinisher", finisher_type: "Blast", percent: 100 },
-      ],
-    }];
-    const result = analyzeCombos(skills, []);
-    expect(result.finishers).toHaveLength(1);
-    expect(result.finishers[0]).toMatchObject({
-      finisherType: "Blast", sourceName: "Mighty Blow", hitCount: 1, percent: 100,
-    });
-  });
-
-  test("groups multiple finishers of same type on one skill", () => {
-    const skills = [{
-      name: "Whirling Strike", icon: "", description: "", facts: [
-        { type: "ComboFinisher", finisher_type: "Whirl" },
-        { type: "ComboFinisher", finisher_type: "Whirl" },
-        { type: "ComboFinisher", finisher_type: "Whirl" },
-      ],
-    }];
-    const result = analyzeCombos(skills, []);
-    expect(result.finishers).toHaveLength(1);
-    expect(result.finishers[0].hitCount).toBe(3);
-  });
-
-  test("deduplicates fields by (type, sourceName)", () => {
-    const skills = [
-      { name: "Flame Wall", icon: "", description: "", facts: [{ type: "ComboField", field_type: "Fire" }] },
-      { name: "Flame Wall", icon: "", description: "", facts: [{ type: "ComboField", field_type: "Fire" }] },
-    ];
-    const result = analyzeCombos(skills, []);
-    expect(result.fields).toHaveLength(1);
-  });
-
-  test("extracts fields from traits too", () => {
-    const traits = [{
-      name: "Healing Trait", icon: "", description: "", facts: [
-        { type: "ComboField", field_type: "Water" },
-      ],
-    }];
-    const result = analyzeCombos([], traits);
-    expect(result.fields).toHaveLength(1);
-    expect(result.fields[0].fieldType).toBe("Water");
-  });
-
-  test("tracks finisher percent below 100", () => {
-    const skills = [{
-      name: "Leap", icon: "", description: "", facts: [
-        { type: "ComboFinisher", finisher_type: "Leap", percent: 50 },
-      ],
-    }];
-    const result = analyzeCombos(skills, []);
-    expect(result.finishers[0].percent).toBe(50);
-  });
-});