wows-compute 0.0.0-stage → 1.1.0

package/dist/strength-CBihFxZD.mjs

@@ -0,0 +1,243 @@
+//#region src/strength/index.ts
+/** Display / analysis order; not a composite score. */
+const ROLE_ORDER = [
+	"submarine",
+	"aircraft-carrier",
+	"destroyer",
+	"battleship",
+	"cruiser-functional",
+	"cruiser-firepower",
+	"cruiser",
+	"unknown"
+];
+function isRatedValue(value) {
+	return "value" in value && "basis" in value && "exact" in value;
+}
+function normalize(value) {
+	if (value === void 0) return {
+		pr: null,
+		winRate: null,
+		battles: null,
+		avgDamage: null,
+		avgFrags: null,
+		hidden: false
+	};
+	if (isRatedValue(value)) return {
+		pr: value,
+		winRate: null,
+		battles: value.sample.matches,
+		avgDamage: null,
+		avgFrags: null,
+		hidden: false
+	};
+	return {
+		pr: value.pr ?? null,
+		winRate: value.winRate ?? null,
+		battles: value.battles ?? value.pr?.sample.matches ?? null,
+		avgDamage: value.avgDamage ?? null,
+		avgFrags: value.avgFrags ?? null,
+		hidden: value.hidden ?? false
+	};
+}
+/** Maps a roster to scatter-plot points. Bots and hidden players stay in the list. */
+function buildPlayerPoints(roster, ratings, catalog) {
+	return roster.participants.map((participant) => {
+		const rating = participant.accountId === null ? normalize(void 0) : normalize(ratings.get(participant.accountId));
+		return {
+			accountId: participant.accountId,
+			name: participant.name,
+			teamId: null,
+			shipId: participant.shipId,
+			shipRole: participant.shipId === null ? "unknown" : catalog?.role?.(participant.shipId) ?? "unknown",
+			tier: participant.shipId === null ? null : catalog?.tier?.(participant.shipId) ?? null,
+			divisionId: null,
+			winRate: rating.winRate,
+			pr: rating.pr?.value ?? null,
+			prExact: rating.pr?.exact ?? false,
+			battles: rating.battles,
+			isBot: participant.isBot,
+			relation: participant.relation,
+			avgDamage: rating.avgDamage,
+			avgFrags: rating.avgFrags,
+			hidden: rating.hidden
+		};
+	});
+}
+function median(values) {
+	if (values.length === 0) return null;
+	const sorted = [...values].sort((a, b) => a - b);
+	const middle = Math.floor(sorted.length / 2);
+	if (sorted.length % 2 === 1) return sorted[middle];
+	return (sorted[middle - 1] + sorted[middle]) / 2;
+}
+function referenceLines(points) {
+	return {
+		winRateMedian: median(points.map((point) => point.winRate).filter((value) => value !== null)),
+		prMedian: median(points.map((point) => point.pr).filter((value) => value !== null))
+	};
+}
+/**
+* Quadrants relative to the reference lines.
+*
+* q1 high win rate + high PR, q2 low win rate + high PR,
+* q3 low + low, q4 high win rate + low PR.
+*/
+function quadrantOf(point, reference) {
+	if (point.winRate === null || point.pr === null || reference.winRateMedian === null || reference.prMedian === null) return "unknown";
+	const highWinRate = point.winRate >= reference.winRateMedian;
+	const highPr = point.pr >= reference.prMedian;
+	if (highWinRate) return highPr ? "q1" : "q4";
+	return highPr ? "q2" : "q3";
+}
+function roleCoverage(ally, enemy) {
+	const coverage = {
+		total: 0,
+		resolved: 0,
+		hidden: 0,
+		bot: 0,
+		failed: 0
+	};
+	for (const point of [...ally, ...enemy]) {
+		coverage.total += 1;
+		if (point.isBot) {
+			coverage.bot += 1;
+			continue;
+		}
+		if (point.accountId === null) {
+			coverage.hidden += 1;
+			continue;
+		}
+		if (point.pr === null) {
+			coverage.failed += 1;
+			continue;
+		}
+		coverage.resolved += 1;
+	}
+	return coverage;
+}
+function diff(left, right) {
+	return left === null || right === null ? null : left - right;
+}
+/**
+* Per-role ally/enemy comparison.
+*
+* Returns differences and samples only; no composite score and no prediction.
+*/
+function pairByRole(ally, enemy, profile) {
+	const allyByRole = /* @__PURE__ */ new Map();
+	const enemyByRole = /* @__PURE__ */ new Map();
+	for (const point of ally) {
+		const list = allyByRole.get(point.shipRole) ?? [];
+		list.push(point);
+		allyByRole.set(point.shipRole, list);
+	}
+	for (const point of enemy) {
+		const list = enemyByRole.get(point.shipRole) ?? [];
+		list.push(point);
+		enemyByRole.set(point.shipRole, list);
+	}
+	return ROLE_ORDER.filter((role) => allyByRole.has(role) || enemyByRole.has(role)).map((role) => {
+		const allies = allyByRole.get(role) ?? [];
+		const enemies = enemyByRole.get(role) ?? [];
+		const allyMedianPr = median(allies.map((point) => point.pr).filter((value) => value !== null));
+		const enemyMedianPr = median(enemies.map((point) => point.pr).filter((value) => value !== null));
+		const allyMedianWinRate = median(allies.map((point) => point.winRate).filter((value) => value !== null));
+		const enemyMedianWinRate = median(enemies.map((point) => point.winRate).filter((value) => value !== null));
+		return {
+			role,
+			allyCount: allies.length,
+			enemyCount: enemies.length,
+			allyMedianPr,
+			enemyMedianPr,
+			allyMedianWinRate,
+			enemyMedianWinRate,
+			prDiff: diff(allyMedianPr, enemyMedianPr),
+			winRateDiff: diff(allyMedianWinRate, enemyMedianWinRate),
+			weight: profile?.weights?.[role] ?? null,
+			sample: {
+				ally: allies.length,
+				enemy: enemies.length
+			},
+			coverage: roleCoverage(allies, enemies)
+		};
+	});
+}
+function summaryCoverage(points) {
+	const coverage = {
+		total: 0,
+		resolved: 0,
+		hidden: 0,
+		bot: 0,
+		failed: 0
+	};
+	for (const point of points) {
+		coverage.total += 1;
+		if (point.isBot) {
+			coverage.bot += 1;
+			continue;
+		}
+		if (point.hidden || point.accountId === null) {
+			coverage.hidden += 1;
+			continue;
+		}
+		if (point.winRate === null && point.avgDamage === null && point.avgFrags === null && point.pr === null) {
+			coverage.failed += 1;
+			continue;
+		}
+		coverage.resolved += 1;
+	}
+	return coverage;
+}
+function meanOf(points, metric, weighting) {
+	let total = 0;
+	let weightSum = 0;
+	for (const point of points) {
+		const value = point[metric];
+		if (value === null) continue;
+		const weight = weighting === "battles" ? point.battles ?? 0 : 1;
+		if (weight <= 0) continue;
+		total += value * weight;
+		weightSum += weight;
+	}
+	return weightSum === 0 ? null : total / weightSum;
+}
+/**
+* Reduces normalized player points into one side's overview.
+*
+* Averages only over non-null values; `0` is a valid value. Empty input
+* returns an all-zero summary rather than throwing.
+*/
+function summarizePlayers(points, options = {}) {
+	const weighting = options.weighting ?? "equal";
+	const coverage = summaryCoverage(points);
+	const members = points.filter((point) => !point.isBot);
+	let battles = 0;
+	for (const point of members) if (point.battles !== null) battles += point.battles;
+	return {
+		total: coverage.total,
+		players: coverage.total - coverage.bot,
+		battles,
+		coverage,
+		winRate: meanOf(members, "winRate", weighting),
+		avgDamage: meanOf(members, "avgDamage", weighting),
+		avgFrags: meanOf(members, "avgFrags", weighting),
+		pr: meanOf(members, "pr", weighting),
+		prExact: false
+	};
+}
+/** Groups points by `relation` and summarizes both sides. */
+function summarizeRoster(points, options = {}) {
+	const ally = [];
+	const enemy = [];
+	let unassigned = 0;
+	for (const point of points) if (point.relation === "self" || point.relation === "ally") ally.push(point);
+	else if (point.relation === "enemy") enemy.push(point);
+	else unassigned += 1;
+	return {
+		ally: summarizePlayers(ally, options),
+		enemy: summarizePlayers(enemy, options),
+		unassigned
+	};
+}
+//#endregion
+export { quadrantOf as a, summarizeRoster as c, pairByRole as i, buildPlayerPoints as n, referenceLines as o, median as r, summarizePlayers as s, ROLE_ORDER as t };

package/dist/strength.d.mts

@@ -0,0 +1,3 @@
+import { _ as pairByRole, a as PlayerSummary, b as summarizePlayers, c as ReferenceLines, d as RosterSummary, f as ShipCatalogLike, g as median, h as buildPlayerPoints, i as PlayerRatings, l as RoleMatchup, m as SummaryOptions, n as PlayerRatingSnapshot, o as Quadrant, p as ShipRole, r as PlayerRatingValue, s as ROLE_ORDER, t as PlayerPoint, u as RoleWeightProfile, v as quadrantOf, x as summarizeRoster, y as referenceLines } from "./index-CkKx_Wtz.mjs";
+import { o as groupDivisions } from "./index-_QacyXDj.mjs";
+export { PlayerPoint, PlayerRatingSnapshot, PlayerRatingValue, PlayerRatings, PlayerSummary, Quadrant, ROLE_ORDER, ReferenceLines, RoleMatchup, RoleWeightProfile, RosterSummary, ShipCatalogLike, ShipRole, SummaryOptions, buildPlayerPoints, groupDivisions, median, pairByRole, quadrantOf, referenceLines, summarizePlayers, summarizeRoster };

package/dist/strength.mjs

@@ -0,0 +1,3 @@
+import { i as groupDivisions } from "./match-J2T9QiGg.mjs";
+import { a as quadrantOf, c as summarizeRoster, i as pairByRole, n as buildPlayerPoints, o as referenceLines, r as median, s as summarizePlayers, t as ROLE_ORDER } from "./strength-CBihFxZD.mjs";
+export { ROLE_ORDER, buildPlayerPoints, groupDivisions, median, pairByRole, quadrantOf, referenceLines, summarizePlayers, summarizeRoster };

package/dist/types-DwmuyfXs.d.mts

@@ -0,0 +1,175 @@
+//#region src/match/types.d.ts
+type MatchGroup = 'pvp' | 'ranked' | 'coop' | 'clan' | 'brawl' | 'event' | 'unknown';
+type Relation = 'self' | 'ally' | 'enemy' | 'unknown';
+type Outcome = 'win' | 'loss' | 'draw' | 'unknown';
+/** Statistical outcome: a draw counts as a loss for both teams. */
+type StatOutcome = 'win' | 'loss';
+type RecordQuality = 'meta-only' | 'partial' | 'complete';
+type ResultValue = string | number | boolean | null | ResultValue[] | {
+  [key: string]: ResultValue;
+};
+interface ArenaRoster {
+  provisionalId: string;
+  battleTime: number | null;
+  gameMode: number | null;
+  matchGroup: MatchGroup;
+  mapId: number | null;
+  mapName: string | null;
+  clientVersion: string | null;
+  durationSec: number | null;
+  playersPerTeam: number | null;
+  participants: RosterParticipant[];
+  raw: unknown;
+}
+interface RosterParticipant {
+  accountId: number | null;
+  name: string | null;
+  clanId: number | null;
+  clanTag: string | null;
+  shipId: number | null;
+  relation: Relation;
+  isBot: boolean;
+}
+interface MatchRecord {
+  arenaId: string;
+  provisionalIds: string[];
+  battleTime: number | null;
+  gameMode: number | null;
+  matchGroup: MatchGroup;
+  mapId: number | null;
+  mapName: string | null;
+  clientVersion: string | null;
+  durationSec: number | null;
+  winnerTeamId: number | null;
+  outcome: Outcome;
+  participants: MatchParticipant[];
+  quality: RecordQuality;
+  ingestedAt: number;
+  parsedAt: number;
+  mappingVersion: string | null;
+  source: MatchSource;
+  raw?: unknown;
+}
+interface MatchSource {
+  kind: 'replay';
+  fileName?: string;
+  size?: number;
+  mtimeMs?: number;
+}
+interface MatchParticipant {
+  accountId: number | null;
+  name: string | null;
+  clanId: number | null;
+  clanTag: string | null;
+  shipId: number | null;
+  teamId: number | null;
+  relation: Relation;
+  isBot: boolean;
+  divisionId: number | null;
+  result: PlayerResult | null;
+}
+interface PlayerResult {
+  damage: number | null;
+  frags: number | null;
+  exp: number | null;
+  rawExp: number | null;
+  isAlive: boolean | null;
+  lifeTimeSec: number | null;
+  scoutingDamage: number | null;
+  killerAccountId: number | null;
+  interactions: Record<string, Record<string, ResultValue>>;
+  fields: Record<string, ResultValue>;
+}
+interface ArenaInfoVehicle {
+  id?: number | null;
+  name?: string | null;
+  shipId?: number | null;
+  relation?: number | null;
+}
+/** Structural subset of `tempArenaInfo.json`; unknown keys are preserved in `raw`. */
+interface ArenaInfoLike {
+  matchGroup?: string | null;
+  gameMode?: number | null;
+  mapId?: number | null;
+  mapName?: string | null;
+  clientVersionFromExe?: string | null;
+  duration?: number | null;
+  battleDuration?: number | null;
+  playersPerTeam?: number | null;
+  dateTime?: string | null;
+  vehicles?: readonly ArenaInfoVehicle[] | null;
+  [key: string]: unknown;
+}
+interface ReplayVehicleLike {
+  id?: number | null;
+  name?: string | null;
+  shipId?: number | null;
+  relation?: number | null;
+}
+interface ReplayMetaLike {
+  dateTime?: string | null;
+  mapId?: number | null;
+  mapName?: string | null;
+  gameMode?: number | null;
+  gameType?: string | null;
+  matchGroup?: string | null;
+  clientVersionFromExe?: string | null;
+  duration?: number | null;
+  battleDuration?: number | null;
+  playersPerTeam?: number | null;
+  playerID?: number | null;
+  playerName?: string | null;
+  vehicles?: readonly ReplayVehicleLike[] | null;
+  [key: string]: unknown;
+}
+interface ReplayPlayerLike {
+  accountId: number | null;
+  name: string | null;
+  clanId: number | null;
+  clanTag: string | null;
+  teamId: number | null;
+  shipId: number | null;
+  damage: number | null;
+  frags: number | null;
+  exp: number | null;
+  rawExp: number | null;
+  isAlive: boolean | null;
+  lifeTimeSec: number | null;
+  scoutingDamage: number | null;
+  killerAccountId: number | null;
+  interactions: Record<string, Record<string, ResultValue>>;
+  fields: Record<string, ResultValue>;
+}
+interface ReplayCommonLike {
+  winnerTeamId?: number | null;
+  durationSec?: number | null;
+  gameMode?: number | null;
+  scenarioName?: string | null;
+  startDt?: number | null;
+}
+interface ReplayResultsLike {
+  arenaId?: number | null;
+  accountId?: number | null;
+  mappingVersion?: string | null;
+  common?: ReplayCommonLike | null;
+  players: readonly ReplayPlayerLike[];
+  raw?: unknown;
+}
+/** Structural subset of `ParsedReplay` from `wows-replay-parser`. */
+interface ReplayFacts {
+  meta: ReplayMetaLike;
+  battleResults: ReplayResultsLike | null;
+}
+interface ArenaKeyInput {
+  arenaId?: number | null;
+  battleTime: number | null;
+  mapId: number | null;
+  accountIds: readonly (number | null)[];
+}
+interface Division {
+  teamId: number | null;
+  divisionId: number;
+  participants: MatchParticipant[];
+}
+//#endregion
+export { StatOutcome as S, ReplayPlayerLike as _, Division as a, ResultValue as b, MatchRecord as c, PlayerResult as d, RecordQuality as f, ReplayMetaLike as g, ReplayFacts as h, ArenaRoster as i, MatchSource as l, ReplayCommonLike as m, ArenaInfoVehicle as n, MatchGroup as o, Relation as p, ArenaKeyInput as r, MatchParticipant as s, ArenaInfoLike as t, Outcome as u, ReplayResultsLike as v, RosterParticipant as x, ReplayVehicleLike as y };

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "wows-compute",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.1.0",
+  "description": "Pure TypeScript computation kernels for World of Warships match records, ratings and aggregates.",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "keywords": [
+    "world-of-warships",
+    "wows",
+    "personal-rating",
+    "statistics",
+    "compute"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./match": {
+      "types": "./dist/match.d.mts",
+      "import": "./dist/match.mjs"
+    },
+    "./metrics": {
+      "types": "./dist/metrics.d.mts",
+      "import": "./dist/metrics.mjs"
+    },
+    "./strength": {
+      "types": "./dist/strength.d.mts",
+      "import": "./dist/strength.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "wows-number-api-sdk": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "tsdown": "^0.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.5",
+    "wows-replay-parser": "^1.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/urara-chiya/wows-devkit.git",
+    "directory": "packages/wows-compute"
+  },
+  "homepage": "https://github.com/urara-chiya/wows-devkit#readme",
+  "bugs": {
+    "url": "https://github.com/urara-chiya/wows-devkit/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
 }