@axiapps/gw2-data 0.1.0

package/src/engine/modifiers.js

@@ -0,0 +1,204 @@
+"use strict";
+
+const { CONVERSION_TARGET_MAP } = require("./constants");
+
+// ---------------------------------------------------------------------------
+// Modifiers module — collects active trait IDs and classifies facts into
+// typed modifier objects. Pure functions — no DOM, no renderer state.
+// ---------------------------------------------------------------------------
+
+/**
+ * Collect all active trait IDs — major choices + minor (auto-selected) traits.
+ *
+ * @param {Object} ctx - Build context
+ * @param {Array} ctx.specializations - Array of specialization objects
+ * @param {Object} catalogs - Catalog data
+ * @param {Object} catalogs.specializationById - Map<number, { minorTraits: number[] }>
+ * @returns {Set<number>}
+ */
+function collectActiveTraitIds(ctx, catalogs) {
+  const ids = new Set();
+  if (!ctx || !Array.isArray(ctx.specializations)) return ids;
+
+  for (const spec of ctx.specializations) {
+    if (!spec) continue;
+
+    // Collect major trait choices
+    for (const id of Object.values(spec.majorChoices || {})) {
+      const n = Number(id);
+      if (n) ids.add(n);
+    }
+
+    // Collect minor traits from catalog
+    const specId = Number(spec.specializationId || spec.id) || 0;
+    const specData = (specId && catalogs?.specializationById)
+      ? catalogs.specializationById.get(specId)
+      : null;
+    for (const minorId of specData?.minorTraits || []) {
+      if (minorId) ids.add(Number(minorId));
+    }
+  }
+
+  return ids;
+}
+
+/**
+ * Check whether a trait is fury-related: has a Buff(Fury) fact or is marked
+ * with implicitFury in overrides.
+ *
+ * @param {Object} trait - Trait object with facts array
+ * @param {number} traitId - The trait's ID
+ * @param {Map} overrides - Overrides map (string key → object)
+ * @returns {boolean}
+ */
+function isFuryTrait(trait, traitId, overrides) {
+  const override = overrides?.get(`trait:${traitId}`);
+  if (override?.implicitFury) return true;
+  return trait.facts?.some((f) => f.type === "Buff" && f.status === "Fury") || false;
+}
+
+/**
+ * Collect typed modifier objects from active traits.
+ *
+ * Modifier types emitted:
+ *   - flatBonus:      { source, type, target, value, condition }
+ *   - conversion:     { source, type, sourceAttr, target, percent, condition }
+ *   - critChance:     { source, type, value, condition }
+ *   - mightModifier:  { source, type, power, condi, condition }
+ *   - burstRecharge:  { source, type, value, condition }
+ *
+ * @param {Object} ctx - Build context (has .specializations, .gameMode)
+ * @param {Object} catalogs - Catalog data (has .traitById, .specializationById)
+ * @param {Map} overrides - Overrides map from loadOverrides()
+ * @returns {Array<Object>}
+ */
+function collectModifiers(ctx, catalogs, overrides) {
+  const modifiers = [];
+  if (!catalogs?.traitById) return modifiers;
+
+  const gameMode = ctx?.gameMode || "pve";
+  const activeTraitIds = collectActiveTraitIds(ctx, catalogs);
+  if (!activeTraitIds.size) return modifiers;
+
+  for (const traitId of activeTraitIds) {
+    const source = `trait:${traitId}`;
+    const override = overrides?.get(source) || null;
+
+    // 1. Skip pet-stat-only traits
+    if (override?.petStatOnly) continue;
+
+    const trait = catalogs.traitById.get(traitId);
+
+    // 2. mightOverride — emit mightModifier (no trait facts needed)
+    if (override?.mightOverride) {
+      modifiers.push({
+        source,
+        type: "mightModifier",
+        power: override.mightOverride.power,
+        condi: override.mightOverride.condi,
+        condition: null,
+      });
+    }
+
+    // 3. burstRechargeReduction from overrides
+    if (override?.burstRechargeReduction != null) {
+      modifiers.push({
+        source,
+        type: "burstRecharge",
+        value: override.burstRechargeReduction,
+        condition: null,
+      });
+    }
+
+    if (!trait?.facts) continue;
+
+    // Use per-mode facts when the wiki pipeline has separated them;
+    // fall back to trait.facts (which may contain mixed-mode duplicates).
+    const modeFacts = gameMode === "wvw" && trait.wvwFacts ? trait.wvwFacts
+      : gameMode === "pvp" && trait.pvpFacts ? trait.pvpFacts
+      : trait.facts;
+
+    const fury = isFuryTrait(trait, traitId, overrides);
+    const condition = override?.berserkConditional ? "berserk"
+      : fury ? "fury" : null;
+
+    // 4. AttributeAdjust facts — flatBonus
+    const byTarget = new Map();
+    for (const fact of modeFacts) {
+      if (fact.type !== "AttributeAdjust" || !fact.target || fact.value == null) continue;
+      if (!byTarget.has(fact.target)) byTarget.set(fact.target, []);
+      byTarget.get(fact.target).push(fact.value);
+    }
+    for (const [target, values] of byTarget) {
+      const statKey = CONVERSION_TARGET_MAP[target] || target;
+      const idx = gameMode === "wvw" ? Math.min(1, values.length - 1) : 0;
+      modifiers.push({
+        source,
+        type: "flatBonus",
+        target: statKey,
+        value: values[idx],
+        condition,
+      });
+    }
+
+    // 5. BuffConversion / AttributeConversion facts — conversion
+    //    Group by source+target pair and pick PvE (index 0) or WvW (index 1),
+    //    mirroring the dedup logic used for AttributeAdjust facts above.
+    const convByPair = new Map();
+    for (const fact of modeFacts) {
+      if (fact.type !== "AttributeConversion" && fact.type !== "BuffConversion") continue;
+      if (!fact.source || !fact.target || !fact.percent) continue;
+      const pairKey = `${fact.source}|${fact.target}`;
+      if (!convByPair.has(pairKey)) convByPair.set(pairKey, []);
+      convByPair.get(pairKey).push(fact);
+    }
+    for (const [, facts] of convByPair) {
+      const idx = gameMode === "wvw" ? Math.min(1, facts.length - 1) : 0;
+      const fact = facts[idx];
+      const targetKey = CONVERSION_TARGET_MAP[fact.target] || fact.target;
+      modifiers.push({
+        source,
+        type: "conversion",
+        sourceAttr: fact.source,
+        target: targetKey,
+        percent: fact.percent,
+        condition: null,
+      });
+    }
+
+    // 6. Fury traits with "Critical Chance Increase" Percent facts — critChance
+    if (fury) {
+      const critFacts = modeFacts.filter(
+        (f) => f.type === "Percent" && f.text === "Critical Chance Increase" && f.percent
+      );
+      if (critFacts.length > 0) {
+        const idx = gameMode === "wvw" ? Math.min(1, critFacts.length - 1) : 0;
+        modifiers.push({
+          source,
+          type: "critChance",
+          value: critFacts[idx].percent,
+          condition: "fury",
+        });
+      }
+    }
+
+    // 7. Minor traits with "burst" in description and "Recharge Reduced" Percent facts
+    if (trait.slot === "Minor" && trait.description?.toLowerCase().includes("burst")) {
+      const rechargeFacts = modeFacts.filter(
+        (f) => f.type === "Percent" && f.text === "Recharge Reduced" && f.percent
+      );
+      for (const fact of rechargeFacts) {
+        modifiers.push({
+          source,
+          type: "burstRecharge",
+          value: fact.percent,
+          condition: null,
+        });
+      }
+    }
+  }
+
+  return modifiers;
+}
+
+module.exports = { collectActiveTraitIds, isFuryTrait, collectModifiers };

package/src/engine/overrides.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const raw = require("../../data/overrides.json");
+
+function loadOverrides() {
+  return new Map(Object.entries(raw));
+}
+
+function getOverride(overrides, key) {
+  return overrides.get(key) || null;
+}
+
+module.exports = { loadOverrides, getOverride };

package/src/engine/tooltips.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const { WEAPON_STRENGTH_MIDPOINT } = require("./constants");
+
+/**
+ * Compute tooltip damage for a skill.
+ *
+ * @param {Object} attributes - Result from computeAttributes() (needs .total and .derived)
+ * @param {Object} skill - Skill object with facts array
+ * @param {string} weaponType - Equipped weapon type (e.g. "greatsword", "staff")
+ * @param {Object[]} modifiers - Active modifiers from collectModifiers()
+ * @returns {Object|null} Tooltip result or null if skill has no Damage fact
+ */
+function computeTooltip(attributes, skill, weaponType, modifiers) {
+  const facts = skill.facts || [];
+  const damageFact = facts.find((f) => f.type === "Damage");
+  if (!damageFact) return null;
+
+  const coefficient = damageFact.dmg_multiplier || 0;
+  const hits = damageFact.hit_count || 1;
+  const weaponStrength = WEAPON_STRENGTH_MIDPOINT[weaponType] || 0;
+  const power = attributes.total.Power || 0;
+
+  // Target armor (standard PvE target: 2597)
+  const targetArmor = 2597;
+
+  // Collect applicable damage multipliers
+  let damageMultiplier = 1;
+  const appliedModifiers = [];
+  for (const mod of modifiers) {
+    if (mod.type === "damageMultiplier" && mod.condition === null) {
+      damageMultiplier *= (1 + mod.value / 100);
+      appliedModifiers.push(mod);
+    }
+  }
+
+  // Effective power with crit
+  const critChance = Math.min(100, attributes.derived.critChance || 0) / 100;
+  const critDamage = (attributes.derived.critDamage || 150) / 100;
+  const critMultiplier = 1 + critChance * (critDamage - 1);
+
+  const damage = Math.round(
+    coefficient * weaponStrength * power * damageMultiplier * critMultiplier / targetArmor
+  );
+
+  return {
+    damage,
+    totalDamage: damage * hits,
+    coefficient,
+    hits,
+    weaponStrength,
+    power,
+    critMultiplier,
+    damageMultiplier,
+    modifiers: appliedModifiers,
+  };
+}
+
+module.exports = { computeTooltip };

package/src/facts/match.js

@@ -0,0 +1,134 @@
+"use strict";
+
+const { normalizeFactType } = require("./normalize");
+
+const VALUE_KEYS = [
+  "value", "distance", "duration", "apply_count", "dmg_multiplier",
+  "hit_count", "percent", "coefficient", "finisher_type", "field_type",
+];
+
+const STOP_WORDS = new Set([
+  "the", "and", "per", "for", "with", "from", "based", "gain",
+]);
+
+function splitGroupKey(fact) {
+  const normType = normalizeFactType(fact.type);
+  const qualifier = fact.target || fact.status || "";
+  return `${normType}:${qualifier}`;
+}
+
+function valueChanged(before, after) {
+  for (const key of VALUE_KEYS) {
+    if (key === "hit_count" && before[key] === undefined) continue;
+    if (before[key] !== after[key]) return true;
+  }
+  return false;
+}
+
+function extractKeywords(text) {
+  if (!text) return new Set();
+  const words = text.toLowerCase().split(/\s+/);
+  return new Set(words.filter((w) => w.length >= 3 && !STOP_WORDS.has(w)));
+}
+
+function buildMatchTables(baseFacts, splitFacts) {
+  const baseToSplit = new Map();
+  const splitToBase = new Map();
+  const baseMatched = new Set();
+  const splitMatched = new Set();
+
+  // Pass 1: Exact text + normalized type
+  for (let si = 0; si < splitFacts.length; si++) {
+    if (splitMatched.has(si)) continue;
+    const sf = splitFacts[si];
+    const normSplitType = normalizeFactType(sf.type);
+    for (let bi = 0; bi < baseFacts.length; bi++) {
+      if (baseMatched.has(bi)) continue;
+      const bf = baseFacts[bi];
+      if (normalizeFactType(bf.type) === normSplitType && bf.text === sf.text) {
+        baseToSplit.set(bi, si);
+        splitToBase.set(si, bi);
+        baseMatched.add(bi);
+        splitMatched.add(si);
+        break;
+      }
+    }
+  }
+
+  // Pass 1.5: Cross-type exact text match
+  for (let si = 0; si < splitFacts.length; si++) {
+    if (splitMatched.has(si)) continue;
+    const sf = splitFacts[si];
+    for (let bi = 0; bi < baseFacts.length; bi++) {
+      if (baseMatched.has(bi)) continue;
+      const bf = baseFacts[bi];
+      if (bf.text === sf.text) {
+        baseToSplit.set(bi, si);
+        splitToBase.set(si, bi);
+        baseMatched.add(bi);
+        splitMatched.add(si);
+        break;
+      }
+    }
+  }
+
+  // Pass 2: Type-group positional match
+  const baseGroups = new Map();
+  const splitGroups = new Map();
+  for (let bi = 0; bi < baseFacts.length; bi++) {
+    if (baseMatched.has(bi)) continue;
+    const key = splitGroupKey(baseFacts[bi]);
+    if (!baseGroups.has(key)) baseGroups.set(key, []);
+    baseGroups.get(key).push(bi);
+  }
+  for (let si = 0; si < splitFacts.length; si++) {
+    if (splitMatched.has(si)) continue;
+    const key = splitGroupKey(splitFacts[si]);
+    if (!splitGroups.has(key)) splitGroups.set(key, []);
+    splitGroups.get(key).push(si);
+  }
+  for (const [key, splitIndices] of splitGroups) {
+    const baseIndices = baseGroups.get(key);
+    if (!baseIndices) continue;
+    const pairs = Math.min(baseIndices.length, splitIndices.length);
+    for (let i = 0; i < pairs; i++) {
+      const bi = baseIndices[i];
+      const si = splitIndices[i];
+      baseToSplit.set(bi, si);
+      splitToBase.set(si, bi);
+      baseMatched.add(bi);
+      splitMatched.add(si);
+    }
+  }
+
+  // Pass 3: Keyword overlap
+  for (let si = 0; si < splitFacts.length; si++) {
+    if (splitMatched.has(si)) continue;
+    const splitWords = extractKeywords(splitFacts[si].text);
+    if (splitWords.size === 0) continue;
+    let bestBi = -1;
+    let bestScore = 0;
+    for (let bi = 0; bi < baseFacts.length; bi++) {
+      if (baseMatched.has(bi)) continue;
+      const baseWords = extractKeywords(baseFacts[bi].text);
+      let shared = 0;
+      for (const w of splitWords) {
+        if (baseWords.has(w)) shared++;
+      }
+      if (shared > bestScore) {
+        bestScore = shared;
+        bestBi = bi;
+      }
+    }
+    if (bestBi >= 0 && bestScore >= 1) {
+      baseToSplit.set(bestBi, si);
+      splitToBase.set(si, bestBi);
+      baseMatched.add(bestBi);
+      splitMatched.add(si);
+    }
+  }
+
+  return { baseToSplit, splitToBase };
+}
+
+module.exports = { buildMatchTables, splitGroupKey, valueChanged, VALUE_KEYS };

package/src/facts/merge.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const { buildMatchTables, valueChanged, VALUE_KEYS } = require("./match");
+
+function mergeFacts(baseFacts, splitFacts, { complete = false } = {}) {
+  if (!splitFacts || splitFacts.length === 0) {
+    return baseFacts;
+  }
+
+  const { baseToSplit, splitToBase } = buildMatchTables(baseFacts, splitFacts);
+  const result = [];
+
+  for (let bi = 0; bi < baseFacts.length; bi++) {
+    const si = baseToSplit.get(bi);
+    if (si !== undefined) {
+      const merged = { ...baseFacts[bi] };
+      const splitFact = splitFacts[si];
+      let changed = false;
+      for (const key of VALUE_KEYS) {
+        if (splitFact[key] !== undefined) {
+          if (merged[key] !== splitFact[key]) {
+            changed = true;
+          }
+          merged[key] = splitFact[key];
+        }
+      }
+      if (changed) {
+        merged._splitFact = true;
+      }
+      result.push(merged);
+    } else if (!complete) {
+      result.push({ ...baseFacts[bi] });
+    }
+  }
+
+  for (let si = 0; si < splitFacts.length; si++) {
+    if (!splitToBase.has(si)) {
+      result.push({ ...splitFacts[si], _newFact: true });
+    }
+  }
+
+  return result;
+}
+
+module.exports = { mergeFacts };

package/src/facts/normalize.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const TYPE_ALIASES = {
+  Distance: "Radius",
+  PrefixedBuff: "Buff",
+  ApplyBuffCondition: "Buff",
+};
+
+function normalizeFactType(type) {
+  return TYPE_ALIASES[type] || type;
+}
+
+function stripGw2Markup(text) {
+  if (!text) return text;
+  return text.replace(/<c[^>]*>(.*?)<\/c>/g, "$1");
+}
+
+function stripWikiMarkup(text) {
+  if (!text) return text;
+  let result = text.replace(/\{\{fraction\|([^}]+)\}\}/g, "$1");
+  result = result.replace(/\{\{[^}]*\}\}/g, "");
+  result = result.replace(/\[\[[^\]]*\|([^\]]+)\]\]/g, "$1");
+  result = result.replace(/\[\[([^\]|]+)\]\]/g, "$1");
+  return result;
+}
+
+module.exports = { normalizeFactType, stripGw2Markup, stripWikiMarkup };

package/src/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const { WikiClient, WIKI_API_ROOT } = require("./wiki/client");
+const { MemoryCache, DiskCache } = require("./wiki/cache");
+const { Gw2ApiClient, GW2_API_ROOT } = require("./api/client");
+const {
+  parseSplitGrouping,
+  parseWikitextFacts,
+  mapWikiFactToApiFact,
+  parseInfoboxParams,
+} = require("./wiki/parser");
+const { parseRelatedItems, parseRelatedGroups } = require("./wiki/relations");
+const { mergeFacts } = require("./facts/merge");
+const { buildMatchTables, valueChanged, VALUE_KEYS } = require("./facts/match");
+const { normalizeFactType, stripGw2Markup, stripWikiMarkup } = require("./facts/normalize");
+const engine = require("./engine");
+
+module.exports = {
+  // Wiki layer
+  WikiClient,
+  WIKI_API_ROOT,
+
+  // GW2 API layer
+  Gw2ApiClient,
+  GW2_API_ROOT,
+
+  // Cache
+  MemoryCache,
+  DiskCache,
+
+  // Parser
+  parseSplitGrouping,
+  parseWikitextFacts,
+  mapWikiFactToApiFact,
+  parseInfoboxParams,
+
+  // Relations
+  parseRelatedItems,
+  parseRelatedGroups,
+
+  // Facts
+  mergeFacts,
+  buildMatchTables,
+  valueChanged,
+  VALUE_KEYS,
+  normalizeFactType,
+  stripGw2Markup,
+  stripWikiMarkup,
+
+  // Engine
+  StatEngine: engine.StatEngine,
+  computeAttributes: engine.computeAttributes,
+  computeSlotStats: engine.computeSlotStats,
+  collectModifiers: engine.collectModifiers,
+  computeTooltip: engine.computeTooltip,
+  analyzeBoons: engine.analyzeBoons,
+  analyzeCombos: engine.analyzeCombos,
+  loadOverrides: engine.loadOverrides,
+  buildInteractionGraph: engine.buildInteractionGraph,
+};

package/src/wiki/cache.js

@@ -0,0 +1,103 @@
+"use strict";
+
+/**
+ * @typedef {Object} CacheAdapter
+ * @property {(key: string) => any|null} get - Get value by key, null if missing/expired
+ * @property {(key: string, value: any, ttlMs: number) => void} set - Set value with TTL in milliseconds
+ * @property {(key: string) => void} invalidate - Remove a specific key
+ * @property {() => void} clear - Remove all entries
+ * @property {(key: string) => boolean} has - Check if key exists and is not expired
+ */
+
+class MemoryCache {
+  constructor() {
+    this._store = new Map();
+  }
+
+  get(key) {
+    const entry = this._store.get(key);
+    if (!entry) return null;
+    if (Date.now() >= entry.expiresAt) {
+      this._store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+
+  set(key, value, ttlMs) {
+    this._store.set(key, { value, expiresAt: Date.now() + ttlMs });
+  }
+
+  invalidate(key) {
+    this._store.delete(key);
+  }
+
+  clear() {
+    this._store.clear();
+  }
+
+  has(key) {
+    return this.get(key) !== null;
+  }
+}
+
+const fs = require("node:fs/promises");
+const path = require("node:path");
+
+class DiskCache {
+  constructor(dir) {
+    this._dir = dir;
+  }
+
+  _filePath(key) {
+    const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return path.join(this._dir, `${safeKey}.json`);
+  }
+
+  async get(key) {
+    try {
+      const raw = await fs.readFile(this._filePath(key), "utf-8");
+      const entry = JSON.parse(raw);
+      if (Date.now() >= entry.expiresAt) {
+        await this.invalidate(key);
+        return null;
+      }
+      return entry.value;
+    } catch {
+      return null;
+    }
+  }
+
+  async set(key, value, ttlMs) {
+    const entry = { value, expiresAt: Date.now() + ttlMs };
+    await fs.mkdir(this._dir, { recursive: true });
+    await fs.writeFile(this._filePath(key), JSON.stringify(entry), "utf-8");
+  }
+
+  async invalidate(key) {
+    try {
+      await fs.unlink(this._filePath(key));
+    } catch {
+      // File may not exist
+    }
+  }
+
+  async clear() {
+    try {
+      const files = await fs.readdir(this._dir);
+      await Promise.all(
+        files
+          .filter((f) => f.endsWith(".json"))
+          .map((f) => fs.unlink(path.join(this._dir, f)))
+      );
+    } catch {
+      // Directory may not exist
+    }
+  }
+
+  async has(key) {
+    return (await this.get(key)) !== null;
+  }
+}
+
+module.exports = { MemoryCache, DiskCache };