Converted socketEvents to new format

Still need to rework 'any' type Promises

src/socketEvents/gameMaster/assetManager/sprite/create.ts

@@ -6,15 +6,19 @@ import prisma from '../../../../utilities/prisma'
 import CharacterManager from '../../../../managers/characterManager'
 import characterRepository from '../../../../repositories/characterRepository'
 
-/**
- * Handle game master new sprite event
- * @param socket
- * @param io
- */
-export default function (io: Server, socket: TSocket) {
-  socket.on('gm:sprite:create', async (data: undefined, callback: (response: boolean) => void) => {
+export default class SpriteCreateEvent {
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {}
+
+  public listen(): void {
+    this.socket.on('gm:sprite:create', this.handleSpriteCreate.bind(this))
+  }
+
+  private async handleSpriteCreate(data: undefined, callback: (response: boolean) => void): Promise<void> {
     try {
-      const character = await characterRepository.getById(socket.characterId as number)
+      const character = await characterRepository.getById(this.socket.characterId as number)
       if (!character) return callback(false)
 
       if (character.role !== 'gm') {
@@ -42,5 +46,5 @@ export default function (io: Server, socket: TSocket) {
       console.error('Error creating sprite:', error)
       callback(false)
     }
-  })
-}
+  }
+}

src/socketEvents/gameMaster/assetManager/sprite/list.ts

@@ -7,14 +7,18 @@ import characterRepository from '../../../../repositories/characterRepository'
 
 interface IPayload {}
 
-/**
- * Handle game master list sprite event
- * @param socket
- * @param io
- */
-export default function (io: Server, socket: TSocket) {
-  socket.on('gm:sprite:list', async (data: any, callback: (response: Sprite[]) => void) => {
-    const character = await characterRepository.getById(socket.characterId as number)
+export default class SpriteListEvent {
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {}
+
+  public listen(): void {
+    this.socket.on('gm:sprite:list', this.handleSpriteList.bind(this))
+  }
+
+  private async handleSpriteList(data: any, callback: (response: Sprite[]) => void): Promise<void> {
+    const character = await characterRepository.getById(this.socket.characterId as number)
     if (!character) return callback([])
 
     if (character.role !== 'gm') {
@@ -24,5 +28,5 @@ export default function (io: Server, socket: TSocket) {
     // get all sprites
     const sprites = await SpriteRepository.getAll()
     callback(sprites)
-  })
-}
+  }
+}

src/socketEvents/gameMaster/assetManager/sprite/update.ts

@@ -27,9 +27,18 @@ interface ProcessedSpriteAction extends SpriteActionInput {
   }>
 }
 
-export default function (io: Server, socket: TSocket) {
-  socket.on('gm:sprite:update', async (data: Payload, callback: (success: boolean) => void) => {
-    const character = CharacterManager.getCharacterFromSocket(socket)
+export default class SpriteUpdateEvent {
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {}
+
+  public listen(): void {
+    this.socket.on('gm:sprite:update', this.handleSpriteUpdate.bind(this))
+  }
+
+  private async handleSpriteUpdate(data: Payload, callback: (success: boolean) => void): Promise<void> {
+    const character = CharacterManager.getCharacterFromSocket(this.socket)
     if (character?.role !== 'gm') {
       return callback(false)
     }
@@ -46,101 +55,101 @@ export default function (io: Server, socket: TSocket) {
       console.error('Error updating sprite:', error)
       callback(false)
     }
-  })
-}
 
-function validateSpriteActions(spriteActions: Prisma.JsonValue): SpriteActionInput[] {
-  try {
-    const parsed = JSON.parse(JSON.stringify(spriteActions)) as SpriteActionInput[]
-    if (!Array.isArray(parsed)) {
-      throw new Error('spriteActions is not an array')
-    }
-    return parsed
-  } catch (error) {
-    console.error('Error parsing spriteActions:', error)
-    throw error
-  }
-}
-
-async function processSprites(spriteActions: SpriteActionInput[]): Promise<ProcessedSpriteAction[]> {
-  return Promise.all(
-    spriteActions.map(async (spriteAction) => {
-      const { action, sprites } = spriteAction
-
-      if (!Array.isArray(sprites) || sprites.length === 0) {
-        throw new Error(`Invalid sprites array for action: ${action}`)
+    function validateSpriteActions(spriteActions: Prisma.JsonValue): SpriteActionInput[] {
+      try {
+        const parsed = JSON.parse(JSON.stringify(spriteActions)) as SpriteActionInput[]
+        if (!Array.isArray(parsed)) {
+          throw new Error('spriteActions is not an array')
+        }
+        return parsed
+      } catch (error) {
+        console.error('Error parsing spriteActions:', error)
+        throw error
       }
+    }
 
-      const buffersWithDimensions = await Promise.all(
-        sprites.map(async (sprite: string) => {
-          const buffer = Buffer.from(sprite.split(',')[1], 'base64')
-          const { width, height } = await sharp(buffer).metadata()
-          return { buffer, width, height }
+    async function processSprites(spriteActions: SpriteActionInput[]): Promise<ProcessedSpriteAction[]> {
+      return Promise.all(
+        spriteActions.map(async (spriteAction) => {
+          const { action, sprites } = spriteAction
+    
+          if (!Array.isArray(sprites) || sprites.length === 0) {
+            throw new Error(`Invalid sprites array for action: ${action}`)
+          }
+    
+          const buffersWithDimensions = await Promise.all(
+            sprites.map(async (sprite: string) => {
+              const buffer = Buffer.from(sprite.split(',')[1], 'base64')
+              const { width, height } = await sharp(buffer).metadata()
+              return { buffer, width, height }
+            })
+          )
+    
+          const frameWidth = Math.max(...buffersWithDimensions.map((b) => b.width || 0))
+          const frameHeight = Math.max(...buffersWithDimensions.map((b) => b.height || 0))
+    
+          return {
+            ...spriteAction,
+            frameWidth,
+            frameHeight,
+            buffersWithDimensions
+          }
         })
       )
-
-      const frameWidth = Math.max(...buffersWithDimensions.map((b) => b.width || 0))
-      const frameHeight = Math.max(...buffersWithDimensions.map((b) => b.height || 0))
-
-      return {
-        ...spriteAction,
-        frameWidth,
-        frameHeight,
-        buffersWithDimensions
-      }
-    })
-  )
-}
-
-async function updateDatabase(id: string, name: string, processedActions: ProcessedSpriteAction[]) {
-  await prisma.sprite.update({
-    where: { id },
-    data: {
-      name,
-      spriteActions: {
-        deleteMany: { spriteId: id },
-        create: processedActions.map(({ action, sprites, originX, originY, isAnimated, isLooping, frameWidth, frameHeight, frameSpeed }) => ({
-          action,
-          sprites,
-          originX,
-          originY,
-          isAnimated,
-          isLooping,
-          frameWidth,
-          frameHeight,
-          frameSpeed
-        }))
-      }
     }
-  })
-}
 
-async function saveSpritesToDisk(id: string, processedActions: ProcessedSpriteAction[]) {
-  const publicFolder = path.join(process.cwd(), 'public', 'sprites', id)
-  await mkdir(publicFolder, { recursive: true })
-
-  await Promise.all(
-    processedActions.map(async ({ action, buffersWithDimensions, frameWidth, frameHeight }) => {
-      const combinedImage = await sharp({
-        create: {
-          width: frameWidth * buffersWithDimensions.length,
-          height: frameHeight,
-          channels: 4,
-          background: { r: 0, g: 0, b: 0, alpha: 0 }
+    async function updateDatabase(id: string, name: string, processedActions: ProcessedSpriteAction[]) {
+      await prisma.sprite.update({
+        where: { id },
+        data: {
+          name,
+          spriteActions: {
+            deleteMany: { spriteId: id },
+            create: processedActions.map(({ action, sprites, originX, originY, isAnimated, isLooping, frameWidth, frameHeight, frameSpeed }) => ({
+              action,
+              sprites,
+              originX,
+              originY,
+              isAnimated,
+              isLooping,
+              frameWidth,
+              frameHeight,
+              frameSpeed
+            }))
+          }
         }
       })
-        .composite(
-          buffersWithDimensions.map(({ buffer }, index) => ({
-            input: buffer,
-            left: index * frameWidth,
-            top: 0
-          }))
-        )
-        .png()
-        .toBuffer()
+    }
 
-      const filename = path.join(publicFolder, `${action}.png`)
-      await writeFile(filename, combinedImage)
-    })
-  )
-}
+    async function saveSpritesToDisk(id: string, processedActions: ProcessedSpriteAction[]) {
+      const publicFolder = path.join(process.cwd(), 'public', 'sprites', id)
+      await mkdir(publicFolder, { recursive: true })
+    
+      await Promise.all(
+        processedActions.map(async ({ action, buffersWithDimensions, frameWidth, frameHeight }) => {
+          const combinedImage = await sharp({
+            create: {
+              width: frameWidth * buffersWithDimensions.length,
+              height: frameHeight,
+              channels: 4,
+              background: { r: 0, g: 0, b: 0, alpha: 0 }
+            }
+          })
+            .composite(
+              buffersWithDimensions.map(({ buffer }, index) => ({
+                input: buffer,
+                left: index * frameWidth,
+                top: 0
+              }))
+            )
+            .png()
+            .toBuffer()
+    
+          const filename = path.join(publicFolder, `${action}.png`)
+          await writeFile(filename, combinedImage)
+        })
+      )
+    }
+  }
+}