@tak-ps/node-cot 14.38.0 → 14.40.0

package/lib/parser/from_geojson.ts

@@ -3,6 +3,12 @@ import { v4 as randomUUID } from 'uuid';
 import type { Static } from '@sinclair/typebox';
 import type {
     LinkAttributes,
+    RadMeasurementAttributes,
+    RadPhysicalModuleAttributes,
+    RadSpectrumAttributes,
+    RadIsotopeAttributes,
+    ChemDetectionAttributes,
+    BioMeasurementLevelAttributes,
 } from '../types/types.js'
 import {
     InputFeature,
@@ -194,6 +200,82 @@ export async function from_geojson(
         cot.event.detail.sensor = { _attributes: { ...feature.properties.sensor } };
     }
 
+    if (feature.properties.radsensordetail) {
+        const rad = feature.properties.radsensordetail;
+        cot.event.detail.radsensordetail = {
+            sensor_data: { _attributes: { ...rad.sensor_data } }
+        };
+
+        if (rad.radmeasurement) {
+            cot.event.detail.radsensordetail.radmeasurement = rad.radmeasurement.map((m: Static<typeof RadMeasurementAttributes>) => ({ _attributes: { ...m } }));
+        }
+
+        if (rad.physical_module) {
+            cot.event.detail.radsensordetail.physical_module = rad.physical_module.map((m: Static<typeof RadPhysicalModuleAttributes>) => ({ _attributes: { ...m } }));
+        }
+
+        if (rad.search_algorithm) {
+            cot.event.detail.radsensordetail.search_algorithm = { _attributes: { ...rad.search_algorithm } };
+        }
+
+        if (rad.spectrum) {
+            cot.event.detail.radsensordetail.spectrum = rad.spectrum.map((s: Static<typeof RadSpectrumAttributes>) => ({ _attributes: { ...s } }));
+        }
+
+        if (rad.isotope) {
+            cot.event.detail.radsensordetail.isotope = rad.isotope.map((i: Static<typeof RadIsotopeAttributes>) => ({ _attributes: { ...i } }));
+        }
+
+        if (rad.data_permissions) {
+            cot.event.detail.radsensordetail.data_permissions = { _attributes: { ...rad.data_permissions } };
+        }
+
+        if (rad.command_permissions) {
+            cot.event.detail.radsensordetail.command_permissions = { _attributes: { ...rad.command_permissions } };
+        }
+    }
+
+    if (feature.properties.chemsensordetail) {
+        const chem = feature.properties.chemsensordetail;
+        cot.event.detail.chemsensordetail = {
+            sensor_data: { _attributes: { ...chem.sensor_data } }
+        };
+
+        if (chem.detection) {
+            cot.event.detail.chemsensordetail.detection = chem.detection.map((d: Static<typeof ChemDetectionAttributes>) => ({ _attributes: { ...d } }));
+        }
+    }
+
+    if (feature.properties.biosensordetail) {
+        const bio = feature.properties.biosensordetail;
+        cot.event.detail.biosensordetail = {
+            sensor_data: { _attributes: { ...bio.sensor_data } }
+        };
+
+        if (bio.measurement) {
+            cot.event.detail.biosensordetail.measurement = bio.measurement.map((m) => {
+                const { level, ...attrs } = m;
+                const measurement: { _attributes: typeof attrs; level?: Array<{ _attributes: Static<typeof BioMeasurementLevelAttributes> }> } = { _attributes: { ...attrs } };
+                if (level) {
+                    measurement.level = level.map((l: Static<typeof BioMeasurementLevelAttributes>) => ({ _attributes: { ...l } }));
+                }
+                return measurement;
+            });
+        }
+    }
+
+    if (feature.properties.spatial) {
+        const spatial = feature.properties.spatial;
+        cot.event.detail.spatial = {
+            attitude: { _attributes: { ...spatial.attitude } },
+            spin: { _attributes: { ...spatial.spin } }
+        };
+
+        if (spatial.version !== undefined) {
+            cot.event.detail.spatial._attributes = { version: spatial.version };
+        }
+    }
+
     if (feature.properties.ackrequest) {
         cot.event.detail.ackrequest = { _attributes: { ...feature.properties.ackrequest } };
     }

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({