wows-compute 0.0.0-stage → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,669 @@
+import { d as gameDay, f as inRange, l as outcomeOf, m as weekBoundary, p as parseBattleTime, u as statOutcome } from "./match-J2T9QiGg.mjs";
+import { PR_BANDS, PR_BANDS as PR_BANDS$1, PR_CATEGORY_LABELS, WIN_RATE_BANDS, WIN_RATE_BANDS as WIN_RATE_BANDS$1, calculateBattlePR, calculatePR, prCategory, prCategory as prCategory$1, shipExpectedValues, winRateCategory, winRateCategory as winRateCategory$1 } from "wows-number-api-sdk";
+//#region src/rating/index.ts
+const ACCOUNT_SHIP_ID = "__account__";
+function baselineOf(expected) {
+	return String(expected.time);
+}
+function resultValue(result) {
+	return result === null ? null : result.pr;
+}
+/** Unweighted mean of every ship that carries expected values. */
+function globalAverages(expected) {
+	let damage = 0;
+	let frags = 0;
+	let winRate = 0;
+	let count = 0;
+	for (const entry of Object.values(expected.data)) {
+		if (Array.isArray(entry)) continue;
+		damage += entry.average_damage_dealt;
+		frags += entry.average_frags;
+		winRate += entry.win_rate;
+		count += 1;
+	}
+	if (count === 0) return null;
+	return {
+		damage: damage / count,
+		frags: frags / count,
+		winRate: winRate / count
+	};
+}
+function estimateBias(expected, averages, shipMix) {
+	if (shipMix === void 0 || shipMix.length === 0) return {
+		direction: "unknown",
+		reason: "insufficient-data"
+	};
+	let battles = 0;
+	let expectedDamage = 0;
+	let expectedFrags = 0;
+	let expectedWins = 0;
+	for (const entry of shipMix) {
+		if (!Number.isFinite(entry.battles) || entry.battles <= 0) continue;
+		const values = shipExpectedValues(expected, entry.shipId);
+		if (values === null) continue;
+		battles += entry.battles;
+		expectedDamage += values.average_damage_dealt * entry.battles;
+		expectedFrags += values.average_frags * entry.battles;
+		expectedWins += values.win_rate / 100 * entry.battles;
+	}
+	if (battles === 0) return {
+		direction: "unknown",
+		reason: "insufficient-data"
+	};
+	const delta = {
+		damage: expectedDamage / battles / averages.damage - 1,
+		frags: expectedFrags / battles / averages.frags - 1,
+		wins: expectedWins / battles / (averages.winRate / 100) - 1
+	};
+	const directions = [
+		delta.damage,
+		delta.frags,
+		delta.wins
+	];
+	const positives = directions.filter((value) => value > 1e-9).length;
+	const negatives = directions.filter((value) => value < -1e-9).length;
+	let direction = "unknown";
+	if (positives === directions.length) direction = "overestimate";
+	else if (negatives === directions.length) direction = "underestimate";
+	else if (positives > 0 && negatives > 0) direction = "mixed";
+	return {
+		direction,
+		reason: "ship-mix",
+		delta
+	};
+}
+/** Personal Rating for one ship, using that ship's own expected values. */
+function shipPr(stats, expected, sample = {
+	kind: "lifetime",
+	matches: stats.battles
+}) {
+	const value = resultValue(calculatePR([stats], expected));
+	if (value === null) return null;
+	return {
+		value,
+		basis: "ship",
+		exact: true,
+		sample,
+		baselineVersion: baselineOf(expected)
+	};
+}
+/** Personal Rating for a single battle. */
+function battlePr(battle, expected, sample = {
+	kind: "match",
+	matches: 1
+}) {
+	const value = resultValue(calculateBattlePR(battle, expected));
+	if (value === null) return null;
+	return {
+		value,
+		basis: "ship",
+		exact: true,
+		sample,
+		baselineVersion: baselineOf(expected)
+	};
+}
+/**
+* Fast account PR*: account totals against the unweighted average of all
+* expected values.
+*
+* This is an estimate, not a different formula: the account is treated as one
+* synthetic ship. `exact: false` is a product promise — UI must mark it `PR*`.
+*/
+function accountPrEstimated(account, expected, options = {}) {
+	if (!Number.isFinite(account.battles) || account.battles <= 0) return null;
+	const averages = globalAverages(expected);
+	if (averages === null) return null;
+	const syntheticExpected = {
+		time: expected.time,
+		data: { [ACCOUNT_SHIP_ID]: {
+			average_damage_dealt: averages.damage,
+			average_frags: averages.frags,
+			win_rate: averages.winRate
+		} }
+	};
+	const synthetic = {
+		shipId: ACCOUNT_SHIP_ID,
+		battles: account.battles,
+		damage: account.damage,
+		frags: account.frags,
+		wins: account.wins
+	};
+	const value = resultValue(calculatePR([synthetic], syntheticExpected));
+	if (value === null) return null;
+	return {
+		value,
+		basis: "account",
+		exact: false,
+		sample: {
+			kind: "lifetime",
+			matches: account.battles
+		},
+		baselineVersion: baselineOf(expected),
+		bias: estimateBias(expected, averages, options.shipMix)
+	};
+}
+/**
+* Exact weighted account PR: pools per-ship totals and per-ship baselines.
+*
+* Ships without expected values are skipped by `calculatePR`, not counted
+* as zero.
+*/
+function accountPrPooled(ships, expected, sample) {
+	const value = resultValue(calculatePR(ships, expected));
+	if (value === null) return null;
+	return {
+		value,
+		basis: "account",
+		exact: true,
+		sample,
+		baselineVersion: baselineOf(expected)
+	};
+}
+//#endregion
+//#region src/aggregate/index.ts
+function emptyCoverage() {
+	return {
+		total: 0,
+		resolved: 0,
+		hidden: 0,
+		bot: 0,
+		failed: 0
+	};
+}
+function includedRecord(record, options) {
+	if (options.matchGroups !== void 0 && !options.matchGroups.includes(record.matchGroup)) return false;
+	if (record.battleTime === null) return options.from === void 0 && options.to === void 0;
+	if (options.from !== void 0 && record.battleTime < options.from) return false;
+	if (options.to !== void 0 && record.battleTime > options.to) return false;
+	return true;
+}
+function sampleOf(matches, players, options) {
+	const sample = {
+		kind: "ingested",
+		matches,
+		players
+	};
+	if (options.from !== void 0) sample.from = new Date(options.from).toISOString();
+	if (options.to !== void 0) sample.to = new Date(options.to).toISOString();
+	return sample;
+}
+function addShip(map, shipId, damage, frags, win) {
+	const key = String(shipId);
+	const current = map.get(key);
+	if (current === void 0) map.set(key, {
+		shipId,
+		battles: 1,
+		damage,
+		frags,
+		wins: win ? 1 : 0
+	});
+	else {
+		current.battles += 1;
+		current.damage += damage;
+		current.frags += frags;
+		if (win) current.wins += 1;
+	}
+}
+function scan(records, options, teamId) {
+	const coverage = emptyCoverage();
+	const players = /* @__PURE__ */ new Map();
+	const ships = /* @__PURE__ */ new Map();
+	let matches = 0;
+	for (const record of records) {
+		if (!includedRecord(record, options)) continue;
+		const participants = teamId === void 0 ? record.participants : record.participants.filter((participant) => participant.teamId === teamId);
+		if (participants.length === 0) continue;
+		matches += 1;
+		for (const participant of participants) {
+			coverage.total += 1;
+			if (participant.isBot) {
+				coverage.bot += 1;
+				continue;
+			}
+			if (participant.accountId === null) {
+				coverage.hidden += 1;
+				continue;
+			}
+			if (participant.result === null) {
+				coverage.failed += 1;
+				continue;
+			}
+			const outcome = outcomeOf(participant.teamId, record.winnerTeamId);
+			const statistical = statOutcome(outcome);
+			if (statistical === null) {
+				coverage.failed += 1;
+				continue;
+			}
+			coverage.resolved += 1;
+			const accountId = participant.accountId;
+			const damage = participant.result.damage ?? 0;
+			const frags = participant.result.frags ?? 0;
+			const win = statistical === "win";
+			let player = players.get(accountId);
+			if (player === void 0) {
+				player = {
+					accountId,
+					name: participant.name,
+					battles: 0,
+					wins: 0,
+					losses: 0,
+					draws: 0,
+					damage: 0,
+					frags: 0,
+					matches: 0,
+					ships: /* @__PURE__ */ new Map()
+				};
+				players.set(accountId, player);
+			}
+			player.matches += 1;
+			player.battles += 1;
+			if (outcome === "win") player.wins += 1;
+			else if (outcome === "loss") player.losses += 1;
+			else if (outcome === "draw") player.draws += 1;
+			player.damage += damage;
+			player.frags += frags;
+			if (participant.shipId !== null) {
+				addShip(player.ships, participant.shipId, damage, frags, win);
+				const ship = ships.get(participant.shipId);
+				if (ship === void 0) ships.set(participant.shipId, {
+					shipId: participant.shipId,
+					battles: 1,
+					wins: win ? 1 : 0,
+					losses: outcome === "loss" ? 1 : 0,
+					draws: outcome === "draw" ? 1 : 0,
+					damage,
+					frags,
+					players: /* @__PURE__ */ new Set([accountId])
+				});
+				else {
+					ship.battles += 1;
+					if (outcome === "win") ship.wins += 1;
+					else if (outcome === "loss") ship.losses += 1;
+					else ship.draws += 1;
+					ship.damage += damage;
+					ship.frags += frags;
+					ship.players.add(accountId);
+				}
+			}
+		}
+	}
+	return {
+		matches,
+		coverage,
+		players,
+		ships
+	};
+}
+function ratioOf(numerator, denominator) {
+	return denominator === 0 ? null : numerator / denominator;
+}
+function weightedMean(entries, weighting) {
+	let total = 0;
+	let weight = 0;
+	for (const entry of entries) {
+		const entryWeight = weighting === "equal" ? 1 : entry.weight;
+		if (entryWeight <= 0) continue;
+		total += entry.value * entryWeight;
+		weight += entryWeight;
+	}
+	return weight === 0 ? null : total / weight;
+}
+function playerPr(player, options, sample) {
+	if (options.expected === void 0 || player.ships.size === 0) return null;
+	return accountPrPooled([...player.ships.values()], options.expected, sample)?.value ?? null;
+}
+function playerCoverage(player) {
+	return {
+		total: player.battles,
+		resolved: player.battles,
+		hidden: 0,
+		bot: 0,
+		failed: 0
+	};
+}
+function playerValues(player, options, sample) {
+	const coverage = playerCoverage(player);
+	return {
+		accountId: player.accountId,
+		name: player.name,
+		battles: player.battles,
+		wins: player.wins,
+		losses: player.losses,
+		draws: player.draws,
+		damage: player.damage,
+		frags: player.frags,
+		winRate: {
+			value: ratioOf(player.wins * 100, player.battles),
+			sample,
+			coverage
+		},
+		avgDamage: {
+			value: ratioOf(player.damage, player.battles),
+			sample,
+			coverage
+		},
+		avgFrags: {
+			value: ratioOf(player.frags, player.battles),
+			sample,
+			coverage
+		},
+		pr: {
+			value: playerPr(player, options, sample),
+			sample,
+			coverage
+		}
+	};
+}
+/** Per-player aggregates over the selected records. Ordered by battles, then account id. */
+function aggregatePlayers(records, options) {
+	return [...scan(records, options).players.values()].map((player) => playerValues(player, options, sampleOf(player.matches, 1, options))).sort((a, b) => b.battles - a.battles || a.accountId - b.accountId);
+}
+/** One team's aggregate; coverage only counts that team's participants. */
+function aggregateTeam(records, teamId, options) {
+	const scanned = teamId === null ? scan(records, options) : scan(records, options, teamId);
+	const players = [...scanned.players.values()];
+	const sample = sampleOf(scanned.matches, players.length, options);
+	const coverage = scanned.coverage;
+	const winRate = weightedMean(players.filter((player) => player.battles > 0).map((player) => ({
+		value: player.wins / player.battles * 100,
+		weight: player.battles
+	})), options.weighting);
+	const avgDamage = weightedMean(players.filter((player) => player.battles > 0).map((player) => ({
+		value: player.damage / player.battles,
+		weight: player.battles
+	})), options.weighting);
+	const avgFrags = weightedMean(players.filter((player) => player.battles > 0).map((player) => ({
+		value: player.frags / player.battles,
+		weight: player.battles
+	})), options.weighting);
+	let pr = null;
+	if (options.expected !== void 0) {
+		if (options.prAggregation === "pooled") {
+			const ships = players.flatMap((player) => [...player.ships.values()]);
+			pr = ships.length === 0 ? null : accountPrPooled(ships, options.expected, sample)?.value ?? null;
+		} else pr = weightedMean(players.map((player) => ({
+			value: playerPr(player, options, sample),
+			weight: player.battles
+		})).filter((entry) => entry.value !== null), options.weighting);
+	}
+	return {
+		teamId,
+		players: players.length,
+		coverage,
+		values: {
+			winRate: {
+				value: winRate,
+				sample,
+				coverage
+			},
+			avgDamage: {
+				value: avgDamage,
+				sample,
+				coverage
+			},
+			avgFrags: {
+				value: avgFrags,
+				sample,
+				coverage
+			},
+			pr: {
+				value: pr,
+				sample,
+				coverage
+			}
+		}
+	};
+}
+/** Per-ship aggregates over the selected records. Ordered by battles, then ship id. */
+function aggregateShips(records, options) {
+	const scanned = scan(records, options);
+	const coverage = scanned.coverage;
+	const rows = [];
+	for (const ship of scanned.ships.values()) {
+		const sample = sampleOf(scanned.matches, ship.players.size, options);
+		const stats = {
+			shipId: ship.shipId,
+			battles: ship.battles,
+			damage: ship.damage,
+			frags: ship.frags,
+			wins: ship.wins
+		};
+		const pr = options.expected === void 0 ? null : accountPrPooled([stats], options.expected, sample)?.value ?? null;
+		rows.push({
+			shipId: ship.shipId,
+			battles: ship.battles,
+			wins: ship.wins,
+			losses: ship.losses,
+			draws: ship.draws,
+			damage: ship.damage,
+			frags: ship.frags,
+			winRate: {
+				value: ratioOf(ship.wins * 100, ship.battles),
+				sample,
+				coverage
+			},
+			avgDamage: {
+				value: ratioOf(ship.damage, ship.battles),
+				sample,
+				coverage
+			},
+			avgFrags: {
+				value: ratioOf(ship.frags, ship.battles),
+				sample,
+				coverage
+			},
+			pr: {
+				value: pr,
+				sample,
+				coverage
+			}
+		});
+	}
+	return rows.sort((a, b) => b.battles - a.battles || a.shipId - b.shipId);
+}
+/** Self performance per game day, ordered oldest first. */
+function dailySeries(records, options) {
+	const days = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (record.battleTime === null) continue;
+		if (options.matchGroups !== void 0 && !options.matchGroups.includes(record.matchGroup)) continue;
+		if (options.from !== void 0 && record.battleTime < options.from) continue;
+		if (options.to !== void 0 && record.battleTime > options.to) continue;
+		const self = record.participants.find((participant) => participant.relation === "self");
+		if (self === void 0 || self.result === null) continue;
+		const outcome = outcomeOf(self.teamId, record.winnerTeamId);
+		if (statOutcome(outcome) === null) continue;
+		const day = gameDay(record.battleTime, options.timeZone, options.boundaryHour);
+		let totals = days.get(day);
+		if (totals === void 0) {
+			totals = {
+				day,
+				matches: 0,
+				wins: 0,
+				losses: 0,
+				draws: 0,
+				damage: 0,
+				frags: 0,
+				ships: /* @__PURE__ */ new Map()
+			};
+			days.set(day, totals);
+		}
+		totals.matches += 1;
+		if (outcome === "win") totals.wins += 1;
+		else if (outcome === "loss") totals.losses += 1;
+		else totals.draws += 1;
+		const damage = self.result.damage ?? 0;
+		const frags = self.result.frags ?? 0;
+		totals.damage += damage;
+		totals.frags += frags;
+		if (self.shipId !== null) addShip(totals.ships, self.shipId, damage, frags, outcome === "win");
+	}
+	const points = [];
+	for (const totals of days.values()) {
+		const battles = totals.matches;
+		const coverage = {
+			total: battles,
+			resolved: battles,
+			hidden: 0,
+			bot: 0,
+			failed: 0
+		};
+		const sample = {
+			kind: "ingested",
+			matches: battles
+		};
+		const pr = options.expected === void 0 || totals.ships.size === 0 ? null : accountPrPooled([...totals.ships.values()], options.expected, sample)?.value ?? null;
+		points.push({
+			day: totals.day,
+			matches: totals.matches,
+			battles,
+			wins: totals.wins,
+			losses: totals.losses,
+			draws: totals.draws,
+			winRate: battles === 0 ? null : totals.wins / battles * 100,
+			avgDamage: battles === 0 ? null : totals.damage / battles,
+			avgFrags: battles === 0 ? null : totals.frags / battles,
+			pr: {
+				value: pr,
+				sample,
+				coverage
+			}
+		});
+	}
+	return points.sort((a, b) => a.day.localeCompare(b.day));
+}
+//#endregion
+//#region src/levels/index.ts
+/** Level key plus thresholds. Labels and colors belong to the application. */
+function levelOf(kind, value) {
+	if (!Number.isFinite(value)) return null;
+	const bands = kind === "pr" ? PR_BANDS$1 : WIN_RATE_BANDS$1;
+	const levelKey = kind === "pr" ? prCategory$1(value) : winRateCategory$1(value);
+	const index = bands.findIndex((band) => band.category === levelKey);
+	const band = bands[index];
+	if (band === void 0) return null;
+	const nextFloor = bands[index + 1]?.floor ?? null;
+	return {
+		levelKey,
+		floor: band.floor,
+		nextFloor,
+		deltaToFloor: band.floor === null ? null : value - band.floor,
+		deltaToNext: nextFloor === null ? null : nextFloor - value
+	};
+}
+//#endregion
+//#region src/recent/index.ts
+const DEFAULT_WINDOW = 20;
+function subjectParticipant(record, subject) {
+	if (subject.kind === "self") return record.participants.find((participant) => participant.relation === "self") ?? null;
+	return record.participants.find((participant) => participant.accountId === subject.accountId) ?? null;
+}
+function inDateRange(record, from, to) {
+	if (from === void 0 && to === void 0) return true;
+	if (record.battleTime === null) return false;
+	if (from !== void 0 && record.battleTime < from) return false;
+	if (to !== void 0 && record.battleTime > to) return false;
+	return true;
+}
+function compareNewestFirst(a, b) {
+	const timeA = a.battleTime ?? Number.NEGATIVE_INFINITY;
+	const timeB = b.battleTime ?? Number.NEGATIVE_INFINITY;
+	if (timeA !== timeB) return timeB - timeA;
+	return a.arenaId.localeCompare(b.arenaId);
+}
+function emptyStats() {
+	return {
+		battles: 0,
+		wins: 0,
+		losses: 0,
+		draws: 0,
+		winRate: null,
+		damage: 0,
+		frags: 0,
+		avgDamage: null,
+		avgFrags: null,
+		pr: null
+	};
+}
+/**
+* Statistics over ingested matches only.
+*
+* No gap filling, no lifetime totals, no historical replay scan: a match is in
+* the window only when it was successfully parsed and stored by the caller.
+*/
+function recentMatches(records, query, expected) {
+	const drawPolicy = query.drawPolicy ?? "loss";
+	const limit = query.last === void 0 ? DEFAULT_WINDOW : Math.max(0, Math.trunc(query.last));
+	let matches = records.filter((record) => {
+		if (query.matchGroups !== void 0 && !query.matchGroups.includes(record.matchGroup)) return false;
+		if (!inDateRange(record, query.from, query.to)) return false;
+		const participant = subjectParticipant(record, query.subject);
+		if (participant === null || participant.result === null) return false;
+		const outcome = outcomeOf(participant.teamId, record.winnerTeamId);
+		if (statOutcome(outcome) === null) return false;
+		if (drawPolicy === "exclude" && outcome === "draw") return false;
+		return true;
+	});
+	matches = matches.sort(compareNewestFirst).slice(0, limit);
+	const stats = emptyStats();
+	const ships = /* @__PURE__ */ new Map();
+	let damage = 0;
+	let frags = 0;
+	let wins = 0;
+	let losses = 0;
+	let draws = 0;
+	for (const record of matches) {
+		const participant = subjectParticipant(record, query.subject);
+		if (participant === null || participant.result === null) continue;
+		const outcome = outcomeOf(participant.teamId, record.winnerTeamId);
+		if (outcome === "win") wins += 1;
+		else if (outcome === "loss") losses += 1;
+		else if (outcome === "draw") draws += 1;
+		const resultDamage = participant.result.damage ?? 0;
+		const resultFrags = participant.result.frags ?? 0;
+		damage += resultDamage;
+		frags += resultFrags;
+		if (participant.shipId !== null) {
+			const key = String(participant.shipId);
+			const ship = ships.get(key);
+			if (ship === void 0) ships.set(key, {
+				shipId: participant.shipId,
+				battles: 1,
+				damage: resultDamage,
+				frags: resultFrags,
+				wins: outcome === "win" ? 1 : 0
+			});
+			else {
+				ship.battles += 1;
+				ship.damage += resultDamage;
+				ship.frags += resultFrags;
+				if (outcome === "win") ship.wins += 1;
+			}
+		}
+	}
+	const battles = matches.length;
+	stats.battles = battles;
+	stats.wins = wins;
+	stats.losses = losses;
+	stats.draws = draws;
+	stats.winRate = battles === 0 ? null : wins / battles * 100;
+	stats.damage = damage;
+	stats.frags = frags;
+	stats.avgDamage = battles === 0 ? null : damage / battles;
+	stats.avgFrags = battles === 0 ? null : frags / battles;
+	const sample = {
+		kind: "ingested",
+		matches: battles
+	};
+	if (query.from !== void 0) sample.from = new Date(query.from).toISOString();
+	if (query.to !== void 0) sample.to = new Date(query.to).toISOString();
+	if (query.subject.kind === "participant") sample.sharedWith = battles;
+	if (expected !== void 0 && ships.size > 0) stats.pr = accountPrPooled([...ships.values()], expected, sample);
+	return {
+		matches,
+		sample,
+		stats
+	};
+}
+//#endregion
+export { PR_BANDS, PR_CATEGORY_LABELS, WIN_RATE_BANDS, accountPrEstimated, accountPrPooled, aggregatePlayers, aggregateShips, aggregateTeam, battlePr, dailySeries, gameDay, inRange, levelOf, parseBattleTime, prCategory, recentMatches, shipPr, weekBoundary, winRateCategory };