@cplace/test-mcp-server 0.1.15 → 1.1.0

package/dist/widget-specifications/_research_from_ga_products/cf-platform-connectedPieChart/research.md

@@ -0,0 +1,150 @@
+# Research: Connected Pie Chart Widget
+
+**Widget ID:** `cf.platform.connectedPieChart`
+**Display Name:** Pie Chart
+**Repository:** main
+**Icon:** `fa-chart-pie`
+
+## Description
+
+The Connected Pie Chart widget visualizes the distribution of values in a selected attribute as an interactive pie chart. It can display data either from a connected table widget or from a search query defined directly in the widget configuration.
+
+## Purpose
+
+This widget provides a visual representation of categorical data distribution, showing the proportion of each value as a slice of a pie chart. It aggregates data by counting the frequency of each distinct value in a selected attribute and displays the results with percentages and a legend.
+
+## Use Cases
+
+### 1. Status Distribution Analysis
+Display the distribution of items across different status values (e.g., "Open", "In Progress", "Completed") to get a quick overview of work progress.
+
+**Example:** A project manager wants to see how many tasks are in each status category to understand project health at a glance.
+
+### 2. Category Breakdown
+Visualize how items are distributed across categorical attributes like priority, type, or department.
+
+**Example:** Show the distribution of support tickets by priority level (High, Medium, Low) to identify where support resources should be focused.
+
+### 3. Demographic Analysis
+Display demographic breakdowns such as team distribution, location distribution, or role distribution.
+
+**Example:** Visualize how employees are distributed across different departments or locations within an organization.
+
+### 4. Enum Attribute Visualization
+Any enum or reference attribute can be visualized to understand value distribution patterns.
+
+**Example:** Show the distribution of products by manufacturer or vendor to understand supplier diversity.
+
+### 5. Connected Filtering Scenario
+When connected to a table widget, the pie chart updates dynamically based on table filters, providing real-time distribution visualization of filtered data.
+
+**Example:** A table shows all projects, and the connected pie chart shows the distribution of those projects by status. When users filter the table, the pie chart automatically updates to reflect the filtered subset.
+
+## Configuration Concepts
+
+### Data Source Configuration
+
+The widget supports two mutually exclusive data source options:
+
+#### Option 1: Connected Table Widget
+- **Configuration:** Select an existing table widget on the same page
+- **Behavior:** The pie chart visualizes data from the table's current result set
+- **Advantage:** Automatically responds to table filters and updates dynamically
+- **Requirement:** A table widget must exist on the same page
+
+#### Option 2: Direct Search Configuration
+- **Configuration:** Define a search query directly in the widget
+- **Behavior:** The pie chart visualizes data from the search results
+- **Advantage:** Independent data source, no dependency on other widgets
+- **Requirement:** The search must specify a unique type (single entity type)
+
+### Main Configuration Options
+
+1. **Table Widget ID** (optional)
+   - Links to another table widget on the same page
+   - Creates a connected relationship where the chart reflects the table's data
+
+2. **Search** (optional)
+   - Defines a search query when not using a connected table
+   - Must specify a unique type
+   - Cannot be used together with Table Widget ID
+
+3. **Attribute Name** (required)
+   - Specifies which attribute to visualize
+   - Must be an enumeration or reference attribute
+   - Available options depend on the data source (table or search)
+   - The widget counts occurrences of each distinct value
+
+4. **Localized Title** (optional)
+   - Custom title displayed above the chart
+   - Supports multiple languages
+   - Defaults to "Pie Chart" if not specified
+
+5. **Height** (optional)
+   - Fixed pixel height for the chart
+   - Allows control over vertical space usage
+
+## Technical Details
+
+### Data Processing
+- Uses Highcharts library for rendering
+- Aggregates data using search index facets (term frequencies)
+- Sorts values alphabetically by their display name
+- Displays percentages in tooltips (e.g., "45.3%")
+- Shows a legend with value names
+- Interactive: slices can be selected/highlighted
+
+### Validation Rules
+1. Exactly one data source must be specified (either table widget or search)
+2. If using search, it must define a unique type
+3. Attribute name is required and must be compatible with the data source
+
+### Chart Behavior
+- Point selection enabled (click to highlight)
+- Hover tooltips show percentage
+- Legend displays on the right side
+- Data labels disabled by default (values shown in legend)
+- No title displayed on the chart itself (uses widget title)
+
+## Context and Relationships
+
+### Widget Family
+This widget is part of the "Connected Widgets" family, which includes:
+- **cf.platform.connectedBarChart** - Similar functionality but displays data as a bar chart
+- **cf.platform.connectedMatrix** - 2D visualization of relationships
+- **cf.platform.connectedTableFilter** - Provides filtering controls for tables
+- **cf.platform.connectedSingleAttribute** - Displays a single attribute value from selected row
+- **cf.platform.connectedAttributesGroup** - Displays multiple attributes from selected row
+
+### Comparison with Bar Chart
+The Connected Pie Chart and Connected Bar Chart widgets are nearly identical in functionality:
+- Both visualize attribute value distribution
+- Both support connected table or direct search
+- Both use the same configuration options
+- **Difference:** Pie chart shows proportions as circular slices, bar chart shows them as vertical bars
+
+### When to Use Pie Chart vs Bar Chart
+- **Use Pie Chart when:** You want to emphasize the proportion of parts to a whole (e.g., "50% of tasks are complete")
+- **Use Bar Chart when:** You have many categories or want to compare absolute values more precisely
+
+## Prerequisites and Dependencies
+
+- The widget must be embedded on a page (cannot be used standalone)
+- When using connected table mode, a compatible table widget must exist on the same page
+- The selected attribute must be of a type that can be aggregated (enum, reference, or similar)
+- Uses the Highcharts JavaScript library for visualization
+- Requires search index support for facet aggregation
+
+## Key Implementation Files
+
+- **Definition:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/ConnectedPieChartWidgetDefinition.java`
+- **Data Handler:** `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/handler/widgets/connectedTables/highcharts/ConnectedPieChartDataHandler.java`
+- **Frontend Controller:** `cf.cplace.platform/assets/ts/highcharts/pieChart/ConnectedPieChartWidget.controller.ts`
+- **Configuration Type:** Defined in `WidgetTypes.CONNECTED_PIE_CHART`
+
+## Localized Messages
+
+- **Name:** "Pie Chart"
+- **Description:** "Visualizes an attribute of a table or a search configurable in the widget as a pie chart."
+- **Error - No Data Source:** "You have to specify the data source of the chart, i.e., either a connected table or a search."
+- **Error - Type Required:** "The search has to specify a unique type."

package/dist/widget-specifications/_research_from_ga_products/cf-platform-connectedSingleAttribute/research.md

@@ -0,0 +1,430 @@
+# Widget Research: cf.platform.connectedSingleAttribute
+
+**Date**: 2026-01-16
+**Widget ID**: `cf.platform.connectedSingleAttribute`
+**Repository**: main
+**Definition Class**: `cf.cplace.platform.frontend.widgets.ConnectedSingleAttributeWidgetDefinition`
+
+---
+
+## Executive Summary
+
+### Widget Description
+
+The Connected Single Attribute Widget displays a single attribute value from an entity that is dynamically selected in a connected table or selection widget. It provides real-time attribute display and editing capabilities based on user selections in linked widgets.
+
+### Primary Purpose
+
+This widget bridges table selections and attribute visualization by showing specific attribute values (like status, name, or custom fields) from the currently selected row in a connected table widget. It updates automatically when the user selects different rows.
+
+---
+
+## Core Functionality
+
+### What This Widget Does
+
+1. **Dynamic Attribute Display**: Shows a single attribute from an entity selected in a connected table/selection widget
+2. **Real-time Updates**: Automatically updates when users change their selection in the connected widget
+3. **In-place Editing**: Optionally allows users to edit attribute values directly without leaving the page
+4. **Conditional Visibility**: Supports cplaceJS scripts to show/hide attributes based on business logic
+5. **Flexible Layout**: Configurable to show labels, values, or both in single or two-column layouts
+
+### Key Characteristics
+
+- **Connected Widget Pattern**: Implements the `ISingleEntitySelectionProducer` interface, allowing it to react to single entity selections
+- **Target Entity**: Always `null` initially - the entity is determined by the user's selection in the connected widget
+- **Embedding Support**: Can be embedded in rich text content or within a `ConnectedAttributesGroupWidgetDefinition`
+- **Frontend Duality**: Supports both legacy HTML templates and new Angular component rendering
+
+---
+
+## Use Cases
+
+### Primary Use Cases
+
+#### 1. Master-Detail View
+**Scenario**: Display detailed information about a selected table row
+**Example**: A table lists projects, and connected single attribute widgets show the selected project's status, owner, budget, and description in a detail panel.
+
+```
+┌─────────────────────────────┐
+│  Projects Table             │
+│  ┌─────┬────────┬────────┐  │
+│  │ ✓   │ Name   │ Status │  │
+│  ├─────┼────────┼────────┤  │
+│  │ [ ] │ Proj A │ Active │  │
+│  │ [x] │ Proj B │ Review │  │ ← User selects this row
+│  │ [ ] │ Proj C │ Done   │  │
+│  └─────┴────────┴────────┘  │
+└─────────────────────────────┘
+
+┌─────────────────────────────┐
+│  Project Details            │
+│  Status:    Review          │ ← Connected Single Attribute
+│  Owner:     John Doe        │ ← Connected Single Attribute
+│  Budget:    $50,000         │ ← Connected Single Attribute
+│  Due Date:  2026-03-15      │ ← Connected Single Attribute
+└─────────────────────────────┘
+```
+
+#### 2. Quick Edit Interface
+**Scenario**: Allow inline editing of specific attributes from a selection
+**Example**: A table of tasks where selecting a task allows quick status updates via connected single attribute widgets with in-place editing enabled.
+
+**Configuration**:
+- `IN_PLACE_EDITING`: `true`
+- `WITH_LABEL`: `true`
+- `WITH_VALUE`: `true`
+- `RELOAD_AFTER_CHANGE`: `true` (to refresh dependent widgets)
+
+#### 3. Conditional Attribute Display
+**Scenario**: Show different attributes based on the selected entity's state
+**Example**: Display "Approval Date" only for approved items, or "Rejection Reason" only for rejected items.
+
+**Configuration**:
+- `SHOW_ATTRIBUTE_SCRIPT`: cplaceJS script evaluating entity state
+- Script bindings: `embeddingPage`, `targetEntity`
+
+```javascript
+// Example script: Only show "Rejection Reason" if status is "Rejected"
+return targetEntity.get('status') === 'Rejected';
+```
+
+#### 4. Grouped Attributes Display
+**Scenario**: Multiple related attributes displayed together with a shared table selection
+**Example**: Embedded within a `ConnectedAttributesGroupWidgetDefinition` to create a form-like interface showing multiple attributes from the selected entity.
+
+```
+┌─────────────────────────────┐
+│  Employees Table            │
+│  [Select employee...]       │
+└─────────────────────────────┘
+
+┌─────────────────────────────┐
+│  Employee Details           │
+│  ┌───────────────────────┐  │
+│  │ Name:     Jane Smith  │  │ ← Connected Single Attribute
+│  │ Email:    jane@co.com │  │ ← Connected Single Attribute
+│  │ Phone:    555-1234    │  │ ← Connected Single Attribute
+│  │ Department: Sales     │  │ ← Connected Single Attribute
+│  └───────────────────────┘  │
+└─────────────────────────────┘
+```
+
+#### 5. Inline Display in Rich Text
+**Scenario**: Embed dynamic attribute values within narrative content
+**Example**: A report page with text like "The selected project's current status is <Connected Single Attribute Widget> and is owned by <Connected Single Attribute Widget>."
+
+---
+
+## Configuration Concepts
+
+### Essential Configuration Parameters
+
+| Parameter | Type | Default | Purpose |
+|-----------|------|---------|---------|
+| **SELECTION_WIDGET_ID** | String | (required) | References the ID of the connected table/selection widget |
+| **ATTRIBUTE_NAME** | String | (required) | Internal name of the attribute to display |
+| **WITH_VALUE** | Boolean | `true` | Show the attribute value |
+| **WITH_LABEL** | Boolean | `false` | Show the attribute label |
+| **IN_PLACE_EDITING** | Boolean | `false` | Enable inline editing |
+| **SINGLE_COLUMN** | Boolean | `false` | Use single-column layout (label above value) |
+| **RELOAD_AFTER_CHANGE** | Boolean | `false` | Reload connected widgets after edit |
+| **SHOW_ATTRIBUTE_SCRIPT** | Script | (optional) | cplaceJS for conditional visibility |
+| **USE_NEW_FRONTEND** | Boolean | `false` | Use Angular component rendering |
+
+### Configuration Modes
+
+#### Mode 1: Value Only (Minimal Display)
+- `WITH_VALUE`: `true`
+- `WITH_LABEL`: `false`
+- `IN_PLACE_EDITING`: `false`
+
+**Result**: Displays only the attribute value inline, useful for embedding in sentences.
+
+#### Mode 2: Editable with Label
+- `WITH_VALUE`: `true`
+- `WITH_LABEL`: `true`
+- `IN_PLACE_EDITING`: `true`
+- `SINGLE_COLUMN`: `false`
+
+**Result**: Two-column layout with label and editable value, standard form field appearance.
+
+#### Mode 3: Label Only
+- `WITH_VALUE`: `false`
+- `WITH_LABEL`: `true`
+
+**Result**: Shows only the attribute label, useful for headers or dynamic labels.
+
+#### Mode 4: Stacked Layout
+- `WITH_VALUE`: `true`
+- `WITH_LABEL`: `true`
+- `SINGLE_COLUMN`: `true`
+
+**Result**: Label displayed above value, better for narrow layouts or mobile views.
+
+### Special Configuration: Embedded in ConnectedAttributesGroup
+
+When embedded inside a `ConnectedAttributesGroupWidgetDefinition`:
+- `SELECTION_WIDGET_ID` should be set to `"<empty>"` (the parent widget manages the connection)
+- Parent widget's `SINGLE_COLUMN` setting overrides individual widget settings
+- Multiple single attribute widgets share the same entity selection from the parent
+
+---
+
+## Widget Relationships
+
+### Parent Widgets
+
+#### ConnectedAttributesGroupWidgetDefinition
+**Relationship**: Can be embedded within
+**Purpose**: Groups multiple connected single attribute widgets under a single table selection
+**Widget ID**: `cf.cplace.platform.connectedAttributesGroup`
+
+**Special Behavior**:
+- Parent widget controls the table selection for all embedded single attribute widgets
+- Parent widget's layout settings (like `SINGLE_COLUMN`) can override individual widget settings
+- Provides a cohesive grouped attributes interface
+
+### Connected Widgets (Data Sources)
+
+The widget connects to any widget that implements `ISingleEntitySelectionProducer`:
+
+#### TableWidgetDefinition (Embedded Search as Table)
+**Relationship**: Primary data source
+**Widget ID**: `cf.platform.embeddedSearchAsTable`
+**Provides**: Single entity selection from table rows
+
+**How It Works**:
+1. User clicks on a table row
+2. Table widget emits a `SingleEntitySelection` event
+3. Connected single attribute widgets receive the selected entity UID
+4. Widgets fetch and display the specified attribute from that entity
+
+#### Other Selection Producers
+Any widget implementing `ISingleEntitySelectionProducer` can act as a data source, enabling flexible connection patterns.
+
+### Related Widgets
+
+#### SingleAttributeWidgetDefinition
+**Widget ID**: `cf.platform.singleAttribute`
+**Relationship**: Non-connected variant
+**Difference**: Displays an attribute from a fixed entity (configured at design time), not dynamically selected
+
+**Use Case Comparison**:
+- **SingleAttributeWidget**: "Show the name of Page X" (fixed entity)
+- **ConnectedSingleAttributeWidget**: "Show the name of the selected page" (dynamic entity)
+
+#### ConnectedAttributesGroupWidgetDefinition
+**Widget ID**: `cf.cplace.platform.connectedAttributesGroup`
+**Relationship**: Container for multiple connected single attribute widgets
+**Shared Pattern**: Both use `ISingleEntitySelectionProducer` interface
+
+---
+
+## Technical Architecture
+
+### Interface Implementation
+
+```java
+@Override
+public Set<Class<? extends IConnectedWidgetProducer>> getSupportedConnectedWidgetProducerTypes() {
+    return Set.of(ISingleEntitySelectionProducer.class);
+}
+```
+
+The widget declares support for `ISingleEntitySelectionProducer`, enabling the platform to:
+- Validate compatible connections at configuration time
+- Route selection events from connected widgets
+- Provide enumeration of valid selection widget IDs
+
+### State Management
+
+#### Frontend State (Angular)
+When `USE_NEW_FRONTEND` is enabled, the widget state is serialized to `SingleAttributeWidgetState`:
+
+```java
+public record SingleAttributeWidgetState(
+    @Nullable String targetEntityUid,           // null initially (set by selection)
+    String embeddingEntityUid,                   // Page containing the widget
+    String widgetId,                             // Widget's unique ID
+    @Nullable String feature,                    // Attribute name
+    boolean showValue,                           // Display value
+    boolean showLabel,                           // Display label
+    @Nullable String alternativeLabel,           // Custom label (not used here)
+    boolean readonly,                            // !IN_PLACE_EDITING
+    boolean reloadGroupedAttributesWidgetOnChange, // RELOAD_AFTER_CHANGE
+    boolean singleColumn,                        // Layout mode
+    @Nullable String parentWidgetId,             // Parent group widget ID
+    @Nullable String invalidConfigurationMessage, // Error if config invalid
+    boolean showAttribute,                       // Result of SHOW_ATTRIBUTE_SCRIPT
+    @Nullable String connectedWidgetId           // SELECTION_WIDGET_ID
+)
+```
+
+**Key Point**: `targetEntityUid` is `null` for connected widgets because the target changes based on user selection, not configuration.
+
+### Event Flow
+
+1. **Selection Event**: User selects row in connected table widget
+2. **Event Propagation**: Table widget emits `SingleEntitySelection` with entity UID
+3. **Widget Update**: Connected single attribute widgets receive the selection
+4. **Data Fetch**: Widget fetches the specified attribute from the selected entity
+5. **Display Update**: Widget renders the attribute value/label based on configuration
+6. **Edit Event** (if `IN_PLACE_EDITING` enabled): User modifies value
+7. **Save**: Value persisted to entity
+8. **Reload Event** (if `RELOAD_AFTER_CHANGE`): Trigger connected widgets to refresh
+
+### Conditional Visibility
+
+The `SHOW_ATTRIBUTE_SCRIPT` provides dynamic control over attribute visibility:
+
+**Script Context**:
+- `embeddingPage`: The page containing the widget
+- `targetEntity`: The currently selected entity
+
+**Script Evaluation**:
+- Evaluated in a sandboxed cplaceJS engine
+- Allowed types: `Search`, `Filters`
+- Returns truthy value to show, falsy to hide
+
+**Example Use Cases**:
+- Hide sensitive fields for certain user roles
+- Show fields only when entity is in specific status
+- Display conditional help text based on entity properties
+
+---
+
+## Embedding Constraints
+
+### Where Can This Widget Be Embedded?
+
+1. **Rich String Content** (page content, document fields, etc.)
+   - Use `RichStringUtilities.embeddedWidgetInsertion()` to embed
+   - Widget displays inline or as block depending on configuration
+
+2. **Inside ConnectedAttributesGroupWidgetDefinition**
+   - Special embedding mode with `"<empty>"` selection widget ID
+   - Parent widget manages the table connection
+
+### Where Can It NOT Be Embedded?
+
+- Cannot be standalone on a page (must be embedded)
+- Cannot be embedded in arbitrary widgets (only in `ConnectedAttributesGroupWidgetDefinition`)
+
+**Code Reference** (ConnectedSingleAttributeWidgetDefinition.java:89-97):
+```java
+@Override
+public void checkEmbeddableIn(PersistentEntity entity, WidgetEmbedding embedding)
+    throws NotEmbeddableException {
+    checkIsEmbeddedInRichStringOrInWidget(entity, embedding);
+}
+
+@Override
+public boolean canBeEmbeddedInsideWidgetOfType(
+    Class<? extends WidgetDefinition> enclosingWidgetDefinitionClass) {
+    return ConnectedAttributesGroupWidgetDefinition.class.equals(enclosingWidgetDefinitionClass);
+}
+```
+
+---
+
+## Configuration Validation
+
+### Configuration Completeness Rules
+
+A widget configuration is considered **complete** when:
+
+1. All required parameters are set:
+   - `SELECTION_WIDGET_ID` is provided
+   - `ATTRIBUTE_NAME` is specified
+
+2. At least one display option is enabled:
+   - `WITH_VALUE` is `true` OR `WITH_LABEL` is `true`
+
+**Code Reference** (ConnectedSingleAttributeWidgetDefinition.java:256-261):
+```java
+@Override
+public boolean isConfigurationComplete(WidgetConfiguration conf,
+                                      WidgetSubstitutionParameters params) {
+    return (
+        super.isConfigurationComplete(conf, params) &&
+        (conf.getWithDefault(CONNECTED_SINGLE_ATTRIBUTE.WITH_VALUE) ||
+         conf.getWithDefault(CONNECTED_SINGLE_ATTRIBUTE.WITH_LABEL))
+    );
+}
+```
+
+---
+
+## Comparison with Related Widgets
+
+| Aspect | ConnectedSingleAttribute | SingleAttribute | ConnectedAttributesGroup |
+|--------|-------------------------|-----------------|-------------------------|
+| **Entity Source** | Dynamic (selected in table) | Fixed (configured) | Dynamic (selected in table) |
+| **Attributes Shown** | One | One | Multiple (contains singles) |
+| **Primary Use** | Master-detail views | Static displays | Grouped detail forms |
+| **In-place Editing** | Yes | Yes | Via embedded singles |
+| **Connection Required** | Yes (table widget) | No | Yes (table widget) |
+| **Embedding** | Rich text or group | Rich text or group | Page layouts |
+
+---
+
+## Code References
+
+### Primary Files
+- **Widget Definition**: `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/ConnectedSingleAttributeWidgetDefinition.java`
+- **Configuration Type**: `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/templating/WidgetTypes.java:994-1089`
+- **State DTO**: `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/rest/shared/dto/widget/attributes/SingleAttributeWidgetState.java`
+- **Handler**: `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/handler/functions/ConnectedSingleAttributeHandler.java`
+
+### Supporting Files
+- **Interface**: `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/rest/shared/widget/ISingleEntitySelectionProducer.java`
+- **Producer**: `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/rest/shared/widget/SingleEntitySelectionProducer.java`
+- **Parent Widget**: `cf.cplace.platform/src/main/java/cf/cplace/platform/frontend/widgets/ConnectedAttributesGroupWidgetDefinition.java`
+- **Unit Test**: `cf.cplace.platform/src/test/java/cf/cplace/platform/frontend/widgets/TestConnectedSingleAttributeWidget.java`
+
+### Related Documentation
+- Comprehensive parameter research: `main/specs/2026-01-11_connected-single-attribute-widget-parameters/research.md`
+
+---
+
+## Summary for Documentation
+
+### Short Description (1-2 sentences)
+
+The Connected Single Attribute Widget displays a single attribute value from an entity selected in a connected table or selection widget, providing dynamic attribute visualization and optional in-place editing based on user selections.
+
+### Conceptual Overview
+
+This widget implements the master-detail pattern by showing specific attribute values from entities selected in related table widgets. Unlike the standard Single Attribute Widget which displays attributes from a fixed entity, this widget updates dynamically as users select different rows in a connected table, making it ideal for building interactive detail panels, quick edit interfaces, and responsive data exploration experiences.
+
+The widget offers flexible display modes (value only, label only, or both), supports in-place editing for quick updates, and can conditionally show or hide based on business logic through cplaceJS scripting. It can be embedded directly in rich text content for inline displays or grouped with other connected single attribute widgets using the Connected Attributes Group Widget for structured form-like interfaces.
+
+---
+
+## Research Notes
+
+### Key Insights
+
+1. **"Connected" Means Dynamic Entity**: The term "connected" refers to the dynamic entity selection mechanism, not a fixed relationship. The widget always starts with `targetEntityUid = null` and gets its entity from user selections.
+
+2. **Dual Frontend Support**: The widget bridges legacy and modern architectures by supporting both HTML template rendering and Angular component rendering via the `USE_NEW_FRONTEND` flag.
+
+3. **Parent Override Pattern**: When embedded in `ConnectedAttributesGroupWidgetDefinition`, certain settings like `SINGLE_COLUMN` can be overridden by the parent, ensuring consistent grouped layout.
+
+4. **Security Consideration**: The `SHOW_ATTRIBUTE_SCRIPT` runs in a sandboxed environment with limited bindings, preventing arbitrary code execution while allowing conditional logic.
+
+5. **Configuration Symmetry**: The configuration mirrors `SingleAttributeWidgetDefinition` closely, with the key difference being the addition of `SELECTION_WIDGET_ID` for the connection.
+
+### Potential Use Case Extensions
+
+- **Cascading Connections**: Multiple connected tables feeding into different single attribute widgets at different detail levels
+- **Dashboard Panels**: Using connected single attributes to create KPI displays based on filtered table selections
+- **Approval Workflows**: Quick status updates via connected editable attributes in task management interfaces
+- **Data Quality Tools**: Inline correction of attribute values identified in validation tables
+
+---
+
+**Research Completed**: 2026-01-16
+**Confidence Level**: High (based on source code analysis, existing research, and test files)