camstreamerlib 4.0.0-beta.97 → 4.0.1

package/esm/types/CamStreamerAPI/streamCommonTypes.js

@@ -1,64 +1,122 @@
 import { z } from 'zod';
-import { booleanSchema } from '../common';
-export const streamTypeSchema = z.union([
-    z.literal('youtube'),
-    z.literal('facebook'),
-    z.literal('sd_card'),
-    z.literal('windy'),
-    z.literal('mpeg_dvb'),
-    z.literal('rtmp'),
-    z.literal('dailymotion'),
-    z.literal('ibm'),
-    z.literal('hls_pull'),
-    z.literal('hls_push'),
-    z.literal('wowza'),
-    z.literal('microsoft_stream'),
-    z.literal('microsoft_azure'),
-    z.literal('vimeo'),
-    z.literal('twitch'),
-    z.literal('church'),
-    z.literal('srt'),
-    z.literal('da_cast'),
-    z.literal('game_changer'),
-]);
-const scheduleSchema = z.object({
-    start: z.object({
-        day: z.number().int().min(0).max(6),
-        timeS: z.number().int().min(0).max(86400),
-    }),
-    stop: z.object({
-        day: z.number().int().min(0).max(6),
-        timeS: z.number().int().min(0).max(86400),
-    }),
-    isActive: z.boolean(),
-});
-export const streamTriggerSchema = z.discriminatedUnion('type', [
-    z.object({
-        type: z.literal('manual'),
-        ioPort: z.string().nullable(),
-    }),
-    z.object({ type: z.literal('onetime'), startTime: z.number(), stopTime: z.number() }),
-    z.object({
-        type: z.literal('recurrent'),
-        schedule: z.array(scheduleSchema),
-    }),
-]);
-export const streamInputTypeSchema = z.union([z.literal('CSw'), z.literal('CRS'), z.literal('RTSP_URL')]);
-export const internalVapixParametersSchema = z.object({
-    camera: z.string(),
-    resolution: z.string().optional(),
-    compression: z.number().optional(),
-    fps: z.number().int().optional(),
-    videobitrate: z.number().int().optional(),
-    videomaxbitrate: z.number().int().optional(),
-    audio: booleanSchema.optional(),
-});
+import { bitrateVapixParamsSchema, booleanSchema, h264ProfileSchema } from '../common';
 export const streamCommonSchema = z.object({
-    id: z.number(),
+    streamId: z.string(),
     enabled: z.boolean(),
     active: z.boolean(),
     title: z.string(),
-    trigger: streamTriggerSchema,
-    inputType: streamInputTypeSchema,
-    internalVapixParameters: internalVapixParametersSchema,
+    callApi: z.boolean(),
+    trigger: z.discriminatedUnion('type', [
+        z.object({
+            type: z.literal('manual'),
+            port: z.number().optional(),
+        }),
+        z.object({
+            type: z.literal('onetime'),
+            startTime: z.number(),
+            stopTime: z.number(),
+            everActivated: z.boolean(),
+            prepareAheadS: z.number().int().optional(),
+        }),
+        z.object({
+            type: z.literal('recurrent'),
+            schedule: z.array(z.object({
+                start: z.object({
+                    day: z.number().int().min(0).max(6),
+                    timeS: z.number().int().min(0).max(86400),
+                }),
+                stop: z.object({
+                    day: z.number().int().min(0).max(6),
+                    timeS: z.number().int().min(0).max(86400),
+                }),
+                isActive: z.boolean(),
+            })),
+            prepareAheadS: z.number().int().optional(),
+        }),
+    ]),
+    video: z.object({
+        output: z.discriminatedUnion('type', [
+            z.object({
+                type: z.literal('video'),
+                url: z.string().nullable(),
+                parameters: z.string(),
+                saveToSdCard: z
+                    .object({
+                    ruleId: z.string(),
+                    configurationId: z.string(),
+                })
+                    .optional(),
+            }),
+            z.object({
+                type: z.literal('images'),
+                url: z.string().nullable(),
+                imageIntervalS: z.number(),
+            }),
+            z.object({
+                type: z.literal('none'),
+                saveToSdCard: z.object({
+                    ruleId: z.string(),
+                    configurationId: z.string(),
+                }),
+            }),
+        ]),
+        input: z.discriminatedUnion('type', [
+            z.object({
+                type: z.literal('RTSP_URL'),
+                url: z.string(),
+                internalVapixParameters: z.string(),
+            }),
+            z.object({
+                type: z.literal('CSw'),
+                internalVapixParameters: z.string(),
+            }),
+            z.object({
+                type: z.literal('CRS'),
+                internalVapixParameters: z.string(),
+                userVapixParameters: z.string(),
+            }),
+        ]),
+        delayS: z.number().int().nonnegative().optional(),
+    }),
+    audio: z.discriminatedUnion('source', [
+        z.object({
+            source: z.literal('none'),
+        }),
+        z.object({
+            source: z.literal('microphone'),
+            audioChannelNbr: z.number().int(),
+            forceStereo: z.boolean(),
+        }),
+        z.object({
+            source: z.literal('file'),
+            name: z.string(),
+            path: z.string(),
+            forceStereo: z.boolean(),
+        }),
+        z.object({
+            source: z.literal('url'),
+            name: z.string(),
+            url: z.string(),
+            avSyncMsec: z.number().int().nonnegative(),
+            forceStereo: z.boolean(),
+        }),
+    ]),
+    status: z.object({
+        led: z.boolean(),
+        port: z.number().optional(),
+    }),
+});
+export const internalVapixParametersSchema = bitrateVapixParamsSchema.extend({
+    camera: z.string(),
+    resolution: z.string(),
+    fps: z.number().int(),
+    compression: z.number().int(),
+    govLength: z.number().int(),
+    videoCodec: z.union([z.literal('h264'), z.literal('h265'), z.literal('av1')]),
+    h264Profile: h264ProfileSchema.optional(),
+    audio: booleanSchema,
+    nbrOfChannels: z.union([z.literal(1), z.literal(2)]).optional(),
+    overlays: z
+        .union([z.literal('all'), z.literal('text'), z.literal('image'), z.literal('application'), z.literal('off')])
+        .optional(),
 });

package/esm/types/CamStreamerAPI/streamsSchema.js

@@ -0,0 +1,75 @@
+import z from 'zod';
+import { streamCommonSchema } from './streamCommonTypes';
+export const streamPlatforms = {
+    da_cast: 'da_cast',
+    dailymotion: 'dailymotion',
+    facebook_rtmp: 'facebook_rtmp',
+    game_changer: 'game_changer',
+    hls_pull: 'hls_pull',
+    hls_push: 'hls_push',
+    ibm: 'ibm',
+    mpeg_dvb: 'mpeg_dvb',
+    microsoft_azure: 'microsoft_azure',
+    microsoft_stream: 'microsoft_stream',
+    rtmp: 'rtmp',
+    sd_card: 'sd_card',
+    srt: 'srt',
+    twitch: 'twitch',
+    vimeo: 'vimeo',
+    wowza: 'wowza',
+    youtube_rtmp: 'youtube_rtmp',
+    windy: 'windy',
+    youtube: 'youtube',
+    facebook: 'facebook',
+};
+export const daCastSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.da_cast),
+});
+export const dailymotionSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.dailymotion),
+});
+export const facebookRtmpSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.facebook_rtmp),
+});
+export const gameChangerSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.game_changer),
+});
+export const hlsPullSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.hls_pull),
+});
+export const hlsPushSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.hls_push),
+});
+export const ibmSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.ibm),
+});
+export const mpegDvbSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.mpeg_dvb),
+});
+export const microsoftAzureSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.microsoft_azure),
+});
+export const microsoftStreamSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.microsoft_stream),
+});
+export const rtmpSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.rtmp),
+});
+export const sdCardSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.sd_card),
+});
+export const srtSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.srt),
+});
+export const twitchSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.twitch),
+});
+export const vimeoSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.vimeo),
+});
+export const wowzaSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.wowza),
+});
+export const youtubeRtmpSchema = streamCommonSchema.extend({
+    platform: z.literal(streamPlatforms.youtube_rtmp),
+});

package/esm/types/CamStreamerAPI/windySchema.js

@@ -1,5 +1,13 @@
 import z from 'zod';
 import { streamCommonSchema } from './streamCommonTypes';
 export const windySchema = streamCommonSchema.extend({
-    type: z.literal('windy'),
+    platform: z.literal('windy'),
+    locationLat: z.number(),
+    locationLon: z.number(),
+    locationName: z.string(),
+    locationAddress: z.string(),
+    mapZoom: z.number(),
+    direction: z.enum(['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW']).nullable(),
+    position: z.union([z.literal('fix'), z.literal('rotating'), z.literal('controllable')]),
+    webPageUrl: z.string(),
 });

package/esm/types/CamStreamerAPI/youtubeSchema.js

@@ -1,5 +1,16 @@
 import z from 'zod';
 import { streamCommonSchema } from './streamCommonTypes';
 export const youtubeSchema = streamCommonSchema.extend({
-    type: z.literal('youtube'),
+    platform: z.literal('youtube'),
+    description: z.string().optional(),
+    playlists: z.array(z.string()),
+    tags: z.array(z.string()),
+    notificationEmails: z.array(z.string().email()),
+    streamPrivacy: z.union([z.literal('public'), z.literal('unlisted'), z.literal('private')]),
+    latency: z.union([z.literal('normal'), z.literal('low'), z.literal('ultra_low')]),
+    afterEndStatus: z.union([z.literal('no_change'), z.literal('public'), z.literal('unlisted'), z.literal('private')]),
+    dvr: z.boolean(),
+    hasWatchdogs: z.boolean(),
+    countdown: z.boolean().optional(),
+    streamingProtocol: z.union([z.literal('RTMP'), z.literal('RTMPS'), z.literal('HLS')]),
 });

package/esm/types/CamSwitcherAPI.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { toCamelCase, toCamelCaseDeep } from '../internal/transformers';
-import { storageTypeSchema, keyboardShortcutsSchema, h264ProfileSchema, audioChannelCountSchema, keyboardShortcutSchema, } from './common';
+import { storageTypeSchema, keyboardShortcutsSchema, h264ProfileSchema, audioChannelCountSchema, keyboardShortcutSchema, bitrateVapixParamsSchema, } from './common';
 const channelTypeSchema = z.union([z.literal('audio'), z.literal('video'), z.literal('av')]);
 const playlistPlayTypeSchema = z.union([
     z.literal('PLAY_ALL'),
@@ -132,13 +132,6 @@ export const clipListSchema = z.object({
         ])),
     })),
 });
-export const bitrateModeSchema = z.union([z.literal('VBR'), z.literal('MBR'), z.literal('ABR')]);
-export const bitrateVapixParamsSchema = z.object({
-    bitrateMode: bitrateModeSchema,
-    maximumBitRate: z.number(),
-    retentionTime: z.number(),
-    bitRateLimit: z.number(),
-});
 export const cameraOptionsSchema = bitrateVapixParamsSchema
     .extend({
     resolution: z.string(),
@@ -169,3 +162,10 @@ export const secondaryAudioSettingsSchema = z.object({
     secondaryAudioLevel: z.number(),
     masterAudioLevel: z.number(),
 });
+export const clipFilesListSchema = z.object({
+    status: z.number(),
+    message: z.string(),
+    data: z.object({
+        files: z.array(z.string()),
+    }),
+});

package/esm/types/PlaneTrackerAPI.js

@@ -38,6 +38,7 @@ const identificationLabelSchema = z.object({
     opacity: z.number().positive(),
 });
 export const cameraSettingsSchema = z.object({
+    trackingDomain: z.union([z.literal('adsb'), z.literal('dronetag')]).default('adsb'),
     units: z.union([z.literal('metric'), z.literal('imperial')]).default('imperial'),
     adsbSource: z
         .object({
@@ -120,15 +121,17 @@ export const cameraSettingsSchema = z.object({
         displayPTError: z.boolean().optional(),
         displayPTZSpeed: z.boolean().optional(),
         displayVelocityData: z.boolean().optional(),
+        displayAdsbVelocityData: z.boolean().optional(),
         displaySignalQuality: z.boolean().optional(),
         displayAutoTrackingInfo: z.boolean().optional(),
         displayGPSCoords: z.boolean().optional(),
         displayVapixQuery: z.boolean().optional(),
         displayFocus: z.boolean().optional(),
         displayAperture: z.boolean().optional(),
+        displayAircraftInfo: z.boolean().optional(),
         displaySunDistance: z.boolean().optional(),
         displayTickTime: z.boolean().optional(),
-        displayAircraftInfo: z.boolean().optional(),
+        displaySystemInfo: z.boolean().optional(),
     })
         .optional(),
     widget: widgetSchema.default({
@@ -262,7 +265,7 @@ export const getIcaoSchema = z.object({
     icao: z.string(),
 });
 export const trackingModeSchema = z.object({
-    mode: z.union([z.literal('MANUAL'), z.literal('AUTOMATIC')]),
+    mode: z.union([z.literal('MANUAL'), z.literal('AUTOMATIC')]).default('AUTOMATIC'),
 });
 export const flightInfoSchema = z.object({
     callsign: z.string().optional(),

package/esm/types/VapixAPI.js

@@ -22,6 +22,7 @@ export const applicationListSchema = z.array(applicationSchema.extend({
         z.literal('PlaneTracker'),
         z.literal('Ndihxplugin'),
         z.literal('SportTracker'),
+        z.literal('CamOverlayHtmlplugin'),
     ])
         .nullable(),
 }));
@@ -32,8 +33,8 @@ export const APP_IDS = [
     'CamScripter',
     'PlaneTracker',
     'Ndihxplugin',
-    'SportTracker',
 ];
+export const ALL_APP_IDS = [...APP_IDS, 'SportTracker', 'CamOverlayHtmlplugin'];
 export const guardTourSchema = z.object({
     id: z.string(),
     camNbr: z.unknown(),
@@ -168,7 +169,7 @@ export const getPortsResponseSchema = z.object({
     method: z.literal('getPorts'),
     data: z.object({
         numberOfPorts: z.number(),
-        items: z.array(portStatusSchema),
+        items: z.array(portStatusSchema).optional(),
     }),
 });
 export const portSetSchema = z.object({
@@ -183,3 +184,9 @@ export const portSequenceStateSchema = z.object({
     state: z.enum(['open', 'closed']),
     time: z.number().min(0).max(65535),
 });
+export const recordingConfigItemSchema = z.object({
+    diskid: z.string(),
+    eventid: z.string(),
+    options: z.record(z.string()),
+    profile: z.string(),
+});

package/esm/types/common.js

@@ -12,3 +12,15 @@ export const networkCameraListSchema = z.array(z.object({
 }));
 export const keyboardShortcutSchema = z.string().nullable();
 export const keyboardShortcutsSchema = z.record(keyboardShortcutSchema);
+export const bitrateModeSchema = z.union([z.literal('VBR'), z.literal('MBR'), z.literal('ABR')]);
+export const bitrateVapixParamsSchema = z.object({
+    bitrateMode: bitrateModeSchema,
+    maximumBitRate: z.number(),
+    retentionTime: z.number(),
+    bitRateLimit: z.number(),
+});
+export const fileSchema = typeof File !== 'undefined'
+    ? z.instanceof(File)
+    : z.custom((val) => {
+        return val !== null && typeof val === 'object' && 'name' in val && 'size' in val && 'type' in val;
+    });

package/esm/types/ws/CamStreamerEvents.js

@@ -3,25 +3,29 @@ const csEventsDataSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal('authorization'), state: z.string() }),
     z.object({
         type: z.literal('StreamState'),
-        streamID: z.number(),
-        enabled: z.union([z.literal(0), z.literal(1)]),
-        active: z.union([z.literal(0), z.literal(1)]),
-        automationState: z.union([z.literal(0), z.literal(1)]),
-        isStreaming: z.union([z.literal(0), z.literal(1)]),
+        streamId: z.string(),
+        isStreaming: z.boolean(),
+        active: z.boolean(),
+        enabled: z.boolean(),
     }),
     z.object({
         type: z.literal('CS_API_SUCCESS'),
         apiCall: z.string(),
         message: z.string(),
-        streamID: z.string(),
+        streamId: z.string(),
     }),
     z.object({
         type: z.literal('CS_API_ERROR'),
         apiCall: z.string(),
         message: z.string(),
-        streamID: z.string(),
+        streamId: z.string(),
         code: z.string(),
     }),
+    z.object({
+        type: z.literal('PortChanged'),
+        port: z.number(),
+        value: z.boolean(),
+    }),
 ]);
 export const csEventsSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal('init'), data: csEventsDataSchema }),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "camstreamerlib",
-    "version": "4.0.0-beta.97",
+    "version": "4.0.1",
     "description": "Helper library for CamStreamer ACAP applications.",
     "prettier": "@camstreamer/prettier-config",
     "engine": {
@@ -9,8 +9,8 @@
     "dependencies": {
         "adm-zip": "^0.5.9",
         "eventemitter2": "^5.0.1",
-        "fast-xml-parser": "^5.2.5",
-        "lodash": "^4.17.21",
+        "fast-xml-parser": "^5.3.6",
+        "lodash-es": "^4.18.1",
         "type-fest": "^4.41.0",
         "undici": "^6.21.3",
         "ws": "^8.18.0",
@@ -21,7 +21,7 @@
         "@camstreamer/prettier-config": "^2.0.4",
         "@types/adm-zip": "^0.5.5",
         "@types/jest": "^28.0.0",
-        "@types/lodash": "^4.17.18",
+        "@types/lodash-es": "^4.17.12",
         "@types/node": "^18.19.127",
         "@types/ws": "^8.5.10",
         "@typescript-eslint/eslint-plugin": "^6.8.0",