camstreamerlib 4.0.35 → 4.0.36-05711a0

package/cjs/types/PlaneTrackerAPI.test.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PlaneTrackerAPI_1 = require("./PlaneTrackerAPI");
+const globals_1 = require("@jest/globals");
+const AIRCRAFT_LABEL = {
+    firstRow: 'icao',
+    secondRow: 'call_sign',
+    thirdRow: 'blank',
+    fourthRow: 'registration',
+    opacity: 50,
+};
+const DEFAULT_DRONE_LABEL = { firstRow: 'remote_id', opacity: 30 };
+(0, globals_1.describe)('cameraSettingsSchema identificationLabel', () => {
+    (0, globals_1.test)('defaults both aircraft and drone labels', () => {
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({}).identificationLabel).toEqual({
+            aircraft: {
+                firstRow: 'icao',
+                secondRow: 'call_sign',
+                thirdRow: 'blank',
+                fourthRow: 'blank',
+                opacity: 30,
+            },
+            drone: DEFAULT_DRONE_LABEL,
+        });
+    });
+    (0, globals_1.test)('parses the aircraft and drone label', () => {
+        const identificationLabel = { aircraft: AIRCRAFT_LABEL, drone: { firstRow: 'blank', opacity: 70 } };
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({ identificationLabel }).identificationLabel).toEqual(identificationLabel);
+    });
+    (0, globals_1.test)('defaults a missing drone label', () => {
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({ identificationLabel: { aircraft: AIRCRAFT_LABEL } }).identificationLabel).toEqual({ aircraft: AIRCRAFT_LABEL, drone: DEFAULT_DRONE_LABEL });
+    });
+    (0, globals_1.test)('converts the legacy flat label to the aircraft label', () => {
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL }).identificationLabel).toEqual({
+            aircraft: AIRCRAFT_LABEL,
+            drone: DEFAULT_DRONE_LABEL,
+        });
+    });
+    (0, globals_1.test)('returns an independent drone label for each legacy parse', () => {
+        const first = PlaneTrackerAPI_1.cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL });
+        first.identificationLabel.drone.opacity = 90;
+        const second = PlaneTrackerAPI_1.cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL });
+        (0, globals_1.expect)(second.identificationLabel.drone).toEqual(DEFAULT_DRONE_LABEL);
+    });
+    (0, globals_1.test)('rejects an unknown drone label row', () => {
+        const identificationLabel = { aircraft: AIRCRAFT_LABEL, drone: { firstRow: 'icao', opacity: 30 } };
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.safeParse({ identificationLabel }).success).toBe(false);
+    });
+});
+const CAPTURE_CONFIG = { defaultCaptureSizeMeters: 50, captureSizeExtensionMeters: 20 };
+const DEFAULT_CAPTURE_CONFIG = { defaultCaptureSizeMeters: 120, captureSizeExtensionMeters: 80 };
+(0, globals_1.describe)('cameraSettingsSchema cameraConfig', () => {
+    (0, globals_1.test)('defaults both aircraft and drone capture config', () => {
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({}).cameraConfig).toEqual({
+            aircraft: DEFAULT_CAPTURE_CONFIG,
+            drone: DEFAULT_CAPTURE_CONFIG,
+        });
+    });
+    (0, globals_1.test)('parses independent aircraft and drone capture config', () => {
+        const cameraConfig = {
+            aircraft: CAPTURE_CONFIG,
+            drone: { defaultCaptureSizeMeters: 5, captureSizeExtensionMeters: 3 },
+        };
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({ cameraConfig }).cameraConfig).toEqual(cameraConfig);
+    });
+    (0, globals_1.test)('defaults a missing drone capture config', () => {
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({ cameraConfig: { aircraft: CAPTURE_CONFIG } }).cameraConfig).toEqual({
+            aircraft: CAPTURE_CONFIG,
+            drone: DEFAULT_CAPTURE_CONFIG,
+        });
+    });
+    (0, globals_1.test)('copies the legacy flat capture config to both aircraft and drone', () => {
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({ cameraConfig: CAPTURE_CONFIG }).cameraConfig).toEqual({
+            aircraft: CAPTURE_CONFIG,
+            drone: CAPTURE_CONFIG,
+        });
+    });
+    (0, globals_1.test)('returns independent aircraft and drone objects', () => {
+        const legacy = PlaneTrackerAPI_1.cameraSettingsSchema.parse({ cameraConfig: CAPTURE_CONFIG }).cameraConfig;
+        legacy.drone.defaultCaptureSizeMeters = 1;
+        (0, globals_1.expect)(legacy.aircraft).toEqual(CAPTURE_CONFIG);
+        const first = PlaneTrackerAPI_1.cameraSettingsSchema.parse({}).cameraConfig;
+        first.drone.defaultCaptureSizeMeters = 1;
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.parse({}).cameraConfig.drone).toEqual(DEFAULT_CAPTURE_CONFIG);
+    });
+    (0, globals_1.test)('rejects a non-positive drone capture size', () => {
+        const cameraConfig = { aircraft: CAPTURE_CONFIG, drone: { ...CAPTURE_CONFIG, defaultCaptureSizeMeters: 0 } };
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.safeParse({ cameraConfig }).success).toBe(false);
+    });
+});
+(0, globals_1.describe)('cameraSettingsSchema widget units', () => {
+    const WIDGET = { coord: 'top_left', posX: 10, posY: 10, scale: 100 };
+    (0, globals_1.test)('defaults all widget units to rotate', () => {
+        const settings = PlaneTrackerAPI_1.cameraSettingsSchema.parse({});
+        (0, globals_1.expect)(settings.widget.units).toBe('rotate');
+        (0, globals_1.expect)(settings.airportWidget.windSpeedUnits).toBe('rotate');
+        (0, globals_1.expect)(settings.airportWidget.temperatureUnits).toBe('rotate');
+    });
+    (0, globals_1.test)('defaults missing units of saved widgets to rotate', () => {
+        const settings = PlaneTrackerAPI_1.cameraSettingsSchema.parse({ widget: WIDGET, airportWidget: WIDGET });
+        (0, globals_1.expect)(settings.widget.units).toBe('rotate');
+        (0, globals_1.expect)(settings.airportWidget.windSpeedUnits).toBe('rotate');
+        (0, globals_1.expect)(settings.airportWidget.temperatureUnits).toBe('rotate');
+    });
+    (0, globals_1.test)('parses independent widget units', () => {
+        const settings = PlaneTrackerAPI_1.cameraSettingsSchema.parse({
+            widget: { ...WIDGET, units: 'imperial' },
+            airportWidget: { ...WIDGET, windSpeedUnits: 'rotate', temperatureUnits: 'metric' },
+        });
+        (0, globals_1.expect)(settings.widget.units).toBe('imperial');
+        (0, globals_1.expect)(settings.airportWidget.windSpeedUnits).toBe('rotate');
+        (0, globals_1.expect)(settings.airportWidget.temperatureUnits).toBe('metric');
+    });
+    (0, globals_1.test)('rejects an unknown widget unit', () => {
+        (0, globals_1.expect)(PlaneTrackerAPI_1.cameraSettingsSchema.safeParse({ widget: { ...WIDGET, units: 'kelvin' } }).success).toBe(false);
+    });
+});

package/cjs/types/ws/CamSwitcherEvents.d.ts

@@ -54,15 +54,15 @@ declare const cswEventsDataSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
 }, "strip", z.ZodTypeAny, {
     type: "StreamSwitchVideoError";
     playlist_name: string;
-    playlist_active_stream: number;
     info: string;
+    playlist_active_stream: number;
     stream_name?: string | undefined;
     clip_name?: string | undefined;
 }, {
     type: "StreamSwitchVideoError";
     playlist_name: string;
-    playlist_active_stream: number;
     info: string;
+    playlist_active_stream: number;
     stream_name?: string | undefined;
     clip_name?: string | undefined;
 }>, z.ZodObject<{
@@ -207,15 +207,15 @@ export declare const cswEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
     }, "strip", z.ZodTypeAny, {
         type: "StreamSwitchVideoError";
         playlist_name: string;
-        playlist_active_stream: number;
         info: string;
+        playlist_active_stream: number;
         stream_name?: string | undefined;
         clip_name?: string | undefined;
     }, {
         type: "StreamSwitchVideoError";
         playlist_name: string;
-        playlist_active_stream: number;
         info: string;
+        playlist_active_stream: number;
         stream_name?: string | undefined;
         clip_name?: string | undefined;
     }>, z.ZodObject<{
@@ -323,8 +323,8 @@ export declare const cswEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
     } | {
         type: "StreamSwitchVideoError";
         playlist_name: string;
-        playlist_active_stream: number;
         info: string;
+        playlist_active_stream: number;
         stream_name?: string | undefined;
         clip_name?: string | undefined;
     } | {
@@ -376,8 +376,8 @@ export declare const cswEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
     } | {
         type: "StreamSwitchVideoError";
         playlist_name: string;
-        playlist_active_stream: number;
         info: string;
+        playlist_active_stream: number;
         stream_name?: string | undefined;
         clip_name?: string | undefined;
     } | {
@@ -464,15 +464,15 @@ export declare const cswEventsSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
 }, "strip", z.ZodTypeAny, {
     type: "StreamSwitchVideoError";
     playlist_name: string;
-    playlist_active_stream: number;
     info: string;
+    playlist_active_stream: number;
     stream_name?: string | undefined;
     clip_name?: string | undefined;
 }, {
     type: "StreamSwitchVideoError";
     playlist_name: string;
-    playlist_active_stream: number;
     info: string;
+    playlist_active_stream: number;
     stream_name?: string | undefined;
     clip_name?: string | undefined;
 }>, z.ZodObject<{

package/esm/VapixAPI.js

@@ -1,5 +1,5 @@
 import { arrayToUrl, isNullish, paramToUrl } from './internal/utils';
-import { sdCardWatchedStatuses, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, timeZoneSchema, getPortsResponseSchema, guardTourSchema, ptzOverviewSchema, cameraPTZItemDataSchema, applicationListSchema, sdCardInfoSchema, ALL_APP_IDS, allDateTimeInfoSchema, } from './types/VapixAPI';
+import { sdCardWatchedStatuses, maxFpsResponseSchema, dateTimeinfoSchema, audioDeviceRequestSchema, audioSampleRatesResponseSchema, applicationSchema, timeZoneSchema, getPortsResponseSchema, guardTourSchema, ptzOverviewSchema, cameraPTZItemDataSchema, sdCardInfoSchema, ALL_APP_IDS, allDateTimeInfoSchema, } from './types/VapixAPI';
 import { ApplicationAPIError, MaxFPSError, NoDeviceInfoError, PtzNotSupportedError, ErrorWithResponse, SDCardActionError, SDCardJobError, SettingParameterError, TimezoneFetchError, } from './errors/errors';
 import { z } from 'zod';
 import { XMLParser } from 'fast-xml-parser';
@@ -562,17 +562,21 @@ export class VapixAPI extends BasicAPI {
             allowBooleanAttributes: true,
         });
         const result = parser.parse(xml);
-        let apps = result.reply.application ?? [];
-        if (!Array.isArray(apps)) {
-            apps = [apps];
-        }
-        const appList = apps.map((app) => {
-            return {
-                ...app,
-                appId: ALL_APP_IDS.find((id) => id.toLowerCase() === app.Name.toLowerCase()) ?? null,
-            };
-        });
-        return applicationListSchema.parse(appList);
+        const rawApps = result.reply.application ?? [];
+        const apps = Array.isArray(rawApps) ? rawApps : [rawApps];
+        const appList = [];
+        for (const app of apps) {
+            const parsedApp = applicationSchema.safeParse(app);
+            if (!parsedApp.success) {
+                console.debug('Skipping invalid application entry:', app, parsedApp.error.issues);
+                continue;
+            }
+            appList.push({
+                ...parsedApp.data,
+                appId: ALL_APP_IDS.find((id) => id.toLowerCase() === parsedApp.data.Name.toLowerCase()) ?? null,
+            });
+        }
+        return appList;
     }
     async startApplication(applicationId, options) {
         const agent = this.getClient(options?.proxyParams);

package/esm/VapixAPI.test.js

@@ -0,0 +1,144 @@
+import { VapixAPI } from './VapixAPI';
+import { describe, test, expect, jest, afterEach } from '@jest/globals';
+const createApi = (xml) => {
+    const client = {
+        get: () => Promise.resolve(new Response(xml)),
+        post: () => Promise.reject(new Error('unused')),
+    };
+    return new VapixAPI(client);
+};
+describe('VapixAPI', () => {
+    describe('getApplicationList', () => {
+        afterEach(() => {
+            jest.restoreAllMocks();
+        });
+        test('skips the nameless entry of the live camera list', async () => {
+            const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
+            const api = createApi(`<reply result="ok">
+ <application Name="camstreamer" NiceName="CamStreamer App" Vendor="CamStreamer" Version="5.0-15" ApplicationID="413135" License="None" Status="Running" ConfigurationPage="local/camstreamer/settings.html" />
+ <application Name="" License="None" Status="Stopped" />
+ <application Name="vmd" NiceName="AXIS Video Motion Detection" Vendor="Axis Communications" Version="4.4-5" ApplicationID="143440" License="None" Status="Stopped" ConfigurationPage="local/vmd/config.html" VendorHomePage="http://www.axis.com" LicenseName="Proprietary" />
+</reply>`);
+            await expect(api.getApplicationList()).resolves.toEqual([
+                {
+                    Name: 'camstreamer',
+                    NiceName: 'CamStreamer App',
+                    Vendor: 'CamStreamer',
+                    Version: '5.0-15',
+                    ApplicationID: '413135',
+                    License: 'None',
+                    Status: 'Running',
+                    ConfigurationPage: 'local/camstreamer/settings.html',
+                    appId: 'CamStreamer',
+                },
+                {
+                    Name: 'vmd',
+                    NiceName: 'AXIS Video Motion Detection',
+                    Vendor: 'Axis Communications',
+                    Version: '4.4-5',
+                    ApplicationID: '143440',
+                    License: 'None',
+                    Status: 'Stopped',
+                    ConfigurationPage: 'local/vmd/config.html',
+                    VendorHomePage: 'http://www.axis.com',
+                    LicenseName: 'Proprietary',
+                    appId: null,
+                },
+            ]);
+            expect(debugSpy).toHaveBeenCalledTimes(1);
+            expect(debugSpy.mock.calls[0]).toContainEqual({ Name: '', License: 'None', Status: 'Stopped' });
+        });
+        test.each([
+            {
+                name: 'an entry without a name',
+                xml: '<reply result="ok"><application Name="vmd" NiceName="AXIS Video Motion Detection" Vendor="Axis Communications" Version="4.4-5" License="None" Status="Stopped" /><application License="None" Status="Stopped" /></reply>',
+                expected: [
+                    {
+                        Name: 'vmd',
+                        NiceName: 'AXIS Video Motion Detection',
+                        Vendor: 'Axis Communications',
+                        Version: '4.4-5',
+                        License: 'None',
+                        Status: 'Stopped',
+                        appId: null,
+                    },
+                ],
+            },
+            {
+                name: 'a named entry missing informational fields',
+                xml: '<reply result="ok"><application Name="vmd" NiceName="AXIS Video Motion Detection" Vendor="Axis Communications" Version="4.4-5" License="None" Status="Stopped" /><application Name="broken" License="None" Status="Stopped" /></reply>',
+                expected: [
+                    {
+                        Name: 'vmd',
+                        NiceName: 'AXIS Video Motion Detection',
+                        Vendor: 'Axis Communications',
+                        Version: '4.4-5',
+                        License: 'None',
+                        Status: 'Stopped',
+                        appId: null,
+                    },
+                ],
+            },
+        ])('skips invalid entries individually: $name', async ({ xml, expected }) => {
+            const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
+            await expect(createApi(xml).getApplicationList()).resolves.toEqual(expected);
+            expect(debugSpy).toHaveBeenCalledTimes(1);
+        });
+        test.each([
+            {
+                name: 'drops attributes outside the schema',
+                xml: '<reply result="ok"><application Name="camoverlay" NiceName="CamOverlay App" Vendor="CamStreamer" Version="3.0-1" License="None" Status="Running" Unexpected="value" /></reply>',
+                expected: [
+                    {
+                        Name: 'camoverlay',
+                        NiceName: 'CamOverlay App',
+                        Vendor: 'CamStreamer',
+                        Version: '3.0-1',
+                        License: 'None',
+                        Status: 'Running',
+                        appId: 'CamOverlay',
+                    },
+                ],
+            },
+            {
+                name: 'maps an application outside the core CamStreamer apps to its appId',
+                xml: '<reply result="ok"><application Name="sporttracker" NiceName="SportTracker App" Vendor="CamStreamer" Version="1.0-1" License="None" Status="Running" /></reply>',
+                expected: [
+                    {
+                        Name: 'sporttracker',
+                        NiceName: 'SportTracker App',
+                        Vendor: 'CamStreamer',
+                        Version: '1.0-1',
+                        License: 'None',
+                        Status: 'Running',
+                        appId: 'SportTracker',
+                    },
+                ],
+            },
+            {
+                name: 'maps a capitalised application name to its appId',
+                xml: '<reply result="ok"><application Name="CamOverlay" NiceName="CamOverlay App" Vendor="CamStreamer" Version="3.0-1" License="None" Status="Running" /></reply>',
+                expected: [
+                    {
+                        Name: 'CamOverlay',
+                        NiceName: 'CamOverlay App',
+                        Vendor: 'CamStreamer',
+                        Version: '3.0-1',
+                        License: 'None',
+                        Status: 'Running',
+                        appId: 'CamOverlay',
+                    },
+                ],
+            },
+            {
+                name: 'returns an empty list when the camera has no applications',
+                xml: '<reply result="ok"></reply>',
+                expected: [],
+            },
+        ])('returns every valid entry with its appId and logs nothing: $name', async ({ xml, expected }) => {
+            const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => { });
+            await expect(createApi(xml).getApplicationList()).resolves.toEqual(expected);
+            expect(debugSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/esm/types/PlaneTrackerAPI.js

@@ -25,6 +25,7 @@ export const widgetSchema = z.object({
     posY: z.number().nonnegative(),
     scale: z.number().positive(),
 });
+const widgetUnitsSchema = z.union([z.literal('metric'), z.literal('imperial'), z.literal('rotate')]);
 const labelOptionsSchema = z.union([
     z.literal('blank'),
     z.literal('registration'),
@@ -32,13 +33,59 @@ const labelOptionsSchema = z.union([
     z.literal('flight_number'),
     z.literal('icao'),
 ]);
-const identificationLabelSchema = z.object({
+const aircraftIdentificationLabelSchema = z.object({
     firstRow: labelOptionsSchema,
     secondRow: labelOptionsSchema,
     thirdRow: labelOptionsSchema,
     fourthRow: labelOptionsSchema,
-    opacity: z.number().positive(),
+    opacity: z.number().nonnegative(),
 });
+const droneLabelOptionsSchema = z.union([z.literal('blank'), z.literal('remote_id')]);
+const droneIdentificationLabelSchema = z.object({
+    firstRow: droneLabelOptionsSchema,
+    opacity: z.number().nonnegative(),
+});
+const DEFAULT_DRONE_IDENTIFICATION_LABEL = {
+    firstRow: 'remote_id',
+    opacity: 30,
+};
+const identificationLabelSchema = z.union([
+    z.object({
+        aircraft: aircraftIdentificationLabelSchema,
+        drone: droneIdentificationLabelSchema.default(DEFAULT_DRONE_IDENTIFICATION_LABEL),
+    }),
+    aircraftIdentificationLabelSchema.transform((aircraft) => ({
+        aircraft,
+        drone: { ...DEFAULT_DRONE_IDENTIFICATION_LABEL },
+    })),
+]);
+const captureConfigSchema = z.object({
+    defaultCaptureSizeMeters: z.number().positive(),
+    captureSizeExtensionMeters: z.number().positive(),
+});
+const DEFAULT_CAPTURE_CONFIG = {
+    defaultCaptureSizeMeters: 120,
+    captureSizeExtensionMeters: 80,
+};
+const cameraConfigSchema = z.union([
+    z.object({
+        aircraft: captureConfigSchema,
+        drone: captureConfigSchema.default(() => ({ ...DEFAULT_CAPTURE_CONFIG })),
+    }),
+    z
+        .object({
+        defaultCaptureSizeMeters: z.number().positive().default(DEFAULT_CAPTURE_CONFIG.defaultCaptureSizeMeters),
+        captureSizeExtensionMeters: z
+            .number()
+            .positive()
+            .default(DEFAULT_CAPTURE_CONFIG.captureSizeExtensionMeters),
+    })
+        .strict()
+        .transform((captureConfig) => ({
+        aircraft: captureConfig,
+        drone: { ...captureConfig },
+    })),
+]);
 export const cameraSettingsSchema = z.object({
     units: z.union([z.literal('metric'), z.literal('imperial')]).default('imperial'),
     adsbSource: z
@@ -76,15 +123,10 @@ export const cameraSettingsSchema = z.object({
         nightSkyCalibrationFocusValue: 9000,
         focusCalibrationPoints: '',
     }),
-    cameraConfig: z
-        .object({
-        defaultCaptureSizeMeters: z.number().positive().default(120),
-        captureSizeExtensionMeters: z.number().positive().default(80),
-    })
-        .default({
-        defaultCaptureSizeMeters: 120,
-        captureSizeExtensionMeters: 80,
-    }),
+    cameraConfig: cameraConfigSchema.default(() => ({
+        aircraft: { ...DEFAULT_CAPTURE_CONFIG },
+        drone: { ...DEFAULT_CAPTURE_CONFIG },
+    })),
     stream: z
         .object({
         width: z.number().positive(),
@@ -145,18 +187,25 @@ export const cameraSettingsSchema = z.object({
         displaySystemInfo: z.boolean().optional(),
     })
         .optional(),
-    widget: widgetSchema.default({
+    widget: widgetSchema
+        .extend({
+        units: widgetUnitsSchema.default('rotate'),
+    })
+        .default({
         enabled: true,
         coord: 'top_right',
         posX: 10,
         posY: 10,
         scale: 100,
+        units: 'rotate',
     }),
     airportWidget: widgetSchema
         .extend({
         showWeather: z.boolean().default(false),
         weatherLocationKey: z.string().default(''),
         weatherLocationName: z.string().default(''),
+        windSpeedUnits: widgetUnitsSchema.default('rotate'),
+        temperatureUnits: widgetUnitsSchema.default('rotate'),
     })
         .default({
         enabled: true,
@@ -167,6 +216,8 @@ export const cameraSettingsSchema = z.object({
         showWeather: false,
         weatherLocationKey: '',
         weatherLocationName: '',
+        windSpeedUnits: 'rotate',
+        temperatureUnits: 'rotate',
     }),
     fr24FlightInfoSource: z
         .object({
@@ -195,11 +246,14 @@ export const cameraSettingsSchema = z.object({
         port: 80,
     }),
     identificationLabel: identificationLabelSchema.default({
-        firstRow: 'registration',
-        secondRow: 'blank',
-        thirdRow: 'blank',
-        fourthRow: 'blank',
-        opacity: 30,
+        aircraft: {
+            firstRow: 'icao',
+            secondRow: 'call_sign',
+            thirdRow: 'blank',
+            fourthRow: 'blank',
+            opacity: 30,
+        },
+        drone: DEFAULT_DRONE_IDENTIFICATION_LABEL,
     }),
     acs: connectionSchema
         .extend({

package/esm/types/PlaneTrackerAPI.test.js

@@ -0,0 +1,115 @@
+import { cameraSettingsSchema } from './PlaneTrackerAPI';
+import { describe, test, expect } from '@jest/globals';
+const AIRCRAFT_LABEL = {
+    firstRow: 'icao',
+    secondRow: 'call_sign',
+    thirdRow: 'blank',
+    fourthRow: 'registration',
+    opacity: 50,
+};
+const DEFAULT_DRONE_LABEL = { firstRow: 'remote_id', opacity: 30 };
+describe('cameraSettingsSchema identificationLabel', () => {
+    test('defaults both aircraft and drone labels', () => {
+        expect(cameraSettingsSchema.parse({}).identificationLabel).toEqual({
+            aircraft: {
+                firstRow: 'icao',
+                secondRow: 'call_sign',
+                thirdRow: 'blank',
+                fourthRow: 'blank',
+                opacity: 30,
+            },
+            drone: DEFAULT_DRONE_LABEL,
+        });
+    });
+    test('parses the aircraft and drone label', () => {
+        const identificationLabel = { aircraft: AIRCRAFT_LABEL, drone: { firstRow: 'blank', opacity: 70 } };
+        expect(cameraSettingsSchema.parse({ identificationLabel }).identificationLabel).toEqual(identificationLabel);
+    });
+    test('defaults a missing drone label', () => {
+        expect(cameraSettingsSchema.parse({ identificationLabel: { aircraft: AIRCRAFT_LABEL } }).identificationLabel).toEqual({ aircraft: AIRCRAFT_LABEL, drone: DEFAULT_DRONE_LABEL });
+    });
+    test('converts the legacy flat label to the aircraft label', () => {
+        expect(cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL }).identificationLabel).toEqual({
+            aircraft: AIRCRAFT_LABEL,
+            drone: DEFAULT_DRONE_LABEL,
+        });
+    });
+    test('returns an independent drone label for each legacy parse', () => {
+        const first = cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL });
+        first.identificationLabel.drone.opacity = 90;
+        const second = cameraSettingsSchema.parse({ identificationLabel: AIRCRAFT_LABEL });
+        expect(second.identificationLabel.drone).toEqual(DEFAULT_DRONE_LABEL);
+    });
+    test('rejects an unknown drone label row', () => {
+        const identificationLabel = { aircraft: AIRCRAFT_LABEL, drone: { firstRow: 'icao', opacity: 30 } };
+        expect(cameraSettingsSchema.safeParse({ identificationLabel }).success).toBe(false);
+    });
+});
+const CAPTURE_CONFIG = { defaultCaptureSizeMeters: 50, captureSizeExtensionMeters: 20 };
+const DEFAULT_CAPTURE_CONFIG = { defaultCaptureSizeMeters: 120, captureSizeExtensionMeters: 80 };
+describe('cameraSettingsSchema cameraConfig', () => {
+    test('defaults both aircraft and drone capture config', () => {
+        expect(cameraSettingsSchema.parse({}).cameraConfig).toEqual({
+            aircraft: DEFAULT_CAPTURE_CONFIG,
+            drone: DEFAULT_CAPTURE_CONFIG,
+        });
+    });
+    test('parses independent aircraft and drone capture config', () => {
+        const cameraConfig = {
+            aircraft: CAPTURE_CONFIG,
+            drone: { defaultCaptureSizeMeters: 5, captureSizeExtensionMeters: 3 },
+        };
+        expect(cameraSettingsSchema.parse({ cameraConfig }).cameraConfig).toEqual(cameraConfig);
+    });
+    test('defaults a missing drone capture config', () => {
+        expect(cameraSettingsSchema.parse({ cameraConfig: { aircraft: CAPTURE_CONFIG } }).cameraConfig).toEqual({
+            aircraft: CAPTURE_CONFIG,
+            drone: DEFAULT_CAPTURE_CONFIG,
+        });
+    });
+    test('copies the legacy flat capture config to both aircraft and drone', () => {
+        expect(cameraSettingsSchema.parse({ cameraConfig: CAPTURE_CONFIG }).cameraConfig).toEqual({
+            aircraft: CAPTURE_CONFIG,
+            drone: CAPTURE_CONFIG,
+        });
+    });
+    test('returns independent aircraft and drone objects', () => {
+        const legacy = cameraSettingsSchema.parse({ cameraConfig: CAPTURE_CONFIG }).cameraConfig;
+        legacy.drone.defaultCaptureSizeMeters = 1;
+        expect(legacy.aircraft).toEqual(CAPTURE_CONFIG);
+        const first = cameraSettingsSchema.parse({}).cameraConfig;
+        first.drone.defaultCaptureSizeMeters = 1;
+        expect(cameraSettingsSchema.parse({}).cameraConfig.drone).toEqual(DEFAULT_CAPTURE_CONFIG);
+    });
+    test('rejects a non-positive drone capture size', () => {
+        const cameraConfig = { aircraft: CAPTURE_CONFIG, drone: { ...CAPTURE_CONFIG, defaultCaptureSizeMeters: 0 } };
+        expect(cameraSettingsSchema.safeParse({ cameraConfig }).success).toBe(false);
+    });
+});
+describe('cameraSettingsSchema widget units', () => {
+    const WIDGET = { coord: 'top_left', posX: 10, posY: 10, scale: 100 };
+    test('defaults all widget units to rotate', () => {
+        const settings = cameraSettingsSchema.parse({});
+        expect(settings.widget.units).toBe('rotate');
+        expect(settings.airportWidget.windSpeedUnits).toBe('rotate');
+        expect(settings.airportWidget.temperatureUnits).toBe('rotate');
+    });
+    test('defaults missing units of saved widgets to rotate', () => {
+        const settings = cameraSettingsSchema.parse({ widget: WIDGET, airportWidget: WIDGET });
+        expect(settings.widget.units).toBe('rotate');
+        expect(settings.airportWidget.windSpeedUnits).toBe('rotate');
+        expect(settings.airportWidget.temperatureUnits).toBe('rotate');
+    });
+    test('parses independent widget units', () => {
+        const settings = cameraSettingsSchema.parse({
+            widget: { ...WIDGET, units: 'imperial' },
+            airportWidget: { ...WIDGET, windSpeedUnits: 'rotate', temperatureUnits: 'metric' },
+        });
+        expect(settings.widget.units).toBe('imperial');
+        expect(settings.airportWidget.windSpeedUnits).toBe('rotate');
+        expect(settings.airportWidget.temperatureUnits).toBe('metric');
+    });
+    test('rejects an unknown widget unit', () => {
+        expect(cameraSettingsSchema.safeParse({ widget: { ...WIDGET, units: 'kelvin' } }).success).toBe(false);
+    });
+});