camstreamerlib 3.5.2 → 4.0.0-beta.2

package/CamSwitcherAPI.js

@@ -1,112 +1,350 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamSwitcherAPI = void 0;
-const DefaultAgent_1 = require("./DefaultAgent");
-const common_1 = require("./internal/common");
-const cgiNames = {
-    camera: 'streams',
-    audio: 'audios',
-    playlist: 'playlists',
-    clip: 'clips',
-    tracker: 'trackers',
-};
-class CamSwitcherAPI {
-    constructor(options = {}) {
-        if ((0, common_1.isClient)(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultAgent_1.DefaultAgent(options);
-        }
-    }
-    generateSilence(sampleRate, channels) {
-        return this.get('/local/camswitcher/generate_silence.cgi', { sample_rate: sampleRate.toString(), channels });
+import { z } from 'zod';
+import { AddNewClipError } from './errors/errors';
+import { isNullish, responseStringify } from './internal/common';
+import { storageInfoListSchema, outputInfoSchema, audioPushInfoSchema, clipListSchema, playlistQueueSchema, streamSaveLoadSchema, clipSaveLoadSchema, playlistSaveLoadSchema, trackerSaveLoadSchema, } from './types/CamSwitcherAPI';
+import { networkCameraListSchema } from './types/common';
+import { VapixAPI } from './VapixAPI';
+import { isFirmwareVersionAtLeast } from './internal/versionCompare';
+import { isClip } from './internal/utils';
+import { FIRMWARE_WITH_BITRATE_MODES_SUPPORT } from './internal/constants';
+const baseUrl = '/local/camswitcher/api';
+export class CamSwitcherAPI {
+    client;
+    vapixAgent;
+    constructor(client) {
+        this.client = client;
+        this.vapixAgent = new VapixAPI(client, () => '');
     }
-    getIpListFromNetworkCheck() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.get('/local/camswitcher/network_camera_list.cgi')).data;
+    static getProxyUrl = () => `${baseUrl}/proxy.cgi`;
+    static getWsEventsUrl = () => `/local/camswitcher/events`;
+    static getClipPreview = (id, storage) => `${baseUrl}/clip_preview.cgi?clip_name=${id}&storage=${storage}`;
+    async generateSilence(sampleRate, channels) {
+        await this.client.get(`${baseUrl}/generate_silence.cgi`, {
+            sample_rate: sampleRate.toString(),
+            channels,
         });
     }
-    getMaxFps(source) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.get('/local/camswitcher/get_max_framerate.cgi', { video_source: source.toString() })).data;
-        });
+    async checkCameraTime() {
+        const data = await this.get(`${baseUrl}/camera_time.cgi`);
+        return z.boolean().parse(data);
     }
-    getStorageInfo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.get('/local/camswitcher/get_storage.cgi')).data;
-        });
+    async getIpListFromNetworkCheck() {
+        const data = await this.get(`${baseUrl}/network_camera_list.cgi`);
+        return networkCameraListSchema.parse(data);
     }
-    getOutputInfo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.get('/local/camswitcher/output_info.cgi')).data;
+    async getMaxFps(source) {
+        const data = await this.get(`${baseUrl}/get_max_framerate.cgi`, {
+            video_source: source.toString(),
         });
+        return z.number().parse(data);
     }
-    getPlaylistList() {
-        return this.get('/local/camswitcher/playlists.cgi?action=get');
+    async getStorageInfo() {
+        const data = await this.get(`${baseUrl}/get_storage.cgi`);
+        return storageInfoListSchema.parse(data);
     }
-    playlistSwitch(playlistName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.get(`/local/camswitcher/playlist_switch.cgi?playlist_name=${playlistName}`);
-        });
+    async wsAuthorization() {
+        const data = await this.get(`${baseUrl}/ws_authorization.cgi`);
+        return z.string().parse(data);
     }
-    playlistQueuePush(playlistName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.get(`/local/camswitcher/playlist_queue_push.cgi?playlist_name=${playlistName}`);
-        });
+    async getOutputInfo() {
+        const data = await this.get(`${baseUrl}/output_info.cgi`);
+        return outputInfoSchema.parse(data);
     }
-    playlistQueueClear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.get('/local/camswitcher/playlist_queue_clear.cgi');
-        });
+    async getAudioPushInfo() {
+        const data = await this.get(`${baseUrl}/audio_push_info.cgi`);
+        return audioPushInfoSchema.parse(data);
     }
-    playlistQueueList() {
-        return this.get('/local/camswitcher/playlist_queue_list.cgi');
+    async getStreamSaveList() {
+        const data = await this.get(`${baseUrl}/streams.cgi`, { action: 'get' });
+        return streamSaveLoadSchema.parse(data);
     }
-    playlistQueuePlayNext() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.get('/local/camswitcher/playlist_queue_play_next.cgi');
-        });
+    async getClipSaveList() {
+        const data = await this.get(`${baseUrl}/clips.cgi`, { action: 'get' });
+        return clipSaveLoadSchema.parse(data);
     }
-    getClipList() {
-        return this.get('/local/camswitcher/clips.cgi?action=get');
-    }
-    addNewClip(file, clipType, storage, id, fileName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const formData = new FormData();
-            formData.append('clip_name', id);
-            formData.append('clip_type', clipType);
-            formData.append('file', file, fileName);
-            const path = `/local/camswitcher/clip_upload.cgi?storage=${storage}`;
-            const res = yield this.client.post(path, formData);
-            const output = (yield res.json());
-            if (output.status !== 200) {
-                throw new Error('Error on camera: ' + output.message);
-            }
-        });
+    async getPlaylistSaveList() {
+        const data = await this.get(`${baseUrl}/playlists.cgi`, { action: 'get' });
+        return playlistSaveLoadSchema.parse(data);
+    }
+    async getTrackerSaveList() {
+        const data = await this.get(`${baseUrl}/trackers.cgi`, { action: 'get' });
+        return trackerSaveLoadSchema.parse(data);
+    }
+    async setStreamSaveList(data) {
+        return await this.set(`${baseUrl}/streams.cgi`, data, { action: 'set' });
+    }
+    async setClipSaveList(data) {
+        return await this.set(`${baseUrl}/clips.cgi`, data, { action: 'set' });
+    }
+    async setPlaylistSaveList(data) {
+        return await this.set(`${baseUrl}/playlists.cgi`, data, { action: 'set' });
+    }
+    async setTrackerSaveList(data) {
+        return await this.set(`${baseUrl}/trackers.cgi`, data, { action: 'set' });
+    }
+    async playlistSwitch(playlistName) {
+        await this.get(`${baseUrl}/playlist_switch.cgi?playlist_name=${playlistName}`);
+    }
+    async playlistQueuePush(playlistName) {
+        await this.get(`${baseUrl}/playlist_queue_push.cgi?playlist_name=${playlistName}`);
+    }
+    async playlistQueueClear() {
+        await this.get(`${baseUrl}/playlist_queue_clear.cgi`);
+    }
+    async playlistQueueList() {
+        const data = await this.get(`${baseUrl}/playlist_queue_list.cgi`);
+        return playlistQueueSchema.parse(data).playlistQueueList;
+    }
+    async playlistQueuePlayNext() {
+        await this.get(`${baseUrl}/playlist_queue_play_next.cgi`);
+    }
+    async addNewClip(file, clipType, storage, id, fileName) {
+        const formData = new FormData();
+        formData.append('clip_name', id);
+        formData.append('clip_type', clipType);
+        formData.append('file', file, fileName);
+        const path = `${baseUrl}/clip_upload.cgi?storage=${storage}`;
+        const res = await this.client.post(path, formData);
+        const output = (await res.json());
+        if (output.status !== 200) {
+            throw new AddNewClipError(output.message);
+        }
     }
     removeClip(id, storage) {
-        return this.get(`/local/camswitcher/clip_remove.cgi`, { clip_name: id, storage });
+        return this.get(`${baseUrl}/clip_remove.cgi`, { clip_name: id, storage });
     }
-    get(path, parameters = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.client.get(path, parameters);
-            if (res.ok) {
-                return yield res.json();
+    async getClipList() {
+        const data = await this.get(`${baseUrl}/clip_list.cgi`);
+        return clipListSchema.parse(data).clip_list;
+    }
+    setCamSwitchOptions(data, cameraFWVersion) {
+        const bitrateVapixParams = parseBitrateOptionsToBitrateVapixParams(cameraFWVersion, data.bitrateMode, data);
+        const saveData = {
+            video: {
+                resolution: data.resolution,
+                h264Profile: data.h264Profile,
+                fps: data.fps,
+                compression: data.compression,
+                govLength: data.govLength,
+                videoClipQuality: data.maximumBitRate,
+                bitrateVapixParams: bitrateVapixParams,
+            },
+            audio: {
+                sampleRate: data.audioSampleRate,
+                channelCount: data.audioChannelCount,
+            },
+            keyboard: data.keyboard,
+        };
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SETTINGS, saveData);
+    }
+    setGlobalAudioSettings(settings) {
+        let acceptedType = 'NONE';
+        if (settings.type === 'source' && settings.source) {
+            if (isClip(settings.source)) {
+                acceptedType = 'CLIP';
             }
             else {
-                throw new Error(yield (0, common_1.responseStringify)(res));
+                acceptedType = 'STREAM';
             }
-        });
+        }
+        const data = {
+            type: acceptedType,
+            stream_name: settings.source,
+            clip_name: settings.source,
+            storage: settings.storage,
+        };
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.MASTER_AUDIO, data);
+    }
+    setSecondaryAudioSettings(settings) {
+        const data = {
+            type: settings.type,
+            stream_name: settings.streamName ?? '',
+            clip_name: settings.clipName ?? '',
+            storage: settings.storage,
+            secondary_audio_level: settings.secondaryAudioLevel,
+            master_audio_level: settings.masterAudioLevel,
+        };
+        return this.setParamFromCameraJSON(CSW_PARAM_NAMES.SECONDARY_AUDIO, data);
+    }
+    setDefaultPlaylist(id) {
+        const value = JSON.stringify({ default_playlist_id: id });
+        return this.vapixAgent.setParameter({
+            [CSW_PARAM_NAMES.DEFAULT_PLAYLIST]: value,
+        }, null);
+    }
+    setPermanentRtspUrlToken(token) {
+        return this.vapixAgent.setParameter({ [CSW_PARAM_NAMES.RTSP_TOKEN]: token }, null);
+    }
+    async getCamSwitchOptions() {
+        const saveData = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SETTINGS);
+        if (isNullish(saveData.video)) {
+            return saveData;
+        }
+        if (!isNullish(saveData.video?.bitrateVapixParams)) {
+            const bitrateOptions = parseVapixParamsToBitrateOptions(saveData.video.bitrateVapixParams);
+            saveData.video.bitrateMode = bitrateOptions.bitrateMode;
+            saveData.video.maximumBitRate = bitrateOptions.maximumBitRate;
+            saveData.video.retentionTime = bitrateOptions.retentionTime;
+            saveData.video.bitRateLimit = bitrateOptions.bitRateLimit;
+        }
+        if (!isNullish(saveData.video?.bitrateLimit)) {
+            saveData.video.maximumBitRate = saveData.video.bitrateLimit;
+            saveData.video.bitrateMode = 'MBR';
+        }
+        if (!isNullish(saveData.video?.videoClipQuality)) {
+            saveData.video.maximumBitRate = saveData.video.videoClipQuality;
+        }
+        return {
+            ...saveData.video,
+            audioSampleRate: saveData.audio.sampleRate,
+            audioChannelCount: saveData.audio.channelCount,
+            keyboard: saveData.keyboard,
+        };
+    }
+    async getGlobalAudioSettings() {
+        const settings = {
+            type: 'fromSource',
+            source: 'fromSource',
+        };
+        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.MASTER_AUDIO);
+        if (res.type === 'STREAM') {
+            settings.type = 'source';
+            settings.source = res.stream_name;
+        }
+        else if (res.type === 'CLIP') {
+            settings.type = 'source';
+            settings.source = res.clip_name;
+            settings.storage = res.storage;
+        }
+        return settings;
+    }
+    async getSecondaryAudioSettings() {
+        const res = await this.getParamFromCameraAndJSONParse(CSW_PARAM_NAMES.SECONDARY_AUDIO);
+        const settings = {
+            type: res.type ?? 'NONE',
+            streamName: res.stream_name,
+            clipName: res.clip_name,
+            storage: res.storage,
+            secondaryAudioLevel: res.secondary_audio_level ?? 1,
+            masterAudioLevel: res.master_audio_level ?? 1,
+        };
+        return settings;
+    }
+    async getPermanentRtspUrlToken() {
+        const paramName = CSW_PARAM_NAMES.RTSP_TOKEN;
+        const res = await this.vapixAgent.getParameter([paramName], null);
+        return res[paramName] ?? '';
+    }
+    async get(path, parameters = {}) {
+        const res = await this.client.get(path, parameters);
+        if (res.ok) {
+            const d = (await res.json());
+            return d.data;
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    async set(path, data, parameters = {}) {
+        const res = await this.client.post(path, JSON.stringify(data), parameters);
+        if (res.ok) {
+            const parsed = await res.json();
+            return parsed.message === 'OK';
+        }
+        else {
+            throw new Error(await responseStringify(res));
+        }
+    }
+    setParamFromCameraJSON(paramName, data) {
+        const params = {};
+        params[paramName] = JSON.stringify(data);
+        return this.vapixAgent.setParameter(params, null);
+    }
+    async getParamFromCameraAndJSONParse(paramName) {
+        const data = await this.vapixAgent.getParameter([paramName], null);
+        if (data[paramName] !== undefined) {
+            try {
+                if (data[paramName] === '') {
+                    return {};
+                }
+                else {
+                    return JSON.parse(data[paramName] + '');
+                }
+            }
+            catch {
+                throw new Error('Error: in JSON parsing of ' + paramName + '. Cannot parse: ' + data[paramName]);
+            }
+        }
+        throw new Error("Error: no parametr '" + paramName + "' was found");
     }
 }
-exports.CamSwitcherAPI = CamSwitcherAPI;
+const CSW_PARAM_NAMES = {
+    SETTINGS: 'Camswitcher.Settings',
+    MASTER_AUDIO: 'Camswitcher.MasterAudio',
+    SECONDARY_AUDIO: 'Camswitcher.SecondaryAudio',
+    RTSP_TOKEN: 'Camswitcher.RTSPAccessToken',
+    DEFAULT_PLAYLIST: 'Camswitcher.DefaultPlaylist',
+};
+const parseBitrateOptionsToBitrateVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
+    if (!isFirmwareVersionAtLeast(firmWareVersion, FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
+        return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
+    }
+    if (bitrateMode === null) {
+        return '';
+    }
+    if (bitrateMode === 'VBR') {
+        return 'videobitratemode=vbr';
+    }
+    if (bitrateMode === 'MBR') {
+        return `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}`;
+    }
+    if (bitrateMode === 'ABR') {
+        return `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`;
+    }
+    throw new Error('Unknown bitrateMode param in getVapixParams method.');
+};
+const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
+    const params = {};
+    const searchParams = new URLSearchParams(bitrateVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
+    const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
+    if (hasLowerFw) {
+        const maximumBitRate = parseInt(params['videomaxbitrate'], 10);
+        return {
+            bitrateMode: 'MBR',
+            maximumBitRate: maximumBitRate,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate * 1.1),
+        };
+    }
+    if (bitrateMode === 'ABR') {
+        const maximumBitRate = parseInt(params['videoabrtargetbitrate'], 10);
+        const retentionTime = parseInt(params['videoabrretentiontime'], 10);
+        const bitrateLimit = parseInt(params['videoabrmaxbitrate'], 10);
+        return {
+            bitrateMode: bitrateMode,
+            maximumBitRate: maximumBitRate,
+            retentionTime: retentionTime,
+            bitRateLimit: bitrateLimit,
+        };
+    }
+    else if (bitrateMode === 'MBR') {
+        const maximumBitRate = parseInt(params['videomaxbitrate'], 10);
+        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'], 10);
+        return {
+            bitrateMode: bitrateMode,
+            maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate ?? oldMaximumBitrateParamValue * 1.1),
+        };
+    }
+    return {
+        bitrateMode: bitrateMode,
+        retentionTime: 1,
+        maximumBitRate: 0,
+        bitRateLimit: 0,
+    };
+};

package/CamSwitcherEvents.d.ts

@@ -1,36 +1,18 @@
-/// <reference types="node" />
-import * as EventEmitter from 'events';
-import { HttpOptions } from './internal/common';
-export type CamSwitcherEventsOptions = HttpOptions;
-export type TEvent = {
-    type: string;
-    date: Record<string, string | number | boolean> & {
-        type: string;
-    };
-};
-export interface CamSwitcherEvents {
-    on(event: 'open', listener: () => void): this;
-    on(event: 'close', listener: () => void): this;
-    on(event: 'event', listener: (data: TEvent) => void): this;
-    on(event: 'error', listener: (err: Error) => void): this;
-    emit(event: 'open'): boolean;
-    emit(event: 'close'): boolean;
-    emit(event: 'event', data: TEvent): boolean;
-    emit(event: 'error', err: Error): boolean;
-}
-export declare class CamSwitcherEvents extends EventEmitter {
-    private tls;
-    private tlsInsecure;
-    private ip;
-    private port;
-    private user;
-    private pass;
-    private client;
+import { IWebsocket } from './internal/common';
+import { TCamSwitcherEventOfType, TCamSwitcherEventType } from './types/CamswitcherEvents';
+type TListenerFunction<T extends TCamSwitcherEventType> = (data: TCamSwitcherEventOfType<T>, isInit: boolean) => void;
+export declare class CamSwitcherEvents<Event extends {
+    data: string;
+}> {
+    isDestroyed: boolean;
     private ws;
-    constructor(options?: CamSwitcherEventsOptions);
-    connect(): void;
-    disconnect(): void;
+    private listeners;
+    setWebsocket(ws: IWebsocket<Event>): void;
     resendInitData(): void;
-    private createWsClient;
-    private get;
+    addListener<T extends TCamSwitcherEventType>(type: T, listener: TListenerFunction<T>, id: string): void;
+    removeListener<T extends TCamSwitcherEventType>(type: T, id: string): void;
+    private onMessage;
+    private processMessage;
+    destroy(): void;
 }
+export {};

package/CamSwitcherEvents.js

@@ -1,107 +1,63 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamSwitcherEvents = void 0;
-const EventEmitter = require("events");
-const WsClient_1 = require("./internal/WsClient");
-const DefaultAgent_1 = require("./DefaultAgent");
-class CamSwitcherEvents extends EventEmitter {
-    constructor(options = {}) {
-        var _a, _b, _c, _d, _e, _f;
-        super();
-        this.tls = (_a = options.tls) !== null && _a !== void 0 ? _a : false;
-        this.tlsInsecure = (_b = options.tlsInsecure) !== null && _b !== void 0 ? _b : false;
-        this.ip = (_c = options.ip) !== null && _c !== void 0 ? _c : '127.0.0.1';
-        this.port = (_d = options.port) !== null && _d !== void 0 ? _d : (this.tls ? 443 : 80);
-        this.user = (_e = options.user) !== null && _e !== void 0 ? _e : 'root';
-        this.pass = (_f = options.pass) !== null && _f !== void 0 ? _f : '';
-        this.client = new DefaultAgent_1.DefaultAgent(options);
-        this.createWsClient();
-        EventEmitter.call(this);
-    }
-    connect() {
-        this.ws.open();
-    }
-    disconnect() {
-        this.ws.close();
+import { cswEventsSchema, } from './types/CamswitcherEvents';
+export class CamSwitcherEvents {
+    isDestroyed = false;
+    ws = null;
+    listeners = {};
+    setWebsocket(ws) {
+        if (this.ws) {
+            this.ws.destroy();
+        }
+        this.ws = ws;
+        this.ws.onmessage = (e) => this.onMessage(e);
     }
     resendInitData() {
         const request = {
             command: 'sendInitData',
         };
-        this.ws.send(JSON.stringify(request));
+        this.ws?.send(JSON.stringify(request));
     }
-    createWsClient() {
-        const options = {
-            ip: this.ip,
-            port: this.port,
-            user: this.user,
-            pass: this.pass,
-            tls: this.tls,
-            tlsInsecure: this.tlsInsecure,
-            address: '/local/camswitcher/events',
-            protocol: 'events',
-        };
-        this.ws = new WsClient_1.WsClient(options);
-        this.ws.on('open', () => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const token = yield this.get('/local/camswitcher/ws_authorization.cgi');
-                this.ws.send(JSON.stringify({ authorization: token }));
-            }
-            catch (err) {
-                this.emit('error', err);
-            }
-        }));
-        this.ws.on('message', (data) => {
-            try {
-                const parsedData = JSON.parse(data.toString());
-                if (parsedData.type === 'authorization') {
-                    if (parsedData.state === 'OK') {
-                        this.emit('open');
-                    }
-                    else {
-                        this.emit('error', new Error(data.toString()));
-                    }
-                }
-                else {
-                    this.emit('event', parsedData);
-                }
-            }
-            catch (err) {
-                this.emit('error', err);
-            }
-        });
-        this.ws.on('error', (err) => {
-            this.emit('error', err);
-        });
-        this.ws.on('close', () => {
-            this.emit('close');
-        });
+    addListener(type, listener, id) {
+        const typeList = this.listeners[type];
+        if (typeList === undefined) {
+            this.listeners[type] = { [id]: listener };
+            return;
+        }
+        typeList[id] = listener;
     }
-    get(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.client.get(path);
-            if (res.ok) {
-                const responseText = JSON.parse(yield res.text());
-                if (responseText.status === 200) {
-                    return responseText.data;
-                }
-                else {
-                    throw new Error(`Request (${path}) error, response: ${JSON.stringify(responseText)}`);
-                }
-            }
-            else {
-                throw new Error(JSON.stringify(res));
+    removeListener(type, id) {
+        const typeList = this.listeners[type];
+        if (typeList) {
+            delete typeList[id];
+        }
+    }
+    onMessage(evt) {
+        if (this.isDestroyed) {
+            return;
+        }
+        try {
+            const eventData = JSON.parse(evt.data);
+            const data = cswEventsSchema.parse(eventData);
+            if (data.type === 'init') {
+                this.processMessage(data.data, true);
+                return;
             }
-        });
+            this.processMessage(data, false);
+        }
+        catch (error) {
+            console.error('Error parsing event data:', evt.data, error);
+        }
+    }
+    processMessage(event, isInit) {
+        const listeners = this.listeners[event.type];
+        const list = Object.values(listeners ?? {});
+        list.forEach((listener) => listener(event, isInit));
+    }
+    destroy() {
+        this.isDestroyed = true;
+        if (this.ws) {
+            this.ws.destroy();
+            this.ws = null;
+        }
+        this.listeners = {};
     }
 }
-exports.CamSwitcherEvents = CamSwitcherEvents;