@axiapps/bridge-metrics 0.1.0

package/dist/dashboardMetrics.cjs

@@ -0,0 +1,226 @@
+"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/dashboardMetrics.ts
+var dashboardMetrics_exports = {};
+__export(dashboardMetrics_exports, {
+  getPlayerBlocked: () => getPlayerBlocked,
+  getPlayerBreakbarDamage: () => getPlayerBreakbarDamage,
+  getPlayerCleanses: () => getPlayerCleanses,
+  getPlayerDamage: () => getPlayerDamage,
+  getPlayerDamageTaken: () => getPlayerDamageTaken,
+  getPlayerDashboardTotals: () => getPlayerDashboardTotals,
+  getPlayerDeaths: () => getPlayerDeaths,
+  getPlayerDistanceToTag: () => getPlayerDistanceToTag,
+  getPlayerDodges: () => getPlayerDodges,
+  getPlayerDownsTaken: () => getPlayerDownsTaken,
+  getPlayerDps: () => getPlayerDps,
+  getPlayerEvaded: () => getPlayerEvaded,
+  getPlayerMissed: () => getPlayerMissed,
+  getPlayerOutgoingInterrupts: () => getPlayerOutgoingInterrupts,
+  getPlayerResurrects: () => getPlayerResurrects,
+  getPlayerStrips: () => getPlayerStrips,
+  getTargetStatTotal: () => getTargetStatTotal
+});
+module.exports = __toCommonJS(dashboardMetrics_exports);
+
+// 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/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 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;
+}
+
+// src/dashboardMetrics.ts
+var getPlayerDamage = (player) => player.dpsAll?.[0]?.damage || 0;
+var getPlayerDps = (player) => player.dpsAll?.[0]?.dps || 0;
+var getPlayerCleanses = (player) => (player.support?.[0]?.condiCleanse || 0) + (player.support?.[0]?.condiCleanseSelf || 0);
+var getPlayerStrips = (player, method = DEFAULT_DISRUPTION_METHOD) => {
+  const support = player.support?.[0];
+  const count = Number(support?.boonStrips ?? 0);
+  const durationMs = Number(support?.boonStripsTime ?? 0);
+  return resolveDisruptionValue(count, durationMs, method);
+};
+var getPlayerResurrects = (player) => player.support?.[0]?.resurrects || 0;
+var getPlayerDistanceToTag = (player) => {
+  const stats = player.statsAll?.[0];
+  const distToCom = stats?.distToCom;
+  if (distToCom !== void 0 && distToCom !== null) {
+    return distToCom;
+  }
+  return stats?.stackDist || 0;
+};
+var getPlayerBreakbarDamage = (player) => player.dpsAll?.[0]?.breakbarDamage || 0;
+var getPlayerDamageTaken = (player) => player.defenses?.[0]?.damageTaken || 0;
+var getPlayerDeaths = (player) => player.defenses?.[0]?.deadCount || 0;
+var getPlayerDodges = (player) => player.defenses?.[0]?.dodgeCount || 0;
+var getPlayerMissed = (player) => player.defenses?.[0]?.missedCount || 0;
+var getPlayerBlocked = (player) => player.defenses?.[0]?.blockedCount || 0;
+var getPlayerEvaded = (player) => player.defenses?.[0]?.evadedCount || 0;
+var getPlayerDownsTaken = (player) => player.defenses?.[0]?.downCount || 0;
+var getTargetStatTotal = (player, field) => {
+  let total = 0;
+  const statsTargets = player.statsTargets || [];
+  for (const targetStats of statsTargets) {
+    if (targetStats && targetStats.length > 0) {
+      total += Number(targetStats[0][field] || 0);
+    }
+  }
+  return total;
+};
+var getPlayerOutgoingInterrupts = (player) => getTargetStatTotal(player, "interrupts");
+var getPlayerDashboardTotals = (player, method = DEFAULT_DISRUPTION_METHOD) => ({
+  downContrib: computeDownContribution(player),
+  cleanses: getPlayerCleanses(player),
+  strips: getPlayerStrips(player, method),
+  healing: computeSquadHealing(player),
+  barrier: computeSquadBarrier(player),
+  cc: computeOutgoingCrowdControl(player, method)
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPlayerBlocked,
+  getPlayerBreakbarDamage,
+  getPlayerCleanses,
+  getPlayerDamage,
+  getPlayerDamageTaken,
+  getPlayerDashboardTotals,
+  getPlayerDeaths,
+  getPlayerDistanceToTag,
+  getPlayerDodges,
+  getPlayerDownsTaken,
+  getPlayerDps,
+  getPlayerEvaded,
+  getPlayerMissed,
+  getPlayerOutgoingInterrupts,
+  getPlayerResurrects,
+  getPlayerStrips,
+  getTargetStatTotal
+});

package/dist/dashboardMetrics.d.cts

@@ -0,0 +1,29 @@
+import { Player } from './dpsReportTypes.cjs';
+import { DisruptionMethod } from './metricsSettings.cjs';
+
+declare const getPlayerDamage: (player: Player) => number;
+declare const getPlayerDps: (player: Player) => number;
+declare const getPlayerCleanses: (player: Player) => number;
+declare const getPlayerStrips: (player: Player, method?: DisruptionMethod) => number;
+declare const getPlayerResurrects: (player: Player) => number;
+declare const getPlayerDistanceToTag: (player: Player) => number;
+declare const getPlayerBreakbarDamage: (player: Player) => number;
+declare const getPlayerDamageTaken: (player: Player) => number;
+declare const getPlayerDeaths: (player: Player) => number;
+declare const getPlayerDodges: (player: Player) => number;
+declare const getPlayerMissed: (player: Player) => number;
+declare const getPlayerBlocked: (player: Player) => number;
+declare const getPlayerEvaded: (player: Player) => number;
+declare const getPlayerDownsTaken: (player: Player) => number;
+declare const getTargetStatTotal: (player: Player, field: "killed" | "downed" | "againstDownedCount" | "interrupts") => number;
+declare const getPlayerOutgoingInterrupts: (player: Player) => number;
+declare const getPlayerDashboardTotals: (player: Player, method?: DisruptionMethod) => {
+    downContrib: number;
+    cleanses: number;
+    strips: number;
+    healing: number;
+    barrier: number;
+    cc: number;
+};
+
+export { getPlayerBlocked, getPlayerBreakbarDamage, getPlayerCleanses, getPlayerDamage, getPlayerDamageTaken, getPlayerDashboardTotals, getPlayerDeaths, getPlayerDistanceToTag, getPlayerDodges, getPlayerDownsTaken, getPlayerDps, getPlayerEvaded, getPlayerMissed, getPlayerOutgoingInterrupts, getPlayerResurrects, getPlayerStrips, getTargetStatTotal };

package/dist/dashboardMetrics.d.ts

@@ -0,0 +1,29 @@
+import { Player } from './dpsReportTypes.js';
+import { DisruptionMethod } from './metricsSettings.js';
+
+declare const getPlayerDamage: (player: Player) => number;
+declare const getPlayerDps: (player: Player) => number;
+declare const getPlayerCleanses: (player: Player) => number;
+declare const getPlayerStrips: (player: Player, method?: DisruptionMethod) => number;
+declare const getPlayerResurrects: (player: Player) => number;
+declare const getPlayerDistanceToTag: (player: Player) => number;
+declare const getPlayerBreakbarDamage: (player: Player) => number;
+declare const getPlayerDamageTaken: (player: Player) => number;
+declare const getPlayerDeaths: (player: Player) => number;
+declare const getPlayerDodges: (player: Player) => number;
+declare const getPlayerMissed: (player: Player) => number;
+declare const getPlayerBlocked: (player: Player) => number;
+declare const getPlayerEvaded: (player: Player) => number;
+declare const getPlayerDownsTaken: (player: Player) => number;
+declare const getTargetStatTotal: (player: Player, field: "killed" | "downed" | "againstDownedCount" | "interrupts") => number;
+declare const getPlayerOutgoingInterrupts: (player: Player) => number;
+declare const getPlayerDashboardTotals: (player: Player, method?: DisruptionMethod) => {
+    downContrib: number;
+    cleanses: number;
+    strips: number;
+    healing: number;
+    barrier: number;
+    cc: number;
+};
+
+export { getPlayerBlocked, getPlayerBreakbarDamage, getPlayerCleanses, getPlayerDamage, getPlayerDamageTaken, getPlayerDashboardTotals, getPlayerDeaths, getPlayerDistanceToTag, getPlayerDodges, getPlayerDownsTaken, getPlayerDps, getPlayerEvaded, getPlayerMissed, getPlayerOutgoingInterrupts, getPlayerResurrects, getPlayerStrips, getTargetStatTotal };

package/dist/dashboardMetrics.js

@@ -0,0 +1,42 @@
+import {
+  getPlayerBlocked,
+  getPlayerBreakbarDamage,
+  getPlayerCleanses,
+  getPlayerDamage,
+  getPlayerDamageTaken,
+  getPlayerDashboardTotals,
+  getPlayerDeaths,
+  getPlayerDistanceToTag,
+  getPlayerDodges,
+  getPlayerDownsTaken,
+  getPlayerDps,
+  getPlayerEvaded,
+  getPlayerMissed,
+  getPlayerOutgoingInterrupts,
+  getPlayerResurrects,
+  getPlayerStrips,
+  getTargetStatTotal
+} from "./chunk-FU74LJEM.js";
+import "./chunk-R5EJF5AW.js";
+import "./chunk-ZFZS7JFU.js";
+import "./chunk-PMVLNDZZ.js";
+import "./chunk-KRHODGVU.js";
+export {
+  getPlayerBlocked,
+  getPlayerBreakbarDamage,
+  getPlayerCleanses,
+  getPlayerDamage,
+  getPlayerDamageTaken,
+  getPlayerDashboardTotals,
+  getPlayerDeaths,
+  getPlayerDistanceToTag,
+  getPlayerDodges,
+  getPlayerDownsTaken,
+  getPlayerDps,
+  getPlayerEvaded,
+  getPlayerMissed,
+  getPlayerOutgoingInterrupts,
+  getPlayerResurrects,
+  getPlayerStrips,
+  getTargetStatTotal
+};

package/dist/dpsReportTypes.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/dpsReportTypes.ts
+var dpsReportTypes_exports = {};
+module.exports = __toCommonJS(dpsReportTypes_exports);

package/dist/dpsReportTypes.d.cts

@@ -0,0 +1,294 @@
+interface DamageModifierInfo {
+    name: string;
+    icon: string;
+    description: string;
+    nonMultiplier?: boolean;
+    skillBased?: boolean;
+    approximate?: boolean;
+    incoming: boolean;
+}
+interface DamageModifierData {
+    id: number;
+    damageModifiers: Array<{
+        hitCount: number;
+        totalHitCount: number;
+        damageGain: number;
+        totalDamage: number;
+    }>;
+}
+interface DPSReportJSON {
+    evtc: {
+        type: string;
+        version: string;
+        bossId: number;
+    };
+    encounterDuration: string;
+    recordedBy: string;
+    uploadTime: number;
+    players: Player[];
+    targets: Target[];
+    durationMS: number;
+    fightName: string;
+    success: boolean;
+    skillMap?: {
+        [key: string]: {
+            name: string;
+            icon: string;
+            autoAttack?: boolean;
+            isTraitProc?: boolean;
+            isGearProc?: boolean;
+            isUnconditionalProc?: boolean;
+        };
+    };
+    buffMap?: {
+        [key: string]: {
+            name: string;
+            stacking: boolean;
+            icon?: string;
+            classification?: string;
+        };
+    };
+    combatReplayMetaData?: {
+        inchToPixel?: number;
+        pollingRate?: number;
+        sizes?: [number, number];
+        maps?: Array<{
+            url?: string;
+        }>;
+    };
+    wvWMapData?: {
+        redTeamID?: number;
+        greenTeamID?: number;
+        blueTeamID?: number;
+        redShardID?: number;
+        greenShardID?: number;
+        blueShardID?: number;
+    };
+    damageModMap?: Record<string, DamageModifierInfo>;
+    personalDamageMods?: Record<string, number[]>;
+}
+interface Target {
+    id: number;
+    name: string;
+    isFake: boolean;
+    dpsAll: StatsAll[];
+    statsAll: StatsAll[];
+    defenses: Defenses[];
+    totalHealth: number;
+    healthPercentBurned: number;
+    enemyPlayer: boolean;
+    teamID?: number;
+}
+interface Player {
+    name: string;
+    display_name: string;
+    character_name: string;
+    profession: string;
+    teamID?: number;
+    elite_spec: number;
+    group: number;
+    dpsAll: StatsAll[];
+    statsAll?: StatsAll[];
+    dpsTargets?: StatsTarget[][];
+    defenses: Defenses[];
+    support: Support[];
+    rotation?: Array<{
+        id: number;
+        /** Per-instance cast events for this skill. castTime is ms from fight start. */
+        skills?: Array<{
+            castTime: number;
+            duration: number;
+            timeGained?: number;
+            quickness?: number;
+        }>;
+    }>;
+    extHealingStats?: {
+        outgoingHealingAllies?: {
+            healing: number;
+            downedHealing?: number;
+        }[][];
+        totalHealingDist?: Array<Array<{
+            id: number;
+            totalHealing: number;
+            totalDownedHealing?: number;
+            hits: number;
+            min: number;
+            max: number;
+            indirectHealing?: boolean;
+        }>>;
+        /** Cumulative total outgoing healing per second (to all targets). Shape: [phase][time]. Diff to get per-second. */
+        healing1S?: number[][];
+        /** Cumulative healing received per second (from all sources). Shape: [phase][time]. Diff to get per-second. */
+        healingReceived1S?: number[][];
+    };
+    extBarrierStats?: {
+        outgoingBarrierAllies?: {
+            barrier: number;
+        }[][];
+        totalBarrierDist?: Array<Array<{
+            id: number;
+            totalBarrier: number;
+            hits: number;
+            min: number;
+            max: number;
+            indirectBarrier?: boolean;
+        }>>;
+    };
+    squadBuffVolumes?: SquadBuffVolume[];
+    selfBuffs?: BuffGeneration[];
+    groupBuffs?: BuffGeneration[];
+    squadBuffs?: BuffGeneration[];
+    selfBuffsActive?: BuffGeneration[];
+    groupBuffsActive?: BuffGeneration[];
+    squadBuffsActive?: BuffGeneration[];
+    buffUptimes?: BuffUptimesEntry[];
+    totalDamageDist?: TotalDamageDist[][];
+    targetDamageDist?: TotalDamageDist[][][];
+    totalDamageTaken?: TotalDamageTaken[][];
+    statsTargets?: StatsTarget[][];
+    combatReplayData?: {
+        positions?: Array<[number, number]>;
+        dead?: Array<[number, number]>;
+        down?: Array<[number, number]>;
+        start?: number;
+    };
+    healthPercents?: Array<[number, number]>;
+    hasCommanderTag?: boolean;
+    notInSquad?: boolean;
+    account?: string;
+    stabGeneration?: number;
+    activeTimes?: number[];
+    damageModifiers?: DamageModifierData[];
+    incomingDamageModifiers?: DamageModifierData[];
+    damage1S?: number[][];
+    targetDamage1S?: number[][][];
+    /** Cumulative incoming damage per second. Shape: [phase][time]. Diff adjacent entries to get per-second values. */
+    damageTaken1S?: number[][];
+}
+interface StatsAll {
+    dps: number;
+    damage: number;
+    breakbarDamage: number;
+    downContribution?: number;
+    stackDist?: number;
+    distToCom?: number;
+    appliedCrowdControl?: number;
+    appliedCrowdControlDuration?: number;
+}
+interface Defenses {
+    downCount: number;
+    deadCount: number;
+    missedCount: number;
+    blockedCount: number;
+    evadedCount: number;
+    dodgeCount: number;
+    interruptedCount: number;
+    damageTaken: number;
+    /** Boons stripped from this player by enemies. */
+    boonStrips?: number;
+    boonStripsTime?: number;
+    /** Conditions cleansed from this player (by self or allies). */
+    conditionCleanses?: number;
+    conditionCleansesTime?: number;
+    /** Number of condition damage hits received. */
+    conditionDamageTakenCount?: number;
+    receivedCrowdControl?: number;
+    receivedCrowdControlDuration?: number;
+}
+interface SquadBuffVolume {
+    id: number;
+    buffVolumeData: {
+        outgoing: number;
+    }[];
+}
+interface BuffGeneration {
+    id: number;
+    buffData?: {
+        generation?: number;
+        wasted?: number;
+    }[];
+}
+/** @deprecated Use BuffUptimesEntry */
+interface BuffUptimes {
+    id: number;
+    buffData: {
+        uptime: number;
+    }[];
+    statesPerSource: {
+        [key: string]: number[][];
+    };
+}
+/**
+ * Per-player per-buff entry in the `buffUptimes` array.
+ * `states` is an array of `[timeMs, stackCount]` pairs recording state-change
+ * events throughout the fight.  The value at any given millisecond is the last
+ * `stackCount` whose `timeMs` is ≤ the queried time.
+ */
+interface BuffUptimesEntry {
+    id: number;
+    buffData: {
+        uptime: number;
+        presence?: number;
+    }[];
+    /** `[timeMs, stackCount]` state-change pairs, sorted by time ascending. */
+    states?: Array<[number, number]>;
+    statesPerSource?: {
+        [key: string]: Array<[number, number]>;
+    };
+}
+interface TotalDamageDist {
+    id: number;
+    hits: number;
+    connectedHits: number;
+    flank: number;
+    crit: number;
+    glance: number;
+    totalDamage: number;
+    missed: number;
+    interrupted: number;
+    evaded: number;
+    blocked: number;
+    min: number;
+    max: number;
+    downContribution?: number;
+}
+interface TotalDamageTaken {
+    id: number;
+    hits: number;
+    connectedHits: number;
+    flank: number;
+    crit: number;
+    glance: number;
+    totalDamage: number;
+    missed: number;
+    interrupted: number;
+    evaded: number;
+    blocked: number;
+    min: number;
+    max: number;
+    indirectDamage: boolean;
+}
+interface StatsTarget {
+    killed: number;
+    downed: number;
+    downContribution: number;
+    againstDownedCount: number;
+    againstDownedDamage: number;
+    interrupts?: number;
+}
+interface Support {
+    condiCleanse: number;
+    condiCleanseTime?: number;
+    condiCleanseSelf: number;
+    condiCleanseTimeSelf?: number;
+    boonStrips: number;
+    boonStripsTime?: number;
+    boonStripDownContribution?: number;
+    boonStripDownContributionTime?: number;
+    stunBreak?: number;
+    removedStunDuration?: number;
+    resurrects: number;
+    resurrectTime?: number;
+}
+
+export type { BuffGeneration, BuffUptimes, BuffUptimesEntry, DPSReportJSON, DamageModifierData, DamageModifierInfo, Defenses, Player, SquadBuffVolume, StatsAll, StatsTarget, Support, Target, TotalDamageDist, TotalDamageTaken };