wows-compute 0.0.0-stage → 1.0.0

package/dist/strength.d.mts

@@ -0,0 +1,80 @@
+import { r as Coverage, v as RatedValue } from "./index-DoUlnTgG.mjs";
+import { i as ArenaRoster } from "./types-DwmuyfXs.mjs";
+import { o as groupDivisions } from "./index-_QacyXDj.mjs";
+//#region src/strength/index.d.ts
+export type ShipRole = 'submarine' | 'aircraft-carrier' | 'destroyer' | 'battleship' | 'cruiser-functional' | 'cruiser-firepower' | 'cruiser' | 'unknown';
+/** Display / analysis order; not a composite score. */
+export declare const ROLE_ORDER: readonly ShipRole[];
+export interface ShipCatalogLike {
+  role?: (shipId: number) => ShipRole | null;
+  tier?: (shipId: number) => number | null;
+}
+export interface PlayerRatingSnapshot {
+  pr?: RatedValue | null;
+  /** Lifetime win rate in percent, e.g. `54.3`. */
+  winRate?: number | null;
+  battles?: number | null;
+}
+export type PlayerRatingValue = RatedValue | PlayerRatingSnapshot;
+export type PlayerRatings = ReadonlyMap<number, PlayerRatingValue>;
+export interface PlayerPoint {
+  accountId: number | null;
+  name: string | null;
+  /** `null` for pre-battle rosters; relations are known, team ids are not. */
+  teamId: number | null;
+  shipId: number | null;
+  shipRole: ShipRole;
+  tier: number | null;
+  divisionId: number | null;
+  /** Percentage, e.g. `54.3`. */
+  winRate: number | null;
+  pr: number | null;
+  prExact: boolean;
+  battles: number | null;
+  isBot: boolean;
+}
+export interface ReferenceLines {
+  winRateMedian: number | null;
+  prMedian: number | null;
+}
+export type Quadrant = 'q1' | 'q2' | 'q3' | 'q4' | 'unknown';
+export interface RoleWeightProfile {
+  weights?: Partial<Record<ShipRole, number>>;
+}
+export interface RoleMatchup {
+  role: ShipRole;
+  allyCount: number;
+  enemyCount: number;
+  allyMedianPr: number | null;
+  enemyMedianPr: number | null;
+  allyMedianWinRate: number | null;
+  enemyMedianWinRate: number | null;
+  /** Ally median minus enemy median; `null` when either side lacks values. */
+  prDiff: number | null;
+  winRateDiff: number | null;
+  weight: number | null;
+  sample: {
+    ally: number;
+    enemy: number;
+  };
+  coverage: Coverage;
+}
+/** Maps a roster to scatter-plot points. Bots and hidden players stay in the list. */
+export declare function buildPlayerPoints(roster: ArenaRoster, ratings: PlayerRatings, catalog?: ShipCatalogLike): PlayerPoint[];
+export declare function median(values: readonly number[]): number | null;
+export declare function referenceLines(points: readonly PlayerPoint[]): ReferenceLines;
+/**
+ * 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.
+ */
+export declare function quadrantOf(point: PlayerPoint, reference: ReferenceLines): Quadrant;
+/**
+ * Per-role ally/enemy comparison.
+ *
+ * Returns differences and samples only; no composite score and no prediction.
+ */
+export declare function pairByRole(ally: readonly PlayerPoint[], enemy: readonly PlayerPoint[], profile?: RoleWeightProfile): RoleMatchup[];
+//#endregion
+export { groupDivisions };

package/dist/strength.mjs

@@ -0,0 +1,154 @@
+import { i as groupDivisions } from "./match-J2T9QiGg.mjs";
+//#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
+	};
+	if (isRatedValue(value)) return {
+		pr: value,
+		winRate: null,
+		battles: value.sample.matches
+	};
+	return {
+		pr: value.pr ?? null,
+		winRate: value.winRate ?? null,
+		battles: value.battles ?? value.pr?.sample.matches ?? null
+	};
+}
+/** 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
+		};
+	});
+}
+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)
+		};
+	});
+}
+//#endregion
+export { ROLE_ORDER, buildPlayerPoints, groupDivisions, median, pairByRole, quadrantOf, referenceLines };

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.0.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"
+  }
 }