camstreamerlib 4.0.32 → 4.0.33-10a29ef

package/README.md

@@ -39,6 +39,15 @@ npm install camstreamerlib
 
 </br>
 
+# Examples
+
+| Example                                                                                                                                                         | Description                                                                                                                                                                                                                                                                                                                                                                                                           | Open in browser                                                                        |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
+| [CamSwitcherEvents](examples/camswitcher-events.html) ([source](https://github.com/CamStreamer/CamStreamerLib/blob/master/examples/camswitcher-events.html))    | Logs every CamSwitcher event. `DeviceConnectClient` (HTTP) backs [CamSwitcherAPI](doc/CamSwitcherAPI.md) to obtain the websocket authorization token, `DeviceConnectWsClient` (websocket) backs [CamSwitcherEvents](doc/ws/CamSwitcherEvents.md), which validates and dispatches the events. Connection state is taken from the `authorization` event.                                                                | [open](https://camstreamer.github.io/CamStreamerLib/examples/camswitcher-events.html)  |
+| [PlaneTrackerEvents](examples/planetracker-events.html) ([source](https://github.com/CamStreamer/CamStreamerLib/blob/master/examples/planetracker-events.html)) | Logs every PlaneTracker event. PlaneTracker needs no authorization token — [PlaneTrackerEvents](doc/ws/PlaneTrackerEvents.md) announces the connecting user (`userId` / `userName` / `userPriority`, editable in the form) as the init message instead, so only the websocket client is needed. The continuous `CAMERA_POSITION` and `FLIGHT_LIST` events only update the summary line unless the checkbox is ticked. | [open](https://camstreamer.github.io/CamStreamerLib/examples/planetracker-events.html) |
+
+</br>
+
 # Breaking Changes
 
 <details open>

package/cjs/PlaneTrackerAPI.d.ts

@@ -45,8 +45,23 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
             focusCalibrationPoints: string;
         };
         cameraConfig: {
-            defaultCaptureSizeMeters: number;
-            captureSizeExtensionMeters: number;
+            aircraft: {
+                defaultCaptureSizeMeters: number;
+                captureSizeExtensionMeters: number;
+            };
+            drone: {
+                defaultCaptureSizeMeters: number;
+                captureSizeExtensionMeters: number;
+            };
+        } | {
+            aircraft: {
+                defaultCaptureSizeMeters: number;
+                captureSizeExtensionMeters: number;
+            };
+            drone: {
+                defaultCaptureSizeMeters: number;
+                captureSizeExtensionMeters: number;
+            };
         };
         stream: {
             width: number;
@@ -99,11 +114,29 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
             priority: number;
         };
         identificationLabel: {
-            firstRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
-            secondRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
-            thirdRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
-            fourthRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
-            opacity: number;
+            aircraft: {
+                firstRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+                secondRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+                thirdRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+                fourthRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+                opacity: number;
+            };
+            drone: {
+                firstRow: "blank" | "remote_id";
+                opacity: number;
+            };
+        } | {
+            aircraft: {
+                firstRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+                secondRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+                thirdRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+                fourthRow: "blank" | "registration" | "call_sign" | "flight_number" | "icao";
+                opacity: number;
+            };
+            drone: {
+                firstRow: "blank" | "remote_id";
+                opacity: number;
+            };
         };
         acs: {
             ip: string;
@@ -181,11 +214,11 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     importAppSettings(dataType: TImportDataType, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
     getDomainList(options?: THttpRequestOptions): Promise<Partial<Record<"adsb" | "remoteId", {
         uiName: string;
-        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator" | "vehicle";
+        icon: "unknown" | "small" | "drone" | "large" | "heavy" | "helicopter" | "operator" | "vehicle";
         categoryList: {
             categoryId: string;
             uiName: string;
-            icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator" | "vehicle";
+            icon: "unknown" | "small" | "drone" | "large" | "heavy" | "helicopter" | "operator" | "vehicle";
         }[];
     }>>>;
     fetchFlightInfo(targetId: string, options?: THttpRequestOptions): Promise<{

package/cjs/PlaneTrackerAPI.js

@@ -5,12 +5,13 @@ const zod_1 = require("zod");
 const PlaneTrackerAPI_1 = require("./types/PlaneTrackerAPI");
 const errors_1 = require("./errors/errors");
 const BasicAPI_1 = require("./internal/BasicAPI");
+const PlaneTrackerEvents_1 = require("./types/ws/PlaneTrackerEvents");
 const BASE_PATH = '/local/planetracker';
 class PlaneTrackerAPI extends BasicAPI_1.BasicAPI {
     apiUser;
     constructor(client, apiUser) {
         super(client);
-        this.apiUser = apiUser;
+        this.apiUser = PlaneTrackerEvents_1.apiUserInputSchema.parse(apiUser);
     }
     static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
     static getWsEventsPath = () => `${BASE_PATH}/package/ws`;

package/cjs/VapixAPI.js

@@ -93,7 +93,7 @@ class VapixAPI extends BasicAPI_1.BasicAPI {
             };
             await this._postJsonEncoded('/axis-cgi/opticscontrol.cgi', data, undefined, options);
         }
-        catch (err) {
+        catch {
             await this._postUrlEncoded('/axis-cgi/opticssetup.cgi', {
                 autofocus: 'perform',
                 source: '1',

package/cjs/browser.index.d.ts

@@ -0,0 +1,2 @@
+export * from './index';
+export * from './web/index';

package/cjs/browser.index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index"), exports);
+__exportStar(require("./web/index"), exports);

package/cjs/helpers.js

@@ -13,7 +13,7 @@ const jsonParseCameraParam = (param, paramName) => {
         try {
             return JSON.parse(decodeURIComponent(param.replaceAll('\\', '')));
         }
-        catch (e) {
+        catch {
             throw new errors_1.JsonParseError(paramName, param);
         }
     }

package/cjs/node/HttpRequestSender.js

@@ -32,12 +32,15 @@ class HttpRequestSender {
             options.headers ??= {};
             options.headers['Authorization'] = authorization;
         }
-        const req = new undici_1.Request(url, { body: postData, method: options.method, headers: options.headers });
-        const res = await (0, undici_1.fetch)(req, { signal: AbortSignal.timeout(options.timeout), dispatcher: this.agent });
-        if (!res.ok) {
-            this.invalidateAuthorization();
-        }
+        const res = await (0, undici_1.fetch)(url, {
+            method: options.method,
+            headers: options.headers,
+            body: postData,
+            signal: AbortSignal.timeout(options.timeout),
+            dispatcher: this.agent,
+        });
         if (res.status === 401) {
+            this.invalidateAuthorization();
             const authenticateHeader = res.headers.get('www-authenticate');
             if (authenticateHeader !== null &&
                 authenticateHeader.indexOf('Digest') !== -1 &&

package/cjs/node/HttpRequestSender.test.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/node/HttpRequestSender.test.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+const undici_1 = require("undici");
+const globals_1 = require("@jest/globals");
+const HttpRequestSender_1 = require("./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');
+};
+(0, globals_1.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,
+    });
+    (0, globals_1.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);
+        });
+    });
+    (0, globals_1.afterEach)(async () => {
+        server.closeAllConnections();
+        await new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+    });
+    (0, globals_1.test)('sends basic auth when the server accepts it', async () => {
+        const res = await new HttpRequestSender_1.HttpRequestSender().sendRequest(options());
+        (0, globals_1.expect)(res.status).toBe(200);
+        (0, globals_1.expect)(await res.text()).toBe('ok');
+        (0, globals_1.expect)(received).toHaveLength(1);
+        (0, globals_1.expect)(received[0]?.authorization).toBe(`Basic ${Buffer.from('root:pass').toString('base64')}`);
+    });
+    (0, globals_1.test)('sends no authorization without credentials', async () => {
+        await new HttpRequestSender_1.HttpRequestSender().sendRequest(options({ user: undefined, pass: undefined }));
+        (0, globals_1.expect)(received[0]?.authorization).toBeUndefined();
+    });
+    (0, globals_1.test)('retries with digest auth on a digest 401 and reuses it for later requests', async () => {
+        handler = digestHandler;
+        const sender = new HttpRequestSender_1.HttpRequestSender();
+        const first = await sender.sendRequest(options());
+        const second = await sender.sendRequest(options());
+        (0, globals_1.expect)(first.status).toBe(200);
+        (0, globals_1.expect)(second.status).toBe(200);
+        (0, globals_1.expect)(received.map((r) => r.authorization?.split(' ')[0])).toEqual(['Basic', 'Digest', 'Digest']);
+    });
+    (0, globals_1.test)('keeps digest auth after a non-401 error response', async () => {
+        const sender = new HttpRequestSender_1.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());
+        (0, globals_1.expect)(res.status).toBe(200);
+        (0, globals_1.expect)(received.map((r) => r.authorization?.split(' ')[0])).toEqual(['Basic', 'Digest', 'Digest', 'Digest']);
+    });
+    (0, globals_1.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_1.HttpRequestSender().sendRequest(options());
+        (0, globals_1.expect)(res.status).toBe(401);
+        (0, globals_1.expect)(received).toHaveLength(2);
+    });
+    (0, globals_1.test)('rejects when the response does not arrive within the timeout', async () => {
+        handler = () => undefined;
+        await (0, globals_1.expect)(new HttpRequestSender_1.HttpRequestSender().sendRequest(options({ timeout: 200 }))).rejects.toThrow();
+    });
+    (0, globals_1.test)('sends a url-encoded POST body', async () => {
+        const res = await new HttpRequestSender_1.HttpRequestSender().sendRequest(options({ method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }), 'action=settext&text=hello');
+        (0, globals_1.expect)(res.ok).toBe(true);
+        (0, globals_1.expect)(received[0]).toMatchObject({
+            method: 'POST',
+            contentType: 'application/x-www-form-urlencoded',
+            body: 'action=settext&text=hello',
+        });
+    });
+    (0, globals_1.test)('sends a JSON POST body', async () => {
+        const payload = JSON.stringify({ text: 'hello', index: 1 });
+        await new HttpRequestSender_1.HttpRequestSender().sendRequest(options({ method: 'POST', headers: { 'Content-Type': 'application/json' } }), payload);
+        (0, globals_1.expect)(received[0]).toMatchObject({ method: 'POST', contentType: 'application/json', body: payload });
+    });
+    (0, globals_1.test)('sends a Buffer POST body', async () => {
+        await new HttpRequestSender_1.HttpRequestSender().sendRequest(options({ method: 'POST' }), Buffer.from('binary-data'));
+        (0, globals_1.expect)(received[0]?.body).toBe('binary-data');
+    });
+    (0, globals_1.test)('sends a FormData POST body as multipart', async () => {
+        const formData = new undici_1.FormData();
+        formData.append('field', 'value');
+        await new HttpRequestSender_1.HttpRequestSender().sendRequest(options({ method: 'POST' }), formData);
+        (0, globals_1.expect)(received[0]?.contentType).toMatch(/^multipart\/form-data; boundary=/);
+        (0, globals_1.expect)(received[0]?.body).toContain('value');
+    });
+    (0, globals_1.test)('resends the POST body on the digest retry', async () => {
+        handler = digestHandler;
+        await new HttpRequestSender_1.HttpRequestSender().sendRequest(options({ method: 'POST' }), 'payload');
+        (0, globals_1.expect)(received.map((r) => r.body)).toEqual(['payload', 'payload']);
+    });
+});