Data Visualization Suite
Run ID: 69cd11223e7fb09ff16a79a82026-04-01Analytics
PantheraHive BOS
BOS Dashboard

Data Visualization Suite: Design Requirements & Specifications

This document outlines the comprehensive design requirements and specifications for the proposed Data Visualization Suite. This deliverable represents the culmination of our initial research phase, establishing the foundational principles, core functionalities, visual design guidelines, and user experience recommendations. Our goal is to create a powerful, intuitive, and aesthetically pleasing platform that empowers users to transform complex data into actionable insights.


1. Introduction & Core Design Principles

The Data Visualization Suite aims to provide a robust platform for connecting to diverse data sources, creating interactive dashboards, and generating insightful visualizations. This suite is designed to cater to various user roles, from business analysts to executive decision-makers, by offering flexibility, performance, and ease of use.

Core Design Principles:

  • Clarity & Simplicity: Prioritize clear, unambiguous presentation of data and intuitive user interfaces. Minimize cognitive load.
  • Interactivity & Exploration: Enable users to dive deep into data through filtering, drilling, and dynamic interactions.
  • Performance & Scalability: Ensure rapid data loading, rendering, and responsiveness, even with large datasets. Design for future growth.
  • Accessibility & Inclusivity: Adhere to accessibility standards (WCAG) to ensure the suite is usable by individuals with diverse needs.
  • Consistency & Predictability: Maintain a consistent visual language, interaction patterns, and navigation across the entire suite.
  • Actionability: Design visualizations and dashboards that directly support decision-making and business outcomes.

2. Detailed Design Specifications

2.1. Target Audience

The Data Visualization Suite is designed for:

  • Business Analysts: To explore data, identify trends, and create detailed reports.
  • Department Managers: To monitor KPIs, track team performance, and make operational decisions.
  • Executives: To gain high-level overviews of business health and strategic insights.
  • Data Scientists/Engineers: To validate data, prototype visualizations, and share findings.

2.2. Key Features & Functionality

2.2.1. Data Ingestion & Management

  • Data Source Connectors:

* Databases: PostgreSQL, MySQL, SQL Server, Oracle.

* Cloud Data Warehouses: Snowflake, Google BigQuery, Amazon Redshift, Azure Synapse Analytics.

* Flat Files: CSV, Excel, JSON.

* APIs: Generic REST API connector with authentication options (OAuth2, API Key, Basic Auth).

  • Data Preview & Schema Discovery: Ability to preview data and automatically detect data types.
  • Basic Data Transformation:

* Renaming columns.

* Changing data types (e.g., string to number, date parsing).

* Simple aggregations (sum, count, average).

* Filtering rows based on conditions.

* Creating calculated fields (basic arithmetic, string concatenation).

  • Data Refresh Scheduling: Configure automated refresh intervals (e.g., hourly, daily, weekly) for connected data sources.
  • Connection Management: Securely store and manage multiple data source connections.

2.2.2. Visualization Types

  • Standard Charts: Bar charts (horizontal/vertical, stacked), Line charts, Area charts, Pie/Donut charts, Scatter plots, Bubble charts.
  • Statistical Charts: Histograms, Box plots.
  • Geospatial: Choropleth maps, Symbol maps (requires geographical data).
  • Tabular: Data tables with sorting, pagination, and conditional formatting.
  • Indicators: Gauge charts, KPI cards (single value display with trend indicators).
  • Hierarchical: Treemaps, Sunburst charts.
  • Custom Visualizations: Support for embedding custom code or integrating with third-party visualization libraries (e.g., D3.js) for advanced users (future phase consideration).

2.2.3. Dashboard Creation & Management

  • Drag-and-Drop Interface: Intuitive canvas for arranging and resizing visualization widgets.
  • Layout & Grid System: Responsive grid system for flexible dashboard design across different screen sizes.
  • Dashboard Templates: Pre-defined templates for common business use cases (e.g., Sales Performance, Marketing Analytics, Financial Overview).
  • Global Filters: Apply filters across multiple visualizations on a single dashboard.
  • Text & Media Widgets: Rich text editor, image embedding for context and branding.
  • Sharing & Collaboration: Secure sharing of dashboards with specific users or teams, with view-only or edit permissions.
  • Versioning: Basic version control for dashboards to track changes.

2.2.4. Interactivity & Exploration

  • Filtering: Single-select, multi-select, range sliders, date pickers.
  • Drill-Down/Up: Navigate from aggregate views to detailed data and vice versa.
  • Cross-Filtering: Selecting data points in one visualization automatically filters data in other related visualizations on the dashboard.
  • Tooltips: On-hover display of detailed data points.
  • Zoom & Pan: For charts with high data density (e.g., scatter plots, line charts).
  • Sorting: Ability to sort data within visualizations (e.g., by value, by category).

2.2.5. Reporting & Export

  • Export Formats: Export entire dashboards or individual visualizations to:

* PDF (print-ready)

* PNG/JPEG (image)

* CSV/Excel (underlying data)

  • Scheduled Reports: Configure automated email delivery of dashboards/reports at specified intervals.

2.2.6. User Management & Security

  • Role-Based Access Control (RBAC): Define roles (e.g., Admin, Editor, Viewer) with granular permissions over data sources, dashboards, and features.
  • Authentication: Integration with standard authentication mechanisms (e.g., username/password, OAuth2, SAML for enterprise SSO).
  • Data Security: Secure connection strings, encrypted data at rest (if applicable for internal storage), row-level security (future consideration).

2.2.7. Performance Optimization

  • Efficient Query Execution: Optimized query generation based on visualization needs.
  • Data Caching: Intelligent caching mechanisms for frequently accessed data and dashboards.
  • Asynchronous Loading: Load dashboard components independently to improve perceived performance.

2.3. Data Sources & Integration Strategy

  • Phase 1 (Initial Launch): Focus on robust connectors for the most common relational databases (PostgreSQL, MySQL, SQL Server), flat files (CSV, Excel), and major cloud data warehouses (Snowflake, BigQuery, Redshift).
  • Phase 2 (Enhancements): Expand to include NoSQL databases (MongoDB, Cassandra), generic REST API connectors, and potentially direct integration with popular business applications (e.g., Salesforce, Google Analytics).

3. Wireframe Descriptions (High-Level)

The following descriptions outline the key screens and their primary functionalities. These will serve as the basis for detailed wireframing and prototyping.

3.1. Login / Authentication Screen

  • Purpose: Secure access to the suite.
  • Elements: Username/email input, password input, "Remember Me" checkbox, "Forgot Password" link, Login button, SSO/OAuth options (if integrated).

3.2. Dashboard Overview / Home Screen

  • Purpose: Central hub for users to view and manage their dashboards.
  • Elements:

* Header: Logo, User Profile (avatar, name, logout), Global Search bar.

* Sidebar Navigation: Links to Dashboards, Data Sources, Users (Admin only), Settings.

* Main Content Area:

* "My Dashboards" section: Grid/list view of dashboards created by the user.

* "Shared with Me" section: Dashboards shared by others.

* "Favorites" section.

* "Create New Dashboard" button.

* Dashboard cards: Title, description, last updated, thumbnail preview, actions (edit, view, share, delete).

3.3. Individual Dashboard View

  • Purpose: Display a specific dashboard with its visualizations and interactive elements.
  • Elements:

* Header: Dashboard Title, "Edit" button, "Share" button, "Export" button, "Refresh" button.

* Global Filter Bar: Dropdowns, date pickers, search inputs for applying filters across the entire dashboard.

* Canvas Area: Grid layout containing multiple visualization widgets (charts, tables, KPI cards).

* Visualization Widgets: Each widget displays a chart/table, with a title, context menu (edit, export data, export image), and interactive elements (tooltips, click actions).

3.4. Data Source Connection & Management Screen

  • Purpose: Manage connections to various data sources.
  • Elements:

* Header: "Data Sources" title, "Add New Data Source" button.

* List of Connected Data Sources: Table with Name, Type, Status (connected/disconnected), Last Refresh, Actions (edit connection, test connection, refresh schema, delete).

* "Add New Data Source" Modal/Form:

* Select Data Source Type (dropdown/icons).

* Connection Details (host, port, database name, username, password, API keys).

* "Test Connection" button.

* "Save" button.

3.5. Visualization Builder / Editor Screen

  • Purpose: Interface for creating and configuring individual visualizations.
  • Elements:

* Sidebar (Left):

* Data Source Selector (dropdown).

* List of available fields/columns from the selected data source (searchable).

* Field properties (data type, aggregation options).

* Configuration Panel (Right):

* Chart Type Selector (bar, line, pie, etc.).

* Drag-and-drop zones for assigning fields to X-axis, Y-axis, Color, Size, Filters, Tooltips, etc.

* Formatting Options: Colors, labels, titles, legends, axis properties, tooltips, conditional formatting.

* Central Canvas: Live preview of the visualization as it's being configured.

* Footer: "Save" button, "Cancel" button, "Add to Dashboard" button.

3.6. User & Role Management Screen (Admin Only)

  • Purpose: Manage users, roles, and permissions.
  • Elements:

* Header: "User Management" title, "Add New User" button.

* User List: Table with User Name, Email, Role, Status, Actions (edit, deactivate, delete, reset password).

* Role Management Section: List of defined roles, permissions associated with each role, "Create New Role" button.


4. Color Palettes

A well-defined color palette is crucial for visual appeal, data clarity, and accessibility.

4.1. Brand & UI Colors

  • Primary Brand Color: #007bff (A vibrant, professional blue for main accents, primary buttons, and active states).
  • Secondary Brand Color: #6c757d (A neutral grey for secondary actions, inactive states, and less prominent elements).
  • Neutral Palette:

* #FFFFFF (Pure White): Backgrounds, card elements.

* #F8F9FA (Light Grey): Secondary backgrounds, hover states.

* #E9ECEF (Border Grey): Borders, dividers.

* #CED4DA (Input Border): Form input borders.

* #343A40 (Dark Text): Primary text, headings.

* #6C757D (Medium Text): Secondary text, descriptions.

  • System Status Colors:

* #28A745 (Success): Green for successful operations.

* #DC3545 (Error): Red for errors and critical alerts.

* #FFC107 (Warning): Yellow/Orange for warnings.

* #17A2B8 (Info): Cyan/Blue for informational messages.

4.2. Data Visualization Palettes

General Principles:

  • Accessibility First: Ensure sufficient contrast ratios (WCAG 2.1 AA compliant) for all text and graphical elements.
  • Colorblind Friendliness: Utilize palettes that minimize confusion for common forms of colorblindness (e.g., deuteranomaly, protanomaly). Avoid relying solely on color to convey information; use shapes, patterns, or labels as well.
  • Semantic Use: Use color consistently to represent the same categories or values across different charts.

4.2.1. Categorical Palette (for discrete categories)

  • A set of 6-8 distinct, perceptually uniform colors suitable for distinguishing different categories.
  • Example (Colorblind-friendly):

1. #1F77B4 (Blue)

2. #FF7F0E (Orange)

3. #2CA02C (Green)

4. #D62728 (Red)

5. #9467BD (Purple)

6. #8C564B (Brown)

gemini Output

Data Visualization Suite: Detailed Design Specifications

This document outlines the comprehensive design specifications for the "Data Visualization Suite," focusing on creating a professional, intuitive, and highly functional platform. These specifications will guide the development process, ensuring a cohesive user experience and robust data presentation capabilities.


1. Introduction

The Data Visualization Suite aims to empower users with actionable insights through interactive and visually compelling data representations. This deliverable details the core design principles, architectural considerations, user experience flows, and aesthetic guidelines to achieve a best-in-class visualization platform.


2. Design Specifications

2.1 Core Design Principles

  • Clarity & Simplicity: Data visualizations must be easy to understand at a glance, minimizing cognitive load.
  • Interactivity: Users should be able to explore data dynamically through filters, drill-downs, and customizable views.
  • Performance: The suite must handle large datasets efficiently, ensuring rapid loading and smooth interaction.
  • Scalability: The architecture should support future growth in data volume, user count, and feature complexity.
  • Accessibility: Designed to be usable by individuals with diverse abilities, adhering to WCAG 2.1 AA standards.
  • Customization: Provide options for users to tailor dashboards, reports, and visual elements to their specific needs.
  • Consistency: Maintain a uniform look, feel, and interaction model across the entire suite.

2.2 Dashboard Layout & Structure

  • Responsive Design: Optimized for various screen sizes (desktop, tablet, mobile) with adaptive layouts.
  • Configurable Widgets: Users can add, remove, resize, and rearrange visualization widgets within a dashboard.
  • Grid-based Layout: A flexible grid system (e.g., 12-column) to ensure organized and aligned widget placement.
  • Global Filters Panel: A dedicated area (e.g., left sidebar or top bar) for filters that apply across the entire dashboard (e.g., date range, geographical region, department).
  • Drill-down Capabilities: Support for clicking on a data point (e.g., a bar in a bar chart) to reveal more granular data or navigate to a related detailed view.
  • Tabbed Dashboards: Option to organize complex information into multiple tabs within a single dashboard.
  • Save & Share: Functionality to save custom dashboard layouts and share them with other users or teams, with appropriate permission controls.

2.3 Visualization Types

The suite will support a comprehensive range of chart types, each with configurable properties (e.g., axes labels, legends, tooltips, colors):

  • Bar Charts: Vertical and horizontal, stacked, grouped. Ideal for comparing discrete categories.
  • Line Charts: Single and multi-series. Excellent for showing trends over time.
  • Area Charts: Single and multi-series, stacked. For illustrating magnitude of change over time.
  • Pie/Donut Charts: For displaying proportions of a whole (use with caution for too many categories).
  • Scatter Plots: For showing relationships and correlations between two numerical variables.
  • Bubble Charts: An extension of scatter plots, adding a third dimension (size of bubble).
  • Heatmaps: For visualizing data density or magnitude across two categorical variables.
  • Treemaps: Hierarchical data visualization, showing proportions within a nested structure.
  • Gauge Charts: For displaying progress towards a target or current status against a threshold.
  • Table/Grid Visualizations: Detailed tabular data with sorting, pagination, and search capabilities.
  • Key Performance Indicator (KPI) Cards: Large, prominent display of single, critical metrics with optional sparklines or trend indicators.
  • Geographical Maps: Choropleth maps, symbol maps, and heatmaps for location-based data.
  • Funnel Charts: For illustrating stages in a process (e.g., sales pipeline).

2.4 Data Interaction & Controls

  • Filtering:

* Global Filters: Applied to all visualizations on a dashboard.

* Local Filters: Applied only to specific visualizations.

* Filter Types: Dropdowns, multi-select checkboxes, date pickers (range, relative), text search.

  • Sorting: Ascending/descending for tabular data and most chart types.
  • Zoom & Pan: For detailed exploration of specific data ranges (e.g., time series).
  • Tooltips: On-hover information display for data points, providing granular details without cluttering the main visualization.
  • Brushing & Linking: Selecting data points in one visualization highlights corresponding data in others.
  • Export Options: Export data (CSV, Excel) and visualizations (PNG, SVG, PDF) from individual widgets and entire dashboards.

2.5 Data Source Management

  • Connectors: Support for various data sources (e.g., SQL databases, NoSQL databases, REST APIs, CSV/Excel files, cloud storage like S3, Google Drive).
  • Data Upload: Secure and efficient methods for uploading local files.
  • Data Preview & Schema Detection: Ability to preview data and automatically detect data types.
  • Basic Data Transformation: Options for renaming columns, changing data types, simple aggregations (e.g., sum, average), and filtering at the source level.

2.6 Security & Permissions

  • Role-Based Access Control (RBAC): Define roles (e.g., Admin, Editor, Viewer) with distinct permissions for data sources, dashboards, and features.
  • Row-Level Security (RLS): Configure data access based on user attributes (e.g., a manager only sees data for their team).
  • Secure Data Connections: Encrypted connections to data sources.
  • Audit Trails: Logging of significant user actions (e.g., dashboard creation, data source modification).

2.7 Performance Optimization

  • Lazy Loading: Load visualizations only when they are visible in the viewport.
  • Data Aggregation: Pre-aggregate large datasets where appropriate to improve query times.
  • Caching: Implement robust caching mechanisms for frequently accessed data and dashboards.
  • Efficient Rendering: Utilize optimized rendering libraries (e.g., D3.js, Chart.js, Vega-Lite) and techniques to ensure smooth interactions.

3. Wireframe Descriptions

The following descriptions outline the key screens and their functional components.

3.1 Dashboard Overview Screen

  • Layout:

* Header: Application logo, user profile/settings, global search, "Create New Dashboard" button.

* Left Sidebar (Optional/Collapsible): Navigation for "My Dashboards," "Shared Dashboards," "Data Sources," "Reports," "Admin."

* Main Content Area:

* Dashboard List/Grid: Displays thumbnails or cards of existing dashboards.

* Dashboard Card Elements: Title, last modified date, owner, tags, quick actions (e.g., view, edit, share, delete).

* Filtering/Sorting: Options to filter dashboards by owner, tags, or sort by name, date.

* Search Bar: To quickly find dashboards by name or description.

  • User Flow: Users land here after login, giving them an overview of their available dashboards and entry points to other sections.

3.2 Individual Dashboard View Screen

  • Layout:

* Header: Dashboard title, "Edit" button, "Share" button, "Export Dashboard" button (PDF/Image), "Refresh" button.

* Global Filters Panel (Top or Left): Date range picker, multi-select dropdowns for key dimensions, text search.

* Main Canvas: Grid-based layout containing various visualization widgets.

* Widget Elements (within canvas):

* Widget Header: Chart title, type icon, kebab menu (options: edit, duplicate, export data, export image, remove).

* Visualization Area: The interactive chart or table.

* Loading Spinner: Appears during data retrieval.

* Error Message: Displays if data fails to load.

  • User Flow: This is the primary screen for consuming data. Users interact with filters and individual visualizations.

3.3 Dashboard Editor Screen

  • Layout:

* Header: Dashboard title (editable), "Save," "Cancel," "Preview," "Add Widget" buttons.

* Left Sidebar:

* "Widgets" Panel: List of available chart types, drag-and-drop functionality to canvas.

* "Data Sources" Panel: List of connected data sources, drag-and-drop fields to widget configuration.

* "Settings" Panel: Dashboard-level settings (e.g., refresh interval, theme).

* Main Canvas: Interactive grid where widgets can be dragged, dropped, resized, and configured.

* Widget Configuration Panel (Contextual): Appears when a widget is selected. Contains options for:

* Data: Select data source, fields (dimensions, measures), filters specific to the widget.

* Chart Type: Change chart type.

* Appearance: Colors, labels, legends, axes, titles.

  • User Flow: Users create new dashboards or modify existing ones, selecting data, configuring visualizations, and arranging them on the canvas.

3.4 Data Source Management Screen

  • Layout:

* Header: "Add New Data Source" button.

* Main Content Area:

* Data Source List: Table or cards displaying connected data sources.

* Data Source Card/Row Elements: Name, type, connection status, last updated, actions (edit, delete, refresh schema).

* Search/Filter: To find specific data sources.

  • "Add/Edit Data Source" Modal/Page:

* Form Fields: Data source type selection, connection details (host, port, credentials, API key), name, description.

* "Test Connection" Button.

* "Save" Button.

  • User Flow: Administrators or authorized users configure and manage connections to various data repositories.

4. Color Palettes

The color palettes are designed for professionalism, clarity, accessibility, and effective data differentiation.

4.1 Primary UI Palette

  • Primary Brand Color: #007bff (A vibrant, professional blue) - Used for primary buttons, active states, key highlights.
  • Secondary Color: #6c757d (A muted grey) - Used for secondary actions, borders, inactive states.
  • Accent Color: #28a745 (Green) - Used for success messages, positive indicators.
  • Warning Color: #ffc107 (Amber) - Used for warnings, pending states.
  • Danger Color: #dc3545 (Red) - Used for error messages, negative indicators.
  • Text Colors:

* #212529 (Dark charcoal) - Primary text.

* #495057 (Medium grey) - Secondary text, labels.

* #ffffff (White) - Inverse text on dark backgrounds.

  • Background Colors:

* #ffffff (White) - Primary background.

* #f8f9fa (Light grey) - Secondary background, subtle sections.

* #e9ecef (Lighter grey) - Borders, dividers.

4.2 Data Visualization Palettes

Colors for data visualizations will be distinct from UI colors to avoid confusion and ensure data stands out.

  • Categorical Palette (Discrete Data):

* A set of 8-12 distinct, perceptually uniform colors.

* Example sequence: #1f77b4, #ff7f0e, #2ca02c, #d62728, #9467bd, #8c564b, #e377c2, #7f7f7f, #bcbd22, #17becf.

* Prioritize color-blind friendly options (e.g., using tools like ColorBrewer or custom palettes verified with accessibility checkers).

* For more than 12 categories, consider grouping "Other" or using patterns/textures in conjunction with colors.

  • Sequential Palette (Continuous Data - Single Hue):

* Gradients from light to dark (or vice-versa) of a single hue.

* Example (Blue): #deebf7 (light), #c6dbef, #9ecae1, #6baed6, #4292c6, #2171b5, #084594 (dark).

* Used for heatmaps, intensity maps, or showing magnitude.

  • Diverging Palette (Continuous Data - Two Hues):

* Two contrasting hues diverging from a neutral midpoint.

* Example (Red-Blue): #b2182b (strong negative), #ef8a62, #fddbc7, #f7f7f7 (neutral), #d1e5f0, #67a9cf, #2166ac (strong positive).

* Ideal for data with a meaningful central value (e.g., deviations from average, positive/negative sentiment).

4.3 Accessibility Considerations

  • Contrast Ratio: Ensure text and interactive elements meet WCAG 2.1 AA contrast ratios (4.5:1 for normal text, 3:1 for large text and graphical objects).
  • Color Blindness: Validate data palettes using simulators to ensure differentiability for common forms of color blindness (protanopia, deuteranopia, tritanopia).
  • Redundancy: Whenever possible, use secondary encodings (e.g., patterns, labels, varying line styles) in addition to color, especially for critical data.

5. UX Recommendations

5.1 Clarity and Simplicity

  • Minimalist Interface: Reduce visual clutter, focusing user attention on the data.
  • Intuitive Navigation: Clear, consistent navigation paths with easily recognizable icons and labels.
  • Contextual Information: Provide help text, tooltips, and clear labels where necessary, but avoid overwhelming the user.
  • Progressive Disclosure: Show only essential information initially, allowing users to drill down for more detail as needed.

5.2 Interactivity and Feedback

  • Hover States: Provide clear visual feedback when hovering over interactive elements (buttons, links, data points).
  • Clickable Elements: Clearly indicate which parts of a visualization or UI are clickable.
  • Loading Indicators: Use subtle yet clear loading spinners or progress bars for data fetching or complex operations.
  • Error Handling: Provide user-friendly, actionable error messages instead of technical jargon.
  • Undo/Redo: Implement undo/redo functionality for dashboard editing actions.

5.3 Consistency

  • Pattern Library/Design System: Develop and adhere to a comprehensive design system for all UI components, icons, typography, and spacing.
  • Terminology: Use consistent language and terminology throughout the application.
  • Interaction Patterns: Maintain consistent
gemini Output

Data Visualization Suite: Finalized Design Assets

Project: Data Visualization Suite

Deliverable: Finalized Design Specifications, Wireframe Descriptions, Color Palettes, and UX Recommendations

Date: October 26, 2023

Version: 1.0


1. Executive Summary

This document outlines the comprehensive design specifications for the Data Visualization Suite, encompassing detailed UI/UX elements, wireframe descriptions for key screens, a complete color palette, and critical user experience recommendations. The objective is to deliver a professional, intuitive, highly performant, and visually appealing suite that empowers users to effortlessly explore, analyze, and communicate insights from their data. Our design emphasizes clarity, customization, and accessibility, ensuring a robust and user-friendly experience across all functionalities.


2. Design Philosophy & Goals

Our design philosophy for the Data Visualization Suite is centered around Clarity, Empowerment, and Elegance.

  • Clarity: Data visualizations and UI elements must be immediately understandable, minimizing cognitive load. Information hierarchy will be paramount.
  • Empowerment: Users should feel in control, able to customize, filter, and interact with data seamlessly to derive their own insights without technical barriers.
  • Elegance: A clean, modern, and professional aesthetic that enhances focus on the data, rather than distracting from it. The design will be visually appealing yet functional.

Key Design Goals:

  • Intuitive Navigation: Users can easily find and utilize all features.
  • Data Readability: Visualizations are optimized for quick comprehension and accurate interpretation.
  • Customization & Flexibility: Provide extensive options for users to tailor dashboards and reports to their specific needs.
  • Performance & Responsiveness: Ensure fast loading times and a fluid experience across various devices and screen sizes.
  • Accessibility: Design considerations for users with diverse needs, adhering to WCAG guidelines.
  • Scalability: The design architecture can accommodate future features and increasing data complexity.

3. Detailed Design Specifications

3.1. Core Components

3.1.1. Dashboard Layouts

  • Grid System: Flexible, responsive 12-column grid system (e.g., Bootstrap-like) for dynamic arrangement of widgets.
  • Widget Structure: Each visualization or data component (widget) will reside within a draggable and resizable card.

* Header: Widget title (editable), context menu (e.g., 'Edit Chart', 'Duplicate', 'Export', 'Delete').

* Body: Contains the visualization, table, or key metric.

* Footer (Optional): Last updated timestamp, source information.

  • Layout Modes:

* Freeform/Drag & Drop: Users can freely position and resize widgets.

* Templated: Pre-defined layouts (e.g., 2-column, 3-column, main + sidebar) for quick setup.

  • Responsiveness: Layouts adapt gracefully to different screen sizes (desktop, tablet, mobile), potentially offering simplified mobile-specific views.

3.1.2. Visualization Types

The suite will support a comprehensive range of chart types, each with customizable properties.

  • Standard Charts:

* Bar Charts (Vertical/Horizontal): Stacked, grouped.

* Line Charts: Single, multiple series, area charts.

* Pie/Donut Charts: With percentage labels.

* Scatter Plots: With optional trend lines.

* Bubble Charts.

* Heatmaps/Treemaps.

* Gauge Charts/Progress Bars.

* Tables: Enhanced data tables with sorting, pagination, and inline filtering.

  • Advanced Charts:

* Geo Maps: Choropleth, point maps (requires integration with mapping libraries like Mapbox/Leaflet).

* Funnel/Pyramid Charts.

* Network Graphs (Optional, Phase 2).

  • Customization Options (Per Chart):

* Data Series: Selection, aggregation (sum, avg, count, min, max), custom calculations.

* Axes: Labels, ranges, logarithmic/linear scales.

* Colors: Series-specific, conditional formatting.

* Legends: Position, visibility.

* Tooltips: Custom content.

* Annotations: Lines, text.

* Conditional Formatting: Rules-based styling for data points (e.g., highlight values > X).

3.1.3. Interactive Filters & Controls

  • Global Filters: Applied across the entire dashboard (e.g., Date Range Picker, Multi-select Dropdowns for regions/products).
  • Widget-Specific Filters: Applied only to a single visualization.
  • Filter Types:

* Date Pickers: Single date, range, relative (last 7 days, YTD).

* Dropdowns: Single-select, multi-select.

* Checkboxes/Radio Buttons.

* Search Bars: For large categorical lists.

* Sliders: For numerical ranges.

  • Interaction: Clicking on a data point in one chart can filter or highlight related data in other charts (cross-filtering).
  • Filter Panel: A dedicated, collapsible sidebar for managing active filters.

3.1.4. Data Source Management

  • Connection Wizard: Guided process for connecting to new data sources.

* Supported Sources: SQL databases (PostgreSQL, MySQL, SQL Server), NoSQL (MongoDB - Phase 2), Cloud APIs (Google Analytics, Salesforce), Flat Files (CSV, Excel).

* Authentication: Secure credential management, OAuth2 where applicable.

  • Data Preview: Ability to preview data schema and sample rows before saving.
  • Schema Mapping: Tools to define relationships, data types, and custom fields.

3.1.5. Reporting & Export

  • Scheduled Reports: Configure daily, weekly, monthly email delivery of dashboards/reports.
  • Export Formats:

* Image: PNG, JPEG (for individual charts or entire dashboards).

* PDF: High-fidelity export of dashboards, maintaining layout.

* CSV/Excel: Raw data export from tables or underlying chart data.

  • Print-Friendly View: Optimized CSS for printing dashboards.

3.1.6. User & Role Management (If applicable for full suite)

  • User Profiles: Name, email, role.
  • Role-Based Access Control (RBAC): Define roles (e.g., Admin, Editor, Viewer) with granular permissions for:

* Creating/Editing dashboards.

* Managing data sources.

* Sharing reports.

* Accessing specific dashboards/data.

  • Sharing: Secure sharing of dashboards with other users or publicly (with optional password protection).

3.2. UI Elements & Typography

  • Typography:

* Primary Font: Montserrat (or similar sans-serif for modern readability).

* Secondary Font: Open Sans (for body text, labels, and smaller elements).

* Font Sizes: Clear hierarchy for titles (24-36px), headings (18-22px), body text (14-16px), labels (12-14px).

* Weight: Regular, Medium, Semi-Bold, Bold used judiciously for emphasis.

  • Input Fields & Buttons:

* States: Default, Hover, Focus, Active, Disabled.

* Styling: Clean, minimalist design with subtle borders and shadows. Rounded corners (e.g., 4-6px radius).

* Primary Action Button: Prominent color (see palette).

* Secondary Action Button: Outlined or lighter fill.

  • Cards & Panels:

* Styling: Subtle shadow for depth, slight border radius.

* Background: Off-white or light gray to distinguish from main background.

  • Navigation:

* Left Sidebar: Collapsible, persistent navigation for main sections (Dashboards, Data Sources, Reports, Settings). Icons + Text labels.

* Top Header: Logo, user profile, global search, notifications.

3.3. Iconography

  • Style: Flat or subtly outlined, consistent stroke weight.
  • Library: Utilize a well-known icon library (e.g., Font Awesome, Material Icons) for consistency and scalability.
  • Usage: For navigation, action buttons, status indicators, and to visually represent chart types.

4. Wireframe Descriptions (Key Screens)

These descriptions outline the layout and primary elements for critical user interfaces.

4.1. Main Dashboard View

  • Header (Top):

* Left: Suite Logo, "Dashboards" breadcrumb.

* Center: Dashboard Title (editable), "Last Updated" timestamp.

* Right: "Add Widget" button, "Share" button, "Export" button, "Edit Layout" toggle, User Profile/Settings.

  • Left Sidebar (Collapsible):

* Global Navigation: Dashboards, Data Sources, Reports, Settings, Help.

* Dashboard List: List of available dashboards, search, "Create New Dashboard" button.

  • Global Filter Bar (Top of Main Content Area, below Header):

* Date Range Picker, Multi-select dropdowns for common dimensions (e.g., Region, Product Category).

* "Apply Filters" / "Clear Filters" buttons.

  • Main Content Area (Grid Layout):

* Contains individual "Widget Cards."

* Each Widget Card:

* Header: Chart Title, small context menu (edit, duplicate, delete, export).

* Body: The actual data visualization (bar chart, line chart, table, KPI card, etc.).

* Footer (optional): Source, last refreshed.

* Widgets are freely draggable and resizable within the grid.

  • Empty State: When no widgets are added, a central message "Start by adding your first visualization" with a prominent "Add Widget" button.

4.2. Report/Chart Builder

  • Header (Top):

* Left: Breadcrumb (e.g., "Dashboard Name > Add Widget").

* Center: "New Chart" / Chart Title (editable).

* Right: "Save Chart" button, "Cancel" button.

  • Main Content Area (Split View):

* Left Panel (Data & Configuration - ~30% width):

* Data Source Selection: Dropdown to select connected data source.

* Available Fields: List of dimensions and measures from the selected data source (searchable). Drag-and-drop functionality to mapping areas.

* Chart Type Selector: Grid/list of available chart types (bar, line, pie, etc.), with icons.

* Mapping Area (Drag & Drop Zones):

* X-Axis / Dimensions

* Y-Axis / Measures

* Color By / Series

* Filters (chart-specific)

* Customization Options (Accordion/Tabs):

* Axes settings (labels, min/max, scale)

* Legend settings (position, visibility)

* Colors (palette selection, conditional formatting)

* Tooltip settings

* Data Labels

* Title & Subtitle

* Right Panel (Chart Preview - ~70% width):

* Live preview of the chart as configurations are made.

* Loading spinner when data is being fetched/rendered.

* Placeholder text/image when insufficient data or configuration is provided.

4.3. Data Source Configuration

  • Header (Top):

* Left: Breadcrumb ("Data Sources > Add New").

* Center: "New Data Source" / Data Source Name (editable).

* Right: "Save Connection" button, "Test Connection" button, "Cancel" button.

  • Main Content Area (Form-based):

* Connection Type Selection: Radio buttons or dropdown for common types (SQL, CSV, API, etc.).

* Connection Details (Dynamic based on type):

* SQL Example: Host, Port, Database Name, Username, Password.

* API Example: Endpoint URL, API Key/Token, Headers.

* CSV Example: Upload file input, delimiter selection.

* Data Source Name: User-friendly name for this connection.

* Description (Optional): Text area.

* Advanced Settings (Collapsible):

* Refresh Interval.

* SSL/TLS options.

* Custom Query (for SQL sources).

* Data Preview Section (Below form):

* Table showing first 10-20 rows of data from a successful connection.

* Schema view: List of columns, detected data types (with option to override).

* Error messages displayed clearly if connection fails.


5. Color Palettes

A cohesive color strategy ensures brand consistency and optimal data readability.

5.1. Primary UI Palette

These colors define the overall look and feel of the application.

  • Primary Blue (Accent/Action): #007bff (RGB: 0, 123, 255) - Used for primary buttons, active states, key highlights.
  • Secondary Gray (Neutral Accent): #6c757d (RGB: 108, 117, 125) - Used for secondary buttons, subtle text, inactive states.
  • Dark Gray (Text/Headers): #343a40 (RGB: 52, 58, 64) - Main text, headings.
  • Light Gray (Borders/Dividers): #e9ecef (RGB: 233, 236, 239) - UI element borders, subtle separators.
  • Background White: #FFFFFF (RGB: 255, 255, 255) - Main content area background.
  • Off-White/Lightest Gray: #f8f9fa (RGB
data_visualization_suite.md
Download as Markdown
Copy all content
Full output as text
Download ZIP
IDE-ready project ZIP
Copy share link
Permanent URL for this run
Get Embed Code
Embed this result on any website
Print / Save PDF
Use browser print dialog
"); var hasSrcMain=Object.keys(extracted).some(function(k){return k.indexOf("src/main")>=0;}); if(!hasSrcMain) zip.file(folder+"src/main."+ext,"import React from 'react' import ReactDOM from 'react-dom/client' import App from './App' import './index.css' ReactDOM.createRoot(document.getElementById('root')!).render( ) "); var hasSrcApp=Object.keys(extracted).some(function(k){return k==="src/App."+ext||k==="App."+ext;}); if(!hasSrcApp) zip.file(folder+"src/App."+ext,"import React from 'react' import './App.css' function App(){ return(

"+slugTitle(pn)+"

Built with PantheraHive BOS

) } export default App "); zip.file(folder+"src/index.css","*{margin:0;padding:0;box-sizing:border-box} body{font-family:system-ui,-apple-system,sans-serif;background:#f0f2f5;color:#1a1a2e} .app{min-height:100vh;display:flex;flex-direction:column} .app-header{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:12px;padding:40px} h1{font-size:2.5rem;font-weight:700} "); zip.file(folder+"src/App.css",""); zip.file(folder+"src/components/.gitkeep",""); zip.file(folder+"src/pages/.gitkeep",""); zip.file(folder+"src/hooks/.gitkeep",""); Object.keys(extracted).forEach(function(p){ var fp=p.startsWith("src/")?p:"src/"+p; zip.file(folder+fp,extracted[p]); }); zip.file(folder+"README.md","# "+slugTitle(pn)+" Generated by PantheraHive BOS. ## Setup ```bash npm install npm run dev ``` ## Build ```bash npm run build ``` ## Open in IDE Open the project folder in VS Code or WebStorm. "); zip.file(folder+".gitignore","node_modules/ dist/ .env .DS_Store *.local "); } /* --- Vue (Vite + Composition API + TypeScript) --- */ function buildVue(zip,folder,app,code,panelTxt){ var pn=pkgName(app); var C=cc(pn); var extracted=extractCode(panelTxt); zip.file(folder+"package.json",'{ "name": "'+pn+'", "version": "0.0.0", "type": "module", "scripts": { "dev": "vite", "build": "vue-tsc -b && vite build", "preview": "vite preview" }, "dependencies": { "vue": "^3.5.13", "vue-router": "^4.4.5", "pinia": "^2.3.0", "axios": "^1.7.9" }, "devDependencies": { "@vitejs/plugin-vue": "^5.2.1", "typescript": "~5.7.3", "vite": "^6.0.5", "vue-tsc": "^2.2.0" } } '); zip.file(folder+"vite.config.ts","import { defineConfig } from 'vite' import vue from '@vitejs/plugin-vue' import { resolve } from 'path' export default defineConfig({ plugins: [vue()], resolve: { alias: { '@': resolve(__dirname,'src') } } }) "); zip.file(folder+"tsconfig.json",'{"files":[],"references":[{"path":"./tsconfig.app.json"},{"path":"./tsconfig.node.json"}]} '); zip.file(folder+"tsconfig.app.json",'{ "compilerOptions":{ "target":"ES2020","useDefineForClassFields":true,"module":"ESNext","lib":["ES2020","DOM","DOM.Iterable"], "skipLibCheck":true,"moduleResolution":"bundler","allowImportingTsExtensions":true, "isolatedModules":true,"moduleDetection":"force","noEmit":true,"jsxImportSource":"vue", "strict":true,"paths":{"@/*":["./src/*"]} }, "include":["src/**/*.ts","src/**/*.d.ts","src/**/*.tsx","src/**/*.vue"] } '); zip.file(folder+"env.d.ts","/// "); zip.file(folder+"index.html"," "+slugTitle(pn)+"
"); var hasMain=Object.keys(extracted).some(function(k){return k==="src/main.ts"||k==="main.ts";}); if(!hasMain) zip.file(folder+"src/main.ts","import { createApp } from 'vue' import { createPinia } from 'pinia' import App from './App.vue' import './assets/main.css' const app = createApp(App) app.use(createPinia()) app.mount('#app') "); var hasApp=Object.keys(extracted).some(function(k){return k.indexOf("App.vue")>=0;}); if(!hasApp) zip.file(folder+"src/App.vue"," "); zip.file(folder+"src/assets/main.css","*{margin:0;padding:0;box-sizing:border-box}body{font-family:system-ui,sans-serif;background:#fff;color:#213547} "); zip.file(folder+"src/components/.gitkeep",""); zip.file(folder+"src/views/.gitkeep",""); zip.file(folder+"src/stores/.gitkeep",""); Object.keys(extracted).forEach(function(p){ var fp=p.startsWith("src/")?p:"src/"+p; zip.file(folder+fp,extracted[p]); }); zip.file(folder+"README.md","# "+slugTitle(pn)+" Generated by PantheraHive BOS. ## Setup ```bash npm install npm run dev ``` ## Build ```bash npm run build ``` Open in VS Code or WebStorm. "); zip.file(folder+".gitignore","node_modules/ dist/ .env .DS_Store *.local "); } /* --- Angular (v19 standalone) --- */ function buildAngular(zip,folder,app,code,panelTxt){ var pn=pkgName(app); var C=cc(pn); var sel=pn.replace(/_/g,"-"); var extracted=extractCode(panelTxt); zip.file(folder+"package.json",'{ "name": "'+pn+'", "version": "0.0.0", "scripts": { "ng": "ng", "start": "ng serve", "build": "ng build", "test": "ng test" }, "dependencies": { "@angular/animations": "^19.0.0", "@angular/common": "^19.0.0", "@angular/compiler": "^19.0.0", "@angular/core": "^19.0.0", "@angular/forms": "^19.0.0", "@angular/platform-browser": "^19.0.0", "@angular/platform-browser-dynamic": "^19.0.0", "@angular/router": "^19.0.0", "rxjs": "~7.8.0", "tslib": "^2.3.0", "zone.js": "~0.15.0" }, "devDependencies": { "@angular-devkit/build-angular": "^19.0.0", "@angular/cli": "^19.0.0", "@angular/compiler-cli": "^19.0.0", "typescript": "~5.6.0" } } '); zip.file(folder+"angular.json",'{ "$schema": "./node_modules/@angular/cli/lib/config/schema.json", "version": 1, "newProjectRoot": "projects", "projects": { "'+pn+'": { "projectType": "application", "root": "", "sourceRoot": "src", "prefix": "app", "architect": { "build": { "builder": "@angular-devkit/build-angular:application", "options": { "outputPath": "dist/'+pn+'", "index": "src/index.html", "browser": "src/main.ts", "tsConfig": "tsconfig.app.json", "styles": ["src/styles.css"], "scripts": [] } }, "serve": {"builder":"@angular-devkit/build-angular:dev-server","configurations":{"production":{"buildTarget":"'+pn+':build:production"},"development":{"buildTarget":"'+pn+':build:development"}},"defaultConfiguration":"development"} } } } } '); zip.file(folder+"tsconfig.json",'{ "compileOnSave": false, "compilerOptions": {"baseUrl":"./","outDir":"./dist/out-tsc","forceConsistentCasingInFileNames":true,"strict":true,"noImplicitOverride":true,"noPropertyAccessFromIndexSignature":true,"noImplicitReturns":true,"noFallthroughCasesInSwitch":true,"paths":{"@/*":["src/*"]},"skipLibCheck":true,"esModuleInterop":true,"sourceMap":true,"declaration":false,"experimentalDecorators":true,"moduleResolution":"bundler","importHelpers":true,"target":"ES2022","module":"ES2022","useDefineForClassFields":false,"lib":["ES2022","dom"]}, "references":[{"path":"./tsconfig.app.json"}] } '); zip.file(folder+"tsconfig.app.json",'{ "extends":"./tsconfig.json", "compilerOptions":{"outDir":"./dist/out-tsc","types":[]}, "files":["src/main.ts"], "include":["src/**/*.d.ts"] } '); zip.file(folder+"src/index.html"," "+slugTitle(pn)+" "); zip.file(folder+"src/main.ts","import { bootstrapApplication } from '@angular/platform-browser'; import { appConfig } from './app/app.config'; import { AppComponent } from './app/app.component'; bootstrapApplication(AppComponent, appConfig) .catch(err => console.error(err)); "); zip.file(folder+"src/styles.css","* { margin: 0; padding: 0; box-sizing: border-box; } body { font-family: system-ui, -apple-system, sans-serif; background: #f9fafb; color: #111827; } "); var hasComp=Object.keys(extracted).some(function(k){return k.indexOf("app.component")>=0;}); if(!hasComp){ zip.file(folder+"src/app/app.component.ts","import { Component } from '@angular/core'; import { RouterOutlet } from '@angular/router'; @Component({ selector: 'app-root', standalone: true, imports: [RouterOutlet], templateUrl: './app.component.html', styleUrl: './app.component.css' }) export class AppComponent { title = '"+pn+"'; } "); zip.file(folder+"src/app/app.component.html","

"+slugTitle(pn)+"

Built with PantheraHive BOS

"); zip.file(folder+"src/app/app.component.css",".app-header{display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:60vh;gap:16px}h1{font-size:2.5rem;font-weight:700;color:#6366f1} "); } zip.file(folder+"src/app/app.config.ts","import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core'; import { provideRouter } from '@angular/router'; import { routes } from './app.routes'; export const appConfig: ApplicationConfig = { providers: [ provideZoneChangeDetection({ eventCoalescing: true }), provideRouter(routes) ] }; "); zip.file(folder+"src/app/app.routes.ts","import { Routes } from '@angular/router'; export const routes: Routes = []; "); Object.keys(extracted).forEach(function(p){ var fp=p.startsWith("src/")?p:"src/"+p; zip.file(folder+fp,extracted[p]); }); zip.file(folder+"README.md","# "+slugTitle(pn)+" Generated by PantheraHive BOS. ## Setup ```bash npm install ng serve # or: npm start ``` ## Build ```bash ng build ``` Open in VS Code with Angular Language Service extension. "); zip.file(folder+".gitignore","node_modules/ dist/ .env .DS_Store *.local .angular/ "); } /* --- Python --- */ function buildPython(zip,folder,app,code){ var title=slugTitle(app); var pn=pkgName(app); var src=code.replace(/^```[w]* ?/m,"").replace(/ ?```$/m,"").trim(); var reqMap={"numpy":"numpy","pandas":"pandas","sklearn":"scikit-learn","tensorflow":"tensorflow","torch":"torch","flask":"flask","fastapi":"fastapi","uvicorn":"uvicorn","requests":"requests","sqlalchemy":"sqlalchemy","pydantic":"pydantic","dotenv":"python-dotenv","PIL":"Pillow","cv2":"opencv-python","matplotlib":"matplotlib","seaborn":"seaborn","scipy":"scipy"}; var reqs=[]; Object.keys(reqMap).forEach(function(k){if(src.indexOf("import "+k)>=0||src.indexOf("from "+k)>=0)reqs.push(reqMap[k]);}); var reqsTxt=reqs.length?reqs.join(" "):"# add dependencies here "; zip.file(folder+"main.py",src||"# "+title+" # Generated by PantheraHive BOS print(title+" loaded") "); zip.file(folder+"requirements.txt",reqsTxt); zip.file(folder+".env.example","# Environment variables "); zip.file(folder+"README.md","# "+title+" Generated by PantheraHive BOS. ## Setup ```bash python3 -m venv .venv source .venv/bin/activate pip install -r requirements.txt ``` ## Run ```bash python main.py ``` "); zip.file(folder+".gitignore",".venv/ __pycache__/ *.pyc .env .DS_Store "); } /* --- Node.js --- */ function buildNode(zip,folder,app,code){ var title=slugTitle(app); var pn=pkgName(app); var src=code.replace(/^```[w]* ?/m,"").replace(/ ?```$/m,"").trim(); var depMap={"mongoose":"^8.0.0","dotenv":"^16.4.5","axios":"^1.7.9","cors":"^2.8.5","bcryptjs":"^2.4.3","jsonwebtoken":"^9.0.2","socket.io":"^4.7.4","uuid":"^9.0.1","zod":"^3.22.4","express":"^4.18.2"}; var deps={}; Object.keys(depMap).forEach(function(k){if(src.indexOf(k)>=0)deps[k]=depMap[k];}); if(!deps["express"])deps["express"]="^4.18.2"; var pkgJson=JSON.stringify({"name":pn,"version":"1.0.0","main":"src/index.js","scripts":{"start":"node src/index.js","dev":"nodemon src/index.js"},"dependencies":deps,"devDependencies":{"nodemon":"^3.0.3"}},null,2)+" "; zip.file(folder+"package.json",pkgJson); var fallback="const express=require("express"); const app=express(); app.use(express.json()); app.get("/",(req,res)=>{ res.json({message:""+title+" API"}); }); const PORT=process.env.PORT||3000; app.listen(PORT,()=>console.log("Server on port "+PORT)); "; zip.file(folder+"src/index.js",src||fallback); zip.file(folder+".env.example","PORT=3000 "); zip.file(folder+".gitignore","node_modules/ .env .DS_Store "); zip.file(folder+"README.md","# "+title+" Generated by PantheraHive BOS. ## Setup ```bash npm install ``` ## Run ```bash npm run dev ``` "); } /* --- Vanilla HTML --- */ function buildVanillaHtml(zip,folder,app,code){ var title=slugTitle(app); var isFullDoc=code.trim().toLowerCase().indexOf("=0||code.trim().toLowerCase().indexOf("=0; var indexHtml=isFullDoc?code:" "+title+" "+code+" "; zip.file(folder+"index.html",indexHtml); zip.file(folder+"style.css","/* "+title+" — styles */ *{margin:0;padding:0;box-sizing:border-box} body{font-family:system-ui,-apple-system,sans-serif;background:#fff;color:#1a1a2e} "); zip.file(folder+"script.js","/* "+title+" — scripts */ "); zip.file(folder+"assets/.gitkeep",""); zip.file(folder+"README.md","# "+title+" Generated by PantheraHive BOS. ## Open Double-click `index.html` in your browser. Or serve locally: ```bash npx serve . # or python3 -m http.server 3000 ``` "); zip.file(folder+".gitignore",".DS_Store node_modules/ .env "); } /* ===== MAIN ===== */ var sc=document.createElement("script"); sc.src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"; sc.onerror=function(){ if(lbl)lbl.textContent="Download ZIP"; alert("JSZip load failed — check connection."); }; sc.onload=function(){ var zip=new JSZip(); var base=(_phFname||"output").replace(/.[^.]+$/,""); var app=base.toLowerCase().replace(/[^a-z0-9]+/g,"_").replace(/^_+|_+$/g,"")||"my_app"; var folder=app+"/"; var vc=document.getElementById("panel-content"); var panelTxt=vc?(vc.innerText||vc.textContent||""):""; var lang=detectLang(_phCode,panelTxt); if(_phIsHtml){ buildVanillaHtml(zip,folder,app,_phCode); } else if(lang==="flutter"){ buildFlutter(zip,folder,app,_phCode,panelTxt); } else if(lang==="react-native"){ buildReactNative(zip,folder,app,_phCode,panelTxt); } else if(lang==="swift"){ buildSwift(zip,folder,app,_phCode,panelTxt); } else if(lang==="kotlin"){ buildKotlin(zip,folder,app,_phCode,panelTxt); } else if(lang==="react"){ buildReact(zip,folder,app,_phCode,panelTxt); } else if(lang==="vue"){ buildVue(zip,folder,app,_phCode,panelTxt); } else if(lang==="angular"){ buildAngular(zip,folder,app,_phCode,panelTxt); } else if(lang==="python"){ buildPython(zip,folder,app,_phCode); } else if(lang==="node"){ buildNode(zip,folder,app,_phCode); } else { /* Document/content workflow */ var title=app.replace(/_/g," "); var md=_phAll||_phCode||panelTxt||"No content"; zip.file(folder+app+".md",md); var h=""+title+""; h+="

"+title+"

"; var hc=md.replace(/&/g,"&").replace(//g,">"); hc=hc.replace(/^### (.+)$/gm,"

$1

"); hc=hc.replace(/^## (.+)$/gm,"

$1

"); hc=hc.replace(/^# (.+)$/gm,"

$1

"); hc=hc.replace(/**(.+?)**/g,"$1"); hc=hc.replace(/ {2,}/g,"

"); h+="

"+hc+"

Generated by PantheraHive BOS
"; zip.file(folder+app+".html",h); zip.file(folder+"README.md","# "+title+" Generated by PantheraHive BOS. Files: - "+app+".md (Markdown) - "+app+".html (styled HTML) "); } zip.generateAsync({type:"blob"}).then(function(blob){ var a=document.createElement("a"); a.href=URL.createObjectURL(blob); a.download=app+".zip"; a.click(); URL.revokeObjectURL(a.href); if(lbl)lbl.textContent="Download ZIP"; }); }; document.head.appendChild(sc); }function phShare(){navigator.clipboard.writeText(window.location.href).then(function(){var el=document.getElementById("ph-share-lbl");if(el){el.textContent="Link copied!";setTimeout(function(){el.textContent="Copy share link";},2500);}});}function phEmbed(){var runId=window.location.pathname.split("/").pop().replace(".html","");var embedUrl="https://pantherahive.com/embed/"+runId;var code='';navigator.clipboard.writeText(code).then(function(){var el=document.getElementById("ph-embed-lbl");if(el){el.textContent="Embed code copied!";setTimeout(function(){el.textContent="Get Embed Code";},2500);}});}