volleyballsimtypes 0.0.101 → 0.0.103

package/dist/esm/src/service/event/serve.js

@@ -1,37 +1,37 @@
-import { InPlayEvent } from './in-play-event';
-import { Trait } from '../player';
-export var ServeTypeEnum;
-(function (ServeTypeEnum) {
-    ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
-    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
-    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
-    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
-    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
-})(ServeTypeEnum || (ServeTypeEnum = {}));
-export var ServeFailureEnum;
-(function (ServeFailureEnum) {
-    ServeFailureEnum[ServeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    ServeFailureEnum[ServeFailureEnum["FAULT"] = 1] = "FAULT";
-    ServeFailureEnum[ServeFailureEnum["MISS"] = 2] = "MISS";
-    ServeFailureEnum[ServeFailureEnum["NET"] = 3] = "NET";
-    ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(ServeFailureEnum || (ServeFailureEnum = {}));
-export class Serve extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(stats, type, modifier, activeTraits) {
-        let score = Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === Trait.METEOR_SERVE: {
-                    score *= Trait.METEOR_SERVE.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-}
+import { InPlayEvent } from './in-play-event';
+import { Trait } from '../player';
+export var ServeTypeEnum;
+(function (ServeTypeEnum) {
+    ServeTypeEnum[ServeTypeEnum["UNDERHAND"] = 0] = "UNDERHAND";
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_TOPSPIN"] = 1] = "OVERHAND_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["OVERHAND_FLOAT"] = 2] = "OVERHAND_FLOAT";
+    ServeTypeEnum[ServeTypeEnum["JUMP_TOPSPIN"] = 3] = "JUMP_TOPSPIN";
+    ServeTypeEnum[ServeTypeEnum["JUMP_FLOAT"] = 4] = "JUMP_FLOAT";
+})(ServeTypeEnum || (ServeTypeEnum = {}));
+export var ServeFailureEnum;
+(function (ServeFailureEnum) {
+    ServeFailureEnum[ServeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    ServeFailureEnum[ServeFailureEnum["FAULT"] = 1] = "FAULT";
+    ServeFailureEnum[ServeFailureEnum["MISS"] = 2] = "MISS";
+    ServeFailureEnum[ServeFailureEnum["NET"] = 3] = "NET";
+    ServeFailureEnum[ServeFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(ServeFailureEnum || (ServeFailureEnum = {}));
+export class Serve extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(stats, type, modifier, activeTraits) {
+        let score = Serve.calculateScore(stats, 'SERVE', ServeTypeEnum[type]) * modifier;
+        for (const trait of activeTraits) {
+            switch (true) {
+                case trait === Trait.METEOR_SERVE: {
+                    score *= Trait.METEOR_SERVE.modifier;
+                    break;
+                }
+            }
+        }
+        return score;
+    }
+}

package/dist/esm/src/service/event/set.d.ts

@@ -1,26 +1,26 @@
-import { PerformanceStats, Trait } from '../player';
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-export declare enum SetTypeEnum {
-    OVERHAND = 0,
-    UNDERHAND = 1,
-    SPIKE = 2,
-    DUMP = 3
-}
-export declare enum SetFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    BAD_PASS = 3,
-    OUT_OF_BOUNDS = 4
-}
-interface SetOpts extends InPlayEventOpts {
-    readonly type: SetTypeEnum;
-    readonly failure: SetFailureEnum;
-}
-export declare class Set extends InPlayEvent {
-    readonly failure: SetFailureEnum;
-    readonly type: SetTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
-    static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number, activeTraits: Trait[]): number;
-}
-export {};
+import { PerformanceStats, Trait } from '../player';
+import { InPlayEvent, InPlayEventOpts } from './in-play-event';
+export declare enum SetTypeEnum {
+    OVERHAND = 0,
+    UNDERHAND = 1,
+    SPIKE = 2,
+    DUMP = 3
+}
+export declare enum SetFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    BAD_PASS = 3,
+    OUT_OF_BOUNDS = 4
+}
+interface SetOpts extends InPlayEventOpts {
+    readonly type: SetTypeEnum;
+    readonly failure: SetFailureEnum;
+}
+export declare class Set extends InPlayEvent {
+    readonly failure: SetFailureEnum;
+    readonly type: SetTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SetOpts);
+    static getScore(stats: PerformanceStats, type: SetTypeEnum, modifier: number, activeTraits: Trait[]): number;
+}
+export {};

package/dist/esm/src/service/event/set.js

@@ -1,41 +1,41 @@
-import { Trait } from '../player';
-import { InPlayEvent } from './in-play-event';
-export var SetTypeEnum;
-(function (SetTypeEnum) {
-    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
-    SetTypeEnum[SetTypeEnum["UNDERHAND"] = 1] = "UNDERHAND";
-    SetTypeEnum[SetTypeEnum["SPIKE"] = 2] = "SPIKE";
-    SetTypeEnum[SetTypeEnum["DUMP"] = 3] = "DUMP";
-})(SetTypeEnum || (SetTypeEnum = {}));
-export var SetFailureEnum;
-(function (SetFailureEnum) {
-    SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SetFailureEnum[SetFailureEnum["FAULT"] = 1] = "FAULT";
-    SetFailureEnum[SetFailureEnum["MISS"] = 2] = "MISS";
-    SetFailureEnum[SetFailureEnum["BAD_PASS"] = 3] = "BAD_PASS";
-    SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
-})(SetFailureEnum || (SetFailureEnum = {}));
-export class Set extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(stats, type, modifier, activeTraits) {
-        let score = Set.calculateScore(stats, 'SET', SetTypeEnum[type]) * modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === Trait.MASTER_MIND: {
-                    score *= Trait.MASTER_MIND.modifier;
-                    break;
-                }
-                case trait === Trait.MARKSMAN: {
-                    if ([SetTypeEnum.DUMP, SetTypeEnum.SPIKE].includes(type))
-                        score *= Trait.MARKSMAN.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-}
+import { Trait } from '../player';
+import { InPlayEvent } from './in-play-event';
+export var SetTypeEnum;
+(function (SetTypeEnum) {
+    SetTypeEnum[SetTypeEnum["OVERHAND"] = 0] = "OVERHAND";
+    SetTypeEnum[SetTypeEnum["UNDERHAND"] = 1] = "UNDERHAND";
+    SetTypeEnum[SetTypeEnum["SPIKE"] = 2] = "SPIKE";
+    SetTypeEnum[SetTypeEnum["DUMP"] = 3] = "DUMP";
+})(SetTypeEnum || (SetTypeEnum = {}));
+export var SetFailureEnum;
+(function (SetFailureEnum) {
+    SetFailureEnum[SetFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SetFailureEnum[SetFailureEnum["FAULT"] = 1] = "FAULT";
+    SetFailureEnum[SetFailureEnum["MISS"] = 2] = "MISS";
+    SetFailureEnum[SetFailureEnum["BAD_PASS"] = 3] = "BAD_PASS";
+    SetFailureEnum[SetFailureEnum["OUT_OF_BOUNDS"] = 4] = "OUT_OF_BOUNDS";
+})(SetFailureEnum || (SetFailureEnum = {}));
+export class Set extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(stats, type, modifier, activeTraits) {
+        let score = Set.calculateScore(stats, 'SET', SetTypeEnum[type]) * modifier;
+        for (const trait of activeTraits) {
+            switch (true) {
+                case trait === Trait.MASTER_MIND: {
+                    score *= Trait.MASTER_MIND.modifier;
+                    break;
+                }
+                case trait === Trait.MARKSMAN: {
+                    if ([SetTypeEnum.DUMP, SetTypeEnum.SPIKE].includes(type))
+                        score *= Trait.MARKSMAN.modifier;
+                    break;
+                }
+            }
+        }
+        return score;
+    }
+}

package/dist/esm/src/service/event/spike.d.ts

@@ -1,28 +1,28 @@
-import { InPlayEvent, InPlayEventOpts } from './in-play-event';
-import { Player, Trait } from '../player';
-export declare enum SpikeTypeEnum {
-    CROSS_SHOT = 0,
-    LINE_SHOT = 1,
-    TOOL_SHOT = 2,
-    TIP = 3,
-    DOWN_BALL = 4,
-    OVERHAND = 5
-}
-export declare enum SpikeFailureEnum {
-    NO_FAILURE = 0,
-    FAULT = 1,
-    MISS = 2,
-    OUT_OF_BOUNDS = 3,
-    NET = 4
-}
-interface SpikeOpts extends InPlayEventOpts {
-    readonly type: SpikeTypeEnum;
-    readonly failure: SpikeFailureEnum;
-}
-export declare class Spike extends InPlayEvent {
-    readonly failure: SpikeFailureEnum;
-    readonly type: SpikeTypeEnum;
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
-    static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean, activeTraits: Trait[]): number;
-}
-export {};
+import { InPlayEvent, InPlayEventOpts } from './in-play-event';
+import { Player, Trait } from '../player';
+export declare enum SpikeTypeEnum {
+    CROSS_SHOT = 0,
+    LINE_SHOT = 1,
+    TOOL_SHOT = 2,
+    TIP = 3,
+    DOWN_BALL = 4,
+    OVERHAND = 5
+}
+export declare enum SpikeFailureEnum {
+    NO_FAILURE = 0,
+    FAULT = 1,
+    MISS = 2,
+    OUT_OF_BOUNDS = 3,
+    NET = 4
+}
+interface SpikeOpts extends InPlayEventOpts {
+    readonly type: SpikeTypeEnum;
+    readonly failure: SpikeFailureEnum;
+}
+export declare class Spike extends InPlayEvent {
+    readonly failure: SpikeFailureEnum;
+    readonly type: SpikeTypeEnum;
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }: SpikeOpts);
+    static getScore(player: Player, type: SpikeTypeEnum, modifier: number, isBackRow: boolean, activeTraits: Trait[]): number;
+}
+export {};

package/dist/esm/src/service/event/spike.js

@@ -1,46 +1,46 @@
-import { InPlayEvent } from './in-play-event';
-import { Trait } from '../player';
-export var SpikeTypeEnum;
-(function (SpikeTypeEnum) {
-    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["TOOL_SHOT"] = 2] = "TOOL_SHOT";
-    SpikeTypeEnum[SpikeTypeEnum["TIP"] = 3] = "TIP";
-    SpikeTypeEnum[SpikeTypeEnum["DOWN_BALL"] = 4] = "DOWN_BALL";
-    SpikeTypeEnum[SpikeTypeEnum["OVERHAND"] = 5] = "OVERHAND";
-})(SpikeTypeEnum || (SpikeTypeEnum = {}));
-export var SpikeFailureEnum;
-(function (SpikeFailureEnum) {
-    SpikeFailureEnum[SpikeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
-    SpikeFailureEnum[SpikeFailureEnum["FAULT"] = 1] = "FAULT";
-    SpikeFailureEnum[SpikeFailureEnum["MISS"] = 2] = "MISS";
-    SpikeFailureEnum[SpikeFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
-    SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
-})(SpikeFailureEnum || (SpikeFailureEnum = {}));
-export class Spike extends InPlayEvent {
-    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
-        super({ id, order, score, player, target, eventType, modifier, activeTraits });
-        this.type = type;
-        this.failure = failure;
-    }
-    static getScore(player, type, modifier, isBackRow, activeTraits) {
-        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeTypeEnum[type]);
-        if (![SpikeTypeEnum.DOWN_BALL, SpikeTypeEnum.OVERHAND, SpikeTypeEnum.TIP].includes(type) && isBackRow) {
-            score = score * 0.7 + player.stats.backAttack * 0.3;
-        }
-        score *= modifier;
-        for (const trait of activeTraits) {
-            switch (true) {
-                case trait === Trait.MASTER_MIND: {
-                    score *= Trait.MASTER_MIND.modifier;
-                    break;
-                }
-                case trait === Trait.MARKSMAN: {
-                    score *= Trait.MARKSMAN.modifier;
-                    break;
-                }
-            }
-        }
-        return score;
-    }
-}
+import { InPlayEvent } from './in-play-event';
+import { Trait } from '../player';
+export var SpikeTypeEnum;
+(function (SpikeTypeEnum) {
+    SpikeTypeEnum[SpikeTypeEnum["CROSS_SHOT"] = 0] = "CROSS_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["LINE_SHOT"] = 1] = "LINE_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["TOOL_SHOT"] = 2] = "TOOL_SHOT";
+    SpikeTypeEnum[SpikeTypeEnum["TIP"] = 3] = "TIP";
+    SpikeTypeEnum[SpikeTypeEnum["DOWN_BALL"] = 4] = "DOWN_BALL";
+    SpikeTypeEnum[SpikeTypeEnum["OVERHAND"] = 5] = "OVERHAND";
+})(SpikeTypeEnum || (SpikeTypeEnum = {}));
+export var SpikeFailureEnum;
+(function (SpikeFailureEnum) {
+    SpikeFailureEnum[SpikeFailureEnum["NO_FAILURE"] = 0] = "NO_FAILURE";
+    SpikeFailureEnum[SpikeFailureEnum["FAULT"] = 1] = "FAULT";
+    SpikeFailureEnum[SpikeFailureEnum["MISS"] = 2] = "MISS";
+    SpikeFailureEnum[SpikeFailureEnum["OUT_OF_BOUNDS"] = 3] = "OUT_OF_BOUNDS";
+    SpikeFailureEnum[SpikeFailureEnum["NET"] = 4] = "NET";
+})(SpikeFailureEnum || (SpikeFailureEnum = {}));
+export class Spike extends InPlayEvent {
+    constructor({ id, order, score, player, target, failure, type, eventType, modifier, activeTraits }) {
+        super({ id, order, score, player, target, eventType, modifier, activeTraits });
+        this.type = type;
+        this.failure = failure;
+    }
+    static getScore(player, type, modifier, isBackRow, activeTraits) {
+        let score = Spike.calculateScore(player.stats, 'SPIKE', SpikeTypeEnum[type]);
+        if (![SpikeTypeEnum.DOWN_BALL, SpikeTypeEnum.OVERHAND, SpikeTypeEnum.TIP].includes(type) && isBackRow) {
+            score = score * 0.7 + player.stats.backAttack * 0.3;
+        }
+        score *= modifier;
+        for (const trait of activeTraits) {
+            switch (true) {
+                case trait === Trait.MASTER_MIND: {
+                    score *= Trait.MASTER_MIND.modifier;
+                    break;
+                }
+                case trait === Trait.MARKSMAN: {
+                    score *= Trait.MARKSMAN.modifier;
+                    break;
+                }
+            }
+        }
+        return score;
+    }
+}

package/dist/esm/src/service/event/substitution.d.ts

@@ -1,10 +1,10 @@
-import { RallyEvent, RallyEventOpts } from './rally-event';
-import { Player } from '../player';
-interface SubstitutionOpts extends RallyEventOpts {
-    readonly playerOut: Player;
-}
-export declare class Substitution extends RallyEvent {
-    readonly playerOut: Player;
-    constructor({ id, order, playerOut, player, eventType }: SubstitutionOpts);
-}
-export {};
+import { RallyEvent, RallyEventOpts } from './rally-event';
+import { Player } from '../player';
+interface SubstitutionOpts extends RallyEventOpts {
+    readonly playerOut: Player;
+}
+export declare class Substitution extends RallyEvent {
+    readonly playerOut: Player;
+    constructor({ id, order, playerOut, player, eventType }: SubstitutionOpts);
+}
+export {};

package/dist/esm/src/service/event/substitution.js

@@ -1,7 +1,7 @@
-import { RallyEvent } from './rally-event';
-export class Substitution extends RallyEvent {
-    constructor({ id, order, playerOut, player, eventType }) {
-        super({ eventType, player, order, id });
-        this.playerOut = playerOut;
-    }
-}
+import { RallyEvent } from './rally-event';
+export class Substitution extends RallyEvent {
+    constructor({ id, order, playerOut, player, eventType }) {
+        super({ eventType, player, order, id });
+        this.playerOut = playerOut;
+    }
+}

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

@@ -1,9 +1,9 @@
-export * from './match';
-export * from './coach';
-export * from './country';
-export * from './draft';
-export * from './team';
-export * from './event';
-export * from './player';
-export * from './competition';
-export * from './utils';
+export * from './match';
+export * from './coach';
+export * from './country';
+export * from './draft';
+export * from './team';
+export * from './event';
+export * from './player';
+export * from './competition';
+export * from './utils';

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

@@ -1,9 +1,9 @@
-export * from './match';
-export * from './coach';
-export * from './country';
-export * from './draft';
-export * from './team';
-export * from './event';
-export * from './player';
-export * from './competition';
-export * from './utils';
+export * from './match';
+export * from './coach';
+export * from './country';
+export * from './draft';
+export * from './team';
+export * from './event';
+export * from './player';
+export * from './competition';
+export * from './utils';

package/dist/esm/src/service/match/court-position.d.ts

@@ -1,21 +1,21 @@
-export declare enum CourtRow {
-    BACK = "BACK_ROW",
-    FRONT = "FRONT_ROW"
-}
-export declare enum CourtPosition {
-    NOT_IN_COURT = -1,
-    LIBERO_ZONE = 0,
-    LEFT_FRONT = 4,
-    MIDDLE_FRONT = 3,
-    RIGHT_FRONT = 2,
-    LEFT_BACK = 5,
-    MIDDLE_BACK = 6,
-    RIGHT_BACK = 1
-}
-export declare namespace CourtPosition {
-    function getPositions(): CourtPosition[];
-    function rotatePosition(position: number): CourtPosition;
-    function isFrontRow(position: number): boolean;
-    function isBackRow(position: number): boolean;
-    function getRow(row: CourtRow): CourtPosition[];
-}
+export declare enum CourtRow {
+    BACK = "BACK_ROW",
+    FRONT = "FRONT_ROW"
+}
+export declare enum CourtPosition {
+    NOT_IN_COURT = -1,
+    LIBERO_ZONE = 0,
+    LEFT_FRONT = 4,
+    MIDDLE_FRONT = 3,
+    RIGHT_FRONT = 2,
+    LEFT_BACK = 5,
+    MIDDLE_BACK = 6,
+    RIGHT_BACK = 1
+}
+export declare namespace CourtPosition {
+    function getPositions(): CourtPosition[];
+    function rotatePosition(position: number): CourtPosition;
+    function isFrontRow(position: number): boolean;
+    function isBackRow(position: number): boolean;
+    function getRow(row: CourtRow): CourtPosition[];
+}

package/dist/esm/src/service/match/court-position.js

@@ -1,53 +1,53 @@
-export var CourtRow;
-(function (CourtRow) {
-    CourtRow["BACK"] = "BACK_ROW";
-    CourtRow["FRONT"] = "FRONT_ROW";
-})(CourtRow || (CourtRow = {}));
-export var CourtPosition;
-(function (CourtPosition) {
-    CourtPosition[CourtPosition["NOT_IN_COURT"] = -1] = "NOT_IN_COURT";
-    CourtPosition[CourtPosition["LIBERO_ZONE"] = 0] = "LIBERO_ZONE";
-    // -----------------------------------------------------
-    CourtPosition[CourtPosition["LEFT_FRONT"] = 4] = "LEFT_FRONT";
-    CourtPosition[CourtPosition["MIDDLE_FRONT"] = 3] = "MIDDLE_FRONT";
-    CourtPosition[CourtPosition["RIGHT_FRONT"] = 2] = "RIGHT_FRONT";
-    CourtPosition[CourtPosition["LEFT_BACK"] = 5] = "LEFT_BACK";
-    CourtPosition[CourtPosition["MIDDLE_BACK"] = 6] = "MIDDLE_BACK";
-    CourtPosition[CourtPosition["RIGHT_BACK"] = 1] = "RIGHT_BACK";
-})(CourtPosition || (CourtPosition = {}));
-// eslint-disable-next-line @typescript-eslint/no-namespace
-(function (CourtPosition) {
-    const FRONT_ROW = [CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT];
-    const BACK_ROW = [CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK];
-    function getPositions() {
-        return [...BACK_ROW, ...FRONT_ROW];
-    }
-    CourtPosition.getPositions = getPositions;
-    function rotatePosition(position) {
-        if (position < 1 || position > 6)
-            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
-        if (position > CourtPosition.RIGHT_BACK)
-            return position - 1;
-        else
-            return CourtPosition.MIDDLE_BACK;
-    }
-    CourtPosition.rotatePosition = rotatePosition;
-    function isFrontRow(position) {
-        if (position < 1 || position > 6)
-            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
-        return FRONT_ROW.includes(position);
-    }
-    CourtPosition.isFrontRow = isFrontRow;
-    function isBackRow(position) {
-        if (position < 1 || position > 6)
-            throw new Error(`POSITION_INDEX_OUT_OF_BOUNDS: ${position}`);
-        return BACK_ROW.includes(position);
-    }
-    CourtPosition.isBackRow = isBackRow;
-    function getRow(row) {
-        if (![CourtRow.BACK, CourtRow.FRONT].includes(row))
-            throw new Error(`INVALID_ROW: ${row}`);
-        return CourtRow.BACK === row ? [...BACK_ROW] : [...FRONT_ROW];
-    }
-    CourtPosition.getRow = getRow;
-})(CourtPosition || (CourtPosition = {}));
+export var CourtRow;
+(function (CourtRow) {
+    CourtRow["BACK"] = "BACK_ROW";
+    CourtRow["FRONT"] = "FRONT_ROW";
+})(CourtRow || (CourtRow = {}));
+export var CourtPosition;
+(function (CourtPosition) {
+    CourtPosition[CourtPosition["NOT_IN_COURT"] = -1] = "NOT_IN_COURT";
+    CourtPosition[CourtPosition["LIBERO_ZONE"] = 0] = "LIBERO_ZONE";
+    // -----------------------------------------------------
+    CourtPosition[CourtPosition["LEFT_FRONT"] = 4] = "LEFT_FRONT";
+    CourtPosition[CourtPosition["MIDDLE_FRONT"] = 3] = "MIDDLE_FRONT";
+    CourtPosition[CourtPosition["RIGHT_FRONT"] = 2] = "RIGHT_FRONT";
+    CourtPosition[CourtPosition["LEFT_BACK"] = 5] = "LEFT_BACK";
+    CourtPosition[CourtPosition["MIDDLE_BACK"] = 6] = "MIDDLE_BACK";
+    CourtPosition[CourtPosition["RIGHT_BACK"] = 1] = "RIGHT_BACK";
+})(CourtPosition || (CourtPosition = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (CourtPosition) {
+    const FRONT_ROW = [CourtPosition.LEFT_FRONT, CourtPosition.MIDDLE_FRONT, CourtPosition.RIGHT_FRONT];
+    const BACK_ROW = [CourtPosition.LEFT_BACK, CourtPosition.MIDDLE_BACK, CourtPosition.RIGHT_BACK];
+    function getPositions() {
+        return [...BACK_ROW, ...FRONT_ROW];
+    }
+    CourtPosition.getPositions = getPositions;
+    function rotatePosition(position) {
+        if (position < 1 || position > 6)
+            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+        if (position > CourtPosition.RIGHT_BACK)
+            return position - 1;
+        else
+            return CourtPosition.MIDDLE_BACK;
+    }
+    CourtPosition.rotatePosition = rotatePosition;
+    function isFrontRow(position) {
+        if (position < 1 || position > 6)
+            throw new Error('POSITION_INDEX_OUT_OF_BOUNDS');
+        return FRONT_ROW.includes(position);
+    }
+    CourtPosition.isFrontRow = isFrontRow;
+    function isBackRow(position) {
+        if (position < 1 || position > 6)
+            throw new Error(`POSITION_INDEX_OUT_OF_BOUNDS: ${position}`);
+        return BACK_ROW.includes(position);
+    }
+    CourtPosition.isBackRow = isBackRow;
+    function getRow(row) {
+        if (![CourtRow.BACK, CourtRow.FRONT].includes(row))
+            throw new Error(`INVALID_ROW: ${row}`);
+        return CourtRow.BACK === row ? [...BACK_ROW] : [...FRONT_ROW];
+    }
+    CourtPosition.getRow = getRow;
+})(CourtPosition || (CourtPosition = {}));

package/dist/esm/src/service/match/court-target-enum.d.ts

@@ -1,21 +1,21 @@
-import { CourtPosition } from './court-position';
-export declare enum CourtTargetEnum {
-    NO_TARGET = 0,
-    OPPONENT_RIGHT_BACK = 7,
-    OPPONENT_MIDDLE_BACK = 12,
-    OPPONENT_LEFT_BACK = 11,
-    OPPONENT_RIGHT_FRONT = 8,
-    OPPONENT_MIDDLE_FRONT = 9,
-    OPPONENT_LEFT_FRONT = 10,
-    TEAM_LEFT_FRONT = 4,
-    TEAM_MIDDLE_FRONT = 3,
-    TEAM_RIGHT_FRONT = 2,
-    TEAM_LEFT_BACK = 5,
-    TEAM_MIDDLE_BACK = 6,
-    TEAM_RIGHT_BACK = 1
-}
-export declare namespace CourtTargetEnum {
-    function getTeamSide(): CourtTargetEnum[];
-    function getOpponentSide(): CourtTargetEnum[];
-    function getSidePosition(position: number): CourtPosition;
-}
+import { CourtPosition } from './court-position';
+export declare enum CourtTargetEnum {
+    NO_TARGET = 0,
+    OPPONENT_RIGHT_BACK = 7,
+    OPPONENT_MIDDLE_BACK = 12,
+    OPPONENT_LEFT_BACK = 11,
+    OPPONENT_RIGHT_FRONT = 8,
+    OPPONENT_MIDDLE_FRONT = 9,
+    OPPONENT_LEFT_FRONT = 10,
+    TEAM_LEFT_FRONT = 4,
+    TEAM_MIDDLE_FRONT = 3,
+    TEAM_RIGHT_FRONT = 2,
+    TEAM_LEFT_BACK = 5,
+    TEAM_MIDDLE_BACK = 6,
+    TEAM_RIGHT_BACK = 1
+}
+export declare namespace CourtTargetEnum {
+    function getTeamSide(): CourtTargetEnum[];
+    function getOpponentSide(): CourtTargetEnum[];
+    function getSidePosition(position: number): CourtPosition;
+}