camstreamerlib 4.0.0-beta.9 → 4.0.0-beta.90

package/cjs/CamStreamerAPI.js

@@ -1,65 +1,192 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamStreamerAPI = void 0;
-const common_1 = require("./internal/common");
-const DefaultClient_1 = require("./node/DefaultClient");
-const CamStreamerAPI_1 = require("./types/CamStreamerAPI");
+exports.parseCameraStreamResponse = exports.CamStreamerAPI = void 0;
+const zod_1 = require("zod");
+const ProxyClient_1 = require("./internal/ProxyClient");
+const CamStreamerAPI_1 = require("./types/CamStreamerAPI/CamStreamerAPI");
+const errors_1 = require("./errors/errors");
+const oldStreamSchema_1 = require("./types/CamStreamerAPI/oldStreamSchema");
+const utils_1 = require("./internal/utils");
+const BASE_PATH = '/local/camstreamer';
 class CamStreamerAPI {
     client;
-    constructor(options = {}) {
-        if ((0, common_1.isClient)(options)) {
-            this.client = options;
+    constructor(client) {
+        this.client = client;
+    }
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    getClient(proxyParams) {
+        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
+    }
+    async wsAuthorization(options) {
+        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
+        if (res.status !== 200) {
+            throw new errors_1.WsAuthorizationError(res.message);
         }
-        else {
-            this.client = new DefaultClient_1.DefaultClient(options);
+        return zod_1.z.string().parse(res.data);
+    }
+    async getUtcTime(options) {
+        const res = await this._getJson(`${BASE_PATH}/get_utc_time.cgi`, undefined, options);
+        if (res.status !== 200) {
+            throw new errors_1.UtcTimeFetchError(res.message);
         }
+        return zod_1.z.number().parse(res.data);
     }
-    async getStreamList() {
-        const streamListRes = await this.get('/local/camstreamer/stream/list.cgi');
-        return CamStreamerAPI_1.streamListSchema.parse(streamListRes.data);
-    }
-    async getStream(streamID) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
-        return CamStreamerAPI_1.streamAttributesSchema.parse(stream.data);
-    }
-    async getStreamParameter(streamID, paramName) {
-        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
-        return stream.data[paramName];
-    }
-    async setStream(streamID, params) {
-        const { streamDelay, startTime, stopTime, ...rest } = params;
-        await this.get('/local/camstreamer/stream/set.cgi', {
-            stream_id: streamID,
-            streamDelay: streamDelay ?? '',
-            startTime: startTime ?? 'null',
-            stopTime: stopTime ?? 'null',
-            ...rest,
-        });
+    async getStreamList(options) {
+        const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get' }, options);
+        const oldStreamListRecord = zod_1.z.record(zod_1.z.string(), oldStreamSchema_1.oldStringStreamSchema).safeParse(res.data);
+        if (oldStreamListRecord.success) {
+            const data = Object.entries(oldStreamListRecord.data).map(([id, streamData]) => ({
+                id: parseInt(id),
+                ...(0, exports.parseCameraStreamResponse)(streamData),
+            }));
+            throw new errors_1.MigrationError([], data);
+        }
+        const newStreamData = [];
+        const oldStreamData = [];
+        for (const streamData of res.data.streamList) {
+            const newStreamParse = CamStreamerAPI_1.streamSchema.safeParse(streamData);
+            if (newStreamParse.success) {
+                newStreamData.push(newStreamParse.data);
+                continue;
+            }
+            const oldStreamParse = oldStreamSchema_1.oldStringStreamSchemaWithId.safeParse(streamData);
+            if (oldStreamParse.success) {
+                oldStreamData.push({
+                    id: parseInt(oldStreamParse.data.id),
+                    ...(0, exports.parseCameraStreamResponse)(oldStreamParse.data),
+                });
+                continue;
+            }
+            throw new Error('Failed to parse some stream entries');
+        }
+        if (oldStreamData.length > 0) {
+            throw new errors_1.MigrationError(newStreamData, oldStreamData);
+        }
+        return newStreamData;
+    }
+    async setStreamList(streamList, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify({ streamList }), {
+            action: 'set',
+        }, options);
+    }
+    async getStream(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get', stream_id: streamId }, options);
+        const newStream = CamStreamerAPI_1.streamSchema.safeParse(res.data);
+        if (newStream.success) {
+            return newStream.data;
+        }
+        const oldStream = oldStreamSchema_1.oldStringStreamSchema.passthrough().parse(res.data);
+        throw new errors_1.MigrationError([], [{ id: streamId, ...(0, exports.parseCameraStreamResponse)(oldStream) }]);
+    }
+    async setStream(streamId, streamData, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, JSON.stringify(streamData), {
+            action: 'set',
+            stream_id: streamId,
+        }, options);
+    }
+    async isStreaming(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);
+        return res.data.is_streaming === 1;
+    }
+    async listFiles(options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_audio.cgi`, { action: 'list' }, options);
+        return CamStreamerAPI_1.audioFileListSchema.parse(res.data);
+    }
+    async uploadFile(formData, storage, options) {
+        await this._post(`${BASE_PATH}/upload_audio.cgi`, formData, {
+            action: 'upload',
+            storage: storage,
+        }, options);
     }
-    async setStreamParameter(streamID, paramName, value) {
-        await this.get(`/local/camstreamer/stream/set.cgi?stream_id=${streamID}&${paramName}=${value}`);
+    async removeFile(fileParams, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/upload_audio.cgi`, { action: 'remove', ...fileParams }, options, undefined);
     }
-    async isStreaming(streamID) {
-        const response = await this.get(`/local/camstreamer/get_streamstat.cgi?stream_id=${streamID}`);
-        return response.data.is_streaming === 1;
+    async getFileStorage(options) {
+        const res = await this._getJson(`${BASE_PATH}/upload_audio.cgi`, { action: 'get_storage' }, options);
+        return CamStreamerAPI_1.storageListSchema.parse(res.data);
     }
-    async deleteStream(streamID) {
-        await this.get('/local/camstreamer/stream/remove.cgi', { stream_id: streamID });
+    async getFileFromCamera(path, options) {
+        return await this._getBlob(`${BASE_PATH}/audio.cgi`, { path }, options);
     }
-    wsAutoratization() {
-        return this.get('/local/camstreamer/ws_authorization.cgi');
+    async _getJson(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new errors_1.ErrorWithResponse(res);
+        }
     }
-    async getUtcTime() {
-        return await this.get('/local/camstreamer/get_utc_time.cgi');
+    async _getBlob(path, parameters, options) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.get({ path, parameters, timeout: options?.timeout });
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new errors_1.ErrorWithResponse(res);
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new errors_1.ParsingBlobError(err);
+        }
+    }
+    async _postUrlEncoded(path, parameters, options, headers) {
+        const data = (0, utils_1.paramToUrl)(parameters);
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        return this._post(path, data, undefined, options, { ...baseHeaders, ...headers });
+    }
+    async _postJsonEncoded(path, data, parameters, options, headers) {
+        const agent = this.getClient(options?.proxyParams);
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        return agent.post({
+            path,
+            data,
+            parameters,
+            timeout: options?.timeout,
+            headers: { ...baseHeaders, ...headers },
+        });
     }
-    async get(path, parameters) {
-        const res = await this.client.get(path, parameters);
+    async _post(path, data, parameters, options, headers) {
+        const agent = this.getClient(options?.proxyParams);
+        const res = await agent.post({ path, data, parameters, headers, timeout: options?.timeout });
         if (res.ok) {
             return await res.json();
         }
         else {
-            throw new Error(await (0, common_1.responseStringify)(res));
+            throw new errors_1.ErrorWithResponse(res);
         }
     }
 }
 exports.CamStreamerAPI = CamStreamerAPI;
+const parseCameraStreamResponse = (cameraStreamData) => {
+    return {
+        enabled: parseInt(cameraStreamData.enabled),
+        active: parseInt(cameraStreamData.active),
+        audioSource: cameraStreamData.audioSource,
+        avSyncMsec: parseInt(cameraStreamData.avSyncMsec),
+        internalVapixParameters: cameraStreamData.internalVapixParameters,
+        userVapixParameters: cameraStreamData.userVapixParameters,
+        outputParameters: cameraStreamData.outputParameters,
+        outputType: cameraStreamData.outputType,
+        mediaServerUrl: cameraStreamData.mediaServerUrl,
+        inputType: cameraStreamData.inputType,
+        inputUrl: cameraStreamData.inputUrl,
+        forceStereo: parseInt(cameraStreamData.forceStereo),
+        streamDelay: isNaN(parseInt(cameraStreamData.streamDelay)) ? null : parseInt(cameraStreamData.streamDelay),
+        statusLed: parseInt(cameraStreamData.statusLed),
+        statusPort: cameraStreamData.statusPort,
+        callApi: parseInt(cameraStreamData.callApi),
+        trigger: cameraStreamData.trigger,
+        schedule: cameraStreamData.schedule,
+        prepareAhead: parseInt(cameraStreamData.prepareAhead),
+        startTime: isNaN(parseInt(cameraStreamData.startTime)) ? null : parseInt(cameraStreamData.startTime),
+        stopTime: isNaN(parseInt(cameraStreamData.stopTime)) ? null : parseInt(cameraStreamData.stopTime),
+    };
+};
+exports.parseCameraStreamResponse = parseCameraStreamResponse;

package/cjs/CamSwitcherAPI.d.ts

@@ -1,52 +1,167 @@
-import { IClient } from './internal/common';
-import { TAudioPushInfo, TOutputInfo, TStorageInfo, TStreamSaveList, TClipList, TStreamSaveLoadList, TClipSaveLoadList, TPlaylistSaveLoadList, TTrackerSaveList, TrackerSaveLoadList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
-import { TAudioChannel, TNetworkCamera, TStorageType } from './types/common';
-export declare class CamSwitcherAPI<Client extends IClient = IClient> {
-    client: Client;
+import { IClient, TResponse } from './internal/types';
+import { TStreamSaveList, TTrackerSaveList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
+import { TAudioChannel, THttpRequestOptions, TProxyParams, TStorageType } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
+    private client;
     private CustomFormData;
     private vapixAgent;
     constructor(client: Client, CustomFormData?: {
         new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
         prototype: FormData;
     });
-    static getProxyUrlPath: () => string;
-    static getWsEventsUrlPath: () => string;
-    static getClipPreviewUrlPath: (id: string, storage: TStorageType) => string;
-    generateSilence(sampleRate: number, channels: TAudioChannel): Promise<void>;
-    checkCameraTime(): Promise<boolean>;
-    getIpListFromNetworkCheck(): Promise<TNetworkCamera[]>;
-    getMaxFps(source: number): Promise<number>;
-    getStorageInfo(): Promise<TStorageInfo[]>;
-    wsAuthorization(): Promise<string>;
-    getOutputInfo(): Promise<TOutputInfo>;
-    getAudioPushInfo(): Promise<TAudioPushInfo>;
-    getStreamSaveList(): Promise<TStreamSaveLoadList>;
-    getClipSaveList(): Promise<TClipSaveLoadList>;
-    getPlaylistSaveList(): Promise<TPlaylistSaveLoadList>;
-    getTrackerSaveList(): Promise<TrackerSaveLoadList>;
-    setStreamSaveList(data: TStreamSaveList): Promise<boolean>;
-    setClipSaveList(data: TClipSaveList): Promise<boolean>;
-    setPlaylistSaveList(data: TPlaylistSaveList): Promise<boolean>;
-    setTrackerSaveList(data: TTrackerSaveList): Promise<boolean>;
-    playlistSwitch(playlistName: string): Promise<void>;
-    playlistQueuePush(playlistName: string): Promise<void>;
-    playlistQueueClear(): Promise<void>;
-    playlistQueueList(): Promise<string[]>;
-    playlistQueuePlayNext(): Promise<void>;
-    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string): Promise<void>;
-    removeClip(id: string, storage: TStorageType): Promise<any>;
-    getClipList(): Promise<TClipList>;
-    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string): Promise<boolean>;
-    setGlobalAudioSettings(settings: TGlobalAudioSettings): Promise<boolean>;
-    setSecondaryAudioSettings(settings: TSecondaryAudioSettings): Promise<boolean>;
-    setDefaultPlaylist(id: string): Promise<boolean>;
-    setPermanentRtspUrlToken(token: string): Promise<boolean>;
-    getCamSwitchOptions(): Promise<Partial<TCameraOptions>>;
-    getGlobalAudioSettings(): Promise<TGlobalAudioSettings>;
-    getSecondaryAudioSettings(): Promise<TSecondaryAudioSettings>;
-    getPermanentRtspUrlToken(): Promise<string>;
-    private get;
-    private set;
+    static getProxyPath: () => string;
+    static getWsEventsPath: () => string;
+    static getClipPreviewPath: (clipId: string, storage: TStorageType) => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    getNetworkCameraList(options?: THttpRequestOptions): Promise<{
+        name: string;
+        ip: string;
+    }[]>;
+    generateSilence(sampleRate: number, channels: TAudioChannel, options?: THttpRequestOptions): Promise<void>;
+    getMaxFps(source: number, options?: THttpRequestOptions): Promise<number>;
+    getStorageInfo(options?: THttpRequestOptions): Promise<{
+        storage: "FLASH" | "SD_DISK";
+        writable: boolean;
+        size: number;
+        available: number;
+    }[]>;
+    wsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getOutputInfo(options?: THttpRequestOptions): Promise<{
+        rtspUrl: string;
+        ws: string;
+        wsInitialMessage: string;
+    }>;
+    getAudioPushInfo(options?: THttpRequestOptions): Promise<{
+        ws: string;
+        wsInitialMessage: string;
+    }>;
+    getStreamSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        ip?: string | undefined;
+        niceName?: string | undefined;
+        mdnsName?: string | undefined;
+        port?: number | undefined;
+        enabled?: boolean | undefined;
+        auth?: string | undefined;
+        query?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        viewNumber?: number | undefined;
+    }>>;
+    getClipSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        niceName?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+    }>>;
+    getPlaylistSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        niceName?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        isFavourite?: boolean | undefined;
+        sortIndexFavourite?: number | undefined;
+        play_type?: "PLAY_ALL" | "PLAY_ALL_LOOP" | "PLAY_ALL_SHUFFLED" | "PLAY_ALL_LOOP_SHUFFLED" | "PLAY_ONE_RANDOM" | undefined;
+        default?: boolean | undefined;
+        stream_list?: {
+            repeat: number;
+            video: {
+                storage?: "FLASH" | "SD_DISK" | undefined;
+                stream_name?: string | undefined;
+                clip_name?: string | undefined;
+                tracker_name?: string | undefined;
+            };
+            id: string;
+            isTimeoutCustom: boolean;
+            ptz_preset_pos_name: string;
+            timeout: number;
+            audio?: {
+                storage?: "FLASH" | "SD_DISK" | undefined;
+                stream_name?: string | undefined;
+                clip_name?: string | undefined;
+                tracker_name?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+    }>>;
+    getTrackerSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        name?: string | undefined;
+        channel?: "audio" | "video" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        viewNumber?: number | undefined;
+        id?: string | undefined;
+        previewId?: string | undefined;
+        duration?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        fps?: number | undefined;
+        motion_history_frames?: number | undefined;
+        include_zone?: number[][] | undefined;
+        include_node_ids?: string[] | undefined;
+        camera_list?: {
+            name: string;
+            id: string;
+            overview: boolean;
+            zone: number[];
+            playlist_name: string;
+            ptz_preset_pos_no: number;
+        }[] | undefined;
+        camera_view_number?: number | undefined;
+    }>>;
+    setStreamSaveList(data: TStreamSaveList, options?: THttpRequestOptions): Promise<void>;
+    setClipSaveList(data: TClipSaveList, options?: THttpRequestOptions): Promise<void>;
+    setPlaylistSaveList(data: TPlaylistSaveList, options?: THttpRequestOptions): Promise<void>;
+    setTrackerSaveList(data: TTrackerSaveList, options?: THttpRequestOptions): Promise<void>;
+    playlistSwitch(playlistName: string, options?: THttpRequestOptions): Promise<void>;
+    playlistQueuePush(playlistName: string, options?: THttpRequestOptions): Promise<void>;
+    playlistQueueClear(options?: THttpRequestOptions): Promise<void>;
+    playlistQueueList(options?: THttpRequestOptions): Promise<string[]>;
+    playlistQueuePlayNext(options?: THttpRequestOptions): Promise<void>;
+    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, clipId: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
+    removeClip(clipId: string, storage: TStorageType, options?: THttpRequestOptions): Promise<void>;
+    getClipList(options?: THttpRequestOptions): Promise<Record<string, {
+        storage: "FLASH" | "SD_DISK";
+        stream_list: ({
+            type: "video";
+            width: number;
+            height: number;
+            fps: number;
+            sample_rate: number;
+            h264_profile: "high" | "main" | "baseline";
+            h264_level: "4.1";
+            gop: number;
+            bitrate: number;
+        } | {
+            type: "audio";
+            sample_rate: number;
+            channel_count: 1 | 2;
+        })[];
+        duration: number;
+    }>>;
+    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<void>;
+    setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<void>;
+    setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<void>;
+    setDefaultPlaylist(playlistId: string, options?: THttpRequestOptions): Promise<void>;
+    setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<void>;
+    getCamSwitchOptions(options?: THttpRequestOptions): Promise<any>;
+    getGlobalAudioSettings(options?: THttpRequestOptions): Promise<{
+        type: "fromSource" | "source";
+        source: string;
+        storage?: string | undefined;
+    }>;
+    getSecondaryAudioSettings(options?: THttpRequestOptions): Promise<{
+        type: "CLIP" | "STREAM" | "NONE";
+        storage: "FLASH" | "SD_DISK";
+        secondaryAudioLevel: number;
+        masterAudioLevel: number;
+        streamName?: string | undefined;
+        clipName?: string | undefined;
+    }>;
+    getPermanentRtspUrlToken(options?: THttpRequestOptions): Promise<string>;
+    private _getJson;
+    private _post;
     private setParamFromCameraJSON;
     private getParamFromCameraAndJSONParse;
 }