camstreamerlib 4.0.0-beta.4 → 4.0.0-beta.41

package/esm/types/CamOverlayPainter.js

@@ -0,0 +1,11 @@
+export const COORD = {
+    top_left: [-1, -1],
+    center_left: [-1, 0],
+    bottom_left: [-1, 1],
+    top_center: [0, -1],
+    center: [0, 0],
+    bottom_center: [0, 1],
+    top_right: [1, -1],
+    center_right: [1, 0],
+    bottom_right: [1, 1],
+};

package/esm/types/CamScripterAPI.js

@@ -1,4 +1,7 @@
 import { z } from 'zod';
+export const nodeStateSchema = z.object({
+    node_state: z.union([z.literal('OK'), z.literal('NOT_INSTALLED'), z.literal('NOT_FOUND')]),
+});
 export const packageInfoListSchema = z.array(z.object({
     storage: z.union([z.literal('SD_CARD'), z.literal('INTERNAL')]),
     manifest: z.object({
@@ -6,12 +9,24 @@ export const packageInfoListSchema = z.array(z.object({
         package_menu_name: z.string(),
         package_version: z.string(),
         vendor: z.string(),
-        required_camscripter_version: z.string(),
-        required_camscripter_rbi_version: z.string(),
+        required_camscripter_version: z.string().optional(),
+        required_camscripter_rbi_version: z.string().optional(),
         ui_link: z.string(),
     }),
 }));
-export const storageSchema = z.array(z.object({
-    type: z.union([z.literal('INTERNAL'), z.literal('SD_CARD')]),
-    capacity_mb: z.number(),
-}));
+export const packageConfigSchema = z.record(z.string(), z.object({ enabled: z.boolean() }));
+export const cameraStorageSchema = z.union([
+    z.tuple([
+        z.object({ type: z.literal('INTERNAL'), capacity_mb: z.number() }),
+        z.object({ type: z.literal('SD_CARD'), capacity_mb: z.number() }),
+    ]),
+    z.tuple([z.object({ type: z.literal('INTERNAL'), capacity_mb: z.number() })]),
+]);
+export const camscripterApiResponseSchema = z.object({
+    status: z.number(),
+    message: z.string(),
+});
+export const cameraTimeResponseSchema = z.object({
+    state: z.boolean(),
+    code: z.number(),
+});

package/esm/types/CamScripterAPICameraEventsGenerator.js

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

package/esm/types/CamStreamerAPI.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export const streamAttributesSchema = z.object({
+export const cameraStreamSchema = z.object({
     enabled: z.string(),
     active: z.string(),
     audioSource: z.string(),
@@ -22,4 +22,35 @@ export const streamAttributesSchema = z.object({
     startTime: z.string(),
     stopTime: z.string(),
 });
-export const streamListSchema = z.record(z.string(), streamAttributesSchema);
+export const streamSchema = z.object({
+    enabled: z.union([z.literal(0), z.literal(1)]),
+    active: z.union([z.literal(0), z.literal(1)]),
+    audioSource: z.string(),
+    avSyncMsec: z.number().int(),
+    internalVapixParameters: z.string(),
+    userVapixParameters: z.string(),
+    outputParameters: z.string(),
+    outputType: z.union([z.literal('video'), z.literal('images'), z.literal('none')]),
+    mediaServerUrl: z.string(),
+    inputType: z.union([z.literal('CSw'), z.literal('CRS'), z.literal('RTSP_URL')]),
+    inputUrl: z.string(),
+    forceStereo: z.union([z.literal(0), z.literal(1)]),
+    streamDelay: z.number().nullable(),
+    statusLed: z.number(),
+    statusPort: z.string(),
+    callApi: z.number().int(),
+    trigger: z.string(),
+    schedule: z.string(),
+    prepareAhead: z.number().int(),
+    startTime: z.number().nullable(),
+    stopTime: z.number().nullable(),
+});
+export const cameraStreamResponseSchema = z.object({
+    data: cameraStreamSchema,
+    code: z.number(),
+    message: z.string(),
+});
+export const camstreamerServerResponseSchema = z.object({
+    code: z.number(),
+    message: z.string(),
+});

package/esm/types/CamSwitcherAPI.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { toCamelCase, toCamelCaseDeep } from '../internal/transformers';
-import { storageTypeSchema, keyboardShortcutsSchema, h264ProfileSchema, audioChannelCountSchema, } from './common';
+import { storageTypeSchema, keyboardShortcutsSchema, h264ProfileSchema, audioChannelCountSchema, keyboardShortcutSchema, } from './common';
 const channelTypeSchema = z.union([z.literal('audio'), z.literal('video'), z.literal('av')]);
 const playlistPlayTypeSchema = z.union([
     z.literal('PLAY_ALL'),
@@ -132,3 +132,40 @@ export const clipListSchema = z.object({
         ])),
     })),
 });
+export const bitrateModeSchema = z.union([z.literal('VBR'), z.literal('MBR'), z.literal('ABR')]);
+export const bitrateVapixParamsSchema = z.object({
+    bitrateMode: bitrateModeSchema,
+    maximumBitRate: z.number(),
+    retentionTime: z.number(),
+    bitRateLimit: z.number(),
+});
+export const cameraOptionsSchema = bitrateVapixParamsSchema
+    .extend({
+    resolution: z.string(),
+    h264Profile: h264ProfileSchema,
+    fps: z.number(),
+    compression: z.number().min(0).max(100),
+    govLength: z.number(),
+    bitrateVapixParams: z.string().nullable(),
+    audioSampleRate: z.number(),
+    audioChannelCount: audioChannelCountSchema,
+    keyboard: z.object({
+        fromSource: keyboardShortcutSchema,
+        none: keyboardShortcutSchema,
+    }),
+})
+    .partial();
+export const globalAudioSettingsTypeSchema = z.union([z.literal('fromSource'), z.literal('source')]);
+export const globalAudioSettingsSchema = z.object({
+    type: globalAudioSettingsTypeSchema,
+    source: z.string(),
+    storage: z.string().optional(),
+});
+export const secondaryAudioSettingsSchema = z.object({
+    type: z.union([z.literal('CLIP'), z.literal('STREAM'), z.literal('NONE')]),
+    streamName: z.string().optional(),
+    clipName: z.string().optional(),
+    storage: storageTypeSchema,
+    secondaryAudioLevel: z.number(),
+    masterAudioLevel: z.number(),
+});

package/esm/types/CamSwitcherEvents.js

@@ -16,6 +16,14 @@ const cswEventsDataSchema = z.discriminatedUnion('type', [
         clip_name: z.string().optional(),
         master_audio: z.boolean(),
     }),
+    z.object({
+        type: z.literal('StreamSwitchVideoError'),
+        playlist_name: z.string(),
+        playlist_active_stream: z.number(),
+        stream_name: z.string().optional(),
+        clip_name: z.string().optional(),
+        info: z.string(),
+    }),
     z.object({
         type: z.literal('StreamSwitchAudioError'),
         stream_name: z.string().optional(),

package/esm/types/GenetecAgent.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const successResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+    }),
+});
+export const cameraGuidsResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+        Result: z.array(z.object({ Guid: z.string() })),
+    }),
+});
+export const cameraDetailSchema = z.object({
+    Guid: z.string().optional(),
+    Name: z.string().optional(),
+    EntityType: z.string().optional(),
+});
+export const cameraDetailsResponseSchema = z.object({
+    Rsp: z.object({
+        Status: z.literal('Ok'),
+        Result: z.union([z.array(cameraDetailSchema), cameraDetailSchema]),
+    }),
+});
+export const cameraListSchema = z.array(z.object({
+    index: z.number(),
+    value: z.string(),
+    label: z.string(),
+}));

package/esm/types/PlaneTrackerAPI.js

@@ -0,0 +1,283 @@
+import { z } from 'zod';
+export const wsAliasResponseSchema = z.object({
+    alias: z.string(),
+    ws: z.string(),
+    ws_initial_message: z.string(),
+});
+export const connectionSchema = z.object({
+    protocol: z.union([z.literal('http'), z.literal('https'), z.literal('https_insecure')]),
+    ip: z.union([z.string().ip(), z.literal('')]),
+    port: z.number().positive().lt(65535),
+    user: z.string(),
+    pass: z.string(),
+});
+export const widgetSchema = z.object({
+    enabled: z.boolean().default(true),
+    coord: z.union([
+        z.literal('top_left'),
+        z.literal('top_right'),
+        z.literal('bottom_left'),
+        z.literal('bottom_right'),
+    ]),
+    posX: z.number().nonnegative(),
+    posY: z.number().nonnegative(),
+    scale: z.number().positive(),
+});
+const labelOptionsSchema = z.union([
+    z.literal('blank'),
+    z.literal('registration'),
+    z.literal('call_sign'),
+    z.literal('flight_number'),
+    z.literal('icao'),
+]);
+const identificationLabelSchema = z.object({
+    firstRow: labelOptionsSchema,
+    secondRow: labelOptionsSchema,
+    thirdRow: labelOptionsSchema,
+    fourthRow: labelOptionsSchema,
+    opacity: z.number().positive(),
+});
+export const cameraSettingsSchema = z.object({
+    units: z.union([z.literal('metric'), z.literal('imperial')]).default('imperial'),
+    adsbSource: z
+        .object({
+        ip: z.union([z.string().ip(), z.literal('')]),
+        port: z.number().positive().lt(65535),
+    })
+        .default({ ip: '', port: 30334 }),
+    camera: connectionSchema.default({
+        protocol: 'http',
+        ip: '127.0.0.1',
+        port: 80,
+        user: 'root',
+        pass: '',
+    }),
+    cameraCalibrationProcessConfig: z
+        .object({
+        nightSkyCalibrationEnabled: z.boolean(),
+        scheduleNightSkyCalibrationTimestamp: z.number(),
+    })
+        .default({ nightSkyCalibrationEnabled: false, scheduleNightSkyCalibrationTimestamp: 0 }),
+    cameraConfig: z
+        .object({
+        maxZoomLevel: z.number().optional(),
+        defaultCaptureSizeMeters: z.number().positive().default(120),
+        captureSizeExtensionMeters: z.number().positive().default(80),
+    })
+        .default({
+        maxZoomLevel: 30,
+        defaultCaptureSizeMeters: 120,
+        captureSizeExtensionMeters: 80,
+    }),
+    stream: z
+        .object({
+        width: z.number().positive(),
+        height: z.number().positive(),
+    })
+        .default({ width: 1920, height: 1080 }),
+    imageConfig: z
+        .object({
+        dayAperture: z.number().nonnegative().min(0).max(100),
+        nightAperture: z.number().nonnegative().min(0).max(100),
+    })
+        .default({ dayAperture: 50, nightAperture: 0 }),
+    airportConfig: z
+        .object({
+        icao: z.string().default(''),
+        centerLat: z.number(),
+        centerLon: z.number(),
+        radius: z.number().nonnegative().default(10000),
+    })
+        .default({
+        icao: '',
+        centerLat: 0,
+        centerLon: 0,
+        radius: 10000,
+    }),
+    trackingConfig: z
+        .object({
+        prioritizeEmergency: z.boolean(),
+        guardTourEnabled: z.boolean().default(false),
+        guardTourId: z.number().int().nonnegative().default(0),
+    })
+        .default({ prioritizeEmergency: true, guardTourEnabled: false, guardTourId: 0 }),
+    overlayText: z
+        .object({
+        displayIcao: z.boolean().optional(),
+        displayRegistration: z.boolean().optional(),
+        displayFlightNumber: z.boolean().optional(),
+        displayAltitude: z.boolean().optional(),
+        displayVelocity: z.boolean().optional(),
+        displayDistance: z.boolean().optional(),
+        displayFOV: z.boolean().optional(),
+        displayPTError: z.boolean().optional(),
+        displayPTZSpeed: z.boolean().optional(),
+        displayVelocityData: z.boolean().optional(),
+        displaySignalQuality: z.boolean().optional(),
+        displayAutoTrackingInfo: z.boolean().optional(),
+        displayGPSCoords: z.boolean().optional(),
+        displayVapixQuery: z.boolean().optional(),
+        displayFocus: z.boolean().optional(),
+        displayAperture: z.boolean().optional(),
+        displaySunDistance: z.boolean().optional(),
+        displayTickTime: z.boolean().optional(),
+        displayAircraftInfo: z.boolean().optional(),
+    })
+        .optional(),
+    widget: widgetSchema.default({
+        enabled: true,
+        coord: 'top_right',
+        posX: 10,
+        posY: 10,
+        scale: 100,
+    }),
+    airportWidget: widgetSchema.default({
+        enabled: true,
+        coord: 'top_left',
+        posX: 10,
+        posY: 10,
+        scale: 100,
+    }),
+    fr24FlightInfoSource: z
+        .object({
+        enabled: z.boolean().default(false),
+        priority: z.number().int().positive().default(1),
+        apiToken: z.string().default(''),
+        validateFlights: z.boolean().default(true),
+    })
+        .default({
+        enabled: false,
+        priority: 1,
+        apiToken: '',
+        validateFlights: true,
+    }),
+    radarcapeFlightInfoSource: z
+        .object({
+        enabled: z.boolean().default(false),
+        priority: z.number().int().positive().default(2),
+        ip: z.union([z.string().ip(), z.literal('')]).default(''),
+        port: z.number().positive().lt(65535).default(80),
+    })
+        .default({
+        enabled: false,
+        priority: 2,
+        ip: '',
+        port: 80,
+    }),
+    identificationLabel: identificationLabelSchema.default({
+        firstRow: 'registration',
+        secondRow: 'blank',
+        thirdRow: 'blank',
+        fourthRow: 'blank',
+        opacity: 30,
+    }),
+    acs: connectionSchema
+        .extend({
+        enabled: z.boolean(),
+        sourceKey: z.string(),
+    })
+        .default({
+        enabled: false,
+        protocol: 'https_insecure',
+        ip: '',
+        port: 29204,
+        user: '',
+        pass: '',
+        sourceKey: '',
+    }),
+    genetec: connectionSchema
+        .extend({
+        enabled: z.boolean(),
+        baseUri: z.string().default(''),
+        appId: z.string().default(''),
+        cameraList: z.string().array().default([]),
+    })
+        .default({
+        enabled: false,
+        protocol: 'http',
+        ip: '',
+        port: 4590,
+        user: '',
+        pass: '',
+        baseUri: 'WebSdk',
+        appId: '',
+        cameraList: [],
+    }),
+});
+export const serverSettingsSchema = z.object({
+    cameraCalibration: z.object({
+        posLat: z.number(),
+        posLon: z.number(),
+        geoidHN: z.number(),
+        altitudeAmsl: z.number(),
+        rotationEast: z.number(),
+        rotationNorth: z.number(),
+        rotationUp: z.number(),
+        tiltTransformationCoefA: z.number(),
+        tiltCameraKnownPoint: z.number(),
+        tiltRealKnownPoint: z.number(),
+    }),
+});
+export const trackingModeSchema = z.object({
+    mode: z.union([z.literal('MANUAL'), z.literal('AUTOMATIC')]),
+});
+export const flightInfoSchema = z.object({
+    callsign: z.string().optional(),
+    flightNumber: z.string().optional(),
+    registration: z.string().optional(),
+    aircraftType: z.string().optional(),
+    airlines: z.string().optional(),
+    originAirport: z
+        .object({
+        icao: z.string().optional(),
+        iata: z.string().optional(),
+        city: z.string().optional(),
+    })
+        .optional(),
+    destinationAirport: z.object({
+        icao: z.string().optional(),
+        iata: z.string().optional(),
+        city: z.string().optional(),
+    }),
+    flightImages: z
+        .array(z.object({
+        src: z.string().optional(),
+        photographer: z.string().optional(),
+    }))
+        .optional(),
+});
+export const priorityListSchema = z.object({
+    priorityList: z.array(z.string()).default([]),
+});
+export const whiteListSchema = z.object({
+    whiteList: z.array(z.string()).default([]),
+});
+export const blackListSchema = z.object({
+    blackList: z.array(z.string()).default([]),
+});
+export const mapTypeSchema = z.enum(['roadmap', 'satellite']);
+export const mapInfoSchema = z.object({
+    minZoom: z.number().nonnegative(),
+    maxZoom: z.number().nonnegative(),
+    mapTypes: z.array(mapTypeSchema),
+    tileSize: z.number().nonnegative(),
+});
+export const zonesSchema = z.object({
+    zones: z
+        .array(z.object({
+        enabled: z.boolean().default(true),
+        name: z.string().optional(),
+        area: z
+            .array(z.object({
+            lat: z.number(),
+            lon: z.number(),
+        }))
+            .nonempty(),
+        minAltitudeAmsl: z.number().optional(),
+        maxAltitudeAmsl: z.number().optional(),
+        minSpeedKmph: z.number().optional(),
+        maxSpeedKmph: z.number().optional(),
+        weight: z.number(),
+    }))
+        .default([]),
+});

package/esm/types/VapixAPI.js

@@ -12,6 +12,19 @@ export const applicationSchema = z.object({
     VendorHomePage: z.string().optional(),
     LicenseName: z.string().optional(),
 });
+export const applicationListSchema = z.array(applicationSchema.extend({
+    appId: z
+        .union([
+        z.literal('CamStreamer'),
+        z.literal('CamSwitcher'),
+        z.literal('CamOverlay'),
+        z.literal('CamScripter'),
+        z.literal('PlaneTracker'),
+        z.literal('Ndihxplugin'),
+        z.literal('SportTracker'),
+    ])
+        .nullable(),
+}));
 export const APP_IDS = [
     'CamStreamer',
     'CamSwitcher',
@@ -19,15 +32,8 @@ export const APP_IDS = [
     'CamScripter',
     'PlaneTracker',
     'Ndihxplugin',
+    'SportTracker',
 ];
-export const applicationListSchema = z.object({
-    reply: z.object({
-        $: z.object({ result: z.string() }),
-        application: z.array(z.object({
-            $: applicationSchema,
-        })),
-    }),
-});
 export const guardTourSchema = z.object({
     id: z.string(),
     camNbr: z.unknown(),
@@ -49,7 +55,12 @@ const audioSampleRatesSchema = z.object({
 });
 const audioSampleRatesOutSchema = audioSampleRatesSchema.transform(toCamelCaseDeep);
 export const sdCardWatchedStatuses = ['OK', 'connected', 'disconnected'];
-export const PtzOverviewSchema = z.record(z.number(), z.array(z.object({ id: z.number(), name: z.string() })));
+export const sdCardInfoSchema = z.object({
+    status: z.enum(sdCardWatchedStatuses),
+    totalSize: z.number(),
+    freeSize: z.number(),
+});
+export const ptzOverviewSchema = z.record(z.number(), z.array(z.object({ id: z.number(), name: z.string() })));
 export const cameraPTZItemDataSchema = z.object({
     pan: z.number().optional(),
     tilt: z.number().optional(),
@@ -67,7 +78,7 @@ export const audioDeviceSignalingChannelTypeSchema = z.object({
 });
 export const audioDeviceSignalingTypeSchema = z.object({
     id: z.string(),
-    powerType: z.string(),
+    powerType: z.string().optional(),
     channels: z.array(audioDeviceSignalingChannelTypeSchema),
 });
 export const audioDeviceConnectionTypeSchema = z.object({
@@ -94,7 +105,9 @@ const audioDeviceFromRequestSchema = z.object({
     inputs: z.array(audioDeviceInputOutputSchema).optional(),
     outputs: z.array(audioDeviceInputOutputSchema).optional(),
 });
-export const audioDeviceRequestSchema = z.object({ devices: z.array(audioDeviceFromRequestSchema) });
+export const audioDeviceRequestSchema = z.object({
+    data: z.object({ devices: z.array(audioDeviceFromRequestSchema) }),
+});
 export const maxFpsResponseSchema = z.object({
     data: z
         .array(z.object({
@@ -112,9 +125,23 @@ export const dateTimeinfoSchema = z.object({
         dstEnabled: z.boolean(),
         localDateTime: z.string(),
         posixTimeZone: z.string(),
-        timeZone: z.string(),
+        timeZone: z.string().optional(),
     }),
 });
+export const timeZoneSchema = z.discriminatedUnion('status', [
+    z.object({
+        status: z.literal('success'),
+        data: z.object({
+            activeTimeZone: z.string(),
+        }),
+    }),
+    z.object({
+        status: z.literal('error'),
+        error: z.object({
+            message: z.string(),
+        }),
+    }),
+]);
 export const audioSampleRatesResponseSchema = z.object({
     data: z.object({
         encoders: z
@@ -125,3 +152,34 @@ export const audioSampleRatesResponseSchema = z.object({
             .partial(),
     }),
 });
+export const portStatusSchema = z.object({
+    port: z.string(),
+    state: z.enum(['open', 'closed']),
+    configurable: z.boolean(),
+    readonly: z.boolean().optional(),
+    usage: z.string(),
+    direction: z.enum(['input', 'output']),
+    name: z.string(),
+    normalState: z.enum(['open', 'closed']),
+});
+export const getPortsResponseSchema = z.object({
+    apiVersion: z.string(),
+    context: z.string(),
+    method: z.literal('getPorts'),
+    data: z.object({
+        numberOfPorts: z.number(),
+        items: z.array(portStatusSchema),
+    }),
+});
+export const portSetSchema = z.object({
+    port: z.string(),
+    state: z.enum(['open', 'closed']),
+    usage: z.string().optional(),
+    direction: z.enum(['input', 'output']).optional(),
+    name: z.string().optional(),
+    normalState: z.enum(['open', 'closed']).optional(),
+});
+export const portSequenceStateSchema = z.object({
+    state: z.enum(['open', 'closed']),
+    time: z.number().min(0).max(65535),
+});

package/esm/types/VapixEvents.js

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

package/esm/web/DefaultClient.js

@@ -1,16 +1,28 @@
 import { addParametersToPath } from '../internal/utils';
 export class DefaultClient {
-    get(url, parameters, headers) {
-        return fetch(addParametersToPath(url, parameters), {
+    get = (params) => {
+        return this.fetchWithTimeout(addParametersToPath(params.path, params.parameters), {
             method: 'GET',
-            headers: headers,
-        });
-    }
-    post(url, data, parameters, headers) {
-        return fetch(addParametersToPath(url, parameters), {
+            headers: params.headers,
+        }, params.timeout);
+    };
+    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(url, options, timeout) {
+        const controller = new AbortController();
+        const timeoutId = timeout !== undefined ? setTimeout(() => controller.abort(), timeout) : null;
+        try {
+            return await fetch(url, { ...options, signal: controller.signal });
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
     }
 }

package/esm/web/WsClient.js

@@ -1,4 +1,4 @@
-const REFRESH_TIMEOUT = 5_000;
+const REFRESH_TIMEOUT = 5000;
 export class WsClient {
     getUrl;
     getAuthToken;
@@ -27,7 +27,7 @@ export class WsClient {
         };
         ws.onmessage = (e) => this.onmessage(e);
         ws.onclose = () => {
-            this.restartTimeout = setTimeout(() => this.init(), REFRESH_TIMEOUT);
+            this.restartTimeout = window.setTimeout(() => this.init(), REFRESH_TIMEOUT);
         };
         this.ws = ws;
     }
@@ -40,7 +40,7 @@ export class WsClient {
         this.destroyWebsocket();
     };
     destroyWebsocket() {
-        if (this.restartTimeout) {
+        if (this.restartTimeout !== null) {
             clearTimeout(this.restartTimeout);
             this.restartTimeout = null;
         }