mdas-jsview-sdk 1.0.17-uat.0 → 1.0.21-uat.0

package/dist/mdas-sdk.js

@@ -1283,6 +1283,24 @@
                 <span class="l2-market-name"></span>
             </div>
             <span class="symbol editable-symbol">--</span>
+            <div class="level1-info">
+                <div class="l1-item">
+                    <span class="l1-label">Last:</span>
+                    <span class="l1-value l1-last-px">--</span>
+                </div>
+                <div class="l1-item">
+                    <span class="l1-label">Low:</span>
+                    <span class="l1-value l1-low-px">--</span>
+                </div>
+                <div class="l1-item">
+                    <span class="l1-label">High:</span>
+                    <span class="l1-value l1-high-px">--</span>
+                </div>
+                <div class="l1-item">
+                    <span class="l1-label">Volume:</span>
+                    <span class="l1-value l1-volume">--</span>
+                </div>
+            </div>
         </div>
     </div>
 
@@ -1957,6 +1975,38 @@
     color: #111827;
 }
 
+/* ========================================
+   LEVEL 1 INFO (INSIDE HEADER)
+   ======================================== */
+
+.onbbo-level2-widget .level1-info {
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 12px;
+    margin-top: 10px;
+}
+
+.onbbo-level2-widget .l1-item {
+    display: flex;
+    flex-direction: column;
+    gap: 3px;
+}
+
+.onbbo-level2-widget .l1-label {
+    font-size: 11px;
+    font-weight: 600;
+    color: #6b7280;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.onbbo-level2-widget .l1-value {
+    font-size: 15px;
+    font-weight: 700;
+    color: #111827;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+}
+
 /* ========================================
    ORDER BOOK CONTAINER
    ======================================== */
@@ -2341,6 +2391,11 @@
     .onbbo-level2-widget .orderbook-panel:last-child {
         border-bottom: none;
     }
+
+    .onbbo-level2-widget .level1-info {
+        grid-template-columns: repeat(2, 1fr);
+        gap: 6px;
+    }
 }
 
 @media (max-width: 480px) {
@@ -2359,6 +2414,19 @@
         text-align: left;
     }
 
+    .onbbo-level2-widget .level1-info {
+        grid-template-columns: repeat(2, 1fr);
+        gap: 4px;
+    }
+
+    .onbbo-level2-widget .l1-label {
+        font-size: 9px;
+    }
+
+    .onbbo-level2-widget .l1-value {
+        font-size: 11px;
+    }
+
     .onbbo-level2-widget .panel-header {
         font-size: 10px;
         padding: 6px 2px;
@@ -4507,13 +4575,14 @@
       } */
 
       handleData(message) {
+        console.log('DEBUG', message);
         if (this.loadingTimeout) {
           clearTimeout(this.loadingTimeout);
           this.loadingTimeout = null;
         }
 
         // Handle error messages from server (plain text converted to structured format)
-        if (message.type === 'error' && message.noData) {
+        if (message.type === 'error') {
           if (this.debug) {
             console.log('[MarketDataWidget] Received no data message:', message.message);
           }
@@ -5283,13 +5352,16 @@
         // to avoid duplicate timeouts
       }
       handleData(message) {
+        console.log('DEBUG NIGHT', message);
+        //message = message.data || message.Data
+
         if (this.loadingTimeout) {
           clearTimeout(this.loadingTimeout);
           this.loadingTimeout = null;
         }
 
         // Handle error messages from server (plain text converted to structured format)
-        if (message.type === 'error' && message.noData) {
+        if (message.type === 'error' || message.error == true) {
           if (this.debug) {
             console.log('[NightSessionWidget] Received no data message:', message.message);
           }
@@ -5345,9 +5417,10 @@
         }
 
         // Filter for night session data
-        if (Array.isArray(message)) {
+
+        if (Array.isArray(message.data)) {
           // First, try to find data matching our symbol regardless of MarketName
-          const symbolData = message.find(item => item.Symbol === this.symbol);
+          const symbolData = message.data.find(item => item.Symbol === this.symbol);
           if (symbolData) {
             if (this.debug) {
               console.log('[NightSessionWidget] Found data for symbol:', symbolData);
@@ -5387,34 +5460,35 @@
           }
         }
         // Handle wrapped format
-        else if (message.type === 'queryblueoceanl1' || message.type === 'querybrucel1' || message.type === 'queryonbbol1') {
-          if (message['0']?.Symbol === this.symbol) {
-            // For onbbo source, skip MarketName check
-            const isOnbbo = message.type === 'queryonbbol1';
-            const shouldShowNoData = message['0'].NotFound === true || !isOnbbo && (!message['0'].MarketName || message['0'].MarketName !== 'BLUE');
-            if (shouldShowNoData) {
-              // Only show no data state if we don't have cached data
-              if (!this.data) {
-                this.showNoDataState(message['0']);
-              } else {
-                this.hideLoading();
-                if (this.debug) {
-                  console.log('[NightSessionWidget] No new data, keeping cached data visible');
+        /* else if (message.type === 'queryblueoceanl1' || message.type === 'querybrucel1' || message.type === 'queryonbbol1') {
+            if (message.data['0']?.Symbol === this.symbol) {
+                // For onbbo source, skip MarketName check
+                const isOnbbo = message.type === 'queryonbbol1';
+                const shouldShowNoData = message['0'].NotFound === true ||
+                    (!isOnbbo && (!message['0'].MarketName || message['0'].MarketName !== 'BLUE'));
+                 if (shouldShowNoData) {
+                    // Only show no data state if we don't have cached data
+                    if (!this.data) {
+                        this.showNoDataState(message['0']);
+                    } else {
+                        this.hideLoading();
+                        if (this.debug) {
+                            console.log('[NightSessionWidget] No new data, keeping cached data visible');
+                        }
+                    }
+                } else {
+                    const model = new NightSessionModel(message['0']);
+                    this.data = model; // Store for caching
+                    this.updateWidget(model);
                 }
-              }
             } else {
-              const model = new NightSessionModel(message['0']);
-              this.data = model; // Store for caching
-              this.updateWidget(model);
-            }
-          } else {
-            // No matching symbol - keep cached data if available
-            if (this.debug) {
-              console.log('[NightSessionWidget] No matching symbol in response, keeping cached data');
+                // No matching symbol - keep cached data if available
+                if (this.debug) {
+                    console.log('[NightSessionWidget] No matching symbol in response, keeping cached data');
+                }
+                this.hideLoading();
             }
-            this.hideLoading();
-          }
-        }
+        } */
         if (message._cached) ;
       }
       updateWidget(data) {
@@ -39091,7 +39165,7 @@ ${SharedStyles}
         let priceData = null;
 
         // Handle array format (standard night session format)
-        if (Array.isArray(message)) {
+        if (Array.isArray(message.data)) {
           console.log('[IntradayChartWidget] Processing array format, length:', message.length);
           const symbolData = message.find(item => item.Symbol === this.symbol);
           console.log('[IntradayChartWidget] Found symbol data:', symbolData);
@@ -40062,8 +40136,10 @@ ${SharedStyles}
         this.styled = options.styled !== undefined ? options.styled : true;
         this.maxLevels = options.maxLevels || 10; // Number of levels to display
         this.data = null;
+        this.level1Data = null; // Store Level 1 data separately
         this.isDestroyed = false;
-        this.unsubscribe = null;
+        this.unsubscribeL2 = null;
+        this.unsubscribeL1 = null;
         this.symbolEditor = null;
         this.loadingTimeout = null;
 
@@ -40164,13 +40240,22 @@ ${SharedStyles}
             this.showError(`No data received for ${upperSymbol}. Please try again.`);
           }, 10000);
 
-          // Unsubscribe from old symbol
-          if (this.unsubscribe) {
+          // Unsubscribe from old symbol's L2 and L1 data
+          if (this.unsubscribeL2) {
             if (this.debug) {
-              console.log(`[ONBBOLevel2Widget] Unsubscribing from ${this.symbol}`);
+              console.log(`[ONBBOLevel2Widget] Unsubscribing from ${this.symbol} L2`);
             }
-            this.unsubscribe();
-            this.unsubscribe = null;
+            this.wsManager.sendUnsubscribe('queryonbbol2', this.symbol);
+            this.unsubscribeL2();
+            this.unsubscribeL2 = null;
+          }
+          if (this.unsubscribeL1) {
+            if (this.debug) {
+              console.log(`[ONBBOLevel2Widget] Unsubscribing from ${this.symbol} L1`);
+            }
+            this.wsManager.sendUnsubscribe('queryonbbol1', this.symbol);
+            this.unsubscribeL1();
+            this.unsubscribeL1 = null;
           }
 
           // Update internal symbol
@@ -40240,10 +40325,51 @@ ${SharedStyles}
         }
       }
       subscribeToData() {
-        // Subscribe to ONBBO Level 2 data
-        this.unsubscribe = this.wsManager.subscribe(this.widgetId, ['queryonbbol2'],
-        // ONBBO Level 2 subscription type
-        this.handleMessage.bind(this), this.symbol);
+        // Subscribe to ONBBO Level 2 data (order book)
+        // Use separate widget IDs to avoid "already active" duplicate detection
+        this.unsubscribeL2 = this.wsManager.subscribe(`${this.widgetId}-l2`, ['queryonbbol2'], messageWrapper => {
+          const {
+            event,
+            data
+          } = messageWrapper;
+
+          // Handle connection events
+          if (event === 'connection') {
+            this.handleConnectionStatus(data);
+            return;
+          }
+
+          // For data events, add type context
+          if (event === 'data') {
+            data._dataType = 'level2';
+            this.handleMessage({
+              event,
+              data
+            });
+          }
+        }, this.symbol);
+
+        // Subscribe to ONBBO Level 1 data (statistics: LastPx, LowPx, HighPx, Volume)
+        this.unsubscribeL1 = this.wsManager.subscribe(`${this.widgetId}-l1`, ['queryonbbol1'], messageWrapper => {
+          const {
+            event,
+            data
+          } = messageWrapper;
+
+          // Connection already handled by L2 subscription
+          if (event === 'connection') {
+            return;
+          }
+
+          // For data events, add type context
+          if (event === 'data') {
+            data._dataType = 'level1';
+            this.handleMessage({
+              event,
+              data
+            });
+          }
+        }, this.symbol);
       }
       handleData(message) {
         if (this.loadingTimeout) {
@@ -40251,8 +40377,14 @@ ${SharedStyles}
           this.loadingTimeout = null;
         }
 
+        // Extract data type from metadata (added by subscription callback)
+        const dataType = message._dataType;
+        if (this.debug) {
+          console.log(`[ONBBOLevel2Widget] handleData called with type: ${dataType}`, message);
+        }
+
         // Handle error messages
-        if (message.type === 'error') {
+        if (message.type === 'error' || message.error == true) {
           const errorMsg = message.message || 'Server error';
           if (this.debug) {
             console.log('[ONBBOLevel2Widget] Error:', errorMsg);
@@ -40261,16 +40393,54 @@ ${SharedStyles}
           return;
         }
 
+        // Handle Level 1 data (statistics: LastPx, LowPx, HighPx, Volume)
+        if (message.type === 'queryonbbol1') {
+          if (this.debug) {
+            console.log('[ONBBOLevel2Widget] Processing Level 1 data:', message);
+          }
+
+          // Handle array format (new format with Data wrapper)
+          if (message.data && Array.isArray(message.data)) {
+            const l1Data = message.data.find(d => d.Symbol === this.symbol);
+            if (l1Data) {
+              this.level1Data = {
+                lastPx: l1Data.LastPx || 0,
+                lowPx: l1Data.LowPx || 0,
+                highPx: l1Data.HighPx || 0,
+                volume: l1Data.Volume || 0
+              };
+              this.updateLevel1Display();
+            }
+          }
+          // Handle direct array format (standard format)
+          else if (Array.isArray(message)) {
+            const l1Data = message.find(d => d.Symbol === this.symbol);
+            if (l1Data) {
+              this.level1Data = {
+                lastPx: l1Data.LastPx || 0,
+                lowPx: l1Data.LowPx || 0,
+                highPx: l1Data.HighPx || 0,
+                volume: l1Data.Volume || 0
+              };
+              this.updateLevel1Display();
+            }
+          }
+
+          // Clean up metadata
+          delete message._dataType;
+          return;
+        }
+
         // Handle Level 2 data - Array of MMID quotes
-        if (Array.isArray(message)) {
+        if (Array.isArray(message.data)) {
           // Check if it's an array of MMID objects (ONBBO format)
-          if (message.length > 0 && message[0].MMID) {
+          if (message.data.length > 0 && message.data[0].MMID) {
             if (this.debug) {
               console.log('[ONBBOLevel2Widget] Received MMID array:', message);
             }
 
             // Create model from MMID array
-            const model = new ONBBOLevel2Model(message);
+            const model = new ONBBOLevel2Model(message.data);
             model.symbol = this.symbol; // Set symbol from widget
             this.data = model;
             this.updateWidget(model);
@@ -40278,7 +40448,7 @@ ${SharedStyles}
           }
 
           // Try to find symbol in array (alternative format)
-          const symbolData = message.find(item => item.Symbol === this.symbol);
+          const symbolData = message.data.find(item => item.Symbol === this.symbol);
           if (symbolData) {
             if (symbolData.NotFound === true) {
               this.showError(`No Level 2 data available for ${this.symbol}`);
@@ -40292,32 +40462,31 @@ ${SharedStyles}
           this.showError(`No Level 2 data available for ${this.symbol}`);
         }
         // Handle wrapped format
-        else if (message.type === 'queryonbbol2') {
-          // Check if wrapped data contains MMID array
-          if (message['0'] && Array.isArray(message['0'])) {
-            if (this.debug) {
-              console.log('[ONBBOLevel2Widget] Received wrapped MMID array:', message['0']);
+        /* else if (message.type === 'queryonbbol2') {
+            // Check if wrapped data contains MMID array
+            if (message['0'] && Array.isArray(message['0'])) {
+                if (this.debug) {
+                    console.log('[ONBBOLevel2Widget] Received wrapped MMID array:', message['0']);
+                }
+                 const model = new ONBBOLevel2Model(message['0']);
+                model.symbol = this.symbol;
+                this.data = model;
+                this.updateWidget(model);
+                return;
             }
-            const model = new ONBBOLevel2Model(message['0']);
-            model.symbol = this.symbol;
-            this.data = model;
-            this.updateWidget(model);
-            return;
-          }
-
-          // Check for symbol match in wrapped format
-          if (message['0']?.Symbol === this.symbol) {
-            if (message['0'].NotFound === true) {
-              this.showError(`No Level 2 data available for ${this.symbol}`);
+             // Check for symbol match in wrapped format
+            if (message['0']?.Symbol === this.symbol) {
+                if (message['0'].NotFound === true) {
+                    this.showError(`No Level 2 data available for ${this.symbol}`);
+                } else {
+                    const model = new ONBBOLevel2Model(message['0']);
+                    this.data = model;
+                    this.updateWidget(model);
+                }
             } else {
-              const model = new ONBBOLevel2Model(message['0']);
-              this.data = model;
-              this.updateWidget(model);
+                this.showError(`No Level 2 data available for ${this.symbol}`);
             }
-          } else {
-            this.showError(`No Level 2 data available for ${this.symbol}`);
-          }
-        }
+        } */
       }
       updateWidget(data) {
         if (this.isDestroyed) return;
@@ -40415,6 +40584,43 @@ ${SharedStyles}
           askBody.appendChild(row);
         });
       }
+      updateLevel1Display() {
+        if (!this.level1Data) return;
+        const formatPrice = price => {
+          return price ? price.toFixed(2) : '--';
+        };
+        const formatVolume = volume => {
+          if (!volume) return '--';
+          return volume.toLocaleString();
+        };
+
+        // Update Last Price
+        const lastPxElement = this.container.querySelector('.l1-last-px');
+        if (lastPxElement) {
+          lastPxElement.textContent = formatPrice(this.level1Data.lastPx);
+        }
+
+        // Update Low Price
+        const lowPxElement = this.container.querySelector('.l1-low-px');
+        if (lowPxElement) {
+          lowPxElement.textContent = formatPrice(this.level1Data.lowPx);
+        }
+
+        // Update High Price
+        const highPxElement = this.container.querySelector('.l1-high-px');
+        if (highPxElement) {
+          highPxElement.textContent = formatPrice(this.level1Data.highPx);
+        }
+
+        // Update Volume
+        const volumeElement = this.container.querySelector('.l1-volume');
+        if (volumeElement) {
+          volumeElement.textContent = formatVolume(this.level1Data.volume);
+        }
+        if (this.debug) {
+          console.log('[ONBBOLevel2Widget] Updated Level 1 display:', this.level1Data);
+        }
+      }
       showLoading() {
         const loadingOverlay = this.container.querySelector('.widget-loading-overlay');
         if (loadingOverlay) {
@@ -40461,9 +40667,17 @@ ${SharedStyles}
           this.clearTimeout(this.loadingTimeout);
           this.loadingTimeout = null;
         }
-        if (this.unsubscribe) {
-          this.unsubscribe();
-          this.unsubscribe = null;
+
+        // Unsubscribe from L2 data
+        if (this.unsubscribeL2) {
+          this.unsubscribeL2();
+          this.unsubscribeL2 = null;
+        }
+
+        // Unsubscribe from L1 data
+        if (this.unsubscribeL1) {
+          this.unsubscribeL1();
+          this.unsubscribeL1 = null;
         }
 
         // Destroy the symbol editor
@@ -41589,6 +41803,7 @@ ${SharedStyles}
         }
       }
       handleMessage(event) {
+        //console.log('EVENT', event)
         try {
           // Update activity tracking - connection is alive!
           this.lastMessageReceived = Date.now();
@@ -41613,22 +41828,20 @@ ${SharedStyles}
               return;
             }
 
-            // Determine target type based on error content
-            const targetType = this._getTargetTypeFromErrorMessage(textMessage);
+            // Determine type based on error content, default to 'error'
+            const errorType = this._getTargetTypeFromErrorMessage(textMessage) || 'error';
             if (textMessage.toLowerCase().includes('no night session') || textMessage.toLowerCase().includes('no data')) {
               message = {
-                type: 'error',
+                type: errorType,
                 message: textMessage,
-                error: textMessage,
-                noData: true,
-                targetType: targetType // Will be 'querynightsession' for night session errors
+                error: true,
+                noData: true
               };
             } else {
               message = {
-                type: 'error',
+                type: errorType,
                 message: textMessage,
-                error: textMessage,
-                targetType: targetType // Could be null for general errors
+                error: true
               };
             }
           }
@@ -41636,9 +41849,16 @@ ${SharedStyles}
             console.log('[WebSocketManager] Processed message:', message);
           }
 
-          // Handle new message format with type and data fields (case-insensitive)
-          const normalizedMessage = this._normalizeMessage(message);
-          this._routeMessage(normalizedMessage);
+          // Extract data field for night session messages to avoid nested structure
+          // Night session format: { type: 'queryonbbol1', error: false, data: [...] }
+          // We want to send just the data array to widgets
+          let dataToRoute = message;
+          /* if (message.data !== undefined && message.type !== undefined) {
+              // This is night session format - extract the data
+              dataToRoute = message.data;
+          } */
+
+          this._routeMessage(dataToRoute);
         } catch (error) {
           console.error('[WebSocketManager] Error handling message:', error);
           this._notifyWidgets('error', {
@@ -41777,7 +41997,31 @@ ${SharedStyles}
                 }
               } else {
                 if (this.config.debug) {
-                  console.log(`[WebSocketManager] Subscription ${subscriptionKey} already active, skipping`);
+                  console.log(`[WebSocketManager] Subscription ${subscriptionKey} already active, skipping server subscription`);
+                }
+
+                // Subscription already active, but send cached data to newly subscribing widgets
+                const cachedMessage = this.lastMessageCache.get(subscriptionKey);
+                console.log('LAST', this.lastMessageCache);
+                if (cachedMessage) {
+                  if (this.config.debug) {
+                    console.log(`[WebSocketManager] Sending cached data to newly subscribing widgets for ${subscriptionKey}`);
+                  }
+
+                  // Find all widgets subscribed to this type:symbol combination
+                  this.subscriptions.forEach((subscription, widgetId) => {
+                    if (subscription.types.has(type) && subscription.symbol === symbol) {
+                      try {
+                        subscription.callback({
+                          event: 'data',
+                          data: cachedMessage,
+                          widgetId
+                        });
+                      } catch (error) {
+                        console.error(`[WebSocketManager] Error sending cached data to widget ${widgetId}:`, error);
+                      }
+                    }
+                  });
                 }
               }
             });
@@ -41829,11 +42073,6 @@ ${SharedStyles}
        * The data field structure varies based on the type
        */
       _normalizeMessage(message) {
-        // If message already has targetType (error messages), return as is
-        if (message.targetType) {
-          return message;
-        }
-
         // Check for error field (case-insensitive)
         const errorField = message.error || message.Error;
         const typeField = message.type || message.Type;
@@ -41844,13 +42083,12 @@ ${SharedStyles}
           if (this.config.debug) {
             console.log(`[WebSocketManager] Detected error message with type: ${typeField}`);
           }
-
-          // Set targetType for routing to specific widget types
           return {
             ...message,
-            targetType: typeField,
-            type: typeField,
-            isError: true
+            // Only add type if message doesn't already have one
+            ...(!message.type && !message.Type && typeField ? {
+              type: typeField
+            } : {})
           };
         }
 
@@ -41868,10 +42106,11 @@ ${SharedStyles}
             // Treat as error and route based on type
             return {
               ...message,
-              targetType: typeField,
-              type: typeField,
-              isError: true,
-              error: true // Mark as error even if it was false
+              // Only add type if message doesn't already have one
+              ...(!message.type && !message.Type && typeField ? {
+                type: typeField
+              } : {}),
+              error: true // Mark as error since it was detected as implicit error
             };
           }
         }
@@ -41905,8 +42144,8 @@ ${SharedStyles}
             };
           }
 
-          // Also preserve the original type at the root level for backward compatibility
-          if (typeof normalizedData === 'object' && !normalizedData.type) {
+          // Only add type field if the normalized data doesn't already have one
+          if (typeof normalizedData === 'object' && !normalizedData.type && !normalizedData.Type) {
             normalizedData.type = typeField;
           }
           return normalizedData;
@@ -41928,32 +42167,7 @@ ${SharedStyles}
         // Cache the message for later use by new subscribers
         this._cacheMessage(message);
 
-        // Check if message has a specific target type (like night session errors)
-        if (message.targetType) {
-          const targetWidgets = this.typeSubscriptions.get(message.targetType);
-          if (targetWidgets && targetWidgets.size > 0) {
-            if (this.config.debug) {
-              console.log(`[WebSocketManager] Routing ${message.targetType} error to specific widgets:`, [...targetWidgets]);
-            }
-            targetWidgets.forEach(widgetId => {
-              const subscription = this.subscriptions.get(widgetId);
-              if (subscription) {
-                try {
-                  subscription.callback({
-                    event: 'data',
-                    data: message,
-                    widgetId
-                  });
-                } catch (error) {
-                  console.error(`[WebSocketManager] Error in widget ${widgetId} callback:`, error);
-                }
-              }
-            });
-            return; // Don't fall through to broadcast
-          }
-        }
-
-        //console.log('here');
+        // Get relevant widgets based on message type and symbol
         const relevantWidgets = this._getRelevantWidgets(message);
         if (this.config.debug && relevantWidgets.size > 0) {
           console.log(`[WebSocketManager] Routing message to ${relevantWidgets.size} relevant widgets`);
@@ -41996,42 +42210,49 @@ ${SharedStyles}
       _cacheMessage(message) {
         try {
           // Extract symbol and message type to create cache key
-          const symbol = this._extractSymbol(message);
-          const messageType = this._extractMessageType(message);
+          // This allows new widgets to get instant data when subscribing
+          // check in message.data or message.Data
+          let data;
+          if (message.data) {
+            data = message.data;
+          } else if (message.Data) {
+            data = message.Data;
+          } else {
+            data = message;
+          }
+          const symbol = this._extractSymbol(data);
+          const messageType = message.type;
+          if (this.config.debug) {
+            console.log(`[WebSocketManager] _cacheMessage - extracted symbol: "${symbol}", messageType: "${messageType}"`);
+          }
+
+          // Cache by type:symbol combination
           if (messageType && symbol) {
             const cacheKey = `${messageType}:${symbol}`;
             this.lastMessageCache.set(cacheKey, message);
             if (this.config.debug) {
               console.log(`[WebSocketManager] Cached message for ${cacheKey}`);
             }
-          }
-
-          // Also handle array messages (for night session / blueocean data)
-          if (Array.isArray(message) && message.length > 0 && message[0].Symbol) {
-            const firstItem = message[0];
-            const symbol = firstItem.Symbol;
-            const messageType = this._extractMessageType(message);
-            if (messageType && symbol) {
-              const cacheKey = `${messageType}:${symbol}`;
-              this.lastMessageCache.set(cacheKey, message);
+          } else {
+            // If we can't extract symbol from message, try to cache by type only
+            // This helps with data like ONBBO L2 which doesn't have symbol in the message
+            if (messageType) {
               if (this.config.debug) {
-                console.log(`[WebSocketManager] Cached array message for ${cacheKey}`);
+                console.log(`[WebSocketManager] No symbol found in message, attempting to infer from subscriptions for type: ${messageType}`);
               }
-            }
-          }
 
-          // Handle Data array format (for queryl1 data)
-          if (message.Data && Array.isArray(message.Data)) {
-            message.Data.forEach(dataItem => {
-              if (dataItem.Symbol) {
-                const cacheKey = `queryl1:${dataItem.Symbol}`;
-                // Cache the whole message, not just the item
-                this.lastMessageCache.set(cacheKey, message);
-                if (this.config.debug) {
-                  console.log(`[WebSocketManager] Cached data item for ${cacheKey}`);
+              // Find active subscriptions for this message type and cache for each
+              this.activeSubscriptions.forEach(activeKey => {
+                const [type, sym] = activeKey.split(':');
+                if (type === messageType && sym) {
+                  const cacheKey = activeKey;
+                  this.lastMessageCache.set(cacheKey, message);
+                  if (this.config.debug) {
+                    console.log(`[WebSocketManager] Cached message for ${cacheKey} (inferred from active subscription)`);
+                  }
                 }
-              }
-            });
+              });
+            }
           }
         } catch (error) {
           console.error('[WebSocketManager] Error caching message:', error);
@@ -42198,7 +42419,7 @@ ${SharedStyles}
       _extractSymbol(item) {
         // Handle new format where symbol might be in nested data structure
         // Check if this is an array with data that has _messageType (normalized new format)
-        if (Array.isArray(item) && item._messageType) {
+        if (Array.isArray(item)) {
           // The data is an array, check first item for symbol
           if (item.length > 0 && item[0]) {
             return this._extractSymbolFromItem(item[0]);