@gamepark/zenith 1.0.4 → 1.0.8

package/dist/rules/effect/EffectEdgeCases.spec.js

@@ -90,7 +90,7 @@ class EffectTestSetup extends ZenithSetup {
         this.setupInfluenceCards();
         this.setupTeams();
         this.setupLeaderBadge();
-        this.setupTechnologyBoard({ animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false, players: [] });
+        this.setupTechnologyBoard({ animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', players: [] });
         this.setupTestBonuses();
     }
     setupTurnOrder() {
@@ -101,14 +101,16 @@ class EffectTestSetup extends ZenithSetup {
             id: this.testAgent,
             location: { type: LocationType.PlayerHand, player: player1 }
         });
-        const fillers = agents.filter(a => a !== this.testAgent && !this.opponentInfluenceCards.includes(a) && !this.playerInfluenceCards.includes(a)).slice(0, 3);
+        const fillers = agents.filter((a) => a !== this.testAgent && !this.opponentInfluenceCards.includes(a) && !this.playerInfluenceCards.includes(a)).slice(0, 3);
         for (const agent of fillers) {
             this.material(MaterialType.AgentCard).createItem({
                 id: agent,
                 location: { type: LocationType.PlayerHand, player: player1 }
             });
         }
-        const p2Fillers = agents.filter(a => a !== this.testAgent && !fillers.includes(a) && !this.opponentInfluenceCards.includes(a) && !this.playerInfluenceCards.includes(a)).slice(0, 4);
+        const p2Fillers = agents
+            .filter((a) => a !== this.testAgent && !fillers.includes(a) && !this.opponentInfluenceCards.includes(a) && !this.playerInfluenceCards.includes(a))
+            .slice(0, 4);
         for (const agent of p2Fillers) {
             this.material(MaterialType.AgentCard).createItem({
                 id: agent,
@@ -121,9 +123,9 @@ class EffectTestSetup extends ZenithSetup {
             this.testAgent,
             ...this.opponentInfluenceCards,
             ...this.playerInfluenceCards,
-            ...agents.filter(a => a !== this.testAgent && !this.opponentInfluenceCards.includes(a) && !this.playerInfluenceCards.includes(a)).slice(0, 7)
+            ...agents.filter((a) => a !== this.testAgent && !this.opponentInfluenceCards.includes(a) && !this.playerInfluenceCards.includes(a)).slice(0, 7)
         ]);
-        const remaining = agents.filter(a => !usedAgents.has(a));
+        const remaining = agents.filter((a) => !usedAgents.has(a));
         let idx = 0;
         for (let i = 0; i < this.deckCount && idx < remaining.length; i++, idx++) {
             this.material(MaterialType.AgentCard).createItem({
@@ -218,7 +220,7 @@ class EffectTestSetup extends ZenithSetup {
     }
 }
 function setupEffects(rules, effects) {
-    const expandedEffects = effects.map(e => ({
+    const expandedEffects = effects.map((e) => ({
         ...e,
         effectSource: { type: MaterialType.AgentCard, value: Agent.Elisabeth }
     }));
@@ -226,45 +228,40 @@ function setupEffects(rules, effects) {
 }
 function createRulesWithEffects(opts, effects) {
     const setup = new EffectTestSetup(opts);
-    const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+    const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
     const rules = new ZenithRules(game);
     setupEffects(rules, effects);
     return rules;
 }
 describe('WinInfluence edge cases', () => {
     it('opponentSide with no planets on opponent side should skip effect', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinInfluence, quantity: 1, opponentSide: true }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinInfluence, quantity: 1, opponentSide: true }]);
         playConsequences(rules, { type: 'rule', id: RuleId.WinInfluence });
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('differentPlanet with only 1 planet remaining should skip after first pull', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinInfluence, quantity: 1, differentPlanet: true, resetDifferentPlanet: true }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinInfluence, quantity: 1, differentPlanet: true, resetDifferentPlanet: true }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('fromCenter with no planets at center should skip', () => {
         const rules = createRulesWithEffects({
             planetPositions: {
-                [Influence.Mercury]: 2, [Influence.Venus]: 2, [Influence.Terra]: 2,
-                [Influence.Mars]: 2, [Influence.Jupiter]: 2
+                [Influence.Mercury]: 2,
+                [Influence.Venus]: 2,
+                [Influence.Terra]: 2,
+                [Influence.Mars]: 2,
+                [Influence.Jupiter]: 2
             }
-        }, [
-            { type: EffectType.WinInfluence, quantity: 1, fromCenter: true }
-        ]);
+        }, [{ type: EffectType.WinInfluence, quantity: 1, fromCenter: true }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('planet already at max position (x=4 for White) should still trigger capture', () => {
         const rules = createRulesWithEffects({
             planetPositions: { [Influence.Mars]: 3 }
-        }, [
-            { type: EffectType.WinInfluence, influence: Influence.Mars, quantity: 1 }
-        ]);
+        }, [{ type: EffectType.WinInfluence, influence: Influence.Mars, quantity: 1 }]);
         playConsequences(rules, rules.play({ type: 'rule', id: RuleId.WinInfluence })[0] ?? { type: 'rule', id: RuleId.WinInfluence });
         resolveAutoMoves(rules);
         const result = resolveAllEffects(rules, player1);
@@ -275,93 +272,76 @@ describe('GiveInfluence edge cases', () => {
     it('all planets at boundary (x=-4 for White push) should skip', () => {
         const rules = createRulesWithEffects({
             planetPositions: {
-                [Influence.Mercury]: -4, [Influence.Venus]: -4, [Influence.Terra]: -4,
-                [Influence.Mars]: -4, [Influence.Jupiter]: -4
+                [Influence.Mercury]: -4,
+                [Influence.Venus]: -4,
+                [Influence.Terra]: -4,
+                [Influence.Mars]: -4,
+                [Influence.Jupiter]: -4
             }
-        }, [
-            { type: EffectType.GiveInfluence }
-        ]);
+        }, [{ type: EffectType.GiveInfluence }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('push planet to -4 should capture for opponent', () => {
         const rules = createRulesWithEffects({
             planetPositions: { [Influence.Mars]: -3 }
-        }, [
-            { type: EffectType.GiveInfluence }
-        ]);
+        }, [{ type: EffectType.GiveInfluence }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('except planet filter works', () => {
         const rules = createRulesWithEffects({
             planetPositions: { [Influence.Mars]: -4 }
-        }, [
-            { type: EffectType.GiveInfluence, except: Influence.Mars }
-        ]);
+        }, [{ type: EffectType.GiveInfluence, except: Influence.Mars }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
 });
 describe('Exile edge cases', () => {
     it('exile with no influence cards should skip', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.Exile }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.Exile }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('exile opponent with no opponent influence cards should skip', () => {
         const rules = createRulesWithEffects({
             playerInfluenceCards: [Agent.Pkd1ck]
-        }, [
-            { type: EffectType.Exile, opponent: true }
-        ]);
+        }, [{ type: EffectType.Exile, opponent: true }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('exile quantity=2 with only 1 card should exile 1 then skip', () => {
         const rules = createRulesWithEffects({
             playerInfluenceCards: [Agent.Pkd1ck]
-        }, [
-            { type: EffectType.Exile, quantity: 2 }
-        ]);
+        }, [{ type: EffectType.Exile, quantity: 2 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('exile with specific influence filter and no matching cards should skip', () => {
         const rules = createRulesWithEffects({
             playerInfluenceCards: [Agent.Pkd1ck]
-        }, [
-            { type: EffectType.Exile, influence: Influence.Venus }
-        ]);
+        }, [{ type: EffectType.Exile, influence: Influence.Venus }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
 });
 describe('Transfer edge cases', () => {
     it('transfer with no opponent influence cards should skip', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.Transfer }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.Transfer }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('transfer quantity=2 with only 1 opponent card should skip (isPossible checks quantity)', () => {
         const rules = createRulesWithEffects({
             opponentInfluenceCards: [Agent.Pkd1ck]
-        }, [
-            { type: EffectType.Transfer, quantity: 2 }
-        ]);
+        }, [{ type: EffectType.Transfer, quantity: 2 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('transfer with specific influence and matching opponent cards should not block', () => {
         const rules = createRulesWithEffects({
             opponentInfluenceCards: [Agent.Pkd1ck]
-        }, [
-            { type: EffectType.Transfer, influence: Influence.Mercury }
-        ]);
+        }, [{ type: EffectType.Transfer, influence: Influence.Mercury }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -370,18 +350,14 @@ describe('GiveCredit edge cases', () => {
     it('give credits with 0 credits should skip', () => {
         const rules = createRulesWithEffects({
             playerCredits: 0
-        }, [
-            { type: EffectType.GiveCredit, quantity: 3 }
-        ]);
+        }, [{ type: EffectType.GiveCredit, quantity: 3 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('give credits with insufficient credits should skip', () => {
         const rules = createRulesWithEffects({
             playerCredits: 2
-        }, [
-            { type: EffectType.GiveCredit, quantity: 5 }
-        ]);
+        }, [{ type: EffectType.GiveCredit, quantity: 5 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -390,9 +366,7 @@ describe('StealCredit edge cases', () => {
     it('steal credits from opponent with 0 credits should skip', () => {
         const rules = createRulesWithEffects({
             opponentCredits: 0
-        }, [
-            { type: EffectType.StealCredit, quantity: 2 }
-        ]);
+        }, [{ type: EffectType.StealCredit, quantity: 2 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -401,9 +375,7 @@ describe('GiveZenithium edge cases', () => {
     it('give zenithium with 0 zenithium should skip', () => {
         const rules = createRulesWithEffects({
             playerZenithium: 0
-        }, [
-            { type: EffectType.GiveZenithium, quantity: 1 }
-        ]);
+        }, [{ type: EffectType.GiveZenithium, quantity: 1 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -412,18 +384,14 @@ describe('SpendCredit edge cases', () => {
     it('spend credits with 0 credits should skip', () => {
         const rules = createRulesWithEffects({
             playerCredits: 0
-        }, [
-            { type: EffectType.SpendCredit, quantities: [2, 4, 6], factors: [1, 2, 3] }
-        ]);
+        }, [{ type: EffectType.SpendCredit, quantities: [2, 4, 6], factors: [1, 2, 3] }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('spend credits with insufficient for all tiers should skip', () => {
         const rules = createRulesWithEffects({
             playerCredits: 1
-        }, [
-            { type: EffectType.SpendCredit, quantities: [2, 4, 6], factors: [1, 2, 3] }
-        ]);
+        }, [{ type: EffectType.SpendCredit, quantities: [2, 4, 6], factors: [1, 2, 3] }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -432,9 +400,7 @@ describe('SpendZenithium edge cases', () => {
     it('spend zenithium with 0 zenithium should skip', () => {
         const rules = createRulesWithEffects({
             playerZenithium: 0
-        }, [
-            { type: EffectType.SpendZenithium, quantities: [1, 2], factors: [1, 2] }
-        ]);
+        }, [{ type: EffectType.SpendZenithium, quantities: [1, 2], factors: [1, 2] }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -442,7 +408,7 @@ describe('SpendZenithium edge cases', () => {
 describe('Discard edge cases', () => {
     it('discard with empty hand should skip', () => {
         const setup = new EffectTestSetup({});
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
         const hand = rules.material(MaterialType.AgentCard).location(LocationType.PlayerHand).player(player1);
         for (const index of hand.getIndexes()) {
@@ -457,12 +423,13 @@ describe('ResetInfluence edge cases', () => {
     it('reset influence with no planets on player side should skip', () => {
         const rules = createRulesWithEffects({
             planetPositions: {
-                [Influence.Mercury]: -2, [Influence.Venus]: -1, [Influence.Terra]: 0,
-                [Influence.Mars]: -1, [Influence.Jupiter]: -2
+                [Influence.Mercury]: -2,
+                [Influence.Venus]: -1,
+                [Influence.Terra]: 0,
+                [Influence.Mars]: -1,
+                [Influence.Jupiter]: -2
             }
-        }, [
-            { type: EffectType.ResetInfluence }
-        ]);
+        }, [{ type: EffectType.ResetInfluence }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -592,17 +559,20 @@ describe('Chained effect sequences', () => {
         }, [
             { type: EffectType.WinInfluence, influence: Influence.Mars, quantity: 1 },
             {
-                type: EffectType.Conditional, mandatory: true,
+                type: EffectType.Conditional,
+                mandatory: true,
                 condition: { type: ConditionType.DoEffect, effect: { type: EffectType.Mobilize } },
                 effect: { type: EffectType.WinInfluence, quantity: 1 }
             },
             {
-                type: EffectType.Conditional, mandatory: true,
+                type: EffectType.Conditional,
+                mandatory: true,
                 condition: { type: ConditionType.DoEffect, effect: { type: EffectType.Mobilize } },
                 effect: { type: EffectType.WinInfluence, quantity: 1 }
             },
             {
-                type: EffectType.Conditional, mandatory: true,
+                type: EffectType.Conditional,
+                mandatory: true,
                 condition: { type: ConditionType.DoEffect, effect: { type: EffectType.Mobilize } },
                 effect: { type: EffectType.WinInfluence, quantity: 1 }
             }
@@ -617,12 +587,14 @@ describe('Chained effect sequences', () => {
         }, [
             { type: EffectType.WinInfluence, influence: Influence.Mars, quantity: 1 },
             {
-                type: EffectType.Conditional, mandatory: true,
+                type: EffectType.Conditional,
+                mandatory: true,
                 condition: { type: ConditionType.DoEffect, effect: { type: EffectType.Mobilize } },
                 effect: { type: EffectType.WinInfluence, quantity: 1 }
             },
             {
-                type: EffectType.Conditional, mandatory: true,
+                type: EffectType.Conditional,
+                mandatory: true,
                 condition: { type: ConditionType.DoEffect, effect: { type: EffectType.Mobilize } },
                 effect: { type: EffectType.WinInfluence, quantity: 1 }
             }
@@ -636,9 +608,7 @@ describe('Mobilize edge cases', () => {
         const rules = createRulesWithEffects({
             deckCount: 2,
             discardCount: 0
-        }, [
-            { type: EffectType.Mobilize, quantity: 2 }
-        ]);
+        }, [{ type: EffectType.Mobilize, quantity: 2 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -646,9 +616,7 @@ describe('Mobilize edge cases', () => {
         const rules = createRulesWithEffects({
             deckCount: 1,
             discardCount: 0
-        }, [
-            { type: EffectType.Mobilize, quantity: 3 }
-        ]);
+        }, [{ type: EffectType.Mobilize, quantity: 3 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -657,7 +625,8 @@ describe('Mobilize edge cases', () => {
             deckCount: 5
         }, [
             {
-                type: EffectType.Conditional, mandatory: true,
+                type: EffectType.Conditional,
+                mandatory: true,
                 condition: { type: ConditionType.DoEffect, effect: { type: EffectType.Mobilize, quantity: 2 } },
                 effect: { type: EffectType.WinInfluence, quantity: 1 }
             }
@@ -668,39 +637,29 @@ describe('Mobilize edge cases', () => {
 });
 describe('WinCredit edge cases', () => {
     it('perLevel1Technology with no techs should give 0 credits (not block)', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinCredit, perLevel1Technology: [Faction.Human] }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinCredit, perLevel1Technology: [Faction.Human] }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('factorPerDifferentInfluence with no influence cards should give 0', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinCredit, factorPerDifferentInfluence: 2 }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinCredit, factorPerDifferentInfluence: 2 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('factorPerDifferentOpponentInfluence with no opponent cards should give 0', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinCredit, factorPerDifferentOpponentInfluence: 2 }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinCredit, factorPerDifferentOpponentInfluence: 2 }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
 });
 describe('WinZenithium edge cases', () => {
     it('perLevel1Technology with no techs should give 0 zenithium', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinZenithium, perLevel1Technology: [Faction.Human] }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinZenithium, perLevel1Technology: [Faction.Human] }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('opponent=true should give zenithium to opponent', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinZenithium, quantity: 1, opponent: true }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinZenithium, quantity: 1, opponent: true }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -709,21 +668,17 @@ describe('StealZenithium', () => {
     it('should steal zenithium from opponent', () => {
         const rules = createRulesWithEffects({
             playerZenithium: 1
-        }, [
-            { type: EffectType.StealZenithium, quantity: 1 }
-        ]);
+        }, [{ type: EffectType.StealZenithium, quantity: 1 }]);
         rules.game.rule = { id: RuleId.StealZenithium, player: player1 };
         resolveAutoMoves(rules);
-        const totalZen = rules.material(MaterialType.ZenithiumToken)
-            .location(LocationType.TeamZenithium).getQuantity();
+        const totalZen = rules.material(MaterialType.ZenithiumToken).location(LocationType.TeamZenithium).getQuantity();
         expect(totalZen).toBe(4);
     });
     it('should skip when opponent has no zenithium', () => {
         const setup = new EffectTestSetup({});
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
-        const opponentZen = rules.material(MaterialType.ZenithiumToken)
-            .location(LocationType.TeamZenithium).player(TeamColor.Black);
+        const opponentZen = rules.material(MaterialType.ZenithiumToken).location(LocationType.TeamZenithium).player(TeamColor.Black);
         if (opponentZen.length) {
             playConsequences(rules, opponentZen.deleteItem());
         }
@@ -734,16 +689,12 @@ describe('StealZenithium', () => {
 });
 describe('Technology board alternative effects', () => {
     it('Board D level 4: WinInfluence pattern [1,1,1,1,1] should influence all planets', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinInfluence, pattern: [1, 1, 1, 1, 1] }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinInfluence, pattern: [1, 1, 1, 1, 1] }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
     it('Board O level 4: WinInfluence pattern [2,2] should influence 2 adjacent planets', () => {
-        const rules = createRulesWithEffects({}, [
-            { type: EffectType.WinInfluence, pattern: [2, 2] }
-        ]);
+        const rules = createRulesWithEffects({}, [{ type: EffectType.WinInfluence, pattern: [2, 2] }]);
         const result = resolveAllEffects(rules, player1);
         expect(result.error).toBeUndefined();
     });
@@ -803,18 +754,18 @@ describe('Technology board alternative effects', () => {
 describe('Board options', () => {
     it('should use specified board sides', () => {
         const setup = new EffectTestSetup({});
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'S', humanBoard: 'U', robotBoard: 'N' });
         const rules = new ZenithRules(game);
         const boards = rules.material(MaterialType.TechnologyBoard).getItems();
-        const ids = boards.map(b => b.id).sort();
+        const ids = boards.map((b) => b.id).sort();
         expect(ids).toEqual(['N', 'S', 'U']);
     });
     it('should use D/O/P sides when specified', () => {
         const setup = new ZenithSetup();
-        const game = setup.setup({ players: [{}, {}], animodBoard: 'D', humanBoard: 'O', robotBoard: 'P', secretAgent: false });
+        const game = setup.setup({ players: [{}, {}], animodBoard: 'D', humanBoard: 'O', robotBoard: 'P' });
         const rules = new ZenithRules(game);
         const boards = rules.material(MaterialType.TechnologyBoard).getItems();
-        const ids = boards.map(b => b.id).sort();
+        const ids = boards.map((b) => b.id).sort();
         expect(ids).toEqual(['D', 'O', 'P']);
     });
     it('should use random faces when no option specified', () => {
@@ -822,11 +773,11 @@ describe('Board options', () => {
         const game = setup.setup({ players: [{}, {}] });
         const rules = new ZenithRules(game);
         const boards = rules.material(MaterialType.TechnologyBoard).getItems();
-        const ids = boards.map(b => b.id);
+        const ids = boards.map((b) => b.id);
         expect(ids.length).toBe(3);
-        expect(['S', 'D']).toContain(ids.find(id => ['S', 'D'].includes(id)));
-        expect(['U', 'O']).toContain(ids.find(id => ['U', 'O'].includes(id)));
-        expect(['N', 'P']).toContain(ids.find(id => ['N', 'P'].includes(id)));
+        expect(['S', 'D']).toContain(ids.find((id) => ['S', 'D'].includes(id)));
+        expect(['U', 'O']).toContain(ids.find((id) => ['U', 'O'].includes(id)));
+        expect(['N', 'P']).toContain(ids.find((id) => ['N', 'P'].includes(id)));
     });
 });
 //# sourceMappingURL=EffectEdgeCases.spec.js.map