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

package/cjs/types/CamStreamerAPI/oldStreamSchema.d.ts

@@ -66,6 +66,77 @@ export declare const oldStringStreamSchema: z.ZodObject<{
     startTime: string;
     stopTime: string;
 }>;
+export declare const oldStringStreamSchemaWithId: z.ZodObject<{
+    enabled: z.ZodString;
+    active: z.ZodString;
+    audioSource: z.ZodString;
+    avSyncMsec: z.ZodString;
+    internalVapixParameters: z.ZodString;
+    userVapixParameters: z.ZodString;
+    outputParameters: z.ZodString;
+    outputType: z.ZodString;
+    mediaServerUrl: z.ZodString;
+    inputType: z.ZodString;
+    inputUrl: z.ZodString;
+    forceStereo: z.ZodString;
+    streamDelay: z.ZodString;
+    statusLed: z.ZodString;
+    statusPort: z.ZodString;
+    callApi: z.ZodString;
+    trigger: z.ZodString;
+    schedule: z.ZodString;
+    prepareAhead: z.ZodString;
+    startTime: z.ZodString;
+    stopTime: z.ZodString;
+} & {
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    enabled: string;
+    id: string;
+    active: string;
+    audioSource: string;
+    avSyncMsec: string;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: string;
+    mediaServerUrl: string;
+    inputType: string;
+    inputUrl: string;
+    forceStereo: string;
+    streamDelay: string;
+    statusLed: string;
+    statusPort: string;
+    callApi: string;
+    trigger: string;
+    schedule: string;
+    prepareAhead: string;
+    startTime: string;
+    stopTime: string;
+}, {
+    enabled: string;
+    id: string;
+    active: string;
+    audioSource: string;
+    avSyncMsec: string;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: string;
+    mediaServerUrl: string;
+    inputType: string;
+    inputUrl: string;
+    forceStereo: string;
+    streamDelay: string;
+    statusLed: string;
+    statusPort: string;
+    callApi: string;
+    trigger: string;
+    schedule: string;
+    prepareAhead: string;
+    startTime: string;
+    stopTime: string;
+}>;
 export type TOldStringStream = z.infer<typeof oldStringStreamSchema>;
 export declare const oldStreamSchema: z.ZodObject<{
     enabled: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;

package/cjs/types/CamStreamerAPI/oldStreamSchema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.oldStreamSchema = exports.oldStringStreamSchema = void 0;
+exports.oldStreamSchema = exports.oldStringStreamSchemaWithId = exports.oldStringStreamSchema = void 0;
 const zod_1 = require("zod");
 exports.oldStringStreamSchema = zod_1.z.object({
     enabled: zod_1.z.string(),
@@ -25,6 +25,9 @@ exports.oldStringStreamSchema = zod_1.z.object({
     startTime: zod_1.z.string(),
     stopTime: zod_1.z.string(),
 });
+exports.oldStringStreamSchemaWithId = exports.oldStringStreamSchema.extend({
+    id: zod_1.z.string(),
+});
 exports.oldStreamSchema = zod_1.z.object({
     enabled: zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]),
     active: zod_1.z.union([zod_1.z.literal(0), zod_1.z.literal(1)]),

package/cjs/types/CamStreamerAPI/rtmpSchema.d.ts

@@ -1,5 +1,6 @@
 import z from 'zod';
 export declare const rtmpSchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
@@ -8,11 +9,13 @@ export declare const rtmpSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "rtmp";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     type: "rtmp";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/cjs/types/CamStreamerAPI/sdCardSchema.d.ts

@@ -1,5 +1,6 @@
 import z from 'zod';
 export declare const sdCardSchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
@@ -8,11 +9,13 @@ export declare const sdCardSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "sd_card";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     type: "sd_card";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/cjs/types/CamStreamerAPI/streamCommonTypes.d.ts

@@ -2,15 +2,18 @@ import { z } from 'zod';
 export declare const streamTypeSchema: z.ZodUnion<[z.ZodLiteral<"youtube">, z.ZodLiteral<"facebook">, z.ZodLiteral<"sd_card">, z.ZodLiteral<"windy">, z.ZodLiteral<"mpeg_dvb">, z.ZodLiteral<"hls">, z.ZodLiteral<"rtmp">]>;
 export type TStreamType = z.infer<typeof streamTypeSchema>;
 export declare const streamCommonSchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/cjs/types/CamStreamerAPI/streamCommonTypes.js

@@ -12,6 +12,7 @@ exports.streamTypeSchema = zod_1.z.union([
     zod_1.z.literal('rtmp'),
 ]);
 exports.streamCommonSchema = zod_1.z.object({
+    id: zod_1.z.number(),
     enabled: zod_1.z.boolean(),
     active: zod_1.z.boolean(),
     title: zod_1.z.string(),

package/cjs/types/CamStreamerAPI/windySchema.d.ts

@@ -1,5 +1,6 @@
 import z from 'zod';
 export declare const windySchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
@@ -8,11 +9,13 @@ export declare const windySchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "windy";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     type: "windy";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/cjs/types/CamStreamerAPI/youtubeSchema.d.ts

@@ -1,5 +1,6 @@
 import z from 'zod';
 export declare const youtubeSchema: z.ZodObject<{
+    id: z.ZodNumber;
     enabled: z.ZodBoolean;
     active: z.ZodBoolean;
     title: z.ZodString;
@@ -8,11 +9,13 @@ export declare const youtubeSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: "youtube";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }, {
     type: "youtube";
     enabled: boolean;
+    id: number;
     active: boolean;
     title: string;
 }>;

package/esm/CamStreamerAPI.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import { ProxyClient } from './internal/ProxyClient';
-import { streamSchema } from './types/CamStreamerAPI/CamStreamerAPI';
+import { audioFileListSchema, storageListSchema, streamSchema, } from './types/CamStreamerAPI/CamStreamerAPI';
 import { ErrorWithResponse, UtcTimeFetchError, WsAuthorizationError, MigrationError } from './errors/errors';
-import { oldStringStreamSchema } from './types/CamStreamerAPI/oldStreamSchema';
+import { oldStringStreamSchema, oldStringStreamSchemaWithId, } from './types/CamStreamerAPI/oldStreamSchema';
 const BASE_PATH = '/local/camstreamer';
 export class CamStreamerAPI {
     client;
@@ -28,55 +28,81 @@ export class CamStreamerAPI {
         return 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 = streamSchema.parse(value);
-                streamList[id] = parsed;
+        const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get' }, options);
+        const oldStreamListRecord = z.record(z.string(), oldStringStreamSchema).safeParse(res.data);
+        if (oldStreamListRecord.success) {
+            const data = Object.entries(oldStreamListRecord.data).map(([id, streamData]) => ({
+                id: parseInt(id),
+                ...parseCameraStreamResponse(streamData),
+            }));
+            throw new MigrationError([], data);
+        }
+        const newStreamData = [];
+        const oldStreamData = [];
+        for (const streamData of res.data.streamList) {
+            const newStreamParse = streamSchema.safeParse(streamData);
+            if (newStreamParse.success) {
+                newStreamData.push(newStreamParse.data);
+                continue;
             }
-            catch (err) {
-                const oldStream = oldStringStreamSchema.parse(value);
-                const parsedOldStream = parseCameraStreamResponse(oldStream);
-                invalidList[id] = parsedOldStream;
+            const oldStreamParse = oldStringStreamSchemaWithId.safeParse(streamData);
+            if (oldStreamParse.success) {
+                oldStreamData.push({
+                    id: parseInt(oldStreamParse.data.id),
+                    ...parseCameraStreamResponse(oldStreamParse.data),
+                });
+                continue;
             }
+            throw new Error('Failed to parse some stream entries');
         }
-        if (Object.keys(invalidList).length > 0) {
-            throw new MigrationError(streamList, invalidList);
+        if (oldStreamData.length > 0) {
+            throw new 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 streamSchema.parse(res.data);
-        }
-        catch (err) {
-            const oldStream = oldStringStreamSchema.parse(res.data);
-            const parsedOldStream = parseCameraStreamResponse(oldStream);
-            throw new MigrationError({}, { [streamId]: parsedOldStream });
+        const res = await this._getJson(`${BASE_PATH}/stream_list.cgi`, { action: 'get', stream_id: streamId }, options);
+        const newStream = streamSchema.safeParse(res.data);
+        if (newStream.success) {
+            return newStream.data;
         }
+        const oldStream = oldStringStreamSchema.passthrough().parse(res.data);
+        throw new MigrationError([], [{ id: streamId, ...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 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 storageListSchema.parse(res.data);
     }
     async _getJson(path, parameters, options) {
         const agent = this.getClient(options?.proxyParams);
@@ -88,6 +114,27 @@ export class CamStreamerAPI {
             throw new 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 ErrorWithResponse(res);
+        }
+    }
 }
 export const parseCameraStreamResponse = (cameraStreamData) => {
     return {

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -15,6 +15,7 @@ export const streamSchema = z.discriminatedUnion('type', [
     windySchema,
     youtubeSchema,
 ]);
+export const streamListSchema = z.object({ streamList: z.array(streamSchema) });
 export const isFacebookStream = (stream) => {
     return stream.type === 'facebook';
 };
@@ -36,3 +37,29 @@ export const isWindyStream = (stream) => {
 export const isYouTubeStream = (stream) => {
     return stream.type === 'youtube';
 };
+export var AudioType;
+(function (AudioType) {
+    AudioType[AudioType["MP3"] = 0] = "MP3";
+    AudioType[AudioType["AAC"] = 1] = "AAC";
+})(AudioType || (AudioType = {}));
+export const audioFileStorageTypeSchema = z.union([z.literal('flash'), z.literal('SD0'), z.literal('url')]);
+export const storageListSchema = z.array(z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('flash'),
+        flash: z.string(),
+    }),
+    z.object({
+        type: z.literal('SD0'),
+        SD0: z.string(),
+    }),
+]));
+export const audioFileSchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    storage: audioFileStorageTypeSchema,
+});
+export const audioFileListSchema = z.array(audioFileSchema);
+export const audioFileDataSchema = z.object({
+    code: z.number(),
+    list: audioFileListSchema,
+});

package/esm/types/CamStreamerAPI/oldStreamSchema.js

@@ -22,6 +22,9 @@ export const oldStringStreamSchema = z.object({
     startTime: z.string(),
     stopTime: z.string(),
 });
+export const oldStringStreamSchemaWithId = oldStringStreamSchema.extend({
+    id: z.string(),
+});
 export const oldStreamSchema = z.object({
     enabled: z.union([z.literal(0), z.literal(1)]),
     active: z.union([z.literal(0), z.literal(1)]),

package/esm/types/CamStreamerAPI/streamCommonTypes.js

@@ -9,6 +9,7 @@ export const streamTypeSchema = z.union([
     z.literal('rtmp'),
 ]);
 export const streamCommonSchema = z.object({
+    id: z.number(),
     enabled: z.boolean(),
     active: z.boolean(),
     title: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.80",
+    "version": "4.0.0-beta.82",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {

package/types/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/types/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 {};