How cb-kozel/openmct works
Main Components
• Core Application: Represent the central “engine” (e.g., the MCT core files in src/MCT.js and its related scripts) that orchestrates the user interface, data processing, and plugin registration.
• API Modules: Group the various API directories (src/api) that handle different functionalities—for example, telemetry, composition, annotations, user, status, forms, menu, overlays, etc. Each of these exposes methods and contracts that plugins and UI components rely on.
• Plugin Architecture: Emphasize the “plugins” folder, which contains many feature extensions (for example, for charts, notebooks, imagery, timeline, etc.). These plugins are discoverable and register with the core application.
• User Interface: Capture the UI layer as seen in src/ui. This includes composable Vue components, inspector panels, layout components, and view controls which render the visualization on desktop and mobile devices.
• Persistence & External Services: From the plugins (such as persistence/couch) and build configuration files (CI configs, npm scripts, etc.), indicate the communication with external databases, web services, or telemetry data sources.
Relationships and Interactions
• Plugin Registration: Show how the core MCT module dynamically loads and registers plugins, which then extend the API with additional views, editors, and dashboards.
• Testing and Build Pipelines: Indicate how code quality and functionality are maintained through unit tests, e2e tests, visual tests (via Playwright), and CI/CD workflows (CircleCI, CodeQL, etc.) that feed back into the system.
Architectural Patterns & Design Principles
• Modular and Extensible Architecture: Very clearly show that Open MCT is built around a plugin-based model where nearly every functional part (UI components, telemetry, visualization, persistence, etc.) is modular.
• Separation of Concerns: Demonstrate the separation between the Core Engine (business logic and orchestration), the API layer (domain-specific services), and the UI (visual representation and interactivity).
• Event-Driven Communication: Indicate that events from user interactions or telemetry updates flow through central registries (for example, the Observer/Interceptor registries in src/api/objects) and then dispatch to plugins.
• Testability: Emphasize that testing is done at multiple levels (unit, e2e, performance, and visual regression), which implies that components are loosely coupled and well-isolated.
– Core Application Engine (MCT.js and supporting modules)
– API Layers (Telemetry, Objects, Menu, Forms, Overlays, etc.)
– UI Components (layout, context menus, inspectors, dashboards)
– External Services & Persistence Layer (e.g., CouchDB integration)
– Testing & Deployment Pipelines (CI/CD components, testing frameworks, build tools)
– From the UI (user input) to the core engine to the API and plugin calls.
– Data flows from plugins back to persistent storage or external services.
– Core modules versus extensions/plugins.
– UI components versus backend integration.
– Test/CI components could be shaded separately to indicate auxiliary support.