camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.20

package/{types → esm/types}/VapixAPI.js

@@ -19,15 +19,8 @@ export const APP_IDS = [
     'CamScripter',
     'PlaneTracker',
     'Ndihxplugin',
+    'SportTracker',
 ];
-export const applicationListSchema = z.object({
-    reply: z.object({
-        $: z.object({ result: z.string() }),
-        application: z.array(z.object({
-            $: applicationSchema,
-        })),
-    }),
-});
 export const guardTourSchema = z.object({
     id: z.string(),
     camNbr: z.unknown(),
@@ -67,7 +60,7 @@ export const audioDeviceSignalingChannelTypeSchema = z.object({
 });
 export const audioDeviceSignalingTypeSchema = z.object({
     id: z.string(),
-    powerType: z.string(),
+    powerType: z.string().optional(),
     channels: z.array(audioDeviceSignalingChannelTypeSchema),
 });
 export const audioDeviceConnectionTypeSchema = z.object({
@@ -94,15 +87,19 @@ const audioDeviceFromRequestSchema = z.object({
     inputs: z.array(audioDeviceInputOutputSchema).optional(),
     outputs: z.array(audioDeviceInputOutputSchema).optional(),
 });
-export const audioDeviceRequestSchema = z.object({ devices: z.array(audioDeviceFromRequestSchema) });
+export const audioDeviceRequestSchema = z.object({
+    data: z.object({ devices: z.array(audioDeviceFromRequestSchema) }),
+});
 export const maxFpsResponseSchema = z.object({
-    data: z.array(z.object({
+    data: z
+        .array(z.object({
         channel: z.number(),
         captureMode: z.array(z.object({
             enabled: z.boolean(),
             maxFPS: z.number().optional(),
         })),
-    })),
+    }))
+        .optional(),
 });
 export const dateTimeinfoSchema = z.object({
     data: z.object({
@@ -110,20 +107,30 @@ export const dateTimeinfoSchema = z.object({
         dstEnabled: z.boolean(),
         localDateTime: z.string(),
         posixTimeZone: z.string(),
-        timeZone: z.string(),
+        timeZone: z.string().optional(),
     }),
 });
+export const timeZoneSchema = z.discriminatedUnion('status', [
+    z.object({
+        status: z.literal('success'),
+        data: z.object({
+            activeTimeZone: z.string(),
+        }),
+    }),
+    z.object({
+        status: z.literal('error'),
+        error: z.object({
+            message: z.string(),
+        }),
+    }),
+]);
 export const audioSampleRatesResponseSchema = z.object({
     data: z.object({
-        encoders: z.union([
-            z.object({
-                aac: z.array(audioSampleRatesSchema),
-                AAC: z.undefined(),
-            }),
-            z.object({
-                AAC: z.array(audioSampleRatesSchema),
-                aac: z.undefined(),
-            }),
-        ]),
+        encoders: z
+            .object({
+            aac: z.array(audioSampleRatesSchema),
+            AAC: z.array(audioSampleRatesSchema),
+        })
+            .partial(),
     }),
 });

package/esm/types/common.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const audioChannelSchema: z.ZodUnion<[z.ZodLiteral<"mono">, z.ZodLiteral<"stereo">]>;
+export type TAudioChannel = z.infer<typeof audioChannelSchema>;
+export declare const audioChannelCountSchema: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+export type TAudioChannelCount = z.infer<typeof audioChannelCountSchema>;
+export declare const h264ProfileSchema: z.ZodUnion<[z.ZodLiteral<"high">, z.ZodLiteral<"main">, z.ZodLiteral<"baseline">]>;
+export type TH264Profile = z.infer<typeof h264ProfileSchema>;
+export declare const storageTypeSchema: z.ZodUnion<[z.ZodLiteral<"SD_DISK">, z.ZodLiteral<"FLASH">]>;
+export type TStorageType = z.infer<typeof storageTypeSchema>;
+export declare const networkCameraListSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    ip: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    ip: string;
+}, {
+    name: string;
+    ip: string;
+}>, "many">;
+export type TNetworkCamera = z.infer<typeof networkCameraListSchema>[number];
+export declare const keyboardShortcutSchema: z.ZodNullable<z.ZodString>;
+export declare const keyboardShortcutsSchema: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+export type TKeyboardShortcut = z.infer<typeof keyboardShortcutSchema>;
+export type TKeyboardShortcuts = z.infer<typeof keyboardShortcutsSchema>;
+export type TProxyParam = {
+    ip: string;
+    mdnsName: string;
+    port: number;
+    user: string;
+    pass: string;
+} | null;
+export type TCameraImageConfig = {
+    camera?: string;
+    resolution?: string;
+    compression?: number;
+    overlays?: 'off';
+};

package/esm/web/DefaultClient.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { IClient } from '../internal/types';
+export declare class DefaultClient implements IClient<Response> {
+    get: (url: string, parameters?: import("../internal/types").TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<Response>;
+    post: (url: string, data: string | Buffer | FormData, parameters?: import("../internal/types").TParameters | undefined, headers?: Record<string, string> | undefined) => Promise<Response>;
+}

package/{web → esm/web}/DefaultClient.js

@@ -1,16 +1,18 @@
 import { addParametersToPath } from '../internal/utils';
 export class DefaultClient {
-    get(url, parameters, headers) {
+    get = (...params) => {
+        const [url, parameters, headers] = params;
         return fetch(addParametersToPath(url, parameters), {
             method: 'GET',
             headers: headers,
         });
-    }
-    post(url, data, parameters, headers) {
+    };
+    post = (...params) => {
+        const [url, data, parameters, headers] = params;
         return fetch(addParametersToPath(url, parameters), {
             method: 'POST',
             body: data,
             headers: headers,
         });
-    }
+    };
 }

package/esm/web/WsClient.d.ts

@@ -0,0 +1,13 @@
+export declare class WsClient {
+    private getUrl;
+    private getAuthToken;
+    isDestroyed: boolean;
+    private ws;
+    private restartTimeout;
+    constructor(getUrl: () => string, getAuthToken: () => Promise<string>);
+    init(): void;
+    send: (msg: string) => void;
+    onmessage: (_: MessageEvent) => void;
+    destroy: () => void;
+    private destroyWebsocket;
+}

package/{web → esm/web}/WsClient.js

@@ -27,7 +27,7 @@ export class WsClient {
         };
         ws.onmessage = (e) => this.onmessage(e);
         ws.onclose = () => {
-            this.restartTimeout = setTimeout(() => this.init(), REFRESH_TIMEOUT);
+            this.restartTimeout = window.setTimeout(() => this.init(), REFRESH_TIMEOUT);
         };
         this.ws = ws;
     }
@@ -40,7 +40,7 @@ export class WsClient {
         this.destroyWebsocket();
     };
     destroyWebsocket() {
-        if (this.restartTimeout) {
+        if (this.restartTimeout !== null) {
             clearTimeout(this.restartTimeout);
             this.restartTimeout = null;
         }

package/esm/web/index.d.ts

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';

package/esm/web/index.js

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';

package/package.json

@@ -1,18 +1,17 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.2",
+    "version": "4.0.0-beta.20",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
-    "type": "module",
     "dependencies": {
         "adm-zip": "^0.5.9",
         "eventemitter2": "^5.0.1",
+        "fast-xml-parser": "^5.2.5",
         "lodash": "^4.17.21",
         "prettify-xml": "^1.2.0",
         "type-fest": "^4.41.0",
         "undici": "^6.21.3",
         "ws": "^8.18.0",
-        "xml2js": "^0.5.0",
         "zod": "^3.24.3"
     },
     "engine": {
@@ -26,7 +25,6 @@
         "@types/lodash": "^4.17.18",
         "@types/node": "^18.19.39",
         "@types/ws": "^8.5.10",
-        "@types/xml2js": "^0.4.14",
         "@typescript-eslint/eslint-plugin": "^6.8.0",
         "@typescript-eslint/parser": "^6.8.0",
         "eslint": "^8.51.0",
@@ -41,9 +39,11 @@
     },
     "scripts": {
         "clean": "rimraf dist/*",
-        "build": "npm-run-all clean tsc copyPackage",
-        "tsc": "tsc",
+        "build": "npm-run-all clean build:cjs build:esm copyPackage",
+        "build:cjs": "tsc --project tsconfig.cjs.json",
+        "build:esm": "tsc --project tsconfig.esm.json",
         "copyPackage": "cp -f LICENSE dist/ && cp -f README.md dist/ && cp -f package.json dist/",
+        "prepublish": "npm run build",
         "lint": "eslint \"src/**/*.ts\"",
         "lint:fix": "eslint \"src/**/*.ts\" --fix",
         "pretty": "prettier --write \"./{{src,doc}/**/*.{ts,tsx,md},README.md}\"",

package/CamOverlayAPI.d.ts

@@ -1,31 +0,0 @@
-/// <reference types="node" />
-import { IClient } from './internal/common';
-import { CamOverlayOptions, ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TService, TServiceList, TStorage } from './types/CamOverlayAPI';
-import { TNetworkCamera } from './types/common';
-export declare class CamOverlayAPI {
-    private client;
-    constructor(options?: CamOverlayOptions | IClient);
-    checkCameraTime(): Promise<boolean>;
-    getNetworkCameraList(): Promise<TNetworkCamera[]>;
-    wsAutoratization(): Promise<string>;
-    getMjpegStreamImage(mjpegUrl: string): Promise<Blob>;
-    listFiles(fileType: TFileType): Promise<TFileList>;
-    uploadFile(fileType: TFileType, file: Blob, fileName: string): Promise<void>;
-    removeFile(fileType: TFileType, file: TFile): Promise<void>;
-    getFileStorage(fileType: TFileType): Promise<TStorage>;
-    updateInfoticker(serviceID: number, text: string): Promise<void>;
-    setEnabled(serviceID: number, enabled: boolean): Promise<void>;
-    isEnabled(serviceID: number): Promise<boolean>;
-    getSingleService(serviceId: number): Promise<TService>;
-    getServices(): Promise<TService[]>;
-    updateSingleService(serviceId: number, serviceJson: TService): Promise<void>;
-    updateServices(servicesJson: TServiceList): Promise<void>;
-    updateCGText(serviceID: number, fields: TField[]): Promise<void>;
-    updateCGImagePos(serviceID: number, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
-    updateCGImage(serviceID: number, path: string, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
-    updateCGImageFromData(serviceID: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number): Promise<void>;
-    private promiseCGUpdate;
-    private get;
-    private post;
-    private parseBlobResponse;
-}

package/CamOverlayAPI.js

@@ -1,172 +0,0 @@
-import { isClient, responseStringify } from './internal/common';
-import { DefaultClient } from './node/DefaultClient';
-import { fileListSchema, ImageType, serviceSchema, storageSchema, } from './types/CamOverlayAPI';
-import { ParsingBlobError, ServiceNotFoundError } from './errors/errors';
-import { networkCameraListSchema } from './types/common';
-export class CamOverlayAPI {
-    client;
-    constructor(options = {}) {
-        if (isClient(options)) {
-            this.client = options;
-        }
-        else {
-            this.client = new DefaultClient(options);
-        }
-    }
-    async checkCameraTime() {
-        const cameraTime = await this.get('/local/camoverlay/api/camera_time.cgi');
-        return cameraTime.state;
-    }
-    async getNetworkCameraList() {
-        const response = await this.get('/local/camoverlay/api/network_camera_list.cgi');
-        return networkCameraListSchema.parse(response.camera_list);
-    }
-    async wsAutoratization() {
-        const response = await this.get(`/local/camoverlay/api/ws_authorization.cgi`);
-        return response.data;
-    }
-    async getMjpegStreamImage(mjpegUrl) {
-        const res = await this.get(`/local/camoverlay/api/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
-        return await this.parseBlobResponse(res);
-    }
-    async listFiles(fileType) {
-        const files = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=list`);
-        return fileListSchema.parse(files.list);
-    }
-    async uploadFile(fileType, file, fileName) {
-        const formData = new FormData();
-        formData.append('target', 'SD0');
-        formData.append('uploadedFile[]', file, fileName);
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=upload`;
-        await this.post(path, formData);
-    }
-    async removeFile(fileType, file) {
-        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=remove`;
-        await this.post(path, JSON.stringify(file));
-    }
-    async getFileStorage(fileType) {
-        const data = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=get_storage`);
-        return storageSchema.parse(data);
-    }
-    async updateInfoticker(serviceID, text) {
-        await this.get(`/local/camoverlay/api/infoticker.cgi?service_id=${serviceID}&text=${text}`);
-    }
-    async setEnabled(serviceID, enabled) {
-        await this.post(`/local/camoverlay/api/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
-    }
-    async isEnabled(serviceID) {
-        const res = await this.client.get('/local/camoverlay/api/services.cgi?action=get');
-        if (res.ok) {
-            const data = JSON.parse(await res.text());
-            for (const service of data.services) {
-                if (service.id === serviceID) {
-                    return service.enabled === 1;
-                }
-            }
-            throw new ServiceNotFoundError();
-        }
-        else {
-            throw new Error(await responseStringify(res));
-        }
-    }
-    async getSingleService(serviceId) {
-        const data = await this.get('/local/camoverlay/api/services.cgi', {
-            action: 'get',
-            service_id: serviceId.toString(),
-        });
-        return serviceSchema.parse(data);
-    }
-    async getServices() {
-        const serviceList = await this.get('/local/camoverlay/api/services.cgi?action=get');
-        return serviceSchema.parse(serviceList).services;
-    }
-    async updateSingleService(serviceId, serviceJson) {
-        const path = '/local/camoverlay/api/services.cgi';
-        await this.post(path, JSON.stringify(serviceJson), {
-            action: 'set',
-            service_id: serviceId.toString(),
-        });
-    }
-    async updateServices(servicesJson) {
-        const path = '/local/camoverlay/api/services.cgi?action=set';
-        await this.post(path, JSON.stringify(servicesJson));
-    }
-    updateCGText(serviceID, fields) {
-        const params = {};
-        for (const field of fields) {
-            const name = field.field_name;
-            params[name] = field.text;
-            if (field.color !== undefined) {
-                params[`${name}_color`] = field.color;
-            }
-        }
-        return this.promiseCGUpdate(serviceID, 'update_text', params);
-    }
-    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
-        const params = {
-            coord_system: coordinates,
-            pos_x: x,
-            pos_y: y,
-        };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
-    }
-    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
-        const params = {
-            coord_system: coordinates,
-            pos_x: x,
-            pos_y: y,
-            image: path,
-        };
-        return this.promiseCGUpdate(serviceID, 'update_image', params);
-    }
-    updateCGImageFromData(serviceID, imageType, imageData, coordinates = '', x = 0, y = 0) {
-        const contentType = imageType === ImageType.PNG ? 'image/png' : 'image/jpeg';
-        const params = {
-            coord_system: coordinates,
-            pos_x: x,
-            pos_y: y,
-        };
-        return this.promiseCGUpdate(serviceID, 'update_image', params, contentType, imageData);
-    }
-    async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
-        const path = `/local/camoverlay/api/customGraphics.cgi`;
-        let headers = {};
-        if (contentType !== undefined && data) {
-            headers = { 'Content-Type': contentType };
-        }
-        const res = await this.client.post(path, data ?? '', {
-            action: action,
-            service_id: serviceID.toString(),
-            ...params,
-        }, headers);
-        if (!res.ok) {
-            throw new Error(await responseStringify(res));
-        }
-    }
-    async get(path, params) {
-        const res = await this.client.get(path, params);
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new Error(await responseStringify(res));
-        }
-    }
-    async post(path, data, params) {
-        const res = await this.client.post(path, data, params);
-        if (res.ok) {
-            return await res.json();
-        }
-        else {
-            throw new Error(await responseStringify(res));
-        }
-    }
-    async parseBlobResponse(response) {
-        try {
-            return await response.blob();
-        }
-        catch (err) {
-            throw new ParsingBlobError(err);
-        }
-    }
-}

package/internal/ProxyClient.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" />
-import { IClient, TParameters } from './common';
-import { TProxyParam } from '../types/common';
-export declare class ProxyClient<Client extends IClient = IClient> {
-    client: Client;
-    getProxyUrl: () => string;
-    constructor(client: Client, getProxyUrl: () => string);
-    get: (proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<import("./common").TResponse>;
-    post: (proxy: TProxyParam, path: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<import("./common").TResponse>;
-    private getReal;
-}

package/internal/common.d.ts

@@ -1,40 +0,0 @@
-/// <reference types="node" />
-type Options = {
-    ip?: string;
-    port?: number;
-    user?: string;
-    pass?: string;
-    tls?: boolean;
-    tlsInsecure?: boolean;
-};
-export type HttpOptions = Options & {
-    keepAlive?: boolean;
-};
-export type WsOptions = Options;
-export type TResponse = {
-    ok: boolean;
-    json: () => Promise<any>;
-    text: () => Promise<string>;
-    status: number;
-    body: any | null;
-};
-export type TParameters = Record<string, string | number | boolean | null | undefined>;
-export type TGetFunction = (url: string, parameters?: TParameters, headers?: Record<string, string>) => Promise<TResponse>;
-export type TPostFunction = (url: string, data: string | Buffer | FormData, parameters?: TParameters, headers?: Record<string, string>) => Promise<TResponse>;
-export interface IClient {
-    get: TGetFunction;
-    post: TPostFunction;
-}
-export interface IWebsocket<Event extends {
-    readonly data: string;
-}> {
-    destroy: () => void;
-    onmessage: null | ((event: Event) => void);
-    send: (data: string) => void;
-}
-export declare function isClient(arg?: Options | IClient): arg is IClient;
-export declare function isBrowserEnvironment(): boolean;
-export declare function responseStringify(res: TResponse): Promise<string>;
-export declare function pad(num: number, size: number): string;
-export declare function isNullish<T>(value: T | undefined | null): value is undefined | null;
-export {};

package/internal/common.js

@@ -1,23 +0,0 @@
-export function isClient(arg = {}) {
-    return 'get' in arg && 'post' in arg;
-}
-export function isBrowserEnvironment() {
-    return typeof process === 'undefined' || !process.versions.node;
-}
-export async function responseStringify(res) {
-    return JSON.stringify({
-        status: res.status,
-        body: await res.text(),
-    });
-}
-export function pad(num, size) {
-    const sign = Math.sign(num) === -1 ? '-' : '';
-    return (sign +
-        new Array(size)
-            .concat([Math.abs(num)])
-            .join('0')
-            .slice(-size));
-}
-export function isNullish(value) {
-    return value === null || value === undefined;
-}

package/node/DefaultClient.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="node" />
-import { IClient, HttpOptions, TParameters } from '../internal/common';
-export declare class DefaultClient implements IClient {
-    private tls;
-    private ip;
-    private port;
-    private user;
-    private pass;
-    private httpRequestSender;
-    constructor(opt?: HttpOptions);
-    get url(): string;
-    get(path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
-    post(path: string, data: string | FormData | Buffer, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
-    private getBaseConnectionParams;
-}