camstreamerlib 4.0.0-beta.80 → 4.0.0-beta.82

package/cjs/CamStreamerAPI.d.ts

@@ -1,6 +1,6 @@
 import { ProxyClient } from './internal/ProxyClient';
 import { IClient, TResponse } from './internal/types';
-import { TStream } from './types/CamStreamerAPI/CamStreamerAPI';
+import { TAudioFile, TAudioFileStorageType, TStream, TStreamList } from './types/CamStreamerAPI/CamStreamerAPI';
 import { THttpRequestOptions, TProxyParams } from './types/common';
 import { TOldStream, TOldStringStream } from './types/CamStreamerAPI/oldStreamSchema';
 export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
@@ -10,21 +10,84 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
     getUtcTime(options?: THttpRequestOptions): Promise<number>;
-    getStreamList(options?: THttpRequestOptions): Promise<Record<number, TStream>>;
+    getStreamList(options?: THttpRequestOptions): Promise<({
+        type: "facebook";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "hls";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "mpeg_dvb";
+        port: number;
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+        ipAddress: string;
+        standard: "DVB" | "ATSC";
+        nullPacketsPaddingEnabled: boolean;
+        nullPacketsPaddingKbps: number;
+        videoPid: number;
+        audioPid: number;
+        mpegtsStreamId: number;
+        pmtPid: number;
+        pcrPid: number;
+        pcrPeriodMs: number;
+        providerName: string;
+        serviceName: string;
+        triggerType: "manual" | "onetime" | "recurrent" | "io" | "nonstop";
+        statusCameraLed: boolean;
+        statusCameraOutput: string;
+        saveToSdCard: boolean;
+    } | {
+        type: "rtmp";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "sd_card";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "windy";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    } | {
+        type: "youtube";
+        enabled: boolean;
+        id: number;
+        active: boolean;
+        title: string;
+    })[]>;
+    setStreamList(streamList: TStreamList['streamList'], options?: THttpRequestOptions): Promise<void>;
     getStream(streamId: number, options?: THttpRequestOptions): Promise<{
         type: "facebook";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "hls";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "mpeg_dvb";
         port: number;
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
         ipAddress: string;
@@ -46,27 +109,46 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
     } | {
         type: "rtmp";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "sd_card";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "windy";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     } | {
         type: "youtube";
         enabled: boolean;
+        id: number;
         active: boolean;
         title: string;
     }>;
     setStream(streamId: number, streamData: Partial<TStream>, options?: THttpRequestOptions): Promise<void>;
     isStreaming(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
-    deleteStream(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
+    listFiles(options?: THttpRequestOptions): Promise<{
+        path: string;
+        name: string;
+        storage: "url" | "flash" | "SD0";
+    }[]>;
+    uploadFile(formData: Parameters<Client['post']>[0]['data'], storage: TAudioFileStorageType, options?: THttpRequestOptions): Promise<void>;
+    removeFile(fileParams: TAudioFile, options?: THttpRequestOptions): Promise<void>;
+    getFileStorage(options?: THttpRequestOptions): Promise<({
+        type: "flash";
+        flash: string;
+    } | {
+        type: "SD0";
+        SD0: string;
+    })[]>;
     private _getJson;
+    private _postJsonEncoded;
+    private _post;
 }
 export declare const parseCameraStreamResponse: (cameraStreamData: TOldStringStream) => TOldStream;

package/cjs/CamStreamerAPI.js

@@ -31,55 +31,81 @@ class CamStreamerAPI {
         return zod_1.z.number().parse(res.data);
     }
     async getStreamList(options) {
-        const res = await this._getJson(`${BASE_PATH}/stream/list.cgi`, undefined, options);
-        const streamList = {};
-        const invalidList = {};
-        for (const [key, value] of Object.entries(res.data)) {
-            const id = parseInt(key);
-            try {
-                const parsed = CamStreamerAPI_1.streamSchema.parse(value);
-                streamList[id] = parsed;
+        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;
             }
-            catch (err) {
-                const oldStream = oldStreamSchema_1.oldStringStreamSchema.parse(value);
-                const parsedOldStream = (0, exports.parseCameraStreamResponse)(oldStream);
-                invalidList[id] = parsedOldStream;
+            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 (Object.keys(invalidList).length > 0) {
-            throw new errors_1.MigrationError(streamList, invalidList);
+        if (oldStreamData.length > 0) {
+            throw new errors_1.MigrationError(newStreamData, oldStreamData);
         }
-        return streamList;
+        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/get.cgi`, { stream_id: streamId }, options);
-        try {
-            return CamStreamerAPI_1.streamSchema.parse(res.data);
-        }
-        catch (err) {
-            const oldStream = oldStreamSchema_1.oldStringStreamSchema.parse(res.data);
-            const parsedOldStream = (0, exports.parseCameraStreamResponse)(oldStream);
-            throw new errors_1.MigrationError({}, { [streamId]: parsedOldStream });
+        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) {
-        const agent = this.getClient(options?.proxyParams);
-        await agent.post({
-            path: `${BASE_PATH}/stream/set.cgi`,
-            data: JSON.stringify(streamData),
-            parameters: {
-                stream_id: streamId,
-            },
-            timeout: options?.timeout,
-        });
+        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 deleteStream(streamId, options) {
-        const res = await this._getJson(`${BASE_PATH}/stream/remove.cgi`, { stream_id: streamId }, options);
-        return res.data.status === 200;
+    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._getJson(`${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 _getJson(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);
@@ -91,6 +117,27 @@ class CamStreamerAPI {
             throw new errors_1.ErrorWithResponse(res);
         }
     }
+    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 _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 errors_1.ErrorWithResponse(res);
+        }
+    }
 }
 exports.CamStreamerAPI = CamStreamerAPI;
 const parseCameraStreamResponse = (cameraStreamData) => {

package/cjs/errors/errors.d.ts

@@ -91,8 +91,12 @@ export declare class BadRequestError<T extends TResponse> extends ErrorWithRespo
     constructor(res: T);
 }
 export declare class MigrationError extends Error {
-    readonly valid: Record<number, TStream>;
-    readonly invalid: Record<number, TOldStream>;
-    constructor(valid: Record<number, TStream>, invalid: Record<number, TOldStream>);
+    readonly valid: TStream[];
+    readonly invalid: (TOldStream & {
+        id: number;
+    })[];
+    constructor(valid: TStream[], invalid: (TOldStream & {
+        id: number;
+    })[]);
 }
 export {};