@vouchfor/embeds 0.0.0-experiment.af36011 → 0.0.0-experiment.b393461

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vouchfor/embeds",
-  "version": "0.0.0-experiment.af36011",
+  "version": "0.0.0-experiment.b393461",
   "license": "MIT",
   "author": "Aaron Williams",
   "main": "dist/es/embeds.js",
@@ -28,7 +28,8 @@
     "size": "size-limit",
     "storybook": "yarn prebuild && storybook dev -p 6007",
     "prebuild": "yarn build:deps && yarn generate:manifest",
-    "test": "true"
+    "test": "rm -rf test/lib && yarn prebuild && vite build --mode test && web-test-runner",
+    "test:ci": "yarn test"
   },
   "lint-staged": {
     "**/*.{ts,tsx,js}": "eslint --fix --quiet",
@@ -36,7 +37,7 @@
   },
   "dependencies": {
     "@lit/task": "^1.0.0",
-    "@vouchfor/media-player": "0.0.0-experiment.af36011",
+    "@vouchfor/media-player": "0.0.0-experiment.b393461",
     "uuid": "^9.0.1"
   },
   "peerDependencies": {
@@ -69,6 +70,7 @@
     "storybook": "^7.4.5",
     "typescript": "^5.1.3",
     "vite": "^4.4.9",
+    "vite-plugin-commonjs": "^0.10.0",
     "vite-plugin-dts": "^3.6.0",
     "web-component-analyzer": "^1.1.7"
   }

package/src/components/Embed/Embed.spec.ts

@@ -0,0 +1,17 @@
+import { expect } from '@esm-bundle/chai';
+// import { fixture } from '@open-wc/testing';
+// import { html } from 'lit';
+
+// import type { Embed } from './index.js';
+
+// Can't use typescript aliases with esbuild file transforms apparently
+// No idea what a good way to actually build before testing is, the examples give nothing
+// https://modern-web.dev/guides/test-runner/typescript/
+import '../../test/lib/embeds.js';
+
+describe('Embeds', () => {
+  it('passes', async () => {
+    expect(true).to.be.true;
+    // const player = await fixture<Embed>(html`<vouch-embed aspectratio=${1}></vouch-embed>`);
+  });
+});

package/src/components/Embed/Embed.stories.ts

@@ -10,7 +10,17 @@ type EmbedArgs = EmbedProps & {
   showVouch?: boolean;
 };
 
-const _Embed = ({ vouchId, templateId, preload, autoplay, env, apiKey, controls, aspectRatio }: EmbedArgs) => {
+const _Embed = ({
+  vouchId,
+  templateId,
+  questions,
+  preload,
+  autoplay,
+  env,
+  apiKey,
+  controls,
+  aspectRatio
+}: EmbedArgs) => {
   return html`
     <div style="height: 100vh">
       <vouch-embed
@@ -18,10 +28,12 @@ const _Embed = ({ vouchId, templateId, preload, autoplay, env, apiKey, controls,
         apiKey=${ifDefined(apiKey)}
         vouchId=${ifDefined(vouchId)}
         templateId=${ifDefined(templateId)}
+        .questions=${questions}
         .controls=${controls}
         ?autoplay=${autoplay}
         preload=${ifDefined(preload)}
         aspectRatio=${ifDefined(aspectRatio)}
+        @error=${console.log}
       ></vouch-embed>
     </div>
   `;
@@ -43,6 +55,7 @@ const Embed: Story = {
     apiKey: 'TVik9uTMgE-PD25UTHIS6gyl0hMBWC7AT4dkpdlLBT4VIfDWZJrQiCk6Ak7m1',
     vouchId: '6JQEIPeStt',
     templateId: '357fc118-e179-4171-9446-ff2b8e9d1b29',
+    questions: [],
     aspectRatio: 0,
     preload: 'none',
     autoplay: false

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

@@ -9,7 +9,7 @@ import { getEnvUrls } from '~/utils/env';
 
 type EmbedHost = ReactiveControllerHost & Embed;
 
-type TaskDeps = [
+type FetchTaskDeps = [
   EmbedProps['env'],
   EmbedProps['apiKey'],
   EmbedProps['data'],
@@ -17,10 +17,13 @@ type TaskDeps = [
   EmbedProps['templateId']
 ];
 
+type FilterTaskDeps = [EmbedProps['data'], EmbedProps['questions']];
+
 class FetcherController {
   host: EmbedHost;
 
   private _fetching = false;
+  private _vouch: EmbedProps['data'];
 
   set fetching(value) {
     if (this._fetching !== value) {
@@ -45,13 +48,13 @@ class FetcherController {
     });
 
     const vouch = await res.json();
-    this.host.dispatchEvent(new CustomEvent('vouch:loaded', { detail: vouchId }));
+    this.host.dispatchEvent(new CustomEvent('vouch:loaded', { detail: vouch?.id }));
 
     // HACK: we're currently using API Gateway caching on the embed API without any invalidation logic,
     // so to ensure that the cache stays up to date, whenever we detect a cache hit we trigger another
     // API call with the `Cache-Control` header which will re-fill the cache
     const resCacheCheck = res?.headers?.get('X-Cache-Check');
-    if (resCacheCheck && resCacheCheck !== cacheCheck) {
+    if (resCacheCheck !== cacheCheck) {
       fetch(`${embedApiUrl}/vouches/${vouchId}`, {
         method: 'GET',
         headers: [
@@ -81,7 +84,7 @@ class FetcherController {
     // so to ensure that the cache stays up to date, whenever we detect a cache hit we trigger another
     // API call with the `Cache-Control` header which will re-fill the cache
     const resCacheCheck = res?.headers?.get('X-Cache-Check');
-    if (resCacheCheck && resCacheCheck !== cacheCheck) {
+    if (resCacheCheck !== cacheCheck) {
       fetch(`${embedApiUrl}/templates/${templateId}`, {
         method: 'GET',
         headers: [
@@ -96,9 +99,9 @@ class FetcherController {
 
   constructor(host: EmbedHost) {
     this.host = host;
-    new Task<TaskDeps, void>(
+    new Task<FetchTaskDeps, void>(
       this.host,
-      async ([env, apiKey, data, vouchId, templateId]: TaskDeps) => {
+      async ([env, apiKey, data, vouchId, templateId]: FetchTaskDeps) => {
         try {
           host.vouch = undefined;
           host.template = undefined;
@@ -109,7 +112,7 @@ class FetcherController {
               this.fetching = true;
               template = await this.getTemplate(env, apiKey, templateId);
             }
-            host.vouch = data;
+            this._vouch = data;
             host.template = template ?? data?.settings?.template?.instance;
           } else if (vouchId) {
             this.fetching = true;
@@ -118,7 +121,7 @@ class FetcherController {
               this.getVouch(env, apiKey, vouchId),
               templateId ? this.getTemplate(env, apiKey, templateId) : null
             ]);
-            host.vouch = vouch;
+            this._vouch = vouch;
             host.template = template ?? vouch?.settings?.template?.instance;
           }
         } finally {
@@ -127,6 +130,22 @@ class FetcherController {
       },
       () => [host.env, host.apiKey, host.data, host.vouchId, host.templateId]
     );
+
+    // This second task is to be able to filter the vouch without fetching it again if only the questions changed
+    new Task<FilterTaskDeps, void>(
+      this.host,
+      ([vouch, questions]: FilterTaskDeps) => {
+        host.vouch = vouch
+          ? {
+              ...vouch,
+              questions: {
+                items: vouch?.questions.items.filter((_, index) => !questions?.length || questions?.includes(index + 1))
+              }
+            }
+          : undefined;
+      },
+      () => [this._vouch, host.questions]
+    );
   }
 }
 

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

@@ -1,19 +1,20 @@
-/* eslint-disable max-lines */
+import { TEMPLATE_VERSION } from '@vouchfor/canvas-video';
 import { v4 as uuidv4 } from 'uuid';
 
 import type { Embed } from '..';
 import type { VideoEventDetail } from '@vouchfor/media-player';
 import type { ReactiveController, ReactiveControllerHost } from 'lit';
 
+import packageJson from '../../../../package.json';
 import { getEnvUrls } from '~/utils/env';
 
-const STREAMED_THROTTLE = 10000;
+const MINIMUM_SEND_THRESHOLD = 1;
 
 type EmbedHost = ReactiveControllerHost & Embed;
 
 type TrackingEvent = 'VOUCH_LOADED' | 'VOUCH_RESPONSE_VIEWED' | 'VIDEO_PLAYED' | 'VIDEO_STREAMED';
 type TrackingPayload = {
-  vouchId: string;
+  vouchId?: string;
   answerId?: string;
   streamStart?: number;
   streamEnd?: number;
@@ -37,22 +38,23 @@ class TrackingController implements ReactiveController {
   private _hasPlayed = false;
   private _hasLoaded: BooleanMap = {};
   private _answersViewed: BooleanMap = {};
-  private _streamedTime: TimeMap = {};
+  private _streamStartTime: TimeMap = {};
   private _streamLatestTime: TimeMap = {};
-  private _streamedPrevTimestamp: TimeMap = {};
+  private _currentlyPlayingVideo: VideoEventDetail | null = null;
 
   constructor(host: EmbedHost) {
     this.host = host;
     host.addController(this);
   }
 
-  private _findVouchId() {
+  private _findVouchId(payload?: TrackingPayload) {
+    if (payload && 'vouchId' in payload) {
+      return payload.vouchId;
+    }
     if (this.host.vouch) {
-      if ('uuid' in this.host.vouch) {
-        return this.host.vouch.uuid;
-      }
       return this.host.vouch.id;
     }
+    return null;
   }
 
   private _createVisitor = (visitorId: string) => {
@@ -126,23 +128,31 @@ class TrackingController implements ReactiveController {
       screenWidth: window.screen.width,
       referrer: document.referrer,
       currentUrl: location.href,
+      embedType: 'media-player-embed',
+      embedVersion: packageJson.version,
+      templateVersion: TEMPLATE_VERSION,
       ...utmParams
     };
   };
 
-  private _sendTrackingEvent = (event: TrackingEvent, payload: TrackingPayload) => {
-    const { publicApiUrl } = getEnvUrls(this.host.env);
-    const { client, tab, request, visitor } = this._getUids();
+  private _sendTrackingEvent = (event: TrackingEvent, payload?: TrackingPayload) => {
+    const vouchId = this._findVouchId(payload);
 
-    if (this.host.disableTracking) {
+    if (!vouchId || this.host.disableTracking) {
       return;
     }
 
+    const { publicApiUrl } = getEnvUrls(this.host.env);
+    const { client, tab, request, visitor } = this._getUids();
+
     navigator.sendBeacon(
-      `${publicApiUrl}/api/events`,
+      `${publicApiUrl}/api/v2/events`,
       JSON.stringify({
         event,
-        payload,
+        payload: {
+          ...payload,
+          vouchId
+        },
         context: {
           'x-uid-client': client,
           'x-uid-tab': tab,
@@ -154,6 +164,26 @@ class TrackingController implements ReactiveController {
     );
   };
 
+  private _streamEnded = () => {
+    if (this._currentlyPlayingVideo) {
+      const { id, key } = this._currentlyPlayingVideo;
+      // Don't send a tracking event when seeking backwards
+      if (this._streamLatestTime[key] > this._streamStartTime[key] + MINIMUM_SEND_THRESHOLD) {
+        // Send a video streamed event any time the stream ends to capture the time between starting
+        // the video and the video stopping for any reason (pausing, deleting the embed node or closing the browser)
+        this._sendTrackingEvent('VIDEO_STREAMED', {
+          answerId: id,
+          streamStart: this._streamStartTime[key],
+          streamEnd: this._streamLatestTime[key]
+        });
+      }
+
+      // Make sure these events are only sent once by deleting the start and latest times
+      delete this._streamStartTime[key];
+      delete this._streamLatestTime[key];
+    }
+  };
+
   private _handleVouchLoaded = ({ detail: vouchId }: CustomEvent<string>) => {
     if (!vouchId) {
       return;
@@ -161,143 +191,102 @@ class TrackingController implements ReactiveController {
 
     // Only send loaded event once per session
     if (!this._hasLoaded[vouchId]) {
-      this._sendTrackingEvent('VOUCH_LOADED', {
-        vouchId
-      });
+      this._sendTrackingEvent('VOUCH_LOADED', { vouchId });
       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._streamedTime[id] = node.currentTime;
-    this._streamLatestTime[id] = node.currentTime;
-    this._streamedPrevTimestamp[id] = Date.now();
-  };
-
-  private _handleVideoSeeking = ({ detail: { id } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
-
-    if (!vouchId) {
-      return;
+      this._answersViewed[key] = true;
     }
 
-    if (this._streamLatestTime[id]) {
-      this._sendTrackingEvent('VIDEO_STREAMED', {
-        vouchId,
-        answerId: id,
-        streamStart: this._streamedTime[id],
-        streamEnd: this._streamLatestTime[id]
-      });
+    if (!this._streamStartTime[key]) {
+      this._streamStartTime[key] = node.currentTime;
+      this._streamLatestTime[key] = node.currentTime;
     }
-
-    delete this._streamedTime[id];
-    delete this._streamLatestTime[id];
-    delete this._streamedPrevTimestamp[id];
   };
 
-  private _handleVideoTimeUpdate = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
-
-    if (!vouchId) {
-      return;
-    }
-
-    const currentTimestamp = Date.now();
+  private _handleVideoTimeUpdate = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
     if (
-      node.currentTime &&
-      !node.paused &&
+      // We only want to count any time that the video is actually playing
       !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
+      // Only update the latest time if this event fires for the currently active video
+      id === this.host.scene?.video?.id
     ) {
+      this._currentlyPlayingVideo = { id, key, node };
+      this._streamLatestTime[key] = node.currentTime;
+    }
+  };
+
+  private _handleVideoPause = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
+    if (this._streamLatestTime[key] > this._streamStartTime[key] + MINIMUM_SEND_THRESHOLD) {
       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;
     }
-
-    this._streamLatestTime[id] = node.currentTime;
+    delete this._streamStartTime[key];
+    delete this._streamLatestTime[key];
   };
 
-  private _handleVideoPause = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
-    const vouchId = this._findVouchId();
+  private _pageUnloading = () => {
+    this._streamEnded();
+    // This will try to send the same stream event again so we delete the start and latest
+    // time in stream ended so that there is no times to send and the pause event does nothing
+    this.host.pause();
+  };
 
-    if (!vouchId) {
-      return;
-    }
-
-    // Don't send a tracking event if the video pauses when seeking backwards
-    if (node.currentTime > this._streamedTime[id]) {
-      // 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
-      });
+  private _handleVisibilityChange = () => {
+    if (document.visibilityState === 'hidden') {
+      this._pageUnloading();
     }
+  };
 
-    delete this._streamedTime[id];
-    delete this._streamLatestTime[id];
-    delete this._streamedPrevTimestamp[id];
+  private _handlePageHide = () => {
+    this._pageUnloading();
   };
 
   hostConnected() {
     requestAnimationFrame(() => {
+      if ('onvisibilitychange' in document) {
+        document.addEventListener('visibilitychange', this._handleVisibilityChange);
+      } else {
+        window.addEventListener('pagehide', this._handlePageHide);
+      }
       this.host.addEventListener('vouch:loaded', this._handleVouchLoaded);
       this.host.mediaPlayer?.addEventListener('play', this._handlePlay);
       this.host.mediaPlayer?.addEventListener('video:play', this._handleVideoPlay);
-      this.host.mediaPlayer?.addEventListener('video:seeking', this._handleVideoSeeking);
       this.host.mediaPlayer?.addEventListener('video:pause', this._handleVideoPause);
       this.host.mediaPlayer?.addEventListener('video:timeupdate', this._handleVideoTimeUpdate);
     });
   }
 
   hostDisconnected() {
+    this._streamEnded();
+    if ('onvisibilitychange' in document) {
+      document.removeEventListener('visibilitychange', this._handleVisibilityChange);
+    } else {
+      window.removeEventListener('pagehide', this._handlePageHide);
+    }
     this.host.removeEventListener('vouch:loaded', this._handleVouchLoaded);
     this.host.mediaPlayer?.removeEventListener('play', this._handlePlay);
     this.host.mediaPlayer?.removeEventListener('video:play', this._handleVideoPlay);
-    this.host.mediaPlayer?.removeEventListener('video:seeking', this._handleVideoSeeking);
     this.host.mediaPlayer?.removeEventListener('video:pause', this._handleVideoPause);
     this.host.mediaPlayer?.removeEventListener('video:timeupdate', this._handleVideoTimeUpdate);
   }

package/src/components/Embed/index.ts

@@ -1,9 +1,9 @@
-import { html, LitElement } from 'lit';
+import { css, html, LitElement } from 'lit';
 import { customElement, property, state } from 'lit/decorators.js';
 import { ifDefined } from 'lit/directives/if-defined.js';
 import { createRef, ref } from 'lit/directives/ref.js';
 
-import type { Scene, TemplateInstance } from '@vouchfor/canvas-video';
+import type { Scene, Scenes, TemplateInstance } from '@vouchfor/canvas-video';
 import type { MediaPlayer, MediaPlayerProps } from '@vouchfor/media-player';
 import type { Ref } from 'lit/directives/ref.js';
 import type { Environment } from '~/utils/env';
@@ -21,20 +21,31 @@ type EmbedProps = Pick<MediaPlayerProps, 'data' | 'aspectRatio' | 'preload' | 'a
   trackingSource?: string;
   vouchId?: string;
   templateId?: string;
+  // Index of the questions to include starting from 1
+  questions?: number[];
 };
 
 @customElement('vouch-embed')
 class Embed extends LitElement {
+  static styles = [
+    css`
+      :host {
+        display: flex;
+      }
+    `
+  ];
+
   private _mediaPlayerRef: Ref<MediaPlayer> = createRef();
 
-  @property({ type: Object, attribute: 'data' }) data: EmbedProps['data'];
+  @property({ type: Object }) data: EmbedProps['data'];
   @property({ type: String }) vouchId: EmbedProps['vouchId'];
   @property({ type: String }) templateId: EmbedProps['templateId'];
+  @property({ type: Array }) questions: EmbedProps['questions'];
 
   @property({ type: String }) env: EmbedProps['env'] = 'prod';
   @property({ type: String }) apiKey: EmbedProps['apiKey'] = '';
   @property({ type: Boolean }) disableTracking: EmbedProps['disableTracking'] = false;
-  @property({ type: String }) trackingSource: EmbedProps['trackingSource'] = 'embed';
+  @property({ type: String }) trackingSource: EmbedProps['trackingSource'] = 'embedded_player';
 
   @property({ type: Array }) controls: EmbedProps['controls'];
   @property({ type: String }) preload: EmbedProps['preload'] = 'auto';
@@ -149,6 +160,10 @@ class Embed extends LitElement {
     return this._mediaPlayerRef.value?.scenes ?? [];
   }
 
+  get sceneConfig(): Scenes | null {
+    return this._mediaPlayerRef.value?.sceneConfig ?? null;
+  }
+
   get videoState() {
     return this._mediaPlayerRef.value?.videoState;
   }
@@ -171,7 +186,7 @@ class Embed extends LitElement {
 
   render() {
     return html`
-      <vmp-new-media-player
+      <vmp-media-player
         ${ref(this._mediaPlayerRef)}
         ${this.eventController.register()}
         ?autoplay=${this.autoplay}
@@ -181,7 +196,7 @@ class Embed extends LitElement {
         aspectRatio=${ifDefined(this.aspectRatio)}
         preload=${ifDefined(this.preload)}
         .controls=${this.controls}
-      ></vmp-new-media-player>
+      ></vmp-media-player>
     `;
   }
 }