@axiapps/bridge-metrics 0.1.0

package/dist/chunk-PMVLNDZZ.js

@@ -0,0 +1,279 @@
+// src/boonGeneration.ts
+var BOON_CATEGORIES = ["selfBuffs", "groupBuffs", "squadBuffs"];
+var CATEGORY_COUNT = {
+  selfBuffs: () => 1,
+  groupBuffs: (groupCount) => Math.max(groupCount - 1, 0),
+  squadBuffs: (_groupCount, squadCount) => Math.max(squadCount - 1, 0)
+};
+var safeDiv = (a, b, fallback = 0) => b ? a / b : fallback;
+var isBoon = (meta) => {
+  if (!meta?.classification) return true;
+  return meta.classification === "Boon";
+};
+var toBoonId = (id) => `b${id}`;
+var getActiveTimeMs = (player, fallbackMs) => {
+  const activeTimes = Array.isArray(player?.activeTimes) ? player.activeTimes : [];
+  const activeMs = typeof activeTimes[0] === "number" ? activeTimes[0] : 0;
+  return activeMs > 0 ? activeMs : fallbackMs;
+};
+var computeGenerationMs = (category, stacking, generation, wasted, durationMs, groupCount, squadCount) => {
+  const count = CATEGORY_COUNT[category](groupCount, squadCount);
+  if (!count || !durationMs) {
+    return { generationMs: 0, wastedMs: 0 };
+  }
+  if (stacking) {
+    return {
+      generationMs: generation * durationMs * count,
+      wastedMs: wasted * durationMs * count
+    };
+  }
+  return {
+    generationMs: generation / 100 * durationMs * count,
+    wastedMs: wasted / 100 * durationMs * count
+  };
+};
+var computeBoonMetrics = (row, category, stacking) => {
+  const activeTimeMs = row.activeTimeMs || 1;
+  const numFights = row.numFights || 1;
+  const groupSupported = row.groupSupported || 1;
+  const squadSupported = row.squadSupported || 1;
+  const selfData = row.categories.selfBuffs;
+  const squadData = row.categories.squadBuffs;
+  const sourceData = category === "totalBuffs" ? {
+    generationMs: selfData.generationMs + squadData.generationMs,
+    wastedMs: selfData.wastedMs + squadData.wastedMs
+  } : row.categories[category];
+  const generationMs = sourceData.generationMs;
+  const wastedMs = sourceData.wastedMs;
+  let denom = 1;
+  if (category === "groupBuffs") {
+    denom = safeDiv(groupSupported - numFights, numFights, 1);
+  } else if (category === "squadBuffs") {
+    denom = safeDiv(squadSupported - numFights, numFights, 1);
+  } else if (category === "totalBuffs") {
+    denom = squadSupported || 1;
+  }
+  let uptimeRaw = 0;
+  let wastedRaw = 0;
+  if (category === "selfBuffs") {
+    uptimeRaw = stacking ? safeDiv(generationMs, activeTimeMs) : safeDiv(generationMs, activeTimeMs) * 100;
+    wastedRaw = stacking ? safeDiv(wastedMs, activeTimeMs) : safeDiv(wastedMs, activeTimeMs) * 100;
+  } else {
+    const base = safeDiv(generationMs, activeTimeMs) / (denom || 1);
+    const wastedBase = safeDiv(wastedMs, activeTimeMs) / (denom || 1);
+    uptimeRaw = stacking ? base : base * 100;
+    wastedRaw = stacking ? wastedBase : wastedBase * 100;
+  }
+  return { generationMs, wastedMs, uptimeRaw, wastedRaw };
+};
+var getBoonMetricValue = (row, category, stacking, metric) => {
+  const { generationMs, uptimeRaw } = computeBoonMetrics(row, category, stacking);
+  const activeTimeMs = row.activeTimeMs || 1;
+  if (metric === "total") {
+    return generationMs / 1e3;
+  }
+  if (metric === "average") {
+    return safeDiv(generationMs, activeTimeMs);
+  }
+  return uptimeRaw;
+};
+var formatBoonMetricDisplay = (row, category, stacking, metric, options) => {
+  const value = getBoonMetricValue(row, category, stacking, metric);
+  const isPercent = metric === "uptime" && !stacking;
+  const isRate = metric === "average";
+  const decimals = options?.roundCountStats && !isPercent && !isRate ? 0 : 2;
+  const formatted = value.toLocaleString(void 0, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+  if (isPercent) {
+    return `${formatted}%`;
+  }
+  return formatted;
+};
+var buildBoonTables = (logs, splitPlayersByClass = false) => {
+  const boonMeta = /* @__PURE__ */ new Map();
+  const playerAgg = /* @__PURE__ */ new Map();
+  logs.forEach((log) => {
+    const details = log.details;
+    if (!details) return;
+    const durationMs = details.durationMS || 0;
+    const buffMap = details.buffMap || {};
+    Object.entries(buffMap).forEach(([id, meta]) => {
+      if (!boonMeta.has(id)) {
+        boonMeta.set(id, meta);
+        return;
+      }
+      const existing = boonMeta.get(id) || {};
+      const merged = {
+        name: existing.name || meta.name,
+        stacking: existing.stacking ?? meta.stacking,
+        icon: existing.icon || meta.icon,
+        classification: existing.classification || meta.classification
+      };
+      boonMeta.set(id, merged);
+    });
+    const players = details.players || [];
+    const squadPlayers = players.filter((p) => !p.notInSquad);
+    const squadCount = squadPlayers.length;
+    const groupCounts = /* @__PURE__ */ new Map();
+    squadPlayers.forEach((player) => {
+      const group = player.group ?? 0;
+      groupCounts.set(group, (groupCounts.get(group) || 0) + 1);
+    });
+    squadPlayers.forEach((player) => {
+      const account = player.account || player.name || player.character_name || "Unknown";
+      const profession = player.profession || "Unknown";
+      const group = player.group ?? 0;
+      const groupCount = groupCounts.get(group) || 1;
+      const activeTimeMs = getActiveTimeMs(player, durationMs);
+      const key = splitPlayersByClass && profession !== "Unknown" ? `${account}::${profession}` : account;
+      if (!playerAgg.has(key)) {
+        playerAgg.set(key, {
+          account,
+          profession,
+          professions: /* @__PURE__ */ new Set(),
+          professionTimeMs: {},
+          activeTimeMs: 0,
+          numFights: 0,
+          groupSupported: 0,
+          squadSupported: 0,
+          boons: {}
+        });
+      }
+      const agg = playerAgg.get(key);
+      agg.profession = profession;
+      if (profession && profession !== "Unknown") {
+        agg.professions.add(profession);
+        agg.professionTimeMs[profession] = (agg.professionTimeMs[profession] || 0) + activeTimeMs;
+      }
+      agg.activeTimeMs += activeTimeMs;
+      agg.numFights += 1;
+      agg.groupSupported += groupCount;
+      agg.squadSupported += squadCount;
+      BOON_CATEGORIES.forEach((category) => {
+        const buffs = player[category] || [];
+        buffs.forEach((buff) => {
+          if (typeof buff?.id !== "number") return;
+          const boonId = toBoonId(buff.id);
+          const meta = buffMap[boonId];
+          if (!isBoon(meta)) return;
+          const stacking = meta?.stacking ?? false;
+          const generation = buff.buffData?.[0]?.generation ?? 0;
+          const wasted = buff.buffData?.[0]?.wasted ?? 0;
+          const { generationMs, wastedMs } = computeGenerationMs(
+            category,
+            stacking,
+            generation,
+            wasted,
+            durationMs,
+            groupCount,
+            squadCount
+          );
+          if (!generationMs && !wastedMs) return;
+          if (!boonMeta.has(boonId)) {
+            boonMeta.set(boonId, meta || {});
+          }
+          if (!agg.boons[boonId]) {
+            agg.boons[boonId] = {
+              selfBuffs: { generationMs: 0, wastedMs: 0 },
+              groupBuffs: { generationMs: 0, wastedMs: 0 },
+              squadBuffs: { generationMs: 0, wastedMs: 0 }
+            };
+          }
+          agg.boons[boonId][category].generationMs += generationMs;
+          agg.boons[boonId][category].wastedMs += wastedMs;
+        });
+      });
+    });
+  });
+  const boonIds = Array.from(boonMeta.keys()).filter((id) => isBoon(boonMeta.get(id)));
+  const boonTables = boonIds.map((boonId) => {
+    const meta = boonMeta.get(boonId) || {};
+    const rows = [];
+    playerAgg.forEach((agg) => {
+      const boonData = agg.boons[boonId];
+      if (!boonData) return;
+      const hasData = BOON_CATEGORIES.some((category) => boonData[category].generationMs > 0 || boonData[category].wastedMs > 0);
+      if (!hasData) return;
+      const professionList = Array.from(agg.professions || []).filter((prof) => prof && prof !== "Unknown");
+      let primaryProfession = agg.profession;
+      if (professionList.length > 0) {
+        primaryProfession = professionList[0];
+        let maxTime = agg.professionTimeMs?.[primaryProfession] || 0;
+        professionList.forEach((prof) => {
+          const time = agg.professionTimeMs?.[prof] || 0;
+          if (time > maxTime) {
+            maxTime = time;
+            primaryProfession = prof;
+          }
+        });
+      }
+      rows.push({
+        account: agg.account,
+        profession: primaryProfession || "Unknown",
+        professionList,
+        activeTimeMs: agg.activeTimeMs || 1,
+        numFights: agg.numFights || 1,
+        groupSupported: agg.groupSupported || 1,
+        squadSupported: agg.squadSupported || 1,
+        categories: {
+          selfBuffs: { ...boonData.selfBuffs },
+          groupBuffs: { ...boonData.groupBuffs },
+          squadBuffs: { ...boonData.squadBuffs }
+        }
+      });
+    });
+    return {
+      id: boonId,
+      name: meta.name || boonId,
+      icon: meta.icon,
+      stacking: meta.stacking ?? false,
+      rows
+    };
+  }).filter((boon) => boon.rows.length > 0);
+  return { boonTables };
+};
+var buildBoonLeaderboards = (tables, metric = "uptime") => {
+  const result = {};
+  for (const table of tables) {
+    const ranked = table.rows.map((row) => ({
+      account: row.account,
+      profession: row.profession,
+      professionList: row.professionList,
+      value: getBoonMetricValue(row, "squadBuffs", table.stacking, metric),
+      count: row.numFights
+    })).filter((r) => Number.isFinite(r.value) && r.value > 0).sort((a, b) => b.value - a.value || a.account.localeCompare(b.account));
+    let lastValue = null;
+    let lastRank = 0;
+    result[table.id] = ranked.map((row, index) => {
+      if (lastValue === null || row.value !== lastValue) {
+        lastRank = index + 1;
+        lastValue = row.value;
+      }
+      return { ...row, rank: lastRank };
+    });
+  }
+  return result;
+};
+var getPlayerBoonGenerationMs = (player, category, boonId, durationMs, groupCount, squadCount, buffMap = {}) => {
+  const buffs = player?.[category] || [];
+  const target = buffs.find((buff) => buff.id === boonId);
+  if (!target) {
+    return { generationMs: 0, wastedMs: 0 };
+  }
+  const meta = buffMap[toBoonId(boonId)];
+  const stacking = meta?.stacking ?? false;
+  const generation = target.buffData?.[0]?.generation ?? 0;
+  const wasted = target.buffData?.[0]?.wasted ?? 0;
+  return computeGenerationMs(category, stacking, generation, wasted, durationMs, groupCount, squadCount);
+};
+
+export {
+  computeBoonMetrics,
+  getBoonMetricValue,
+  formatBoonMetricDisplay,
+  buildBoonTables,
+  buildBoonLeaderboards,
+  getPlayerBoonGenerationMs
+};

package/dist/chunk-R5EJF5AW.js

@@ -0,0 +1,147 @@
+import {
+  STABILITY_BOON_ID
+} from "./chunk-ZFZS7JFU.js";
+import {
+  getPlayerBoonGenerationMs
+} from "./chunk-PMVLNDZZ.js";
+import {
+  DEFAULT_DISRUPTION_METHOD,
+  METRICS_SPEC
+} from "./chunk-KRHODGVU.js";
+
+// src/combatMetrics.ts
+var toSeconds = (ms) => (ms || 0) / 1e3;
+var applyTierWeight = (count, durationMs) => {
+  if (!count) return 0;
+  const tiers = METRICS_SPEC.methods.tiered?.tiers;
+  if (!tiers) return count;
+  const avg = durationMs / Math.max(count, 1);
+  if (avg <= tiers.shortMs) return count * tiers.weights.short;
+  if (avg <= tiers.mediumMs) return count * tiers.weights.medium;
+  return count * tiers.weights.long;
+};
+var resolveDisruptionValue = (count, durationMs, method) => {
+  if (method === "duration") return toSeconds(durationMs);
+  if (method === "tiered") return applyTierWeight(count, durationMs);
+  return count;
+};
+function computeOutgoingCrowdControl(player, method = DEFAULT_DISRUPTION_METHOD) {
+  const stats = player.statsAll?.[0];
+  const count = Number(stats?.appliedCrowdControl ?? 0);
+  const durationMs = Number(stats?.appliedCrowdControlDuration ?? 0);
+  return resolveDisruptionValue(count, durationMs, method);
+}
+function computeIncomingDisruptions(player, method = DEFAULT_DISRUPTION_METHOD) {
+  const defenses = player.defenses?.[0];
+  const incomingCcCount = Number(defenses?.receivedCrowdControl ?? 0);
+  const incomingCcDurationMs = Number(defenses?.receivedCrowdControlDuration ?? 0);
+  const incomingStripCount = Number(defenses?.boonStrips ?? 0);
+  const incomingStripDurationMs = Number(defenses?.boonStripsTime ?? 0);
+  const resolveValue = (count, durationMs) => resolveDisruptionValue(count, durationMs, method);
+  return {
+    strips: {
+      total: resolveValue(incomingStripCount, incomingStripDurationMs),
+      missed: 0,
+      blocked: 0
+    },
+    cc: {
+      total: resolveValue(incomingCcCount, incomingCcDurationMs),
+      missed: 0,
+      blocked: 0
+    }
+  };
+}
+function applySquadStabilityGeneration(players, context) {
+  const durationMs = context?.durationMS || 0;
+  const buffMap = context?.buffMap || {};
+  const squadPlayers = players.filter((p) => !p.notInSquad);
+  const squadCount = squadPlayers.length;
+  const groupCounts = /* @__PURE__ */ new Map();
+  squadPlayers.forEach((player) => {
+    const group = player.group ?? 0;
+    groupCounts.set(group, (groupCounts.get(group) || 0) + 1);
+  });
+  squadPlayers.forEach((player) => {
+    const groupCount = groupCounts.get(player.group ?? 0) || 1;
+    const self = getPlayerBoonGenerationMs(
+      player,
+      "selfBuffs",
+      STABILITY_BOON_ID,
+      durationMs,
+      groupCount,
+      squadCount,
+      buffMap
+    );
+    const squad = getPlayerBoonGenerationMs(
+      player,
+      "squadBuffs",
+      STABILITY_BOON_ID,
+      durationMs,
+      groupCount,
+      squadCount,
+      buffMap
+    );
+    player.stabGeneration = (self.generationMs + squad.generationMs) / 1e3;
+  });
+}
+function computeDownContribution(player) {
+  if (player.statsAll && player.statsAll.length > 0) {
+    const val = player.statsAll[0].downContribution;
+    if (typeof val === "number" && val > 0) return val;
+  }
+  let total = 0;
+  if (player.totalDamageDist) {
+    for (const targetList of player.totalDamageDist) {
+      if (targetList) {
+        for (const entry of targetList) {
+          total += entry.downContribution || 0;
+        }
+      }
+    }
+  }
+  if (total > 0) return total;
+  if (player.statsTargets) {
+    for (const targetStats of player.statsTargets) {
+      if (targetStats && targetStats.length > 0) {
+        total += targetStats[0].downContribution || 0;
+      }
+    }
+  }
+  return total;
+}
+function computeSquadBarrier(player) {
+  if (!player.extBarrierStats || !player.extBarrierStats.outgoingBarrierAllies) return 0;
+  let total = 0;
+  for (const squadMember of player.extBarrierStats.outgoingBarrierAllies) {
+    if (!squadMember) continue;
+    for (const phaseData of squadMember) {
+      if (phaseData) {
+        total += phaseData.barrier || 0;
+      }
+    }
+  }
+  return total;
+}
+function computeSquadHealing(player) {
+  if (!player.extHealingStats || !player.extHealingStats.outgoingHealingAllies) return 0;
+  let total = 0;
+  for (const squadMember of player.extHealingStats.outgoingHealingAllies) {
+    if (!squadMember) continue;
+    for (const phaseData of squadMember) {
+      if (phaseData) {
+        total += phaseData.healing || 0;
+      }
+    }
+  }
+  return total;
+}
+
+export {
+  resolveDisruptionValue,
+  computeOutgoingCrowdControl,
+  computeIncomingDisruptions,
+  applySquadStabilityGeneration,
+  computeDownContribution,
+  computeSquadBarrier,
+  computeSquadHealing
+};