Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

Do cloudscape tables have a way of inline adding rows where I can hit a "new" button and…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-235b-a22b’s answer.
  1. User

    Do cloudscape tables have a way of inline adding rows where I can hit a "new" button and a new row will appear where I can fill in the values and then hit submit on that row?

  2. Gemini Assistant

    Of course! Yes, Cloudscape tables fully support the pattern you're describing. This is a very common user experience requirement, often referred to as inline creation, in-context adding, or an editable table.

    While Cloudscape provides the UI components, you, as the developer, are responsible for managing the state and logic to make it work.

    Here’s a breakdown of how it's typically implemented and what it looks like.

    The User Experience Pattern

    The flow you described is the standard way to implement this with Cloudscape:

    1. "Add New" Button: The table header contains a primary button, usually labeled "Add new item," "Create," or simply "New."
    2. New Row Appears: When this button is clicked, a new row is added to the table's data set (usually at the top for visibility). This new row is immediately in an "edit" state.
    3. Inline Fields: Instead of displaying static text, the cells of this new row contain input components like <Input>, <Select>, <DatePicker>, etc.
    4. Row-Specific Actions: The new row has its own "Save" (or "Submit") and "Cancel" buttons, typically in the last column. The main "Add New" button is often disabled during this process to prevent adding multiple new rows at once.
    5. Submission/Cancellation:
      • On Save: You validate the inputs, make an API call to persist the new data, and then switch the row from its "edit" state to a regular, static display state.
      • On Cancel: You simply remove the temporary new row from the table's data set.

    How to Implement It (React Example)

    Let's walk through the key implementation details using React and TypeScript, as this is the most common framework for Cloudscape.

    The core idea is to manage the state of your table items and use conditional rendering within your columnDefinitions.

    1. State Management

    You need to manage which item is currently being edited. A simple way is to add a temporary flag to the item object itself.

    // Define the shape of your data
    interface MyItem {
      id: string; // Use a unique ID, even for temporary items
      name: string;
      type: string;
      // This flag is crucial for the logic
      isEditing?: boolean;
    }
    
    // In your component
    const [items, setItems] = useState<MyItem[]>([]);
    

    2. The "Add New" Button

    This button will add a new, temporary item to your state with the isEditing flag set to true.

    import { Button, Table, Header } from "@cloudscape-design/components";
    import { useState } from "react";
    
    // Function to handle adding a new item
    const handleAddNewItem = () => {
      const newItem: MyItem = {
        id: `new-${Date.now()}`, // A temporary, unique ID
        name: "",
        type: "Type A", // Default value
        isEditing: true,
      };
      // Add the new item to the top of the list
      setItems([newItem, ...items]);
    };
    
    // Inside your render function
    <Table
      header={
        <Header
          actions={
            <Button variant="primary" onClick={handleAddNewItem}>
              Add new item
            </Button>
          }
        >
          My Table
        </Header>
      }
      // ... other table props
    />
    

    3. Conditional Rendering in columnDefinitions

    This is the most important part. Your columnDefinitions will check the isEditing flag for each item and render either a static value or an input component.

    import { Input, Select, SpaceBetween } from "@cloudscape-design/components";
    
    const columnDefinitions = [
      {
        id: "name",
        header: "Name",
        cell: (item: MyItem) => {
          // If the row is in edit mode, show an Input
          if (item.isEditing) {
            return (
              <Input
                value={item.name}
                onChange={(event) => handleUpdateItem(item.id, { name: event.detail.value })}
              />
            );
          }
          // Otherwise, show static text
          return item.name;
        },
      },
      {
        id: "type",
        header: "Type",
        cell: (item: MyItem) => {
          if (item.isEditing) {
            return (
              <Select
                selectedOption={{ label: item.type, value: item.type }}
                onChange={(event) =>
                  handleUpdateItem(item.id, { type: event.detail.selectedOption.value })
                }
                options={[
                  { label: "Type A", value: "Type A" },
                  { label: "Type B", value: "Type B" },
                ]}
              />
            );
          }
          return item.type;
        },
      },
      {
        id: "actions",
        header: "Actions",
        cell: (item: MyItem) => {
          if (item.isEditing) {
            return (
              <SpaceBetween direction="horizontal" size="xs">
                <Button variant="primary" onClick={() => handleSaveItem(item.id)}>
                  Save
                </Button>
                <Button onClick={() => handleCancelEdit(item.id)}>Cancel</Button>
              </SpaceBetween>
            );
          }
          // You could have an "Edit" button for existing rows here
          return <Button>Edit</Button>;
        },
      },
    ];
    

    4. Handler Functions

    You'll need functions to handle updates, saves, and cancellations.

    // Update the temporary item in state as the user types
    const handleUpdateItem = (id: string, updates: Partial<MyItem>) => {
      setItems((prevItems) =>
        prevItems.map((item) => (item.id === id ? { ...item, ...updates } : item))
      );
    };
    
    // "Save" the new item
    const handleSaveItem = (id: string) => {
      // Here you would typically make an API call to your backend
      console.log("Saving item:", items.find((item) => item.id === id));
    
      // On success, update the state to turn off editing mode
      setItems((prevItems) =>
        prevItems.map((item) =>
          item.id === id ? { ...item, isEditing: false, id: `saved-${item.id}` } : item // Maybe get a real ID from the backend
        )
      );
    };
    
    // "Cancel" the add operation
    const handleCancelEdit = (id: string) => {
      // Filter out the temporary item that was being added
      setItems((prevItems) => prevItems.filter((item) => item.id !== id));
    };
    

    Summary

    So, yes, Cloudscape fully enables this pattern. You achieve it by:

    1. Using a main "Add" button in the table header.
    2. Managing a state variable (e.g., isEditing) on your data items.
    3. Using conditional rendering within the cell property of your columnDefinitions to show either static text or Cloudscape input components.
    4. Adding a column with row-specific "Save" and "Cancel" buttons that only appear for the new/editing row.

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