camstreamerlib 4.0.6 → 4.0.8

package/esm/types/ws/PlaneTrackerEvents.js

@@ -1,7 +1,11 @@
 import { z } from 'zod';
-import { blackListSchema, priorityListSchema, trackingModeSchema, whiteListSchema, zonesSchema, } from '../PlaneTrackerAPI';
-const apiFlightDataSchema = z.object({
+import { blackListSchema, priorityListSchema, trackingModeSchema, whiteListSchema, zonesSchema, domainIdSchema, } from '../PlaneTrackerAPI';
+const wsApiFlightDataSchema = z.object({
+    targetId: z.string(),
     icao: z.string(),
+    domain: domainIdSchema,
+    categoryId: z.string(),
+    groupId: z.string().optional(),
     lat: z.number(),
     lon: z.number(),
     heading: z.number(),
@@ -12,7 +16,6 @@ const apiFlightDataSchema = z.object({
     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),
@@ -20,169 +23,134 @@ const apiFlightDataSchema = z.object({
     emergencyState: z.boolean(),
     emergencyStatusMessage: z.string(),
 });
-const apiUserSchema = z.object({
-    userId: z.string(),
-    userName: z.string(),
-    userPriority: z.number(),
-    ip: z.string(),
+const wsCameraPositionDataSchema = z.object({
+    lat: z.number(),
+    lon: z.number(),
+    azimuth: z.number().min(0).max(360),
+    elevation: z.number().min(-90).max(90),
+    fov: z.number(),
 });
-const apiStringUserSchema = z.object({
+const userSchema = 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_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', [
+const apiUserSchema = userSchema.extend({
+    ip: z.string(),
+    userPriority: z.number(),
+});
+export var EUserActions;
+(function (EUserActions) {
+    EUserActions["TRACK_ICAO"] = "trackIcao.cgi";
+    EUserActions["RESET_ICAO"] = "resetIcao.cgi";
+    EUserActions["SET_PRIORITY_LIST"] = "setPriorityList.cgi";
+    EUserActions["SET_BLACK_LIST"] = "setBlackList.cgi";
+    EUserActions["SET_WHITE_LIST"] = "setWhiteList.cgi";
+    EUserActions["GO_TO_COORDINATES"] = "goToCoordinates.cgi";
+    EUserActions["SET_TRACKING_MODE"] = "setTrackingMode.cgi";
+    EUserActions["SET_ZONES"] = "setZones.cgi";
+    EUserActions["RESET_PTZ_CALIBRATION"] = "resetPtzCalibration.cgi";
+    EUserActions["LOCK_API"] = "lockApi.cgi";
+    EUserActions["UNLOCK_API"] = "unlockApi.cgi";
+})(EUserActions || (EUserActions = {}));
+const eventsDataSchema = z.union([
+    z.object({ type: z.literal('CAMERA_POSITION') }).merge(wsCameraPositionDataSchema),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.TRACK_ICAO),
+        type: z.literal('TRACKING_START'),
+        icao: z.string(),
+        targetId: z.string(),
+        domain: domainIdSchema,
+        categoryId: z.string(),
+    }),
+    z.object({ type: z.literal('TRACKING_STOP') }),
+    z.object({ type: z.literal('FLIGHT_LIST'), list: z.array(wsApiFlightDataSchema) }),
+    z.object({
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.TRACK_ICAO),
         ip: z.string(),
-        params: apiStringUserSchema.extend({
-            icao: z.string(),
-        }),
+        params: userSchema.extend({ icao: z.string() }),
+        postJsonBody: z.any(),
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.RESET_ICAO),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.RESET_ICAO),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
+        postJsonBody: z.any(),
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.SET_PRIORITY_LIST),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.SET_PRIORITY_LIST),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: priorityListSchema,
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.SET_BLACK_LIST),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.SET_BLACK_LIST),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: blackListSchema,
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.SET_WHITE_LIST),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.SET_WHITE_LIST),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: whiteListSchema,
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.GO_TO_COORDINATES),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.GO_TO_COORDINATES),
         ip: z.string(),
-        params: apiStringUserSchema.extend({
-            lat: z.string(),
-            lon: z.string(),
-        }),
+        params: userSchema.extend({ lat: z.string(), lon: z.string() }),
+        postJsonBody: z.any(),
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.SET_TRACKING_MODE),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.SET_TRACKING_MODE),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: trackingModeSchema,
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.SET_ZONES),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.SET_ZONES),
         ip: z.string(),
-        params: apiStringUserSchema,
+        params: userSchema,
         postJsonBody: zonesSchema,
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.RESET_PTZ_CALIBRATION),
-        ip: z.string(),
-        params: apiStringUserSchema,
-    }),
-    z.object({
-        cgi: z.literal(PlaneTrackerUserActions.LOCK_API),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.RESET_PTZ_CALIBRATION),
         ip: z.string(),
-        params: apiStringUserSchema.extend({
-            timeout: z.string(),
-        }),
+        params: userSchema,
+        postJsonBody: z.any(),
     }),
     z.object({
-        cgi: z.literal(PlaneTrackerUserActions.UNLOCK_API),
+        type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.LOCK_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),
+        params: userSchema.extend({ timeout: z.string() }),
+        postJsonBody: z.any(),
     }),
     z.object({
         type: z.literal('USER_ACTION'),
+        cgi: z.literal(EUserActions.UNLOCK_API),
         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_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,
-        ]),
+        params: userSchema,
         postJsonBody: z.any(),
     }),
-    z.object({
-        type: z.literal('CONNECTED_USERS'),
-        users: z.array(apiUserSchema),
-    }),
+    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(),
+        targetId: z.string().optional(),
     }),
-    z.object({
-        type: z.literal('API_LOCK_STATUS'),
-        isLocked: z.boolean(),
-        user: apiUserSchema.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,
+export const ptrEventsSchema = z.union([
+    z.object({ type: z.literal('init'), data: eventsDataSchema }),
+    ...eventsDataSchema.options,
 ]);

package/esm/ws/PlaneTrackerEvents.js

@@ -1,17 +1,9 @@
 import { WsEvents } from '../internal/WsEvents';
-import { PlaneTrackerWsEvents, planeTrackerUserActionData, ptrEventsSchema, } from '../types/ws/PlaneTrackerEvents';
+import { 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);
+        super((data) => ptrEventsSchema.parse(data), ws);
         this._apiUser = _apiUser;
         this.ws.onOpen = this.sendInitMsg;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.6",
+    "version": "4.0.8",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/PlaneTrackerAPI.d.ts

@@ -1,10 +1,11 @@
 import { IClient, TResponse } from './internal/types';
-import { ICAO, TApiUser, TBlackList, TCameraSettings, TExportDataType, TGetIcaoByOption, TImportDataType, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
+import { ICAO, TBlackList, TCameraSettings, TExportDataType, TGetIcaoByOption, TImportDataType, TPriorityList, TTrackingMode, TWhiteList, TZones } from './types/PlaneTrackerAPI';
 import { THttpRequestOptions } from './types/common';
 import { BasicAPI } from './internal/BasicAPI';
+import { TApiUser } from './types/ws/PlaneTrackerEvents';
 export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> extends BasicAPI<Client> {
     private apiUser;
-    constructor(client: Client, apiUser: TApiUser);
+    constructor(client: Client, apiUser: Omit<TApiUser, 'ip'>);
     static getProxyPath: () => string;
     static getWsEventsPath: () => string;
     checkAPIAvailable(options?: THttpRequestOptions): Promise<void>;
@@ -157,7 +158,16 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     }>;
     exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<ReturnType<Awaited<ReturnType<Client["get"]>>["blob"]>>;
     importAppSettings(dataType: TImportDataType, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<void>;
-    fetchFlightInfo(icao: ICAO, options?: THttpRequestOptions): Promise<{
+    getDomainList(options?: THttpRequestOptions): Promise<Partial<Record<"adsb" | "remoteId", {
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+        categoryList: {
+            categoryId: string;
+            uiName: string;
+            icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+        }[];
+    }>>>;
+    fetchFlightInfo(targetId: string, options?: THttpRequestOptions): Promise<{
         destinationAirport: {
             icao?: string | undefined;
             iata?: string | undefined;
@@ -184,6 +194,8 @@ export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> ext
     setTrackingMode(mode: TTrackingMode['mode'], options?: THttpRequestOptions): Promise<void>;
     startTrackingPlane(icao: ICAO, options?: THttpRequestOptions): Promise<void>;
     stopTrackingPlane(options?: THttpRequestOptions): Promise<void>;
+    startTrackingTarget(targetId: string, options?: THttpRequestOptions): Promise<void>;
+    stopTrackingTarget(options?: THttpRequestOptions): Promise<void>;
     getIcao(by: TGetIcaoByOption, value: string, options?: THttpRequestOptions): Promise<string>;
     getPriorityList(options?: THttpRequestOptions): Promise<{
         list: {

package/types/types/PlaneTrackerAPI.d.ts

@@ -1,11 +1,6 @@
 import { z } from 'zod';
 export type TImportDataType = 'MAP_DATA' | 'SERVER_DATA' | 'ALL';
 export type TExportDataType = 'NIGHT_SKY_CALIBRATION_DATA' | 'ALL';
-export type TApiUser = {
-    userId: string;
-    userName: string;
-    userPriority: number;
-};
 export declare const wsAliasResponseSchema: z.ZodObject<{
     alias: z.ZodString;
     ws: z.ZodString;
@@ -706,10 +701,13 @@ export type TServerSettings = z.infer<typeof serverSettingsSchema>;
 export type ICAO = string;
 export declare const getIcaoSchema: z.ZodObject<{
     icao: z.ZodString;
+    targetId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     icao: string;
+    targetId: string;
 }, {
     icao: string;
+    targetId: string;
 }>;
 export type TGetIcaoByOption = 'registration' | 'callsign';
 export declare const trackingModeSchema: z.ZodObject<{
@@ -1040,4 +1038,115 @@ export declare const zonesSchema: z.ZodObject<{
     }[] | undefined;
 }>;
 export type TZones = z.infer<typeof zonesSchema>;
+export declare const domainIdSchema: z.ZodEnum<["adsb", "remoteId"]>;
+export type TDomainId = z.infer<typeof domainIdSchema>;
+declare const categoryIconSchema: z.ZodEnum<["small", "large", "heavy", "helicopter", "drone", "operator", "unknown"]>;
+export type TCategoryIcon = z.infer<typeof categoryIconSchema>;
+declare const categoryDescriptorSchema: z.ZodObject<{
+    categoryId: z.ZodString;
+    uiName: z.ZodString;
+    icon: z.ZodEnum<["small", "large", "heavy", "helicopter", "drone", "operator", "unknown"]>;
+}, "strip", z.ZodTypeAny, {
+    categoryId: string;
+    uiName: string;
+    icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+}, {
+    categoryId: string;
+    uiName: string;
+    icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+}>;
+export type TCategoryDescriptor = z.infer<typeof categoryDescriptorSchema>;
+declare const domainDescriptorSchema: z.ZodObject<{
+    uiName: z.ZodString;
+    icon: z.ZodEnum<["small", "large", "heavy", "helicopter", "drone", "operator", "unknown"]>;
+    categoryList: z.ZodArray<z.ZodObject<{
+        categoryId: z.ZodString;
+        uiName: z.ZodString;
+        icon: z.ZodEnum<["small", "large", "heavy", "helicopter", "drone", "operator", "unknown"]>;
+    }, "strip", z.ZodTypeAny, {
+        categoryId: string;
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    }, {
+        categoryId: string;
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    uiName: string;
+    icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    categoryList: {
+        categoryId: string;
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    }[];
+}, {
+    uiName: string;
+    icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    categoryList: {
+        categoryId: string;
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    }[];
+}>;
+export type TDomainDescriptor = z.infer<typeof domainDescriptorSchema>;
+export declare const domainListSchema: z.ZodRecord<z.ZodEnum<["adsb", "remoteId"]>, z.ZodObject<{
+    uiName: z.ZodString;
+    icon: z.ZodEnum<["small", "large", "heavy", "helicopter", "drone", "operator", "unknown"]>;
+    categoryList: z.ZodArray<z.ZodObject<{
+        categoryId: z.ZodString;
+        uiName: z.ZodString;
+        icon: z.ZodEnum<["small", "large", "heavy", "helicopter", "drone", "operator", "unknown"]>;
+    }, "strip", z.ZodTypeAny, {
+        categoryId: string;
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    }, {
+        categoryId: string;
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    uiName: string;
+    icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    categoryList: {
+        categoryId: string;
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    }[];
+}, {
+    uiName: string;
+    icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    categoryList: {
+        categoryId: string;
+        uiName: string;
+        icon: "unknown" | "small" | "large" | "heavy" | "helicopter" | "drone" | "operator";
+    }[];
+}>>;
+export type TDomainList = z.infer<typeof domainListSchema>;
+export declare const ADSB_CATEGORY_IDS: {
+    readonly A_LIGHT: "A_LIGHT";
+    readonly A_SMALL: "A_SMALL";
+    readonly A_LARGE: "A_LARGE";
+    readonly A_HIGH_VORTEX: "A_HIGH_VORTEX";
+    readonly A_HEAVY: "A_HEAVY";
+    readonly A_HIGH_PERF: "A_HIGH_PERF";
+    readonly A_ROTORCRAFT: "A_ROTORCRAFT";
+    readonly B_GLIDER: "B_GLIDER";
+    readonly B_LIGHTER_THAN_AIR: "B_LIGHTER_THAN_AIR";
+    readonly B_PARACHUTIST: "B_PARACHUTIST";
+    readonly B_ULTRALIGHT: "B_ULTRALIGHT";
+    readonly B_UAV: "B_UAV";
+    readonly B_SPACE: "B_SPACE";
+    readonly C_SURFACE_EMERGENCY: "C_SURFACE_EMERGENCY";
+    readonly C_SERVICE_VEHICLE: "C_SERVICE_VEHICLE";
+    readonly C_POINT_OBSTACLE: "C_POINT_OBSTACLE";
+    readonly C_CLUSTER_OBSTACLE: "C_CLUSTER_OBSTACLE";
+    readonly C_LINE_OBSTACLE: "C_LINE_OBSTACLE";
+    readonly UNKNOWN: "UNKNOWN";
+};
+export declare const REMOTE_ID_CATEGORY_IDS: {
+    readonly DRONE: "DRONE";
+    readonly OPERATOR: "OPERATOR";
+};
 export {};