@vouchfor/embeds 0.0.0-experiment.70f6f8d → 0.0.0-experiment.74a768c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vouchfor/embeds",
-  "version": "0.0.0-experiment.70f6f8d",
+  "version": "0.0.0-experiment.74a768c",
   "license": "MIT",
   "author": "Aaron Williams",
   "main": "dist/es/embeds.js",
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@lit/task": "^1.0.0",
-    "@vouchfor/media-player": "0.0.0-experiment.70f6f8d",
+    "@vouchfor/media-player": "0.0.0-experiment.74a768c",
     "uuid": "^9.0.1"
   },
   "peerDependencies": {

package/src/components/Embed/controllers/tracking.ts

@@ -6,13 +6,13 @@ import type { ReactiveController, ReactiveControllerHost } from 'lit';
 
 import { getEnvUrls } from '~/utils/env';
 
-const STREAMED_THROTTLE = 10000;
+// In seconds due to checking against node.currentTime
+const STREAMED_THROTTLE = 10;
 
 type EmbedHost = ReactiveControllerHost & Embed;
 
 type TrackingEvent = 'VOUCH_LOADED' | 'VOUCH_RESPONSE_VIEWED' | 'VIDEO_PLAYED' | 'VIDEO_STREAMED';
 type TrackingPayload = {
-  vouchId: string;
   answerId?: string;
   streamStart?: number;
   streamEnd?: number;
@@ -36,8 +36,9 @@ class TrackingController implements ReactiveController {
   private _hasPlayed = false;
   private _hasLoaded: BooleanMap = {};
   private _answersViewed: BooleanMap = {};
-  private _streamedTime: TimeMap = {};
-  private _streamedPrevTimestamp: TimeMap = {};
+  private _streamStartTime: TimeMap = {};
+  private _streamLatestTime: TimeMap = {};
+  private _currentlyPlayingVideo: VideoEventDetail | null = null;
 
   constructor(host: EmbedHost) {
     this.host = host;
@@ -128,26 +129,30 @@ class TrackingController implements ReactiveController {
     };
   };
 
-  private _sendTrackingEvent = (event: TrackingEvent, payload: TrackingPayload) => {
+  private _sendTrackingEvent = (event: TrackingEvent, payload?: TrackingPayload) => {
+    const vouchId = this._findVouchId();
+
+    if (!vouchId || this.host.disableTracking) {
+      return;
+    }
+
     const { publicApiUrl } = getEnvUrls(this.host.env);
     const { client, tab, request, visitor } = this._getUids();
 
-    if (this.host.enableTracking) {
-      navigator.sendBeacon(
-        `${publicApiUrl}/api/events`,
-        JSON.stringify({
-          event,
-          payload,
-          context: {
-            'x-uid-client': client,
-            'x-uid-tab': tab,
-            'x-uid-request': request,
-            'x-uid-visitor': visitor,
-            'x-reporting-metadata': this._getReportingMetadata()
-          }
-        })
-      );
-    }
+    navigator.sendBeacon(
+      `${publicApiUrl}/api/events`,
+      JSON.stringify({
+        event,
+        payload,
+        context: {
+          'x-uid-client': client,
+          'x-uid-tab': tab,
+          'x-uid-request': request,
+          'x-uid-visitor': visitor,
+          'x-reporting-metadata': this._getReportingMetadata()
+        }
+      })
+    );
   };
 
   private _handleVouchLoaded = ({ detail: vouchId }: CustomEvent<string>) => {
@@ -157,96 +162,74 @@ class TrackingController implements ReactiveController {
 
     // Only send loaded event once per session
     if (!this._hasLoaded[vouchId]) {
-      this._sendTrackingEvent('VOUCH_LOADED', {
-        vouchId
-      });
+      this._sendTrackingEvent('VOUCH_LOADED');
       this._hasLoaded[vouchId] = true;
     }
   };
 
   private _handlePlay = () => {
-    const vouchId = this._findVouchId();
-
-    if (!vouchId) {
-      return;
-    }
-
     // Only send the video played event once per session
     if (!this._hasPlayed) {
       this._sendTrackingEvent('VIDEO_PLAYED', {
-        vouchId,
         streamStart: this.host.currentTime
       });
       this._hasPlayed = true;
     }
   };
 
-  private _handleVideoPlay = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
-
-    if (!vouchId) {
-      return;
-    }
+  private _handleVideoPlay = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
     // Only increment play count once per session
-    if (!this._answersViewed[id]) {
+    if (!this._answersViewed[key]) {
       this._sendTrackingEvent('VOUCH_RESPONSE_VIEWED', {
-        vouchId,
         answerId: id
       });
-      this._answersViewed[id] = true;
+      this._answersViewed[key] = true;
     }
-    this._streamedTime[id] = node.currentTime;
-    this._streamedPrevTimestamp[id] = Date.now();
-  };
 
-  private _handleVideoTimeUpdate = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
+    this._streamStartTime[key] = node.currentTime;
+    this._streamLatestTime[key] = node.currentTime;
+  };
 
-    if (!vouchId) {
-      return;
+  private _handleVideoTimeUpdate = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
+    // We only want to count any time that the video is actually playing
+    if (!this.host.paused) {
+      this._currentlyPlayingVideo = { id, key, node };
+      this._streamLatestTime[key] = node.currentTime;
     }
-    const currentTimestamp = Date.now();
+
     if (
-      node.currentTime &&
       !node.paused &&
       !this.host.paused &&
       // Only fire the video seeked event when this video is the active one
       id === this.host.scene?.video?.id &&
       // Throttle the frequency that we send streamed events while playing
-      currentTimestamp - this._streamedPrevTimestamp[id] > STREAMED_THROTTLE
+      this._streamLatestTime[key] - this._streamStartTime[key] > STREAMED_THROTTLE
     ) {
       this._sendTrackingEvent('VIDEO_STREAMED', {
-        vouchId,
         answerId: id,
-        streamStart: this._streamedTime[id],
-        streamEnd: node.currentTime
+        streamStart: this._streamStartTime[key],
+        streamEnd: this._streamLatestTime[key]
       });
-      this._streamedTime[id] = node.currentTime;
-      this._streamedPrevTimestamp[id] = currentTimestamp;
-    }
-  };
 
-  private _handleVideoPause = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
-
-    if (!vouchId) {
-      return;
+      this._streamStartTime[key] = node.currentTime;
     }
+  };
 
-    // Don't send a tracking event if the video pauses when seeking backwards
-    if (node.currentTime > this._streamedTime[id]) {
+  private _handleVideoPause = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
+    // Don't send a tracking event when seeking backwards
+    if (this._streamLatestTime[key] > this._streamStartTime[key]) {
       // Send a video streamed event any time the video pauses then reset the streamed state
       // We do this to capture the last bit of time that the video was played between the previous
       // stream event and the video being paused manually or stopping because it ended
       this._sendTrackingEvent('VIDEO_STREAMED', {
-        vouchId,
         answerId: id,
-        streamStart: this._streamedTime[id],
-        streamEnd: node.currentTime
+        streamStart: this._streamStartTime[key],
+        streamEnd: this._streamLatestTime[key]
       });
     }
-    delete this._streamedTime[id];
-    delete this._streamedPrevTimestamp[id];
+    this._currentlyPlayingVideo = null;
+    delete this._streamStartTime[key];
+    delete this._streamLatestTime[key];
   };
 
   hostConnected() {
@@ -260,6 +243,20 @@ class TrackingController implements ReactiveController {
   }
 
   hostDisconnected() {
+    if (this._currentlyPlayingVideo) {
+      const { id, key } = this._currentlyPlayingVideo;
+      if (this._streamLatestTime[key] > this._streamStartTime[key]) {
+        // Send a video streamed event any time the video pauses then reset the streamed state
+        // We do this to capture the last bit of time that the video was played between the previous
+        // stream event and the video being paused manually or stopping because it ended
+        this._sendTrackingEvent('VIDEO_STREAMED', {
+          answerId: id,
+          streamStart: this._streamStartTime[key],
+          streamEnd: this._streamLatestTime[key]
+        });
+      }
+    }
+
     this.host.removeEventListener('vouch:loaded', this._handleVouchLoaded);
     this.host.mediaPlayer?.removeEventListener('play', this._handlePlay);
     this.host.mediaPlayer?.removeEventListener('video:play', this._handleVideoPlay);

package/src/components/Embed/index.ts

@@ -17,7 +17,7 @@ import '@vouchfor/media-player';
 type EmbedProps = Pick<MediaPlayerProps, 'data' | 'aspectRatio' | 'preload' | 'autoplay' | 'controls'> & {
   env: Environment;
   apiKey: string;
-  enableTracking?: boolean;
+  disableTracking?: boolean;
   trackingSource?: string;
   vouchId?: string;
   templateId?: string;
@@ -33,7 +33,7 @@ class Embed extends LitElement {
 
   @property({ type: String }) env: EmbedProps['env'] = 'prod';
   @property({ type: String }) apiKey: EmbedProps['apiKey'] = '';
-  @property({ type: Boolean }) enableTracking: EmbedProps['enableTracking'] = true;
+  @property({ type: Boolean }) disableTracking: EmbedProps['disableTracking'] = false;
   @property({ type: String }) trackingSource: EmbedProps['trackingSource'] = 'embed';
 
   @property({ type: Array }) controls: EmbedProps['controls'];
@@ -59,6 +59,7 @@ class Embed extends LitElement {
     'waiting',
 
     'video:loadeddata',
+    'video:seeking',
     'video:seeked',
     'video:play',
     'video:playing',