feat(a32nx/fms): database holds

.github/CHANGELOG.md

@@ -125,7 +125,7 @@
 1. [A380X/MFD] Add airport data page into the MFD (DATA > AIRPORT) - @bulenteroglu (senolitam)
 1. [A380X/EFB] Adds PRIM/SEC/FCDC failures to EFB - @flogross89 (floridude)
 1. [A380X/PFD] Fix precision of pitch trim indicator - @flogross89 (floridude)
-
+1. [A32NX/FMS] Add terminal area database holds for MSFS2024 - @tracernz (Mike)
 
 ## 0.12.0
 

fbw-a32nx/src/base/flybywire-aircraft-a320-neo/html_ui/Pages/VCockpit/Instruments/Airliners/FlyByWire_A320_Neo/CDU/A320_Neo_CDU_HoldAtPage.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2023 FlyByWire Simulations
+// Copyright (c) 2021-2023, 2025 FlyByWire Simulations
 //
 // SPDX-License-Identifier: GPL-3.0
 
@@ -55,22 +55,112 @@ class CDUHoldAtPage {
                     type: HoldType.Computed,
                 };
                 modifiedHold = {};
+
+                const fix = waypoint.terminationWaypoint();
+                if (fix && fix.area === 1 /* WaypointArea.Terminal */ && fix.airportIdent && fix.airportIdent.length === 4) {
+                    Fmgc.NavigationDatabaseService.activeDatabase.getHolds(fix.ident, fix.airportIdent).then((holds) => {
+                        // Pick a hold based on altitude suitability and inbound course
+                        // Missing in the navdata is the duplicate indicator that would help us pick the right area/airspace type.
+                        holds
+                            .filter((v) => v.waypoint.databaseId === fix.databaseId)
+                            .sort((a, b) => {
+                                let ret = CDUHoldAtPage.holdVerticalDistanceFromAlt(alt, a) - CDUHoldAtPage.holdVerticalDistanceFromAlt(alt, b);
+                                if (ret === 0) {
+                                    ret = Math.abs(a.magneticCourse - inboundMagneticCourse) - Math.abs(b.magneticCourse - inboundMagneticCourse);
+                                }
+                                return ret;
+                            });
+
+                        if (holds[0]) {
+                            defaultHold = {
+                                inboundMagneticCourse: holds[0].magneticCourse,
+                                turnDirection: holds[0].turnDirection,
+                                time: holds[0].lengthTime ? holds[0].lengthTime : undefined,
+                                distance: holds[0].length ? holds[0].length : undefined,
+                                type: HoldType.Database,
+                            };
+                        }
+
+                        CDUHoldAtPage.addOrEditManualHold(
+                            mcdu,
+                            waypointIndexFP,
+                            // eslint-disable-next-line prefer-object-spread
+                            Object.assign({}, defaultHold),
+                            modifiedHold,
+                            defaultHold,
+                            forPlan,
+                            inAlternate,
+                        );
+                    }).catch(() => {
+                        CDUHoldAtPage.addOrEditManualHold(
+                            mcdu,
+                            waypointIndexFP,
+                            // eslint-disable-next-line prefer-object-spread
+                            Object.assign({}, defaultHold),
+                            modifiedHold,
+                            defaultHold,
+                            forPlan,
+                            inAlternate,
+                        );
+                    });
+                    return;
+                }
             }
 
-            mcdu.flightPlanService.addOrEditManualHold(
+            CDUHoldAtPage.addOrEditManualHold(
+                mcdu,
                 waypointIndexFP,
                 // eslint-disable-next-line prefer-object-spread
                 Object.assign({}, defaultHold),
                 modifiedHold,
                 defaultHold,
                 forPlan,
                 inAlternate,
-            ).then((holdIndex) => {
-                CDUHoldAtPage.DrawPage(mcdu, holdIndex, waypointIndexFP, forPlan, inAlternate);
-            });
+            );
+        }
+    }
+
+    static holdVerticalDistanceFromAlt(altitude, hold) {
+        switch (hold.altitudeDescriptor) {
+            case "B":
+                if (altitude <= hold.altitude1 && altitude >= hold.altitude2) {
+                    return 0;
+                }
+                if (altitude > hold.altitude1) {
+                    return altitude - hold.altitude1;
+                }
+                return hold.altitude2 - altitude;
+            case "+":
+                return altitude >= hold.altitude1 ? 0 : hold.altitude1 - altitude;
+            case "-":
+                return altitude <= hold.altitude1 ? 0 : altitude - hold.altitude1;
+            default:
+                // no restriction, so always suitable
+                return 0;
         }
     }
 
+    static addOrEditManualHold(
+        mcdu,
+        atIndex,
+        desiredHold,
+        modifiedHold,
+        defaultHold,
+        planIndex,
+        alternate,
+    ) {
+        mcdu.flightPlanService.addOrEditManualHold(
+            atIndex,
+            desiredHold,
+            modifiedHold,
+            defaultHold,
+            planIndex,
+            alternate,
+        ).then((holdIndex) => {
+            CDUHoldAtPage.DrawPage(mcdu, holdIndex, atIndex, planIndex, alternate);
+        });
+    }
+
     static DrawPage(mcdu, waypointIndexFP, originalFpIndex, forPlan, inAlternate) {
         mcdu.clearDisplay();
         mcdu.page.Current = mcdu.page.HoldAtPage;