@axiapps/bridge-metrics 0.1.0

package/dist/chunk-WW5XFXGC.js

@@ -0,0 +1,234 @@
+// src/professionUtils.ts
+var PROFESSION_COLORS = {
+  "Guardian": "#72C1D9",
+  "Dragonhunter": "#72C1D9",
+  "Firebrand": "#72C1D9",
+  "Willbender": "#72C1D9",
+  "Revenant": "#D16E5A",
+  "Herald": "#D16E5A",
+  "Renegade": "#D16E5A",
+  "Vindicator": "#D16E5A",
+  "Warrior": "#FFD166",
+  "Berserker": "#FFD166",
+  "Spellbreaker": "#FFD166",
+  "Bladesworn": "#FFD166",
+  "Engineer": "#D09C59",
+  "Scrapper": "#D09C59",
+  "Holosmith": "#D09C59",
+  "Mechanist": "#D09C59",
+  "Ranger": "#8CDC82",
+  "Druid": "#8CDC82",
+  "Soulbeast": "#8CDC82",
+  "Untamed": "#8CDC82",
+  "Thief": "#C08F95",
+  "Daredevil": "#C08F95",
+  "Deadeye": "#C08F95",
+  "Specter": "#C08F95",
+  "Elementalist": "#F68A87",
+  "Tempest": "#F68A87",
+  "Weaver": "#F68A87",
+  "Catalyst": "#F68A87",
+  "Mesmer": "#B679D5",
+  "Chronomancer": "#B679D5",
+  "Mirage": "#B679D5",
+  "Virtuoso": "#B679D5",
+  "Necromancer": "#52A76F",
+  "Reaper": "#52A76F",
+  "Scourge": "#52A76F",
+  "Harbinger": "#52A76F",
+  "Ritualist": "#52A76F",
+  "Luminary": "#72C1D9",
+  "Conduit": "#D16E5A",
+  "Paragon": "#FFD166",
+  "Amalgam": "#D09C59",
+  "Galeshot": "#8CDC82",
+  "Antiquary": "#C08F95",
+  "Evoker": "#F68A87",
+  "Troubadour": "#B679D5",
+  "Unknown": "#64748B"
+};
+var PROFESSION_BASE = {
+  Guardian: "Guardian",
+  Dragonhunter: "Guardian",
+  Firebrand: "Guardian",
+  Willbender: "Guardian",
+  Revenant: "Revenant",
+  Herald: "Revenant",
+  Renegade: "Revenant",
+  Vindicator: "Revenant",
+  Warrior: "Warrior",
+  Berserker: "Warrior",
+  Spellbreaker: "Warrior",
+  Bladesworn: "Warrior",
+  Engineer: "Engineer",
+  Scrapper: "Engineer",
+  Holosmith: "Engineer",
+  Mechanist: "Engineer",
+  Ranger: "Ranger",
+  Druid: "Ranger",
+  Soulbeast: "Ranger",
+  Untamed: "Ranger",
+  Thief: "Thief",
+  Daredevil: "Thief",
+  Deadeye: "Thief",
+  Specter: "Thief",
+  Elementalist: "Elementalist",
+  Tempest: "Elementalist",
+  Weaver: "Elementalist",
+  Catalyst: "Elementalist",
+  Mesmer: "Mesmer",
+  Chronomancer: "Mesmer",
+  Mirage: "Mesmer",
+  Virtuoso: "Mesmer",
+  Necromancer: "Necromancer",
+  Reaper: "Necromancer",
+  Scourge: "Necromancer",
+  Harbinger: "Necromancer",
+  Ritualist: "Necromancer",
+  Luminary: "Guardian",
+  Conduit: "Revenant",
+  Paragon: "Warrior",
+  Amalgam: "Engineer",
+  Galeshot: "Ranger",
+  Antiquary: "Thief",
+  Evoker: "Elementalist",
+  Troubadour: "Mesmer",
+  Unknown: "Unknown"
+};
+var PROFESSION_ABBREVIATIONS = {
+  Guardian: "gdn",
+  Dragonhunter: "dh",
+  Firebrand: "fb",
+  Willbender: "wb",
+  Revenant: "rev",
+  Herald: "her",
+  Renegade: "ren",
+  Vindicator: "vin",
+  Warrior: "war",
+  Berserker: "ber",
+  Spellbreaker: "spb",
+  Bladesworn: "bsw",
+  Engineer: "eng",
+  Scrapper: "scr",
+  Holosmith: "hol",
+  Mechanist: "mec",
+  Ranger: "rng",
+  Druid: "dru",
+  Soulbeast: "slb",
+  Untamed: "unt",
+  Thief: "thi",
+  Daredevil: "dar",
+  Deadeye: "dea",
+  Specter: "spe",
+  Elementalist: "ele",
+  Tempest: "tem",
+  Weaver: "wev",
+  Catalyst: "cat",
+  Mesmer: "mes",
+  Chronomancer: "chr",
+  Mirage: "mir",
+  Virtuoso: "vir",
+  Necromancer: "nec",
+  Reaper: "rea",
+  Scourge: "sco",
+  Harbinger: "har",
+  Ritualist: "rit",
+  Luminary: "lum",
+  Conduit: "con",
+  Paragon: "par",
+  Amalgam: "ama",
+  Galeshot: "gal",
+  Antiquary: "ant",
+  Evoker: "evo",
+  Troubadour: "tro",
+  Unknown: "unk"
+};
+var PROFESSION_EMOJI = {
+  Guardian: "\u{1F535}",
+  Revenant: "\u{1F534}",
+  Warrior: "\u{1F7E1}",
+  Engineer: "\u{1F7E0}",
+  Ranger: "\u{1F7E2}",
+  Thief: "\u26AB\uFE0F",
+  Elementalist: "\u{1F534}",
+  Mesmer: "\u{1F7E3}",
+  Necromancer: "\u{1F7E2}",
+  Unknown: "\u26AA\uFE0F"
+};
+function getProfessionColor(profession) {
+  return PROFESSION_COLORS[profession] || PROFESSION_COLORS["Unknown"];
+}
+function hexToRgba(hex, alpha) {
+  const h = hex.replace("#", "");
+  const r = parseInt(h.substring(0, 2), 16);
+  const g = parseInt(h.substring(2, 4), 16);
+  const b = parseInt(h.substring(4, 6), 16);
+  return `rgba(${r},${g},${b},${alpha})`;
+}
+function getProfessionBase(profession) {
+  if (!profession) return "Unknown";
+  return PROFESSION_BASE[profession] || profession;
+}
+function getProfessionAbbrev(profession) {
+  if (!profession) return PROFESSION_ABBREVIATIONS.Unknown;
+  return PROFESSION_ABBREVIATIONS[profession] || profession.slice(0, 3).toLowerCase();
+}
+function getProfessionEmoji(profession) {
+  const base = getProfessionBase(profession);
+  return PROFESSION_EMOJI[base] || PROFESSION_EMOJI.Unknown;
+}
+var SUPERSCRIPT_MAP = {
+  a: "\u1D43",
+  b: "\u1D47",
+  c: "\u1D9C",
+  d: "\u1D48",
+  e: "\u1D49",
+  f: "\u1DA0",
+  g: "\u1D4D",
+  h: "\u02B0",
+  i: "\u2071",
+  j: "\u02B2",
+  k: "\u1D4F",
+  l: "\u02E1",
+  m: "\u1D50",
+  n: "\u207F",
+  o: "\u1D52",
+  p: "\u1D56",
+  q: "\u146B",
+  r: "\u02B3",
+  s: "\u02E2",
+  t: "\u1D57",
+  u: "\u1D58",
+  v: "\u1D5B",
+  w: "\u02B7",
+  x: "\u02E3",
+  y: "\u02B8",
+  z: "\u1DBB",
+  "0": "\u2070",
+  "1": "\xB9",
+  "2": "\xB2",
+  "3": "\xB3",
+  "4": "\u2074",
+  "5": "\u2075",
+  "6": "\u2076",
+  "7": "\u2077",
+  "8": "\u2078",
+  "9": "\u2079"
+};
+function toSuperscript(value) {
+  return value.toLowerCase().split("").map((char) => SUPERSCRIPT_MAP[char] || char).join("");
+}
+function getProfessionAbbrevSuperscript(profession) {
+  return toSuperscript(getProfessionAbbrev(profession));
+}
+
+export {
+  PROFESSION_COLORS,
+  getProfessionColor,
+  hexToRgba,
+  getProfessionBase,
+  getProfessionAbbrev,
+  getProfessionEmoji,
+  toSuperscript,
+  getProfessionAbbrevSuperscript
+};

package/dist/chunk-ZFZS7JFU.js

@@ -0,0 +1,10 @@
+// src/constants.ts
+var TIMESTAMP_MS_THRESHOLD = 1e12;
+var STABILITY_BOON_ID = 1122;
+var BULK_PROCESS_CONCURRENCY = 3;
+
+export {
+  TIMESTAMP_MS_THRESHOLD,
+  STABILITY_BOON_ID,
+  BULK_PROCESS_CONCURRENCY
+};

package/dist/combatMetrics.cjs

@@ -0,0 +1,251 @@
+"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/combatMetrics.ts
+var combatMetrics_exports = {};
+__export(combatMetrics_exports, {
+  applySquadStabilityGeneration: () => applySquadStabilityGeneration,
+  computeDownContribution: () => computeDownContribution,
+  computeIncomingDisruptions: () => computeIncomingDisruptions,
+  computeOutgoingCrowdControl: () => computeOutgoingCrowdControl,
+  computeSquadBarrier: () => computeSquadBarrier,
+  computeSquadHealing: () => computeSquadHealing,
+  resolveDisruptionValue: () => resolveDisruptionValue
+});
+module.exports = __toCommonJS(combatMetrics_exports);
+
+// src/boonGeneration.ts
+var CATEGORY_COUNT = {
+  selfBuffs: () => 1,
+  groupBuffs: (groupCount) => Math.max(groupCount - 1, 0),
+  squadBuffs: (_groupCount, squadCount) => Math.max(squadCount - 1, 0)
+};
+var toBoonId = (id) => `b${id}`;
+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 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);
+};
+
+// src/metrics-methods.json
+var metrics_methods_default = {
+  specVersion: "v5",
+  methods: {
+    count: {
+      label: "Count Events",
+      summary: "Counts each CC/strip event once.",
+      implications: [
+        "Simple and stable across EI versions.",
+        "Multi-hit skills can inflate totals."
+      ]
+    },
+    duration: {
+      label: "Duration (Seconds)",
+      summary: "Uses total CC/strip duration in seconds.",
+      implications: [
+        "Reflects control impact more directly.",
+        "Totals represent time, not event count."
+      ]
+    },
+    tiered: {
+      label: "Tiered Impact",
+      summary: "Weights events based on average duration tiers.",
+      implications: [
+        "Balances short vs long CC/strip effects.",
+        "Uses averaged durations per player."
+      ],
+      tiers: {
+        shortMs: 500,
+        mediumMs: 1500,
+        weights: {
+          short: 0.5,
+          medium: 1,
+          long: 2
+        }
+      }
+    }
+  }
+};
+
+// src/metricsSettings.ts
+var METRICS_SPEC = metrics_methods_default;
+var DEFAULT_DISRUPTION_METHOD = "count";
+
+// src/constants.ts
+var STABILITY_BOON_ID = 1122;
+
+// 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applySquadStabilityGeneration,
+  computeDownContribution,
+  computeIncomingDisruptions,
+  computeOutgoingCrowdControl,
+  computeSquadBarrier,
+  computeSquadHealing,
+  resolveDisruptionValue
+});

package/dist/combatMetrics.d.cts

@@ -0,0 +1,26 @@
+import { Player } from './dpsReportTypes.cjs';
+import { DisruptionMethod } from './metricsSettings.cjs';
+
+declare const resolveDisruptionValue: (count: number, durationMs: number, method: DisruptionMethod) => number;
+declare function computeOutgoingCrowdControl(player: Player, method?: DisruptionMethod): number;
+declare function computeIncomingDisruptions(player: Player, method?: DisruptionMethod): {
+    strips: {
+        total: number;
+        missed: number;
+        blocked: number;
+    };
+    cc: {
+        total: number;
+        missed: number;
+        blocked: number;
+    };
+};
+declare function applySquadStabilityGeneration(players: Player[], context?: {
+    durationMS?: number;
+    buffMap?: Record<string, any>;
+}): void;
+declare function computeDownContribution(player: Player): number;
+declare function computeSquadBarrier(player: Player): number;
+declare function computeSquadHealing(player: Player): number;
+
+export { applySquadStabilityGeneration, computeDownContribution, computeIncomingDisruptions, computeOutgoingCrowdControl, computeSquadBarrier, computeSquadHealing, resolveDisruptionValue };

package/dist/combatMetrics.d.ts

@@ -0,0 +1,26 @@
+import { Player } from './dpsReportTypes.js';
+import { DisruptionMethod } from './metricsSettings.js';
+
+declare const resolveDisruptionValue: (count: number, durationMs: number, method: DisruptionMethod) => number;
+declare function computeOutgoingCrowdControl(player: Player, method?: DisruptionMethod): number;
+declare function computeIncomingDisruptions(player: Player, method?: DisruptionMethod): {
+    strips: {
+        total: number;
+        missed: number;
+        blocked: number;
+    };
+    cc: {
+        total: number;
+        missed: number;
+        blocked: number;
+    };
+};
+declare function applySquadStabilityGeneration(players: Player[], context?: {
+    durationMS?: number;
+    buffMap?: Record<string, any>;
+}): void;
+declare function computeDownContribution(player: Player): number;
+declare function computeSquadBarrier(player: Player): number;
+declare function computeSquadHealing(player: Player): number;
+
+export { applySquadStabilityGeneration, computeDownContribution, computeIncomingDisruptions, computeOutgoingCrowdControl, computeSquadBarrier, computeSquadHealing, resolveDisruptionValue };

package/dist/combatMetrics.js

@@ -0,0 +1,21 @@
+import {
+  applySquadStabilityGeneration,
+  computeDownContribution,
+  computeIncomingDisruptions,
+  computeOutgoingCrowdControl,
+  computeSquadBarrier,
+  computeSquadHealing,
+  resolveDisruptionValue
+} from "./chunk-R5EJF5AW.js";
+import "./chunk-ZFZS7JFU.js";
+import "./chunk-PMVLNDZZ.js";
+import "./chunk-KRHODGVU.js";
+export {
+  applySquadStabilityGeneration,
+  computeDownContribution,
+  computeIncomingDisruptions,
+  computeOutgoingCrowdControl,
+  computeSquadBarrier,
+  computeSquadHealing,
+  resolveDisruptionValue
+};