@axiapps/bridge-metrics 0.1.0

package/dist/chunk-RGXSI3AI.js

@@ -0,0 +1,298 @@
+// src/conditionsMetrics.ts
+var NON_DAMAGING_CONDITIONS = /* @__PURE__ */ new Set([
+  "Vulnerability",
+  "Weakness",
+  "Blind",
+  "Cripple",
+  "Chill",
+  "Immobilize",
+  "Slow",
+  "Fear",
+  "Taunt"
+]);
+var CONDITION_NAME_MAP = /* @__PURE__ */ new Map([
+  ["bleeding", "Bleeding"],
+  ["burning", "Burning"],
+  ["confusion", "Confusion"],
+  ["poison", "Poison"],
+  ["torment", "Torment"],
+  ["vulnerability", "Vulnerability"],
+  ["weakness", "Weakness"],
+  ["weakened", "Weakness"],
+  ["blind", "Blind"],
+  ["blinded", "Blind"],
+  ["blinding", "Blind"],
+  ["cripple", "Cripple"],
+  ["crippled", "Cripple"],
+  ["chill", "Chill"],
+  ["chilled", "Chill"],
+  ["immob", "Immobilize"],
+  ["immobile", "Immobilize"],
+  ["immobilized", "Immobilize"],
+  ["slow", "Slow"],
+  ["slowed", "Slow"],
+  ["fear", "Fear"],
+  ["feared", "Fear"],
+  ["taunt", "Taunt"],
+  ["taunted", "Taunt"]
+]);
+var DEFAULT_CONDITION_ICONS = {
+  Blind: "https://render.guildwars2.com/file/09770136BB76FD0DBE1CC4267DEED54774CB20F6/102837.png",
+  Chill: "https://render.guildwars2.com/file/28C4EC547A3516AF0242E826772DA43A5EAC3DF3/102839.png",
+  Cripple: "https://render.guildwars2.com/file/070325E519C178D502A8160523766070D30C0C19/102838.png",
+  Fear: "https://render.guildwars2.com/file/30307A6E766D74B6EB09EDA12A4A2DE50E4D76F4/102869.png",
+  Immobilize: "https://render.guildwars2.com/file/397A613651BFCA2832B6469CE34735580A2C120E/102844.png",
+  Slow: "https://render.guildwars2.com/file/F60D1EF5271D7B9319610855676D320CD25F01C6/961397.png",
+  Taunt: "https://render.guildwars2.com/file/02EED459AD65FAF7DF32A260E479C625070841B9/1228472.png",
+  Vulnerability: "https://render.guildwars2.com/file/3A394C1A0A3257EB27A44842DDEEF0DF000E1241/102850.png",
+  Weakness: "https://render.guildwars2.com/file/6CB0E64AF9AA292E332A38C1770CE577E2CDE0E8/102853.png"
+};
+var getDefaultConditionIcon = (name) => {
+  if (!name) return void 0;
+  return DEFAULT_CONDITION_ICONS[name];
+};
+var resolveBuffMetaById = (buffMap, id) => {
+  if (!buffMap || id === void 0 || id === null) return void 0;
+  const numericId = Number(id);
+  if (Number.isFinite(numericId)) {
+    return buffMap[`b${numericId}`] || buffMap[String(numericId)];
+  }
+  return buffMap[String(id)];
+};
+var getConditionName = (name) => {
+  if (!name) return null;
+  const cleaned = name.trim().toLowerCase();
+  const directMatch = CONDITION_NAME_MAP.get(cleaned);
+  if (directMatch) return directMatch;
+  const tokens = cleaned.split(/[^a-z]+/).filter(Boolean);
+  for (const token of tokens) {
+    const match = CONDITION_NAME_MAP.get(token);
+    if (match) return match;
+  }
+  return null;
+};
+var normalizeConditionLabel = (name) => getConditionName(name);
+var buildConditionIconMap = (buffMap) => {
+  const map = /* @__PURE__ */ new Map();
+  if (!buffMap) return map;
+  Object.values(buffMap).forEach((meta) => {
+    if (!meta?.icon || !meta?.name) return;
+    const normalized = getConditionName(meta.name);
+    if (!normalized) return;
+    if (!map.has(normalized)) map.set(normalized, meta.icon);
+  });
+  Object.entries(DEFAULT_CONDITION_ICONS).forEach(([name, icon]) => {
+    if (!map.has(name)) map.set(name, icon);
+  });
+  return map;
+};
+var resolveConditionNameFromEntry = (skillName, id, buffMap) => {
+  if (id && buffMap) {
+    const buffName = resolveBuffMetaById(buffMap, id)?.name;
+    const resolved = getConditionName(buffName);
+    if (resolved) return resolved;
+  }
+  if (!skillName) return null;
+  return getConditionName(skillName);
+};
+var defaultGetPlayerKey = (player) => {
+  const account = player?.account || "Unknown";
+  if (account && account !== "Unknown") return account;
+  const name = player?.name || "Unknown";
+  return name || null;
+};
+var countAppliedFromStates = (states) => {
+  if (!states || states.length === 0) return 0;
+  let applied = 0;
+  let prev = null;
+  states.forEach((entry) => {
+    const value = Number(entry[1] ?? 0);
+    if (!Number.isFinite(value)) return;
+    if (prev === null) {
+      prev = value;
+      return;
+    }
+    if (value > prev) {
+      applied += value - prev;
+    }
+    prev = value;
+  });
+  return applied;
+};
+var computeUptimeFromStates = (states) => {
+  if (!states || states.length === 0) return 0;
+  let uptimeMs = 0;
+  let buffOn = 0;
+  let firstTime = 0;
+  for (const [time, value] of states) {
+    if (time === 0) continue;
+    if (value >= 1 && buffOn === 0) {
+      buffOn = value;
+      firstTime = time;
+    } else if (value === 0 && buffOn > 0) {
+      uptimeMs += time - firstTime;
+      buffOn = 0;
+    }
+  }
+  return uptimeMs;
+};
+var countActiveStateEntries = (states) => {
+  if (!states || states.length === 0) return 0;
+  let count = 0;
+  states.forEach((entry) => {
+    const time = Number(entry[0] ?? 0);
+    const value = Number(entry[1] ?? 0);
+    if (!Number.isFinite(value)) return;
+    if (time === 0) return;
+    if (value > 0) count += 1;
+  });
+  return count;
+};
+var computeOutgoingConditions = (payload) => {
+  const { players, targets, skillMap, buffMap } = payload;
+  const getPlayerKey = payload.getPlayerKey || defaultGetPlayerKey;
+  const conditionIconMap = buildConditionIconMap(buffMap);
+  const playerConditions = {};
+  const summary = {};
+  players.forEach((player) => {
+    if (player?.notInSquad) return;
+    const key = getPlayerKey(player);
+    if (!key) return;
+    if (!playerConditions[key]) {
+      playerConditions[key] = {};
+    }
+    if (!player?.totalDamageDist) return;
+    player.totalDamageDist.forEach((distList) => {
+      if (!distList) return;
+      distList.forEach((entry) => {
+        if (!entry.id) return;
+        let skillName = `Skill ${entry.id}`;
+        let skillIcon;
+        if (skillMap) {
+          if (skillMap[`s${entry.id}`]) {
+            skillName = skillMap[`s${entry.id}`].name || skillName;
+            skillIcon = skillMap[`s${entry.id}`].icon || skillIcon;
+          } else if (skillMap[`${entry.id}`]) {
+            skillName = skillMap[`${entry.id}`].name || skillName;
+            skillIcon = skillMap[`${entry.id}`].icon || skillIcon;
+          }
+        }
+        const buffMeta = resolveBuffMetaById(buffMap, entry.id);
+        if (skillName.startsWith("Skill ") && buffMeta?.name) {
+          skillName = buffMeta.name;
+          skillIcon = buffMeta.icon || skillIcon;
+        }
+        const conditionName = resolveConditionNameFromEntry(skillName, entry.id, buffMap);
+        if (!conditionName) return;
+        const buffName = buffMeta?.name;
+        const conditionIcon = conditionIconMap.get(conditionName) || buffMeta?.icon;
+        const skillLabel = skillName.startsWith("Skill ") ? buffName || conditionName : skillName;
+        const skillLabelIcon = skillIcon || buffMeta?.icon;
+        const connectedHits = Number(entry.connectedHits ?? 0);
+        const rawHits = Number(entry.hits ?? 0);
+        const hits = connectedHits > 0 ? connectedHits : rawHits;
+        const damage = Number(entry.totalDamage ?? 0);
+        if (!Number.isFinite(hits) && !Number.isFinite(damage)) return;
+        const existing = summary[conditionName] || {
+          name: conditionName,
+          icon: conditionIcon,
+          applications: 0,
+          damage: 0
+        };
+        existing.applications += Number.isFinite(hits) ? hits : 0;
+        existing.damage += Number.isFinite(damage) ? damage : 0;
+        if (!existing.icon && conditionIcon) existing.icon = conditionIcon;
+        summary[conditionName] = existing;
+        const playerConditionTotals = playerConditions[key][conditionName] || {
+          icon: conditionIcon,
+          applications: 0,
+          damage: 0,
+          skills: {}
+        };
+        playerConditionTotals.applications += Number.isFinite(hits) ? hits : 0;
+        playerConditionTotals.damage += Number.isFinite(damage) ? damage : 0;
+        const skillEntry = playerConditionTotals.skills[skillLabel] || { name: skillLabel, hits: 0, damage: 0, icon: skillLabelIcon };
+        skillEntry.hits += Number.isFinite(hits) ? hits : 0;
+        skillEntry.damage += Number.isFinite(damage) ? damage : 0;
+        if (!skillEntry.icon && skillLabelIcon) skillEntry.icon = skillLabelIcon;
+        playerConditionTotals.skills[skillLabel] = skillEntry;
+        if (!playerConditionTotals.icon && conditionIcon) playerConditionTotals.icon = conditionIcon;
+        playerConditions[key][conditionName] = playerConditionTotals;
+      });
+    });
+  });
+  const nameToKey = /* @__PURE__ */ new Map();
+  players.forEach((player) => {
+    if (player?.notInSquad) return;
+    const key = getPlayerKey(player);
+    if (!key) return;
+    if (player?.name) {
+      nameToKey.set(player.name, key);
+    }
+  });
+  let buffStateApplicationsTotal = 0;
+  let buffStateSourcesSeen = 0;
+  let targetBuffEntriesSeen = 0;
+  targets.forEach((target) => {
+    if (!target?.buffs) return;
+    target.buffs.forEach((buff) => {
+      const buffId = Number(buff?.id);
+      if (!Number.isFinite(buffId)) return;
+      const buffMeta = resolveBuffMetaById(buffMap, buffId);
+      const normalizedName = getConditionName(buffMeta?.name);
+      if (!normalizedName) return;
+      if (buffMeta?.classification && buffMeta.classification !== "Condition") return;
+      const conditionName = normalizedName;
+      if (!conditionName) return;
+      const statesPerSource = buff.statesPerSource || {};
+      targetBuffEntriesSeen += 1;
+      Object.entries(statesPerSource).forEach(([sourceName, states]) => {
+        const key = nameToKey.get(sourceName);
+        if (!key) return;
+        buffStateSourcesSeen += 1;
+        const appliedCounts = countAppliedFromStates(states);
+        const activeCounts = countActiveStateEntries(states);
+        const uptimeMs = computeUptimeFromStates(states);
+        buffStateApplicationsTotal += appliedCounts;
+        const playerConditionTotals = playerConditions[key]?.[conditionName] || {
+          applications: 0,
+          damage: 0,
+          skills: {}
+        };
+        playerConditionTotals.applicationsFromBuffs = (playerConditionTotals.applicationsFromBuffs || 0) + appliedCounts;
+        playerConditionTotals.applicationsFromBuffsActive = (playerConditionTotals.applicationsFromBuffsActive || 0) + activeCounts;
+        playerConditionTotals.uptimeMs = (playerConditionTotals.uptimeMs || 0) + uptimeMs;
+        playerConditions[key] = playerConditions[key] || {};
+        playerConditions[key][conditionName] = playerConditionTotals;
+        const overallTotals = summary[conditionName] || {
+          name: conditionName,
+          applications: 0,
+          damage: 0
+        };
+        overallTotals.applicationsFromBuffs = (overallTotals.applicationsFromBuffs || 0) + appliedCounts;
+        overallTotals.applicationsFromBuffsActive = (overallTotals.applicationsFromBuffsActive || 0) + activeCounts;
+        overallTotals.uptimeMs = (overallTotals.uptimeMs || 0) + uptimeMs;
+        summary[conditionName] = overallTotals;
+      });
+    });
+  });
+  return {
+    playerConditions,
+    summary,
+    meta: {
+      buffStateApplicationsTotal,
+      targetBuffEntriesSeen,
+      buffStateSourcesSeen
+    }
+  };
+};
+
+export {
+  NON_DAMAGING_CONDITIONS,
+  getDefaultConditionIcon,
+  resolveBuffMetaById,
+  normalizeConditionLabel,
+  buildConditionIconMap,
+  resolveConditionNameFromEntry,
+  computeOutgoingConditions
+};

package/dist/chunk-UFJJ6WLD.js

@@ -0,0 +1,197 @@
+// src/reportMetrics.ts
+var ReportSchemaError = class extends Error {
+};
+var num = (value) => {
+  const n = Number(value ?? 0);
+  return Number.isFinite(n) ? n : 0;
+};
+var extractRunSummary = (report) => {
+  const payload = report;
+  const id = String(payload?.meta?.id ?? "").trim();
+  if (!id) throw new ReportSchemaError("report has no meta.id \u2014 not an AxiBridge report.json");
+  const stats = payload?.stats ?? {};
+  const warnings = [];
+  const byAccount = /* @__PURE__ */ new Map();
+  const ensure = (row) => {
+    const account = String(row?.account ?? "").trim();
+    if (!account || account === "Unknown") return null;
+    let entry = byAccount.get(account);
+    if (!entry) {
+      entry = {
+        account,
+        profession: String(row?.profession ?? "Unknown"),
+        professionList: Array.isArray(row?.professionList) ? row.professionList.map(String) : [],
+        combatTimeMs: 0,
+        squadTimeMs: 0,
+        classTimes: [],
+        damage: 0,
+        downContribution: 0,
+        kills: 0,
+        downsCaused: 0,
+        strips: 0,
+        cleanses: 0,
+        resurrects: 0,
+        healing: 0,
+        barrier: 0,
+        hasHealAddon: false,
+        damageTaken: 0,
+        downs: 0,
+        deaths: 0,
+        logsJoined: 0
+      };
+      byAccount.set(account, entry);
+    }
+    return entry;
+  };
+  const tables = ["offensePlayers", "supportPlayers", "healingPlayers", "defensePlayers", "generalPlayers", "attendanceData"];
+  if (!tables.some((key) => Array.isArray(stats?.[key]) && stats[key].length > 0)) {
+    warnings.push("no player tables in report");
+  }
+  for (const row of Array.isArray(stats?.offensePlayers) ? stats.offensePlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.damage += num(row?.offenseTotals?.damage);
+    p.downContribution += num(row?.offenseTotals?.downContribution);
+    p.kills += num(row?.offenseTotals?.killed);
+    p.downsCaused += num(row?.offenseTotals?.downed);
+    p.strips = Math.max(p.strips, num(row?.offenseTotals?.boonStrips));
+  }
+  for (const row of Array.isArray(stats?.supportPlayers) ? stats.supportPlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.cleanses += num(row?.supportTotals?.condiCleanse);
+    p.strips = Math.max(p.strips, num(row?.supportTotals?.boonStrips));
+    p.resurrects += num(row?.supportTotals?.resurrects);
+    p.logsJoined = Math.max(p.logsJoined, num(row?.logsJoined));
+  }
+  for (const row of Array.isArray(stats?.healingPlayers) ? stats.healingPlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.healing += num(row?.healingTotals?.squadHealing ?? row?.healingTotals?.healing);
+    p.barrier += num(row?.healingTotals?.squadBarrier ?? row?.healingTotals?.barrier);
+    if (row?.hasHealAddon === true) p.hasHealAddon = true;
+  }
+  for (const row of Array.isArray(stats?.defensePlayers) ? stats.defensePlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.damageTaken += num(row?.defenseTotals?.damageTaken);
+    p.downs += num(row?.defenseTotals?.downCount);
+    p.deaths += num(row?.defenseTotals?.deadCount);
+  }
+  for (const row of Array.isArray(stats?.generalPlayers) ? stats.generalPlayers : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.combatTimeMs = Math.max(p.combatTimeMs, num(row?.squadActiveMs ?? row?.totalFightMs));
+    p.logsJoined = Math.max(p.logsJoined, num(row?.logsJoined));
+  }
+  for (const row of Array.isArray(stats?.attendanceData) ? stats.attendanceData : []) {
+    const p = ensure(row);
+    if (!p) continue;
+    p.combatTimeMs = Math.max(p.combatTimeMs, num(row?.combatTimeMs));
+    p.squadTimeMs = Math.max(p.squadTimeMs, num(row?.squadTimeMs));
+    if (Array.isArray(row?.classTimes)) {
+      p.classTimes = row.classTimes.map((c) => ({ profession: String(c?.profession ?? ""), timeMs: num(c?.timeMs) })).filter((c) => c.profession && c.timeMs > 0);
+    }
+  }
+  return {
+    id,
+    title: String(payload?.meta?.title ?? id),
+    dateStart: payload?.meta?.dateStart ?? null,
+    dateEnd: payload?.meta?.dateEnd ?? null,
+    fights: num(stats?.total),
+    wins: num(stats?.wins),
+    losses: num(stats?.losses),
+    avgSquadSize: typeof stats?.avgSquadSize === "number" ? stats.avgSquadSize : null,
+    avgEnemies: typeof stats?.avgEnemies === "number" ? stats.avgEnemies : null,
+    squadDeaths: num(stats?.totalSquadDeaths),
+    squadDowns: num(stats?.totalSquadDowns),
+    enemyDeaths: num(stats?.totalEnemyDeaths),
+    enemyDowns: num(stats?.totalEnemyDowns),
+    commanders: Array.isArray(payload?.meta?.commanders) ? payload.meta.commanders.map(String) : [],
+    players: Array.from(byAccount.values()),
+    warnings
+  };
+};
+var aggregatePlayers = (summaries, accounts) => {
+  const wanted = accounts && accounts.length > 0 ? new Set(accounts.map((a) => a.toLowerCase())) : null;
+  const map = /* @__PURE__ */ new Map();
+  for (const run of summaries) {
+    for (const p of run.players) {
+      if (wanted && !wanted.has(p.account.toLowerCase())) continue;
+      let agg = map.get(p.account);
+      if (!agg) {
+        agg = {
+          account: p.account,
+          runsJoined: 0,
+          combatTimeMs: 0,
+          squadTimeMs: 0,
+          professionTimeMs: {},
+          damage: 0,
+          dps: 0,
+          downContribution: 0,
+          kills: 0,
+          strips: 0,
+          cleanses: 0,
+          resurrects: 0,
+          healing: 0,
+          barrier: 0,
+          damageTaken: 0,
+          downs: 0,
+          deaths: 0,
+          lastSeen: null
+        };
+        map.set(p.account, agg);
+      }
+      agg.runsJoined += 1;
+      agg.combatTimeMs += p.combatTimeMs;
+      agg.squadTimeMs += p.squadTimeMs;
+      for (const c of p.classTimes) {
+        agg.professionTimeMs[c.profession] = (agg.professionTimeMs[c.profession] || 0) + c.timeMs;
+      }
+      agg.damage += p.damage;
+      agg.downContribution += p.downContribution;
+      agg.kills += p.kills;
+      agg.strips += p.strips;
+      agg.cleanses += p.cleanses;
+      agg.resurrects += p.resurrects;
+      agg.healing += p.healing;
+      agg.barrier += p.barrier;
+      agg.damageTaken += p.damageTaken;
+      agg.downs += p.downs;
+      agg.deaths += p.deaths;
+      const seen = run.dateEnd ?? run.dateStart;
+      if (seen && (!agg.lastSeen || seen > agg.lastSeen)) agg.lastSeen = seen;
+    }
+  }
+  const rows = Array.from(map.values());
+  for (const row of rows) {
+    row.dps = row.combatTimeMs > 0 ? row.damage / (row.combatTimeMs / 1e3) : 0;
+  }
+  return rows.sort((a, b) => b.damage - a.damage);
+};
+var RUN_SET_METRICS = [
+  "fights",
+  "wins",
+  "losses",
+  "squadDeaths",
+  "squadDowns",
+  "enemyDeaths",
+  "enemyDowns"
+];
+var compareRunSets = (a, b) => {
+  const total = (runs, metric) => runs.reduce((sum, run) => sum + num(run[metric]), 0);
+  return {
+    metrics: RUN_SET_METRICS.map((metric) => {
+      const va = total(a, metric);
+      const vb = total(b, metric);
+      return { metric, a: va, b: vb, delta: vb - va, deltaPct: va !== 0 ? (vb - va) / va : null };
+    })
+  };
+};
+
+export {
+  ReportSchemaError,
+  extractRunSummary,
+  aggregatePlayers,
+  compareRunSets
+};