camstreamerlib 4.0.32 → 4.0.33-10a29ef

package/esm/types/PlaneTrackerAPI.test.js

@@ -0,0 +1,88 @@
+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);
+    });
+});

package/esm/types/ws/PlaneTrackerEvents.js

@@ -3,6 +3,7 @@ import { blackListSchema, friendlyListSchema, priorityListSchema, trackingModeSc
 const wsApiFlightDataSchema = z.object({
     targetId: z.string(),
     icao: z.string(),
+    callsign: z.string().optional(),
     domain: domainIdSchema,
     categoryId: z.string(),
     groupId: z.string().optional(),
@@ -44,6 +45,18 @@ const apiUserSchema = userSchema.extend({
     ip: z.string(),
     userPriority: z.number(),
 });
+export const USER_PRIORITY_MIN = 1;
+export const USER_PRIORITY_MAX = 255;
+const USER_PRIORITY_ERROR = `userPriority must be an integer between ${USER_PRIORITY_MIN} and ${USER_PRIORITY_MAX}, where ${USER_PRIORITY_MIN} is the highest priority`;
+export const apiUserInputSchema = apiUserSchema.omit({ ip: true }).extend({
+    userId: z.string().nonempty(),
+    userName: z.string().nonempty(),
+    userPriority: z
+        .number()
+        .int(USER_PRIORITY_ERROR)
+        .min(USER_PRIORITY_MIN, USER_PRIORITY_ERROR)
+        .max(USER_PRIORITY_MAX, USER_PRIORITY_ERROR),
+});
 export var EUserActions;
 (function (EUserActions) {
     EUserActions["TRACK_ICAO"] = "trackIcao.cgi";
@@ -67,6 +80,7 @@ const eventsDataSchema = z.union([
         type: z.literal('TRACKING_START'),
         icao: z.string(),
         targetId: z.string(),
+        callsign: z.string().optional(),
         domain: domainIdSchema,
         categoryId: z.string(),
     }),

package/esm/ws/PlaneTrackerEvents.js

@@ -1,10 +1,10 @@
 import { WsEvents } from '../internal/WsEvents';
-import { ptrEventsSchema } from '../types/ws/PlaneTrackerEvents';
+import { ptrEventsSchema, apiUserInputSchema, } from '../types/ws/PlaneTrackerEvents';
 export class PlaneTrackerEvents extends WsEvents {
     _apiUser;
-    constructor(ws, _apiUser) {
+    constructor(ws, apiUser) {
         super((data) => ptrEventsSchema.parse(data), ws);
-        this._apiUser = _apiUser;
+        this._apiUser = apiUserInputSchema.parse(apiUser);
         this.ws.onOpen = this.sendInitMsg;
     }
     sendInitMsg = () => {

package/esm/ws/PlaneTrackerEvents.test.js

@@ -0,0 +1,25 @@
+import { PlaneTrackerEvents } from './PlaneTrackerEvents';
+import { USER_PRIORITY_MAX, USER_PRIORITY_MIN } from '../types/ws/PlaneTrackerEvents';
+const createWsClient = () => ({
+    send: jest.fn(),
+    onOpen: undefined,
+    onMessage: undefined,
+});
+const VALID_USER = { userId: 'asd', userName: 'Asd', userPriority: 1 };
+describe('PlaneTrackerEvents', () => {
+    it.each([0, -1, USER_PRIORITY_MAX + 1, 1.5])('rejects userPriority %p', (userPriority) => {
+        expect(() => new PlaneTrackerEvents(createWsClient(), { ...VALID_USER, userPriority })).toThrow(/userPriority must be an integer/);
+    });
+    it.each([USER_PRIORITY_MIN, USER_PRIORITY_MAX])('accepts userPriority %p', (userPriority) => {
+        expect(() => new PlaneTrackerEvents(createWsClient(), { ...VALID_USER, userPriority })).not.toThrow();
+    });
+    it('rejects an empty userId', () => {
+        expect(() => new PlaneTrackerEvents(createWsClient(), { ...VALID_USER, userId: '' })).toThrow();
+    });
+    it('sends USER_INFO once the socket opens', () => {
+        const ws = createWsClient();
+        new PlaneTrackerEvents(ws, VALID_USER);
+        ws.onOpen();
+        expect(ws.send).toHaveBeenCalledWith(JSON.stringify({ type: 'USER_INFO', ...VALID_USER }));
+    });
+});

package/examples/README.md

@@ -0,0 +1,43 @@
+# Examples
+
+Standalone browser examples that use CamStreamerLib directly from a `<script type="module">`,
+without a bundler or a framework.
+
+## Build the browser bundle
+
+```bash
+npm install
+npm run build:browser
+```
+
+## Run
+
+Modules can't be loaded over `file://`, so serve the folder over HTTP:
+
+```bash
+npx serve examples
+```
+
+Both pages connect to a camera through the Device Connect proxy. Fill in the device host
+(`<MAC_ADDRESS>.device-connect.net`) and the device access token in the form, or hardcode them in the
+`DEVICE_HOST` / `DEVICE_ACCESS_TOKEN` constants at the top of the page's script to have the form
+prefilled. See [doc/Client.md](../doc/Client.md).
+
+## camswitcher-events.html
+
+Logs every CamSwitcher event. `DeviceConnectClient` (HTTP) backs `CamSwitcherAPI` to obtain the
+websocket authorization token; `DeviceConnectWsClient` (websocket) backs `CamSwitcherEvents`, which
+validates and dispatches the events. Connection state is taken from the `authorization` event.
+
+See [doc/ws/CamSwitcherEvents.md](../doc/ws/CamSwitcherEvents.md).
+
+## planetracker-events.html
+
+Logs every PlaneTracker event. PlaneTracker needs no authorization token — `PlaneTrackerEvents`
+announces the connecting user (`userId` / `userName` / `userPriority`, editable in the form) as the
+init message instead, so only the websocket client is needed.
+
+`CAMERA_POSITION` and `FLIGHT_LIST` arrive continuously, so by default they only update the summary
+line above the log; tick the checkbox to log them as well.
+
+See [doc/ws/PlaneTrackerEvents.md](../doc/ws/PlaneTrackerEvents.md).