Training Course Builder
Run ID: 69ccea623e7fb09ff16a64372026-04-01Education
PantheraHive BOS
BOS Dashboard

Build a complete training course with modules, lesson plans, quizzes, hands-on exercises, and certification criteria for any subject.

Training Course Builder: Research & Design Requirements

This document outlines the detailed research and design requirements for the "Training Course Builder" platform. It encompasses functional specifications, information architecture, user experience (UX) recommendations, visual design elements, and high-level technical considerations, forming the foundational blueprint for development.


1. Project Overview & Core Objectives

The Training Course Builder platform aims to provide a comprehensive, intuitive, and robust solution for creating, managing, and delivering online training courses. It will empower instructors and organizations to build engaging educational content, assess learner progress, and issue certifications across various subjects.

Core Objectives:

  • Empowerment: Enable easy creation of structured courses with diverse content types.
  • Engagement: Facilitate interactive learning experiences through quizzes, exercises, and multimedia.
  • Assessment: Provide tools for effective learner evaluation and progress tracking.
  • Certification: Offer customizable certification options upon course completion.
  • Scalability: Design for future expansion and integration capabilities.
  • Usability: Ensure an intuitive and accessible user experience for both instructors and learners.

2. Functional Requirements & Information Architecture

2.1. Instructor/Admin Module

  • Course Management:

* Create, edit, delete courses.

* Define course title, description, prerequisites, learning objectives, estimated duration, and cover image.

* Set course visibility (public/private/draft).

* Manage course categories/tags for discoverability.

  • Module & Lesson Management:

* Add, reorder, edit, delete modules within a course.

* Add, reorder, edit, delete lessons within a module.

* Define lesson type (content, quiz, exercise).

* Set lesson completion criteria (e.g., must watch video, must pass quiz).

  • Content Editor:

* Rich Text Editor (WYSIWYG) for text-based content.

* Embed support for images, videos (YouTube, Vimeo, custom uploads), audio.

* Code block formatting for technical courses.

* File upload/download capabilities for supplementary materials.

  • Quiz Builder:

* Support for multiple-choice, true/false, fill-in-the-blank, short answer questions.

* Ability to add explanations for correct/incorrect answers.

* Set passing scores, time limits, and number of attempts.

* Question pooling and randomization options.

  • Hands-on Exercise Builder:

* Provide instructions, resources, and expected outcomes for practical exercises.

* Submission mechanism for learners (e.g., file upload, text input).

* Instructor grading interface with feedback options.

  • Certification Management:

* Design customizable certificate templates (logo, signature, dynamic fields like learner name, course name, completion date).

* Set criteria for certificate issuance (e.g., complete all modules, achieve minimum overall score).

  • User Management:

* View and manage enrolled learners.

* Track individual learner progress and scores.

* Assign roles (e.g., admin, instructor, learner).

  • Analytics & Reporting:

* Course enrollment numbers.

* Learner completion rates.

* Quiz performance statistics.

* Engagement metrics (e.g., time spent on lessons).

2.2. Learner Module

  • Course Catalog/Dashboard:

* Browse available courses by category, search, and filters.

* View enrolled courses with progress indicators.

* Access recently viewed lessons.

  • Course Overview Page:

* Detailed course description, objectives, modules outline.

* Enrollment/start course action.

* Instructor information.

  • Lesson Viewer:

* Display various content types (text, video, images, interactive elements).

* Progress indicator for the current lesson and module.

* Navigation controls (previous/next lesson).

* Ability to mark lessons as complete.

  • Quiz Taking Interface:

* Clear display of questions, options, and timer (if applicable).

* Immediate feedback or deferred grading based on quiz settings.

* Review mechanism for incorrect answers.

  • Exercise Submission:

* View exercise instructions and requirements.

* Upload files or submit text responses.

* View instructor feedback and grades.

  • Progress Tracking:

* Visual progress bars for lessons, modules, and overall course.

* Score reports for quizzes and exercises.

  • Certification:

* Downloadable PDF certificates upon successful course completion.

  • User Profile:

* Manage personal information.

* View course history and achievements.

2.3. Information Architecture (High-Level Structure)

  • Platform Root:

* Home Page / Dashboard

* Course Catalog

* Login / Register

  • Instructor Dashboard:

* My Courses (List)

* Course Detail (Edit Course, Add/Manage Modules/Lessons)

* Module Detail (Edit Module, Add/Manage Lessons)

* Lesson Detail (Content Editor, Quiz Builder, Exercise Builder)

* My Learners

* Analytics

* Certificates (Templates)

* Settings

  • Learner Dashboard:

* My Courses (List with Progress)

* Course Overview

* Lesson View (Content, Quiz, Exercise)

* Certificates (Earned)

* Profile Settings


3. Wireframe Descriptions (Key Screens)

The following descriptions outline the essential elements and layout for critical screens.

3.1. Instructor Dashboard

  • Layout: Left sidebar navigation (My Courses, Learners, Analytics, Certificates, Settings). Main content area with widgets.
  • Widgets: "Courses in Progress" (count), "New Enrollments," "Pending Submissions," "Recent Activity."
  • Primary Action: "Create New Course" button (prominently displayed).
  • Course List: Table/card view of active courses with status (Draft, Published), number of learners, and quick edit/view options.

3.2. Course Creation/Editing Interface

  • Layout: Multi-step form or tabbed interface.
  • Sections:

* Basic Info: Course Title, Description (rich text), Category, Tags, Cover Image Upload, Prerequisites, Learning Objectives.

* Structure: Drag-and-drop interface for Modules and Lessons. Buttons to "Add Module," "Add Lesson."

* Settings: Course visibility, pricing (if applicable), certification criteria.

  • Module/Lesson Card: Displays title, type (content/quiz/exercise), status. Icons for edit, delete, reorder.

3.3. Lesson Content Editor

  • Layout: Top bar with lesson title, module name, breadcrumbs. Main content area with a robust WYSIWYG editor. Right sidebar for lesson settings (e.g., publish status, duration, dependencies).
  • Editor Features: Standard formatting (bold, italic, lists), heading styles, image/video embed buttons, link insertion, code block, file upload.
  • Preview Button: To see how the lesson will appear to learners.

3.4. Quiz Builder

  • Layout: Top bar with quiz title, lesson name. Main area for question list. Right sidebar for quiz settings (passing score, time limit, attempts, randomization).
  • Question List: Each question displayed with type (MCQ, T/F), text, and quick edit/delete options.
  • Action: "Add New Question" button.
  • Question Editor: Pop-up or inline form for question text, answer options, correct answer selection, feedback text.

3.5. Learner Course Overview

  • Layout: Hero section with course title, cover image, instructor, overall progress bar. Below, an accordion or collapsible list of modules and lessons.
  • Module/Lesson List: Each item shows title, type, and completion status (checkmark). Clicking expands to show lesson details or navigates to the lesson.
  • Buttons: "Start Course," "Continue Learning," "Download Certificate" (if applicable).

3.6. Learner Lesson View

  • Layout: Top navigation with course title, module name, lesson name, and progress. Main content area displaying the lesson content. Bottom navigation for "Previous Lesson," "Next Lesson," "Mark Complete."
  • Interactive Elements: Embedded videos, quizzes, exercise submission forms integrated directly into the view.
  • Feedback: For quizzes, immediate feedback on answers (if configured).

4. Visual Design: Color Palettes & Typography

4.1. Color Palette

The chosen palette aims for professionalism, clarity, and accessibility, invoking a sense of trust and focus.

  • Primary Accent: #007BFF (Vibrant Blue) - Used for primary calls to action, active states, key headings. Evokes reliability and efficiency.
  • Secondary Accent: #28A745 (Success Green) - Used for success messages, completion indicators, positive feedback.
  • Tertiary Accent: #FFC107 (Warning Yellow) - Used for warnings, pending actions, highlights.
  • Neutral Dark: #343A40 (Charcoal Grey) - Main text, primary backgrounds for dark mode (if implemented), strong contrasts.
  • Neutral Medium: #6C757D (Slate Grey) - Secondary text, borders, inactive states.
  • Neutral Light: #F8F9FA (Off-White) - Main background color, content areas. Provides clean readability.
  • Error Red: #DC3545 (Alert Red) - Used for error messages, destructive actions.

Accessibility Note: Ensure sufficient contrast ratio (WCAG 2.1 AA or AAA) for all text and interactive elements against their backgrounds.

4.2. Typography

  • Primary Font (Headings): Montserrat (Sans-serif) - Modern, clean, and highly readable. Used for titles, section headers, and call-to-action text.
  • Secondary Font (Body Text): Open Sans (Sans-serif) - Highly versatile and legible at various sizes. Used for all paragraph text, descriptions, and UI labels.

Font Sizes (Responsive Design):

  • H1: 2.5rem (desktop), 1.8rem (mobile)
  • H2: 2rem (desktop), 1.5rem (mobile)
  • H3: 1.75rem (desktop), 1.3rem (mobile)
  • Body: 1rem (desktop), 0.9rem (mobile)
  • Small/Caption: 0.875rem (desktop), 0.75rem (mobile)

5. User Experience (UX) Recommendations

5.1. Intuitive Navigation & Information Hierarchy

  • Clear Labeling: Use concise and descriptive labels for all navigation items, buttons, and form fields.
  • Breadcrumbs: Implement breadcrumbs for complex multi-level pages (e.g., Instructor Dashboard > Course Name > Module Name > Lesson Name) to aid user orientation.
  • Consistent Layout: Maintain a consistent layout structure across similar pages (e.g., all editing interfaces should follow a similar pattern).

5.2. Feedback & Communication

  • Instant Validation: Provide real-time feedback for form inputs (e.g., "Field required," "Invalid email format").
  • Success/Error Messages: Use clear, non-intrusive notification messages for successful actions (e.g., "Course saved!") or errors.
  • Progress Indicators: Visual progress bars for course completion, loading states, and multi-step processes.

5.3. Content Creation Experience (Instructor)

  • Drag-and-Drop: Implement drag-and-drop functionality for reordering modules, lessons, and quiz questions.
  • WYSIWYG Editor: Provide a powerful yet user-friendly rich text editor with options for embedding media and code.
  • Templating: Consider pre-designed templates for common lesson structures or quiz types to speed up content creation.
  • Auto-Save: Implement an auto-save feature for content in progress to prevent data loss.

5.4. Learning Experience (Learner)

  • Focused View: Minimize distractions in the lesson viewing interface.
  • Accessibility: Ensure all content is accessible (keyboard navigation, screen reader compatibility, sufficient color contrast, alt text for images, captions for videos).
  • Mobile Responsiveness: The platform must be fully responsive, providing an optimal experience on desktops, tablets, and mobile devices.
  • Gamification (Optional but Recommended):

* Badges for completing modules or courses.

* Leaderboards (if applicable to the course type).

* Points for quiz completion.

  • Discussion Forums: Integrate a simple discussion forum within courses or modules to foster peer-to-peer learning and instructor interaction.

5.5. Performance & Responsiveness

  • Fast Load Times: Optimize images and scripts to ensure quick page loading.
  • Smooth Interactions: Ensure animations and transitions are smooth and non-disruptive.
  • Browser Compatibility: Support major modern browsers (Chrome, Firefox, Safari, Edge).

6. High-Level Technical Considerations

  • Frontend Framework: React, Vue, or Angular for a dynamic and responsive user interface.
  • Backend Language/Framework: Python (Django/Flask), Node.js (Express), Ruby on Rails, or PHP (Laravel) for robust API development.
  • Database: PostgreSQL or MySQL for relational data (courses, users, quizzes). Potentially NoSQL (MongoDB) for flexible content storage if needed.
  • Cloud Hosting: AWS, Google Cloud, or Azure for scalable infrastructure.
  • Authentication: JWT-based authentication
gemini Output

Training Course Builder: Design Specifications & UX Recommendations

This document outlines the detailed design specifications, wireframe descriptions, color palette, and user experience (UX) recommendations for the "Training Course Builder" application. The goal is to create an intuitive, powerful, and professional tool that enables users to effortlessly build comprehensive training courses.


1. Detailed Design Specifications

The Training Course Builder will provide a structured workflow for creating, managing, and publishing educational content.

1.1 Core Workflow & Features

1.1.1 Course Management Dashboard

  • Purpose: Central hub for viewing and managing all created training courses.
  • Functionality:

* List all courses with status (Draft, Published, Archived).

* Quick actions: Create New Course, Edit, Duplicate, Delete, Preview, Publish/Unpublish.

* Search and filter capabilities (by status, title, creation date).

* Display key metrics per course (e.g., number of modules, lessons, quizzes).

1.1.2 Course Creation Workflow

  • Purpose: Guided process for defining the foundational elements of a new course.
  • Steps/Fields:

1. Basic Information:

* Course Title (required)

* Short Description (1-2 sentences)

* Long Description (rich text editor for detailed overview)

* Course Category/Tags

* Target Audience

* Course Image/Thumbnail

2. Learning Objectives:

* Add multiple high-level learning objectives for the entire course.

* Each objective should have a title and a brief description.

3. Course Settings:

* Access Control: Public, Private (invite-only), Password Protected.

* Enrollment options: Free, Paid (integration with payment gateway TBD).

* Completion Tracking: Automatic based on module completion, manual.

* Enable/Disable Certification.

1.1.3 Module Management

  • Purpose: Structure the course into logical sections.
  • Functionality:

* Add New Module: Title, Description, Module-specific Learning Objectives.

* Reorder Modules: Drag-and-drop functionality.

* Edit/Delete Module.

* Module Overview: Display count of lessons, quizzes, exercises within each module.

1.1.4 Lesson Plan Creation & Content Editor

  • Purpose: Create and manage individual lessons within modules.
  • Functionality:

* Add New Lesson: Title, Description.

* Rich Text Editor (WYSIWYG):

* Text formatting (bold, italics, underline, headings, lists).

* Embed images, videos (YouTube, Vimeo, custom upload), audio.

* Code blocks, tables.

* Hyperlinks.

* Attachments (PDFs, documents).

* Lesson Resources: Section to link external resources or downloadable files.

* Lesson Settings: Optional completion requirements (e.g., "Must spend X minutes on this lesson").

* Reorder Lessons within a module: Drag-and-drop.

* Duplicate/Delete Lesson.

1.1.5 Quiz Builder

  • Purpose: Create interactive assessments to test comprehension.
  • Functionality:

* Add New Quiz: Title, Description, Associated Module.

* Question Types:

* Multiple Choice (single answer)

* Multiple Select (multiple answers)

* True/False

* Short Answer (text input, manual grading optional)

* Matching

* For each question:

* Question text.

* Options (for MC, MS).

* Correct answer selection.

* Optional feedback (for correct/incorrect answers).

* Point value.

* Image/Media attachment.

* Quiz Settings:

* Pass Percentage.

* Time Limit (optional).

* Number of Attempts.

* Randomize Questions/Answers.

* Show Answers After Completion.

* Require completion for module/course progression.

1.1.6 Hands-on Exercise Builder

  • Purpose: Design practical activities for skill development.
  • Functionality:

* Add New Exercise: Title, Description, Associated Module.

* Exercise Instructions: Rich text editor for detailed steps, scenarios, resources needed.

* Expected Outcomes/Rubric: Define what success looks like.

* Submission Type (optional):

* Text input (for code, written responses).

* File upload (for projects, documents, images).

* "Mark as complete" (for offline activities).

* Grading Options: Manual (for instructor review), Peer Review (TBD for future iterations), Auto-graded (if applicable).

* Due Date (optional).

* Require completion for module/course progression.

1.1.7 Certification Criteria & Settings

  • Purpose: Define the requirements for learners to earn a certificate.
  • Functionality:

* Enable/Disable Certification for the course.

* Requirements:

* Complete all modules/lessons.

* Achieve a minimum overall quiz score (e.g., 70% across all quizzes).

* Submit/Pass all required hands-on exercises.

* Specific lesson/quiz/exercise must be completed.

* Certificate Design (Basic):

* Upload Logo.

* Customizable fields: Course Name, Learner Name, Date of Completion, Instructor Signature (image upload).

* Template selection (basic layouts).

* Automated Certificate Generation: Generate a downloadable PDF upon meeting criteria.

1.1.8 Preview & Publish

  • Purpose: Review the course from a learner's perspective and make it live.
  • Functionality:

* Preview Mode: View the entire course (or specific modules/lessons) as a student would, including navigation, quizzes, and exercises.

* Publish Course: Make the course accessible to the target audience.

* Unpublish Course: Take the course offline temporarily.

1.2 Technical Considerations (Brief)

  • Backend: Robust API-driven architecture to support content management, user authentication, and data persistence.
  • Frontend: Responsive web application, ensuring compatibility across various devices and screen sizes.
  • Database: Structured storage for course data, modules, lessons, questions, user progress, etc.
  • Cloud Storage: For media uploads (images, videos, documents).
  • Security: Data encryption, secure authentication, role-based access control.

2. Wireframe Descriptions

The following describes key screens and their layout, focusing on content hierarchy and user interaction.

2.1 Dashboard Screen

  • Layout:

* Header: Logo, User Profile/Settings, "Create New Course" button.

* Sidebar Navigation: Links to Dashboard, My Courses, Analytics (future), Settings.

* Main Content Area:

* Course Overview Cards: Grid or list view of courses. Each card displays: Course Title, Thumbnail, Status (Draft/Published), Progress Bar (if applicable), Last Edited Date, and quick action buttons (Edit, Preview, Publish).

* Search Bar & Filters: Above the course cards for easy navigation.

* "Create New Course" button: Prominently displayed.

2.2 Course Overview Screen (After selecting a course)

  • Layout:

* Header: Course Title, "Preview Course" button, "Publish/Unpublish" toggle/button, "Course Settings" button.

* Left Sidebar (Course Structure):

* Hierarchical tree view: Course Title > Modules > Lessons/Quizzes/Exercises.

* Drag-and-drop functionality for reordering.

* "Add Module," "Add Lesson," "Add Quiz," "Add Exercise" buttons contextually available.

* Selected item (e.g., a specific lesson) highlighted.

* Main Content Area (Details Panel):

* Displays detailed information and editing interface for the currently selected item from the sidebar.

* If "Course Title" is selected: Course details (description, objectives, image).

* If "Module" is selected: Module title, description, objectives, and a list of its contents.

* If "Lesson" is selected: Rich text editor for lesson content.

* If "Quiz" is selected: Quiz builder interface.

* If "Exercise" is selected: Exercise builder interface.

* If "Certification" is selected: Certification settings.

2.3 Lesson Editor Screen (Main Content Area when Lesson is selected)

  • Layout:

* Header (within panel): Lesson Title, "Save" button, "Preview Lesson" button.

* Content Editor: Large WYSIWYG editor occupying the majority of the panel.

* Toolbar: Standard formatting options (bold, italic, lists, headings, media embed, link, table).

* Sidebar/Panel (Contextual):

* Optional: "Lesson Settings" (e.g., completion time).

* "Resources" section: Add file uploads or links.

2.4 Quiz Builder Screen (Main Content Area when Quiz is selected)

  • Layout:

* Header (within panel): Quiz Title, "Save" button, "Preview Quiz" button.

* Quiz Settings Section: Collapsible panel for pass percentage, time limit, attempts, randomization.

* Question List:

* Each question displayed as a card/block.

* Includes question text, type, point value.

* "Edit," "Duplicate," "Delete" actions per question.

* Drag-and-drop to reorder questions.

* "Add New Question" Button: Prominently placed at the bottom or top of the question list.

* Question Editor (Modal/Inline): When adding/editing a question, a modal window or an expanding inline editor appears with fields for question text, options, correct answer, feedback, points, and media upload.

2.5 Certification Settings Screen (Main Content Area when Certification is selected)

  • Layout:

* Header (within panel): "Certification Settings," "Save" button.

* Toggle: "Enable Certification for this Course."

* Requirements Section:

* Checkboxes or input fields for "Complete all modules," "Minimum overall quiz score (%)," "Complete specific exercises."

* Input fields for specific score percentages.

* Certificate Design Section:

* Upload Logo button.

* Basic template preview.

* Customizable text fields (e.g., "Instructor Name," "Issuing Authority").

* "Download Sample Certificate" button.


3. Color Palette

A professional, clean, and accessible color palette is crucial for a positive user experience.

  • Primary Brand Color (Indigo/Deep Blue): #3F51B5 (or a similar shade like #2C3E50 for a more corporate feel)

Usage:* Main call-to-action buttons, primary navigation highlights, brand elements.

  • Secondary Accent Color (Teal/Light Blue): #00BCD4 (or a slightly muted #1ABC9C)

Usage:* Secondary buttons, interactive elements, progress indicators, subtle highlights.

  • Neutral Colors:

* Backgrounds (Light Gray): #F8F9FA or #F4F6F9 (for main content areas, cards)

* Text (Dark Gray): #343A40 or #212529 (for body text, headings)

* Borders/Dividers (Medium Gray): #E0E0E0 or #CED4DA

  • Feedback Colors:

* Success (Green): #4CAF50

* Warning (Orange): #FFC107

* Error (Red): #F44336

  • Accessibility: Ensure sufficient contrast ratios for all text and interactive elements (WCAG 2.1 AA compliance as a target).

4. UX Recommendations

User experience will be paramount to the success of the Training Course Builder.

  • Intuitive Navigation & Information Architecture:

* Clear Hierarchy: Use a consistent left-sidebar navigation for course structure (modules, lessons) with clear visual cues for parent-child relationships.

* Breadcrumbs: Implement breadcrumbs for deep navigation paths (e.g., Dashboard > Course Name > Module Name > Lesson Name).

* Consistent Placement: Ensure interactive elements (e.g., "Save," "Add New") are consistently located.

  • Direct Manipulation & Visual Feedback:

* Drag-and-Drop: Enable drag-and-drop for reordering modules, lessons, and quiz questions. Provide clear visual cues during dragging.

* Inline Editing: Where appropriate, allow for inline editing of titles and short descriptions to reduce clicks.

* Instant Feedback: Provide immediate visual feedback for user actions (e.g., "Saved successfully," "Item deleted").

  • Progress Indicators & Workflow Guidance:

* Step-by-Step Wizards: For initial course creation, use a clear, multi-step wizard with progress indicators.

* Completion Status: Visually indicate completed sections or required fields.

* Empty States: Provide helpful messages and clear calls-to-action for empty sections (e.g., "No lessons yet. Click here to add your first lesson!").

  • Rich Content Editing Experience:

* Robust WYSIWYG Editor: Provide a feature-rich yet uncluttered editor with common formatting options readily available.

* Media Management: Easy upload and embedding of images and videos. Consider a simple media library.

  • Accessibility:

* Keyboard Navigation: Ensure all interactive elements are reachable and operable via keyboard.

* Screen Reader Compatibility: Use proper semantic HTML and ARIA attributes.

* Color Contrast: Adhere to WCAG 2.1 AA standards for text and interactive elements.

* Alt Text: Encourage and facilitate adding alt text for images.

  • Efficiency & Productivity:

* Duplication Feature: Allow users to duplicate modules, lessons, quizzes, or even entire courses to save time.

* Templates (Future): Offer pre-built templates for common course structures or quiz types.

* Keyboard Shortcuts: Consider implementing common keyboard shortcuts for power users.

  • Error Prevention & Recovery:

* Confirmation Dialogs: For destructive actions (e.g., deleting a course, module).

* Auto-Save: Implement auto-save functionality for content editors to prevent data loss.

* Clear Error Messages: Provide user-friendly and actionable error messages.

  • Responsiveness:

* The interface must be fully responsive, adapting seamlessly to different screen sizes (desktop, tablet, mobile) to ensure a consistent experience for creators on the go.

By adhering to these design specifications and UX recommendations, the Training Course Builder will be a powerful, user-friendly, and highly effective tool for developing engaging and professional training content.

gemini Output

Finalized Design Assets for the Training Course Builder

This document outlines the detailed design specifications, wireframe descriptions, color palettes, and user experience (UX) recommendations for the "Training Course Builder" output. The goal is to create a professional, engaging, and highly intuitive learning platform experience, ensuring optimal knowledge retention and user satisfaction.


1. Overall Design Philosophy

The design for the training course platform will be clean, modern, and user-centric. It prioritizes readability, clear navigation, and an uncluttered interface to minimize cognitive load. Emphasis is placed on accessibility, responsiveness across devices, and a consistent visual language that reinforces professionalism and trustworthiness. The design aims to make complex learning content digestible and engaging through thoughtful layout, strategic use of color, and intuitive interactions.


2. Detailed Design Specifications

2.1. Typography

  • Primary Heading Font (H1, H2): A strong, legible sans-serif font for impact and clarity (e.g., Montserrat, Open Sans Bold).

* H1 (Course Title): 48px - 64px, bold.

* H2 (Module Title): 32px - 40px, semi-bold.

* H3 (Lesson Title): 24px - 30px, medium.

  • Body Text Font: A highly readable sans-serif font for long-form content (e.g., Lato, Roboto, Inter).

* Body Paragraphs: 16px - 18px, regular line height 1.5 - 1.6.

* Captions/Labels: 12px - 14px, regular.

  • Font Weights: Utilize regular, medium, semi-bold, and bold to establish visual hierarchy without introducing too many distinct typefaces.
  • Color: Dark gray (#333333) for primary text, lighter gray (#666666) for secondary text/captions.

2.2. Iconography

  • Style: Flat or subtly outlined icons, consistent in style and stroke weight.
  • Purpose: Used for navigation, module/lesson types (e.g., video, quiz, document), progress indicators, and interactive elements.
  • Set: Utilize a well-known icon library (e.g., Font Awesome, Material Icons) for consistency and scalability.
  • Color: Inherit text color or use a subtle accent color.

2.3. Imagery & Media

  • Course Thumbnails: High-quality, relevant images (16:9 aspect ratio recommended) for course cards.
  • Module/Lesson Banners: Optional, subtle background images or solid color blocks with module titles.
  • Video Players: Embed standard players (e.g., YouTube, Vimeo, custom HTML5 player) with consistent controls and responsiveness.
  • Diagrams/Infographics: Clear, vector-based, and annotated for easy comprehension.
  • Instructor Photos: Professional headshots, circular or rounded square format.
  • Accessibility: All images should have descriptive alt text. Videos should include captions/transcripts.

2.4. Interactive Elements

  • Buttons (Primary CTA): Solid background, rounded corners, clear contrasting text. Hover state with subtle color change or shadow.

* Example: [Primary Color] background, white text.

  • Buttons (Secondary/Ghost): Outline style or lighter background, used for less critical actions.

* Example: white background, [Primary Color] border and text.

  • Links: Underlined on hover or distinct text color ([Accent Color]).
  • Forms/Input Fields: Clean, minimal design with clear labels. Focus state with a subtle border highlight.
  • Progress Bars: Clear visual representation of completion, using [Primary Color] for filled portion.
  • Navigation: Sticky header for global navigation, side navigation for module/lesson structure. Highlight active state.
  • Quizzes: Radio buttons/checkboxes for selection, clear submit button, immediate feedback.

2.5. Responsiveness

  • Mobile-First Approach: Design and develop for mobile devices first, then scale up to tablets and desktops.
  • Breakpoints: Define standard breakpoints (e.g., 576px, 768px, 992px, 1200px) for responsive layouts.
  • Fluid Grids: Use flexible grid systems (e.g., CSS Grid, Flexbox) to ensure content adapts gracefully.
  • Touch Targets: Ensure interactive elements are sufficiently large for touch interaction on mobile devices (minimum 44x44px).

2.6. Accessibility (WCAG 2.1 AA Compliance)

  • Color Contrast: Ensure sufficient contrast between text and background colors.
  • Keyboard Navigation: All interactive elements must be navigable via keyboard (Tab key).
  • Focus States: Clearly visible focus indicators for interactive elements.
  • ARIA Attributes: Use appropriate ARIA roles and attributes for screen readers.
  • Semantic HTML: Structure content with proper HTML5 elements (headings, lists, landmarks).
  • Alternative Text: Provide alt text for all meaningful images.
  • Transcripts/Captions: Offer transcripts for audio content and captions for video content.

3. Wireframe Descriptions (Key Pages)

3.1. Course Landing Page

  • Header: Global navigation (Logo, Home, My Courses, Profile/Login).
  • Hero Section: Large course title (H1), short compelling description, engaging hero image/video background, primary "Enroll Now" CTA.
  • Course Overview: Key benefits, learning objectives (bullet points), target audience.
  • Modules Section: List of modules with titles (H2), brief descriptions, and estimated duration. Each module can be an accordion or collapsible section.
  • Instructor(s) Section: Photo, name, brief bio, and credentials for each instructor.
  • What You'll Learn/Skills Gained: Detailed list of outcomes.
  • Certification: Description of certification, criteria, and sample certificate image.
  • FAQs: Accordion section for common questions.
  • Testimonials/Reviews: Social proof.
  • Footer: Copyright, privacy policy, terms of service, social media links.

3.2. Course Dashboard / My Learning Page

  • Header: Global navigation.
  • Welcome Banner: Personalized welcome message, overall course progress bar (e.g., "75% Complete").
  • Currently Active Course Card: Prominently display the course the user is currently engaged with, with a "Continue Learning" button linking to the last visited lesson.
  • My Courses List: Grid or list view of all enrolled courses, each with:

* Course thumbnail/title.

* Individual progress bar.

* "Continue" or "Start Course" button.

* Option to view certificate if completed.

  • Upcoming Deadlines/Tasks (Optional): If the course has scheduled assignments or live sessions.
  • Notifications: Recent activity, new content alerts.

3.3. Module Overview Page

  • Header: Global navigation, Course Title (clickable breadcrumb).
  • Module Header: Module title (H2), brief description, estimated duration, module progress bar.
  • Lessons List: List of all lessons within the module. Each lesson item includes:

* Lesson number/title (H3).

* Lesson type icon (e.g., video, text, quiz, exercise).

* Status indicator (completed, in progress, locked/upcoming).

* Brief description/learning objective.

* "Start" or "Resume" button.

  • Module Resources (Optional): Downloadable PDFs, external links relevant to the entire module.
  • Navigation: "Previous Module" and "Next Module" buttons.

3.4. Lesson Page (Content View)

  • Header: Global navigation, breadcrumbs (Course > Module > Lesson).
  • Left Sidebar (Sticky): Module navigation (list of lessons within the current module). Highlight current lesson.
  • Main Content Area:

* Lesson Title (H3).

* Primary content (video player, rich text, images, code snippets).

* Clear headings (H4, H5) to break up text.

* Interactive elements (e.g., embedded quizzes, simulations).

  • Right Sidebar (Optional):

* Table of contents for long lessons.

* "Ask a Question" / "Discussion" widget.

* Supplementary resources/downloads.

  • Footer Navigation: "Previous Lesson" and "Next Lesson" buttons. "Mark as Complete" button (if not auto-completed).
  • Progress Indicator: Small, persistent progress bar for the current lesson or module.

3.5. Quiz Page

  • Header: Global navigation, breadcrumbs.
  • Quiz Title: Clear title (e.g., "Module 1 Quiz: Foundations of [Topic]").
  • Instructions: Clear instructions (e.g., "Choose the best answer," "You have 10 minutes," "One attempt").
  • Question Area:

* Question number and text.

* Multiple choice (radio buttons), multiple select (checkboxes), true/false, short answer input fields.

* Images or media relevant to the question.

  • Submission: "Submit Quiz" button (disabled until all required questions are answered).
  • Feedback (Post-Submission):

* Score summary.

* Correct/Incorrect indicators for each question.

* Explanations for correct answers.

* Option to review answers or retake (if allowed).

3.6. Hands-on Exercise Page

  • Header: Global navigation, breadcrumbs.
  • Exercise Title: Clear title (H3).
  • Overview/Objective: What the user will achieve.
  • Instructions: Step-by-step guide, clearly numbered, with code blocks, screenshots, or diagrams as needed.
  • Resources: Links to external tools, starter files for download.
  • Submission Area (Optional):

* Text area for code/answers.

* File upload field.

* "Submit Exercise" button.

  • Example Solution (Optional, post-submission/completion): Hidden by default, revealed after an attempt or completion.
  • Discussion Forum: Integrated section for learners to ask questions or share insights related to the exercise.
  • Navigation: "Previous Lesson" and "Next Lesson" buttons.

3.7. Certification Page

  • Header: Global navigation.
  • Certificate Display: Prominent display of the digital certificate:

* Course title.

* Learner's name.

* Date of completion.

* Instructor/Institution signature/logo.

* Unique certificate ID/QR code for verification.

  • Actions:

* "Download PDF" button.

* "Share to LinkedIn" button.

* "Verify Certificate" link (for external sharing).

  • Congratulations Message: Reinforce achievement.

4. Color Palette

The chosen palette aims for professionalism, approachability, and excellent readability.

  • Primary Brand Color: #007BFF (A vibrant, trustworthy blue - common for tech/education)

Usage*: Primary CTAs, active navigation states, progress bars, key highlights.

  • Secondary Accent Color: #28A745 (A refreshing green for success, completion, positive feedback)

Usage*: Success messages, "Completed" indicators, certificate accents.

  • Neutral Palette:

* Background (Light): #F8F9FA (Soft off-white for main content areas)

* Background (Darker): #E9ECEF (Slightly darker for section backgrounds, cards)

* Text (Primary): #343A40 (Dark charcoal for main body text)

* Text (Secondary): #6C757D (Medium gray for captions, secondary info)

* Borders/Dividers: #DEE2E6 (Light gray for subtle separation)

  • Feedback/Status Colors:

* Success: #28A745 (Green - already defined as secondary accent)

* Warning: #FFC107 (Yellow/Orange - for caution, pending actions)

* Error: #DC3545 (Red - for incorrect answers, error messages)


5. UX Recommendations

5.1. Clear and Consistent Navigation

  • Global Navigation: Persistent header with essential links (Home, My Courses, Profile/Settings).
  • Course-Specific Navigation: Dedicated sidebar or collapsible menu for modules and lessons within a course.
  • Breadcrumbs: Always show the user's current location within the course hierarchy (e.g., "Course Name > Module Name > Lesson Name").
  • Contextual Navigation: "Previous" and "Next" buttons on lesson pages to facilitate linear progression.

5.2. Visible Progress Tracking

  • Overall Course Progress: Prominent progress bar on the dashboard and course landing page.
  • Module Progress: Progress bars on module overview pages and potentially within the module navigation sidebar.
  • Lesson Completion: Clear indicators (e.g., checkmarks, different color) next to completed lessons.
  • "Continue Learning" Feature: Automatically resume where the user left off.

5.3. Immediate and Constructive Feedback

  • Quiz Results: Provide instant feedback on answers, including correct explanations.
  • Form Submissions: Clear success or error messages for form interactions.
  • Interactive Elements: Visual cues (e.g., button presses, hover states) for all interactive elements.

5.4. Optimized Content Presentation

  • Chunking: Break down long lessons into smaller, digestible sections with clear headings and subheadings.
  • Multimedia Integration: Seamlessly embed videos, audio, and interactive elements directly within the content.
  • Readability: Use appropriate font sizes, line heights, and paragraph spacing. Avoid overly long line lengths.
  • Visual Hierarchy: Use typography, spacing, and color to guide the user's eye and highlight important information.

5.5. Engagement and Interactivity

  • Micro-Interactions: Subtle animations on hover, click, or completion for a more dynamic feel.
  • Interactive Quizzes/Polls: Integrate short, knowledge-check quizzes within lessons.
  • Discussion Forums/Comments: Allow learners to engage with content and peers directly on lesson pages.
  • Gamification (Optional): Consider elements like badges for module completion, points for quizzes, or leaderboards (if appropriate for the course type).

5.6. Accessibility First

  • Keyboard Navigability: Ensure all content and interactive elements are accessible via keyboard.
  • Screen Reader Compatibility: Implement semantic HTML and ARIA
training_course_builder.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);}});}