camstreamerlib 4.0.0-beta.13 → 4.0.0-beta.130

package/cjs/CamStreamerAPI.js

@@ -1,59 +1,158 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamStreamerAPI = void 0;
-const utils_1 = require("./internal/utils");
-const CamStreamerAPI_1 = require("./types/CamStreamerAPI");
-class CamStreamerAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    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 setStreamParameter(streamID, paramName, value) {
-        await this.get(`/local/camstreamer/stream/set.cgi?stream_id=${streamID}&${paramName}=${value}`);
-    }
-    async isStreaming(streamID) {
-        const response = await this.get(`/local/camstreamer/get_streamstat.cgi?stream_id=${streamID}`);
-        return response.data.is_streaming === 1;
-    }
-    async deleteStream(streamID) {
-        await this.get('/local/camstreamer/stream/remove.cgi', { stream_id: streamID });
-    }
-    wsAutoratization() {
-        return this.get('/local/camstreamer/ws_authorization.cgi');
-    }
-    async getUtcTime() {
-        return await this.get('/local/camstreamer/get_utc_time.cgi');
-    }
-    async get(path, parameters) {
-        const res = await this.client.get(path, parameters);
-        if (res.ok) {
-            return await res.json();
+exports.parseCameraStreamResponse = exports.CamStreamerAPI = void 0;
+const zod_1 = require("zod");
+const CamStreamerAPI_1 = require("./types/CamStreamerAPI/CamStreamerAPI");
+const errors_1 = require("./errors/errors");
+const oldStreamSchema_1 = require("./types/CamStreamerAPI/oldStreamSchema");
+const BasicAPI_1 = require("./internal/BasicAPI");
+const BASE_PATH = '/local/camstreamer';
+class CamStreamerAPI extends BasicAPI_1.BasicAPI {
+    static getProxyPath = () => `${BASE_PATH}/proxy.cgi`;
+    static getWsEventsPath = () => `${BASE_PATH}/events`;
+    async checkAPIAvailable(options) {
+        await this._getJson(`${BASE_PATH}/api_check.cgi`, undefined, options);
+    }
+    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);
+        }
+        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 getMaxFps(source = 0, options) {
+        return await this._getJson(`${BASE_PATH}/get_max_framerate.cgi`, { video_source: source.toString() }, options);
+    }
+    async isCSPassValid(pass, options) {
+        const res = await this._getJson(`${BASE_PATH}/check_pass.cgi`, { pass }, options);
+        return res.data === '1';
+    }
+    async getCamStreamerAppLog(options) {
+        return await this._getText(`${BASE_PATH}/view_log.cgi`, undefined, options);
+    }
+    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(([streamId, streamData]) => ({
+                streamId,
+                ...(0, exports.parseCameraStreamResponse)(streamData),
+            }));
+            throw new errors_1.MigrationError([], data);
+        }
+        const newStreamData = [];
+        const oldStreamData = [];
+        const invalidStreamData = [];
+        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({
+                    streamId: oldStreamParse.data.streamId,
+                    ...(0, exports.parseCameraStreamResponse)(oldStreamParse.data),
+                });
+                continue;
+            }
+            invalidStreamData.push(streamData);
         }
-        else {
-            throw new Error(await (0, utils_1.responseStringify)(res));
+        if (oldStreamData.length > 0 || invalidStreamData.length > 0) {
+            throw new errors_1.MigrationError(newStreamData, oldStreamData, invalidStreamData);
+        }
+        return newStreamData;
+    }
+    async setStreamList(streamList, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, { 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([], [{ streamId, ...(0, exports.parseCameraStreamResponse)(oldStream) }]);
+    }
+    async setStream(streamId, streamData, options) {
+        await this._postJsonEncoded(`${BASE_PATH}/stream_list.cgi`, streamData, {
+            action: 'set',
+            stream_id: streamId,
+        }, options);
+    }
+    async getStreamNetworkStatistics(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);
+        return CamStreamerAPI_1.streamStatsSchema.parse(res.data);
+    }
+    async getSrtStreamStatistics(streamId, options) {
+        const res = await this._getJson(`${BASE_PATH}/srt_statistics.cgi`, { stream_id: streamId }, options);
+        return CamStreamerAPI_1.srtStreamStatisticsSchema.parse(res.data);
+    }
+    async setStreamEnabled(streamId, enabled, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/set_stream_enabled.cgi`, { stream_id: streamId, enabled: enabled ? 1 : 0 }, options);
+    }
+    async setStreamActive(streamId, active, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/set_stream_active.cgi`, { stream_id: streamId, active: active ? 1 : 0 }, options);
+    }
+    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 removeFile(fileParams, options) {
+        await this._postUrlEncoded(`${BASE_PATH}/upload_audio.cgi`, { action: 'remove', ...fileParams }, options);
+    }
+    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 getFileFromCamera(path, options) {
+        return await this._getBlob(`${BASE_PATH}/audio.cgi`, { path }, options);
+    }
+    downloadReport(options) {
+        return this._getText(`${BASE_PATH}/report.cgi`, undefined, options);
     }
 }
 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,165 @@
 import { IClient, TResponse } from './internal/types';
-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<TResponse> = IClient<TResponse>> {
-    client: Client;
+import { TStreamSaveList, TTrackerSaveList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
+import { TAudioChannel, THttpRequestOptions, TStorageType } from './types/common';
+import { BasicAPI } from './internal/BasicAPI';
+export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> extends BasicAPI<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;
+    checkAPIAvailable(options?: THttpRequestOptions): Promise<void>;
+    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<{
+        size: number;
+        storage: "FLASH" | "SD_DISK";
+        writable: boolean;
+        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;
+        enabled?: boolean | undefined;
+        port?: number | undefined;
+        niceName?: string | undefined;
+        mdnsName?: string | undefined;
+        auth?: string | undefined;
+        query?: string | undefined;
+        channel?: "video" | "audio" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        viewNumber?: number | undefined;
+    }>>;
+    getClipSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        niceName?: string | undefined;
+        channel?: "video" | "audio" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+    }>>;
+    getPlaylistSaveList(options?: THttpRequestOptions): Promise<Record<string, {
+        niceName?: string | undefined;
+        channel?: "video" | "audio" | "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;
+        fps?: number | undefined;
+        id?: string | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        duration?: number | undefined;
+        channel?: "video" | "audio" | "av" | undefined;
+        keyboard?: Record<string, string | null> | undefined;
+        sortIndexOverview?: number | undefined;
+        viewNumber?: number | undefined;
+        previewId?: string | 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";
+        duration: number;
+        stream_list: ({
+            type: "video";
+            fps: number;
+            width: number;
+            height: 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;
+        })[];
+    }>>;
+    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: "source" | "fromSource";
+        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>;
+    downloadReport(options?: THttpRequestOptions): Promise<string>;
     private setParamFromCameraJSON;
     private getParamFromCameraAndJSONParse;
 }