Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-2025-04-14· OpenAIHugging Face LMArena Human Preference 140K

for the left side code, please modify the React code to keep the CurrencyInput in a HTML…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-3-7-sonnet-20250219-thinking-32k’s answer.
  1. User

    for the left side code, please modify the React code to keep the CurrencyInput in a HTML form and add a submit button that gets enabled when a numeric value is entered

  2. Assistant

    Certainly! Here’s a complete example of a React component with your CurrencyInput inside a form, and a submit button that is only enabled when a valid numeric value is entered.

    Key points:

    • The submit button is disabled if the value is null, undefined, or NaN.
    • On submit, the form will alert the entered value (you can replace this with your own logic).

    import React, { useState } from 'react';
    
    // CurrencyInput component as previously defined
    const CurrencyInput = ({
      value,
      onChange,
      currencySymbol = '$',
      className = '',
      placeholder = '0.00',
    }) => {
      const [inputValue, setInputValue] = useState('');
      const [formattedValue, setFormattedValue] = useState('');
    
      React.useEffect(() => {
        if (value !== undefined && value !== null) {
          const formatted = formatCurrency(value);
          setFormattedValue(formatted);
          setInputValue(String(value));
        }
      }, [value]);
    
      const handleChange = (e) => {
        const rawValue = e.target.value;
        if (!/^\d*\.?\d*$/.test(rawValue)) {
          return;
        }
        setInputValue(rawValue);
        const formatted = formatCurrency(rawValue);
        setFormattedValue(formatted);
    
        const parsedValue = parseFloat(rawValue);
        if (!isNaN(parsedValue)) {
          onChange(parsedValue);
        } else {
          onChange(null);
        }
      };
    
      const handleBlur = () => {
        if (!inputValue || inputValue === ".") {
          const formatted = formatCurrency(0);
          setFormattedValue(formatted);
          setInputValue("0");
          onChange(0);
        } else {
          const parsedValue = parseFloat(inputValue);
          if (!isNaN(parsedValue)) {
            const formatted = formatCurrency(parsedValue);
            setFormattedValue(formatted);
            setInputValue(String(parsedValue));
          }
        }
      };
    
      const formatCurrency = (number) => {
        const num = Number(number);
        if (isNaN(num)) {
          return '0.00';
        }
        return num.toLocaleString(undefined, {
          minimumFractionDigits: 2,
          maximumFractionDigits: 2,
        });
      };
    
      return (
        <input
          type="text"
          className={`currency-input ${className}`}
          value={formattedValue}
          onChange={handleChange}
          onBlur={handleBlur}
          placeholder={placeholder}
          inputMode="decimal"
          autoComplete="off"
        />
      );
    };
    
    // Parent form component
    const CurrencyForm = () => {
      const [amount, setAmount] = useState(null);
    
      const isValid = typeof amount === 'number' && !isNaN(amount);
    
      const handleSubmit = (e) => {
        e.preventDefault();
        if (isValid) {
          alert(`Submitted amount: ${amount.toFixed(2)}`);
          // You can replace the alert with your own submit logic
        }
      };
    
      return (
        <form onSubmit={handleSubmit}>
          <label>
            Enter Amount:
            <CurrencyInput
              value={amount}
              onChange={setAmount}
              currencySymbol="$"
              className="my-custom-input"
              placeholder="0.00"
            />
          </label>
          <button type="submit" disabled={!isValid} style={{ marginLeft: 8 }}>
            Submit
          </button>
        </form>
      );
    };
    
    export default CurrencyForm;
    

    How it works:

    • The submit button is disabled until a valid number is entered.
    • The form will alert the value on submit (replace with your logic as needed).
    • The CurrencyInput is fully controlled and always displays two decimal places.

    Let me know if you need further customization!

  3. User

    please make the left side code by Assistant A properly work. It is allowing to enter one digit in number and not allowing digits further. And if I delete the digit/s it becomes 0.00 and gets uneditable

  4. Assistant

    You're right! The original code has issues because it always displays the formatted value in the input, which interferes with typing (e.g., you type "1", it becomes "1.00", and the cursor jumps, making further typing difficult). Also, when you delete, it resets to "0.00" and you can't type anymore.

    The correct approach:

    • Let the user type freely (raw value).
    • Only format on blur (when the input loses focus).
    • Always keep the input editable.

    Below is a fixed version of the CurrencyInput and a form with a submit button that is enabled only when a valid number is entered.


    import React, { useState, useRef } from 'react';
    
    const CurrencyInput = ({
      value,
      onChange,
      currencySymbol = '$',
      className = '',
      placeholder = '0.00',
    }) => {
      const [displayValue, setDisplayValue] = useState(
        value !== null && value !== undefined ? value.toFixed(2) : ''
      );
      const lastValue = useRef(value);
    
      // Update displayValue if parent value changes (e.g., on form reset)
      React.useEffect(() => {
        if (value !== lastValue.current) {
          setDisplayValue(
            value !== null && value !== undefined && !isNaN(value)
              ? value.toFixed(2)
              : ''
          );
          lastValue.current = value;
        }
      }, [value]);
    
      const handleChange = (e) => {
        const raw = e.target.value.replace(/[^0-9.]/g, '');
    
        // Only allow one decimal point
        const parts = raw.split('.');
        let cleaned = parts[0];
        if (parts.length > 1) {
          cleaned += '.' + parts.slice(1).join('');
        }
    
        setDisplayValue(cleaned);
    
        // Call onChange with a number or null
        const num = parseFloat(cleaned);
        if (!isNaN(num)) {
          onChange(num);
        } else {
          onChange(null);
        }
      };
    
      const handleBlur = () => {
        // Format to two decimals on blur
        const num = parseFloat(displayValue);
        if (!isNaN(num)) {
          setDisplayValue(num.toFixed(2));
        } else {
          setDisplayValue('');
        }
      };
    
      const handleFocus = () => {
        // Remove formatting on focus for easier editing
        if (displayValue === '0.00') setDisplayValue('');
      };
    
      return (
        <div style={{ display: 'inline-flex', alignItems: 'center' }}>
          <span style={{ marginRight: 4 }}>{currencySymbol}</span>
          <input
            type="text"
            className={`currency-input ${className}`}
            value={displayValue}
            onChange={handleChange}
            onBlur={handleBlur}
            onFocus={handleFocus}
            placeholder={placeholder}
            inputMode="decimal"
            autoComplete="off"
            style={{ width: 100 }}
          />
        </div>
      );
    };
    
    const CurrencyForm = () => {
      const [amount, setAmount] = useState(null);
    
      const isValid = typeof amount === 'number' && !isNaN(amount);
    
      const handleSubmit = (e) => {
        e.preventDefault();
        if (isValid) {
          alert(`Submitted amount: ${amount.toFixed(2)}`);
        }
      };
    
      return (
        <form onSubmit={handleSubmit}>
          <label>
            Enter Amount:
            <CurrencyInput
              value={amount}
              onChange={setAmount}
              currencySymbol="$"
              className="my-custom-input"
              placeholder="0.00"
            />
          </label>
          <button type="submit" disabled={!isValid} style={{ marginLeft: 8 }}>
            Submit
          </button>
        </form>
      );
    };
    
    export default CurrencyForm;
    

    Key improvements:

    • The input is always editable.
    • Formatting to two decimals only happens on blur.
    • The submit button is enabled only for valid numbers.
    • Deleting all input leaves the field empty and editable.

    Let me know if you need further tweaks!

  5. User

    apart from the submit button, add a checkbox "I agree". Now to make the Submit button enabled the condition to be met will be non zero value in currencyInput field and checked value of checkbox, else Submit button will be disabled.

  6. Assistant

    Absolutely! Here’s how you can do it:

    What’s changed:

    • Added a checkbox labeled "I agree".
    • The submit button is enabled only if:
      • The currency input is a valid, non-zero number.
      • The checkbox is checked.

    import React, { useState, useRef } from 'react';
    
    const CurrencyInput = ({
      value,
      onChange,
      currencySymbol = '$',
      className = '',
      placeholder = '0.00',
    }) => {
      const [displayValue, setDisplayValue] = useState(
        value !== null && value !== undefined ? value.toFixed(2) : ''
      );
      const lastValue = useRef(value);
    
      React.useEffect(() => {
        if (value !== lastValue.current) {
          setDisplayValue(
            value !== null && value !== undefined && !isNaN(value)
              ? value.toFixed(2)
              : ''
          );
          lastValue.current = value;
        }
      }, [value]);
    
      const handleChange = (e) => {
        const raw = e.target.value.replace(/[^0-9.]/g, '');
        const parts = raw.split('.');
        let cleaned = parts[0];
        if (parts.length > 1) {
          cleaned += '.' + parts.slice(1).join('');
        }
        setDisplayValue(cleaned);
    
        const num = parseFloat(cleaned);
        if (!isNaN(num)) {
          onChange(num);
        } else {
          onChange(null);
        }
      };
    
      const handleBlur = () => {
        const num = parseFloat(displayValue);
        if (!isNaN(num)) {
          setDisplayValue(num.toFixed(2));
        } else {
          setDisplayValue('');
        }
      };
    
      const handleFocus = () => {
        if (displayValue === '0.00') setDisplayValue('');
      };
    
      return (
        <div style={{ display: 'inline-flex', alignItems: 'center' }}>
          <span style={{ marginRight: 4 }}>{currencySymbol}</span>
          <input
            type="text"
            className={`currency-input ${className}`}
            value={displayValue}
            onChange={handleChange}
            onBlur={handleBlur}
            onFocus={handleFocus}
            placeholder={placeholder}
            inputMode="decimal"
            autoComplete="off"
            style={{ width: 100 }}
          />
        </div>
      );
    };
    
    const CurrencyForm = () => {
      const [amount, setAmount] = useState(null);
      const [agreed, setAgreed] = useState(false);
    
      // Must be a number, not NaN, and not zero
      const isValidAmount = typeof amount === 'number' && !isNaN(amount) && amount !== 0;
      const canSubmit = isValidAmount && agreed;
    
      const handleSubmit = (e) => {
        e.preventDefault();
        if (canSubmit) {
          alert(`Submitted amount: ${amount.toFixed(2)}`);
        }
      };
    
      return (
        <form onSubmit={handleSubmit}>
          <label>
            Enter Amount:
            <CurrencyInput
              value={amount}
              onChange={setAmount}
              currencySymbol="$"
              className="my-custom-input"
              placeholder="0.00"
            />
          </label>
          <div style={{ margin: '8px 0' }}>
            <label>
              <input
                type="checkbox"
                checked={agreed}
                onChange={e => setAgreed(e.target.checked)}
                style={{ marginRight: 4 }}
              />
              I agree
            </label>
          </div>
          <button type="submit" disabled={!canSubmit}>
            Submit
          </button>
        </form>
      );
    };
    
    export default CurrencyForm;
    

    Summary of logic:

    • Submit is enabled only if:
      • The currency input is a valid, non-zero number.
      • The "I agree" checkbox is checked.

    Let me know if you want any further customization!

  7. User

    The left side code from Assistant A has an issue -- it is not allowing to enter more than one digit as Amount. Please fix it

  8. Assistant

    You're right! The issue is that the input always displays the formatted value (e.g., "1.00") as you type, which interferes with normal typing and cursor position. The correct approach is to:

    • Let the user type the raw value (unformatted) while editing.
    • Only format to two decimals on blur (when the input loses focus).
    • Keep the input always editable.

    Below is a fixed version of the CurrencyInput and the form with the "I agree" checkbox and the correct submit button logic:


    import React, { useState, useEffect } from 'react';
    
    const CurrencyInput = ({
      value,
      onChange,
      currencySymbol = '$',
      className = '',
      placeholder = '0.00',
    }) => {
      const [inputValue, setInputValue] = useState('');
    
      // Keep inputValue in sync with value prop (e.g. on form reset)
      useEffect(() => {
        if (value === null || value === undefined || isNaN(value)) {
          setInputValue('');
        } else {
          setInputValue(String(value));
        }
      }, [value]);
    
      const handleChange = (e) => {
        let raw = e.target.value.replace(/[^0-9.]/g, '');
    
        // Only allow one decimal point
        const parts = raw.split('.');
        if (parts.length > 2) {
          raw = parts[0] + '.' + parts.slice(1).join('');
        }
    
        setInputValue(raw);
    
        // Call onChange with a number or null
        const num = parseFloat(raw);
        if (!isNaN(num)) {
          onChange(num);
        } else {
          onChange(null);
        }
      };
    
      const handleBlur = () => {
        const num = parseFloat(inputValue);
        if (!isNaN(num)) {
          setInputValue(num.toFixed(2));
        } else {
          setInputValue('');
        }
      };
    
      const handleFocus = () => {
        // Remove formatting on focus for easier editing
        if (inputValue === '0.00') setInputValue('');
      };
    
      return (
        <div style={{ display: 'inline-flex', alignItems: 'center' }}>
          <span style={{ marginRight: 4 }}>{currencySymbol}</span>
          <input
            type="text"
            className={`currency-input ${className}`}
            value={inputValue}
            onChange={handleChange}
            onBlur={handleBlur}
            onFocus={handleFocus}
            placeholder={placeholder}
            inputMode="decimal"
            autoComplete="off"
            style={{ width: 100 }}
          />
        </div>
      );
    };
    
    const CurrencyForm = () => {
      const [amount, setAmount] = useState(null);
      const [agreed, setAgreed] = useState(false);
    
      // Must be a number, not NaN, and not zero
      const isValidAmount = typeof amount === 'number' && !isNaN(amount) && amount !== 0;
      const canSubmit = isValidAmount && agreed;
    
      const handleSubmit = (e) => {
        e.preventDefault();
        if (canSubmit) {
          alert(`Submitted amount: ${amount.toFixed(2)}`);
        }
      };
    
      return (
        <form onSubmit={handleSubmit}>
          <label>
            Enter Amount:
            <CurrencyInput
              value={amount}
              onChange={setAmount}
              currencySymbol="$"
              className="my-custom-input"
              placeholder="0.00"
            />
          </label>
          <div style={{ margin: '8px 0' }}>
            <label>
              <input
                type="checkbox"
                checked={agreed}
                onChange={e => setAgreed(e.target.checked)}
                style={{ marginRight: 4 }}
              />
              I agree
            </label>
          </div>
          <button type="submit" disabled={!canSubmit}>
            Submit
          </button>
        </form>
      );
    };
    
    export default CurrencyForm;
    

    Now you can:

    • Enter any number of digits and decimals.
    • The field only formats to two decimals on blur.
    • The submit button is enabled only if the amount is non-zero and the checkbox is checked.

    Let me know if you need further tweaks!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.