@axiapps/bridge-metrics 0.1.0

package/dist/aggregationTypes.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/aggregationTypes.ts
+var aggregationTypes_exports = {};
+module.exports = __toCommonJS(aggregationTypes_exports);

package/dist/aggregationTypes.d.cts

@@ -0,0 +1,21 @@
+interface PlayerSkillDamageEntry {
+    id: string;
+    name: string;
+    icon?: string;
+    damage: number;
+    downContribution: number;
+    hits: number;
+    casts: number;
+    min: number;
+    max: number;
+}
+interface PlayerHealingSkillEntry {
+    id: string;
+    name: string;
+    icon?: string;
+    total: number;
+    hits: number;
+    max: number;
+}
+
+export type { PlayerHealingSkillEntry, PlayerSkillDamageEntry };

package/dist/aggregationTypes.d.ts

@@ -0,0 +1,21 @@
+interface PlayerSkillDamageEntry {
+    id: string;
+    name: string;
+    icon?: string;
+    damage: number;
+    downContribution: number;
+    hits: number;
+    casts: number;
+    min: number;
+    max: number;
+}
+interface PlayerHealingSkillEntry {
+    id: string;
+    name: string;
+    icon?: string;
+    total: number;
+    hits: number;
+    max: number;
+}
+
+export type { PlayerHealingSkillEntry, PlayerSkillDamageEntry };

package/dist/aggregationTypes.js

@@ -0,0 +1 @@
+import "./chunk-M2WR3JBQ.js";

package/dist/boonGeneration.cjs

@@ -0,0 +1,308 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/boonGeneration.ts
+var boonGeneration_exports = {};
+__export(boonGeneration_exports, {
+  buildBoonLeaderboards: () => buildBoonLeaderboards,
+  buildBoonTables: () => buildBoonTables,
+  computeBoonMetrics: () => computeBoonMetrics,
+  formatBoonMetricDisplay: () => formatBoonMetricDisplay,
+  getBoonMetricValue: () => getBoonMetricValue,
+  getPlayerBoonGenerationMs: () => getPlayerBoonGenerationMs
+});
+module.exports = __toCommonJS(boonGeneration_exports);
+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);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildBoonLeaderboards,
+  buildBoonTables,
+  computeBoonMetrics,
+  formatBoonMetricDisplay,
+  getBoonMetricValue,
+  getPlayerBoonGenerationMs
+});

package/dist/boonGeneration.d.cts

@@ -0,0 +1,65 @@
+type BoonCategory = 'selfBuffs' | 'groupBuffs' | 'squadBuffs' | 'totalBuffs';
+type BoonMetric = 'total' | 'average' | 'uptime';
+interface BuffInfo {
+    name?: string;
+    stacking?: boolean;
+    icon?: string;
+    classification?: string;
+}
+interface BuffGenerationEntry {
+    id: number;
+    buffData?: Array<{
+        generation?: number;
+        wasted?: number;
+    }>;
+}
+interface BoonRow {
+    account: string;
+    profession: string;
+    professionList?: string[];
+    activeTimeMs: number;
+    numFights: number;
+    groupSupported: number;
+    squadSupported: number;
+    categories: Record<Exclude<BoonCategory, 'totalBuffs'>, {
+        generationMs: number;
+        wastedMs: number;
+    }>;
+}
+interface BoonTable {
+    id: string;
+    name: string;
+    icon?: string;
+    stacking: boolean;
+    rows: BoonRow[];
+}
+declare const computeBoonMetrics: (row: BoonRow, category: BoonCategory, stacking: boolean) => {
+    generationMs: number;
+    wastedMs: number;
+    uptimeRaw: number;
+    wastedRaw: number;
+};
+declare const getBoonMetricValue: (row: BoonRow, category: BoonCategory, stacking: boolean, metric: BoonMetric) => number;
+declare const formatBoonMetricDisplay: (row: BoonRow, category: BoonCategory, stacking: boolean, metric: BoonMetric, options?: {
+    roundCountStats?: boolean;
+}) => string;
+declare const buildBoonTables: (logs: Array<{
+    details?: any;
+}>, splitPlayersByClass?: boolean) => {
+    boonTables: BoonTable[];
+};
+interface BoonLeaderboardRow {
+    rank: number;
+    account: string;
+    profession: string;
+    professionList?: string[];
+    value: number;
+    count?: number;
+}
+declare const buildBoonLeaderboards: (tables: BoonTable[], metric?: BoonMetric) => Record<string, BoonLeaderboardRow[]>;
+declare const getPlayerBoonGenerationMs: (player: any, category: Exclude<BoonCategory, "totalBuffs">, boonId: number, durationMs: number, groupCount: number, squadCount: number, buffMap?: Record<string, BuffInfo>) => {
+    generationMs: number;
+    wastedMs: number;
+};
+
+export { type BoonCategory, type BoonLeaderboardRow, type BoonMetric, type BoonRow, type BoonTable, type BuffGenerationEntry, type BuffInfo, buildBoonLeaderboards, buildBoonTables, computeBoonMetrics, formatBoonMetricDisplay, getBoonMetricValue, getPlayerBoonGenerationMs };

package/dist/boonGeneration.d.ts

@@ -0,0 +1,65 @@
+type BoonCategory = 'selfBuffs' | 'groupBuffs' | 'squadBuffs' | 'totalBuffs';
+type BoonMetric = 'total' | 'average' | 'uptime';
+interface BuffInfo {
+    name?: string;
+    stacking?: boolean;
+    icon?: string;
+    classification?: string;
+}
+interface BuffGenerationEntry {
+    id: number;
+    buffData?: Array<{
+        generation?: number;
+        wasted?: number;
+    }>;
+}
+interface BoonRow {
+    account: string;
+    profession: string;
+    professionList?: string[];
+    activeTimeMs: number;
+    numFights: number;
+    groupSupported: number;
+    squadSupported: number;
+    categories: Record<Exclude<BoonCategory, 'totalBuffs'>, {
+        generationMs: number;
+        wastedMs: number;
+    }>;
+}
+interface BoonTable {
+    id: string;
+    name: string;
+    icon?: string;
+    stacking: boolean;
+    rows: BoonRow[];
+}
+declare const computeBoonMetrics: (row: BoonRow, category: BoonCategory, stacking: boolean) => {
+    generationMs: number;
+    wastedMs: number;
+    uptimeRaw: number;
+    wastedRaw: number;
+};
+declare const getBoonMetricValue: (row: BoonRow, category: BoonCategory, stacking: boolean, metric: BoonMetric) => number;
+declare const formatBoonMetricDisplay: (row: BoonRow, category: BoonCategory, stacking: boolean, metric: BoonMetric, options?: {
+    roundCountStats?: boolean;
+}) => string;
+declare const buildBoonTables: (logs: Array<{
+    details?: any;
+}>, splitPlayersByClass?: boolean) => {
+    boonTables: BoonTable[];
+};
+interface BoonLeaderboardRow {
+    rank: number;
+    account: string;
+    profession: string;
+    professionList?: string[];
+    value: number;
+    count?: number;
+}
+declare const buildBoonLeaderboards: (tables: BoonTable[], metric?: BoonMetric) => Record<string, BoonLeaderboardRow[]>;
+declare const getPlayerBoonGenerationMs: (player: any, category: Exclude<BoonCategory, "totalBuffs">, boonId: number, durationMs: number, groupCount: number, squadCount: number, buffMap?: Record<string, BuffInfo>) => {
+    generationMs: number;
+    wastedMs: number;
+};
+
+export { type BoonCategory, type BoonLeaderboardRow, type BoonMetric, type BoonRow, type BoonTable, type BuffGenerationEntry, type BuffInfo, buildBoonLeaderboards, buildBoonTables, computeBoonMetrics, formatBoonMetricDisplay, getBoonMetricValue, getPlayerBoonGenerationMs };

package/dist/boonGeneration.js

@@ -0,0 +1,16 @@
+import {
+  buildBoonLeaderboards,
+  buildBoonTables,
+  computeBoonMetrics,
+  formatBoonMetricDisplay,
+  getBoonMetricValue,
+  getPlayerBoonGenerationMs
+} from "./chunk-PMVLNDZZ.js";
+export {
+  buildBoonLeaderboards,
+  buildBoonTables,
+  computeBoonMetrics,
+  formatBoonMetricDisplay,
+  getBoonMetricValue,
+  getPlayerBoonGenerationMs
+};

package/dist/chunk-42DVJJLC.js

@@ -0,0 +1,106 @@
+// src/statsMetrics.ts
+var OFFENSE_METRICS = [
+  { id: "damage", label: "Damage", field: "damage", source: "dpsAll" },
+  { id: "directDmg", label: "Direct Damage", field: "directDmg", source: "statsTargets" },
+  { id: "connectedDamageCount", label: "Connected Damage Count", field: "connectedDamageCount", source: "statsTargets" },
+  { id: "connectedDirectDamageCount", label: "Connected Direct Damage Count", field: "connectedDirectDamageCount", source: "statsTargets" },
+  { id: "battleStandardHits", label: "Battle Standard Tracking" },
+  { id: "criticalRate", label: "Critical Rate", field: "criticalRate", isRate: true, isPercent: true, denomField: "critableDirectDamageCount", source: "statsTargets" },
+  { id: "criticalDmg", label: "Critical Damage", field: "criticalDmg", source: "statsTargets" },
+  { id: "flankingRate", label: "Flanking Rate", field: "flankingRate", isRate: true, isPercent: true, denomField: "connectedDirectDamageCount", source: "statsTargets" },
+  { id: "glanceRate", label: "Glance Rate", field: "glanceRate", isRate: true, isPercent: true, denomField: "connectedDirectDamageCount", source: "statsTargets" },
+  { id: "missed", label: "Missed", field: "missed", source: "statsTargets" },
+  { id: "evaded", label: "Evaded (enemy)", field: "evaded", source: "statsTargets" },
+  { id: "blocked", label: "Blocked (enemy)", field: "blocked", source: "statsTargets" },
+  { id: "interrupts", label: "Interrupts", field: "interrupts", source: "statsTargets" },
+  { id: "invulned", label: "Invulned", field: "invulned", source: "statsTargets" },
+  { id: "killed", label: "Killed", field: "killed", source: "statsTargets" },
+  { id: "downed", label: "Downed", field: "downed", source: "statsTargets" },
+  { id: "downContribution", label: "Down Contribution", field: "downContribution", source: "statsTargets" },
+  { id: "downContributionPercent", label: "Down Contribution %", isRate: true, isPercent: true },
+  { id: "againstDownedDamage", label: "Against Downed Damage", field: "againstDownedDamage", source: "statsTargets" },
+  { id: "appliedCrowdControl", label: "Applied CC", field: "appliedCrowdControl", source: "statsTargets" },
+  { id: "appliedCrowdControlDuration", label: "Applied CC Duration", field: "appliedCrowdControlDuration", source: "statsTargets" },
+  { id: "appliedCrowdControlDownContribution", label: "Applied CC Down Contribution", field: "appliedCrowdControlDownContribution", source: "statsTargets" },
+  { id: "appliedCrowdControlDurationDownContribution", label: "Applied CC Duration Down Contribution", field: "appliedCrowdControlDurationDownContribution", source: "statsTargets" },
+  { id: "boonStrips", label: "Boon Strips", field: "boonStrips", source: "support" }
+];
+var DEFENSE_METRICS = [
+  { id: "damageTaken", label: "Damage Taken", field: "damageTaken" },
+  { id: "minionDamageTaken", label: "Minion Damage Taken" },
+  { id: "damageTakenCount", label: "Damage Taken Count", field: "damageTakenCount" },
+  { id: "conditionDamageTaken", label: "Condition Damage Taken", field: "conditionDamageTaken" },
+  { id: "conditionDamageTakenCount", label: "Condition Damage Taken Count", field: "conditionDamageTakenCount" },
+  { id: "powerDamageTaken", label: "Power Damage Taken", field: "powerDamageTaken" },
+  { id: "powerDamageTakenCount", label: "Power Damage Taken Count", field: "powerDamageTakenCount" },
+  { id: "downedDamageTaken", label: "Downed Damage Taken", field: "downedDamageTaken" },
+  { id: "downedDamageTakenCount", label: "Downed Damage Taken Count", field: "downedDamageTakenCount" },
+  { id: "damageBarrier", label: "Damage Barrier", field: "damageBarrier" },
+  { id: "damageBarrierCount", label: "Damage Barrier Count", field: "damageBarrierCount" },
+  { id: "blockedCount", label: "Blocked Count", field: "blockedCount" },
+  { id: "evadedCount", label: "Evaded Count", field: "evadedCount" },
+  { id: "missedCount", label: "Missed Count", field: "missedCount" },
+  { id: "dodgeCount", label: "Dodge Count", field: "dodgeCount" },
+  { id: "invulnedCount", label: "Invulnerable Count", field: "invulnedCount" },
+  { id: "interruptedCount", label: "Interrupted Count", field: "interruptedCount" },
+  { id: "downCount", label: "Down Count", field: "downCount" },
+  { id: "deadCount", label: "Death Count", field: "deadCount" },
+  { id: "boonStrips", label: "Boon Strips (Incoming)", field: "boonStrips" },
+  { id: "conditionCleanses", label: "Cleanses (Incoming)", field: "conditionCleanses" },
+  { id: "receivedCrowdControl", label: "Crowd Control (Incoming)", field: "receivedCrowdControl" }
+];
+var DAMAGE_MITIGATION_METRICS = [
+  { id: "totalHits", label: "Total Hits" },
+  { id: "evaded", label: "Evaded" },
+  { id: "blocked", label: "Blocked" },
+  { id: "glanced", label: "Glanced" },
+  { id: "missed", label: "Missed" },
+  { id: "invulned", label: "Invulned" },
+  { id: "interrupted", label: "Interrupted" },
+  { id: "totalMitigation", label: "Damage Mitigation" },
+  { id: "minMitigation", label: "Min Damage Mitigation" }
+];
+var SUPPORT_METRICS = [
+  { id: "condiCleanse", label: "Condition Cleanses", field: "condiCleanse" },
+  { id: "condiCleanseTime", label: "Condition Cleanse Time", field: "condiCleanseTime", isTime: true },
+  { id: "condiCleanseSelf", label: "Condition Cleanse Self", field: "condiCleanseSelf" },
+  { id: "condiCleanseTimeSelf", label: "Condition Cleanse Time Self", field: "condiCleanseTimeSelf", isTime: true },
+  { id: "boonStrips", label: "Boon Strips", field: "boonStrips" },
+  { id: "boonStripsTime", label: "Boon Strips Time", field: "boonStripsTime", isTime: true },
+  { id: "boonStripDownContribution", label: "Boon Strip Down Contribution", field: "boonStripDownContribution" },
+  { id: "boonStripDownContributionTime", label: "Boon Strip Down Contribution Time", field: "boonStripDownContributionTime", isTime: true },
+  { id: "stunBreak", label: "Stun Breaks", field: "stunBreak" },
+  { id: "removedStunDuration", label: "Removed Stun Duration", field: "removedStunDuration", isTime: true },
+  { id: "resurrects", label: "Resurrects", field: "resurrects" },
+  { id: "resurrectTime", label: "Resurrect Time", field: "resurrectTime", isTime: true }
+];
+var HEALING_METRICS = [
+  { id: "healing", label: "Healing", baseField: "healing", perSecond: false, decimals: 0 },
+  { id: "healingPerSecond", label: "Healing Per Second", baseField: "healing", perSecond: true, decimals: 2 },
+  { id: "barrier", label: "Barrier", baseField: "barrier", perSecond: false, decimals: 0 },
+  { id: "barrierPerSecond", label: "Barrier Per Second", baseField: "barrier", perSecond: true, decimals: 2 },
+  { id: "downedHealing", label: "Downed Healing", baseField: "downedHealing", perSecond: false, decimals: 0 },
+  { id: "downedHealingPerSecond", label: "Downed Healing Per Second", baseField: "downedHealing", perSecond: true, decimals: 1 },
+  { id: "resUtility", label: "Resurrect Utility", baseField: "resUtility", perSecond: false, decimals: 0 }
+];
+var RES_UTILITY_NAME_MATCHES = [
+  "battle standard",
+  "glyph of renewal",
+  "glyph of the stars",
+  "illusion of life",
+  "spirit of nature",
+  "nature spirit",
+  "search and rescue",
+  "signet of mercy"
+];
+var RES_UTILITY_IDS = /* @__PURE__ */ new Set([10244]);
+
+export {
+  OFFENSE_METRICS,
+  DEFENSE_METRICS,
+  DAMAGE_MITIGATION_METRICS,
+  SUPPORT_METRICS,
+  HEALING_METRICS,
+  RES_UTILITY_NAME_MATCHES,
+  RES_UTILITY_IDS
+};