camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.21

package/cjs/CreatePackage.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AdmZip = require("adm-zip");
+const Path = require("path");
+const fs = require("fs");
+const child_process_1 = require("child_process");
+const productionModulesFolder = 'production_modules';
+function isDirectory(path) {
+    const stat = fs.statSync(path);
+    return stat.isDirectory();
+}
+function getPackageInfo(folder) {
+    try {
+        const manifest = fs.readFileSync(Path.join(folder, 'manifest.json'));
+        const manifestParsed = JSON.parse(manifest.toString());
+        return {
+            packageName: manifestParsed.package_name,
+            packageVersion: manifestParsed.package_version.replace(/\./g, '_'),
+        };
+    }
+    catch (err) {
+        console.error('Get package version:', err);
+    }
+}
+function createZipArchive(zip, folder, options) {
+    const zipFileRegex = new RegExp(`${Path.basename(folder)}(_[0-9]){3}\\.zip`);
+    const files = fs.readdirSync(folder);
+    for (const file of files) {
+        const path = Path.join(folder, file);
+        const isDir = isDirectory(path);
+        if (file[0] === '.' ||
+            zipFileRegex.test(file) ||
+            file === 'node_modules' ||
+            (file === 'src' && options.typeScriptPackage) ||
+            options.excludedFileNames.includes(file)) {
+            continue;
+        }
+        else if (file === 'dist' && options.typeScriptPackage) {
+            zip.addLocalFolder(path);
+        }
+        else if (file === productionModulesFolder && options.includeNodeModules) {
+            zip.addLocalFolder(Path.join(productionModulesFolder, 'node_modules'), 'node_modules');
+        }
+        else if (isDir) {
+            zip.addLocalFolder(path, file);
+        }
+        else {
+            zip.addLocalFile(path);
+        }
+    }
+}
+function installDependencies() {
+    if (!fs.existsSync(productionModulesFolder)) {
+        fs.mkdirSync(productionModulesFolder, {});
+    }
+    fs.cpSync('package.json', Path.join(productionModulesFolder, 'package.json'));
+    fs.cpSync('package-lock.json', Path.join(productionModulesFolder, 'package-lock.json'));
+    (0, child_process_1.execSync)(`npm ci --omit=dev`, {
+        cwd: Path.join(process.cwd(), productionModulesFolder),
+    });
+}
+function main(args) {
+    const options = {
+        includeNodeModules: false,
+        typeScriptPackage: false,
+        outputFolder: '.',
+        excludedFileNames: [],
+    };
+    for (const arg of args) {
+        if (arg === '-i' || arg === '-includeNodeModules') {
+            options.includeNodeModules = true;
+        }
+        if (arg.startsWith('-w=') || arg.startsWith('-where=')) {
+            options.outputFolder = arg.substring(arg.indexOf('=') + 1);
+        }
+        if (arg.startsWith('-e=') || arg.startsWith('-exclude=')) {
+            options.excludedFileNames = arg.substring(arg.indexOf('=') + 1).split(',');
+        }
+    }
+    if (options.includeNodeModules) {
+        installDependencies();
+    }
+    if (fs.existsSync('dist')) {
+        options.typeScriptPackage = true;
+    }
+    const folder = Path.resolve('.');
+    const packageInfo = getPackageInfo(folder);
+    if (packageInfo === undefined) {
+        console.error('Package info not found');
+        process.exit(1);
+    }
+    const zipFile = `${options.outputFolder}/${packageInfo.packageName}_${packageInfo.packageVersion}.zip`;
+    if (fs.existsSync(zipFile)) {
+        try {
+            fs.unlinkSync(zipFile);
+        }
+        catch (error) {
+            console.error('An error occured: ', error);
+            process.exit(1);
+        }
+    }
+    const zip = new AdmZip();
+    createZipArchive(zip, folder, options);
+    zip.writeZip(zipFile);
+}
+main(process.argv.slice(2));

package/cjs/PlaneTrackerAPI.d.ts

@@ -0,0 +1,47 @@
+import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
+import { TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
+export type TApiUser = {
+    userId: string;
+    userName: string;
+    userPriority: number;
+};
+type ICAO = string;
+export declare const BASE_URL = "/local/planetracker";
+export declare class PlaneTrackerAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+    private client;
+    private apiUser;
+    private _apiUserQuery;
+    constructor(client: Client, apiUser: TApiUser);
+    static getProxyUrlPath: () => string;
+    checkCameraTime(): Promise<boolean>;
+    fetchCameraSettings: () => Promise<any>;
+    setCameraSettings: (settingsJsonString: string) => Promise<TResponse>;
+    fetchServerSettings: () => Promise<any>;
+    fetchMapInfo: () => Promise<any>;
+    fetchFlightInfo: (icao: ICAO) => Promise<any>;
+    getZones: () => Promise<any>;
+    setZones: (zonesJsonString: string) => Promise<TResponse>;
+    getPriorityList: () => Promise<any>;
+    setPriorityList: (priorityListJsonString: string) => Promise<TResponse>;
+    getWhiteList: () => Promise<any>;
+    setWhiteList: (whiteListJsonString: string) => Promise<TResponse>;
+    getBlackList: () => Promise<any>;
+    setBlackList: (blackListJsonString: string) => Promise<TResponse>;
+    getTrackingMode: () => Promise<any>;
+    setTrackingMode: (modeJsonString: string) => Promise<TResponse>;
+    startTrackingPlane: (icao: ICAO) => Promise<TResponse>;
+    stopTrackingPlane: () => Promise<TResponse>;
+    goToCoordinates: (lat: number, lon: number, alt?: number) => Promise<TResponse>;
+    exportAppSettings: (dataType: TExportDataType) => Promise<TBlobResponse<Client>>;
+    importAppSettings: (dataType: TImportDataType, formData: FormData) => Promise<TResponse>;
+    resetPtzCalibration: () => Promise<TResponse>;
+    checkGenetecConnection: (params: TParameters) => Promise<TResponse>;
+    getGenetecCameraList: (params: TParameters) => Promise<any>;
+    serverRunCheck: () => Promise<TResponse>;
+    private _getJson;
+    private _getBlob;
+    private parseBlobResponse;
+    private _postJsonEncoded;
+    private _postUrlEncoded;
+}
+export {};

package/cjs/PlaneTrackerAPI.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaneTrackerAPI = exports.BASE_URL = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("./internal/utils");
+const errors_1 = require("./errors/errors");
+exports.BASE_URL = '/local/planetracker';
+class PlaneTrackerAPI {
+    client;
+    apiUser;
+    _apiUserQuery;
+    constructor(client, apiUser) {
+        this.client = client;
+        this.apiUser = apiUser;
+        this._apiUserQuery = (0, utils_1.paramToUrl)(this.apiUser);
+    }
+    static getProxyUrlPath = () => `${exports.BASE_URL}/proxy.cgi`;
+    async checkCameraTime() {
+        const responseSchema = zod_1.z.discriminatedUnion('state', [
+            zod_1.z.object({
+                state: zod_1.z.literal(true),
+                code: zod_1.z.number(),
+            }),
+            zod_1.z.object({
+                state: zod_1.z.literal(false),
+                code: zod_1.z.number(),
+                reason: zod_1.z.union([
+                    zod_1.z.literal('INVALID_TIME'),
+                    zod_1.z.literal('COULDNT_RESOLVE_HOST'),
+                    zod_1.z.literal('CONNECTION_ERROR'),
+                ]),
+                message: zod_1.z.string(),
+            }),
+        ]);
+        const response = await this._getJson(`${exports.BASE_URL}/camera_time.cgi`);
+        const cameraTime = responseSchema.parse(response);
+        if (!cameraTime.state) {
+            console.error(`Camera time check failed: ${cameraTime.reason} - ${cameraTime.message}`);
+        }
+        return cameraTime.state;
+    }
+    fetchCameraSettings = async () => {
+        return await this._getJson(`${exports.BASE_URL}/package_camera_settings.cgi`, { action: 'get' });
+    };
+    setCameraSettings = async (settingsJsonString) => {
+        return await this._postJsonEncoded(`${exports.BASE_URL}/package_camera_settings.cgi`, settingsJsonString, {
+            action: 'set',
+        });
+    };
+    fetchServerSettings = async () => {
+        return await this._getJson(`${exports.BASE_URL}/package_server_settings.cgi`, { action: 'get' });
+    };
+    fetchMapInfo = async () => {
+        return await this._getJson(`${exports.BASE_URL}/package/getMapInfo.cgi`);
+    };
+    fetchFlightInfo = async (icao) => {
+        return await this._getJson(`${exports.BASE_URL}/package/flightInfo.cgi`, { icao: encodeURIComponent(icao) });
+    };
+    getZones = async () => {
+        return await this._getJson(`${exports.BASE_URL}/package/getZones.cgi`);
+    };
+    setZones = async (zonesJsonString) => {
+        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setZones.cgi?${this._apiUserQuery}`, zonesJsonString);
+    };
+    getPriorityList = async () => {
+        return await this._getJson(`${exports.BASE_URL}/package/getPriorityList.cgi`);
+    };
+    setPriorityList = async (priorityListJsonString) => {
+        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setPriorityList.cgi?${this._apiUserQuery}`, priorityListJsonString);
+    };
+    getWhiteList = async () => {
+        return await this._getJson(`${exports.BASE_URL}/package/getWhiteList.cgi`);
+    };
+    setWhiteList = async (whiteListJsonString) => {
+        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setWhiteList.cgi?${this._apiUserQuery}`, whiteListJsonString);
+    };
+    getBlackList = async () => {
+        return await this._getJson(`${exports.BASE_URL}/package/getBlackList.cgi`);
+    };
+    setBlackList = async (blackListJsonString) => {
+        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setBlackList.cgi?${this._apiUserQuery}`, blackListJsonString);
+    };
+    getTrackingMode = async () => {
+        return await this._getJson(`${exports.BASE_URL}/package/getTrackingMode.cgi`);
+    };
+    setTrackingMode = async (modeJsonString) => {
+        return await this._postJsonEncoded(`${exports.BASE_URL}/package/setTrackingMode.cgi?${this._apiUserQuery}`, modeJsonString);
+    };
+    startTrackingPlane = async (icao) => {
+        return await this.client.get(`${exports.BASE_URL}/package/trackIcao.cgi`, {
+            icao: encodeURIComponent(icao),
+            userId: encodeURIComponent(this.apiUser.userId),
+            userName: encodeURIComponent(this.apiUser.userName),
+            userPriority: this.apiUser.userPriority,
+        });
+    };
+    stopTrackingPlane = async () => {
+        return await this.client.get(`${exports.BASE_URL}/package/resetIcao.cgi?${this._apiUserQuery}`);
+    };
+    goToCoordinates = async (lat, lon, alt) => {
+        const url = `${exports.BASE_URL}/package/goToCoordinates.cgi?lat=${lat}&lon=${lon}&${this._apiUserQuery}`;
+        return await this.client.get(`${url}${alt !== undefined ? `&alt=${alt}` : ''}`);
+    };
+    exportAppSettings = async (dataType) => {
+        return await this._getBlob(`${exports.BASE_URL}/package_data.cgi`, { action: 'EXPORT', dataType });
+    };
+    importAppSettings = async (dataType, formData) => {
+        return await this.client.post(`${exports.BASE_URL}/package_data.cgi`, formData, { action: 'IMPORT', dataType });
+    };
+    resetPtzCalibration = async () => {
+        return await this.client.get(`${exports.BASE_URL}/package/resetPtzCalibration.cgi`, {
+            userId: encodeURIComponent(this.apiUser.userId),
+            userName: encodeURIComponent(this.apiUser.userName),
+            userPriority: this.apiUser.userPriority,
+        });
+    };
+    checkGenetecConnection = async (params) => {
+        return await this._postUrlEncoded(`${exports.BASE_URL}/package/checkGenetecConnection.cgi`, params);
+    };
+    getGenetecCameraList = async (params) => {
+        const res = await this._postUrlEncoded(`${exports.BASE_URL}/package/getGenetecCameraList.cgi`, params);
+        return await res.json();
+    };
+    serverRunCheck = async () => {
+        return await this.client.get(`${exports.BASE_URL}/package/serverRunCheck.cgi`);
+    };
+    async _getJson(...args) {
+        const res = await this.client.get(...args);
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+    }
+    async _getBlob(...args) {
+        const res = await this.client.get(...args);
+        if (res.ok) {
+            return await this.parseBlobResponse(res);
+        }
+        else {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return (await response.blob());
+        }
+        catch (err) {
+            throw new errors_1.ParsingBlobError(err);
+        }
+    }
+    async _postJsonEncoded(...args) {
+        const [path, data, params, headers] = args;
+        const baseHeaders = { 'Accept': 'application/json', 'Content-Type': 'application/json' };
+        const res = await this.client.post(path, data, params, { ...baseHeaders, ...headers });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+    }
+    async _postUrlEncoded(path, params, headers) {
+        const data = (0, utils_1.paramToUrl)(params);
+        const baseHeaders = { 'Content-Type': 'application/x-www-form-urlencoded' };
+        const res = await this.client.post(path, data, {}, { ...baseHeaders, ...headers });
+        if (res.ok) {
+            return res;
+        }
+        else {
+            throw new Error(await (0, utils_1.responseStringify)(res));
+        }
+    }
+}
+exports.PlaneTrackerAPI = PlaneTrackerAPI;

package/{VapixAPI.d.ts → cjs/VapixAPI.d.ts}

@@ -1,12 +1,12 @@
-import { IClient, TParameters, TResponse } from './internal/common';
-import { TApplication, TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice } from './types/VapixAPI';
+import { IClient, TParameters, TResponse } from './internal/types';
+import { TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice } from './types/VapixAPI';
 import { ProxyClient } from './internal/ProxyClient';
 import { TCameraImageConfig, TProxyParam } from './types/common';
-export declare class VapixAPI<Client extends IClient = IClient> {
+export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
     client: ProxyClient<Client>;
     constructor(client: Client, getProxyUrl: () => string);
-    getUrlEncoded(proxy: TProxyParam | undefined, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
-    postJson(proxy: TProxyParam | undefined, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<TResponse>;
+    getUrlEncoded(proxy: TProxyParam, path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<TResponse>;
+    postJson(proxy: TProxyParam, path: string, jsonData: Record<string, any>, headers?: Record<string, string>): Promise<TResponse>;
     getCameraImage(params: TCameraImageConfig, proxy?: TProxyParam): Promise<TResponse>;
     getEventDeclarations(proxy?: TProxyParam): Promise<string>;
     getSupportedAudioSampleRate(proxy?: TProxyParam): Promise<TAudioSampleRates[]>;
@@ -26,7 +26,7 @@ export declare class VapixAPI<Client extends IClient = IClient> {
             dstEnabled: boolean;
             localDateTime: string;
             posixTimeZone: string;
-            timeZone: string;
+            timeZone?: string | undefined;
         };
     }>;
     getDevicesSettings(proxy?: TProxyParam): Promise<TAudioDevice[]>;
@@ -58,7 +58,19 @@ export declare class VapixAPI<Client extends IClient = IClient> {
     getPtzPosition(camera: number, proxy?: TProxyParam): Promise<TCameraPTZItemData>;
     getInputState(port: number, proxy?: TProxyParam): Promise<boolean>;
     setOutputState(port: number, active: boolean, proxy?: TProxyParam): Promise<TResponse>;
-    getApplicationList(proxy?: TProxyParam): Promise<TApplication[]>;
+    getApplicationList(proxy?: TProxyParam): Promise<{
+        appId: "CamStreamer" | "CamSwitcher" | "CamOverlay" | "CamScripter" | "PlaneTracker" | "Ndihxplugin" | "SportTracker" | null;
+        Name: string;
+        NiceName: string;
+        Vendor: string;
+        Version: string;
+        License: string;
+        Status: string;
+        ApplicationID?: string | undefined;
+        ConfigurationPage?: string | undefined;
+        VendorHomePage?: string | undefined;
+        LicenseName?: string | undefined;
+    }[]>;
     startApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
     restartApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;
     stopApplication(applicationID: string, proxy?: TProxyParam): Promise<void>;