@axiapps/bridge-metrics 0.1.0

package/dist/chunk-ELKDB763.js

@@ -0,0 +1,349 @@
+// src/rollup.ts
+var ROLLUP_SOURCES_VERSION = 1;
+var extractRollupSource = (payload) => {
+  const meta = payload?.meta || {};
+  const commanderRows = Array.isArray(payload?.stats?.commanderStats?.rows) ? payload.stats.commanderStats.rows : [];
+  const attendanceRows = Array.isArray(payload?.stats?.attendanceData) ? payload.stats.attendanceData : [];
+  return {
+    meta: {
+      id: meta.id,
+      dateStart: meta.dateStart,
+      dateEnd: meta.dateEnd,
+      generatedAt: meta.generatedAt
+    },
+    stats: {
+      commanderStats: {
+        rows: commanderRows.map((row) => ({
+          key: row?.key,
+          account: row?.account,
+          characterNames: Array.isArray(row?.characterNames) ? row.characterNames : [],
+          profession: row?.profession,
+          fights: row?.fights,
+          kills: row?.kills,
+          downs: row?.downs,
+          commanderDeaths: row?.commanderDeaths,
+          alliesDead: row?.alliesDead,
+          wins: row?.wins,
+          losses: row?.losses
+        }))
+      },
+      attendanceData: attendanceRows.map((row) => ({
+        account: row?.account,
+        characterNames: Array.isArray(row?.characterNames) ? row.characterNames : [],
+        combatTimeMs: row?.combatTimeMs,
+        squadTimeMs: row?.squadTimeMs,
+        classTimes: (Array.isArray(row?.classTimes) ? row.classTimes : []).map((entry) => ({
+          profession: entry?.profession,
+          timeMs: entry?.timeMs
+        }))
+      }))
+    }
+  };
+};
+var updateRollupSourcesForPublish = (options) => {
+  const { existingSources, currentReport, validIds, loadLocalReport } = options;
+  const sourcesById = /* @__PURE__ */ new Map();
+  existingSources.forEach((source) => {
+    const id = String(source?.meta?.id || "").trim();
+    if (id) sourcesById.set(id, source);
+  });
+  const currentId = String(currentReport?.meta?.id || "").trim();
+  if (currentId) {
+    sourcesById.set(currentId, extractRollupSource(currentReport));
+  }
+  const validIdSet = new Set(validIds.map((id) => String(id || "").trim()).filter(Boolean));
+  if (loadLocalReport) {
+    for (const id of validIdSet) {
+      if (sourcesById.has(id)) continue;
+      const localReport = loadLocalReport(id);
+      if (localReport) {
+        sourcesById.set(id, extractRollupSource(localReport));
+      }
+    }
+  }
+  const sources = Array.from(sourcesById.entries()).filter(([id]) => validIdSet.has(id)).map(([, source]) => source);
+  return {
+    version: ROLLUP_SOURCES_VERSION,
+    sources,
+    rollup: buildRollupData(sources)
+  };
+};
+var removeRollupSources = (file, deletedIds) => {
+  const deleted = new Set(deletedIds.map((id) => String(id || "").trim()).filter(Boolean));
+  const sources = file.sources.filter(
+    (source) => !deleted.has(String(source?.meta?.id || "").trim())
+  );
+  return {
+    version: ROLLUP_SOURCES_VERSION,
+    sources,
+    rollup: buildRollupData(sources)
+  };
+};
+var parseRollupSourcesFile = (data) => {
+  const candidate = data;
+  if (!candidate || typeof candidate !== "object") return null;
+  if (candidate.version !== ROLLUP_SOURCES_VERSION) return null;
+  if (!Array.isArray(candidate.sources)) return null;
+  if (!candidate.rollup || typeof candidate.rollup !== "object") return null;
+  return candidate;
+};
+var toFiniteNumber = (value) => {
+  const numeric = Number(value ?? 0);
+  return Number.isFinite(numeric) ? numeric : 0;
+};
+var parseTimestamp = (meta) => {
+  const candidates = [meta?.dateEnd, meta?.dateStart];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const parsed = new Date(candidate).getTime();
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return 0;
+};
+var parseGeneratedTimestamp = (meta) => {
+  const generated = meta?.generatedAt ? new Date(meta.generatedAt).getTime() : 0;
+  if (Number.isFinite(generated) && generated > 0) {
+    return generated;
+  }
+  return parseTimestamp(meta);
+};
+var buildRaidKey = (report, fallbackIndex) => {
+  const dateStart = String(report?.meta?.dateStart || "").trim();
+  const dateEnd = String(report?.meta?.dateEnd || "").trim();
+  if (dateStart || dateEnd) {
+    return `${dateStart}|${dateEnd}`;
+  }
+  const id = String(report?.meta?.id || "").trim();
+  if (id) return id;
+  return `report-${fallbackIndex}`;
+};
+var choosePrimaryProfession = (professionTimeMs, fallback = "Unknown") => {
+  const entries = Object.entries(professionTimeMs).filter(([profession, timeMs]) => profession && timeMs > 0).sort((a, b) => {
+    const delta = b[1] - a[1];
+    if (delta !== 0) return delta;
+    return a[0].localeCompare(b[0]);
+  });
+  return entries[0]?.[0] || fallback;
+};
+var chooseMostCommonProfession = (professionCounts, fallback = "Unknown") => {
+  const entries = Object.entries(professionCounts).filter(([profession, count]) => profession && count > 0).sort((a, b) => {
+    const delta = b[1] - a[1];
+    if (delta !== 0) return delta;
+    return a[0].localeCompare(b[0]);
+  });
+  return entries[0]?.[0] || fallback;
+};
+var buildProfessionBreakdown = (professionRuns) => Object.entries(professionRuns).filter(([profession, runs]) => profession && runs > 0).sort((a, b) => {
+  const delta = b[1] - a[1];
+  if (delta !== 0) return delta;
+  return a[0].localeCompare(b[0]);
+}).map(([profession, runs]) => ({ profession, runs }));
+var buildRollupData = (reports) => {
+  const uniqueRaidKeys = /* @__PURE__ */ new Set();
+  const reportsByRaid = /* @__PURE__ */ new Map();
+  reports.forEach((report, index) => {
+    const raidKey = buildRaidKey(report, index);
+    uniqueRaidKeys.add(raidKey);
+    const generatedTs = parseGeneratedTimestamp(report?.meta);
+    if (!reportsByRaid.has(raidKey)) {
+      reportsByRaid.set(raidKey, []);
+    }
+    reportsByRaid.get(raidKey).push({ report, generatedTs, index });
+  });
+  const raidGroups = Array.from(reportsByRaid.values()).sort((a, b) => {
+    const aLatest = Math.max(...a.map((entry) => entry.generatedTs || 0));
+    const bLatest = Math.max(...b.map((entry) => entry.generatedTs || 0));
+    if (bLatest !== aLatest) return bLatest - aLatest;
+    const aIndex = Math.max(...a.map((entry) => entry.index));
+    const bIndex = Math.max(...b.map((entry) => entry.index));
+    return bIndex - aIndex;
+  }).map((entries) => [...entries].sort((a, b) => {
+    if (b.generatedTs !== a.generatedTs) return b.generatedTs - a.generatedTs;
+    return b.index - a.index;
+  }));
+  const commanders = /* @__PURE__ */ new Map();
+  const players = /* @__PURE__ */ new Map();
+  let reportsWithCommanderDetails = 0;
+  let reportsMissingCommanderDetails = 0;
+  let reportsWithAttendanceDetails = 0;
+  let reportsMissingAttendanceDetails = 0;
+  let includedRaidGroups = 0;
+  let includedSourceReports = 0;
+  raidGroups.forEach((group) => {
+    const attendanceSource = group.find((entry) => Array.isArray(entry.report?.stats?.attendanceData) && entry.report.stats.attendanceData.length > 0) || null;
+    const attendanceReport = attendanceSource?.report || null;
+    const attendanceTimestamp = attendanceReport ? parseTimestamp(attendanceReport.meta) : 0;
+    const attendanceRows = Array.isArray(attendanceReport?.stats?.attendanceData) ? attendanceReport.stats.attendanceData : [];
+    if (attendanceRows.length > 0) {
+      reportsWithAttendanceDetails += 1;
+    } else {
+      reportsMissingAttendanceDetails += 1;
+    }
+    const latestCommanderRowsByAccount = /* @__PURE__ */ new Map();
+    group.forEach((entry) => {
+      const report = entry.report;
+      const timestamp = parseTimestamp(report?.meta);
+      const commanderRows2 = Array.isArray(report?.stats?.commanderStats?.rows) ? report.stats.commanderStats.rows : [];
+      commanderRows2.forEach((row) => {
+        const account = String(row?.account || row?.key || "").trim();
+        if (!account) return;
+        const existing = latestCommanderRowsByAccount.get(account);
+        if (!existing) {
+          latestCommanderRowsByAccount.set(account, { row, timestamp, generatedTs: entry.generatedTs, index: entry.index });
+          return;
+        }
+        const shouldReplace = entry.generatedTs > existing.generatedTs || entry.generatedTs === existing.generatedTs && entry.index > existing.index;
+        if (shouldReplace) {
+          latestCommanderRowsByAccount.set(account, { row, timestamp, generatedTs: entry.generatedTs, index: entry.index });
+        }
+      });
+    });
+    if (latestCommanderRowsByAccount.size > 0) {
+      reportsWithCommanderDetails += 1;
+    } else {
+      reportsMissingCommanderDetails += 1;
+    }
+    if (attendanceRows.length === 0 || latestCommanderRowsByAccount.size === 0) {
+      return;
+    }
+    includedRaidGroups += 1;
+    includedSourceReports += group.length;
+    attendanceRows.forEach((row) => {
+      const account = String(row?.account || "").trim();
+      if (!account || account === "Unknown") return;
+      const existing = players.get(account) || {
+        account,
+        characterNames: /* @__PURE__ */ new Set(),
+        professionTimeMs: {},
+        professionRuns: {},
+        runs: 0,
+        combatTimeMs: 0,
+        squadTimeMs: 0,
+        lastSeenTs: 0
+      };
+      existing.runs += 1;
+      existing.combatTimeMs += Math.max(0, toFiniteNumber(row?.combatTimeMs));
+      existing.squadTimeMs += Math.max(0, toFiniteNumber(row?.squadTimeMs));
+      existing.lastSeenTs = Math.max(existing.lastSeenTs, attendanceTimestamp);
+      if (Array.isArray(row?.characterNames)) {
+        row.characterNames.forEach((name) => {
+          const normalized = String(name || "").trim();
+          if (normalized) existing.characterNames.add(normalized);
+        });
+      }
+      const classTimes = Array.isArray(row?.classTimes) ? row.classTimes : [];
+      const professionsThisRun = /* @__PURE__ */ new Set();
+      classTimes.forEach((classRow) => {
+        const profession = String(classRow?.profession || "").trim();
+        if (!profession || profession === "Unknown") return;
+        const timeMs = Math.max(0, toFiniteNumber(classRow?.timeMs));
+        existing.professionTimeMs[profession] = (existing.professionTimeMs[profession] || 0) + timeMs;
+        if (timeMs > 0) professionsThisRun.add(profession);
+      });
+      professionsThisRun.forEach((profession) => {
+        existing.professionRuns[profession] = (existing.professionRuns[profession] || 0) + 1;
+      });
+      players.set(account, existing);
+    });
+    latestCommanderRowsByAccount.forEach(({ row, timestamp }) => {
+      const account = String(row?.account || row?.key || "").trim();
+      if (!account) return;
+      const existing = commanders.get(account) || {
+        account,
+        characterNames: /* @__PURE__ */ new Set(),
+        professionCounts: {},
+        runs: 0,
+        fightsLed: 0,
+        kills: 0,
+        downs: 0,
+        commanderDeaths: 0,
+        alliesDead: 0,
+        wins: 0,
+        losses: 0,
+        lastSeenTs: 0
+      };
+      existing.runs += 1;
+      existing.fightsLed += Math.max(0, toFiniteNumber(row?.fights));
+      existing.kills += Math.max(0, toFiniteNumber(row?.kills));
+      existing.downs += Math.max(0, toFiniteNumber(row?.downs));
+      existing.commanderDeaths += Math.max(0, toFiniteNumber(row?.commanderDeaths));
+      existing.alliesDead += Math.max(0, toFiniteNumber(row?.alliesDead));
+      existing.wins += Math.max(0, toFiniteNumber(row?.wins));
+      existing.losses += Math.max(0, toFiniteNumber(row?.losses));
+      existing.lastSeenTs = Math.max(existing.lastSeenTs, timestamp);
+      if (Array.isArray(row?.characterNames)) {
+        row.characterNames.forEach((name) => {
+          const normalized = String(name || "").trim();
+          if (normalized) existing.characterNames.add(normalized);
+        });
+      }
+      const profession = String(row?.profession || "").trim();
+      if (profession) {
+        existing.professionCounts[profession] = (existing.professionCounts[profession] || 0) + 1;
+      }
+      commanders.set(account, existing);
+    });
+  });
+  const commanderRows = Array.from(commanders.values()).map((entry) => {
+    const kdr = entry.alliesDead > 0 ? entry.kills / entry.alliesDead : entry.kills;
+    return {
+      account: entry.account,
+      characterNames: Array.from(entry.characterNames.values()).sort((a, b) => a.localeCompare(b)),
+      profession: chooseMostCommonProfession(entry.professionCounts),
+      professionBreakdown: buildProfessionBreakdown(entry.professionCounts),
+      runs: entry.runs,
+      fightsLed: entry.fightsLed,
+      kills: entry.kills,
+      downs: entry.downs,
+      commanderDeaths: entry.commanderDeaths,
+      alliesDead: entry.alliesDead,
+      wins: entry.wins,
+      losses: entry.losses,
+      kdr,
+      lastSeenTs: entry.lastSeenTs
+    };
+  }).sort((a, b) => {
+    if (b.runs !== a.runs) return b.runs - a.runs;
+    if (b.fightsLed !== a.fightsLed) return b.fightsLed - a.fightsLed;
+    if (b.kills !== a.kills) return b.kills - a.kills;
+    return a.account.localeCompare(b.account);
+  });
+  const playerRows = Array.from(players.values()).map((entry) => ({
+    account: entry.account,
+    characterNames: Array.from(entry.characterNames.values()).sort((a, b) => a.localeCompare(b)),
+    profession: choosePrimaryProfession(entry.professionTimeMs),
+    professionBreakdown: buildProfessionBreakdown(entry.professionRuns),
+    runs: entry.runs,
+    combatTimeMs: entry.combatTimeMs,
+    squadTimeMs: entry.squadTimeMs,
+    lastSeenTs: entry.lastSeenTs
+  })).sort((a, b) => {
+    if (b.runs !== a.runs) return b.runs - a.runs;
+    if (b.lastSeenTs !== a.lastSeenTs) return b.lastSeenTs - a.lastSeenTs;
+    if (b.squadTimeMs !== a.squadTimeMs) return b.squadTimeMs - a.squadTimeMs;
+    return a.account.localeCompare(b.account);
+  });
+  return {
+    commanderRows,
+    playerRows,
+    sourceReports: reports.length,
+    uniqueRaids: includedRaidGroups,
+    duplicateReportsCollapsed: Math.max(0, includedSourceReports - includedRaidGroups),
+    raidsSkippedMissingRequiredData: Math.max(0, raidGroups.length - includedRaidGroups),
+    reportsWithCommanderDetails,
+    reportsMissingCommanderDetails,
+    reportsWithAttendanceDetails,
+    reportsMissingAttendanceDetails
+  };
+};
+
+export {
+  ROLLUP_SOURCES_VERSION,
+  extractRollupSource,
+  updateRollupSourcesForPublish,
+  removeRollupSources,
+  parseRollupSourcesFile,
+  buildRollupData
+};

package/dist/chunk-FU74LJEM.js

@@ -0,0 +1,77 @@
+import {
+  computeDownContribution,
+  computeOutgoingCrowdControl,
+  computeSquadBarrier,
+  computeSquadHealing,
+  resolveDisruptionValue
+} from "./chunk-R5EJF5AW.js";
+import {
+  DEFAULT_DISRUPTION_METHOD
+} from "./chunk-KRHODGVU.js";
+
+// 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)
+});
+
+export {
+  getPlayerDamage,
+  getPlayerDps,
+  getPlayerCleanses,
+  getPlayerStrips,
+  getPlayerResurrects,
+  getPlayerDistanceToTag,
+  getPlayerBreakbarDamage,
+  getPlayerDamageTaken,
+  getPlayerDeaths,
+  getPlayerDodges,
+  getPlayerMissed,
+  getPlayerBlocked,
+  getPlayerEvaded,
+  getPlayerDownsTaken,
+  getTargetStatTotal,
+  getPlayerOutgoingInterrupts,
+  getPlayerDashboardTotals
+};

package/dist/chunk-J3YCFY3C.js

@@ -0,0 +1,37 @@
+import {
+  TIMESTAMP_MS_THRESHOLD
+} from "./chunk-ZFZS7JFU.js";
+
+// src/timestampUtils.ts
+var parseTimestamp = (value) => {
+  if (value === void 0 || value === null || value === "") return 0;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value <= 0) return 0;
+    return value > TIMESTAMP_MS_THRESHOLD ? value : value * 1e3;
+  }
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    return Number.isFinite(ms) && ms > 0 ? ms : 0;
+  }
+  const str = String(value).trim();
+  if (!str) return 0;
+  const numeric = Number(str);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    return numeric > TIMESTAMP_MS_THRESHOLD ? numeric : numeric * 1e3;
+  }
+  const parsed = Date.parse(str);
+  if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  const normalized = str.replace(/([+-]\d{2})$/, "$1:00");
+  const reparsed = Date.parse(normalized);
+  return Number.isFinite(reparsed) && reparsed > 0 ? reparsed : 0;
+};
+var resolveFightTimestamp = (details, log) => {
+  return parseTimestamp(
+    details?.timeStartStd ?? details?.timeStart ?? details?.timeEndStd ?? details?.timeEnd ?? details?.timeStartText ?? details?.timeEndText ?? details?.uploadTime ?? log?.uploadTime
+  );
+};
+
+export {
+  parseTimestamp,
+  resolveFightTimestamp
+};

package/dist/chunk-JP2ZL44R.js

@@ -0,0 +1,18 @@
+import {
+  RES_UTILITY_IDS,
+  RES_UTILITY_NAME_MATCHES
+} from "./chunk-42DVJJLC.js";
+
+// src/resUtility.ts
+var isResUtilitySkill = (id, skillMap) => {
+  if (RES_UTILITY_IDS.has(id)) {
+    return true;
+  }
+  const entry = skillMap?.[`s${id}`] || skillMap?.[`${id}`];
+  const name = entry?.name?.toLowerCase() || "";
+  return RES_UTILITY_NAME_MATCHES.some((match) => name.includes(match));
+};
+
+export {
+  isResUtilitySkill
+};

package/dist/chunk-KRHODGVU.js

@@ -0,0 +1,48 @@
+// 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";
+
+export {
+  METRICS_SPEC,
+  DEFAULT_DISRUPTION_METHOD
+};