volleyballsimtypes 0.0.417 → 0.0.419

package/dist/cjs/src/service/match/index.d.ts

@@ -4,6 +4,7 @@ export * from './match-generator';
 export * from './match-rating';
 export * from './match-set';
 export * from './rally';
+export * from './point-breakdown';
 export * from './court-position';
 export * from './match-team';
 export * from './vper';

package/dist/cjs/src/service/match/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./match-generator"), exports);
 __exportStar(require("./match-rating"), exports);
 __exportStar(require("./match-set"), exports);
 __exportStar(require("./rally"), exports);
+__exportStar(require("./point-breakdown"), exports);
 __exportStar(require("./court-position"), exports);
 __exportStar(require("./match-team"), exports);
 __exportStar(require("./vper"), exports);

package/dist/cjs/src/service/match/point-breakdown.d.ts

@@ -0,0 +1,36 @@
+export interface RallyEventLike {
+    readonly eventType: number;
+    readonly playerId: string;
+}
+export interface RallyLike {
+    readonly events: readonly RallyEventLike[];
+}
+export interface TeamBlockTally {
+    blockPoints: number;
+    blockSolo: number;
+    blockAssists: number;
+}
+export declare function tallyBlockPoints(rallies: readonly RallyLike[], teamOf: (playerId: string) => string | null): Map<string, TeamBlockTally>;
+export interface TeamPointBreakdown {
+    kills: number;
+    aces: number;
+    blockPoints: number;
+    opponentErrors: number;
+}
+export interface PointBreakdown {
+    home: TeamPointBreakdown;
+    away: TeamPointBreakdown;
+}
+export interface PointBreakdownInput {
+    rallies: readonly RallyLike[];
+    homeTeamId: string;
+    awayTeamId: string;
+    teamOf: (playerId: string) => string | null;
+    homeKills: number;
+    awayKills: number;
+    homeAces: number;
+    awayAces: number;
+    homeTotalPoints: number;
+    awayTotalPoints: number;
+}
+export declare function computePointBreakdown(input: PointBreakdownInput): PointBreakdown;

package/dist/cjs/src/service/match/point-breakdown.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tallyBlockPoints = tallyBlockPoints;
+exports.computePointBreakdown = computePointBreakdown;
+const event_1 = require("../event");
+// A block scores a point in exactly ONE place in the sim (reception-simulator: a dig of a block fails
+// and the block landed in-court, i.e. target >= 7). Each such rally is ONE block point regardless of how
+// many blockers were on it; the box score records it as one `block_assists` per blocker (or one
+// `block_solo`), which is why summing solo+assists over-counts block points. We rebuild the true count
+// from the rallies. blockSolo / blockAssists must reconstruct box.block.solo and box.block.assists
+// exactly (the correctness gate). `teamOf(playerId)` returns a player's team id (or null); the scoring
+// team is the blockers' team.
+function tallyBlockPoints(rallies, teamOf) {
+    const out = new Map();
+    const tallyFor = (team) => {
+        let t = out.get(team);
+        if (t == null) {
+            t = { blockPoints: 0, blockSolo: 0, blockAssists: 0 };
+            out.set(team, t);
+        }
+        return t;
+    };
+    for (const rally of rallies) {
+        // Ignore substitutions / libero replacements (eventType < SERVE) when locating the terminal action.
+        const inPlay = rally.events.filter(e => e.eventType >= event_1.EventTypeEnum.SERVE);
+        const last = inPlay[inPlay.length - 1];
+        const prev = inPlay[inPlay.length - 2];
+        if (last == null || prev == null)
+            continue;
+        // Block point signature: the rally ends on a failed RECEPTION (dig) whose previous event is a BLOCK
+        // that landed in-court (target >= 7). target < 7 is a deflection -> the ATTACKER's kill, not a block.
+        if (last.eventType !== event_1.EventTypeEnum.RECEPTION || last.failure <= 0)
+            continue;
+        if (prev.eventType !== event_1.EventTypeEnum.BLOCK)
+            continue;
+        const block = prev;
+        if (block.target < 7)
+            continue;
+        const team = teamOf(block.blockers[0] ?? block.playerId);
+        if (team == null)
+            continue;
+        const t = tallyFor(team);
+        t.blockPoints++;
+        if (block.blockers.length < 2)
+            t.blockSolo++;
+        else
+            t.blockAssists += block.blockers.length;
+    }
+    return out;
+}
+// Kills/aces come straight from the box score; block points are derived from rallies; opponent errors
+// are the remainder (>= 0 by construction). The four reconcile to the team's total points.
+function computePointBreakdown(input) {
+    const tally = tallyBlockPoints(input.rallies, input.teamOf);
+    const homeBlocks = tally.get(input.homeTeamId)?.blockPoints ?? 0;
+    const awayBlocks = tally.get(input.awayTeamId)?.blockPoints ?? 0;
+    return {
+        home: {
+            kills: input.homeKills,
+            aces: input.homeAces,
+            blockPoints: homeBlocks,
+            opponentErrors: input.homeTotalPoints - input.homeKills - input.homeAces - homeBlocks
+        },
+        away: {
+            kills: input.awayKills,
+            aces: input.awayAces,
+            blockPoints: awayBlocks,
+            opponentErrors: input.awayTotalPoints - input.awayKills - input.awayAces - awayBlocks
+        }
+    };
+}

package/dist/cjs/src/service/match/point-breakdown.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/src/service/match/point-breakdown.test.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const event_1 = require("../event");
+const point_breakdown_1 = require("./point-breakdown");
+const blockEvent = (playerId, target, blockers) => ({ eventType: event_1.EventTypeEnum.BLOCK, playerId, target, blockers });
+const receptionEvent = (playerId, failure) => ({ eventType: event_1.EventTypeEnum.RECEPTION, playerId, failure });
+const serveEvent = (playerId) => ({ eventType: event_1.EventTypeEnum.SERVE, playerId });
+const spikeEvent = (playerId) => ({ eventType: event_1.EventTypeEnum.SPIKE, playerId });
+const rally = (events) => ({ events });
+const teamOf = (id) => id.startsWith('h') ? 'HOME' : id.startsWith('a') ? 'AWAY' : null;
+(0, globals_1.describe)('tallyBlockPoints', () => {
+    (0, globals_1.it)('counts an assisted block point once, recording each blocker as an assist', () => {
+        const t = (0, point_breakdown_1.tallyBlockPoints)([rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 1)])], teamOf);
+        (0, globals_1.expect)(t.get('HOME')).toEqual({ blockPoints: 1, blockSolo: 0, blockAssists: 2 });
+    });
+    (0, globals_1.it)('counts a solo block point', () => {
+        const t = (0, point_breakdown_1.tallyBlockPoints)([rally([blockEvent('h1', 9, ['h1']), receptionEvent('a3', 2)])], teamOf);
+        (0, globals_1.expect)(t.get('HOME')).toEqual({ blockPoints: 1, blockSolo: 1, blockAssists: 0 });
+    });
+    (0, globals_1.it)('does NOT count a deflection (target < 7) - that is the attacker\'s kill', () => {
+        const t = (0, point_breakdown_1.tallyBlockPoints)([rally([blockEvent('h1', 4, ['h1', 'h2']), receptionEvent('a3', 1)])], teamOf);
+        (0, globals_1.expect)(t.size).toBe(0);
+    });
+    (0, globals_1.it)('does NOT count an ace (reception fail after serve)', () => {
+        const t = (0, point_breakdown_1.tallyBlockPoints)([rally([serveEvent('h1'), receptionEvent('a3', 1)])], teamOf);
+        (0, globals_1.expect)(t.size).toBe(0);
+    });
+    (0, globals_1.it)('does NOT count a successful dig (reception failure 0)', () => {
+        const t = (0, point_breakdown_1.tallyBlockPoints)([rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 0), spikeEvent('a3')])], teamOf);
+        (0, globals_1.expect)(t.size).toBe(0);
+    });
+    (0, globals_1.it)('reconstructs box block.solo and block.assists across a mix (incl. a triple block)', () => {
+        const t = (0, point_breakdown_1.tallyBlockPoints)([
+            rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 1)]), // double: +2 assists
+            rally([blockEvent('h3', 8, ['h3', 'h4', 'h5']), receptionEvent('a1', 1)]), // triple: +3 assists
+            rally([blockEvent('h1', 9, ['h1']), receptionEvent('a2', 1)]), // solo: +1 solo
+            rally([blockEvent('a1', 8, ['a1', 'a2']), receptionEvent('h2', 1)]) // away double
+        ], teamOf);
+        (0, globals_1.expect)(t.get('HOME')).toEqual({ blockPoints: 3, blockSolo: 1, blockAssists: 5 });
+        (0, globals_1.expect)(t.get('AWAY')).toEqual({ blockPoints: 1, blockSolo: 0, blockAssists: 2 });
+    });
+});
+(0, globals_1.describe)('computePointBreakdown', () => {
+    (0, globals_1.it)('reproduces the prod bug scenario as a positive number (was -3)', () => {
+        // AWAY scored 99 (54 kills, 0 aces) and 28 block points (8 solo + 20 doubles). Old formula did
+        // 99 - 54 - (8 + 40) - 0 = -3; correct is 99 - 54 - 0 - 28 = 17.
+        const rallies = [];
+        for (let i = 0; i < 20; i++)
+            rallies.push(rally([blockEvent('a1', 8, ['a1', 'a2']), receptionEvent(`h${i}`, 1)]));
+        for (let i = 0; i < 8; i++)
+            rallies.push(rally([blockEvent('a3', 9, ['a3']), receptionEvent(`h${i + 20}`, 1)]));
+        const out = (0, point_breakdown_1.computePointBreakdown)({
+            rallies,
+            homeTeamId: 'HOME',
+            awayTeamId: 'AWAY',
+            teamOf,
+            homeKills: 51,
+            awayKills: 54,
+            homeAces: 3,
+            awayAces: 0,
+            homeTotalPoints: 108,
+            awayTotalPoints: 99
+        });
+        (0, globals_1.expect)(out.away.blockPoints).toBe(28);
+        (0, globals_1.expect)(out.away.opponentErrors).toBe(17);
+        (0, globals_1.expect)(out.away.opponentErrors).toBeGreaterThanOrEqual(0);
+        // The four categories reconcile to the team's total points.
+        (0, globals_1.expect)(out.away.kills + out.away.aces + out.away.blockPoints + out.away.opponentErrors).toBe(99);
+        (0, globals_1.expect)(out.home.kills + out.home.aces + out.home.blockPoints + out.home.opponentErrors).toBe(108);
+    });
+});

package/dist/esm/src/service/match/index.d.ts

@@ -4,6 +4,7 @@ export * from './match-generator';
 export * from './match-rating';
 export * from './match-set';
 export * from './rally';
+export * from './point-breakdown';
 export * from './court-position';
 export * from './match-team';
 export * from './vper';

package/dist/esm/src/service/match/index.js

@@ -4,6 +4,7 @@ export * from './match-generator';
 export * from './match-rating';
 export * from './match-set';
 export * from './rally';
+export * from './point-breakdown';
 export * from './court-position';
 export * from './match-team';
 export * from './vper';

package/dist/esm/src/service/match/point-breakdown.d.ts

@@ -0,0 +1,36 @@
+export interface RallyEventLike {
+    readonly eventType: number;
+    readonly playerId: string;
+}
+export interface RallyLike {
+    readonly events: readonly RallyEventLike[];
+}
+export interface TeamBlockTally {
+    blockPoints: number;
+    blockSolo: number;
+    blockAssists: number;
+}
+export declare function tallyBlockPoints(rallies: readonly RallyLike[], teamOf: (playerId: string) => string | null): Map<string, TeamBlockTally>;
+export interface TeamPointBreakdown {
+    kills: number;
+    aces: number;
+    blockPoints: number;
+    opponentErrors: number;
+}
+export interface PointBreakdown {
+    home: TeamPointBreakdown;
+    away: TeamPointBreakdown;
+}
+export interface PointBreakdownInput {
+    rallies: readonly RallyLike[];
+    homeTeamId: string;
+    awayTeamId: string;
+    teamOf: (playerId: string) => string | null;
+    homeKills: number;
+    awayKills: number;
+    homeAces: number;
+    awayAces: number;
+    homeTotalPoints: number;
+    awayTotalPoints: number;
+}
+export declare function computePointBreakdown(input: PointBreakdownInput): PointBreakdown;

package/dist/esm/src/service/match/point-breakdown.js

@@ -0,0 +1,67 @@
+import { EventTypeEnum } from '../event';
+// A block scores a point in exactly ONE place in the sim (reception-simulator: a dig of a block fails
+// and the block landed in-court, i.e. target >= 7). Each such rally is ONE block point regardless of how
+// many blockers were on it; the box score records it as one `block_assists` per blocker (or one
+// `block_solo`), which is why summing solo+assists over-counts block points. We rebuild the true count
+// from the rallies. blockSolo / blockAssists must reconstruct box.block.solo and box.block.assists
+// exactly (the correctness gate). `teamOf(playerId)` returns a player's team id (or null); the scoring
+// team is the blockers' team.
+export function tallyBlockPoints(rallies, teamOf) {
+    const out = new Map();
+    const tallyFor = (team) => {
+        let t = out.get(team);
+        if (t == null) {
+            t = { blockPoints: 0, blockSolo: 0, blockAssists: 0 };
+            out.set(team, t);
+        }
+        return t;
+    };
+    for (const rally of rallies) {
+        // Ignore substitutions / libero replacements (eventType < SERVE) when locating the terminal action.
+        const inPlay = rally.events.filter(e => e.eventType >= EventTypeEnum.SERVE);
+        const last = inPlay[inPlay.length - 1];
+        const prev = inPlay[inPlay.length - 2];
+        if (last == null || prev == null)
+            continue;
+        // Block point signature: the rally ends on a failed RECEPTION (dig) whose previous event is a BLOCK
+        // that landed in-court (target >= 7). target < 7 is a deflection -> the ATTACKER's kill, not a block.
+        if (last.eventType !== EventTypeEnum.RECEPTION || last.failure <= 0)
+            continue;
+        if (prev.eventType !== EventTypeEnum.BLOCK)
+            continue;
+        const block = prev;
+        if (block.target < 7)
+            continue;
+        const team = teamOf(block.blockers[0] ?? block.playerId);
+        if (team == null)
+            continue;
+        const t = tallyFor(team);
+        t.blockPoints++;
+        if (block.blockers.length < 2)
+            t.blockSolo++;
+        else
+            t.blockAssists += block.blockers.length;
+    }
+    return out;
+}
+// Kills/aces come straight from the box score; block points are derived from rallies; opponent errors
+// are the remainder (>= 0 by construction). The four reconcile to the team's total points.
+export function computePointBreakdown(input) {
+    const tally = tallyBlockPoints(input.rallies, input.teamOf);
+    const homeBlocks = tally.get(input.homeTeamId)?.blockPoints ?? 0;
+    const awayBlocks = tally.get(input.awayTeamId)?.blockPoints ?? 0;
+    return {
+        home: {
+            kills: input.homeKills,
+            aces: input.homeAces,
+            blockPoints: homeBlocks,
+            opponentErrors: input.homeTotalPoints - input.homeKills - input.homeAces - homeBlocks
+        },
+        away: {
+            kills: input.awayKills,
+            aces: input.awayAces,
+            blockPoints: awayBlocks,
+            opponentErrors: input.awayTotalPoints - input.awayKills - input.awayAces - awayBlocks
+        }
+    };
+}

package/dist/esm/src/service/match/point-breakdown.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/service/match/point-breakdown.test.js

@@ -0,0 +1,70 @@
+import { describe, expect, it } from '@jest/globals';
+import { EventTypeEnum } from '../event';
+import { computePointBreakdown, tallyBlockPoints } from './point-breakdown';
+const blockEvent = (playerId, target, blockers) => ({ eventType: EventTypeEnum.BLOCK, playerId, target, blockers });
+const receptionEvent = (playerId, failure) => ({ eventType: EventTypeEnum.RECEPTION, playerId, failure });
+const serveEvent = (playerId) => ({ eventType: EventTypeEnum.SERVE, playerId });
+const spikeEvent = (playerId) => ({ eventType: EventTypeEnum.SPIKE, playerId });
+const rally = (events) => ({ events });
+const teamOf = (id) => id.startsWith('h') ? 'HOME' : id.startsWith('a') ? 'AWAY' : null;
+describe('tallyBlockPoints', () => {
+    it('counts an assisted block point once, recording each blocker as an assist', () => {
+        const t = tallyBlockPoints([rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 1)])], teamOf);
+        expect(t.get('HOME')).toEqual({ blockPoints: 1, blockSolo: 0, blockAssists: 2 });
+    });
+    it('counts a solo block point', () => {
+        const t = tallyBlockPoints([rally([blockEvent('h1', 9, ['h1']), receptionEvent('a3', 2)])], teamOf);
+        expect(t.get('HOME')).toEqual({ blockPoints: 1, blockSolo: 1, blockAssists: 0 });
+    });
+    it('does NOT count a deflection (target < 7) - that is the attacker\'s kill', () => {
+        const t = tallyBlockPoints([rally([blockEvent('h1', 4, ['h1', 'h2']), receptionEvent('a3', 1)])], teamOf);
+        expect(t.size).toBe(0);
+    });
+    it('does NOT count an ace (reception fail after serve)', () => {
+        const t = tallyBlockPoints([rally([serveEvent('h1'), receptionEvent('a3', 1)])], teamOf);
+        expect(t.size).toBe(0);
+    });
+    it('does NOT count a successful dig (reception failure 0)', () => {
+        const t = tallyBlockPoints([rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 0), spikeEvent('a3')])], teamOf);
+        expect(t.size).toBe(0);
+    });
+    it('reconstructs box block.solo and block.assists across a mix (incl. a triple block)', () => {
+        const t = tallyBlockPoints([
+            rally([blockEvent('h1', 8, ['h1', 'h2']), receptionEvent('a3', 1)]), // double: +2 assists
+            rally([blockEvent('h3', 8, ['h3', 'h4', 'h5']), receptionEvent('a1', 1)]), // triple: +3 assists
+            rally([blockEvent('h1', 9, ['h1']), receptionEvent('a2', 1)]), // solo: +1 solo
+            rally([blockEvent('a1', 8, ['a1', 'a2']), receptionEvent('h2', 1)]) // away double
+        ], teamOf);
+        expect(t.get('HOME')).toEqual({ blockPoints: 3, blockSolo: 1, blockAssists: 5 });
+        expect(t.get('AWAY')).toEqual({ blockPoints: 1, blockSolo: 0, blockAssists: 2 });
+    });
+});
+describe('computePointBreakdown', () => {
+    it('reproduces the prod bug scenario as a positive number (was -3)', () => {
+        // AWAY scored 99 (54 kills, 0 aces) and 28 block points (8 solo + 20 doubles). Old formula did
+        // 99 - 54 - (8 + 40) - 0 = -3; correct is 99 - 54 - 0 - 28 = 17.
+        const rallies = [];
+        for (let i = 0; i < 20; i++)
+            rallies.push(rally([blockEvent('a1', 8, ['a1', 'a2']), receptionEvent(`h${i}`, 1)]));
+        for (let i = 0; i < 8; i++)
+            rallies.push(rally([blockEvent('a3', 9, ['a3']), receptionEvent(`h${i + 20}`, 1)]));
+        const out = computePointBreakdown({
+            rallies,
+            homeTeamId: 'HOME',
+            awayTeamId: 'AWAY',
+            teamOf,
+            homeKills: 51,
+            awayKills: 54,
+            homeAces: 3,
+            awayAces: 0,
+            homeTotalPoints: 108,
+            awayTotalPoints: 99
+        });
+        expect(out.away.blockPoints).toBe(28);
+        expect(out.away.opponentErrors).toBe(17);
+        expect(out.away.opponentErrors).toBeGreaterThanOrEqual(0);
+        // The four categories reconcile to the team's total points.
+        expect(out.away.kills + out.away.aces + out.away.blockPoints + out.away.opponentErrors).toBe(99);
+        expect(out.home.kills + out.home.aces + out.home.blockPoints + out.home.opponentErrors).toBe(108);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.417",
+  "version": "0.0.419",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",