@clockworkdog/cogs-client 1.5.5 → 2.0.0-beta.1

package/dist/CogsConnection.js

@@ -3,35 +3,51 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const valueTypes_1 = require("./types/valueTypes");
+exports.CogsIncomingEvent = exports.CogsStateChangedEvent = exports.CogsConfigChangedEvent = exports.CogsMessageEvent = exports.CogsConnectionCloseEvent = exports.CogsConnectionOpenEvent = void 0;
+const ShowPhase_1 = __importDefault(require("./types/ShowPhase"));
 const reconnecting_websocket_1 = __importDefault(require("reconnecting-websocket"));
 const urls_1 = require("./helpers/urls");
 class CogsConnection {
-    constructor({ hostname = document.location.hostname, port = urls_1.COGS_SERVER_PORT } = {}, outputPortValues = undefined) {
+    get config() {
+        return { ...this.currentConfig };
+    }
+    get state() {
+        return { ...this.currentState };
+    }
+    get showPhase() {
+        return this._showPhase;
+    }
+    get timerState() {
+        return this._timerState ? { ...this._timerState } : null;
+    }
+    get selectedAudioOutput() {
+        return this._selectedAudioOutput;
+    }
+    constructor(manifest, { hostname = document.location.hostname, port = urls_1.COGS_SERVER_PORT } = {}, initialClientState = undefined) {
         var _a;
+        this.manifest = manifest;
         this.eventTarget = new EventTarget();
         this.currentConfig = {}; // Received on open connection
-        this.currentInputPortValues = {}; // Received on open connection
-        this.currentOutputPortValues = {}; // Sent on open connection
-        this._showPhase = valueTypes_1.ShowPhase.Setup;
+        this.currentState = {}; // Received on open connection - TODO: set initial state from manifest?
+        this._showPhase = ShowPhase_1.default.Setup;
         this._timerState = null;
         /**
          * Cached audio outputs use to look up the device/sink ID when a different device label is requested
          */
         this.audioOutputs = undefined;
         this._selectedAudioOutput = '';
-        this.currentOutputPortValues = { ...outputPortValues };
+        this.currentState = { ...initialClientState };
         const { useReconnectingWebsocket, path, pathParams } = websocketParametersFromUrl(document.location.href);
         const socketUrl = `ws://${hostname}:${port}${path}${pathParams ? '?' + pathParams : ''}`;
         this.websocket = useReconnectingWebsocket ? new reconnecting_websocket_1.default(socketUrl) : new WebSocket(socketUrl);
         this.websocket.onopen = () => {
             this.currentConfig = {}; // Received on open connection
-            this.currentInputPortValues = {}; // Received on open connection
-            this.dispatchEvent('open', undefined);
-            this.setOutputPortValues(this.currentOutputPortValues);
+            this.currentState = {}; // Received on open connection
+            this.dispatchEvent(new CogsConnectionOpenEvent());
+            this.setState(this.currentState); // TODO: Remove this because you should set it manually...??
         };
         this.websocket.onclose = () => {
-            this.dispatchEvent('close', undefined);
+            this.dispatchEvent(new CogsConnectionCloseEvent());
         };
         this.websocket.onmessage = ({ data }) => {
             try {
@@ -39,29 +55,30 @@ class CogsConnection {
                 try {
                     if (parsed.config) {
                         this.currentConfig = parsed.config;
-                        this.dispatchEvent('config', this.currentConfig);
+                        this.dispatchEvent(new CogsConfigChangedEvent(this.currentConfig));
                     }
                     else if (parsed.updates) {
-                        this.currentInputPortValues = { ...this.currentInputPortValues, ...parsed.updates };
-                        this.dispatchEvent('updates', parsed.updates);
+                        this.currentState = { ...this.currentState, ...parsed.updates };
+                        this.dispatchEvent(new CogsStateChangedEvent(parsed.updates));
                     }
                     else if (parsed.event && parsed.event.key) {
-                        this.dispatchEvent('event', parsed.event);
+                        this.dispatchEvent(new CogsIncomingEvent(parsed.event.key, parsed.event.value));
                     }
                     else if (typeof parsed.message === 'object') {
-                        switch (parsed.message.type) {
+                        const message = parsed.message;
+                        switch (message.type) {
                             case 'adjustable_timer_update':
                                 this._timerState = {
                                     startedAt: Date.now(),
-                                    durationMillis: parsed.message.durationMillis,
-                                    ticking: parsed.message.ticking,
+                                    durationMillis: message.durationMillis,
+                                    ticking: message.ticking,
                                 };
                                 break;
                             case 'show_phase':
-                                this._showPhase = parsed.message.phase;
+                                this._showPhase = message.phase;
                                 break;
                         }
-                        this.dispatchEvent('message', parsed.message);
+                        this.dispatchEvent(new CogsMessageEvent(message));
                     }
                 }
                 catch (e) {
@@ -82,29 +99,11 @@ class CogsConnection {
                     this.audioOutputs = audioOutputs;
                 }
             };
-            this.addEventListener('open', refreshAudioOutputs);
+            this.eventTarget.addEventListener('open', refreshAudioOutputs);
             (_a = navigator.mediaDevices) === null || _a === void 0 ? void 0 : _a.addEventListener('devicechange', refreshAudioOutputs);
             refreshAudioOutputs();
         }
     }
-    get config() {
-        return { ...this.currentConfig };
-    }
-    get inputPortValues() {
-        return { ...this.currentInputPortValues };
-    }
-    get outputPortValues() {
-        return { ...this.currentOutputPortValues };
-    }
-    get showPhase() {
-        return this._showPhase;
-    }
-    get timerState() {
-        return this._timerState ? { ...this._timerState } : null;
-    }
-    get selectedAudioOutput() {
-        return this._selectedAudioOutput;
-    }
     get isConnected() {
         return this.websocket.readyState === WebSocket.OPEN;
     }
@@ -121,8 +120,8 @@ class CogsConnection {
             }));
         }
     }
-    setOutputPortValues(values) {
-        this.currentOutputPortValues = { ...this.currentOutputPortValues, ...values };
+    setState(values) {
+        this.currentState = { ...this.currentState, ...values };
         if (this.isConnected) {
             this.websocket.send(JSON.stringify({ updates: values }));
         }
@@ -163,8 +162,8 @@ class CogsConnection {
     removeEventListener(type, listener, options) {
         this.eventTarget.removeEventListener(type, listener, options);
     }
-    dispatchEvent(type, detail) {
-        this.eventTarget.dispatchEvent(new CustomEvent(type, { detail }));
+    dispatchEvent(event) {
+        this.eventTarget.dispatchEvent(event);
     }
 }
 exports.default = CogsConnection;
@@ -206,3 +205,50 @@ function websocketParametersFromUrl(url) {
         return { path: `/client/${encodeURIComponent(serial)}`, pathParams };
     }
 }
+class CogsConnectionOpenEvent extends Event {
+    constructor() {
+        super('open');
+        this.type = 'open';
+    }
+}
+exports.CogsConnectionOpenEvent = CogsConnectionOpenEvent;
+class CogsConnectionCloseEvent extends Event {
+    constructor() {
+        super('close');
+        this.type = 'close';
+    }
+}
+exports.CogsConnectionCloseEvent = CogsConnectionCloseEvent;
+class CogsMessageEvent extends Event {
+    constructor(message) {
+        super('message');
+        this.message = message;
+        this.type = 'message';
+    }
+}
+exports.CogsMessageEvent = CogsMessageEvent;
+class CogsConfigChangedEvent extends Event {
+    constructor(config) {
+        super('config');
+        this.config = config;
+        this.type = 'config';
+    }
+}
+exports.CogsConfigChangedEvent = CogsConfigChangedEvent;
+class CogsStateChangedEvent extends Event {
+    constructor(state) {
+        super('state');
+        this.state = state;
+        this.type = 'state';
+    }
+}
+exports.CogsStateChangedEvent = CogsStateChangedEvent;
+class CogsIncomingEvent extends Event {
+    constructor(name, value) {
+        super('event');
+        this.name = name;
+        this.value = value;
+        this.type = 'event';
+    }
+}
+exports.CogsIncomingEvent = CogsIncomingEvent;

package/dist/RtspStreamer.js

@@ -33,7 +33,7 @@ class RtspStreamer {
             });
             // Restart stream on RTCP BYE (stream ended)
             pipeline.rtsp.onRtcp = (rtcp) => {
-                if (media_stream_library_browser_1.isRtcpBye(rtcp)) {
+                if ((0, media_stream_library_browser_1.isRtcpBye)(rtcp)) {
                     console.log('Video stream ended. Restarting.');
                     videoElement.pause();
                     setTimeout(startPipeline, 0);

package/dist/VideoPlayer.d.ts

@@ -2,7 +2,7 @@ import CogsConnection from './CogsConnection';
 import { VideoState } from './types/VideoState';
 import MediaClipStateMessage from './types/MediaClipStateMessage';
 import { MediaObjectFit } from '.';
-declare type EventTypes = {
+type EventTypes = {
     state: VideoState;
     videoClipState: MediaClipStateMessage;
 };
@@ -14,7 +14,7 @@ export default class VideoPlayer {
     private pendingClip?;
     private parentElement;
     private sinkId;
-    constructor(cogsConnection: CogsConnection, parentElement?: HTMLElement);
+    constructor(cogsConnection: CogsConnection<any>, parentElement?: HTMLElement);
     setParentElement(parentElement: HTMLElement): void;
     resetParentElement(): void;
     setGlobalVolume(globalVolume: number): void;

package/dist/VideoPlayer.js

@@ -15,8 +15,7 @@ class VideoPlayer {
             cogsConnection.sendMediaClipState(detail);
         });
         // Listen for video control messages
-        cogsConnection.addEventListener('message', (event) => {
-            const message = event.detail;
+        cogsConnection.addEventListener('message', ({ message }) => {
             switch (message.type) {
                 case 'media_config_update':
                     this.setGlobalVolume(message.globalVolume);
@@ -261,7 +260,8 @@ class VideoPlayer {
                     path: this.activeClip.path,
                     state: !((_b = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _b === void 0 ? void 0 : _b.paused) ? VideoState_1.ActiveVideoClipState.Playing : VideoState_1.ActiveVideoClipState.Paused,
                     loop: (_d = (_c = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _c === void 0 ? void 0 : _c.loop) !== null && _d !== void 0 ? _d : false,
-                    volume: ((_e = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _e === void 0 ? void 0 : _e.muted) ? 0
+                    volume: ((_e = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _e === void 0 ? void 0 : _e.muted)
+                        ? 0
                         : (_g = (_f = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _f === void 0 ? void 0 : _f.volume) !== null && _g !== void 0 ? _g : 0,
                 }
                 : undefined,
@@ -284,7 +284,7 @@ class VideoPlayer {
     createVideoElement(path, config, { volume }) {
         const videoElement = document.createElement('video');
         videoElement.playsInline = true; // Required for iOS
-        videoElement.src = urls_1.assetUrl(path);
+        videoElement.src = (0, urls_1.assetUrl)(path);
         videoElement.autoplay = false;
         videoElement.loop = false;
         setVideoElementVolume(videoElement, volume * this.globalVolume);