@golstats/gsc-lineups-reports 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@golstats/gsc-lineups-reports",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "main": "dist/gsc-lineups-reports.umd.js",
   "module": "dist/gsc-lineups-reports.es.js",
   "exports": {

package/src/components/gsc-lineups-reports.vue

@@ -1,6 +1,5 @@
 <template>
   <div>
-    <!-- Aquí va tu contenido -->
     <GSCLineups
       :game="game"
       :gamehome="lastHomeGame"

package/src/components/gsc-lineups.vue

@@ -51,16 +51,6 @@
           <!-- CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA -->
           <!-- CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA - CANCHA -->
           <div :class="canchacontainerClass">
-            <div
-              :class="[notificationnolineupsClass]"
-              v-if="
-                (gameForAnalysis.game_status == 4 || gameForAnalysis.game_status == 1) &&
-                gameForAnalysis.is_live == 0 &&
-                numPlayer == 0
-              "
-            >
-              Las alineaciones estarán disponibles unos minutos antes de que inicie el partido.
-            </div>
             <template v-for="(data, key) in playersHome" :key="key + 'jersey_home'">
               <template v-if="data.played">
                 <div
@@ -440,6 +430,8 @@ export default {
       pendingRequests: new Set(),
       // Debounce timer para evitar peticiones excesivas
       debounceTimer: null,
+      // Timer para evitar múltiples cargas de probables
+      probablesDebounceTimer: null,
       matchdaysPerTeam: [],
       lastGetGame: 0,
       lastSection: '',
@@ -811,6 +803,18 @@ export default {
     numPlayer() {
       return Number(this.playersAway.length) + Number(this.playersHome.length)
     },
+    shouldShowNoLineupsMessage() {
+      const condition =
+        (this.gameForAnalysis.game_status == 4 || this.gameForAnalysis.game_status == 1) &&
+        this.gameForAnalysis.is_live == 0 &&
+        this.numPlayer == 0
+
+      console.log(
+        `🔍 Condición mensaje: status=${this.gameForAnalysis.game_status}, is_live=${this.gameForAnalysis.is_live}, numPlayer=${this.numPlayer} -> ${condition}`,
+      )
+
+      return condition
+    },
     benchFillHome() {
       if (this.playersHome.length < this.playersAway.length) {
         return this.playersAway.length - this.playersHome.length
@@ -838,6 +842,15 @@ export default {
       }
     }
   },
+  beforeUnmount() {
+    // Limpiar timers para evitar memory leaks
+    if (this.probablesDebounceTimer) {
+      clearTimeout(this.probablesDebounceTimer)
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer)
+    }
+  },
   watch: {
     /*'homeTeam.acronym': {
     handler(newValue) {
@@ -859,7 +872,12 @@ export default {
         if (newValue != oldValue) {
           if (this.selectedOption !== 'Postmatch') {
             if (newValue === 'Probables') {
-              setTimeout(() => {
+              // Limpiar timer anterior para evitar ejecuciones múltiples
+              if (this.probablesDebounceTimer) {
+                clearTimeout(this.probablesDebounceTimer)
+              }
+
+              this.probablesDebounceTimer = setTimeout(async () => {
                 // Validar que los game_id sean válidos antes de proceder
                 if (
                   this.gamehome &&
@@ -869,20 +887,80 @@ export default {
                   this.gameaway.game_id &&
                   this.gameaway.game_id !== 0
                 ) {
-                  console.log(
-                    '✅ Cargando alineaciones probables - Home:',
+                  // Verificar si ya se cargaron las alineaciones para estos game_ids
+                  const alreadyLoaded = this.areProbablesAlreadyLoaded(
+                    this.gamehome.game_id,
+                    this.gameaway.game_id,
+                  )
+
+                  // Verificar si ya hay peticiones en curso
+                  const requestsPending = this.areProbablesRequestsPending(
                     this.gamehome.game_id,
-                    'Away:',
                     this.gameaway.game_id,
                   )
 
-                  this.auxProbablesIDGameHome = this.gamehome.game_id
-                  this.auxProbablesIDGameAway = this.gameaway.game_id
+                  if (requestsPending) {
+                    console.log('⏳ Peticiones de alineaciones probables ya en curso, saltando...')
+                    return
+                  }
 
-                  this.cleaneDataAway()
-                  this.cleaneDataHome()
-                  this.getLineUpProbablesHome3D(this.gamehome.game_id)
-                  this.getLineUpProbablesAway3D(this.gameaway.game_id)
+                  if (!alreadyLoaded) {
+                    console.log(
+                      '✅ Cargando alineaciones probables - Home:',
+                      this.gamehome.game_id,
+                      'Away:',
+                      this.gameaway.game_id,
+                    )
+
+                    this.auxProbablesIDGameHome = this.gamehome.game_id
+                    this.auxProbablesIDGameAway = this.gameaway.game_id
+
+                    console.log('🧹 Limpiando datos antes de cargar nuevas alineaciones...')
+                    this.cleaneDataAway()
+                    this.cleaneDataHome()
+                    console.log(
+                      '📊 Estado después de limpiar - Home:',
+                      this.playersHome.length,
+                      'Away:',
+                      this.playersAway.length,
+                    )
+
+                    // Obtener información del header antes de cargar las alineaciones
+                    console.log('📋 Obteniendo información del header para probables...')
+                    try {
+                      // Verificar que la prop game esté disponible
+                      if (!this.game || !this.game.game_id) {
+                        console.warn('❌ Prop game no disponible para obtener header info')
+                        return
+                      }
+
+                      // Usar la prop game para obtener el header info del partido principal
+                      await this.getHeaderInfo(this.game)
+                      console.log(
+                        '✅ Header info obtenido para el partido principal:',
+                        this.game.game_id,
+                      )
+                    } catch (error) {
+                      console.error('❌ Error obteniendo header info:', error)
+                    }
+
+                    this.getLineUpProbablesHome3D(this.gamehome.game_id)
+                    this.getLineUpProbablesAway3D(this.gameaway.game_id)
+
+                    // Log del estado actual después de iniciar las peticiones
+                    setTimeout(() => {
+                      console.log(
+                        `📊 Estado después de iniciar peticiones - Home: ${this.playersHome.length}, Away: ${this.playersAway.length}, numPlayer: ${this.numPlayer}`,
+                      )
+                    }, 100)
+                  } else {
+                    console.log(
+                      '⏭️ Alineaciones probables ya cargadas para estos game_ids - Home:',
+                      this.gamehome.game_id,
+                      'Away:',
+                      this.gameaway.game_id,
+                    )
+                  }
                 } else {
                   console.warn(
                     '❌ No se pueden cargar alineaciones probables - game_id inválidos:',
@@ -911,6 +989,25 @@ export default {
         }
       },
     },
+    numPlayer: {
+      handler(newValue, oldValue) {
+        if (newValue !== oldValue) {
+          console.log(
+            `👥 numPlayer cambió de ${oldValue} a ${newValue} (Home: ${this.playersHome.length}, Away: ${this.playersAway.length})`,
+          )
+        }
+      },
+    },
+    'gameForAnalysis.game_status': {
+      handler(newValue) {
+        console.log(`🎮 game_status cambió a: ${newValue}`)
+      },
+    },
+    'gameForAnalysis.is_live': {
+      handler(newValue) {
+        console.log(`📡 is_live cambió a: ${newValue}`)
+      },
+    },
     'socket.connected': {
       immediate: true,
       handler(newValue) {
@@ -1864,6 +1961,16 @@ export default {
       this.pendingRequests.delete(requestKey)
       console.log(`🔓 Removiendo petición pendiente: ${requestKey}`)
     },
+    // Función para verificar si las alineaciones probables ya están cargadas
+    areProbablesAlreadyLoaded(homeGameId, awayGameId) {
+      return (
+        this.auxProbablesIDGameHome === homeGameId && this.auxProbablesIDGameAway === awayGameId
+      )
+    },
+    // Función para verificar si hay peticiones pendientes para probables
+    areProbablesRequestsPending(homeGameId, awayGameId) {
+      return this.isRequestPending(homeGameId, 'home') || this.isRequestPending(awayGameId, 'away')
+    },
     // Función para calcular el ajuste de perspectiva basado en la posición X
     calculatePerspectiveAdjustment(positionX) {
       // Fórmula progresiva: cuanto menor sea positionX, mayor será el ajuste
@@ -1896,6 +2003,7 @@ export default {
       this.$emit('onOpenProfile', data)
     },
     async getLineUpProbablesHome3D(game) {
+      console.log('🏠 Iniciando petición de alineaciones probables HOME para game_id:', game)
       if (game == null || game === 0) {
         console.warn(
           '❌ getLineUpProbablesHome3D: Se intentó hacer petición con game_id inválido:',
@@ -1904,6 +2012,20 @@ export default {
         return
       }
 
+      // Verificar si gameInfoheader está disponible
+      if (!this.gameInfoheader) {
+        console.warn('❌ getLineUpProbablesHome3D: gameInfoheader no está disponible')
+        return
+      }
+
+      // Verificar que gameInfoheader corresponde al partido correcto
+      if (this.game && this.gameInfoheader.id !== this.game.game_id) {
+        console.warn(
+          `❌ getLineUpProbablesHome3D: gameInfoheader (${this.gameInfoheader.id}) no corresponde al partido actual (${this.game.game_id})`,
+        )
+        return
+      }
+
       // Verificar si ya hay una petición en curso para este game_id
       if (this.isRequestPending(game, 'home')) {
         console.warn(
@@ -1992,6 +2114,9 @@ export default {
               (player) =>
                 player.player_id == data.data.home_team.starting_lineup[0].lineup[index].player_id,
             )
+            console.log(
+              `🏠 Agregando jugador HOME: ${data.data.home_team.starting_lineup[0].lineup[index].player_name}`,
+            )
             this.playersHome.push({
               played: true,
               name: data.data.home_team.starting_lineup[0].lineup[index].player_name,
@@ -2399,6 +2524,7 @@ export default {
         console.log(
           `✅ getLineUpProbablesHome3D: Petición completada exitosamente para game_id: ${game}`,
         )
+        console.log(`📊 Jugadores HOME cargados: ${this.playersHome.length}`)
       } catch (e) {
         // Remover la petición del estado pendiente en caso de error
         this.removeRequestPending(game, 'home')
@@ -2486,6 +2612,7 @@ export default {
       this.movil = false
     },
     async getLineUpProbablesAway3D(game) {
+      console.log('✈️ Iniciando petición de alineaciones probables AWAY para game_id:', game)
       if (game == null || game === 0) {
         console.warn(
           '❌ getLineUpProbablesAway3D: Se intentó hacer petición con game_id inválido:',
@@ -2494,6 +2621,20 @@ export default {
         return
       }
 
+      // Verificar si gameInfoheader está disponible
+      if (!this.gameInfoheader) {
+        console.warn('❌ getLineUpProbablesAway3D: gameInfoheader no está disponible')
+        return
+      }
+
+      // Verificar que gameInfoheader corresponde al partido correcto
+      if (this.game && this.gameInfoheader.id !== this.game.game_id) {
+        console.warn(
+          `❌ getLineUpProbablesAway3D: gameInfoheader (${this.gameInfoheader.id}) no corresponde al partido actual (${this.game.game_id})`,
+        )
+        return
+      }
+
       // Verificar si ya hay una petición en curso para este game_id
       if (this.isRequestPending(game, 'away')) {
         console.warn(
@@ -2586,6 +2727,9 @@ export default {
               (player) =>
                 player.player_id == data.data.home_team.starting_lineup[0].lineup[index].player_id,
             )
+            console.log(
+              `✈️ Agregando jugador AWAY: ${data.data.home_team.starting_lineup[0].lineup[index].player_name}`,
+            )
             this.playersAway.push({
               played: true,
               name: data.data.home_team.starting_lineup[0].lineup[index].player_name,
@@ -2985,6 +3129,7 @@ export default {
         console.log(
           `✅ getLineUpProbablesAway3D: Petición completada exitosamente para game_id: ${game}`,
         )
+        console.log(`📊 Jugadores AWAY cargados: ${this.playersAway.length}`)
       } catch (e) {
         // Remover la petición del estado pendiente en caso de error
         this.removeRequestPending(game, 'away')
@@ -2998,8 +3143,8 @@ export default {
           console.log('✅ getLineupProbablesHome: Cargando alineaciones para game_id:', val.id)
           this.auxProbablesIDGameHome = val.id
           //this.homeTeam.acronym = this.awayTeamAbrev
-          this.cleaneDataHome()
-          this.getLineUpProbablesHome3D(val.id)
+          //this.cleaneDataHome()
+          //this.getLineUpProbablesHome3D(val.id)
         }
       } else {
         console.warn('❌ getLineupProbablesHome: game_id inválido:', val?.id)
@@ -3011,8 +3156,8 @@ export default {
           console.log('✅ getLineupProbablesAway: Cargando alineaciones para game_id:', val.id)
           this.auxProbablesIDGameAway = val.id
           //this.visitingTeam.acronym = this.awayTeamAbrev
-          this.cleaneDataAway()
-          this.getLineUpProbablesAway3D(val.id)
+          //this.cleaneDataAway()
+          //this.getLineUpProbablesAway3D(val.id)
         }
       } else {
         console.warn('❌ getLineupProbablesAway: game_id inválido:', val?.id)
@@ -3083,7 +3228,17 @@ export default {
             game.game_id +
             '/lineups',
         ))
+      console.log(
+        'GAME INFO HEADER --------------------------------------------------------> ',
+        game.game_id,
+      )
       this.gameInfoheader = data.data.game
+      console.log(
+        '📋 gameInfoheader establecido para game_id:',
+        this.gameInfoheader.id,
+        'del partido:',
+        game.game_id,
+      )
       if (this.selectedOption != 'Postmatch') {
         for (let index = 0; index < data.data.games_historic.length; index++) {
           this.gamesHistoric.push({
@@ -3500,7 +3655,10 @@ export default {
         console.warn('❌ getLineUp: Se intentó hacer petición con game_id inválido:', game)
         return
       }
-
+      console.log(
+        '------------------------------------------------> SE HIZO LA PETICION ----> DEL PARTIDO ID: ',
+        game,
+      )
       // Verificar si ya hay una petición en curso para este game_id
       if (this.isRequestPending(game, 'general')) {
         console.warn(`🔒 getLineUp: Ya hay una petición en curso para game_id: ${game}`)