camstreamerlib 3.5.2 → 4.0.0-beta.2

package/types/VapixAPI.js

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { toCamelCaseDeep } from '../internal/transformers';
+export const applicationSchema = z.object({
+    Name: z.string(),
+    NiceName: z.string(),
+    Vendor: z.string(),
+    Version: z.string(),
+    ApplicationID: z.string().optional(),
+    License: z.string(),
+    Status: z.string(),
+    ConfigurationPage: z.string().optional(),
+    VendorHomePage: z.string().optional(),
+    LicenseName: z.string().optional(),
+});
+export const APP_IDS = [
+    'CamStreamer',
+    'CamSwitcher',
+    'CamOverlay',
+    'CamScripter',
+    'PlaneTracker',
+    'Ndihxplugin',
+];
+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(),
+    name: z.string(),
+    randomEnabled: z.unknown(),
+    running: z.string(),
+    timeBetweenSequences: z.unknown(),
+    tour: z.array(z.object({
+        moveSpeed: z.unknown(),
+        position: z.unknown(),
+        presetNbr: z.unknown(),
+        waitTime: z.unknown(),
+        waitTimeViewType: z.unknown(),
+    })),
+});
+const audioSampleRatesSchema = z.object({
+    sample_rate: z.number(),
+    bit_rates: z.array(z.number()),
+});
+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 cameraPTZItemDataSchema = z.object({
+    pan: z.number().optional(),
+    tilt: z.number().optional(),
+    zoom: z.number().optional(),
+});
+export const cameraPTZItemSchema = z.object({
+    name: z.string(),
+    id: z.number(),
+    data: cameraPTZItemDataSchema,
+});
+export const audioDeviceSignalingChannelTypeSchema = z.object({
+    id: z.string(),
+    gain: z.number(),
+    mute: z.boolean(),
+});
+export const audioDeviceSignalingTypeSchema = z.object({
+    id: z.string(),
+    powerType: z.string(),
+    channels: z.array(audioDeviceSignalingChannelTypeSchema),
+});
+export const audioDeviceConnectionTypeSchema = z.object({
+    id: z.string(),
+    signalingTypeSelected: z.string(),
+    signalingTypes: z.array(audioDeviceSignalingTypeSchema),
+});
+export const audioDeviceInputOutputSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    enabled: z.boolean(),
+    connectionTypes: z.array(audioDeviceConnectionTypeSchema),
+    connectionTypeSelected: z.string(),
+});
+export const audioDeviceSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    inputs: z.array(audioDeviceInputOutputSchema),
+    outputs: z.array(audioDeviceInputOutputSchema),
+});
+const audioDeviceFromRequestSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    inputs: z.array(audioDeviceInputOutputSchema).optional(),
+    outputs: z.array(audioDeviceInputOutputSchema).optional(),
+});
+export const audioDeviceRequestSchema = z.object({ devices: z.array(audioDeviceFromRequestSchema) });
+export const maxFpsResponseSchema = z.object({
+    data: z.array(z.object({
+        channel: z.number(),
+        captureMode: z.array(z.object({
+            enabled: z.boolean(),
+            maxFPS: z.number().optional(),
+        })),
+    })),
+});
+export const dateTimeinfoSchema = z.object({
+    data: z.object({
+        dateTime: z.string(),
+        dstEnabled: z.boolean(),
+        localDateTime: z.string(),
+        posixTimeZone: z.string(),
+        timeZone: z.string(),
+    }),
+});
+export const audioSampleRatesResponseSchema = z.object({
+    data: z.object({
+        encoders: z.union([
+            z.object({
+                aac: z.array(audioSampleRatesSchema),
+                AAC: z.undefined(),
+            }),
+            z.object({
+                AAC: z.array(audioSampleRatesSchema),
+                aac: z.undefined(),
+            }),
+        ]),
+    }),
+});

package/types/common.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const audioChannelSchema: z.ZodUnion<[z.ZodLiteral<"mono">, z.ZodLiteral<"stereo">]>;
+export type TAudioChannel = z.infer<typeof audioChannelSchema>;
+export declare const audioChannelCountSchema: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+export type TAudioChannelCount = z.infer<typeof audioChannelCountSchema>;
+export declare const h264ProfileSchema: z.ZodUnion<[z.ZodLiteral<"high">, z.ZodLiteral<"main">, z.ZodLiteral<"baseline">]>;
+export type TH264Profile = z.infer<typeof h264ProfileSchema>;
+export declare const storageTypeSchema: z.ZodUnion<[z.ZodLiteral<"SD_DISK">, z.ZodLiteral<"FLASH">]>;
+export type TStorageType = z.infer<typeof storageTypeSchema>;
+export declare const networkCameraListSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    ip: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ip: string;
+    name: string;
+}, {
+    ip: string;
+    name: string;
+}>, "many">;
+export type TNetworkCamera = z.infer<typeof networkCameraListSchema>[number];
+export declare const keyboardShortcutSchema: z.ZodNullable<z.ZodString>;
+export declare const keyboardShortcutsSchema: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+export type TKeyboardShortcut = z.infer<typeof keyboardShortcutSchema>;
+export type TKeyboardShortcuts = z.infer<typeof keyboardShortcutsSchema>;
+export type TProxyParam = {
+    ip: string;
+    mdnsName: string;
+    port: number;
+    user: string;
+    pass: string;
+} | null;
+export type TCameraImageConfig = {
+    camera?: string;
+    resolution?: string;
+    compression?: number;
+    overlays?: 'off';
+};

package/types/common.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export const audioChannelSchema = z.union([z.literal('mono'), z.literal('stereo')]);
+export const audioChannelCountSchema = z.union([z.literal(1), z.literal(2)]);
+export const h264ProfileSchema = z.union([z.literal('high'), z.literal('main'), z.literal('baseline')]);
+export const storageTypeSchema = z.union([z.literal('SD_DISK'), z.literal('FLASH')]);
+export const networkCameraListSchema = z.array(z.object({
+    name: z.string(),
+    ip: z.string(),
+}));
+export const keyboardShortcutSchema = z.string().nullable();
+export const keyboardShortcutsSchema = z.record(keyboardShortcutSchema);

package/web/DefaultClient.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { IClient, TParameters } from '../internal/common';
+export declare class DefaultClient implements IClient {
+    get(url: string, parameters?: TParameters, headers?: Record<string, string>): Promise<Response>;
+    post(url: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>): Promise<Response>;
+}

package/web/DefaultClient.js

@@ -0,0 +1,16 @@
+import { addParametersToPath } from '../internal/utils';
+export class DefaultClient {
+    get(url, parameters, headers) {
+        return fetch(addParametersToPath(url, parameters), {
+            method: 'GET',
+            headers: headers,
+        });
+    }
+    post(url, data, parameters, headers) {
+        return fetch(addParametersToPath(url, parameters), {
+            method: 'POST',
+            body: data,
+            headers: headers,
+        });
+    }
+}

package/web/WsClient.d.ts

@@ -0,0 +1,13 @@
+export declare class WsClient {
+    private getUrl;
+    private getAuthToken;
+    isDestroyed: boolean;
+    private ws;
+    private restartTimeout;
+    constructor(getUrl: () => string, getAuthToken: () => Promise<string>);
+    init(): void;
+    send: (msg: string) => void;
+    onmessage: (_: MessageEvent) => void;
+    destroy: () => void;
+    private destroyWebsocket;
+}

package/web/WsClient.js

@@ -0,0 +1,58 @@
+const REFRESH_TIMEOUT = 5_000;
+export class WsClient {
+    getUrl;
+    getAuthToken;
+    isDestroyed = false;
+    ws = null;
+    restartTimeout = null;
+    constructor(getUrl, getAuthToken) {
+        this.getUrl = getUrl;
+        this.getAuthToken = getAuthToken;
+    }
+    init() {
+        if (this.isDestroyed) {
+            return;
+        }
+        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.onclose = () => {
+            this.restartTimeout = setTimeout(() => this.init(), REFRESH_TIMEOUT);
+        };
+        this.ws = ws;
+    }
+    send = (msg) => {
+        this.ws?.send(msg);
+    };
+    onmessage = (_) => { };
+    destroy = () => {
+        this.isDestroyed = true;
+        this.destroyWebsocket();
+    };
+    destroyWebsocket() {
+        if (this.restartTimeout) {
+            clearTimeout(this.restartTimeout);
+            this.restartTimeout = null;
+        }
+        if (!this.ws) {
+            return;
+        }
+        this.ws.onmessage = null;
+        this.ws.onopen = null;
+        this.ws.onclose = null;
+        if (this.ws.readyState === this.ws.OPEN) {
+            this.ws.close();
+        }
+        this.ws = null;
+    }
+}

package/CameraVapix.d.ts

@@ -1,98 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { WritableStream } from 'node:stream/web';
-import { HttpOptions, IClient } from './internal/common';
-export type CameraVapixOptions = HttpOptions;
-export type TApplicationList = {
-    reply: {
-        $: {
-            result: string;
-        };
-        application: {
-            $: TApplication;
-        }[];
-    };
-};
-export type TApplication = {
-    Name: string;
-    NiceName: string;
-    Vendor: string;
-    Version: string;
-    ApplicationID?: string;
-    License: string;
-    Status: string;
-    ConfigurationPage?: string;
-    VendorHomePage?: string;
-    LicenseName?: string;
-};
-export type TGuardTour = {
-    id: string;
-    camNbr: unknown;
-    name: string;
-    randomEnabled: unknown;
-    running: string;
-    timeBetweenSequences: unknown;
-    tour: {
-        moveSpeed: unknown;
-        position: unknown;
-        presetNbr: unknown;
-        waitTime: unknown;
-        waitTimeViewType: unknown;
-    }[];
-};
-export type TAudioSampleRates = {
-    sampleRate: number;
-    bitRates: number[];
-};
-export type TSDCardInfo = {
-    available: boolean;
-    totalSize: number;
-    freeSize: number;
-};
-export type TPtzOverview = Record<number, {
-    id: number;
-    name: string;
-}[]>;
-export type TCameraPTZItem = {
-    name: string;
-    id: number;
-    data: TCameraPTZItemData;
-};
-export type TCameraPTZItemData = {
-    pan?: number;
-    tilt?: number;
-    zoom?: number;
-};
-export declare class CameraVapix {
-    private client;
-    constructor(options?: CameraVapixOptions | IClient);
-    vapixGet(path: string, parameters?: Record<string, string>): Promise<Response>;
-    vapixPost(path: string, data: string | Buffer | FormData, contentType?: string): Promise<Response>;
-    getCameraImage(camera: string, compression: string, resolution: string, outputStream: WritableStream): Promise<WritableStream<any>>;
-    getEventDeclarations(): Promise<string>;
-    getSupportedAudioSampleRate(): Promise<TAudioSampleRates[]>;
-    checkSdCard(): Promise<TSDCardInfo>;
-    downloadCameraReport(): Promise<Response>;
-    getMaxFps(channel: number): Promise<number>;
-    getTimezone(): Promise<string>;
-    getHeaders(): Promise<Record<string, string>>;
-    setHeaders(headers: Record<string, string>): Promise<Response>;
-    private parseParameters;
-    getParameterGroup(groupNames: string): Promise<Record<string, string>>;
-    setParameter(params: Record<string, string>): Promise<Response>;
-    getGuardTourList(): Promise<TGuardTour[]>;
-    setGuardTourEnabled(guardTourID: string, enable: boolean): Promise<Response>;
-    private parsePtz;
-    private parseCameraPtzResponse;
-    getPTZPresetList(channel: number): Promise<string[]>;
-    listPtzVideoSourceOverview(): Promise<TPtzOverview>;
-    goToPreset(channel: number, presetName: string): Promise<Response>;
-    getPtzPosition(camera: number): Promise<TCameraPTZItemData>;
-    getInputState(port: number): Promise<boolean>;
-    setOutputState(port: number, active: boolean): Promise<Response>;
-    getApplicationList(): Promise<TApplication[]>;
-    startApplication(applicationID: string): Promise<void>;
-    restartApplication(applicationID: string): Promise<void>;
-    stopApplication(applicationID: string): Promise<void>;
-}