@mxtommy/kip 4.1.0-beta.1 → 4.1.0-beta.10

package/dist/out-tsc/src/app/widgets/widget-autopilot/widget-autopilot.component.js

@@ -1,1128 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-/**
- * Autopilot Widget Component
- *
- * A comprehensive autopilot control widget that supports both Signal K V1 (plugin-based)
- * and V2 (REST API-based) autopilot systems. Provides intuitive controls for autopilot
- * modes, heading adjustments, tacking, and route navigation.
- *
- * Features:
- * - Automatic API version detection (V1/V2)
- * - Dynamic endpoint discovery for V2 systems
- * - Mixed environment support (V2 preferred, V1 fallback)
- * - Comprehensive error handling and user feedback
- * - Promise-based state management for V2 operations
- * - Confirmation dialogs for critical operations (tack, waypoint advance)
- *
- * Supported Autopilot Operations:
- * - Mode switching (auto, wind, route, standby)
- * - Heading adjustments (±1°, ±10°)
- * - Tacking (port/starboard with confirmation)
- * - Waypoint advancement with confirmation
- * - V2-only: Absolute target heading, dodge mode
- *
- * @requires HttpClient, Angular Signals
- */
-import { Component, inject, signal, untracked, DestroyRef, computed, linkedSignal } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { MatButtonModule } from '@angular/material/button';
-import { MatIconModule } from '@angular/material/icon';
-import { TitleCasePipe } from '@angular/common';
-import { MatBadgeModule } from '@angular/material/badge';
-import { BaseWidgetComponent } from '../../core/utils/base-widget.component';
-import { WidgetHostComponent } from '../../core/components/widget-host/widget-host.component';
-import { SvgAutopilotComponent } from '../svg-autopilot/svg-autopilot.component';
-import { WidgetPositionComponent } from '../widget-position/widget-position.component';
-import { WidgetNumericComponent } from '../widget-numeric/widget-numeric.component';
-import { WidgetDatetimeComponent } from "../widget-datetime/widget-datetime.component";
-import { DashboardService } from '../../core/services/dashboard.service';
-import { SignalkRequestsService } from '../../core/services/signalk-requests.service';
-import { isEqual } from 'lodash-es';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { lastValueFrom, finalize } from 'rxjs';
-// Shared constants for API paths and configuration
-const API_PATHS = {
-    V1_MODE_PATH: 'self.steering.autopilot.state',
-    V2_BASE: '/signalk/v2/api',
-    V2_AUTOPILOTS: '/signalk/v2/api/vessels/self/autopilots',
-    V2_COURSE: '/signalk/v2/api/vessels/self/navigation/course'
-};
-const V2_ENDPOINT_TEMPLATES = {
-    BASE: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}`,
-    ENGAGE: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/engage`,
-    DISENGAGE: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/disengage`,
-    STATE: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/state`,
-    MODE: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/mode`,
-    TARGET_HEADING: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/target`,
-    TACK: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/tack`,
-    GYBE: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/gybe`,
-    DODGE: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/dodge`,
-    ADJUST_HEADING: (instance) => `${API_PATHS.V2_AUTOPILOTS}/${instance}/target/adjust`,
-};
-const COMMANDS = {
-    "auto": { "path": "self.steering.autopilot.state", "value": "auto" },
-    "wind": { "path": "self.steering.autopilot.state", "value": "wind" },
-    "route": { "path": "self.steering.autopilot.state", "value": "route" },
-    "standby": { "path": "self.steering.autopilot.state", "value": "standby" },
-    "+1": { "path": "self.steering.autopilot.actions.adjustHeading", "value": 1 },
-    "+10": { "path": "self.steering.autopilot.actions.adjustHeading", "value": 10 },
-    "-1": { "path": "self.steering.autopilot.actions.adjustHeading", "value": -1 },
-    "-10": { "path": "self.steering.autopilot.actions.adjustHeading", "value": -10 },
-    "tackToPort": { "path": "self.steering.autopilot.actions.tack", "value": "port" },
-    "tackToStarboard": { "path": "self.steering.autopilot.actions.tack", "value": "starboard" },
-    "advanceWaypoint": { "path": "self.steering.autopilot.actions.advanceWaypoint", "value": "1" },
-    // V2-only commands
-    "compass": { "path": "v2 only command", "value": "v2 only command" },
-    "gps": { "path": "v2 only command", "value": "v2 only command" },
-    "true wind": { "path": "v2 only command", "value": "v2 only command" },
-    "nav": { "path": "v2 only command", "value": "v2 only command" },
-};
-const DEFAULTS = {
-    COUNTDOWN_SECONDS: 5,
-    ERROR_DISPLAY_DURATION: 6000,
-    MESSAGE_DISPLAY_DURATION: 5000
-};
-let WidgetAutopilotComponent = class WidgetAutopilotComponent extends BaseWidgetComponent {
-    _requests = inject(SignalkRequestsService);
-    http = inject(HttpClient);
-    dashboard = inject(DashboardService);
-    _destroyRef = inject(DestroyRef);
-    apiEndpoints;
-    // Autopilot state Management
-    apState = signal(null);
-    apEngaged = signal(null);
-    apMode = signal(null);
-    dodgeModeActive = signal(false);
-    autopilotTargetHeading = signal(null);
-    autopilotTargetWindHeading = signal(null);
-    heading = signal(null);
-    crossTrackError = signal(null);
-    windAngleApparent = signal(null);
-    rudder = signal(null);
-    autopilotTarget = linkedSignal(() => {
-        const v1Heading = this.autopilotTargetHeading();
-        const v1Wind = this.autopilotTargetWindHeading();
-        if (this.apMode() === 'wind') {
-            return v1Wind ?? null;
-        }
-        return v1Heading ?? null;
-    });
-    // Request management
-    currentRequests = new Set();
-    // Keypad buttons & layout
-    apGrid = computed(() => this.apMode() ? 'grid' : 'none');
-    apEngageBtnDisabled = computed(() => {
-        const state = this.apState();
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const engaged = this.apEngaged();
-        const apiVersion = this.widgetProperties.config.autopilot.apiVersion;
-        if (!apiVersion)
-            return true;
-        if (apiVersion === "v1") {
-            return (['standby', 'off-line'].includes(state)) ? true : false;
-        }
-        if (apiVersion === "v2") {
-            return false;
-        }
-        return true;
-    });
-    apBtnDisabled = computed(() => {
-        const engaged = this.apEngaged();
-        const apiVersion = this.widgetProperties.config.autopilot.apiVersion;
-        if (apiVersion === "v1") {
-            return this.apMode() === 'standby' ? true : false;
-        }
-        if (engaged) {
-            return false;
-        }
-        return true;
-    });
-    adjustHdgBtnVisibility = computed(() => {
-        const mode = this.apMode();
-        if (['auto', 'compass', 'gps', 'wind', 'true wind', 'standby'].includes(mode)) {
-            return true;
-        }
-        return false;
-    });
-    tackBtnVisibility = computed(() => {
-        const mode = this.apMode();
-        if (['auto', 'compass', 'gps', 'wind', 'true wind', 'standby'].includes(mode)) {
-            return true;
-        }
-        return false;
-    });
-    routeBtnVisibility = computed(() => {
-        const mode = this.apMode();
-        if (mode === 'route' || mode === 'nav') {
-            return true;
-        }
-        return false;
-    });
-    // Widget messaging countdown
-    countdownOverlayVisibility = signal('hidden');
-    countdownOverlayText = signal('');
-    msgOverlayVisibility = signal('hidden');
-    msgOverlayText = signal('');
-    errorOverlayVisibility = signal('hidden');
-    errorOverlayText = signal('');
-    handleCountDownCounterTimeout = null;
-    handleConfirmActionTimeout = null;
-    handleDisplayErrorTimeout = null;
-    handleMessageTimeout = null;
-    isPersistentError = false; // Track if current error should persist
-    countDownValue = -1;
-    actionToBeConfirmed = "";
-    // Mode Menu
-    menuItems = computed(() => {
-        const mode = this.apMode();
-        const apiVersion = this.widgetProperties.config.autopilot.apiVersion;
-        const plugin = this.widgetProperties.config.autopilot.pluginId;
-        let menuItems = [];
-        untracked(() => {
-            if (apiVersion === 'v2') {
-                if (plugin == 'pypilot-autopilot-provider') {
-                    const allAPModes = [
-                        { label: 'Compass', action: 'compass' },
-                        { label: 'GPS', action: 'gps' },
-                        { label: 'Wind', action: 'wind' },
-                        { label: 'True Wind', action: 'true wind' },
-                        { label: 'Navigation', action: 'nav' },
-                        { label: 'Close', action: 'cancel', isCancel: true }
-                    ];
-                    menuItems = this.parseMenuItems(allAPModes, mode);
-                }
-            }
-            else if (apiVersion === 'v1') {
-                const allAPModes = [
-                    { label: 'Auto', action: 'auto' },
-                    { label: 'Wind', action: 'wind' },
-                    { label: 'Route', action: 'route' },
-                    { label: 'Close', action: 'cancel', isCancel: true }
-                ];
-                menuItems = this.parseMenuItems(allAPModes, mode);
-            }
-        });
-        return menuItems;
-    });
-    menuOpen = signal(false);
-    itemHeight = 60;
-    padding = 20;
-    // Integrated widget properties
-    embedWidgetColor = 'contrast';
-    nextWptProperties = signal({
-        type: "widget-position",
-        uuid: "db473695-42b1-4435-9d3d-ac2f27bf9665",
-        config: {
-            displayName: "Next WPT",
-            filterSelfPaths: true,
-            paths: {
-                "longPath": {
-                    description: "Longitude",
-                    path: "self.navigation.courseGreatCircle.nextPoint.position.longitude",
-                    source: "default",
-                    pathType: "number",
-                    isPathConfigurable: true,
-                    convertUnitTo: "longitudeMin",
-                    showPathSkUnitsFilter: true,
-                    pathSkUnitsFilter: null,
-                    sampleTime: 500
-                },
-                "latPath": {
-                    description: "Latitude",
-                    path: "self.navigation.courseGreatCircle.nextPoint.position.latitude",
-                    source: "default",
-                    pathType: "number",
-                    isPathConfigurable: true,
-                    convertUnitTo: "latitudeMin",
-                    showPathSkUnitsFilter: true,
-                    pathSkUnitsFilter: null,
-                    sampleTime: 500
-                }
-            },
-            color: this.embedWidgetColor,
-            enableTimeout: false,
-            dataTimeout: 5
-        }
-    }, { equal: isEqual });
-    ttwProperties = signal({
-        type: "widget-numeric",
-        uuid: "ee022f2f-ee23-41a7-b0b1-0928dc28864d",
-        config: {
-            displayName: "TTWpt",
-            filterSelfPaths: true,
-            paths: {
-                numericPath: {
-                    description: "Time To Waypoint",
-                    path: "self.navigation.course.calcValues.timeToGo",
-                    source: "default",
-                    pathType: "number",
-                    isPathConfigurable: true,
-                    convertUnitTo: "D HH:MM:SS",
-                    showPathSkUnitsFilter: true,
-                    pathSkUnitsFilter: null,
-                    sampleTime: 500
-                }
-            },
-            showMax: false,
-            showMin: false,
-            numDecimal: 1,
-            numInt: 1,
-            showMiniChart: false,
-            color: this.embedWidgetColor,
-            enableTimeout: false,
-            dataTimeout: 5,
-            ignoreZones: false
-        }
-    }, { equal: isEqual });
-    etaProperties = signal({
-        type: "widget-datetime",
-        uuid: "544ca35d-18bf-4a90-9aa8-b12312e3fc60",
-        config: {
-            displayName: "ETA",
-            filterSelfPaths: true,
-            paths: {
-                gaugePath: {
-                    description: "Estimated Time Of Arrival Date",
-                    path: "self.navigation.course.calcValues.estimatedTimeOfArrival",
-                    source: "default",
-                    pathType: "Date",
-                    isPathConfigurable: true,
-                    sampleTime: 500
-                }
-            },
-            dateFormat: "EEE HH:mm",
-            dateTimezone: "System Timezone -",
-            color: this.embedWidgetColor,
-            enableTimeout: false,
-            dataTimeout: 5
-        }
-    }, { equal: isEqual });
-    dtwProperties = signal({
-        type: "widget-numeric",
-        uuid: "ee02ef2f-ee23-41a7-b0b1-0928dc28864d",
-        config: {
-            displayName: "DTWpt",
-            filterSelfPaths: true,
-            paths: {
-                numericPath: {
-                    description: "Distance To Waypoint",
-                    path: "self.navigation.course.calcValues.distance",
-                    source: "default",
-                    pathType: "number",
-                    isPathConfigurable: true,
-                    convertUnitTo: "nm",
-                    showPathSkUnitsFilter: true,
-                    pathSkUnitsFilter: null,
-                    sampleTime: 500
-                }
-            },
-            showMax: false,
-            showMin: false,
-            numDecimal: 1,
-            numInt: 1,
-            showMiniChart: false,
-            color: this.embedWidgetColor,
-            enableTimeout: false,
-            dataTimeout: 5,
-            ignoreZones: false
-        }
-    }, { equal: isEqual });
-    xteProperties = signal({
-        type: "widget-numeric",
-        uuid: "9234856b-7573-4154-a44f-3baf7c6f119c",
-        config: {
-            displayName: "XTE",
-            filterSelfPaths: true,
-            paths: {
-                numericPath: {
-                    description: "Cross Track Error",
-                    path: "self.navigation.course.calcValues.crossTrackError",
-                    source: "default",
-                    pathType: "number",
-                    isPathConfigurable: true,
-                    convertUnitTo: "m",
-                    showPathSkUnitsFilter: true,
-                    pathSkUnitsFilter: null,
-                    sampleTime: 500
-                }
-            },
-            showMax: false,
-            showMin: false,
-            numDecimal: 1,
-            numInt: 1,
-            showMiniChart: false,
-            color: this.embedWidgetColor,
-            enableTimeout: false,
-            dataTimeout: 5,
-            ignoreZones: false
-        }
-    }, { equal: isEqual });
-    constructor() {
-        super();
-        this.defaultConfig = {
-            filterSelfPaths: true,
-            paths: {
-                "autopilotState": {
-                    description: "Autopilot State",
-                    path: "self.steering.autopilot.state",
-                    source: "default",
-                    pathType: "string",
-                    isPathConfigurable: false,
-                    showPathSkUnitsFilter: false,
-                    convertUnitTo: "",
-                    sampleTime: 500
-                },
-                "autopilotMode": {
-                    description: "Autopilot Mode",
-                    path: "self.steering.autopilot.mode",
-                    source: "default",
-                    pathType: "string",
-                    isPathConfigurable: false,
-                    showPathSkUnitsFilter: false,
-                    convertUnitTo: "",
-                    sampleTime: 500
-                },
-                "autopilotEngaged": {
-                    description: "Autopilot Engaged",
-                    path: 'self.steering.autopilot.engaged',
-                    source: 'default',
-                    pathType: "boolean",
-                    isPathConfigurable: false,
-                    showPathSkUnitsFilter: false,
-                    convertUnitTo: "",
-                    sampleTime: 500
-                },
-                "autopilotV2Target": {
-                    description: "Autopilot API v2 Target",
-                    path: 'self.steering.autopilot.target',
-                    source: 'default',
-                    pathType: "number",
-                    convertUnitTo: "deg",
-                    isPathConfigurable: false,
-                    showPathSkUnitsFilter: false,
-                    pathSkUnitsFilter: 'rad',
-                    sampleTime: 500
-                },
-                "autopilotTargetHeading": {
-                    description: "Autopilot Target Magnetic Heading",
-                    path: 'self.steering.autopilot.target.headingMagnetic',
-                    source: 'default',
-                    pathType: "number",
-                    convertUnitTo: "deg",
-                    isPathConfigurable: false,
-                    showPathSkUnitsFilter: false,
-                    pathSkUnitsFilter: 'rad',
-                    sampleTime: 500
-                },
-                "autopilotTargetWindHeading": {
-                    description: "Autopilot Target Apparent Wind Angle",
-                    path: 'self.steering.autopilot.target.windAngleApparent',
-                    source: 'default',
-                    pathType: "number",
-                    convertUnitTo: "deg",
-                    isPathConfigurable: false,
-                    showPathSkUnitsFilter: false,
-                    pathSkUnitsFilter: 'rad',
-                    sampleTime: 500
-                },
-                "rudderAngle": {
-                    description: "Rudder Angle",
-                    path: 'self.steering.rudderAngle',
-                    source: 'default',
-                    pathType: "number",
-                    convertUnitTo: "deg",
-                    isPathConfigurable: false,
-                    showPathSkUnitsFilter: false,
-                    pathSkUnitsFilter: 'rad',
-                    sampleTime: 500
-                },
-                "courseXte": {
-                    description: "Cross Track Error",
-                    path: "self.navigation.course.calcValues.crossTrackError",
-                    source: "default",
-                    pathType: "number",
-                    isPathConfigurable: false,
-                    convertUnitTo: "m",
-                    showPathSkUnitsFilter: true,
-                    pathRequired: false,
-                    pathSkUnitsFilter: 'm',
-                    sampleTime: 500
-                },
-                "headingMag": {
-                    description: "Magnetic Heading",
-                    path: 'self.navigation.headingMagnetic',
-                    source: 'default',
-                    pathType: "number",
-                    convertUnitTo: "deg",
-                    isPathConfigurable: true,
-                    pathRequired: false,
-                    showPathSkUnitsFilter: false,
-                    pathSkUnitsFilter: 'rad',
-                    showConvertUnitTo: false,
-                    sampleTime: 500
-                },
-                "headingTrue": {
-                    description: "True Heading",
-                    path: 'self.navigation.headingTrue',
-                    source: 'default',
-                    pathType: "number",
-                    convertUnitTo: "deg",
-                    isPathConfigurable: true,
-                    pathRequired: false,
-                    showPathSkUnitsFilter: false,
-                    pathSkUnitsFilter: 'rad',
-                    showConvertUnitTo: false,
-                    sampleTime: 500
-                },
-                "windAngleApparent": {
-                    description: "Apparent Wind Angle",
-                    path: 'self.environment.wind.angleApparent',
-                    source: 'default',
-                    pathType: "number",
-                    convertUnitTo: "deg",
-                    isPathConfigurable: true,
-                    pathRequired: false,
-                    showPathSkUnitsFilter: false,
-                    pathSkUnitsFilter: 'rad',
-                    showConvertUnitTo: false,
-                    sampleTime: 500
-                },
-                "windAngleTrueWater": {
-                    description: "Wind Angle True Water",
-                    path: 'self.environment.wind.angleTrueWater',
-                    source: 'default',
-                    pathType: "number",
-                    convertUnitTo: "deg",
-                    isPathConfigurable: true,
-                    pathRequired: false,
-                    showPathSkUnitsFilter: false,
-                    pathSkUnitsFilter: 'rad',
-                    showConvertUnitTo: false,
-                    sampleTime: 500
-                }
-            },
-            autopilot: {
-                invertRudder: true,
-                headingDirectionTrue: false,
-                courseDirectionTrue: false,
-                apiVersion: null,
-                instanceId: null,
-                pluginId: null,
-                modes: null // Default modes for V1
-            },
-            enableTimeout: false,
-            dataTimeout: 5,
-        };
-    }
-    ngOnInit() {
-        this.validateConfig();
-        this.startWidget();
-    }
-    startWidget() {
-        const err = {
-            statusCode: 500,
-            statusCodeDescription: 'Autopilot widget not configured',
-            requestId: '',
-            state: ''
-        };
-        const apiVersion = this.widgetProperties.config.autopilot.apiVersion;
-        const instanceId = this.widgetProperties.config.autopilot.instanceId;
-        const pluginId = this.widgetProperties.config.autopilot.pluginId;
-        // Helper for persistent error state
-        const setPersistentError = (message) => {
-            this.unsubscribeDataStream();
-            console.error(`[Autopilot Widget] ${message}`);
-            this.displayApError(err);
-            this.isPersistentError = true;
-            this.apMode.set('off-line');
-            this.apState.set('off-line');
-            this.apEngaged.set(false);
-        };
-        this.unsubscribeDataStream();
-        if (!apiVersion) {
-            setPersistentError('Not configured with autopilot API version, skipping initialization');
-            return;
-        }
-        if (apiVersion === 'v2') {
-            if (!instanceId) {
-                setPersistentError('No autopilot instance ID configured for V2 API, skipping initialization');
-                return;
-            }
-            if (!pluginId) {
-                setPersistentError('No autopilot plugin ID configured for V2 API, skipping initialization');
-                return;
-            }
-            this.apiEndpoints = this.setV2Endpoint(instanceId);
-            this.startV2Subscriptions();
-            return;
-        }
-        if (apiVersion === 'v1') {
-            this.startV1Subscriptions();
-            return;
-        }
-        // Unknown API version
-        setPersistentError(`Unknown autopilot API version: ${apiVersion}`);
-    }
-    setV2Endpoint(instanceId) {
-        const endpoints = {
-            engage: V2_ENDPOINT_TEMPLATES.ENGAGE(instanceId),
-            disengage: V2_ENDPOINT_TEMPLATES.DISENGAGE(instanceId),
-            mode: V2_ENDPOINT_TEMPLATES.MODE(instanceId),
-            state: V2_ENDPOINT_TEMPLATES.STATE(instanceId),
-            target: V2_ENDPOINT_TEMPLATES.TARGET_HEADING(instanceId),
-            tack: V2_ENDPOINT_TEMPLATES.TACK(instanceId),
-            gybe: V2_ENDPOINT_TEMPLATES.GYBE(instanceId),
-            dodge: V2_ENDPOINT_TEMPLATES.DODGE(instanceId),
-            adjustHeading: V2_ENDPOINT_TEMPLATES.ADJUST_HEADING(instanceId)
-        };
-        return endpoints;
-    }
-    isV2CommandSupported(command) {
-        return this.widgetProperties.config.autopilot.modes.includes(command);
-    }
-    updateConfig(config) {
-        this.widgetProperties.config = config;
-        // Cancel any ongoing HTTP requests
-        this.cancelAllHttpRequests();
-        // Clear any error or message overlays
-        this.isPersistentError = false;
-        this.errorOverlayVisibility.set("hidden");
-        this.errorOverlayText.set("");
-        this.apEngaged.set(null);
-        this.startWidget();
-    }
-    startV2Subscriptions() {
-        this.observeDataStream('autopilotState', newValue => {
-            if (newValue.data?.value) {
-                this.apState.set(newValue.data.value);
-            }
-            else {
-                this.apState.set('off-line');
-                console.warn('[Autopilot Widget] Autopilot state is null or not available');
-            }
-        });
-        this.observeDataStream('autopilotMode', newValue => {
-            if (newValue.data?.value) {
-                this.apMode.set(newValue.data.value);
-            }
-            else {
-                this.apMode.set('off-line');
-                console.warn('[Autopilot Widget] Autopilot mode is null or not available');
-            }
-        });
-        this.observeDataStream('autopilotEngaged', newValue => {
-            if (newValue.data?.value != null) {
-                this.apEngaged.set(newValue.data.value);
-            }
-            else {
-                this.apEngaged.set(false);
-                console.warn('[Autopilot Widget] Autopilot engaged is null or not available');
-            }
-        });
-        this.observeDataStream('autopilotV2Target', newValue => {
-            if (newValue.data?.value) {
-                this.autopilotTarget.set(newValue.data.value);
-            }
-            else {
-                this.autopilotTarget.set(null);
-                console.warn('[Autopilot Widget] Autopilot V2 target is null or not available');
-            }
-        });
-        this.startDataSubscription();
-    }
-    startV1Subscriptions() {
-        // For V1, we use this single legacy path
-        this.widgetProperties.config.paths['autopilotMode'].path = API_PATHS.V1_MODE_PATH;
-        this.observeDataStream('autopilotMode', newValue => {
-            if (newValue.data?.value) {
-                this.apMode.set(newValue.data.value);
-            }
-            else {
-                this.apMode.set('off-line');
-                console.warn('[Autopilot Widget] Autopilot V1 mode state is null or not available');
-            }
-        });
-        this.observeDataStream('autopilotTargetHeading', newValue => this.autopilotTargetHeading.set(newValue.data.value != null ? newValue.data.value : 0));
-        this.observeDataStream('autopilotTargetWindHeading', newValue => this.autopilotTargetWindHeading.set(newValue.data.value != null ? newValue.data.value : 0));
-        this.startDataSubscription();
-        // Subscribe to V1 autopilot PUT state changes
-        this.subscribePutResponse();
-        // Not used in V1, but needed for UI state management
-        this.apState.set(null);
-    }
-    startDataSubscription() {
-        this.observeDataStream('courseXte', newValue => this.crossTrackError.set(newValue.data.value != null ? newValue.data.value : 0));
-        this.observeDataStream('rudderAngle', newValue => {
-            if (newValue.data.value === null) {
-                this.rudder.set(null);
-            }
-            else {
-                this.rudder.set(this.widgetProperties.config.autopilot.invertRudder ? -newValue.data.value : newValue.data.value);
-            }
-        });
-        if (this.widgetProperties.config.autopilot.headingDirectionTrue) {
-            this.observeDataStream('headingTrue', newValue => this.heading.set(newValue.data.value != null ? newValue.data.value : 0));
-        }
-        else {
-            this.observeDataStream('headingMag', newValue => this.heading.set(newValue.data.value != null ? newValue.data.value : 0));
-        }
-        this.observeDataStream('windAngleApparent', newValue => this.windAngleApparent.set(newValue.data.value != null ? newValue.data.value : 0));
-    }
-    subscribePutResponse() {
-        this._requests.subscribeRequest().pipe(takeUntilDestroyed(this._destroyRef)).subscribe(requestResult => {
-            if (requestResult.widgetUUID == this.widgetProperties.uuid) {
-                this.commandReceived(requestResult);
-            }
-        });
-    }
-    /**
-     * Creates a managed HTTP request with automatic cancellation and tracking
-     * @param observable The HTTP Observable to manage
-     * @returns Observable with takeUntilDestroyed and tracking
-     */
-    makeHttpRequest(observable) {
-        const request = observable.pipe(takeUntilDestroyed(this._destroyRef));
-        this.currentRequests.add(request);
-        return request.pipe(finalize(() => this.currentRequests.delete(request)));
-    }
-    /**
-     * Cancels all ongoing HTTP requests
-     */
-    cancelAllHttpRequests() {
-        // Observables with takeUntilDestroyed() auto-cancel, just clear tracking
-        this.currentRequests.clear();
-    }
-    buildAndSendCommand(cmd) {
-        const cmdAction = COMMANDS[cmd];
-        if (typeof cmdAction === 'undefined') {
-            alert('Unknown Autopilot command: ' + cmd);
-            return;
-        }
-        if ((this.actionToBeConfirmed !== '') && (this.actionToBeConfirmed !== cmd)) {
-            this.clearConfirmCmd();
-        }
-        if (((cmd === 'tackToPort') || (cmd === 'tackToStarboard')) && (this.actionToBeConfirmed === '')) {
-            this.confirmTack(cmd);
-            return;
-        }
-        if (((cmd === 'route' && this.apMode() === 'route') || (cmd === 'route' && this.apMode() === 'nav')) && (this.actionToBeConfirmed === '')) {
-            this.confirmAdvanceWaypoint(cmd);
-            return;
-        }
-        if (this.actionToBeConfirmed === cmd) {
-            this.clearConfirmCmd();
-            if ((cmd === 'tackToPort') || (cmd === 'tackToStarboard')) {
-                const direction = cmd === 'tackToPort' ? 'port' : 'starboard';
-                this.performTackOrGybe('tack', direction);
-            }
-            if ((cmd === 'route' && this.apMode() === 'route') || (cmd === 'route' && this.apMode() === 'nav')) {
-                this.routeCommand(cmd, COMMANDS['advanceWaypoint']);
-            }
-            return;
-        }
-        this.routeCommand(cmd, cmdAction);
-    }
-    routeCommand(cmd, cmdAction) {
-        const apiVersion = this.widgetProperties.config.autopilot.apiVersion;
-        if (apiVersion === 'v2') {
-            if (cmd === 'route' && this.apMode() === 'nav') {
-                cmd = 'advanceWaypoint';
-            }
-            this.sendV2Command(cmd);
-        }
-        else if (apiVersion === 'v1' && !cmdAction.path.startsWith('v2:')) {
-            // V1 command
-            this.sendV1Command(cmdAction);
-        }
-        else {
-            console.error('[Autopilot Widget] Unsupported basic command:', cmdAction.path);
-            this.displayApError({
-                statusCode: 400,
-                statusCodeDescription: 'Unsupported Command',
-                message: `Command path '${cmdAction.path}' is not supported in the current API version`,
-                widgetUUID: this.widgetProperties.uuid
-            });
-        }
-    }
-    sendV1Command(cmdAction) {
-        this._requests.putRequest(cmdAction["path"], cmdAction["value"], this.widgetProperties.uuid);
-        console.log("AP Action:\n" + JSON.stringify(cmdAction));
-    }
-    /**
-     * Executes V2 autopilot commands using REST endpoints
-     *
-     * Special Handling:
-     * - Dodge mode: Toggles between POST (activate) and DELETE (deactivate)
-     * - Tack/Gybe: Appends direction to endpoint path
-     * - State tracking: Updates dodgeModeActive signal on successful dodge operations
-     *
-     * @param cmd V2 command identifier
-     * @param cmdAction Optional V1 command for compatibility (unused in V2)
-     * @param value Optional command value (direction for tack/gybe, heading for target)
-     */
-    async sendV2Command(cmd, value) {
-        const endpoints = this.apiEndpoints;
-        if (!endpoints) {
-            console.error('V2 endpoints not available');
-            return;
-        }
-        const dodge = this.dodgeModeActive();
-        let targetCommand;
-        switch (cmd) {
-            case '+1':
-                targetCommand = {
-                    path: !dodge ? endpoints.adjustHeading : endpoints.dodge,
-                    value: { value: +1, units: "deg" }
-                };
-                this.executeRestRequest('PUT', targetCommand);
-                break;
-            case '+10':
-                targetCommand = {
-                    path: !dodge ? endpoints.adjustHeading : endpoints.dodge,
-                    value: { value: +10, units: "deg" }
-                };
-                this.executeRestRequest('PUT', targetCommand);
-                break;
-            case '-1':
-                targetCommand = {
-                    path: !dodge ? endpoints.adjustHeading : endpoints.dodge,
-                    value: { value: -1, units: "deg" }
-                };
-                this.executeRestRequest('PUT', targetCommand);
-                break;
-            case '-10':
-                targetCommand = {
-                    path: !dodge ? endpoints.adjustHeading : endpoints.dodge,
-                    value: { value: -10, units: "deg" }
-                };
-                this.executeRestRequest('PUT', targetCommand);
-                break;
-            case 'advanceWaypoint':
-                targetCommand = {
-                    path: `${API_PATHS.V2_COURSE}/activeRoute/nextPoint`
-                };
-                this.executeRestRequest('PUT', targetCommand);
-                break;
-            case 'tack':
-                targetCommand = {
-                    path: `${endpoints.tack}/${value.value}`
-                };
-                this.executeRestRequest('POST', targetCommand);
-                break;
-            case 'gybe':
-                targetCommand = {
-                    path: `${endpoints.gybe}/${value}`
-                };
-                this.executeRestRequest('POST', targetCommand);
-                break;
-            case 'dodge':
-                targetCommand = {
-                    path: endpoints.dodge
-                };
-                if (this.dodgeModeActive()) {
-                    this.executeRestRequest('DELETE', targetCommand).then(response => {
-                        if (response.statusCode !== 200) {
-                            this.dodgeModeActive.set(false);
-                        }
-                    });
-                }
-                else {
-                    this.executeRestRequest('POST', targetCommand).then(response => {
-                        if (response.statusCode !== 200) {
-                            this.dodgeModeActive.set(true);
-                        }
-                    });
-                }
-                break;
-            case 'target_heading':
-                targetCommand = {
-                    path: endpoints.target,
-                    value: value
-                };
-                this.executeRestRequest('PUT', targetCommand);
-                break;
-            case 'standby':
-                {
-                    const targetCommand = {
-                        path: `${this.apEngaged() ? endpoints.disengage : endpoints.engage}`
-                    };
-                    this.executeRestRequest('POST', targetCommand);
-                }
-                break;
-            case 'auto':
-            case 'compass':
-            case 'gps':
-            case 'wind':
-            case 'true wind':
-            case 'route':
-            case 'nav':
-                await this.setModeAndEnable(cmd, endpoints);
-                break;
-            default:
-                console.error('Unknown V2 command:', cmd);
-                this.displayApError({
-                    statusCode: 400,
-                    statusCodeDescription: 'Unknown Command',
-                    message: `V2 command '${cmd}' is not supported`,
-                    widgetUUID: this.widgetProperties.uuid
-                });
-        }
-    }
-    async executeRestRequest(method, cmd) {
-        try {
-            let response;
-            switch (method) {
-                case 'POST':
-                    response = await lastValueFrom(this.makeHttpRequest(this.http.post(cmd.path, undefined)));
-                    break;
-                case 'PUT':
-                    response = await lastValueFrom(this.makeHttpRequest(this.http.put(cmd.path, cmd.value == null ? undefined : cmd.value)));
-                    break;
-                case 'DELETE':
-                    response = await lastValueFrom(this.makeHttpRequest(this.http.delete(cmd.path)));
-                    break;
-                default:
-                    console.error('[Autopilot Widget] Unsupported REST method:', method);
-            }
-            if (response && response.statusCode === 200) {
-                // console.log('[Autopilot Widget] V2 Command executed successfully:', cmd.path);
-                return response;
-            }
-            else {
-                console.warn('[Autopilot Widget] V2 Command completed with non-success status:', JSON.stringify(response));
-                return response || { statusCode: 0, message: 'Unavailable', state: 'not provided' };
-            }
-        }
-        catch (error) {
-            console.error('[Autopilot Widget] REST operation failed:', error);
-            // Display error to user for V2 command failures
-            this.displayApError({
-                statusCode: 500,
-                statusCodeDescription: 'V2 Command Failed',
-                message: `Failed to execute ${method} ${cmd.path}`,
-                widgetUUID: this.widgetProperties.uuid
-            });
-            return {
-                statusCode: 0,
-                message: error instanceof Error ? error.message : 'REST operation failed',
-                state: null
-            };
-        }
-    }
-    async setModeAndEnable(mode, endpoints) {
-        try {
-            const modeResp = await this.executeRestRequest('PUT', { path: endpoints.mode, value: { value: mode } });
-            if (modeResp.statusCode !== 200) {
-                console.error(`[Autopilot Widget] Failed to set mode '${mode}':`, modeResp);
-                return; // abort engage if setting mode failed
-            }
-            const engageResp = await this.executeRestRequest('PUT', { path: endpoints.state, value: { value: 'enabled' } });
-            if (engageResp.statusCode !== 200) {
-                console.error(`[Autopilot Widget] Failed to engage after mode '${mode}':`, engageResp);
-            }
-        }
-        catch (err) {
-            console.error('[Autopilot Widget] setModeAndEngage unexpected error:', err);
-        }
-    }
-    performTackOrGybe(operation, direction) {
-        if (this.widgetProperties.config.autopilot.apiVersion === 'v2') {
-            this.sendV2Command(operation, { value: direction });
-        }
-        else {
-            // Fall back to V1
-            if (operation !== 'tack')
-                return;
-            // console.log(`[Autopilot Widget] Executing V1 tack to ${direction}`);
-            const cmdAction = COMMANDS[direction === 'port' ? 'tackToPort' : 'tackToStarboard'];
-            this._requests.putRequest(cmdAction.path, cmdAction.value, this.widgetProperties.uuid);
-        }
-    }
-    // V2 Absolute Target Method (class only - no UI yet)
-    setAbsoluteTarget(heading) {
-        if (this.widgetProperties.config.autopilot.apiVersion === 'v2') {
-            this.sendV2Command('target_heading', { "value": heading, "units": "deg" });
-        }
-        else {
-            console.error('[Autopilot Widget] Absolute target only available in V2 API');
-        }
-    }
-    // V2 Dodge Method (class only - no UI yet)
-    toggleDodge() {
-        if (this.widgetProperties.config.autopilot.apiVersion === 'v2') {
-            this.sendV2Command('dodge');
-        }
-        else {
-            console.warn('[Autopilot Widget] Dodge mode only available in V2 API');
-            this.displayApError({
-                statusCode: 400,
-                statusCodeDescription: 'V2 API Required',
-                message: 'Dodge mode only available in V2 API',
-                widgetUUID: this.widgetProperties.uuid
-            });
-        }
-    }
-    commandReceived(cmdResult) {
-        if (cmdResult.statusCode != 200) {
-            this.displayApError(cmdResult);
-        }
-        else {
-            // console.log("AP Received: \n" + JSON.stringify(cmdResult));
-        }
-    }
-    confirmAdvanceWaypoint(cmd) {
-        const message = "Repeat key [Adv Wpt] to confirm";
-        this.startConfirmCmd(cmd, message);
-    }
-    confirmTack(cmd) {
-        let direction = "";
-        if (cmd === "tackToPort") {
-            direction = "Port";
-            this.actionToBeConfirmed = cmd;
-        }
-        else if (cmd === "tackToStarboard") {
-            direction = "Starboard";
-            this.actionToBeConfirmed = cmd;
-        }
-        else {
-            this.actionToBeConfirmed = "";
-            return;
-        }
-        const message = `Repeat [Tack ${direction}] key to confirm`;
-        this.startConfirmCmd(cmd, message);
-    }
-    startConfirmCmd(cmd, message) {
-        this.countDownValue = DEFAULTS.COUNTDOWN_SECONDS;
-        this.actionToBeConfirmed = cmd;
-        this.countdownOverlayText.set(message);
-        this.countdownOverlayVisibility.set("visible");
-        this.updateCountDownCounter(message);
-        clearTimeout(this.handleConfirmActionTimeout);
-        this.handleConfirmActionTimeout = setTimeout(() => {
-            this.countdownOverlayVisibility.set("hidden");
-            this.countdownOverlayText.set("");
-            this.actionToBeConfirmed = "";
-        }, DEFAULTS.MESSAGE_DISPLAY_DURATION);
-    }
-    clearConfirmCmd() {
-        clearTimeout(this.handleConfirmActionTimeout);
-        clearTimeout(this.handleCountDownCounterTimeout);
-        this.countDownValue = -1;
-        this.countdownOverlayVisibility.set("hidden");
-        this.countdownOverlayText.set("");
-        this.actionToBeConfirmed = '';
-    }
-    updateCountDownCounter(message) {
-        if (this.countDownValue > 0) {
-            clearTimeout(this.handleCountDownCounterTimeout);
-            this.countdownOverlayText.set(message);
-            this.countDownValue -= 1;
-            this.handleCountDownCounterTimeout = setTimeout(() => {
-                this.updateCountDownCounter(message);
-            }, 1000);
-        }
-        else {
-            this.countDownValue = -1;
-            clearTimeout(this.handleCountDownCounterTimeout);
-        }
-    }
-    displayApError(cmdResult) {
-        // Don't override persistent offline errors with temporary command errors
-        if (this.isPersistentError) {
-            console.warn('[Autopilot Widget] Skipping temporary error display - persistent error active:', cmdResult.statusCodeDescription);
-            return;
-        }
-        let errMsg = cmdResult.statusCode + " - " + cmdResult.statusCodeDescription + ".";
-        if (cmdResult.message) {
-            errMsg = errMsg + "Server Message: " + cmdResult.message + ".";
-        }
-        this.errorOverlayText.set(errMsg);
-        this.errorOverlayVisibility.set("visible");
-        clearTimeout(this.handleDisplayErrorTimeout);
-        this.handleDisplayErrorTimeout = setTimeout(() => {
-            // Only hide if it's not a persistent error
-            if (!this.isPersistentError) {
-                this.errorOverlayVisibility.set("hidden");
-                this.errorOverlayText.set("");
-            }
-        }, DEFAULTS.ERROR_DISPLAY_DURATION);
-    }
-    toggleMenu() {
-        this.menuOpen.set(!this.menuOpen());
-    }
-    onMenuItemClick(action) {
-        if (action === 'cancel') {
-            this.toggleMenu();
-            return;
-        }
-        this.buildAndSendCommand(action);
-        this.menuOpen.set(false);
-    }
-    parseMenuItems(menuItems, mode) {
-        // Set enabled/disabled state for each mode menu item based
-        const apiVersion = this.widgetProperties.config.autopilot.apiVersion;
-        const parsedMenuItems = menuItems.map(item => {
-            if (item.isCancel)
-                return { ...item, current: false, disabled: false };
-            let enabled = false;
-            if (apiVersion === 'v1') {
-                switch (mode) {
-                    case 'standby':
-                        enabled = (item.action === 'auto' || item.action === 'wind');
-                        break;
-                    case 'auto':
-                        enabled = (item.action === 'wind' || item.action === 'route');
-                        break;
-                    case 'wind':
-                        enabled = (item.action === 'auto');
-                        break;
-                    case 'route':
-                        enabled = (item.action === 'auto');
-                        break;
-                    default:
-                        enabled = false;
-                }
-            }
-            else if (apiVersion === 'v2') {
-                // For V2, check if the action is in the capabilities
-                enabled = this.widgetProperties.config.autopilot.modes.includes(item.action);
-            }
-            return {
-                ...item,
-                current: item.action === mode,
-                disabled: !enabled
-            };
-        });
-        return parsedMenuItems;
-    }
-    ngOnDestroy() {
-        // Cancel all ongoing HTTP requests
-        this.cancelAllHttpRequests();
-        // Clear any pending timeouts
-        clearTimeout(this.handleCountDownCounterTimeout);
-        clearTimeout(this.handleConfirmActionTimeout);
-        clearTimeout(this.handleDisplayErrorTimeout);
-        clearTimeout(this.handleMessageTimeout);
-        // Clean up data streams
-        this.destroyDataStreams();
-    }
-};
-WidgetAutopilotComponent = __decorate([
-    Component({
-        selector: 'widget-autopilot',
-        templateUrl: './widget-autopilot.component.html',
-        styleUrls: ['./widget-autopilot.component.scss'],
-        imports: [WidgetHostComponent, SvgAutopilotComponent, MatButtonModule, TitleCasePipe, MatIconModule, MatBadgeModule, WidgetPositionComponent, WidgetNumericComponent, WidgetDatetimeComponent],
-    }),
-    __metadata("design:paramtypes", [])
-], WidgetAutopilotComponent);
-export { WidgetAutopilotComponent };
-//# sourceMappingURL=widget-autopilot.component.js.map