@tak-ps/node-cot 14.39.0 → 14.40.1

package/lib/parser/to_geojson.ts

@@ -13,6 +13,14 @@ import type {
     Link,
     LinkAttributes,
     ColorAttributes,
+    RadMeasurement,
+    RadPhysicalModule,
+    RadSpectrum,
+    RadIsotope,
+    ChemDetection,
+    BioMeasurement,
+    BioMeasurementLevel,
+    BioMeasurementLevelAttributes,
 } from '../types/types.js'
 import Ellipse from '@turf/ellipse';
 import Truncate from '@turf/truncate';
@@ -91,6 +99,88 @@ export async function to_geojson(
         feat.properties.sensor = raw.event.detail.sensor._attributes;
     }
 
+    if (raw.event.detail.radsensordetail) {
+        const rad = raw.event.detail.radsensordetail;
+        feat.properties.radsensordetail = {
+            sensor_data: { ...rad.sensor_data._attributes }
+        };
+
+        if (rad.radmeasurement) {
+            const measurements = Array.isArray(rad.radmeasurement) ? rad.radmeasurement : [rad.radmeasurement];
+            feat.properties.radsensordetail.radmeasurement = measurements.map((m: Static<typeof RadMeasurement>) => ({ ...m._attributes }));
+        }
+
+        if (rad.physical_module) {
+            const modules = Array.isArray(rad.physical_module) ? rad.physical_module : [rad.physical_module];
+            feat.properties.radsensordetail.physical_module = modules.map((m: Static<typeof RadPhysicalModule>) => ({ ...m._attributes }));
+        }
+
+        if (rad.search_algorithm) {
+            feat.properties.radsensordetail.search_algorithm = { ...rad.search_algorithm._attributes };
+        }
+
+        if (rad.spectrum) {
+            const spectra = Array.isArray(rad.spectrum) ? rad.spectrum : [rad.spectrum];
+            feat.properties.radsensordetail.spectrum = spectra.map((s: Static<typeof RadSpectrum>) => ({ ...s._attributes }));
+        }
+
+        if (rad.isotope) {
+            const isotopes = Array.isArray(rad.isotope) ? rad.isotope : [rad.isotope];
+            feat.properties.radsensordetail.isotope = isotopes.map((i: Static<typeof RadIsotope>) => ({ ...i._attributes }));
+        }
+
+        if (rad.data_permissions) {
+            feat.properties.radsensordetail.data_permissions = { ...rad.data_permissions._attributes };
+        }
+
+        if (rad.command_permissions) {
+            feat.properties.radsensordetail.command_permissions = { ...rad.command_permissions._attributes };
+        }
+    }
+
+    if (raw.event.detail.chemsensordetail) {
+        const chem = raw.event.detail.chemsensordetail;
+        feat.properties.chemsensordetail = {
+            sensor_data: { ...chem.sensor_data._attributes }
+        };
+
+        if (chem.detection) {
+            const detections = Array.isArray(chem.detection) ? chem.detection : [chem.detection];
+            feat.properties.chemsensordetail.detection = detections.map((d: Static<typeof ChemDetection>) => ({ ...d._attributes }));
+        }
+    }
+
+    if (raw.event.detail.biosensordetail) {
+        const bio = raw.event.detail.biosensordetail;
+        feat.properties.biosensordetail = {
+            sensor_data: { ...bio.sensor_data._attributes }
+        };
+
+        if (bio.measurement) {
+            const measurements = Array.isArray(bio.measurement) ? bio.measurement : [bio.measurement];
+            feat.properties.biosensordetail.measurement = measurements.map((m: Static<typeof BioMeasurement>) => {
+                const measurement: { level?: Array<Static<typeof BioMeasurementLevelAttributes>> } & typeof m._attributes = { ...m._attributes };
+                if (m.level) {
+                    const levels = Array.isArray(m.level) ? m.level : [m.level];
+                    measurement.level = levels.map((l: Static<typeof BioMeasurementLevel>) => ({ ...l._attributes }));
+                }
+                return measurement;
+            });
+        }
+    }
+
+    if (raw.event.detail.spatial) {
+        const spatial = raw.event.detail.spatial;
+        feat.properties.spatial = {
+            attitude: { ...spatial.attitude._attributes },
+            spin: { ...spatial.spin._attributes }
+        };
+
+        if (spatial._attributes?.version !== undefined) {
+            feat.properties.spatial.version = spatial._attributes.version;
+        }
+    }
+
     if (raw.event.detail.range) {
         feat.properties.range = raw.event.detail.range._attributes.value;
     }

package/lib/types/feature.ts

@@ -15,7 +15,21 @@ import {
     TrackAttributes,
     LinkAttributes,
     SensorAttributes,
-    VideoAttributes
+    VideoAttributes,
+    RadSensorDataAttributes,
+    RadMeasurementAttributes,
+    RadPhysicalModuleAttributes,
+    RadSearchAlgorithmAttributes,
+    RadSpectrumAttributes,
+    RadIsotopeAttributes,
+    RadPermissionsAttributes,
+    ChemSensorDataAttributes,
+    ChemDetectionAttributes,
+    BioSensorDataAttributes,
+    BioMeasurementAttributes,
+    BioMeasurementLevelAttributes,
+    SpatialAttitudeAttributes,
+    SpatialSpinAttributes
 } from './types.js';
 
 export const Position = Type.Array(Type.Number(), {
@@ -75,6 +89,47 @@ export const FeaturePropertyMission = Type.Object({
     missionChanges: Type.Optional(Type.Array(FeaturePropertyMissionChange))
 });
 
+// === CBRN Sensor GeoJSON Types (flattened - no _attributes wrapper) ===
+
+export const FeaturePropertyRadSensorDetail = Type.Object({
+    sensor_data: RadSensorDataAttributes,
+    radmeasurement: Type.Optional(Type.Array(RadMeasurementAttributes)),
+    physical_module: Type.Optional(Type.Array(RadPhysicalModuleAttributes)),
+    search_algorithm: Type.Optional(RadSearchAlgorithmAttributes),
+    spectrum: Type.Optional(Type.Array(RadSpectrumAttributes)),
+    isotope: Type.Optional(Type.Array(RadIsotopeAttributes)),
+    data_permissions: Type.Optional(RadPermissionsAttributes),
+    command_permissions: Type.Optional(RadPermissionsAttributes)
+});
+
+export const FeaturePropertyChemSensorDetail = Type.Object({
+    sensor_data: ChemSensorDataAttributes,
+    detection: Type.Optional(Type.Array(ChemDetectionAttributes))
+});
+
+export const FeaturePropertyBioMeasurementLevel = Type.Object({
+    levelName: Type.String(),
+    levelValue: Type.String()
+});
+
+export const FeaturePropertyBioMeasurement = Type.Composite([
+    BioMeasurementAttributes,
+    Type.Object({
+        level: Type.Optional(Type.Array(BioMeasurementLevelAttributes))
+    })
+]);
+
+export const FeaturePropertyBioSensorDetail = Type.Object({
+    sensor_data: BioSensorDataAttributes,
+    measurement: Type.Optional(Type.Array(FeaturePropertyBioMeasurement))
+});
+
+export const FeaturePropertySpatial = Type.Object({
+    version: Type.Optional(Type.Number()),
+    attitude: SpatialAttitudeAttributes,
+    spin: SpatialSpinAttributes
+});
+
 export const Properties = Type.Object({
     callsign: Type.String({ default: 'UNKNOWN' }),
     type: Type.String({ default: 'a-f-G' }),
@@ -146,6 +201,10 @@ export const Properties = Type.Object({
     status: Type.Optional(StatusAttributes),
     precisionlocation: Type.Optional(PrecisionLocationAttributes),
     flow: Type.Optional(Type.Record(Type.String(), Type.String())),
+    radsensordetail: Type.Optional(FeaturePropertyRadSensorDetail),
+    chemsensordetail: Type.Optional(FeaturePropertyChemSensorDetail),
+    biosensordetail: Type.Optional(FeaturePropertyBioSensorDetail),
+    spatial: Type.Optional(FeaturePropertySpatial),
 })
 
 export const Point = Type.Object({

package/lib/types/types.ts

@@ -394,6 +394,66 @@ export const Sensor = Type.Object({
     _attributes: SensorAttributes
 })
 
+export const SpatialAttitudeAttributes = Type.Object({
+    roll: Type.Number({
+        description: 'Roll of entity in degrees. Positive indicates listing to the right.'
+    }),
+    pitch: Type.Number({
+        description: 'Pitch of entity in degrees. Positive indicates nose point up.'
+    }),
+    yaw: Type.Optional(Type.Number({
+        description: 'Yaw of entity in degrees. Positive indicates turned to the right.'
+    })),
+    eRoll: Type.Optional(Type.Number({
+        description: '1-sigma error of roll with respect to a zero mean normal Gaussian distribution.'
+    })),
+    ePitch: Type.Optional(Type.Number({
+        description: '1-sigma error of pitch with respect to a zero mean normal Gaussian distribution.'
+    })),
+    eYaw: Type.Optional(Type.Number({
+        description: '1-sigma error of yaw with respect to a zero mean normal Gaussian distribution.'
+    }))
+});
+
+export const SpatialAttitude = Type.Object({
+    _attributes: SpatialAttitudeAttributes
+});
+
+export const SpatialSpinAttributes = Type.Object({
+    roll: Type.Number({
+        description: 'Degrees per second with positive indicating to the pilots right'
+    }),
+    pitch: Type.Number({
+        description: 'Degrees per second with positive indicating nose up.'
+    }),
+    yaw: Type.Optional(Type.Number({
+        description: 'Degrees per second with positive indicating right.'
+    })),
+    eRoll: Type.Optional(Type.Number({
+        description: '1-sigma error of roll with respect to a zero mean normal Gaussian distribution.'
+    })),
+    ePitch: Type.Optional(Type.Number({
+        description: '1-sigma error of pitch with respect to a zero mean normal Gaussian distribution.'
+    })),
+    eYaw: Type.Optional(Type.Number({
+        description: '1-sigma error of yaw with respect to a zero mean normal Gaussian distribution.'
+    }))
+});
+
+export const SpatialSpin = Type.Object({
+    _attributes: SpatialSpinAttributes
+});
+
+export const Spatial = Type.Object({
+    _attributes: Type.Optional(Type.Object({
+        version: Type.Optional(Type.Number({
+            description: 'Version tag for this sub schema.'
+        }))
+    })),
+    attitude: SpatialAttitude,
+    spin: SpatialSpin
+});
+
 export const VideoAttributes = Type.Object({
     uid: Type.Optional(Type.String()),
     sensor: Type.Optional(Type.String()),
@@ -1210,7 +1270,10 @@ export const Detail = Type.Object({
     // CBRN Sensor Details
     radsensordetail: Type.Optional(RadSensorDetail),
     chemsensordetail: Type.Optional(ChemSensorDetail),
-    biosensordetail: Type.Optional(BioSensorDetail)
+    biosensordetail: Type.Optional(BioSensorDetail),
+
+    // Spatial information
+    spatial: Type.Optional(Spatial)
 })
 
 export const Point = Type.Object({

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@tak-ps/node-cot",
     "type": "module",
-    "version": "14.39.0",
+    "version": "14.40.1",
     "description": "Lightweight JavaScript library for parsing and manipulating TAK messages",
     "author": "Nick Ingalls <nick@ingalls.ca>",
     "types": "index.ts",