fix: use appropriate console methods based on alert variant and only log in debug mode

packages/controllers/src/controllers/AlertController.ts

@@ -45,12 +45,23 @@ const controller = {
       state.open = true
     }
 
-    if (debugMessage) {
-      // eslint-disable-next-line no-console
-      console.error(
-        typeof debugMessage === 'function' ? debugMessage() : debugMessage,
-        code ? { code } : undefined
-      )
+    if (debugMessage && debug) {
+      const message = typeof debugMessage === 'function' ? debugMessage() : debugMessage
+      const logData = code ? { code } : undefined
+
+      switch (variant) {
+        case 'error':
+          // eslint-disable-next-line no-console
+          console.error(message, logData)
+          break
+        case 'warning':
+          // eslint-disable-next-line no-console
+          console.warn(message, logData)
+          break
+        default:
+          // eslint-disable-next-line no-console
+          console.log(message, logData)
+      }
     }
   },
 

packages/controllers/tests/controllers/AlertController.test.ts

@@ -56,7 +56,7 @@ describe('AlertController', () => {
     })
   })
 
-  it('should show error code', () => {
+  it('should use console.error for error variant with debug message', () => {
     const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
     AlertController.open(
       {
@@ -72,4 +72,75 @@ describe('AlertController', () => {
       { code: 'APKT005' }
     )
   })
+
+  it('should use console.warn for warning variant with debug message', () => {
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    AlertController.open(
+      {
+        code: 'APKT006',
+        displayMessage: 'Config Notice',
+        debugMessage: '[Reown Config Notice] Configuration has been overridden by remote config.'
+      },
+      'warning'
+    )
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      '[Reown Config Notice] Configuration has been overridden by remote config.',
+      { code: 'APKT006' }
+    )
+  })
+
+  it('should use console.log for info variant with debug message', () => {
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    AlertController.open(
+      {
+        debugMessage: 'Info debug message'
+      },
+      'info'
+    )
+    expect(consoleLogSpy).toHaveBeenCalledWith('Info debug message', undefined)
+  })
+
+  it('should use console.log for success variant with debug message', () => {
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    AlertController.open(
+      {
+        debugMessage: 'Success debug message'
+      },
+      'success'
+    )
+    expect(consoleLogSpy).toHaveBeenCalledWith('Success debug message', undefined)
+  })
+
+  it('should not log to console when debug mode is disabled', () => {
+    OptionsController.state.debug = false
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    AlertController.open(
+      {
+        debugMessage: 'This should not be logged'
+      },
+      'error'
+    )
+
+    expect(consoleErrorSpy).not.toHaveBeenCalled()
+    expect(consoleWarnSpy).not.toHaveBeenCalled()
+    expect(consoleLogSpy).not.toHaveBeenCalled()
+
+    // Restore debug mode for other tests
+    OptionsController.state.debug = true
+  })
+
+  it('should handle function debug message', () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const debugMessageFn = () => 'Dynamic error message'
+    AlertController.open(
+      {
+        debugMessage: debugMessageFn
+      },
+      'error'
+    )
+    expect(consoleErrorSpy).toHaveBeenCalledWith('Dynamic error message', undefined)
+  })
 })