volleyballsimtypes 0.0.485 → 0.0.487

package/dist/cjs/src/service/team/base-position.test.js

@@ -148,6 +148,39 @@ describe('getLineupFunctions()', () => {
         expect((0, lineup_function_1.getLineupFunctions)(rotation_system_1.RotationSystemEnum.SIX_ZERO, [], baseLineup()).size).toBe(0);
     });
 });
+describe('getAttackingFunctions()', () => {
+    it('maps the 6-2 FRONT-row setter to OPPOSITE and the back-row setter to SETTER, every rotation', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            const fns = (0, lineup_function_1.getAttackingFunctions)(rotation_system_1.RotationSystemEnum.SIX_TWO, ['S', 'OPP'], players);
+            for (const id of ['S', 'OPP']) {
+                const p = players.find(s => s.playerId === id);
+                expect(fns.get(id)).toBe((0, match_1.isFrontRow)(p.position) ? player_1.RoleEnum.OPPOSITE_HITTER : player_1.RoleEnum.SETTER);
+            }
+            // Non-setters keep their normal hitting function.
+            expect(fns.get('OH1')).toBe(player_1.RoleEnum.OUTSIDE_HITTER);
+            expect(fns.get('MB1')).toBe(player_1.RoleEnum.MIDDLE_BLOCKER);
+        }
+    });
+    it('keeps BOTH 4-2 setters as SETTER (a 4-2 has no attacking opposite)', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            const fns = (0, lineup_function_1.getAttackingFunctions)(rotation_system_1.RotationSystemEnum.FOUR_TWO, ['S', 'OPP'], players);
+            expect(fns.get('S')).toBe(player_1.RoleEnum.SETTER);
+            expect(fns.get('OPP')).toBe(player_1.RoleEnum.SETTER);
+        }
+    });
+    it('matches getLineupFunctions for 5-1 (a real opposite already exists) and 6-0 (empty)', () => {
+        const five = (0, lineup_function_1.getAttackingFunctions)(rotation_system_1.RotationSystemEnum.FIVE_ONE, ['S'], baseLineup());
+        expect(five.get('S')).toBe(player_1.RoleEnum.SETTER);
+        expect(five.get('OPP')).toBe(player_1.RoleEnum.OPPOSITE_HITTER);
+        expect((0, lineup_function_1.getAttackingFunctions)(rotation_system_1.RotationSystemEnum.SIX_ZERO, [], baseLineup()).size).toBe(0);
+    });
+    it('does NOT mutate the positional getLineupFunctions (6-2 front setter stays SETTER there)', () => {
+        const positional = (0, lineup_function_1.getLineupFunctions)(rotation_system_1.RotationSystemEnum.SIX_TWO, ['S', 'OPP'], baseLineup());
+        expect(positional.get('OPP')).toBe(player_1.RoleEnum.SETTER); // OPP is front-row at rotation 0
+    });
+});
 describe('out-of-position penalty', () => {
     it('penalises a specialist played in a slot whose role they lack', () => {
         // A pure middle blocker placed in the opposite slot (function OPPOSITE_HITTER) is out of position.

package/dist/cjs/src/service/team/lineup-function.d.ts

@@ -9,5 +9,6 @@ export interface LineupSlot {
 }
 export declare function slotFunctionAt(system: RotationSystemEnum, setterPosition: CourtPosition, position: CourtPosition): RoleEnum;
 export declare function getLineupFunctions(system: RotationSystemEnum, designatedSetterIds: string[], starters: LineupSlot[]): Map<string, RoleEnum>;
+export declare function getAttackingFunctions(system: RotationSystemEnum, designatedSetterIds: string[], starters: LineupSlot[]): Map<string, RoleEnum>;
 export declare function isOutOfPosition(roles: Role[], fn: RoleEnum | undefined): boolean;
 export declare function outOfPositionPenalty(roles: Role[], fn: RoleEnum | undefined): number;

package/dist/cjs/src/service/team/lineup-function.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OUT_OF_POSITION_PENALTY = void 0;
 exports.slotFunctionAt = slotFunctionAt;
 exports.getLineupFunctions = getLineupFunctions;
+exports.getAttackingFunctions = getAttackingFunctions;
 exports.isOutOfPosition = isOutOfPosition;
 exports.outOfPositionPenalty = outOfPositionPenalty;
+const match_1 = require("../match");
 const player_1 = require("../player");
 const rotation_system_1 = require("./rotation-system");
 // Flat multiplier applied to EVERY action a player performs while played out of their preferred position.
@@ -54,6 +56,24 @@ function getLineupFunctions(system, designatedSetterIds, starters) {
     }
     return functions;
 }
+// Like getLineupFunctions but for ATTACK + BLOCK purposes. In a 6-2 the FRONT-ROW designated setter attacks and
+// blocks as the OPPOSITE this rotation, so it maps to OPPOSITE_HITTER here (its base-positioning + setting function
+// stays SETTER via getLineupFunctions, so the out-of-position penalty is unaffected). Everything else is identical:
+// the 6-2 back setter, both 4-2 setters, and the 5-1 setter all stay SETTER (they set / do not attack), and 6-0 is
+// empty. Consumed by dedicated-block targeting and the opposite serve-hunt so defenders see the 6-2 opposite as the
+// opposite, matching what the offence already does (it keeps the front-row setter as an attacker).
+function getAttackingFunctions(system, designatedSetterIds, starters) {
+    const functions = getLineupFunctions(system, designatedSetterIds, starters);
+    if (system !== rotation_system_1.RotationSystemEnum.SIX_TWO)
+        return functions;
+    const setterIds = new Set(designatedSetterIds);
+    for (const slot of starters) {
+        if (setterIds.has(slot.playerId) && (0, match_1.isFrontRow)(slot.position)) {
+            functions.set(slot.playerId, player_1.RoleEnum.OPPOSITE_HITTER);
+        }
+    }
+    return functions;
+}
 // True when a player's slot requires a role they do not hold (i.e. they are played out of position). A missing
 // function (6-0, or unknown player) is never out of position.
 function isOutOfPosition(roles, fn) {

package/dist/cjs/src/service/team/sub-config-convert.js

@@ -23,12 +23,17 @@ function fatigueCondition(band) {
 function convertLegacySetSubConfig(raw) {
     if (!isRecord(raw))
         return raw;
-    // Derive the mode for the oldest (pre-mode) generation; a unified shape has none of these keys.
+    // Derive the mode for the oldest (pre-mode) generation; a unified shape has none of these keys. Test the
+    // isPinchServer VALUE, not key presence: the sim read path (transformToObject) spreads `isPinchServer:
+    // d.isPinchServer` onto every row, so a unified row carries an `isPinchServer: undefined` key. `'isPinchServer'
+    // in raw` would then misread that unified row as a legacy FATIGUE sub and overwrite its real conditions /
+    // pinchServer flag. A genuine legacy isPinchServer-era row always has a boolean flag (true handled above), so
+    // the only remaining legacy case is an explicit `=== false`.
     const mode = raw.mode ?? (raw.isPinchServer === true
         ? 'PINCH'
         : raw.fatigueBand === 'NEVER'
             ? 'NEVER'
-            : raw.fatigueBand != null || 'isPinchServer' in raw ? 'FATIGUE' : null);
+            : raw.fatigueBand != null || raw.isPinchServer === false ? 'FATIGUE' : null);
     if (mode == null)
         return raw;
     const { mode: _m, fatigueBand, isPinchServer: _p, ...rest } = raw;

package/dist/cjs/src/service/team/sub-config-convert.test.js

@@ -12,6 +12,25 @@ const sub_config_convert_1 = require("./sub-config-convert");
         const unified = { bench: 'X', conditions: [{ type: pinch_condition_1.PinchConditionType.ASAP }], pinchServer: true };
         (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)(unified)).toBe(unified);
     });
+    (0, globals_1.it)('keeps a unified pinch server intact when a caller injects isPinchServer: undefined (sim read path)', () => {
+        // The sim read path (transformToObject) spreads `isPinchServer: d.isPinchServer` onto every row, so a
+        // unified row arrives carrying an `isPinchServer: undefined` key. Detecting the legacy shape by key
+        // PRESENCE misread it as a FATIGUE sub and wiped its real conditions + pinchServer flag; the value check
+        // (=== false) keeps the unified shape. Regression for the "pinch server never serves" prod bug.
+        const out = (0, sub_config_convert_1.convertLegacySetSubConfig)({
+            bench: 'X',
+            conditions: [{ type: pinch_condition_1.PinchConditionType.AFTER_ROTATIONS, rotations: 1 }],
+            conditionLogic: 'ANY',
+            pinchServer: true,
+            subBackMode: 'FATIGUE',
+            isPinchServer: undefined,
+            mode: undefined,
+            fatigueBand: undefined
+        });
+        (0, globals_1.expect)(out.pinchServer).toBe(true);
+        (0, globals_1.expect)(out.conditions).toEqual([{ type: pinch_condition_1.PinchConditionType.AFTER_ROTATIONS, rotations: 1 }]);
+        (0, globals_1.expect)(out.conditionLogic).toBe('ANY');
+    });
     (0, globals_1.it)('converts mode NEVER to an explicit empty condition list, dropping every other field', () => {
         (0, globals_1.expect)((0, sub_config_convert_1.convertLegacySetSubConfig)({ mode: 'NEVER', bench: 'X' })).toEqual({ conditions: [] });
     });

package/dist/esm/src/service/team/base-position.test.js

@@ -1,7 +1,7 @@
 import { CourtPosition, isFrontRow, rotatePosition } from '../match';
 import { RoleEnum } from '../player';
 import { RotationSystemEnum } from './rotation-system';
-import { getLineupFunctions, isOutOfPosition, outOfPositionPenalty, OUT_OF_POSITION_PENALTY, slotFunctionAt } from './lineup-function';
+import { getAttackingFunctions, getLineupFunctions, isOutOfPosition, outOfPositionPenalty, OUT_OF_POSITION_PENALTY, slotFunctionAt } from './lineup-function';
 import { rallySetterId, resolveBases } from './base-position';
 // Balanced 5-1 at rotation 1 (setter serving from RIGHT_BACK = 1): S, OH1, MB1, OPP, OH2, MB2 around the court.
 function baseLineup() {
@@ -146,6 +146,39 @@ describe('getLineupFunctions()', () => {
         expect(getLineupFunctions(RotationSystemEnum.SIX_ZERO, [], baseLineup()).size).toBe(0);
     });
 });
+describe('getAttackingFunctions()', () => {
+    it('maps the 6-2 FRONT-row setter to OPPOSITE and the back-row setter to SETTER, every rotation', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            const fns = getAttackingFunctions(RotationSystemEnum.SIX_TWO, ['S', 'OPP'], players);
+            for (const id of ['S', 'OPP']) {
+                const p = players.find(s => s.playerId === id);
+                expect(fns.get(id)).toBe(isFrontRow(p.position) ? RoleEnum.OPPOSITE_HITTER : RoleEnum.SETTER);
+            }
+            // Non-setters keep their normal hitting function.
+            expect(fns.get('OH1')).toBe(RoleEnum.OUTSIDE_HITTER);
+            expect(fns.get('MB1')).toBe(RoleEnum.MIDDLE_BLOCKER);
+        }
+    });
+    it('keeps BOTH 4-2 setters as SETTER (a 4-2 has no attacking opposite)', () => {
+        for (let r = 0; r < 6; r++) {
+            const players = rotate(baseLineup(), r);
+            const fns = getAttackingFunctions(RotationSystemEnum.FOUR_TWO, ['S', 'OPP'], players);
+            expect(fns.get('S')).toBe(RoleEnum.SETTER);
+            expect(fns.get('OPP')).toBe(RoleEnum.SETTER);
+        }
+    });
+    it('matches getLineupFunctions for 5-1 (a real opposite already exists) and 6-0 (empty)', () => {
+        const five = getAttackingFunctions(RotationSystemEnum.FIVE_ONE, ['S'], baseLineup());
+        expect(five.get('S')).toBe(RoleEnum.SETTER);
+        expect(five.get('OPP')).toBe(RoleEnum.OPPOSITE_HITTER);
+        expect(getAttackingFunctions(RotationSystemEnum.SIX_ZERO, [], baseLineup()).size).toBe(0);
+    });
+    it('does NOT mutate the positional getLineupFunctions (6-2 front setter stays SETTER there)', () => {
+        const positional = getLineupFunctions(RotationSystemEnum.SIX_TWO, ['S', 'OPP'], baseLineup());
+        expect(positional.get('OPP')).toBe(RoleEnum.SETTER); // OPP is front-row at rotation 0
+    });
+});
 describe('out-of-position penalty', () => {
     it('penalises a specialist played in a slot whose role they lack', () => {
         // A pure middle blocker placed in the opposite slot (function OPPOSITE_HITTER) is out of position.

package/dist/esm/src/service/team/lineup-function.d.ts

@@ -9,5 +9,6 @@ export interface LineupSlot {
 }
 export declare function slotFunctionAt(system: RotationSystemEnum, setterPosition: CourtPosition, position: CourtPosition): RoleEnum;
 export declare function getLineupFunctions(system: RotationSystemEnum, designatedSetterIds: string[], starters: LineupSlot[]): Map<string, RoleEnum>;
+export declare function getAttackingFunctions(system: RotationSystemEnum, designatedSetterIds: string[], starters: LineupSlot[]): Map<string, RoleEnum>;
 export declare function isOutOfPosition(roles: Role[], fn: RoleEnum | undefined): boolean;
 export declare function outOfPositionPenalty(roles: Role[], fn: RoleEnum | undefined): number;

package/dist/esm/src/service/team/lineup-function.js

@@ -1,3 +1,4 @@
+import { isFrontRow } from '../match';
 import { RoleEnum } from '../player';
 import { RotationSystemEnum } from './rotation-system';
 // Flat multiplier applied to EVERY action a player performs while played out of their preferred position.
@@ -47,6 +48,24 @@ export function getLineupFunctions(system, designatedSetterIds, starters) {
     }
     return functions;
 }
+// Like getLineupFunctions but for ATTACK + BLOCK purposes. In a 6-2 the FRONT-ROW designated setter attacks and
+// blocks as the OPPOSITE this rotation, so it maps to OPPOSITE_HITTER here (its base-positioning + setting function
+// stays SETTER via getLineupFunctions, so the out-of-position penalty is unaffected). Everything else is identical:
+// the 6-2 back setter, both 4-2 setters, and the 5-1 setter all stay SETTER (they set / do not attack), and 6-0 is
+// empty. Consumed by dedicated-block targeting and the opposite serve-hunt so defenders see the 6-2 opposite as the
+// opposite, matching what the offence already does (it keeps the front-row setter as an attacker).
+export function getAttackingFunctions(system, designatedSetterIds, starters) {
+    const functions = getLineupFunctions(system, designatedSetterIds, starters);
+    if (system !== RotationSystemEnum.SIX_TWO)
+        return functions;
+    const setterIds = new Set(designatedSetterIds);
+    for (const slot of starters) {
+        if (setterIds.has(slot.playerId) && isFrontRow(slot.position)) {
+            functions.set(slot.playerId, RoleEnum.OPPOSITE_HITTER);
+        }
+    }
+    return functions;
+}
 // True when a player's slot requires a role they do not hold (i.e. they are played out of position). A missing
 // function (6-0, or unknown player) is never out of position.
 export function isOutOfPosition(roles, fn) {

package/dist/esm/src/service/team/sub-config-convert.js

@@ -17,12 +17,17 @@ function fatigueCondition(band) {
 export function convertLegacySetSubConfig(raw) {
     if (!isRecord(raw))
         return raw;
-    // Derive the mode for the oldest (pre-mode) generation; a unified shape has none of these keys.
+    // Derive the mode for the oldest (pre-mode) generation; a unified shape has none of these keys. Test the
+    // isPinchServer VALUE, not key presence: the sim read path (transformToObject) spreads `isPinchServer:
+    // d.isPinchServer` onto every row, so a unified row carries an `isPinchServer: undefined` key. `'isPinchServer'
+    // in raw` would then misread that unified row as a legacy FATIGUE sub and overwrite its real conditions /
+    // pinchServer flag. A genuine legacy isPinchServer-era row always has a boolean flag (true handled above), so
+    // the only remaining legacy case is an explicit `=== false`.
     const mode = raw.mode ?? (raw.isPinchServer === true
         ? 'PINCH'
         : raw.fatigueBand === 'NEVER'
             ? 'NEVER'
-            : raw.fatigueBand != null || 'isPinchServer' in raw ? 'FATIGUE' : null);
+            : raw.fatigueBand != null || raw.isPinchServer === false ? 'FATIGUE' : null);
     if (mode == null)
         return raw;
     const { mode: _m, fatigueBand, isPinchServer: _p, ...rest } = raw;

package/dist/esm/src/service/team/sub-config-convert.test.js

@@ -10,6 +10,25 @@ describe('convertLegacySetSubConfig', () => {
         const unified = { bench: 'X', conditions: [{ type: PinchConditionType.ASAP }], pinchServer: true };
         expect(convertLegacySetSubConfig(unified)).toBe(unified);
     });
+    it('keeps a unified pinch server intact when a caller injects isPinchServer: undefined (sim read path)', () => {
+        // The sim read path (transformToObject) spreads `isPinchServer: d.isPinchServer` onto every row, so a
+        // unified row arrives carrying an `isPinchServer: undefined` key. Detecting the legacy shape by key
+        // PRESENCE misread it as a FATIGUE sub and wiped its real conditions + pinchServer flag; the value check
+        // (=== false) keeps the unified shape. Regression for the "pinch server never serves" prod bug.
+        const out = convertLegacySetSubConfig({
+            bench: 'X',
+            conditions: [{ type: PinchConditionType.AFTER_ROTATIONS, rotations: 1 }],
+            conditionLogic: 'ANY',
+            pinchServer: true,
+            subBackMode: 'FATIGUE',
+            isPinchServer: undefined,
+            mode: undefined,
+            fatigueBand: undefined
+        });
+        expect(out.pinchServer).toBe(true);
+        expect(out.conditions).toEqual([{ type: PinchConditionType.AFTER_ROTATIONS, rotations: 1 }]);
+        expect(out.conditionLogic).toBe('ANY');
+    });
     it('converts mode NEVER to an explicit empty condition list, dropping every other field', () => {
         expect(convertLegacySetSubConfig({ mode: 'NEVER', bench: 'X' })).toEqual({ conditions: [] });
     });

package/package.json

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