camstreamerlib 4.0.32 → 4.0.33-018c17e

package/esm/node/HttpRequestSender.test.js

@@ -0,0 +1,136 @@
+import * as http from 'http';
+import { FormData } from 'undici';
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { HttpRequestSender } from './HttpRequestSender';
+const DIGEST_CHALLENGE = 'Digest realm="test", qop="auth", nonce="abc123", opaque="xyz"';
+const okHandler = (_req, res) => {
+    res.end('ok');
+};
+const digestHandler = (req, res) => {
+    if (req.headers.authorization?.startsWith('Digest ') !== true) {
+        res.writeHead(401, { 'WWW-Authenticate': DIGEST_CHALLENGE });
+        res.end();
+        return;
+    }
+    res.end('ok');
+};
+describe('HttpRequestSender', () => {
+    let server;
+    let received;
+    let handler;
+    const options = (overrides = {}) => ({
+        protocol: 'http:',
+        host: '127.0.0.1',
+        port: server.address().port,
+        path: '/test.cgi',
+        user: 'root',
+        pass: 'pass',
+        ...overrides,
+    });
+    beforeEach(async () => {
+        received = [];
+        handler = okHandler;
+        server = http.createServer((req, res) => {
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk.toString();
+            });
+            req.on('end', () => {
+                received.push({
+                    method: req.method,
+                    url: req.url,
+                    authorization: req.headers.authorization,
+                    contentType: req.headers['content-type'],
+                    body,
+                });
+                handler(req, res);
+            });
+        });
+        await new Promise((resolve) => {
+            server.listen(0, '127.0.0.1', resolve);
+        });
+    });
+    afterEach(async () => {
+        server.closeAllConnections();
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+    });
+    test('sends basic auth when the server accepts it', async () => {
+        const res = await new HttpRequestSender().sendRequest(options());
+        expect(res.status).toBe(200);
+        expect(await res.text()).toBe('ok');
+        expect(received).toHaveLength(1);
+        expect(received[0]?.authorization).toBe(`Basic ${Buffer.from('root:pass').toString('base64')}`);
+    });
+    test('sends no authorization without credentials', async () => {
+        await new HttpRequestSender().sendRequest(options({ user: undefined, pass: undefined }));
+        expect(received[0]?.authorization).toBeUndefined();
+    });
+    test('retries with digest auth on a digest 401 and reuses it for later requests', async () => {
+        handler = digestHandler;
+        const sender = new HttpRequestSender();
+        const first = await sender.sendRequest(options());
+        const second = await sender.sendRequest(options());
+        expect(first.status).toBe(200);
+        expect(second.status).toBe(200);
+        expect(received.map((r) => r.authorization?.split(' ')[0])).toEqual(['Basic', 'Digest', 'Digest']);
+    });
+    test('keeps digest auth after a non-401 error response', async () => {
+        const sender = new HttpRequestSender();
+        handler = digestHandler;
+        await sender.sendRequest(options());
+        handler = (_req, res) => {
+            res.writeHead(500);
+            res.end();
+        };
+        await sender.sendRequest(options());
+        handler = digestHandler;
+        const res = await sender.sendRequest(options());
+        expect(res.status).toBe(200);
+        expect(received.map((r) => r.authorization?.split(' ')[0])).toEqual(['Basic', 'Digest', 'Digest', 'Digest']);
+    });
+    test('retries a digest 401 only once', async () => {
+        handler = (_req, res) => {
+            res.writeHead(401, { 'WWW-Authenticate': DIGEST_CHALLENGE });
+            res.end();
+        };
+        const res = await new HttpRequestSender().sendRequest(options());
+        expect(res.status).toBe(401);
+        expect(received).toHaveLength(2);
+    });
+    test('rejects when the response does not arrive within the timeout', async () => {
+        handler = () => undefined;
+        await expect(new HttpRequestSender().sendRequest(options({ timeout: 200 }))).rejects.toThrow();
+    });
+    test('sends a url-encoded POST body', async () => {
+        const res = await new HttpRequestSender().sendRequest(options({ method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }), 'action=settext&text=hello');
+        expect(res.ok).toBe(true);
+        expect(received[0]).toMatchObject({
+            method: 'POST',
+            contentType: 'application/x-www-form-urlencoded',
+            body: 'action=settext&text=hello',
+        });
+    });
+    test('sends a JSON POST body', async () => {
+        const payload = JSON.stringify({ text: 'hello', index: 1 });
+        await new HttpRequestSender().sendRequest(options({ method: 'POST', headers: { 'Content-Type': 'application/json' } }), payload);
+        expect(received[0]).toMatchObject({ method: 'POST', contentType: 'application/json', body: payload });
+    });
+    test('sends a Buffer POST body', async () => {
+        await new HttpRequestSender().sendRequest(options({ method: 'POST' }), Buffer.from('binary-data'));
+        expect(received[0]?.body).toBe('binary-data');
+    });
+    test('sends a FormData POST body as multipart', async () => {
+        const formData = new FormData();
+        formData.append('field', 'value');
+        await new HttpRequestSender().sendRequest(options({ method: 'POST' }), formData);
+        expect(received[0]?.contentType).toMatch(/^multipart\/form-data; boundary=/);
+        expect(received[0]?.body).toContain('value');
+    });
+    test('resends the POST body on the digest retry', async () => {
+        handler = digestHandler;
+        await new HttpRequestSender().sendRequest(options({ method: 'POST' }), 'payload');
+        expect(received.map((r) => r.body)).toEqual(['payload', 'payload']);
+    });
+});

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).