Fix: connectionResolver receives incorrect field value when switching between Login and Sign-up tabs (#2697)

### Changes
Fixes a bug where connectionResolver callback receives the wrong field
value when users switch between Login and Sign-up tabs that have
different field types (username vs email).

Closes #2631

### Root Cause

The bug was in `src/ui/box/container.jsx` in the
`checkConnectionResolver()` method at line 80:

**BEFORE** (buggy code)
`const userInputValue = c.getFieldValue(lock, 'username') ||
c.getFieldValue(lock, 'email');
`
This code always prioritized the username field over email, regardless
of which screen (Login vs Sign-up) was currently active. Since both
field values exist in the global lock state, it would retrieve the Login
username even when on the Sign-up screen.

### Solution
Modified checkConnectionResolver() to check which screen is currently
active and prioritize the appropriate field:

**AFTER** (fixed code)
  ```
const isSignUpScreen = screenName && screenName.includes('signUp');
const userInputValue = databaseUsernameValue(lock, isSignUpScreen ? {
emailFirst: true } : {});
```

### Testing
Manual testing performed - 

-  Verified bug exists in original code
- Applied fix and verified bug is resolved
- Tested multiple scenarios:
    - Sign-up with email (email prioritized) 
    - Sign-up with username only (username used) 
    - Login with username (username prioritized) 
    - Login with email (email used) 
    - Switch from Login to Sign-up with pre-filled fields (correct field used)

### Checklist

* [x] I have read the [Auth0 general contribution guidelines](https://github.com/auth0/open-source-template/blob/master/GENERAL-CONTRIBUTING.md)
* [x] I have read the [Auth0 Code of Conduct](https://github.com/auth0/open-source-template/blob/master/CODE-OF-CONDUCT.md)
* [x] All code quality tools/guidelines have been run/followed
* [x] All relevant assets have been compiled

Author: ankita10119

src/__tests__/ui/box/container.test.jsx

@@ -9,6 +9,10 @@ jest.mock('store/index', () => ({
 
 jest.mock('ui/box/chrome', () => mockComponent('chrome'));
 
+jest.mock('connection/database/index', () => ({
+  databaseUsernameValue: jest.fn()
+}));
+
 const mockEvent = {
   preventDefault: () => {}
 };
@@ -75,14 +79,25 @@ describe('Container', () => {
   describe('with a custom `connectionResolver`', () => {
     let connectionResolverMock;
     let setResolvedConnectionMock;
+    let databaseUsernameValueMock;
 
     beforeEach(() => {
       connectionResolverMock = jest.fn();
       setResolvedConnectionMock = jest.fn();
+      databaseUsernameValueMock = require('connection/database/index').databaseUsernameValue;
+
+      // Set default return value for databaseUsernameValue mock
+      databaseUsernameValueMock.mockReturnValue('[email protected]');
+
       require('core/index').connectionResolver = () => connectionResolverMock;
       require('core/index').setResolvedConnection = setResolvedConnectionMock;
     });
 
+    afterEach(() => {
+      // Reset mock between tests and restore default return value
+      databaseUsernameValueMock.mockReset().mockReturnValue('[email protected]');
+    });
+
     it('calls `connectionResolver` onSubmit', () => {
       const c = getContainer();
       c.handleSubmit(mockEvent);
@@ -110,6 +125,54 @@ describe('Container', () => {
       expect(mock.calls.length).toBe(1);
       expect(mock.calls[0]).toMatchSnapshot();
     });
+
+    it('prioritizes email over username on signUp screen', () => {
+      databaseUsernameValueMock.mockReturnValue('[email protected]');
+
+      const c = getContainer({ screenName: 'main.signUp' });
+      c.handleSubmit(mockEvent);
+
+      // Should call databaseUsernameValue with emailFirst: true
+      expect(databaseUsernameValueMock).toHaveBeenCalledWith(
+        expect.anything(),
+        { emailFirst: true }
+      );
+
+      // connectionResolver should receive the email value
+      const { mock } = connectionResolverMock;
+      expect(mock.calls[0][0]).toBe('[email protected]');
+    });
+
+    it('prioritizes username over email on login screen', () => {
+      databaseUsernameValueMock.mockReturnValue('testuser');
+
+      const c = getContainer({ screenName: 'main.login' });
+      c.handleSubmit(mockEvent);
+
+      // Should call databaseUsernameValue with empty options (default behavior)
+      expect(databaseUsernameValueMock).toHaveBeenCalledWith(
+        expect.anything(),
+        {}
+      );
+
+      // connectionResolver should receive the username value
+      const { mock } = connectionResolverMock;
+      expect(mock.calls[0][0]).toBe('testuser');
+    });
+
+    it('uses default behavior when screenName is not main.signUp', () => {
+      databaseUsernameValueMock.mockReturnValue('defaultvalue');
+
+      const c = getContainer({ screenName: 'forgotPassword' });
+      c.handleSubmit(mockEvent);
+
+      // Should call databaseUsernameValue with empty options (default behavior)
+      expect(databaseUsernameValueMock).toHaveBeenCalledWith(
+        expect.anything(),
+        {}
+      );
+    });
+
   });
 
   describe('when suppressSubmitOverlay is true', () => {

src/ui/box/container.jsx

@@ -5,6 +5,7 @@ import { CloseButton } from './button';
 import * as l from '../../core/index';
 import * as c from '../../field/index';
 import { swap, updateEntity } from '../../store/index';
+import { databaseUsernameValue } from '../../connection/database/index';
 
 const badgeSvg = (
   <svg focusable="false" width="58px" height="21px" viewBox="0 0 462 168">
@@ -69,15 +70,20 @@ export default class Container extends React.Component {
     this.state = { isOpen: false };
   }
   checkConnectionResolver(done) {
-    const { contentProps } = this.props;
+    const { contentProps, screenName } = this.props;
     const lock = contentProps.model;
     const connectionResolver = l.connectionResolver(lock);
     if (!connectionResolver) {
       return done();
     }
     const { connections, id } = lock.get('client').toJS();
     const context = { connections, id };
-    const userInputValue = c.getFieldValue(lock, 'username') || c.getFieldValue(lock, 'email');
+
+    // On signUp screen, use emailFirst option to prioritize email over username
+    // On login screen, use default behavior (username first)
+    const isSignUpScreen = screenName === 'main.signUp';
+    const userInputValue = databaseUsernameValue(lock, isSignUpScreen ? { emailFirst: true } : {});
+
     connectionResolver(userInputValue, context, resolvedConnection => {
       swap(updateEntity, 'lock', l.id(lock), m => l.setResolvedConnection(m, resolvedConnection));
       done();