@battle-racing/br-common-lib 6.0.0 → 6.1.0

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm whoami *)",
+      "Bash(npm config *)"
+    ]
+  }
+}

package/dist/domains/gameHistory/GameHistory.const.d.ts

@@ -0,0 +1,10 @@
+export declare const COIN_TRANSACTION_TYPE: {
+    /** Coins given to the player when a game they played finished. */
+    readonly GAME_REWARD: "GAME_REWARD";
+    /** Manual correction made by the staff. */
+    readonly ADJUSTMENT: "ADJUSTMENT";
+};
+export declare const GAME_HISTORY_GROUP_BY: {
+    readonly DAY: "day";
+    readonly MONTH: "month";
+};

package/dist/domains/gameHistory/GameHistory.const.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GAME_HISTORY_GROUP_BY = exports.COIN_TRANSACTION_TYPE = void 0;
+exports.COIN_TRANSACTION_TYPE = {
+    /** Coins given to the player when a game they played finished. */
+    GAME_REWARD: 'GAME_REWARD',
+    /** Manual correction made by the staff. */
+    ADJUSTMENT: 'ADJUSTMENT',
+};
+exports.GAME_HISTORY_GROUP_BY = {
+    DAY: 'day',
+    MONTH: 'month',
+};

package/dist/domains/gameHistory/GameHistory.schema.d.ts

@@ -0,0 +1,210 @@
+import { z } from 'zod';
+export declare const raceResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    gameId: z.ZodNumber;
+    gameTrackId: z.ZodString;
+    gameTurnId: z.ZodOptional<z.ZodString>;
+    playerId: z.ZodString;
+    playerNickname: z.ZodString;
+    kartGuid: z.ZodString;
+    position: z.ZodNumber;
+    totalKarts: z.ZodNumber;
+    isWinner: z.ZodBoolean;
+    coinsEarned: z.ZodNumber;
+    isOfficial: z.ZodBoolean;
+    finishedAt: z.ZodDate;
+    createdAt: z.ZodDate;
+    gameType: z.ZodLiteral<"Race">;
+    lapsCompleted: z.ZodNumber;
+    fastestLapMs: z.ZodNullable<z.ZodNumber>;
+    totalTimeMs: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const battleResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    gameId: z.ZodNumber;
+    gameTrackId: z.ZodString;
+    gameTurnId: z.ZodOptional<z.ZodString>;
+    playerId: z.ZodString;
+    playerNickname: z.ZodString;
+    kartGuid: z.ZodString;
+    position: z.ZodNumber;
+    totalKarts: z.ZodNumber;
+    isWinner: z.ZodBoolean;
+    coinsEarned: z.ZodNumber;
+    isOfficial: z.ZodBoolean;
+    finishedAt: z.ZodDate;
+    createdAt: z.ZodDate;
+    gameType: z.ZodLiteral<"Battle">;
+    livesRemaining: z.ZodNumber;
+    wasEliminated: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const gameResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    gameId: z.ZodNumber;
+    gameTrackId: z.ZodString;
+    gameTurnId: z.ZodOptional<z.ZodString>;
+    playerId: z.ZodString;
+    playerNickname: z.ZodString;
+    kartGuid: z.ZodString;
+    position: z.ZodNumber;
+    totalKarts: z.ZodNumber;
+    isWinner: z.ZodBoolean;
+    coinsEarned: z.ZodNumber;
+    isOfficial: z.ZodBoolean;
+    finishedAt: z.ZodDate;
+    createdAt: z.ZodDate;
+    gameType: z.ZodLiteral<"Race">;
+    lapsCompleted: z.ZodNumber;
+    fastestLapMs: z.ZodNullable<z.ZodNumber>;
+    totalTimeMs: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    gameId: z.ZodNumber;
+    gameTrackId: z.ZodString;
+    gameTurnId: z.ZodOptional<z.ZodString>;
+    playerId: z.ZodString;
+    playerNickname: z.ZodString;
+    kartGuid: z.ZodString;
+    position: z.ZodNumber;
+    totalKarts: z.ZodNumber;
+    isWinner: z.ZodBoolean;
+    coinsEarned: z.ZodNumber;
+    isOfficial: z.ZodBoolean;
+    finishedAt: z.ZodDate;
+    createdAt: z.ZodDate;
+    gameType: z.ZodLiteral<"Battle">;
+    livesRemaining: z.ZodNumber;
+    wasEliminated: z.ZodBoolean;
+}, z.core.$strip>], "gameType">;
+export declare const filterGameHistorySchema: z.ZodObject<{
+    playerId: z.ZodOptional<z.ZodString>;
+    gameTrackId: z.ZodOptional<z.ZodString>;
+    gameType: z.ZodOptional<z.ZodEnum<{
+        readonly Race: "Race";
+        readonly Battle: "Battle";
+    }>>;
+    from: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    to: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const paginatedGameResultSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        gameId: z.ZodNumber;
+        gameTrackId: z.ZodString;
+        gameTurnId: z.ZodOptional<z.ZodString>;
+        playerId: z.ZodString;
+        playerNickname: z.ZodString;
+        kartGuid: z.ZodString;
+        position: z.ZodNumber;
+        totalKarts: z.ZodNumber;
+        isWinner: z.ZodBoolean;
+        coinsEarned: z.ZodNumber;
+        isOfficial: z.ZodBoolean;
+        finishedAt: z.ZodDate;
+        createdAt: z.ZodDate;
+        gameType: z.ZodLiteral<"Race">;
+        lapsCompleted: z.ZodNumber;
+        fastestLapMs: z.ZodNullable<z.ZodNumber>;
+        totalTimeMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        gameId: z.ZodNumber;
+        gameTrackId: z.ZodString;
+        gameTurnId: z.ZodOptional<z.ZodString>;
+        playerId: z.ZodString;
+        playerNickname: z.ZodString;
+        kartGuid: z.ZodString;
+        position: z.ZodNumber;
+        totalKarts: z.ZodNumber;
+        isWinner: z.ZodBoolean;
+        coinsEarned: z.ZodNumber;
+        isOfficial: z.ZodBoolean;
+        finishedAt: z.ZodDate;
+        createdAt: z.ZodDate;
+        gameType: z.ZodLiteral<"Battle">;
+        livesRemaining: z.ZodNumber;
+        wasEliminated: z.ZodBoolean;
+    }, z.core.$strip>], "gameType">>;
+    meta: z.ZodObject<{
+        nextCursor: z.ZodOptional<z.ZodString>;
+        hasMore: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const gameCountByPeriodSchema: z.ZodObject<{
+    period: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export declare const gameHistoryStatsSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    byGameType: z.ZodRecord<z.ZodEnum<{
+        readonly Race: "Race";
+        readonly Battle: "Battle";
+    }>, z.ZodNumber>;
+    byPeriod: z.ZodArray<z.ZodObject<{
+        period: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const filterGameHistoryStatsSchema: z.ZodObject<{
+    gameTrackId: z.ZodOptional<z.ZodString>;
+    gameType: z.ZodOptional<z.ZodEnum<{
+        readonly Race: "Race";
+        readonly Battle: "Battle";
+    }>>;
+    from: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    to: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    groupBy: z.ZodDefault<z.ZodEnum<{
+        readonly DAY: "day";
+        readonly MONTH: "month";
+    }>>;
+    includeUnofficial: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+/** Append only ledger. Every change to a player wallet must leave one row here. */
+export declare const coinTransactionSchema: z.ZodObject<{
+    id: z.ZodString;
+    playerId: z.ZodString;
+    amount: z.ZodNumber;
+    type: z.ZodEnum<{
+        readonly GAME_REWARD: "GAME_REWARD";
+        readonly ADJUSTMENT: "ADJUSTMENT";
+    }>;
+    balanceAfter: z.ZodNumber;
+    gameId: z.ZodOptional<z.ZodNumber>;
+    gameType: z.ZodOptional<z.ZodEnum<{
+        readonly Race: "Race";
+        readonly Battle: "Battle";
+    }>>;
+    note: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const filterCoinTransactionSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const paginatedCoinTransactionSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        playerId: z.ZodString;
+        amount: z.ZodNumber;
+        type: z.ZodEnum<{
+            readonly GAME_REWARD: "GAME_REWARD";
+            readonly ADJUSTMENT: "ADJUSTMENT";
+        }>;
+        balanceAfter: z.ZodNumber;
+        gameId: z.ZodOptional<z.ZodNumber>;
+        gameType: z.ZodOptional<z.ZodEnum<{
+            readonly Race: "Race";
+            readonly Battle: "Battle";
+        }>>;
+        note: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>>;
+    meta: z.ZodObject<{
+        nextCursor: z.ZodOptional<z.ZodString>;
+        hasMore: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/domains/gameHistory/GameHistory.schema.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginatedCoinTransactionSchema = exports.filterCoinTransactionSchema = exports.coinTransactionSchema = exports.filterGameHistoryStatsSchema = exports.gameHistoryStatsSchema = exports.gameCountByPeriodSchema = exports.paginatedGameResultSchema = exports.filterGameHistorySchema = exports.gameResultSchema = exports.battleResultSchema = exports.raceResultSchema = void 0;
+const zod_1 = require("zod");
+const Game_const_1 = require("../game/Game.const");
+const Game_schema_1 = require("../game/Game.schema");
+const pagination_1 = require("../pagination");
+const GameHistory_const_1 = require("./GameHistory.const");
+// --- Game Result Schemas ---
+/**
+ * One row per (game, player). A game stores its players in `playerKartMap`, and a map
+ * cannot be queried by its keys, so per player history needs this flat collection.
+ */
+const gameResultBaseSchema = zod_1.z.object({
+    /** `${gameType}-${gameId}-${playerId}`. Writing the same result twice does not duplicate it. */
+    id: zod_1.z.string(),
+    gameId: zod_1.z.number(),
+    gameTrackId: zod_1.z.string(),
+    gameTurnId: zod_1.z.string().optional(),
+    playerId: zod_1.z.string(),
+    /** Copied at the end of the game: nicknames are not unique and can change. */
+    playerNickname: zod_1.z.string(),
+    kartGuid: zod_1.z.string(),
+    position: zod_1.z.number().int(),
+    totalKarts: zod_1.z.number().int(),
+    isWinner: zod_1.z.boolean(),
+    /** Coin balance the player ended the game with. */
+    coinsEarned: zod_1.z.number().int(),
+    isOfficial: zod_1.z.boolean(),
+    finishedAt: zod_1.z.date(),
+    createdAt: zod_1.z.date(),
+});
+exports.raceResultSchema = gameResultBaseSchema.extend({
+    gameType: zod_1.z.literal(Game_const_1.GAME_TYPE.Race),
+    lapsCompleted: zod_1.z.number().int(),
+    /** Null when the player never completed a lap. */
+    fastestLapMs: zod_1.z.number().int().nullable(),
+    totalTimeMs: zod_1.z.number().int().nullable(),
+});
+exports.battleResultSchema = gameResultBaseSchema.extend({
+    gameType: zod_1.z.literal(Game_const_1.GAME_TYPE.Battle),
+    livesRemaining: zod_1.z.number().int(),
+    wasEliminated: zod_1.z.boolean(),
+});
+exports.gameResultSchema = zod_1.z.discriminatedUnion('gameType', [exports.raceResultSchema, exports.battleResultSchema]);
+exports.filterGameHistorySchema = zod_1.z.object({
+    playerId: zod_1.z.string().optional(),
+    gameTrackId: zod_1.z.string().optional(),
+    gameType: Game_schema_1.gameTypeSchema.optional(),
+    from: zod_1.z.coerce.date().optional(),
+    to: zod_1.z.coerce.date().optional(),
+    limit: zod_1.z.coerce.number().min(1).max(100).default(20),
+    cursor: zod_1.z.string().optional(),
+});
+exports.paginatedGameResultSchema = (0, pagination_1.paginatedResponseSchema)(exports.gameResultSchema);
+// --- Staff Counter Schemas ---
+exports.gameCountByPeriodSchema = zod_1.z.object({
+    /** `YYYY-MM-DD` when grouping by day, `YYYY-MM` when grouping by month. */
+    period: zod_1.z.string(),
+    count: zod_1.z.number().int(),
+});
+exports.gameHistoryStatsSchema = zod_1.z.object({
+    total: zod_1.z.number().int(),
+    byGameType: zod_1.z.record(Game_schema_1.gameTypeSchema, zod_1.z.number().int()),
+    byPeriod: zod_1.z.array(exports.gameCountByPeriodSchema),
+});
+exports.filterGameHistoryStatsSchema = zod_1.z.object({
+    gameTrackId: zod_1.z.string().optional(),
+    gameType: Game_schema_1.gameTypeSchema.optional(),
+    from: zod_1.z.coerce.date().optional(),
+    to: zod_1.z.coerce.date().optional(),
+    groupBy: zod_1.z.enum(GameHistory_const_1.GAME_HISTORY_GROUP_BY).default(GameHistory_const_1.GAME_HISTORY_GROUP_BY.DAY),
+    /** Operator test games are left out unless this is set. */
+    includeUnofficial: zod_1.z.coerce.boolean().default(false),
+});
+// --- Coin Transaction Schemas ---
+/** Append only ledger. Every change to a player wallet must leave one row here. */
+exports.coinTransactionSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    playerId: zod_1.z.string(),
+    /** Positive when the player earns coins, negative when they spend them. */
+    amount: zod_1.z.number().int(),
+    type: zod_1.z.enum(GameHistory_const_1.COIN_TRANSACTION_TYPE),
+    balanceAfter: zod_1.z.number().int(),
+    gameId: zod_1.z.number().optional(),
+    gameType: Game_schema_1.gameTypeSchema.optional(),
+    note: zod_1.z.string().optional(),
+    createdAt: zod_1.z.date(),
+});
+exports.filterCoinTransactionSchema = zod_1.z.object({
+    limit: zod_1.z.coerce.number().min(1).max(100).default(20),
+    cursor: zod_1.z.string().optional(),
+});
+exports.paginatedCoinTransactionSchema = (0, pagination_1.paginatedResponseSchema)(exports.coinTransactionSchema);

package/dist/domains/gameHistory/GameHistory.types.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { coinTransactionSchema, filterCoinTransactionSchema, filterGameHistorySchema, filterGameHistoryStatsSchema, gameCountByPeriodSchema, gameHistoryStatsSchema, battleResultSchema, gameResultSchema, paginatedCoinTransactionSchema, paginatedGameResultSchema, raceResultSchema } from './GameHistory.schema';
+export type RaceResult = z.infer<typeof raceResultSchema>;
+export type BattleResult = z.infer<typeof battleResultSchema>;
+export type GameResult = z.infer<typeof gameResultSchema>;
+export type FilterGameHistory = z.infer<typeof filterGameHistorySchema>;
+export type PaginatedGameResult = z.infer<typeof paginatedGameResultSchema>;
+export type GameCountByPeriod = z.infer<typeof gameCountByPeriodSchema>;
+export type GameHistoryStats = z.infer<typeof gameHistoryStatsSchema>;
+export type FilterGameHistoryStats = z.infer<typeof filterGameHistoryStatsSchema>;
+export type CoinTransaction = z.infer<typeof coinTransactionSchema>;
+export type FilterCoinTransaction = z.infer<typeof filterCoinTransactionSchema>;
+export type PaginatedCoinTransaction = z.infer<typeof paginatedCoinTransactionSchema>;

package/dist/domains/gameHistory/GameHistory.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domains/gameHistory/index.d.ts

@@ -0,0 +1,3 @@
+export * from './GameHistory.const';
+export * from './GameHistory.schema';
+export * from './GameHistory.types';

package/dist/domains/gameHistory/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./GameHistory.const"), exports);
+__exportStar(require("./GameHistory.schema"), exports);
+__exportStar(require("./GameHistory.types"), exports);

package/dist/domains/hardware/KartHardwareState.schema.d.ts

@@ -52,10 +52,11 @@ export declare const kartHardwareStateSchema: z.ZodObject<{
     steeringWheel: z.ZodNullable<z.ZodObject<{
         ledStatus: z.ZodEnum<{
             readonly OFF: "Off";
-            readonly IDLE: "Idle";
-            readonly POWER_UP: "Power-Up";
-            readonly EMERGENCY: "Emergency";
+            readonly COLOR: "Color";
+            readonly EFFECT: "Effect";
             readonly CONFIG: "Config";
+            readonly ERROR: "Error";
+            readonly UNKNOWN: "Unknown";
         }>;
         buttons: z.ZodObject<{
             powerRightPressed: z.ZodBoolean;

package/dist/domains/hardware/ModuleStatus.schema.d.ts

@@ -109,10 +109,11 @@ export declare const moduleStatusSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     ledStatus: z.ZodEnum<{
         readonly OFF: "Off";
-        readonly IDLE: "Idle";
-        readonly POWER_UP: "Power-Up";
-        readonly EMERGENCY: "Emergency";
+        readonly COLOR: "Color";
+        readonly EFFECT: "Effect";
         readonly CONFIG: "Config";
+        readonly ERROR: "Error";
+        readonly UNKNOWN: "Unknown";
     }>;
     buttons: z.ZodObject<{
         powerRightPressed: z.ZodBoolean;

package/dist/domains/hardware/screen/ScreenDebug.schema.d.ts

@@ -52,10 +52,11 @@ export declare const screenDebugViewInputSchema: z.ZodObject<{
     steeringWheel: z.ZodNullable<z.ZodObject<{
         ledStatus: z.ZodEnum<{
             readonly OFF: "Off";
-            readonly IDLE: "Idle";
-            readonly POWER_UP: "Power-Up";
-            readonly EMERGENCY: "Emergency";
+            readonly COLOR: "Color";
+            readonly EFFECT: "Effect";
             readonly CONFIG: "Config";
+            readonly ERROR: "Error";
+            readonly UNKNOWN: "Unknown";
         }>;
         buttons: z.ZodObject<{
             powerRightPressed: z.ZodBoolean;

package/dist/domains/hardware/steering-wheel/SteeringWheel.const.d.ts

@@ -6,15 +6,26 @@ export declare const STEERING_WHEEL_ACTION_COMMAND: {
     readonly CONFIGURE_LEDS: "ConfigureLeds";
 };
 export declare const STEERING_WHEEL_SHOW_LED_EFFECT_OPTIONS: {
-    readonly SHOW_LED_IDLE_EFFECT: "ShowLedIdleEffect";
-    readonly SHOW_LED_POWERUP_EFFECT: "ShowLedPowerupEffect";
-    readonly SHOW_LED_EMERGENCY_EFFECT: "ShowLedEmergencyEffect";
-    readonly SHOW_LED_CONFIG_EFFECT: "ShowLedConfigEffect";
+    readonly SHOW_COLOR: "ShowColor";
+    readonly STAR: "Star";
+    readonly RAY: "Ray";
+    readonly RAY_HIT: "RayHit";
+    readonly SPEED_BOOST: "SpeedBoost";
+    readonly CHARGED_POWER: "ChargedPower";
+    readonly ROULETTE: "Roulette";
+    readonly SHIELD: "Shield";
+    readonly BROKEN_SHIELD: "BrokenShield";
+    readonly WAIT: "Wait";
+    readonly STANDARD: "Standard";
+    readonly POWER_UP: "PowerUp";
+    readonly EMERGENCY: "Emergency";
+    readonly TRAFFIC_LIGHT: "TrafficLight";
 };
 export declare const STEERING_WHEEL_LED_STATUS: {
     readonly OFF: "Off";
-    readonly IDLE: "Idle";
-    readonly POWER_UP: "Power-Up";
-    readonly EMERGENCY: "Emergency";
+    readonly COLOR: "Color";
+    readonly EFFECT: "Effect";
     readonly CONFIG: "Config";
+    readonly ERROR: "Error";
+    readonly UNKNOWN: "Unknown";
 };

package/dist/domains/hardware/steering-wheel/SteeringWheel.const.js

@@ -9,15 +9,26 @@ exports.STEERING_WHEEL_ACTION_COMMAND = {
     CONFIGURE_LEDS: 'ConfigureLeds',
 };
 exports.STEERING_WHEEL_SHOW_LED_EFFECT_OPTIONS = {
-    SHOW_LED_IDLE_EFFECT: 'ShowLedIdleEffect',
-    SHOW_LED_POWERUP_EFFECT: 'ShowLedPowerupEffect',
-    SHOW_LED_EMERGENCY_EFFECT: 'ShowLedEmergencyEffect',
-    SHOW_LED_CONFIG_EFFECT: 'ShowLedConfigEffect',
+    SHOW_COLOR: 'ShowColor',
+    STAR: 'Star',
+    RAY: 'Ray',
+    RAY_HIT: 'RayHit',
+    SPEED_BOOST: 'SpeedBoost',
+    CHARGED_POWER: 'ChargedPower',
+    ROULETTE: 'Roulette',
+    SHIELD: 'Shield',
+    BROKEN_SHIELD: 'BrokenShield',
+    WAIT: 'Wait',
+    STANDARD: 'Standard',
+    POWER_UP: 'PowerUp',
+    EMERGENCY: 'Emergency',
+    TRAFFIC_LIGHT: 'TrafficLight',
 };
 exports.STEERING_WHEEL_LED_STATUS = {
     OFF: 'Off',
-    IDLE: 'Idle',
-    POWER_UP: 'Power-Up',
-    EMERGENCY: 'Emergency',
+    COLOR: 'Color',
+    EFFECT: 'Effect',
     CONFIG: 'Config',
+    ERROR: 'Error',
+    UNKNOWN: 'Unknown',
 };

package/dist/domains/hardware/steering-wheel/SteeringWheel.schema.d.ts

@@ -7,18 +7,20 @@ export declare const steeringWheelActionCommandSchema: z.ZodEnum<{
 }>;
 export declare const steeringWheelLedStatusSchema: z.ZodEnum<{
     readonly OFF: "Off";
-    readonly IDLE: "Idle";
-    readonly POWER_UP: "Power-Up";
-    readonly EMERGENCY: "Emergency";
+    readonly COLOR: "Color";
+    readonly EFFECT: "Effect";
     readonly CONFIG: "Config";
+    readonly ERROR: "Error";
+    readonly UNKNOWN: "Unknown";
 }>;
 export declare const steeringWheelModuleStatusSchema: z.ZodObject<{
     ledStatus: z.ZodEnum<{
         readonly OFF: "Off";
-        readonly IDLE: "Idle";
-        readonly POWER_UP: "Power-Up";
-        readonly EMERGENCY: "Emergency";
+        readonly COLOR: "Color";
+        readonly EFFECT: "Effect";
         readonly CONFIG: "Config";
+        readonly ERROR: "Error";
+        readonly UNKNOWN: "Unknown";
     }>;
     buttons: z.ZodObject<{
         powerRightPressed: z.ZodBoolean;
@@ -30,12 +32,36 @@ export declare const steeringWheelModuleStatusSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const steeringWheelShowLedsEffectOptionsSchema: z.ZodEnum<{
-    readonly SHOW_LED_IDLE_EFFECT: "ShowLedIdleEffect";
-    readonly SHOW_LED_POWERUP_EFFECT: "ShowLedPowerupEffect";
-    readonly SHOW_LED_EMERGENCY_EFFECT: "ShowLedEmergencyEffect";
-    readonly SHOW_LED_CONFIG_EFFECT: "ShowLedConfigEffect";
+    readonly SHOW_COLOR: "ShowColor";
+    readonly STAR: "Star";
+    readonly RAY: "Ray";
+    readonly RAY_HIT: "RayHit";
+    readonly SPEED_BOOST: "SpeedBoost";
+    readonly CHARGED_POWER: "ChargedPower";
+    readonly ROULETTE: "Roulette";
+    readonly SHIELD: "Shield";
+    readonly BROKEN_SHIELD: "BrokenShield";
+    readonly WAIT: "Wait";
+    readonly STANDARD: "Standard";
+    readonly POWER_UP: "PowerUp";
+    readonly EMERGENCY: "Emergency";
+    readonly TRAFFIC_LIGHT: "TrafficLight";
 }>;
 export declare const steeringWheelConfigureLedsOptionsSchema: z.ZodObject<{
     brightness: z.ZodNumber;
     durationSeconds: z.ZodNumber;
+    colorBody: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        readonly Black: "Black";
+        readonly Red: "Red";
+        readonly Blue: "Blue";
+        readonly Green: "Green";
+        readonly Yellow: "Yellow";
+        readonly Violet: "Violet";
+        readonly Cyan: "Cyan";
+        readonly Magenta: "Magenta";
+        readonly Orange: "Orange";
+        readonly White: "White";
+        readonly GreenYellow: "GreenYellow";
+        readonly SaddleBrown: "SaddleBrown";
+    }>>>;
 }, z.core.$strip>;

package/dist/domains/hardware/steering-wheel/SteeringWheel.schema.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.steeringWheelConfigureLedsOptionsSchema = exports.steeringWheelShowLedsEffectOptionsSchema = exports.steeringWheelModuleStatusSchema = exports.steeringWheelLedStatusSchema = exports.steeringWheelActionCommandSchema = void 0;
 const zod_1 = require("zod");
+const Color_schema_1 = require("../../color/Color.schema");
+const Color_const_1 = require("../../color/Color.const");
 const SteeringWheel_const_1 = require("./SteeringWheel.const");
 exports.steeringWheelActionCommandSchema = zod_1.z.enum(SteeringWheel_const_1.STEERING_WHEEL_ACTION_COMMAND);
 exports.steeringWheelLedStatusSchema = zod_1.z.enum(SteeringWheel_const_1.STEERING_WHEEL_LED_STATUS);
@@ -20,4 +22,5 @@ exports.steeringWheelShowLedsEffectOptionsSchema = zod_1.z.enum(SteeringWheel_co
 exports.steeringWheelConfigureLedsOptionsSchema = zod_1.z.object({
     brightness: zod_1.z.number().min(0).max(100),
     durationSeconds: zod_1.z.number().min(1).max(25),
+    colorBody: Color_schema_1.colorNameSchema.optional().default(Color_const_1.COLOR_NAME.Red),
 });

package/dist/domains/kart/Kart.schema.d.ts

@@ -116,10 +116,11 @@ export declare const kartSchema: z.ZodObject<{
         steeringWheel: z.ZodNullable<z.ZodObject<{
             ledStatus: z.ZodEnum<{
                 readonly OFF: "Off";
-                readonly IDLE: "Idle";
-                readonly POWER_UP: "Power-Up";
-                readonly EMERGENCY: "Emergency";
+                readonly COLOR: "Color";
+                readonly EFFECT: "Effect";
                 readonly CONFIG: "Config";
+                readonly ERROR: "Error";
+                readonly UNKNOWN: "Unknown";
             }>;
             buttons: z.ZodObject<{
                 powerRightPressed: z.ZodBoolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@battle-racing/br-common-lib",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "description": "Common library for all Battle Racing Repositorios",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/src/domains/hardware/steering-wheel/SteeringWheel.const.ts

@@ -7,16 +7,27 @@ export const STEERING_WHEEL_ACTION_COMMAND = {
 } as const;
 
 export const STEERING_WHEEL_SHOW_LED_EFFECT_OPTIONS = {
-  SHOW_LED_IDLE_EFFECT: 'ShowLedIdleEffect',
-  SHOW_LED_POWERUP_EFFECT: 'ShowLedPowerupEffect',
-  SHOW_LED_EMERGENCY_EFFECT: 'ShowLedEmergencyEffect',
-  SHOW_LED_CONFIG_EFFECT: 'ShowLedConfigEffect',
+  SHOW_COLOR: 'ShowColor',
+  STAR: 'Star',
+  RAY: 'Ray',
+  RAY_HIT: 'RayHit',
+  SPEED_BOOST: 'SpeedBoost',
+  CHARGED_POWER: 'ChargedPower',
+  ROULETTE: 'Roulette',
+  SHIELD: 'Shield',
+  BROKEN_SHIELD: 'BrokenShield',
+  WAIT: 'Wait',
+  STANDARD: 'Standard',
+  POWER_UP: 'PowerUp',
+  EMERGENCY: 'Emergency',
+  TRAFFIC_LIGHT: 'TrafficLight',
 } as const;
 
 export const STEERING_WHEEL_LED_STATUS = {
   OFF: 'Off',
-  IDLE: 'Idle',
-  POWER_UP: 'Power-Up',
-  EMERGENCY: 'Emergency',
+  COLOR: 'Color',
+  EFFECT: 'Effect',
   CONFIG: 'Config',
+  ERROR: 'Error',
+  UNKNOWN: 'Unknown',
 } as const;

package/src/domains/hardware/steering-wheel/SteeringWheel.schema.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { colorNameSchema } from '../../color/Color.schema';
+import { COLOR_NAME } from '../../color/Color.const';
 import {
   STEERING_WHEEL_ACTION_COMMAND,
   STEERING_WHEEL_LED_STATUS,
@@ -25,4 +27,5 @@ export const steeringWheelShowLedsEffectOptionsSchema = z.enum(STEERING_WHEEL_SH
 export const steeringWheelConfigureLedsOptionsSchema = z.object({
   brightness: z.number().min(0).max(100),
   durationSeconds: z.number().min(1).max(25),
+  colorBody: colorNameSchema.optional().default(COLOR_NAME.Red),
 });