bruce-cesium 5.7.9 → 5.8.0

package/dist/lib/rendering/render-managers/data-source/data-source-static-csv-manager.js

@@ -0,0 +1,668 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceStaticCsvManager = void 0;
+const bruce_models_1 = require("bruce-models");
+const Cesium = require("cesium");
+const bruce_cesium_1 = require("src/bruce-cesium");
+/**
+ * Made for a POC experiment.
+ * Do not use without reviewing the purpose and settings of the Menu Item.
+ */
+var DataSourceStaticCsvManager;
+(function (DataSourceStaticCsvManager) {
+    class Manager {
+        get Disposed() {
+            return this.disposed;
+        }
+        get DataSources() {
+            return this.dataSource ? [this.dataSource] : [];
+        }
+        get CzmlDataInputs() {
+            return this.czmlDataInputs;
+        }
+        constructor(params) {
+            this.disposed = false;
+            this.czmlDataInputs = [];
+            // Array of callbacks to remove from the clock tick event.
+            this.tickRemovals = [];
+            const { viewer, apiGetter, item, register } = params;
+            this.viewer = viewer;
+            this.apiGetter = apiGetter;
+            this.item = item;
+            this.register = register;
+        }
+        Init() {
+            let files = this.item.CSV;
+            if (!files) {
+                return;
+            }
+            if (!Array.isArray(files)) {
+                files = [files];
+            }
+            (async () => {
+                var _a;
+                const api = this.apiGetter.getApi();
+                await api.Loading;
+                if (this.disposed) {
+                    return;
+                }
+                try {
+                    await this.renderMovingItem();
+                    if (this.disposed) {
+                        if (!((_a = this.viewer) === null || _a === void 0 ? void 0 : _a.isDestroyed()) && this.dataSource && this.viewer.dataSources.contains(this.dataSource)) {
+                            this.viewer.dataSources.remove(this.dataSource);
+                            this.dataSource = null;
+                            this.viewer.scene.requestRender();
+                        }
+                        if (this.tickRemovals.length) {
+                            this.tickRemovals.forEach(removal => removal());
+                            this.tickRemovals = [];
+                        }
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            })();
+        }
+        /**
+         * Takes a set of CSV files and renders the collection as a single moving item (truck, car, etc).
+         * This will try to find which is the primary source of point data, and complimentary sources of attribute information.
+         * @param files
+         */
+        async renderMovingItem() {
+            var _a;
+            const api = this.apiGetter.getApi();
+            await api.Loading;
+            let vehicleFileUrl;
+            let alarmFileUrl;
+            let lineColor;
+            let vehicleEntityId;
+            const fileStrings = [];
+            const files = this.item.CSV;
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                const fileId = (_a = file === null || file === void 0 ? void 0 : file.ClientFile) === null || _a === void 0 ? void 0 : _a.ID;
+                const externalURL = file === null || file === void 0 ? void 0 : file.fileUrl;
+                if (!fileId && !externalURL) {
+                    continue;
+                }
+                let fileUrl;
+                if (fileId) {
+                    fileUrl = bruce_models_1.ClientFile.GetUrl({
+                        api,
+                        fileId,
+                        viaCdn: true
+                    });
+                }
+                else if (externalURL) {
+                    fileUrl = externalURL;
+                }
+                const fileStr = await (await fetch(fileUrl)).text();
+                fileStrings.push(fileStr);
+                if (this.disposed) {
+                    return;
+                }
+                if (file.vehicleFileId) {
+                    vehicleFileUrl = bruce_models_1.ClientFile.GetUrl({
+                        api,
+                        fileId: file.vehicleFileId,
+                        viaCdn: true
+                    });
+                }
+                if (file.lineColor) {
+                    lineColor = file.lineColor;
+                }
+                if (file.alertFileId) {
+                    alarmFileUrl = bruce_models_1.ClientFile.GetUrl({
+                        api,
+                        fileId: file.alertFileId,
+                        viaCdn: true
+                    });
+                }
+                if (file.vehicleEntityId) {
+                    vehicleEntityId = file.vehicleEntityId;
+                }
+            }
+            // We'll run through and turn the fileStrings into an array of objects that represent the CSV data.
+            // Each file string is the text of a CSV file.
+            const csvData = [];
+            for (let i = 0; i < fileStrings.length; i++) {
+                const delimiter = ",";
+                const fileStr = fileStrings[i];
+                const headers = fileStr.slice(0, fileStr.indexOf("\n")).split(delimiter).map(header => header.trim());
+                const rows = fileStr.slice(fileStr.indexOf("\n") + 1).split("\n");
+                const rowsArr = [];
+                for (let j = 0; j < rows.length; j++) {
+                    const row = rows[j];
+                    const rowArr = row.split(delimiter).map(item => item.trim());
+                    if (rowArr.length === 1 && rowArr[0] === "") {
+                        continue;
+                    }
+                    rowsArr.push(rowArr);
+                }
+                csvData.push({
+                    headers,
+                    rows: rowsArr
+                });
+            }
+            // TODO. Find one with lat/lon/dateTime values instead of just taking first one.
+            const primary = csvData[0];
+            const pHeaders = primary.headers;
+            const pLatIndex = pHeaders.findIndex(x => x.toLowerCase().includes("lat"));
+            const pLonIndex = pHeaders.findIndex(x => x.toLowerCase().includes("lon"));
+            const pDateTimeIndex = pHeaders.findIndex(x => x.toLowerCase().includes("date"));
+            // Ensure values are correct data types.
+            for (let i = 0; i < primary.rows.length; i++) {
+                const row = primary.rows[i];
+                const lat = row[pLatIndex];
+                if (typeof lat == "string") {
+                    row[pLatIndex] = parseFloat(lat);
+                }
+                const lon = row[pLonIndex];
+                if (typeof lon == "string") {
+                    row[pLonIndex] = parseFloat(lon);
+                }
+                const dateTimeStr = row[pDateTimeIndex];
+                if (typeof dateTimeStr === "string") {
+                    let utcDate;
+                    // Dates are assumed to be in UTC.
+                    // Check for the format: `2023/12/24 04:15:00.743`.
+                    if (dateTimeStr.includes("/") && dateTimeStr.includes(":")) {
+                        const [datePart, timePart] = dateTimeStr.split(" ");
+                        const [year, month, day] = datePart.split("/").map(Number);
+                        const [hours, minutes, seconds] = timePart.split(":").map(Number);
+                        const milliseconds = seconds % 1 * 1000; // Extract milliseconds
+                        utcDate = new Date(Date.UTC(year, month - 1, day, hours, minutes, Math.floor(seconds), milliseconds));
+                    }
+                    // Check for the format: `24-12-2023  4:15:12 AM`.
+                    else if (dateTimeStr.includes("-") && dateTimeStr.includes(":") && (dateTimeStr.includes("AM") || dateTimeStr.includes("PM"))) {
+                        const convertTo24HourFormat = (dateTimeStr) => {
+                            const [datePart, timePart, meridian] = dateTimeStr.split(/[: ]+/);
+                            let [hours, minutes, seconds] = timePart.split(":").map(Number);
+                            if (meridian === 'PM' && hours < 12) {
+                                hours += 12;
+                            }
+                            if (meridian === 'AM' && hours === 12) {
+                                hours = 0;
+                            }
+                            return `${datePart} ${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+                        };
+                        // Convert to 24-hour format before parsing.
+                        const dateTime24hr = convertTo24HourFormat(dateTimeStr);
+                        const [datePart, timePart] = dateTime24hr.split(" ");
+                        const [day, month, year] = datePart.split("-").map(Number);
+                        const [hours, minutes, seconds] = timePart.split(":").map(Number);
+                        utcDate = new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds));
+                    }
+                    // Format: `2023-12-24 04:19:17.196`.
+                    else if (dateTimeStr.includes("-") && dateTimeStr.includes(":")) {
+                        const [datePart, timePart] = dateTimeStr.split(" ");
+                        const [year, month, day] = datePart.split("-").map(Number);
+                        const [hours, minutes, seconds] = timePart.split(":").map(Number);
+                        utcDate = new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds));
+                    }
+                    else {
+                        // Fallback to parsing in local time.
+                        utcDate = new Date(dateTimeStr);
+                    }
+                    row[pDateTimeIndex] = utcDate.toISOString();
+                }
+            }
+            // Sort by date.
+            primary.rows.sort((a, b) => {
+                const aDate = new Date(a[pDateTimeIndex]);
+                const bDate = new Date(b[pDateTimeIndex]);
+                return aDate.getTime() - bDate.getTime();
+            });
+            const vehicleCesiumId = bruce_models_1.ObjectUtils.UId();
+            const { czml, entityMapping } = createJourneyCzml(vehicleCesiumId, vehicleFileUrl, alarmFileUrl, lineColor, primary);
+            this.czmlDataInputs.push(czml);
+            // Dereference czml and remove clock property.
+            // We do this so our apps can reference the property and manage the clock themselves.
+            const czmlAdjusted = JSON.parse(JSON.stringify(czml));
+            czmlAdjusted.forEach((item) => {
+                delete item.clock;
+            });
+            // Get current cesium dateTime.
+            const curSettings = bruce_cesium_1.ViewUtils.GetTimeDetails({
+                viewer: this.viewer
+            });
+            const source = await this.viewer.dataSources.add(Cesium.CzmlDataSource.load(czmlAdjusted));
+            this.dataSource = source;
+            // Reset back to the previous dateTime.
+            // Adding the czml data source will have changed the clock.
+            bruce_cesium_1.ViewUtils.SetTimeDetails({
+                viewer: this.viewer,
+                isAnimating: curSettings.isAnimating,
+                animationSpeed: curSettings.animationSpeed,
+                currentTimeIso: curSettings.currentTimeIso,
+                startTimeIso: curSettings.startTimeIso,
+                stopTimeIso: curSettings.stopTimeIso
+            });
+            // Listen to update ticks and ensure orientation of moving item is correct.
+            if (this.viewer.clock) {
+                const pHeadingIndex = pHeaders.findIndex(x => x.toLowerCase().includes("head"));
+                let errorsInARow = 0;
+                const removal = this.viewer.clock.onTick.addEventListener(() => {
+                    const vehicle = source.entities.getById(vehicleCesiumId);
+                    if (vehicle) {
+                        try {
+                            updateOrientation(primary.rows, pHeadingIndex, pDateTimeIndex, this.viewer, vehicle);
+                            errorsInARow = 0;
+                        }
+                        catch (e) {
+                            console.error(e);
+                            errorsInARow += 1;
+                            if (errorsInARow >= 3) {
+                                removal();
+                            }
+                        }
+                        this.viewer.scene.requestRender();
+                    }
+                });
+                this.tickRemovals.push(removal);
+                // Register vehicle rego.
+                if (vehicleEntityId) {
+                    const vehicleEntity = source.entities.getById(vehicleCesiumId);
+                    if (vehicleEntity) {
+                        this.register.AddRego({
+                            rego: {
+                                canEdit: false,
+                                entityId: vehicleEntityId,
+                                menuItemId: this.item.id,
+                                menuItemType: this.item.Type,
+                                priority: 0,
+                                visual: vehicleEntity,
+                                accountId: this.apiGetter.accountId,
+                                cdn: false,
+                                overrideShow: true
+                            },
+                            requestRender: false
+                        });
+                    }
+                }
+                // Register alarms (and any other Entities that were created).
+                const cesiumEntityIds = Object.keys(entityMapping);
+                for (let i = 0; i < cesiumEntityIds.length; i++) {
+                    const cesiumEntityId = cesiumEntityIds[i];
+                    const entity = source.entities.getById(cesiumEntityId);
+                    if (entity) {
+                        const nextspaceEntityId = entityMapping[cesiumEntityId];
+                        if (nextspaceEntityId) {
+                            this.register.AddRego({
+                                rego: {
+                                    canEdit: false,
+                                    entityId: nextspaceEntityId,
+                                    menuItemId: this.item.id,
+                                    menuItemType: this.item.Type,
+                                    priority: 0,
+                                    visual: entity,
+                                    accountId: this.apiGetter.accountId,
+                                    cdn: false,
+                                    overrideShow: true
+                                },
+                                requestRender: false
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        Dispose() {
+            var _a;
+            if (this.disposed) {
+                return;
+            }
+            this.disposed = true;
+            if (!((_a = this.viewer) === null || _a === void 0 ? void 0 : _a.isDestroyed())) {
+                if (this.dataSource && this.viewer.dataSources.contains(this.dataSource)) {
+                    this.viewer.dataSources.remove(this.dataSource);
+                    this.dataSource = null;
+                    this.viewer.scene.requestRender();
+                }
+            }
+            if (this.tickRemovals.length) {
+                this.tickRemovals.forEach(removal => removal());
+                this.tickRemovals = [];
+            }
+            this.register.RemoveRegos({
+                menuItemId: this.item.id,
+                doUpdate: false,
+                requestRender: false
+            });
+        }
+        async ReRender(params) {
+            const { entityIds, force } = params;
+            if (entityIds == null) {
+            }
+            else {
+            }
+        }
+    }
+    DataSourceStaticCsvManager.Manager = Manager;
+})(DataSourceStaticCsvManager = exports.DataSourceStaticCsvManager || (exports.DataSourceStaticCsvManager = {}));
+/**
+ * Creates a CZML object from the CSV data.
+ * This shows a journey taken by a moving object and alarms detected along the way.
+ * @param vehicleId
+ * @param vehicleFileUrl
+ * @param alarmFileUrl
+ * @param lineColor
+ * @param data
+ * @returns
+ */
+function createJourneyCzml(vehicleId, vehicleFileUrl, alarmFileUrl, lineColor, data) {
+    const headers = data.headers;
+    const rows = data.rows;
+    const latIndex = headers.findIndex(x => x.toLowerCase().includes("lat"));
+    const lonIndex = headers.findIndex(x => x.toLowerCase().includes("lon"));
+    const dateTimeIndex = headers.findIndex(x => x.toLowerCase().includes("date"));
+    const alarmIndex = headers.findIndex(x => x.toLowerCase().includes("alarm"));
+    const entityIdIndex = headers.findIndex((x, i) => {
+        if (i === latIndex || i === lonIndex || i === dateTimeIndex || i === alarmIndex) {
+            return false;
+        }
+        const lower = x.toLowerCase();
+        return lower.includes("entityid") || lower.includes("bruce") || lower.includes("nextspace");
+    });
+    // Map between Cesium Entity ID and Nextspace Entity ID.
+    // This is returned to the caller so they can map between the two.
+    const entityMapping = {};
+    const czml = [
+        {
+            "id": "document",
+            "name": "Journey",
+            "version": "1.0",
+            "clock": {
+                "interval": rows[0][dateTimeIndex] + "/" + rows[rows.length - 1][dateTimeIndex],
+                "currentTime": rows[0][dateTimeIndex],
+                "multiplier": 10,
+                "range": "LOOP_STOP",
+                "step": "SYSTEM_CLOCK_MULTIPLIER"
+            }
+        },
+    ];
+    const SEGMENTED = true;
+    // Create a polyline for the full path.
+    // If segmented we'll break it into pieces and display each piece based on relative time to the cesium viewer clock.
+    if (SEGMENTED) {
+        // Calculate the total duration of the journey in milliseconds.
+        const totalDuration = new Date(rows[rows.length - 1][dateTimeIndex]).getTime() - new Date(rows[0][dateTimeIndex]).getTime();
+        // Percentage of the journey to be visible before and after each point.
+        const visibilityPercentage = 0.05; // 5%
+        const visibilityDuration = totalDuration * visibilityPercentage;
+        rows.forEach((row, index) => {
+            const time = new Date(row[dateTimeIndex]).getTime();
+            const startTime = new Date(time - visibilityDuration / 2).toISOString();
+            const endTime = new Date(time + visibilityDuration / 2).toISOString();
+            const position = [
+                Number(row[lonIndex]),
+                Number(row[latIndex]),
+                0
+            ];
+            if (index < rows.length - 1) {
+                const nextRow = rows[index + 1];
+                const nextPosition = [
+                    Number(nextRow[lonIndex]),
+                    Number(nextRow[latIndex]),
+                    0
+                ];
+                czml.push({
+                    "id": "segment-" + bruce_models_1.ObjectUtils.UId(),
+                    "name": "Path Segment",
+                    "availability": startTime + "/" + endTime,
+                    "polyline": {
+                        "clampToGround": true,
+                        "positions": {
+                            "cartographicDegrees": position.concat(nextPosition)
+                        },
+                        "material": {
+                            "solidColor": {
+                                "color": {
+                                    "rgba": lineColor ? Cesium.Color.fromCssColorString(lineColor).toBytes() : [0, 255, 0, 100]
+                                }
+                            }
+                        },
+                        "width": 5
+                    }
+                });
+            }
+        });
+        // Alarm points.
+        rows.filter(row => row[alarmIndex]).forEach((row, index) => {
+            const alarmTime = new Date(row[dateTimeIndex]).getTime();
+            const startTime = new Date(alarmTime - visibilityDuration / 2).toISOString();
+            const endTime = new Date(alarmTime + visibilityDuration / 2).toISOString();
+            const alarmCesiumId = bruce_models_1.ObjectUtils.UId();
+            czml.push({
+                "id": alarmCesiumId,
+                "name": "Alarm",
+                "availability": startTime + "/" + endTime,
+                "position": {
+                    "cartographicDegrees": [
+                        Number(row[lonIndex]),
+                        Number(row[latIndex]),
+                        5
+                    ]
+                },
+                "point": !alarmFileUrl ? {
+                    "pixelSize": 10,
+                    "color": {
+                        "rgba": [255, 0, 0, 255]
+                    },
+                    "heightReference": "CLAMP_TO_GROUND"
+                } : undefined,
+                "billboard": alarmFileUrl ? {
+                    "image": alarmFileUrl,
+                    "scale": 1,
+                    "pixelOffset": {
+                        "cartesian2": [0, 0]
+                    },
+                    "heightReference": "CLAMP_TO_GROUND"
+                } : undefined
+            });
+            const entityId = entityIdIndex > -1 ? row[entityIdIndex] : null;
+            if (entityId) {
+                entityMapping[alarmCesiumId] = String(entityId);
+            }
+        });
+    }
+    else {
+        const roadPositions = rows.map(row => {
+            const position = [
+                Number(row[lonIndex]),
+                Number(row[latIndex]),
+                0
+            ];
+            return position;
+        }).flat();
+        czml.push({
+            "id": bruce_models_1.ObjectUtils.UId(),
+            "name": "Path",
+            "polyline": {
+                "clampToGround": true,
+                "positions": {
+                    "cartographicDegrees": roadPositions
+                },
+                "material": {
+                    "solidColor": {
+                        "color": {
+                            "rgba": lineColor ? Cesium.Color.fromCssColorString(lineColor).toBytes() : [0, 255, 0, 100]
+                        }
+                    }
+                },
+                "width": 5
+            }
+        });
+        // Alarm points.
+        rows.filter(row => row[alarmIndex]).forEach((row, index) => {
+            const position = [
+                Number(row[lonIndex]),
+                Number(row[latIndex]),
+                0
+            ];
+            czml.push({
+                "id": bruce_models_1.ObjectUtils.UId(),
+                "name": "Alarm",
+                "position": {
+                    "cartographicDegrees": position
+                },
+                "point": !alarmFileUrl ? {
+                    "heightReference": "CLAMP_TO_GROUND",
+                    "pixelSize": 10,
+                    "color": {
+                        "rgba": [255, 0, 0, 255]
+                    }
+                } : undefined,
+                "billboard": alarmFileUrl ? {
+                    "heightReference": "CLAMP_TO_GROUND",
+                    "image": alarmFileUrl,
+                    "scale": 1,
+                    "pixelOffset": {
+                        "cartesian2": [0, 0]
+                    }
+                } : undefined,
+                /*
+                "label": {
+                    "text": row[alarmIndex],
+                    "show": true,
+                    "font": "11pt monospace",
+                    "style": "FILL",
+                    "outlineColor": {
+                        "rgba": [0, 0, 0, 255]
+                    },
+                    "outlineWidth": 2,
+                    "pixelOffset": {
+                        "cartesian2": [0, -16]
+                    }
+                }
+                */
+            });
+        });
+    }
+    // Add animated point for the moving item.
+    const vehiclePositions = rows.map((row) => {
+        const position = [
+            (new Date(row[dateTimeIndex]).getTime() - new Date(rows[0][dateTimeIndex]).getTime()) / 1000,
+            Number(row[lonIndex]),
+            Number(row[latIndex]),
+            0
+        ];
+        return position;
+    }).flat();
+    czml.push({
+        "id": vehicleId,
+        "name": "Vehicle",
+        "availability": rows[0][dateTimeIndex] + "/" + rows[rows.length - 1][dateTimeIndex],
+        "model": vehicleFileUrl ? {
+            "heightReference": "CLAMP_TO_GROUND",
+            "gltf": vehicleFileUrl,
+            "scale": 1
+        } : undefined,
+        "point": !vehicleFileUrl ? {
+            "heightReference": "CLAMP_TO_GROUND",
+            "pixelSize": 20,
+            "color": {
+                "rgba": [0, 0, 255, 255]
+            }
+        } : undefined,
+        "orientation": {
+            "velocityReference": "#vehicle#position"
+        },
+        "position": {
+            "epoch": rows[0][dateTimeIndex],
+            "cartographicDegrees": vehiclePositions
+        }
+    });
+    return {
+        czml,
+        entityMapping
+    };
+}
+/**
+ * Updates the orientation of the moving item.
+ * If there is a heading in the file then it will calculate based on the file data,
+ * if there isn't then it will calculate one based on the previous and current position.
+ * @param rows
+ * @param headingIndex
+ * @param dateTimeIndex
+ * @param viewer
+ * @param vehicleEntity
+ * @returns
+ */
+function updateOrientation(rows, headingIndex, dateTimeIndex, viewer, vehicleEntity) {
+    if (!vehicleEntity || !vehicleEntity.position) {
+        return;
+    }
+    const positionProperty = vehicleEntity.position;
+    const currentTime = viewer.clock.currentTime;
+    const currentPosition = positionProperty.getValue(currentTime);
+    if (!currentPosition) {
+        return;
+    }
+    if (headingIndex > -1) {
+        try {
+            const interpolatedHeading = interpolateHeading(dateTimeIndex, rows, currentTime, headingIndex);
+            if (interpolatedHeading !== null) {
+                const radians = Cesium.Math.toRadians(interpolatedHeading - 90);
+                const quaternion = Cesium.Transforms.headingPitchRollQuaternion(currentPosition, new Cesium.HeadingPitchRoll(radians, 0, 0));
+                if (!isNaN(quaternion.w) && !isNaN(quaternion.x) && !isNaN(quaternion.y) && !isNaN(quaternion.z)) {
+                    vehicleEntity.orientation = new Cesium.ConstantProperty(quaternion);
+                    return;
+                }
+                else {
+                    console.error("Invalid quaternion", quaternion);
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    const previousTime = Cesium.JulianDate.addSeconds(currentTime, -1, new Cesium.JulianDate());
+    const previousPosition = positionProperty.getValue(previousTime);
+    if (previousPosition && !Cesium.Cartesian3.equals(currentPosition, previousPosition)) {
+        const direction = Cesium.Cartesian3.subtract(currentPosition, previousPosition, new Cesium.Cartesian3());
+        Cesium.Cartesian3.normalize(direction, direction);
+        const rotationMatrix = Cesium.Transforms.rotationMatrixFromPositionVelocity(previousPosition, direction);
+        vehicleEntity.orientation = new Cesium.ConstantProperty(Cesium.Quaternion.fromRotationMatrix(rotationMatrix));
+    }
+}
+function interpolateHeading(dateTimeIndex, rows, currentTime, headingIndex) {
+    const currentTimeMs = Cesium.JulianDate.toDate(currentTime).getTime();
+    let nearestBefore = null;
+    let nearestAfter = null;
+    for (const row of rows) {
+        const time = new Date(row[dateTimeIndex]).getTime();
+        let heading = parseFloat(String(row[headingIndex]));
+        if (!isNaN(heading)) {
+            if (time <= currentTimeMs) {
+                nearestBefore = { time, heading };
+            }
+            else if (time > currentTimeMs && nearestAfter === null) {
+                nearestAfter = { time, heading };
+                break;
+            }
+        }
+    }
+    if (nearestBefore && nearestAfter) {
+        // Normalize headings to handle wraparound from 359 to 0.
+        let deltaHeading = nearestAfter.heading - nearestBefore.heading;
+        if (deltaHeading > 180) {
+            deltaHeading -= 360;
+        }
+        else if (deltaHeading < -180) {
+            deltaHeading += 360;
+        }
+        const factor = (currentTimeMs - nearestBefore.time) / (nearestAfter.time - nearestBefore.time);
+        let interpolatedHeading = nearestBefore.heading + factor * deltaHeading;
+        interpolatedHeading = (interpolatedHeading + 360) % 360;
+        return interpolatedHeading;
+    }
+    else if (nearestBefore) {
+        return nearestBefore.heading;
+    }
+    return null;
+}
+//# sourceMappingURL=data-source-static-csv-manager.js.map