@cplace/test-mcp-server 1.0.0 → 1.1.0

package/dist/widget-specifications/cf.platform.incomingLinks/_overview.md

@@ -0,0 +1,83 @@
+## Overview
+
+If available, this widget displays incoming links from other cplace pages. The Incoming Links widget displays all pages that reference the current page through hyperlinks in rich text fields (like description fields, comments, or other formatted text content). It provides "backlinks" functionality similar to wiki systems, helping users understand which other pages reference the current page and enabling reverse navigation through interconnected content.
+
+The widget automatically scans hyperlinks in rich text content and groups incoming links by source page type and attribute, showing the count of links from each source.
+
+## Use Cases
+
+### Content Navigation & Discovery
+Enables users to see all pages that reference the current page, helping discover related content that might not be connected through formal relationships. Supports reverse navigation from a page back to its referencing pages, creating a graph-like navigation experience through interconnected content.
+
+### Knowledge Management & Wiki-Style Usage
+Provides "What links here" functionality similar to wikis, supporting organic content organization through hyperlinks. Ideal for knowledge bases and documentation pages where discoverability through natural hyperlinks is important.
+
+### Impact Analysis
+Before deleting or archiving a page, users can see what other pages link to it. Helps understand the reach and importance of a page based on how many places reference it and identifies dependencies between content items.
+
+### Relationship Visualization
+Complements outgoing links by showing the "other side" of hyperlink relationships. Provides context about how a page fits into the broader information architecture and helps identify pages that serve as hubs with many incoming links.
+
+### Master Data & Reference Pages
+Particularly useful on pages that are frequently referenced by other content, such as products, projects, requirements, or other master data entities that other pages naturally reference in their descriptions and notes.
+
+## Design Considerations
+
+### When to Use This Widget
+
+- On pages that are frequently referenced by other content through hyperlinks
+- In knowledge management scenarios where discoverability through natural linking is important
+- For master data pages (products, projects, requirements) that other pages reference in descriptions
+- When tracking informal content relationships created through natural hyperlinks
+- To complement structured relationships with organic linking patterns
+
+### When NOT to Use This Widget
+
+- If your content model relies primarily on formal reference attributes (use Incoming References widget instead)
+- On pages where hyperlinks in rich text fields are rarely used
+- If the widget consistently shows no results (indicating no incoming links exist)
+- When only structured, schema-defined relationships are needed
+
+## Operating Behavior
+
+### Automatic Detection
+The widget requires no manual configuration and automatically scans `RichStringLink` entities where the current page is the target. It only displays links that the current user has permission to see, respecting cplace's security model.
+
+### Display Format
+Links are grouped by source page type and the attribute name where the link appears. Each group shows:
+- Source entity type with the attribute name containing the link
+- Workspace/space information if the link comes from a different space
+- Count of incoming links for each group
+
+Example display:
+```
+Project as "Related Projects" (3)
+Task as "Description" in Product Space (5)
+Meeting Notes (2)
+```
+
+### Visibility Rules
+- Shows "No incoming links found" message if no links exist
+- Only displays links from pages the user can access
+- Indicates when links come from different workspaces
+- Respects attribute restrictions based on security extensions
+
+## Related Widgets
+
+### Incoming References Widget (`cf.platform.incomingReferences`)
+Tracks formal reference attributes rather than hyperlinks. Use when you need to display structured relationships defined through reference fields in your data model. The Incoming Links widget and Incoming References widget serve complementary purposes and can coexist on the same page.
+
+**Key Differences**:
+- **Incoming Links**: Tracks hyperlinks in rich text content (informal, user-created)
+- **Incoming References**: Tracks formal reference attributes (structured, schema-defined)
+
+## Common Pitfalls
+
+### Expecting Formal References
+This widget only shows hyperlinks created in rich text fields, not formal reference attributes. If you need to display structured relationships, use the Incoming References widget instead.
+
+### Empty Widget on New Pages
+Newly created pages will show no incoming links until other pages create hyperlinks pointing to them. This is normal behavior and the widget will populate as content is created.
+
+### Confusion with Bidirectional Relationships
+This widget shows who links TO the current page (incoming), not who the current page links to (outgoing). The directionality is from other pages pointing at this page.

package/dist/widget-specifications/cf.platform.incomingLinks/_summary.md

@@ -0,0 +1 @@
+If available, displays incoming links from other cplace pages through hyperlinks in rich text fields. Enables wiki-style navigation and relationship discovery for knowledge bases, documentation pages, and impact analysis.

package/dist/widget-specifications/cf.platform.incomingReferences/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.incomingReferences",
+  "Description": "{\"en\":\"If available, this widget displays references associated with other cplace pages.\",\"de\":\"Falls vorhanden, werden zugehörige Referenzen mit anderen cplace Seiten angezeigt.\"}",
+  "Localized Name": "{\"en\":\"Incoming References\",\"de\":\"Eingehende Referenzen\"}",
+  "Icon": "fa-external-link fa-rotate-90",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Incoming References' widget lists all references to other cplace pages.</p>\n\n<p>&nbsp;</p>"
+}

package/dist/widget-specifications/cf.platform.incomingReferences/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "references",
+    "list",
+    "read-only",
+    "detail-view",
+    "navigation"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.incomingReferences/_overview.md

@@ -0,0 +1,48 @@
+## Overview
+
+If available, this widget displays references associated with other cplace pages. The Incoming References widget provides a "backlinks" view showing where the current entity is referenced in the data model through structured reference attributes. It queries the database to identify all custom reference relationships pointing to the entity and presents them grouped by source type, attribute name, and workspace. The widget distinguishes between references with actual values (entities currently referencing this one) and available reference types without values (configured but unused references).
+
+## Use Cases
+
+- **Dependency Discovery**: Understand what depends on an entity before making changes or deletions (e.g., view a Product entity and see which Projects reference it)
+- **Impact Analysis**: Review incoming references before performing destructive operations to prevent broken references and data inconsistencies
+- **Bidirectional Relationship Navigation**: Navigate from a referenced entity back to referring entities without manual searching
+- **Data Model Analysis**: Visualize actual usage of reference attributes in the system and understand relationship patterns
+- **Cross-Space Visibility**: Identify and understand cross-workspace dependencies when entities in one workspace are referenced by entities in other workspaces
+
+## Design Considerations
+
+### When to Use This Widget
+
+Use this widget when:
+- Your data model includes formal reference attributes between entity types
+- You need to track which entities reference a particular entity
+- You want to provide users with impact analysis capabilities
+- You need bidirectional relationship navigation
+- Your content model has complex interdependencies
+
+Do NOT use this widget when:
+- You only need to display outgoing references (use attribute widgets instead)
+- You want to track wiki-style hyperlinks in rich text (use `cf.platform.incomingLinks` instead)
+- The entity type is Person (use the dedicated "myElements" widget instead)
+
+### Display Organization
+
+The widget automatically organizes references into two sections:
+- **With Values** (expanded by default): Shows reference types that have at least one referring entity
+- **Without Values** (collapsed by default): Shows configured reference types with zero referring entities, useful for discovering potential relationship opportunities
+
+### Typical Layout Patterns
+
+**Basic Relationship Discovery**: Place the widget after core attributes to show who references the current entity.
+
+**Complete Relationship View**: Combine with `cf.platform.incomingLinks` to show both formal data model relationships and informal wiki-style links.
+
+**Impact Analysis Dashboard**: Pair with embedded search widgets and connected charts to visualize relationship patterns.
+
+## Related Patterns
+
+- `cf.platform.incomingLinks` - For tracking informal rich text hyperlinks rather than formal reference attributes. Use both widgets together for complete relationship visibility.
+- `cf.platform.singleAttribute` / `cf.platform.connectedSingleAttribute` - For displaying outgoing reference attributes (what this entity references)
+- `cf.platform.embeddedSearchAsList` / `cf.platform.embeddedSearchAsTable` - For displaying filtered entity lists based on relationships
+- `cf.platform.connectedMatrix` - For visualizing two-dimensional relationships between entity types

package/dist/widget-specifications/cf.platform.incomingReferences/_summary.md

@@ -0,0 +1 @@
+If available, displays references associated with other cplace pages through formal reference attributes, organized by source type, attribute, and workspace. Use for dependency discovery, impact analysis, and bidirectional relationship navigation.

package/dist/widget-specifications/cf.platform.makeover.attributes/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.makeover.attributes",
+  "Description": "{\"en\":\"Displays all attributes of the page and allows editing.\",\"de\":\"Zeigt alle Attribute der Seite an und erlaubt ihre Bearbeitung.\"}",
+  "Localized Name": "{\"en\":\"Attributes (new)\",\"de\":\"Attribute (neu)\"}",
+  "Icon": "fa-list-alt",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.platform.makeover.attributes/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "attributes",
+    "form",
+    "inline-edit",
+    "detail-view"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.makeover.attributes/_overview.md

@@ -0,0 +1,48 @@
+## Overview
+
+Displays all attributes of the page and allows editing. The Makeover Attributes widget is a redesigned version of the original `cf.platform.attributes` widget, providing the same core functionality with enhanced visual styling and improved user experience. It displays all attributes of a page and allows inline editing, making it the primary widget for viewing and modifying entity properties.
+
+This widget is part of the UIX (User Interface eXperience) modernization initiative and requires a feature flag to be enabled.
+
+## Use Cases
+
+### Entity Detail Pages
+Embed the widget on pages to show all properties of an entity (projects, tasks, documents, etc.) in a comprehensive, editable view.
+
+### Inline Editing Workflows
+Allow users to modify entity attributes directly within the page view without navigating to separate forms.
+
+### Data Review
+Provide a complete view of all entity data in one location for quick review and verification.
+
+## Design Considerations
+
+### Feature Flag Requirement
+This widget requires the feature flag `cplace.uix.newAttributesWidgetEnabled` to be set to `true`. When disabled, the widget cannot be embedded and will not appear in widget selection.
+
+### Entity Type Restriction
+The widget can only be embedded in `CustomEntity` page types. It cannot be used with system entities or type definitions.
+
+### Single Instance Rule
+Only one attributes widget (either this or the original) can be embedded per page to prevent duplicate attribute displays.
+
+### Migration Strategy
+The original `cf.platform.attributes` widget remains available, ensuring backward compatibility. Organizations can migrate to the makeover version when ready by enabling the feature flag.
+
+## When to Choose This Widget
+
+**Choose the makeover version when:**
+- You want the modern, improved UI for displaying attributes
+- The feature flag is enabled in your cplace instance
+- You're building new pages and want to use the latest UI components
+
+**Choose the original widget when:**
+- The makeover version is not enabled
+- You need consistency with existing pages using the old design
+- The feature flag is not yet available in your cplace version
+
+## Alternatives
+
+- `cf.platform.attributes` - The original attributes widget with classic styling
+- `cf.platform.attributesGroup` - Displays attributes organized into groups
+- `cf.platform.singleAttribute` - Displays a single attribute instead of all attributes

package/dist/widget-specifications/cf.platform.makeover.attributes/_summary.md

@@ -0,0 +1 @@
+Displays all attributes of the page and allows editing. A modernized version of the attributes widget with enhanced styling and improved UI/UX for inline viewing and editing of page properties.

package/dist/widget-specifications/cf.platform.modificationInfo/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.modificationInfo",
+  "Description": "{\"de\":\"Zeigt Nutzer und Zeitpunkt der letzten Änderung an der Seite.\",\"en\":\"Shows users and the time of the last change made to the page.\"}",
+  "Localized Name": "{\"en\":\"Version Info\",\"de\":\"Versionsinformation\"}",
+  "Icon": "fa-info",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Version Info' widget displays the name of the user who last modified the current cplace page and the date on which this modification was made.</p>"
+}

package/dist/widget-specifications/cf.platform.modificationInfo/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "metadata",
+    "read-only",
+    "detail-view",
+    "collaboration"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.modificationInfo/_overview.md

@@ -0,0 +1,27 @@
+## Overview
+
+Shows users and the time of the last change made to the page. The Modification Info widget displays version tracking metadata for pages, providing transparency about content changes and enabling users to track page activity without requiring any configuration.
+
+The widget automatically pulls data from the platform's built-in modification tracking system, displaying the timestamp and a clickable link to the modifier's profile.
+
+## Use Cases
+
+- **Content Transparency**: Show when documentation, policies, or process descriptions were last updated so users can assess currency and relevance
+- **Collaboration Tracking**: Help teams identify who made recent changes and when the page was last touched
+- **Audit Trail**: Provide traceability for tracking page ownership, verifying when critical information was updated, and monitoring activity
+- **Content Management**: Enable administrators to identify stale content and monitor which team members are actively maintaining pages
+
+## Design Considerations
+
+This widget is designed to be unobtrusive:
+- Renders without a frame or padding
+- Typically placed at the bottom of page layouts (footer area) or in metadata sections
+- Only one instance allowed per page (enforced by the platform)
+- No configuration options - the display is standardized and automatic
+
+The minimalist design allows flexible positioning without visual clutter, making it ideal for footer areas or compact layout sections.
+
+## Related Patterns
+
+- **Attribute History Widget** (`cf.platform.attributeHistory`): Use together when you need both page-level modification tracking AND detailed attribute-level change history. Attribute History tracks changes to specific attributes over time, while Modification Info shows overall page-level last modification.
+- **Comments Widget**: Related collaboration widget for explicit user feedback and discussion, whereas Modification Info passively tracks system-generated metadata.

package/dist/widget-specifications/cf.platform.modificationInfo/_summary.md

@@ -0,0 +1 @@
+Shows users and the time of the last change made to the page, providing transparency about when and by whom page content was updated.

package/dist/widget-specifications/cf.platform.myElements/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.myElements",
+  "Description": "{\"en\":\"Widget available only on the personal dashboard that displays all pages that have a relation to the current user.\",\"de\":\"Nur auf dem persönlichen Dashboard verfügbares Widget, das alle Seiten anzeigt, die eine Relation zum aktuellen Nutzer haben.\"}",
+  "Localized Name": "{\"en\":\"My Elements\",\"de\":\"Meine Elemente\"}",
+  "Icon": "fa-user",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>// The 'My Elements' widget ...</p>"
+}

package/dist/widget-specifications/cf.platform.myElements/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "references",
+    "list",
+    "read-only",
+    "detail-view",
+    "dashboard"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.myElements/_overview.md

@@ -0,0 +1,69 @@
+## Overview
+
+Widget available only on the personal dashboard that displays all pages that have a relation to the current user. The My Elements widget displays incoming references for Person entities, showing all cplace pages that reference or are associated with a specific user. It is the Person-specific variant of the Incoming References widget (`cf.platform.incomingReferences`), designed exclusively for Person pages and type definitions that apply to Person.
+
+This widget automatically scans and presents all pages where the Person is referenced through formal reference attributes, providing users with a complete picture of their involvement across the system. The standard Incoming References widget explicitly forbids embedding in Person pages with the message "Not embeddable in person; use myElements widget instead."
+
+## Use Cases
+
+### Personal Dashboard
+Display all pages and entities that reference a specific user on their profile page, giving users immediate visibility into their associations.
+
+### User Activity Overview
+Show projects, tasks, documents, and other entities associated with a person, helping them understand their scope of involvement.
+
+### Accountability Tracking
+Identify all items where a person is mentioned, assigned, or referenced, useful for workload assessment and responsibility mapping.
+
+### Relationship Visualization
+Help users understand their connections across the cplace system, revealing how they relate to various entities and workflows.
+
+## Design Considerations
+
+### When to Use This Widget
+
+- On Person profile pages to show user involvement across the system
+- On type definitions that apply to Person entities
+- When building personal dashboards or user-centric views
+- To provide accountability and relationship visibility for users
+- As the standard (and only) way to display incoming references on Person entities
+
+### When NOT to Use This Widget
+
+- On non-Person entities (the widget enforces Person entity restrictions)
+- If you need to customize how references are displayed (this widget has no configuration options)
+- When you need to show hyperlinks from rich text fields rather than formal reference attributes (use Incoming Links widget)
+
+### Technical Constraints
+
+- **Single Instance Only**: Cannot be embedded multiple times on the same Person page
+- **Person Entities Only**: Enforced at the widget definition level; only embeddable in Person or applicable type definitions
+- **No Configuration**: Works out-of-the-box without user-configurable options
+- **Read-Only**: Displays references but does not provide editing capabilities
+- **Widget Embedding Only**: Cannot be embedded in other embedding contexts
+
+## Related Widgets
+
+### Incoming References Widget (`cf.platform.incomingReferences`)
+The standard incoming references widget for non-Person entities. It explicitly prohibits embedding in Person pages. Both widgets share the same underlying rendering mechanism (`incomingReferences()` template function).
+
+**Key Differences**:
+- **My Elements**: Person-specific, no configuration options
+- **Incoming References**: General-purpose for non-Person entities, more configuration options available
+
+### Incoming Links Widget (`cf.platform.incomingLinks`)
+Tracks hyperlinks in rich text content rather than formal reference attributes. Can be used alongside My Elements on a Person page to show both types of relationships - formal references (My Elements) and informal hyperlinks (Incoming Links).
+
+### Wiki Widget (`cf.platform.wiki`)
+Often used alongside My Elements on Person pages to display descriptive content. While My Elements shows references, Wiki provides rich text content.
+
+## Common Pitfalls
+
+### Using Incoming References Instead
+The standard Incoming References widget explicitly blocks embedding on Person pages. If you need to show incoming references for a Person, you must use My Elements.
+
+### Expecting Configuration Options
+This widget has no configurable attributes. It automatically displays all incoming references to the Person entity without filtering or customization.
+
+### Multiple Widget Instances
+Attempting to add the widget multiple times to the same page will fail. The widget enforces single-instance embedding.

package/dist/widget-specifications/cf.platform.myElements/_summary.md

@@ -0,0 +1 @@
+Widget available only on the personal dashboard that displays all pages that have a relation to the current user. Use on Person profile pages as the Person-specific variant of the Incoming References widget.

package/dist/widget-specifications/cf.platform.richString/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.richString",
+  "Description": "{\"en\":\"Widget for entering formatted text with a title.\",\"de\":\"Widget zur Eingabe von formatiertem Text mit Titel.\"}",
+  "Localized Name": "{\"en\":\"Text\",\"de\":\"Text\"}",
+  "Icon": "fa-font",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Text' widget provides a title and a framed text box for entering formatted text in the layout view.</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Title*: Bilingual text.</p>\n\n<p>// * Content:</p>\n\n<p>&nbsp;</p>\n\n<p>&nbsp;</p>"
+}

package/dist/widget-specifications/cf.platform.richString/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "rich-text",
+    "read-only",
+    "searchable",
+    "detail-view",
+    "collaboration"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.richString/_overview.md

@@ -0,0 +1,43 @@
+## Overview
+
+Widget for entering formatted text with a title. The Rich String widget provides a way to add formatted HTML content to pages within a titled frame. Unlike attribute-based widgets that display data from entities, this widget stores its content directly in the widget configuration, making it ideal for static informational content that doesn't need to update dynamically with data changes.
+
+The widget supports the full range of HTML formatting options including headings, lists, links, tables, and embedded images, while ensuring security through automatic content sanitization.
+
+## Use Cases
+
+- **Documentation and Instructions**: Add formatted help sections, step-by-step guides, or explanatory content with headings and lists
+- **Announcements and Notices**: Display important messages with highlighted text, bold formatting, or colored content
+- **Rich Content Pages**: Build knowledge base articles, landing pages, or onboarding pages with structured content
+- **Meeting Notes and Summaries**: Capture formatted minutes with bullet points, action items, and decisions
+- **Embedded Links and References**: Create navigation sections or resource lists with hyperlinks to internal pages or external URLs
+- **Formatted Reports**: Present status summaries or executive overviews with rich formatting for clarity
+
+## Design Considerations
+
+### When to Use This Widget
+
+Use the Rich String widget when you need:
+- Static text content that doesn't change based on data
+- Formatted content with titles in a consistent framed presentation
+- Content that should be searchable via fulltext search
+- Multi-language title support (content itself is not localized)
+
+### When to Use Alternative Widgets
+
+- **Displaying entity attribute values**: Use `cf.platform.customRichStringAttribute` instead, which binds to a rich string attribute on an entity
+- **Frameless presentation**: Consider other approaches if you don't want the widget frame
+- **Dynamic content**: For content that should update when data changes, use attribute-display widgets
+
+### Content Limitations
+
+- All content is automatically sanitized for security (XSS protection)
+- Custom scripts and some HTML elements/attributes are stripped
+- Very large content may impact page load performance
+- Content is not versioned - no built-in history of changes
+
+## Related Patterns
+
+- **cf.platform.customRichStringAttribute** - Displays a rich string attribute from an entity (data-bound content)
+- **cf.platform.singleAttribute** - Displays any single attribute value from the current page
+- **cf.cplace.pageViewHeadline.widget** - Alternative for simple titled text sections

package/dist/widget-specifications/cf.platform.richString/_summary.md

@@ -0,0 +1 @@
+Widget for entering formatted text with a title. Use for static content sections like documentation, announcements, instructions, or meeting notes in a framed widget container.

package/dist/widget-specifications/cf.platform.singleAttribute/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.singleAttribute",
+  "Description": "{\"de\":\"Ausgabe des Werts eines Attributs.\",\"en\":\"Output of the value of an attribute.\"}",
+  "Localized Name": "{\"en\":\"Single Attribute of a page\",\"de\":\"Einzelnes Attribut einer Seite\"}",
+  "Icon": "fa-pen-square",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details </strong></p>\n\n<p>The 'Single Attribute on a Page' widget displays the information that is available about an individual attribute.</p>\n\n<p>This widget cannot be used on its own but has to be embedded in a 'Grouped Attributes of a Page' widget (ToD: Add link) or in a 'Richstring' widget (ToDo:&nbsp; Add link).</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Attribute name: List of available custom and system attributes.<br>\n// * Show attribute value*: True/false.<br>\n// * Show attribute name*: True/false.<br>\n// * Alternative attribute label: Bilingual text.<br>\n// * Allow in-place editing*: True/false.<br>\n// * Reload grouped widget after attribute change*: True/false.<br>\n// * Show attribute: cplaceJS script. The script entered here determines if the attribute is to be displayed.</p>\n\n<p><strong>Key Benefits</strong></p>\n\n<p><strong>Examples</strong></p>\n\n<p>&nbsp;</p>"
+}

package/dist/widget-specifications/cf.platform.singleAttribute/_implementation.md

@@ -0,0 +1,18 @@
+**Configuration Modes**:
+- **Value only** (`withValue=true`, `withLabel=false`): Shows attribute value inline
+- **Value + Label** (`withValue=true`, `withLabel=true`): Shows both label and value (supports two layouts via `singleColumn`)
+
+**Typical Configuration Workflow**:
+1. Set `entity` to the page whose attribute should be displayed
+   - Leave empty for current page
+   - Use `"<empty>"` when embedded inside a `cf.platform.attributesGroup` widget
+2. Set `quotedAttributeName` to the attribute to display
+3. Configure display options:
+   - `withValue` and `withLabel` (at least one must be true)
+   - `singleColumn` for layout (only relevant when both value and label are shown)
+   - `inPlaceEditing` to allow inline editing
+4. Optional: Set `localizedAlternativeLabel` for a custom label
+5. Optional: Set `showAttributeScript` for conditional visibility
+6. Optional: Set `reloadAfterChange` to refresh parent widgets after edits
+
+**Embedding in AttributesGroup**: When this widget is embedded inside a `cf.platform.attributesGroup` widget, the following parameters are controlled by the parent widget: `entity`, `useParent`, `singleColumn`, `useNewFrontend`.

package/dist/widget-specifications/cf.platform.singleAttribute/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "attributes",
+    "form",
+    "inline-edit",
+    "detail-view",
+    "low-code"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.singleAttribute/_overview.md

@@ -0,0 +1,83 @@
+## Overview
+
+Output of the value of an attribute. The Single Attribute widget displays one specific attribute from a page with fine-grained control over its presentation. Unlike the full Attributes widget that shows all attributes, this widget focuses on a single attribute with maximum configuration flexibility, including custom labels, in-place editing, and conditional visibility based on business logic.
+
+## Use Cases
+
+### Custom Attribute Layout
+
+Display specific attributes in a custom page layout without showing all attributes. Create summary sections at the top of pages showing only critical attributes (status, priority, owner) while keeping detailed attributes in separate sections.
+
+### Quick Edit Interface
+
+Enable rapid editing of specific attributes without opening full edit forms. Allow users to quickly update task status or priority directly from a page view, reducing clicks and page transitions.
+
+### Read-Only Display with Alternative Labels
+
+Show attribute values with custom, user-friendly labels instead of technical attribute names. Display a technical attribute like an internal code with a friendlier label for business users, with multi-language support.
+
+### Conditional Attribute Display
+
+Show or hide attributes based on dynamic conditions using cplaceJS scripts. Display "Rejection Reason" only when a request's status is "Rejected", or show "Approval Date" only for approved items.
+
+### Parent Page Attribute Display
+
+Display attributes from a parent page in hierarchical structures. Show project-level attributes on task pages without duplicating data across the hierarchy.
+
+### Value-Only Display
+
+Show attribute values without labels in compact layouts. Display status badges, icons, or values in dense UIs where labels would be redundant.
+
+### Building Block for Complex Forms
+
+Use as a building block within Attributes Group widgets to create custom multi-column forms with precise attribute placement and mixed widget types.
+
+## Design Considerations
+
+### Display Mode Options
+
+The widget supports three primary display modes:
+- **Label and Value**: Standard display showing both the attribute name and its current value
+- **Value Only**: Clean rendering without labels for compact layouts
+- **Label Only**: Show just the attribute name without its value
+
+At least one of label or value must be shown - the widget validates this requirement.
+
+### In-Place Editing
+
+When enabled, in-place editing allows users to modify attribute values directly in the display without form submission. Consider enabling the reload option if other widgets on the page depend on the edited attribute's value.
+
+### Conditional Visibility Scripts
+
+The visibility script receives two bindings:
+- `targetEntity`: The entity whose attribute is displayed
+- `embeddingPage`: The page where the widget is embedded
+
+The script should return a boolean - returning `false` hides the attribute.
+
+### Layout Control
+
+The single-column option controls whether the attribute displays in full-width or two-column layout. This setting is only relevant when showing the label.
+
+When embedded within an Attributes Group widget, layout settings are inherited from the parent widget.
+
+## Alternatives
+
+| Scenario | Recommended Widget |
+|----------|-------------------|
+| Display all attributes | `cf.platform.attributes` |
+| Multiple attributes with custom layout | `cf.cplace.platform.attributesGroup` |
+| Attribute from selected table row | `cf.platform.connectedSingleAttribute` |
+| Simple default display | `cf.platform.attributes` |
+
+## Common Pitfalls
+
+- **Forgetting display mode**: At least one of "Show attribute name" or "Show attribute value" must be enabled
+- **Missing reload setting**: When in-place editing is enabled and other widgets depend on the attribute, enable "Reload grouped widget after attribute change"
+- **Script binding confusion**: In visibility scripts, use `targetEntity` for the data source and `embeddingPage` for the widget's location
+
+## Related Patterns
+
+- **Master-Detail**: Use `cf.platform.connectedSingleAttribute` when the attribute source should change based on table selection
+- **Grouped Attributes**: Embed multiple Single Attribute widgets within an Attributes Group for complex form layouts
+- **Hierarchical Display**: Use the "Use parent page" option to show inherited attributes from parent entities

package/dist/widget-specifications/cf.platform.singleAttribute/_summary.md

@@ -0,0 +1 @@
+Output of the value of an attribute. Displays a single attribute from a page with flexible label, value, and editing options, including in-place editing and conditional visibility for precise control over individual attribute placement.

package/dist/widget-specifications/cf.platform.singleAttribute/cf.platform.entity.md

@@ -0,0 +1,10 @@
+**Default Behavior**: When left empty, the widget displays an attribute from the page where it is embedded.
+
+**Valid Values**:
+- Empty/null: Use the current (embedding) page
+- Page UID: Reference to a specific page whose attribute should be displayed
+- `"<empty>"`: Special value when embedded inside a `cf.platform.attributesGroup` widget
+
+**Warning**: When embedded inside a `cf.platform.attributesGroup` widget, leave this empty or use `"<empty>"` - the parent widget provides the target entity.
+
+**Note**: This parameter is hidden from the edit UI when the widget is embedded inside `cf.platform.attributesGroup`.

package/dist/widget-specifications/cf.platform.singleAttribute/cf.platform.quotedAttributeName.md

@@ -0,0 +1,12 @@
+**Warning**: Use the full internal attribute name, not the simple/short name!
+
+**Important**:
+- **Custom attributes** require single quotes around the attribute name: `'cf.cplace.myApp.myAttribute'`
+- **Builtin attributes** (e.g., `name`, `createdAt`, `creator`, `modifiedAt`, `modifier`, `owner`, `_writers`) are specified without quotes: `name`
+
+**Workflow**:
+1. Call `cplace_get_type_datamodel` for the type of the target page
+2. Find the custom attribute you want to display
+3. Use the custom attribute's `name` field (the full internal name), wrapped in single quotes
+
+**Configuration Completeness**: The widget is incomplete if no attribute is selected. The selected attribute must also exist on the target type definition.