@cplace/test-mcp-server 1.0.0 → 1.1.0

package/dist/widget-specifications/cf.cplace.tuplesWidget.widget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.tuplesWidget.widget",
+  "Description": "{\"de\":\"Zeigt die Tupel-Seiten innerhalb einer Tabelle.\",\"en\":\"Shows the tuple pages within a table.\"}",
+  "Localized Name": "{\"en\":\"Tuple\",\"de\":\"Tupel\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.tuplesWidget",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace-paw",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Tuples' widget can be used to create and edit tuple-type data.</p>\n\n<p>Tuples are finite ordered lists of elements. Unlike lists, tuples are immutable.</p>\n\n<p><strong>Settings</strong></p>\n\n<p>// * Tuple attribute:</p>\n\n<p>// * Show name of tuple as column *: True/false.</p>\n\n<p>// * Attributes of tuples to be shown in widget:</p>\n\n<p>// * Sort by:</p>\n\n<p>// * Sort order:</p>\n\n<p>// * Widget title: Bilingual text.</p>\n\n<p>// * Height of the widget (in pixels)</p>\n\n<p>// * Allow reordering of tuple entries<span class=\"cplace-control-required\"> *: True/false.&nbsp;</span> If this option is enabled and if the user has the permission to edit the tuple attribute, the widget will show buttons for&nbsp; reordering the tuple entries. This option cannot be used in combination with 'Sort by'.</p>\n\n<p><span class=\"cplace-control-required\">// </span> * Allow the creation of tupel entries<span class=\"cplace-control-required\"> *:&nbsp;True/false.</span>&nbsp; If this option is enabled and if the user has the permission to create pages of the tuple type, the widget will show a button for creating new tuple entries.</p>\n\n<p><span class=\"cplace-control-required\">// * </span> Allow editing of tupel entries <span class=\"cplace-control-required\">*</span>: <span class=\"cplace-control-required\">True/false. </span> If this option is enabled and if the user has the permission to edit a tuple entry, its attributes will be editable within the widget.</p>\n\n<p>// * Allow deletion of tupel entries <span class=\"cplace-control-required\">*</span>: <span class=\"cplace-control-required\">True/false. </span> If this option is enabled and if the user has the permission to delete a tuple entry, the widget will show a button for deleting it.</p>"
+}

package/dist/widget-specifications/cf.cplace.tuplesWidget.widget/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "table",
+    "references",
+    "inline-edit",
+    "sortable",
+    "drag-drop",
+    "detail-view"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.tuplesWidget.widget/_overview.md

@@ -0,0 +1,202 @@
+## Overview
+
+The Tuple widget shows the tuple pages within a table. It provides a specialized table view for managing collections of referenced pages (called "tuples") through a multi-reference attribute. It combines viewing, inline editing, and CRUD operations in a spreadsheet-like interface without requiring users to navigate away from the parent page.
+
+In cplace terminology, "tuples" are referenced entities (pages) linked to the current page through a reference attribute. This widget displays these referenced pages with configurable columns showing selected attributes from the referenced type.
+
+## Use Cases
+
+### Master-Detail Relationships
+Display and manage a list of related detail records for a master record.
+- **Example**: A project page showing related tasks, risks, or milestones
+- **Example**: A customer page displaying contacts or orders
+- **Benefit**: All related items visible and editable in one place
+
+### Structured Data Collections
+Manage collections of structured data entries where multiple attributes of each item need to be visible.
+- **Example**: Configuration items, checklist entries, or requirements
+- **Benefit**: Table format provides quick scanning of multiple data points per item
+
+### Editable Reference Lists
+When users need to create, edit, and delete referenced items directly from the parent page.
+- **Benefit**: Inline editing without navigation
+- **Benefit**: Quick creation of new related entities
+- **Benefit**: Integrated deletion with confirmation
+
+### Ordered Collections
+When the sequence of referenced items matters and users need to reorder them.
+- **Feature**: Drag-and-drop reordering
+- **Feature**: Manual ordering controls (up/down buttons)
+- **Benefit**: Maintains user-defined sequence in the reference attribute
+
+### Configurable Views of Related Data
+Show only specific attributes of referenced items tailored to the use case.
+- **Feature**: Custom column selection from available tuple attributes
+- **Benefit**: Focused view without information overload
+- **Benefit**: Adapts to different viewing contexts
+
+## Operating Modes
+
+The widget has two mutually exclusive ordering modes:
+
+### Manual Ordering Mode
+**Enabled when**: Reordering is allowed AND no sort attribute is configured
+
+Users can drag-and-drop or use up/down buttons to reorder tuples. The order is persisted in the reference attribute and maintained across sessions.
+
+**Requirements**:
+- User must have edit permission on the tuple attribute
+- At least 2 tuples must exist
+- Automatic sorting must not be configured
+
+### Automatic Sorting Mode
+**Enabled when**: A sort attribute is configured
+
+Tuples are automatically sorted by the specified attribute in ascending or descending order. Users cannot manually change the order.
+
+**Note**: This mode and manual ordering mode cannot be used together.
+
+## Design Considerations
+
+### When to Use This Widget
+
+**Choose Tuples Widget when**:
+- You need to manage a moderate collection of referenced entities (typically < 100 items)
+- Users need inline editing capabilities for referenced items
+- The relationship is managed through a reference attribute on the embedding page
+- CRUD operations on referenced items are important to the workflow
+- Column-based view of multiple attributes is valuable
+
+**Consider Alternatives when**:
+- You need complex filtering or aggregation (use Embedded Search Table)
+- The collection is very large (> 100 items) (use Embedded Search Table)
+- You only need read-only display (use Table Widget or Embedded Search)
+- The relationship is single-valued 1-to-1 (use Connected Attributes Group)
+- You need cross-workspace searches (use Embedded Search)
+
+### Permission-Aware Design
+
+The widget adapts its UI based on user permissions and configuration:
+
+1. **Allow Reordering**: Shows/hides ordering controls based on configuration and permissions
+2. **Allow Adding**: Shows/hides "Create [Type]" button based on create permissions and multiplicity
+3. **Allow Editing**: Enables/disables inline editing based on edit permissions
+4. **Allow Deleting**: Shows/hides delete buttons based on delete permissions
+
+This granular control allows precise definition of user capabilities at the widget level.
+
+### Configuration Dependencies
+
+Key configuration flow:
+1. First select the reference attribute (Tuple Attribute)
+2. Save configuration to refresh available options
+3. Then select which tuple attributes to display as columns
+4. Configure ordering mode (manual OR automatic, not both)
+5. Set permission toggles based on intended user interaction
+
+**Important**: The list of available tuple attributes for column selection only becomes available after selecting and saving the reference attribute.
+
+## Common Pitfalls
+
+### Trying to Use Both Ordering Modes
+**Problem**: Configuring both manual reordering and automatic sorting simultaneously.
+
+**Solution**: Choose one mode. If sorting is needed, use automatic sorting. If user-defined order is needed, enable manual reordering without configuring a sort attribute.
+
+### Not Saving After Selecting Reference Attribute
+**Problem**: Attempting to configure visible columns before saving the reference attribute selection.
+
+**Solution**: Save the widget configuration after selecting the tuple attribute to refresh the available column options.
+
+### Using for Large Collections
+**Problem**: Performance issues when displaying hundreds of tuples.
+
+**Solution**: For large collections, use Embedded Search Table widget which provides pagination and is optimized for larger datasets.
+
+### Insufficient Permissions
+**Problem**: Users cannot perform expected operations (create, edit, delete, reorder).
+
+**Solution**: Verify users have:
+- Edit permission on the reference attribute (for add/remove/reorder)
+- Create permission on tuple type (for adding)
+- Edit permission on individual tuples (for inline editing)
+- Delete permission on individual tuples (for deletion)
+
+### Overlooking Multiplicity Constraints
+**Problem**: Users cannot add tuples when maximum multiplicity is reached.
+
+**Solution**: Check the reference attribute's multiplicity settings. If set to single-valued or has a maximum, the widget will prevent additional additions.
+
+## Related Widgets
+
+### Connected Attributes Group (`cf.cplace.platform.connectedAttributesGroup`)
+Shows attributes of a single referenced entity in form layout.
+
+**Use Connected Attributes when**: You have a 1-to-1 relationship and need to display/edit attributes of a single referenced page.
+
+**Use Tuples Widget when**: You have a 1-to-many relationship and need table-based view of multiple referenced pages.
+
+### Embedded Search Table (`cf.platform.embeddedSearchAsTable`)
+Shows search results in table format with advanced filtering and aggregation.
+
+**Use Embedded Search when**: You need complex filtering, large datasets, cross-space searches, aggregations, or read-only display of query results.
+
+**Use Tuples Widget when**: You need CRUD operations, inline editing, manual ordering, or direct reference management through an attribute.
+
+### Table Widget (`cf.cplace.platform.tableWidget`)
+Generic table for displaying structured data.
+
+**Use Table Widget when**: You need a simple read-only table display of data.
+
+**Use Tuples Widget when**: You need interactive management of referenced entities with editing and CRUD capabilities.
+
+### Table Detail View Widget (`cf.cplace.tableDetailViewWidget.widget`)
+Shows table with expandable detail panels.
+
+**Use Table Detail View when**: You need master-detail layout with expandable detail panels showing more information than fits in columns.
+
+**Use Tuples Widget when**: You need simpler table-based reference management without detail panels.
+
+## Key Differences from Similar Widgets
+
+### vs. Embedded Search Table
+- **Tuples Widget**: Direct reference management, inline editing, CRUD operations, manual ordering, works through reference attribute
+- **Embedded Search**: Read-only view, complex filtering, cross-space searches, aggregations, pagination for large datasets
+
+### vs. Connected Attributes Group
+- **Tuples Widget**: Multiple referenced entities in table format
+- **Connected Attributes**: Single referenced entity with form layout
+
+### vs. Table Detail View
+- **Tuples Widget**: Simpler table-focused interface with inline editing
+- **Table Detail View**: More complex layout with expandable detail views
+
+## Prerequisites
+
+### Data Model Requirements
+1. A reference attribute must exist on the embedding page's type
+2. The reference attribute must point to a specific tuple type
+3. The tuple type should have attributes that make sense to display in columns
+4. Multi-value multiplicity (0..* or similar) for the reference attribute
+
+### Permission Requirements
+1. Read access to the tuple type and its attributes
+2. Edit access to the reference attribute (for add/remove/reorder operations)
+3. Create permissions on tuple type (for creation operations)
+4. Delete permissions on tuple type (for deletion operations)
+
+### Embedding Context
+The widget must be embedded in a Page or TypeDefinition. It cannot be embedded in other contexts.
+
+## Extension Points
+
+The widget provides several extension points for custom behavior:
+
+### AssignReferenceToNewTupleExtension
+Add custom search filters when creating new tuples to restrict which tuples can be created based on business logic.
+
+### TupleValidationErrorExtension
+Show custom error messages or warnings about the tuple collection in the widget UI.
+
+### PreventRemoveTupleExtension
+Prevent deletion of specific tuples to protect required tuples or enforce business rules.

package/dist/widget-specifications/cf.cplace.tuplesWidget.widget/_summary.md

@@ -0,0 +1 @@
+Shows the tuple pages within a table. Displays referenced entities with inline editing capabilities and CRUD operations for managing collections of related pages through reference attributes.

package/dist/widget-specifications/cf.cplace.videoWidget/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.videoWidget",
+  "Description": "{\"en\":\"Enables output of a previously selected video uploaded to cplace.\",\"de\":\"Ermöglicht die Ausgabe eines zuvor gewählten und in cplace hochgeladenen Videos.\"}",
+  "Localized Name": "{\"en\":\"Video\",\"de\":\"Video\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.videoWidget",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace-utility-widgets",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.videoWidget/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "media",
+    "files",
+    "read-only",
+    "detail-view",
+    "documentation"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.videoWidget/_overview.md

@@ -0,0 +1,65 @@
+## Overview
+
+The Video widget enables output of a previously selected video uploaded to cplace. It provides a simple way to embed video and image content directly on cplace pages using the browser's native HTML5 video player, providing standard controls (play, pause, volume, fullscreen) without requiring external video hosting services. The widget automatically detects whether the uploaded file is a video or image and renders it appropriately with configurable dimensions and optional frame styling.
+
+## Use Cases
+
+**Educational Content**: Display instructional or training videos directly on project pages or documentation pages for team learning and knowledge transfer.
+
+**Presentations & Demos**: Embed product demos, feature walkthroughs, or presentation recordings to showcase functionality without leaving cplace.
+
+**Documentation**: Add visual content (videos or images) to enhance written documentation and make processes clearer.
+
+**Media Galleries**: Create visual portfolios or media collections on pages to organize and display multimedia content.
+
+**Team Communication**: Share recorded meetings, status updates, or announcements in video format for asynchronous collaboration.
+
+**Marketing Materials**: Display promotional videos, case studies, or customer testimonials within cplace pages.
+
+### When to Use This Widget
+
+- When you need to embed video or image content directly on a cplace page without external hosting
+- When you want browser-native video controls without additional configuration
+- When you need responsive video display that adapts to container width
+- When you want a simple, no-configuration-needed media display solution
+- When you need to support offline scenarios where external video hosting isn't available
+
+## Design Considerations
+
+### Why This Widget Exists
+
+The Video Widget leverages native HTML5 capabilities for better performance and privacy compared to external video services. It maintains consistent styling with cplace's widget framework and supports offline scenarios where external video hosting like YouTube or Vimeo isn't available or desirable.
+
+### Limitations
+
+The widget has intentional constraints focused on simplicity:
+
+- No advanced video player features (chapters, subtitles, playback speed controls)
+- Relies on browser's native video codec support, which varies by browser
+- Files must be uploaded to cplace (no direct URL embedding to external sources)
+- Width is always responsive (100% of container), cannot set fixed width
+- Height is fixed in pixels rather than responsive
+
+### Browser Compatibility
+
+The widget requires HTML5 video support in the browser. For unsupported browsers, it displays a fallback message: "Your browser does not support the video tag."
+
+## Alternatives
+
+Consider alternatives when this widget doesn't fit your needs:
+
+**For YouTube/Vimeo videos**: Use an iframe widget or embed widget instead of uploading the file to cplace.
+
+**For complex video interactions**: Custom development may be needed if you require advanced features like chaptered navigation, multi-language subtitles, or custom player controls.
+
+**For streaming large video files**: Consider external hosting platforms optimized for streaming to avoid storage and bandwidth constraints.
+
+**For live video**: Requires a different streaming solution; this widget only supports uploaded files.
+
+## Related Patterns
+
+**Documentation Enhancement**: Combine the Video Widget with text widgets and structured content to create rich, multimedia documentation pages.
+
+**Media Collections**: Use multiple Video Widgets within a layout to create galleries or comparison views.
+
+**Training Materials**: Pair with form widgets or interactive elements to create training modules with embedded video demonstrations.

package/dist/widget-specifications/cf.cplace.videoWidget/_summary.md

@@ -0,0 +1 @@
+Enables output of a previously selected video uploaded to cplace. Displays video files and images with customizable dimensions and optional frame styling using HTML5 video player controls.

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.visualizations.scriptingHighcharts",
+  "Description": "{\"de\":\"Ermöglicht die Konfiguration von Highchart-Diagrammen mittels cplaceJS.\",\"en\":\"Enables the configuration of Highchart diagrams using cplaceJS.\"}",
+  "Localized Name": "{\"en\":\"cplaceJS based Highcharts Visualization\",\"de\":\"cplaceJS Highcharts-Diagramm\"}",
+  "Icon": "cf-cplace",
+  "Plugin": "cf.cplace.scriptingVisualizations",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace-paw",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/_implementation.md

@@ -0,0 +1,12 @@
+**Configuration Modes**: The widget has these data source modes controlled by `cf.cplace.visualization.dataSource`:
+- `search`: Query pages via embedded search
+- `connectedTable`: Use pages from another table widget on the same layout
+
+**Typical Configuration Workflow**:
+1. Set `cf.cplace.visualization.dataSource` to choose your data source mode
+2. Configure the corresponding data source attribute:
+   - For `search`: Configure `cf.cplace.visualization.search` (use cplaceJson from cplace_search_pages)
+   - For `connectedTable`: Set `tableWidgetId` and `cf.cplace.visualization.tableSelectionOnly`
+3. Write your cplaceJS script in `cf.cplace.visualization.script` that:
+   - Processes the `pages` variable (all pages from your data source)
+   - Returns a valid Highcharts configuration object

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "chart",
+    "low-code",
+    "dashboard",
+    "filterable"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/_overview.md

@@ -0,0 +1,117 @@
+## Overview
+
+The cplaceJS based Highcharts Visualization widget enables the configuration of Highchart diagrams using cplaceJS. It serves as the escape hatch when standard chart widgets cannot meet visualization requirements.
+
+**Use when**:
+- Standard chart widgets (pie, bar, line) lack required customization
+- You need complex chart types like Gantt charts, mixed-type charts, or specialized layouts
+- Visualization logic requires conditional formatting, custom tooltips, or dynamic data transformations
+- Charts must respond to specific business rules or calculations
+
+**Alternatives**:
+- **Connected Pie Chart** - Simpler pie/donut charts without scripting
+- **Connected Bar Chart** - Standard bar/column visualizations
+- **Scripting Line Chart** - When only line charts are needed with simpler scripting
+
+## Use Cases
+
+### Timeline and Scheduling Visualizations
+Gantt charts displaying projects, tasks, or activities across time. These require mapping start/end dates to horizontal bars, applying status-based coloring, and often include clickable elements linking to detail pages.
+
+### Status Distribution Displays
+Donut or pie charts showing how items distribute across different states (open/in progress/done, risk levels, categories). Useful for dashboards where stakeholders need quick visual summaries.
+
+### Trend Analysis with Comparisons
+Mixed chart types combining stacked columns with overlaid line series. Common for comparing actual values against targets, demand versus capacity, or historical trends against forecasts.
+
+### Resource and Capacity Views
+Visualizations aggregating time-bounded data across periods (monthly, quarterly). Often requires processing complex reference chains and calculating derived metrics.
+
+## Behavior and Capabilities
+
+### Data Source Modes
+
+The widget supports two fundamentally different data retrieval approaches:
+
+**Connected Table Mode**: The chart receives its data from a table widget on the same page. This creates a tight coupling where the chart always reflects what the table shows, including any filters or sorting the user has applied. Users can optionally restrict the chart to only selected rows, enabling interactive exploration.
+
+**Search Mode**: The chart queries for data independently using cplace's search filters. This provides flexibility when the chart needs different data than surrounding widgets, or when there is no table to connect to.
+
+### Scripting Capabilities
+
+Scripts receive page data and must return a valid Highcharts configuration object. Within the script, you can:
+
+- Access page attributes including references and their nested properties
+- Perform aggregations and calculations across the dataset
+- Apply conditional logic for colors, labels, and formatting
+- Generate clickable elements linking to pages
+- Handle localization based on user language
+- Implement empty-state handling when no data matches criteria
+
+### Highcharts Integration
+
+The widget supports the full range of Highcharts chart types and configurations:
+- Standard charts (column, bar, line, pie, area)
+- Gantt charts with timeline axes
+- Mixed-type charts combining multiple series types
+- Custom tooltips, data labels, and legends
+- Interactive features like zoom and click handlers
+
+## Design Considerations
+
+### When Scripting is Worth the Complexity
+
+Scripting adds maintenance overhead and requires JavaScript knowledge. Choose this widget when:
+
+- The visualization logic cannot be expressed through configuration alone
+- You need to combine or transform data from multiple attributes
+- Status-to-color mapping requires business logic beyond simple lookups
+- The chart type or layout is not available in standard widgets
+
+For straightforward distributions or comparisons, standard chart widgets are preferable.
+
+### When NOT to Use This Widget
+
+**For simple number displays (KPI cards, metric counts), use `demoRichString` instead:**
+
+- No Highcharts configuration needed
+- Full CSS control over card styling
+- Lower complexity for basic number + label displays
+- Platform widget - always available
+
+| Need | Better Choice |
+|------|---------------|
+| Single number with label (KPI card) | `demoRichString` |
+| Styled metric with custom colors | `demoRichString` |
+| Count from search query | `demoRichString` with embedded Low-Code widget |
+
+Use this widget only when you need actual charts (bar, pie, line, Gantt, gauge).
+
+### Data Volume Implications
+
+Scripts execute on page load and process data client-side. For large datasets:
+- Consider server-side aggregation before visualization
+- Use specific search filters to limit returned data
+- Avoid complex nested reference traversals on large result sets
+
+### Empty State Handling
+
+Scripts should always handle the case where no data matches the search criteria. Returning a centered message rather than a broken or empty chart improves user experience significantly.
+
+### Mixed Chart Considerations
+
+When combining series types (e.g., columns with a line overlay), layer ordering matters. Line series typically need higher z-index values to appear above filled series. Step-style lines often work better than smooth curves when overlaying discrete column data.
+
+### Localization
+
+Charts displayed to international users should detect user language and provide localized labels, titles, and messages. This includes both static text and dynamically generated content like tooltips.
+
+## Related Widgets
+
+**Data Source Widgets**: Works with **Table Widget** or **Connected Table** when using connected table mode. The table defines what data flows into the chart.
+
+**Alternative Chart Widgets**: Consider **Connected Pie Chart** and **Connected Bar Chart** for simpler requirements. These offer less flexibility but require no scripting.
+
+**Sibling Scripting Widget**: **Scripting Line Chart** provides similar scripting capabilities but optimized specifically for line chart rendering.
+
+**Dashboard Context**: Often appears alongside summary widgets, KPI displays, and tables to provide complementary visualizations of the same underlying data from different perspectives.

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/_summary.md

@@ -0,0 +1 @@
+Enables the configuration of Highchart diagrams using cplaceJS. Use when standard chart widgets lack required customization for complex chart types, conditional formatting, or business-rule-driven visualizations.

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/cf.cplace.visualization.dataSource.md

@@ -0,0 +1,5 @@
+**Valid Values**:
+- `search`: Widget queries data via embedded search
+  - Activates: `cf.cplace.visualization.search`, `sortColumn`, `sortOrder`
+- `connectedTable`: Widget uses data from a connected table widget
+  - Activates: `tableWidgetId`, `cf.cplace.visualization.tableSelectionOnly`

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/cf.cplace.visualization.search.md

@@ -0,0 +1,10 @@
+**Warning**: Do not manually construct search JSON!
+
+**Correct Usage**: Use the `cplaceJson` field from `cplace_search_pages` response.
+
+**Workflow**:
+1. Call `cplace_search_pages` with your desired filter
+2. Take the `cplaceJson` field from the response
+3. Use that value for this attribute
+
+**Note**: Only active when `cf.cplace.visualization.dataSource` = `search`. The search results become available to the cplaceJS script as the `pages` variable.

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/script.md

@@ -0,0 +1,29 @@
+**Warning**: The script must return a valid Highcharts configuration object!
+
+**Available Bindings** (variables accessible in your script):
+
+| Variable | Type | Description |
+|----------|------|-------------|
+| `embeddingPage` | `WrappedPage` | The page in which the Highchart widget is embedded |
+| `pages` | `Iterable<WrappedPage>` | All pages from the configured data source |
+| `messages` | Message Provider | Helper to access localized messages from the embedding page's type definition |
+
+**Additional Allowed Classes**:
+- `Search.class` - For creating additional searches
+- `Filters.class` - For creating search filters
+
+**Expected Return**: A valid Highcharts configuration object (JSON-compatible). See [Highcharts API](https://api.highcharts.com/highcharts/).
+
+**Example**:
+```javascript
+var configuration = {
+    chart: { type: 'bar' },
+    title: { text: 'My Chart' },
+    xAxis: { categories: ['A', 'B', 'C'] },
+    series: [{
+        name: 'Series 1',
+        data: [1, 2, 3]
+    }]
+};
+return configuration;
+```

package/dist/widget-specifications/cf.cplace.visualizations.scriptingHighcharts/tableWidgetId.md

@@ -0,0 +1,10 @@
+**Note**: Only active when `cf.cplace.visualization.dataSource` = `connectedTable`.
+
+**How to Find Widget IDs**:
+1. Use `cplace_get_embedded_layout` or `cplace_get_type_layout` to retrieve the page's layout
+2. Look for widgets in the layout with table-type widget kinds (e.g., `cf.platform.embeddedSearchAsTable`)
+
+**Workflow**: When connecting to a table widget:
+1. Ensure both widgets are on the same page layout
+2. Configure the table widget first (if creating new layout)
+3. Get its `widgetId` from the layout

package/dist/widget-specifications/cf.cplace.visualizations.scriptingLineChart/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.cplace.visualizations.scriptingLineChart",
+  "Description": "{\"de\":\"Ermöglicht die Konfiguration eines Liniendiagramms mittels cplaceJS.\",\"en\":\"Enables configuration of a line chart using cplaceJS.\"}",
+  "Localized Name": "{\"en\":\"cplaceJS based Line Chart\",\"de\":\"cplaceJS Liniendiagramm\"}",
+  "Icon": "cf-cplace",
+  "Plugin": "cf.cplace.scriptingVisualizations",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace-paw",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.cplace.visualizations.scriptingLineChart/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "time-series",
+    "chart",
+    "searchable",
+    "filterable",
+    "dashboard",
+    "low-code"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.cplace.visualizations.scriptingLineChart/_overview.md

@@ -0,0 +1,72 @@
+## Overview
+
+The cplaceJS based Line Chart widget enables configuration of a line chart using cplaceJS. It creates custom time-series visualizations by executing JavaScript code to transform page data into chart series. It bridges configuration-based widgets and fully custom implementations, allowing developers to apply business logic, aggregations, and calculations while leveraging the robust Highcharts rendering engine and built-in UI components.
+
+## Use Cases
+
+### When to Use This Widget
+
+- **Custom Data Transformation**: When you need to aggregate, calculate, or transform page data before visualizing it as a line chart
+- **Complex Business Logic**: When chart data requires logic that cannot be expressed through configuration alone
+- **Dynamic Series Generation**: When the number or nature of chart series depends on runtime data
+- **Advanced Calculations**: When computing trends, moving averages, or other derived metrics
+- **Multi-Source Data**: When combining data from multiple page types or attributes into a single visualization
+
+### Example Scenarios
+
+- Project timeline visualization showing milestone progress over time
+- Resource utilization tracking across multiple projects
+- Performance metrics dashboards with computed KPIs
+- Budget burn-down charts with custom calculation logic
+- Status change trend analysis over time
+
+### When NOT to Use This Widget
+
+- **Simple Attribute Visualization**: Use the Tuple Line Chart widget (`cf.cplace.visualizations.tupleLineChart`) if you only need to display attribute values from tuple data without transformation
+- **No Scripting Requirement**: Prefer configuration-based widgets when they meet your needs for better maintainability
+- **Limited JavaScript Knowledge**: This widget requires cplaceJS expertise
+
+## Design Considerations
+
+### Script-Based Architecture
+
+The widget executes custom cplaceJS code server-side to generate chart series data. Scripts receive:
+- `pages`: Iterable of pages from the configured search results
+- `messages`: Message provider for internationalization support
+
+Scripts must return data in Highcharts series format, with each series containing an ID, name, and array of timestamp-value pairs.
+
+### Timeframe Filtering
+
+The widget includes built-in timeframe filtering capabilities:
+- Client-side filtering by timeframe (all, 3, 6, or 12 months)
+- Scripts should include all data; frontend handles timeframe selection
+- Timeframe selector buttons can be shown or hidden via configuration
+
+### Performance Implications
+
+- Scripts execute server-side on each widget load
+- Performance monitoring is enabled for detailed logging
+- Optimize scripts when processing large datasets
+- Consider data volume when designing search queries
+
+## Common Pitfalls
+
+- **Incorrect Series Format**: Scripts must return a JSONArray in Highcharts format with proper timestamp-value pairs
+- **Missing Series IDs**: Each series needs a unique ID for proper rendering
+- **Unsorted Data**: Pre-sort data points by timestamp for optimal chart performance
+- **Script Errors**: Thoroughly test scripts with various data scenarios as exceptions will display as widget errors
+- **Date Format**: Use timestamps in milliseconds since epoch for x-axis data points
+
+## Alternatives to Consider
+
+| Widget | When to Choose |
+|--------|----------------|
+| **Tuple Line Chart** (`cf.cplace.visualizations.tupleLineChart`) | Simple visualization of tuple attributes without transformation |
+| **cplaceJS based Highcharts** (`cf.cplace.visualizations.scriptingHighcharts`) | Need full control over any Highcharts chart type, not just line charts |
+
+## Related Patterns
+
+- **Master-Detail with Charts**: Use a table widget as master to filter which pages are visualized in the line chart
+- **Dashboard KPI Display**: Combine with other visualization widgets for comprehensive dashboards
+- **Time-Based Trend Analysis**: Pair with search filters to analyze trends across different time periods

package/dist/widget-specifications/cf.cplace.visualizations.scriptingLineChart/_summary.md

@@ -0,0 +1 @@
+Enables configuration of a line chart using cplaceJS. Use for time-series visualizations requiring custom data aggregation, calculations, or business logic that cannot be achieved through configuration-based widgets.