@battle-racing/br-common-lib 4.5.0 → 4.6.1

package/dist/domains/user/User.types.d.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
-import { userSchema, userTypeSchema, userWithPasswordSchema, userInitialRegistrationSchema, userVerifySchema, userCompleteProfileSchema, userLoginInputSchema, authUserSchema } from './User.schema';
+import { authUserSchema, initialUserSchema, userCompleteProfileSchema, userInitialRegistrationSchema, userLoginInputSchema, userSchema, userTypeSchema, userVerifySchema, userWithPasswordSchema } from './User.schema';
 export type UserType = z.infer<typeof userTypeSchema>;
 export type User = z.infer<typeof userSchema>;
 export type UserWithPassword = z.infer<typeof userWithPasswordSchema>;
 export type AuthUser = z.infer<typeof authUserSchema>;
+export type InitialUser = z.infer<typeof initialUserSchema>;
 export type UserInitialRegistration = z.infer<typeof userInitialRegistrationSchema>;
 export type UserVerify = z.infer<typeof userVerifySchema>;
 export type UserCompleteProfile = z.infer<typeof userCompleteProfileSchema>;

package/package.json

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

package/src/domains/command/Command.schema.ts

@@ -10,6 +10,8 @@ import {
   screenCountdownParamsSchema,
   screenFinishViewInputSchema,
   screenUpdateGameViewInputSchema,
+  showLightsColorParamsSchema,
+  showLightsEffectParamsSchema,
   speedChangeOptionsSchema,
   speedConfigurationSchema,
   starLaserConfigureModuleOptionsSchema,
@@ -152,16 +154,32 @@ export const steeringWheelModuleCommandSchema = z.union([
   z.object({ module: z.literal('steeringWheel'), action: z.literal('turnLedOff') }),
 ]);
 
-// --- All Commands Union ---
-export const allCommandsConfigSchema = z.union([
-  ballSensorDiskThrowerModuleCommandSchema,
-  diskSensorBallShooterModuleCommandSchema,
-  flagModuleCommandSchema,
-  rgbModuleCommandSchema,
-  speedModuleCommandSchema,
-  leftStarBackLaserModuleCommandSchema,
-  rightStarFrontLaserModuleCommandSchema,
-  screenModuleCommandSchema,
-  steeringWheelModuleCommandSchema,
-  soundModuleCommandSchema,
+// --- Emergency ---
+export const emergencyModuleCommandSchema = z.union([
+  z.object({ module: z.literal('emergency'), action: z.literal('activate') }),
+  z.object({ module: z.literal('emergency'), action: z.literal('deactivate') }),
+]);
+
+// --- Lights ---
+export const lightsModuleCommandSchema = z.union([
+  z.object({ module: z.literal('lights'), action: z.literal('showColor'), params: showLightsColorParamsSchema }),
+  z.object({ module: z.literal('lights'), action: z.literal('showEffect'), params: showLightsEffectParamsSchema }),
 ]);
+
+// --- All Commands Union ---
+export const allCommandsConfigSchema = z
+  .union([
+    ballSensorDiskThrowerModuleCommandSchema,
+    diskSensorBallShooterModuleCommandSchema,
+    flagModuleCommandSchema,
+    rgbModuleCommandSchema,
+    speedModuleCommandSchema,
+    leftStarBackLaserModuleCommandSchema,
+    rightStarFrontLaserModuleCommandSchema,
+    screenModuleCommandSchema,
+    steeringWheelModuleCommandSchema,
+    soundModuleCommandSchema,
+    emergencyModuleCommandSchema,
+    lightsModuleCommandSchema,
+  ])
+  .and(z.object({ params: z.unknown().optional() }));

package/src/domains/command/Command.types.ts

@@ -4,8 +4,10 @@ import {
   ballSensorDiskThrowerModuleCommandSchema,
   changeSpeedActionCommandOptionsSchema,
   diskSensorBallShooterModuleCommandSchema,
+  emergencyModuleCommandSchema,
   flagModuleCommandSchema,
   leftStarBackLaserModuleCommandSchema,
+  lightsModuleCommandSchema,
   playSoundActionCommandOptionsSchema,
   rgbModuleCommandSchema,
   rightStarFrontLaserModuleCommandSchema,
@@ -28,5 +30,7 @@ export type RightStarFrontLaserModuleCommands = z.infer<typeof rightStarFrontLas
 export type ScreenModuleCommands = z.infer<typeof screenModuleCommandSchema>;
 export type SteeringWheelModuleCommands = z.infer<typeof steeringWheelModuleCommandSchema>;
 export type SoundModuleCommands = z.infer<typeof soundModuleCommandSchema>;
+export type EmergencyModuleCommands = z.infer<typeof emergencyModuleCommandSchema>;
+export type LightsModuleCommands = z.infer<typeof lightsModuleCommandSchema>;
 
 export type AllCommandsConfig = z.infer<typeof allCommandsConfigSchema>;

package/src/domains/hardware/KartHardwareState.schema.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { checkpointTypeSchema } from '../checkpoint/Checkpoint.schema';
-import { flagStatusSchema } from './flag/Flag.schema';
-import { rgbStatusSchema } from './rgb/RGB.schema';
-import { screenStatusSchema } from './screen/Screen.schema';
-import { speedStatusSchema } from './speed/Speed.schema';
+import { flagStatusSchema } from './flag';
+import { rgbStatusSchema } from './rgb';
+import { screenStatusSchema } from './screen';
+import { speedStatusSchema } from './speed';
 
 export const kartHardwareStateSchema = z.object({
   speed: z

package/src/domains/hardware/KartHardwareState.types.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { kartHardwareStateSchema } from './KartHardwareState.schema';
+
+export type KartHardwareState = z.infer<typeof kartHardwareStateSchema>;

package/src/domains/hardware/ModuleStatus.schema.ts

@@ -3,9 +3,11 @@ import { ballSensorDiskThrowerModuleStatusSchema } from './ballSensor';
 import { diskSensorBallShooterModuleStatusSchema } from './diskSensor';
 import { emergencyModuleStatusSchema } from './emergency';
 import { flagModuleStatusSchema } from './flag';
+import { lightsModuleStatusSchema } from './lights';
 import { MODULE_NAME } from './ModuleName.const';
 import { rgbModuleStatusSchema } from './rgb';
 import { speedModuleStatusSchema } from './speed';
+import { screenModuleStatusSchema } from './screen';
 import { starLaserModuleStatusSchema } from './star-laser';
 import { steeringWheelModuleStatusSchema } from './steering-wheel';
 
@@ -20,4 +22,6 @@ export const moduleStatusSchema = z.union([
   starLaserModuleStatusSchema,
   steeringWheelModuleStatusSchema,
   emergencyModuleStatusSchema,
+  screenModuleStatusSchema,
+  lightsModuleStatusSchema,
 ]);

package/src/domains/hardware/ballSensor/BallSensor.const.ts

@@ -11,3 +11,9 @@ export const BALL_SENSOR_STATUS = {
   SENSOR_HIT: 'Sensor Hit',
   UNKNOWN: 'Unknown',
 } as const;
+
+export const DISK_THROWER_COMMAND = {
+  ACTIVATE_THROWER: 'Activate Thrower',
+  DEACTIVATE_THROWER: 'Deactivate Thrower',
+  THROW_DISK: 'Throw Disk',
+} as const;

package/src/domains/hardware/ballSensor/BallSensor.schema.ts

@@ -1,8 +1,10 @@
 import { z } from 'zod';
-import { BALL_SENSOR_COMMAND, BALL_SENSOR_STATUS } from './BallSensor.const';
+import { BALL_SENSOR_COMMAND, BALL_SENSOR_STATUS, DISK_THROWER_COMMAND } from './BallSensor.const';
 
 export const ballSensorCommandSchema = z.enum(BALL_SENSOR_COMMAND);
 
+export const diskThrowerCommandSchema = z.enum(DISK_THROWER_COMMAND);
+
 export const ballSensorStatusSchema = z.enum(BALL_SENSOR_STATUS);
 
 export const configureBallSensorDiskThrowerModuleOptionsSchema = z.object({

package/src/domains/hardware/ballSensor/BallSensor.types.ts

@@ -4,9 +4,11 @@ import {
   ballSensorDiskThrowerModuleStatusSchema,
   ballSensorStatusSchema,
   configureBallSensorDiskThrowerModuleOptionsSchema,
+  diskThrowerCommandSchema,
 } from './BallSensor.schema';
 
 export type BallSensorCommand = z.infer<typeof ballSensorCommandSchema>;
+export type DiskThrowerCommand = z.infer<typeof diskThrowerCommandSchema>;
 export type BallSensorStatus = z.infer<typeof ballSensorStatusSchema>;
 export type ConfigureBallSensorDiskThrowerModuleOptions = z.infer<
   typeof configureBallSensorDiskThrowerModuleOptionsSchema

package/src/domains/hardware/flag/Flag.const.ts

@@ -82,3 +82,11 @@ export const FLAG_MEDIA_NAME = {
   STATIC_BEATING_HEART: 'static_beating_heart',
   STATIC_SPEED_PAD: 'static_speed_pad',
 } as const;
+
+export const FLAG_ACTION_COMMAND = {
+  ACTIVATE: 'Activate',
+  DEACTIVATE: 'Deactivate',
+  SHOW_MEDIA_INDEFINITELY: 'Show Media Indefinitely',
+  SHOW_MEDIA_TEMPORARILY: 'Show Media Temporarily',
+  CONFIGURE: 'Configure',
+} as const;

package/src/domains/hardware/flag/Flag.schema.ts

@@ -1,11 +1,15 @@
 import { z } from 'zod';
 import { colorNameSchema } from '../../color';
 import { checkpointTypeSchema } from '../../checkpoint';
-import { FLAG_MEDIA_NAME, FLAG_STATUS } from './Flag.const';
+import { FLAG_MEDIA_NAME, FLAG_STATUS, FLAG_ACTION_COMMAND } from './Flag.const';
 
 export const flagStatusSchema = z.enum(FLAG_STATUS);
 
-export const flagMediaNameSchema = z.enum(FLAG_MEDIA_NAME);
+export const flagActionCommandSchema = z.enum(FLAG_ACTION_COMMAND);
+
+export const flagMediaNameSchema = z
+  .union([z.number().min(0).max(255), z.enum(FLAG_MEDIA_NAME)])
+  .describe('The Media source could be the name of the icon on Flag Module or a number to render');
 
 export const flagModuleStatusSchema = z.object({
   flagStatus: flagStatusSchema,

package/src/domains/hardware/flag/Flag.types.ts

@@ -5,9 +5,11 @@ import {
   flagModuleStatusSchema,
   flagShowMediaOptionsSchema,
   flagStatusSchema,
+  flagActionCommandSchema,
 } from './Flag.schema';
 
 export type FlagStatus = z.infer<typeof flagStatusSchema>;
+export type FlagActionCommand = z.infer<typeof flagActionCommandSchema>;
 export type FlagMediaName = z.infer<typeof flagMediaNameSchema>;
 export type FlagModuleStatus = z.infer<typeof flagModuleStatusSchema>;
 export type FlagConfigurationOptions = z.infer<typeof flagConfigurationOptionsSchema>;

package/src/domains/hardware/index.ts

@@ -8,7 +8,8 @@ export * from './lights';
 export * from './ModuleName.const';
 export * from './ModuleStatus.schema';
 export * from './ModuleStatus.types';
-export * from './KartHardwareState.schema'; // Added
+export * from './KartHardwareState.schema';
+export * from './KartHardwareState.types';
 export * from './rgb';
 export * from './screen';
 export * from './sound';

package/src/domains/hardware/lights/Lights.const.ts

@@ -9,3 +9,8 @@ export const LIGHTS_EFFECT = {
   RED_FLAG: 'RED_FLAG',
   PULSE: 'PULSE',
 } as const;
+
+export const LIGHTS_ACTION_COMMAND = {
+  SHOW_COLOR: 'ShowColor',
+  SHOW_EFFECT: 'ShowEffect',
+} as const;

package/src/domains/hardware/lights/Lights.schema.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
-import { LIGHTS_EFFECT } from './Lights.const';
+import { LIGHTS_EFFECT, LIGHTS_ACTION_COMMAND } from './Lights.const';
+
+export const lightsActionCommandSchema = z.enum(LIGHTS_ACTION_COMMAND);
 
 export const lightsEffectSchema = z.enum(LIGHTS_EFFECT);
 
@@ -14,3 +16,7 @@ export const showLightsEffectParamsSchema = z.object({
   effect: lightsEffectSchema,
   timeDuration: z.number().min(1).max(25),
 });
+
+export const lightsModuleStatusSchema = z.object({
+  currentEffect: lightsEffectSchema.nullable(),
+});

package/src/domains/hardware/lights/Lights.types.ts

@@ -1,6 +1,14 @@
 import { z } from 'zod';
-import { lightsEffectSchema, showLightsColorParamsSchema, showLightsEffectParamsSchema } from './Lights.schema';
+import {
+  lightsActionCommandSchema,
+  lightsEffectSchema,
+  lightsModuleStatusSchema,
+  showLightsColorParamsSchema,
+  showLightsEffectParamsSchema,
+} from './Lights.schema';
 
+export type LightsActionCommand = z.infer<typeof lightsActionCommandSchema>;
 export type LightsEffect = z.infer<typeof lightsEffectSchema>;
+export type LightsModuleStatus = z.infer<typeof lightsModuleStatusSchema>;
 export type ShowLightsColorParams = z.infer<typeof showLightsColorParamsSchema>;
 export type ShowLightsEffectParams = z.infer<typeof showLightsEffectParamsSchema>;

package/src/domains/hardware/rgb/RGB.const.ts

@@ -6,3 +6,8 @@ export const RGB_STATUS = {
   UNKNOWN: 'Unknown',
   ERROR: 'Error',
 } as const;
+
+export const RGB_ACTION_COMMANDS = {
+  EXEC: 'Exec',
+  CONFIGURE: 'Configure',
+} as const;

package/src/domains/hardware/rgb/RGB.schema.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { colorNameSchema } from '../../color';
 import { kartEffectSchema } from '../../hardware/kart-effect';
-import { RGB_STATUS } from './RGB.const';
+import { RGB_STATUS, RGB_ACTION_COMMANDS } from './RGB.const';
 
 export const rgbStatusSchema = z.enum(RGB_STATUS);
 
+export const rgbActionCommandSchema = z.enum(RGB_ACTION_COMMANDS);
+
 export const rgbModuleStatusSchema = z.object({
   rgbStatus: rgbStatusSchema,
   kartColor: colorNameSchema,

package/src/domains/hardware/rgb/RGB.types.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import {
+  rgbActionCommandSchema,
   rgbConfigurationOptionsSchema,
   rgbModuleStatusSchema,
   rgbShowEffectOptionsSchema,
@@ -10,3 +11,4 @@ export type RGBStatus = z.infer<typeof rgbStatusSchema>;
 export type RGBModuleStatus = z.infer<typeof rgbModuleStatusSchema>;
 export type RGBConfigurationOptions = z.infer<typeof rgbConfigurationOptionsSchema>;
 export type RGBShowEffectOptions = z.infer<typeof rgbShowEffectOptionsSchema>;
+export type RGBActionCommand = z.infer<typeof rgbActionCommandSchema>;

package/src/domains/hardware/sound/Sound.const.ts

@@ -1,3 +1,7 @@
 export const PLAY_SOUND_DURATION = {
   INFINITE: 'infinite',
 } as const;
+
+export const SOUND_ACTION_COMMAND = {
+  PLAY: 'Play',
+} as const;

package/src/domains/hardware/sound/Sound.schema.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { soundNameSchema } from '../../sounds'; // Import from domains/sounds
-import { PLAY_SOUND_DURATION } from './Sound.const';
+import { PLAY_SOUND_DURATION, SOUND_ACTION_COMMAND } from './Sound.const';
+
+export const soundActionCommandSchema = z.enum(SOUND_ACTION_COMMAND);
 
 export const playSoundOptionsSchema = z.object({
   soundName: soundNameSchema,

package/src/domains/hardware/sound/Sound.types.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
-import { playSoundOptionsSchema } from './Sound.schema';
+import { soundActionCommandSchema, playSoundOptionsSchema } from './Sound.schema';
+
+export type SoundActionCommand = z.infer<typeof soundActionCommandSchema>;
 
 export type PlaySoundOptions = z.infer<typeof playSoundOptionsSchema>;

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

@@ -0,0 +1,4 @@
+export const STEERING_WHEEL_ACTION_COMMAND = {
+  TURN_LED_ON: 'TurnLedOn',
+  TURN_LED_OFF: 'TurnLedOff',
+} as const;

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

@@ -1,4 +1,7 @@
 import { z } from 'zod';
+import { STEERING_WHEEL_ACTION_COMMAND } from './SteeringWheel.const';
+
+export const steeringWheelActionCommandSchema = z.enum(STEERING_WHEEL_ACTION_COMMAND);
 
 export const steeringWheelModuleStatusSchema = z.object({
   isLeftButtonPressed: z.boolean(),

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

@@ -1,4 +1,6 @@
 import { z } from 'zod';
-import { steeringWheelModuleStatusSchema } from './SteeringWheel.schema';
+import { steeringWheelActionCommandSchema, steeringWheelModuleStatusSchema } from './SteeringWheel.schema';
+
+export type SteeringWheelActionCommand = z.infer<typeof steeringWheelActionCommandSchema>;
 
 export type SteeringWheelModuleStatus = z.infer<typeof steeringWheelModuleStatusSchema>;

package/src/domains/socket/index.ts

@@ -5,3 +5,4 @@ export * from './SocketHardwareModulesEventsParams';
 export * from './SocketHardwareOnDataEventsParams';
 export * from './SocketPowerUpEventsParams';
 export * from './utils';
+export * from './screen';

package/src/domains/socket/screen/SocketScreenServerToClientEventsParams.ts

@@ -0,0 +1,19 @@
+import type {
+  ScreenCountdownParams,
+  ScreenDebugViewInput,
+  ScreenFinishViewInput,
+  ScreenHomeViewInput,
+  ScreenUpdateGameViewInput,
+} from '../../hardware';
+
+/**
+ * Socket events from Raspberry Pi to Screen
+ */
+export interface SocketScreenServerToClientEventsParams {
+  'view:home': ScreenHomeViewInput;
+  'view:countdown': ScreenCountdownParams;
+  'game:sync_state': ScreenUpdateGameViewInput;
+  'view:summary': ScreenFinishViewInput & { state: 'Victory' | 'Defeat' };
+  'view:debug': ScreenDebugViewInput;
+  'view:instruction_video': Record<string, never>;
+}

package/src/domains/socket/screen/index.ts

@@ -0,0 +1 @@
+export * from './SocketScreenServerToClientEventsParams';

package/src/domains/ticketing/Ticketing.schema.ts

@@ -85,6 +85,8 @@ export const gameTurnTaskSchema = z.object({
 
 export const gameTurnSchema = z.object({
   id: z.string(),
+  turnNumber: z.number().int().positive(),
+  groupName: z.string().optional(),
   purchaseId: z.string(),
   sessionId: z.string().optional(),
   leaderPlayerId: z.string(),

package/src/domains/user/User.schema.ts

@@ -22,8 +22,8 @@ export const emailOrPhoneSchema = z
 const baseUserObj = z.object({
   id: z.uuidv4(),
 
-  name: z.string(),
-  lastName: z.string(),
+  name: z.string().optional(),
+  lastName: z.string().optional(),
 
   email: z.email().toLowerCase().optional().nullable(),
 
@@ -49,6 +49,19 @@ export const userSchema = baseUserObj.refine((data) => data.email || data.phoneN
   path: ['email', 'phoneNumber'],
 });
 
+/**
+ * When a user registers, we don't have all the information, so we use this schema
+ */
+export const initialUserSchema = baseUserObj.pick({
+  id: true,
+  email: true,
+  phoneNumber: true,
+  isEmailVerified: true,
+  isPhoneVerified: true,
+  type: true,
+  createdAt: true,
+});
+
 /**
  * The schema for the user returned on login
  */

package/src/domains/user/User.types.ts

@@ -1,19 +1,21 @@
 import { z } from 'zod';
 import {
+  authUserSchema,
+  initialUserSchema,
+  userCompleteProfileSchema,
+  userInitialRegistrationSchema,
+  userLoginInputSchema,
   userSchema,
   userTypeSchema,
-  userWithPasswordSchema,
-  userInitialRegistrationSchema,
   userVerifySchema,
-  userCompleteProfileSchema,
-  userLoginInputSchema,
-  authUserSchema,
+  userWithPasswordSchema,
 } from './User.schema';
 
 export type UserType = z.infer<typeof userTypeSchema>;
 export type User = z.infer<typeof userSchema>;
 export type UserWithPassword = z.infer<typeof userWithPasswordSchema>;
 export type AuthUser = z.infer<typeof authUserSchema>;
+export type InitialUser = z.infer<typeof initialUserSchema>;
 export type UserInitialRegistration = z.infer<typeof userInitialRegistrationSchema>;
 export type UserVerify = z.infer<typeof userVerifySchema>;
 export type UserCompleteProfile = z.infer<typeof userCompleteProfileSchema>;