camstreamerlib 4.0.0-beta.13 → 4.0.0-beta.130

package/esm/types/ws/PlaneTrackerEvents.js

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+import { trackingModeSchema, zonesSchema } from '../PlaneTrackerAPI';
+const apiFlightDataSchema = z.object({
+    icao: z.string(),
+    lat: z.number(),
+    lon: z.number(),
+    heading: z.number(),
+    groundSpeed: z.number(),
+    altitudeAMSL: z.number(),
+    cameraDistance: z.number(),
+    autoTrackingOrder: z.number(),
+    whiteListed: z.boolean(),
+    blackListed: z.boolean(),
+    priorityListed: z.boolean(),
+    typePriorityListed: z.boolean().default(false),
+    autoSelectionIgnored: z.boolean(),
+    signalQuality: z.number(),
+    emitterCategorySet: z.number().default(4),
+    emitterCategory: z.number().default(3),
+    emergencyState: z.boolean(),
+    emergencyStatusMessage: z.string(),
+});
+const apiUserSchema = z.object({
+    userId: z.string(),
+    userName: z.string(),
+    userPriority: z.number(),
+    ip: z.string(),
+});
+const apiStringUserSchema = z.object({
+    userId: z.string(),
+    userName: z.string(),
+    userPriority: z.string(),
+});
+export var PlaneTrackerWsEvents;
+(function (PlaneTrackerWsEvents) {
+    PlaneTrackerWsEvents["FLIGHT_LIST"] = "FLIGHT_LIST";
+    PlaneTrackerWsEvents["CAMERA_POSITION"] = "CAMERA_POSITION";
+    PlaneTrackerWsEvents["TRACKING_START"] = "TRACKING_START";
+    PlaneTrackerWsEvents["TRACKING_STOP"] = "TRACKING_STOP";
+    PlaneTrackerWsEvents["USER_ACTION"] = "USER_ACTION";
+    PlaneTrackerWsEvents["CONNECTED_USERS"] = "CONNECTED_USERS";
+    PlaneTrackerWsEvents["FORCE_TRACKING_STATUS"] = "FORCE_TRACKING_STATUS";
+})(PlaneTrackerWsEvents || (PlaneTrackerWsEvents = {}));
+export var PlaneTrackerUserActions;
+(function (PlaneTrackerUserActions) {
+    PlaneTrackerUserActions["TRACK_ICAO"] = "trackIcao.cgi";
+    PlaneTrackerUserActions["RESET_ICAO"] = "resetIcao.cgi";
+    PlaneTrackerUserActions["SET_PRIORITY_LIST"] = "setPriorityList.cgi";
+    PlaneTrackerUserActions["SET_TYPE_PRIORITY_LIST"] = "setTypePriorityList.cgi";
+    PlaneTrackerUserActions["SET_BLACK_LIST"] = "setBlackList.cgi";
+    PlaneTrackerUserActions["SET_WHITE_LIST"] = "setWhiteList.cgi";
+    PlaneTrackerUserActions["GO_TO_COORDINATES"] = "goToCoordinates.cgi";
+    PlaneTrackerUserActions["SET_TRACKING_MODE"] = "setTrackingMode.cgi";
+    PlaneTrackerUserActions["SET_ZONES"] = "setZones.cgi";
+    PlaneTrackerUserActions["RESET_PTZ_CALIBRATION"] = "resetPtzCalibration.cgi";
+    PlaneTrackerUserActions["LOCK_API"] = "lockApi.cgi";
+    PlaneTrackerUserActions["UNLOCK_API"] = "unlockApi.cgi";
+})(PlaneTrackerUserActions || (PlaneTrackerUserActions = {}));
+export const planeTrackerUserActionData = z.discriminatedUnion('cgi', [
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.TRACK_ICAO),
+        ip: z.string(),
+        params: apiStringUserSchema.extend({
+            icao: z.string(),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.RESET_ICAO),
+        ip: z.string(),
+        params: apiStringUserSchema,
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_PRIORITY_LIST),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: z.object({
+            priorityList: z.array(z.string()),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_TYPE_PRIORITY_LIST),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: z.object({
+            typePriorityList: z.array(z.string()),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_BLACK_LIST),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: z.object({
+            blackList: z.array(z.string()),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_WHITE_LIST),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: z.object({
+            whiteList: z.array(z.string()),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.GO_TO_COORDINATES),
+        ip: z.string(),
+        params: apiStringUserSchema.extend({
+            lat: z.string(),
+            lon: z.string(),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_TRACKING_MODE),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: trackingModeSchema,
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.SET_ZONES),
+        ip: z.string(),
+        params: apiStringUserSchema,
+        postJsonBody: zonesSchema,
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.RESET_PTZ_CALIBRATION),
+        ip: z.string(),
+        params: apiStringUserSchema,
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.LOCK_API),
+        ip: z.string(),
+        params: apiStringUserSchema.extend({
+            timeout: z.string(),
+        }),
+    }),
+    z.object({
+        cgi: z.literal(PlaneTrackerUserActions.UNLOCK_API),
+        ip: z.string(),
+        params: apiStringUserSchema,
+    }),
+]);
+const ptrEventsDataSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('CAMERA_POSITION'),
+        lat: z.number(),
+        lon: z.number(),
+        azimuth: z.number().min(0).max(360),
+        elevation: z.number().min(-90).max(90),
+        fov: z.number(),
+    }),
+    z.object({
+        type: z.literal('TRACKING_START'),
+        icao: z.string(),
+    }),
+    z.object({
+        type: z.literal('TRACKING_STOP'),
+    }),
+    z.object({
+        type: z.literal('FLIGHT_LIST'),
+        list: z.array(apiFlightDataSchema),
+    }),
+    z.object({
+        type: z.literal('USER_ACTION'),
+        ip: z.string(),
+        params: apiStringUserSchema.extend({
+            lat: z.string().optional(),
+            lon: z.string().optional(),
+            timeout: z.string().optional(),
+        }),
+        cgi: z.enum([
+            PlaneTrackerUserActions.TRACK_ICAO,
+            PlaneTrackerUserActions.RESET_ICAO,
+            PlaneTrackerUserActions.SET_PRIORITY_LIST,
+            PlaneTrackerUserActions.SET_TYPE_PRIORITY_LIST,
+            PlaneTrackerUserActions.SET_BLACK_LIST,
+            PlaneTrackerUserActions.SET_WHITE_LIST,
+            PlaneTrackerUserActions.GO_TO_COORDINATES,
+            PlaneTrackerUserActions.SET_TRACKING_MODE,
+            PlaneTrackerUserActions.SET_ZONES,
+            PlaneTrackerUserActions.RESET_PTZ_CALIBRATION,
+            PlaneTrackerUserActions.LOCK_API,
+            PlaneTrackerUserActions.UNLOCK_API,
+        ]),
+        postJsonBody: z.any(),
+    }),
+    z.object({
+        type: z.literal('CONNECTED_USERS'),
+        users: z.array(apiUserSchema),
+    }),
+    z.object({
+        type: z.literal('FORCE_TRACKING_STATUS'),
+        enabled: z.boolean(),
+        icao: z.string().optional(),
+    }),
+    z.object({
+        type: z.literal('API_LOCK_STATUS'),
+        isLocked: z.boolean(),
+        user: apiUserSchema.optional(),
+    }),
+]);
+export const ptrEventsSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('init'), data: ptrEventsDataSchema }),
+    ...ptrEventsDataSchema.options,
+]);

package/esm/web/DefaultClient.js

@@ -1,18 +1,32 @@
 import { addParametersToPath } from '../internal/utils';
 export class DefaultClient {
-    get = (...params) => {
-        const [url, parameters, headers] = params;
-        return fetch(addParametersToPath(url, parameters), {
+    domain;
+    constructor(domain = '') {
+        this.domain = domain;
+    }
+    get = (params) => {
+        return this.fetchWithTimeout(addParametersToPath(params.path, params.parameters), {
             method: 'GET',
-            headers: headers,
-        });
+            headers: params.headers,
+        }, params.timeout);
     };
-    post = (...params) => {
-        const [url, data, parameters, headers] = params;
-        return fetch(addParametersToPath(url, parameters), {
+    post = (params) => {
+        return this.fetchWithTimeout(addParametersToPath(params.path, params.parameters), {
             method: 'POST',
-            body: data,
-            headers: headers,
-        });
+            body: params.data,
+            headers: params.headers,
+        }, params.timeout);
     };
+    async fetchWithTimeout(path, options, timeout) {
+        const controller = new AbortController();
+        const timeoutId = timeout !== undefined ? setTimeout(() => controller.abort(), timeout) : null;
+        try {
+            return await fetch(`${this.domain}${path}`, { ...options, signal: controller.signal });
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
 }

package/esm/web/WsClient.js

@@ -1,13 +1,11 @@
-const REFRESH_TIMEOUT = 5_000;
+const REFRESH_TIMEOUT = 5000;
 export class WsClient {
     getUrl;
-    getAuthToken;
     isDestroyed = false;
     ws = null;
     restartTimeout = null;
-    constructor(getUrl, getAuthToken) {
+    constructor(getUrl) {
         this.getUrl = getUrl;
-        this.getAuthToken = getAuthToken;
     }
     init() {
         if (this.isDestroyed) {
@@ -15,32 +13,32 @@ export class WsClient {
         }
         this.destroyWebsocket();
         const ws = new WebSocket(this.getUrl(), 'events');
-        ws.onopen = async () => {
-            try {
-                const token = await this.getAuthToken();
-                ws.send(JSON.stringify({ authorization: token }));
-            }
-            catch (error) {
-                console.error('Error sending auth token:', error);
-                ws.close();
-            }
-        };
-        ws.onmessage = (e) => this.onmessage(e);
+        ws.binaryType = 'arraybuffer';
+        ws.onopen = () => this.onOpen();
+        ws.onmessage = (e) => this.onMessage(e.data);
         ws.onclose = () => {
-            this.restartTimeout = setTimeout(() => this.init(), REFRESH_TIMEOUT);
+            this.restartTimeout = window.setTimeout(() => this.init(), REFRESH_TIMEOUT);
         };
         this.ws = ws;
     }
     send = (msg) => {
         this.ws?.send(msg);
     };
-    onmessage = (_) => { };
+    onMessage = (_) => { };
+    onOpen = () => { };
+    onClose = () => { };
+    onError = (error) => {
+        console.error(error);
+    };
+    reconnect = () => {
+        this.ws?.close();
+    };
     destroy = () => {
         this.isDestroyed = true;
         this.destroyWebsocket();
     };
     destroyWebsocket() {
-        if (this.restartTimeout) {
+        if (this.restartTimeout !== null) {
             clearTimeout(this.restartTimeout);
             this.restartTimeout = null;
         }

package/esm/ws/CamOverlayEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { coEventsSchema } from '../types/ws/CamOverlayEvents';
+export class CamOverlayEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super((data) => coEventsSchema.parse(data), ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/CamStreamerEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { csEventsSchema } from '../types/ws/CamStreamerEvents';
+export class CamStreamerEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super((data) => csEventsSchema.parse(data), ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/CamSwitcherEvents.js

@@ -0,0 +1,20 @@
+import { WsEvents } from '../internal/WsEvents';
+import { cswEventsSchema } from '../types/ws/CamSwitcherEvents';
+export class CamSwitcherEvents extends WsEvents {
+    getAuthToken;
+    constructor(ws, getAuthToken) {
+        super((data) => cswEventsSchema.parse(data), ws);
+        this.getAuthToken = getAuthToken;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = async () => {
+        try {
+            const token = await this.getAuthToken();
+            this.ws.send(JSON.stringify({ authorization: token }));
+        }
+        catch (error) {
+            console.error('Error on open:', error);
+            this.ws.reconnect();
+        }
+    };
+}

package/esm/ws/PlaneTrackerEvents.js

@@ -0,0 +1,26 @@
+import { WsEvents } from '../internal/WsEvents';
+import { PlaneTrackerWsEvents, planeTrackerUserActionData, ptrEventsSchema, } from '../types/ws/PlaneTrackerEvents';
+export class PlaneTrackerEvents extends WsEvents {
+    _apiUser;
+    constructor(ws, _apiUser) {
+        super((data) => {
+            const parsedData = ptrEventsSchema.parse(data);
+            if (parsedData.type === PlaneTrackerWsEvents.USER_ACTION) {
+                const { type, ...actionData } = parsedData;
+                const userAction = planeTrackerUserActionData.parse(actionData);
+                return { ...userAction, type };
+            }
+            return parsedData;
+        }, ws);
+        this._apiUser = _apiUser;
+        this.ws.onOpen = this.sendInitMsg;
+    }
+    sendInitMsg = () => {
+        this.ws.send(JSON.stringify({
+            type: 'USER_INFO',
+            userId: this._apiUser.userId,
+            userName: this._apiUser.userName,
+            userPriority: this._apiUser.userPriority,
+        }));
+    };
+}

package/package.json

@@ -1,21 +1,20 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.13",
+    "version": "4.0.0-beta.130",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
+    "engine": {
+        "node": ">=18.0.0"
+    },
     "dependencies": {
         "adm-zip": "^0.5.9",
         "eventemitter2": "^5.0.1",
         "fast-xml-parser": "^5.2.5",
         "lodash": "^4.17.21",
-        "prettify-xml": "^1.2.0",
         "type-fest": "^4.41.0",
         "undici": "^6.21.3",
         "ws": "^8.18.0",
-        "zod": "^3.24.3"
-    },
-    "engine": {
-        "node": ">=18.0.0"
+        "zod": "^3.25.76"
     },
     "devDependencies": {
         "@camstreamer/eslint-config": "^1.0.2",
@@ -23,7 +22,7 @@
         "@types/adm-zip": "^0.5.5",
         "@types/jest": "^28.0.0",
         "@types/lodash": "^4.17.18",
-        "@types/node": "^18.19.39",
+        "@types/node": "^18.19.127",
         "@types/ws": "^8.5.10",
         "@typescript-eslint/eslint-plugin": "^6.8.0",
         "@typescript-eslint/parser": "^6.8.0",
@@ -43,17 +42,52 @@
         "build:cjs": "tsc --project tsconfig.cjs.json",
         "build:esm": "tsc --project tsconfig.esm.json",
         "copyPackage": "cp -f LICENSE dist/ && cp -f README.md dist/ && cp -f package.json dist/",
-        "prepublish": "npm run build",
         "lint": "eslint \"src/**/*.ts\"",
         "lint:fix": "eslint \"src/**/*.ts\" --fix",
         "pretty": "prettier --write \"./{{src,doc}/**/*.{ts,tsx,md},README.md}\"",
         "pretty:check": "prettier --check \"./{{src,doc}/**/*.{ts,tsx,md},README.md}\"",
-        "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+        "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+        "audit": "npm audit --audit-level=high"
     },
     "files": [
         "/**/*.js",
         "/**/*.ts"
     ],
+    "main": "./cjs/index.js",
+    "module": "./esm/index.js",
+    "types": "types/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./esm/index.js",
+            "require": "./cjs/index.js",
+            "types": "./types/index.d.ts"
+        },
+        "./web": {
+            "import": "./esm/web/index.js",
+            "require": "./cjs/web/index.js",
+            "types": "./types/web/index.d.ts"
+        },
+        "./node": {
+            "import": "./esm/node/index.js",
+            "require": "./cjs/node/index.js",
+            "types": "./types/node/index.d.ts"
+        },
+        "./cjs/index": {
+            "import": "./esm/index.js",
+            "require": "./cjs/index.js",
+            "types": "./types/index.d.ts"
+        },
+        "./cjs/node": {
+            "import": "./esm/node/index.js",
+            "require": "./cjs/node/index.js",
+            "types": "./types/node/index.js"
+        },
+        "./cjs/node/index": {
+            "import": "./esm/node/index.js",
+            "require": "./cjs/node/index.js",
+            "types": "./types/node/index.js"
+        }
+    },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/CamStreamer/CamStreamerLib.git"