@vouchfor/embeds 0.0.0-experiment.08c37fe → 0.0.0-experiment.0add8bd

package/src/components/DialogEmbed/index.ts

@@ -0,0 +1,93 @@
+import { css, html, LitElement } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import { ifDefined } from 'lit/directives/if-defined.js';
+
+import type { PlayerEmbedProps } from '../PlayerEmbed';
+
+import '../PlayerEmbed';
+import './DialogPortal';
+
+type DialogEmbedProps = Omit<PlayerEmbedProps, 'data'> & {
+  disableAutoplay?: boolean;
+};
+
+@customElement('vouch-embed-dialog')
+class DialogEmbed extends LitElement {
+  static styles = [
+    css`
+      :host {
+        --vu-button-padding: 10px 20px;
+        --vu-button-background: #287179;
+        --vu-button-background-hover: #4faab2;
+
+        display: flex;
+        width: fit-content;
+        height: fit-content;
+      }
+    `
+  ];
+
+  @property({ type: String }) vouchId: DialogEmbedProps['vouchId'];
+  @property({ type: String }) templateId: DialogEmbedProps['templateId'];
+  @property({ type: Array }) questions: DialogEmbedProps['questions'];
+
+  @property({ type: String }) env: DialogEmbedProps['env'] = 'prod';
+  @property({ type: String }) apiKey: DialogEmbedProps['apiKey'] = '';
+  @property({ type: Boolean }) disableTracking: DialogEmbedProps['disableTracking'] = false;
+  @property({ type: String }) trackingSource: DialogEmbedProps['trackingSource'] = 'embedded_player';
+
+  @property({ type: Array }) controls: DialogEmbedProps['controls'];
+  @property({ type: String }) preload: DialogEmbedProps['preload'] = 'none';
+  @property({ type: Boolean }) disableAutoplay: DialogEmbedProps['disableAutoplay'] = false;
+  @property({ type: Number }) aspectRatio: DialogEmbedProps['aspectRatio'] = 0;
+
+  private _handleRootClick = () => {
+    this.dispatchEvent(new CustomEvent('dialogembed:click', { bubbles: true, composed: true }));
+  };
+
+  connectedCallback(): void {
+    super.connectedCallback();
+    this.addEventListener('click', this._handleRootClick);
+  }
+
+  disconnectedCallback(): void {
+    super.disconnectedCallback();
+    this.removeEventListener('click', this._handleRootClick);
+  }
+
+  render() {
+    return html`
+      <slot>
+        <vmp-button size="large">Play</vmp-button>
+      </slot>
+      <vouch-embed-dialog-portal
+        ?autoplay=${false}
+        vouchId=${ifDefined(this.vouchId)}
+        templateId=${ifDefined(this.templateId)}
+        .questions=${this.questions}
+        .controls=${this.controls}
+        env=${ifDefined(this.env)}
+        apiKey=${ifDefined(this.apiKey)}
+        ?disableTracking=${this.disableTracking}
+        trackingSource=${ifDefined(this.trackingSource)}
+        preload=${ifDefined(this.preload)}
+        aspectRatio=${this.aspectRatio}
+      ></vouch-embed-dialog-portal>
+    `;
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'vouch-embed-dialog': DialogEmbed;
+  }
+
+  namespace JSX {
+    interface IntrinsicElements {
+      'vouch-embed-dialog': DialogEmbed;
+    }
+  }
+}
+
+export { DialogEmbed };
+export type { DialogEmbedProps };

package/src/components/{Embed/Embed.stories.ts → PlayerEmbed/PlayerEmbed.stories.ts}

@@ -1,48 +1,61 @@
 import { html } from 'lit';
 import { ifDefined } from 'lit/directives/if-defined.js';
 
-import type { EmbedProps } from './';
+import type { PlayerEmbedProps } from '.';
 import type { Meta, StoryObj } from '@storybook/web-components';
 
-import './';
+import '.';
 
-type EmbedArgs = EmbedProps & {
+type PlayerEmbedArgs = PlayerEmbedProps & {
   showVouch?: boolean;
 };
 
-const _Embed = ({ vouchId, templateId, preload, autoplay, env, apiKey, controls, aspectRatio }: EmbedArgs) => {
+const _PlayerEmbed = ({
+  vouchId,
+  templateId,
+  questions,
+  preload,
+  autoplay,
+  env,
+  apiKey,
+  controls,
+  aspectRatio
+}: PlayerEmbedArgs) => {
   return html`
     <div style="height: 100vh">
-      <vouch-embed
+      <vouch-embed-player
         env=${ifDefined(env)}
         apiKey=${ifDefined(apiKey)}
         vouchId=${ifDefined(vouchId)}
         templateId=${ifDefined(templateId)}
+        .questions=${questions}
         .controls=${controls}
         ?autoplay=${autoplay}
         preload=${ifDefined(preload)}
         aspectRatio=${ifDefined(aspectRatio)}
-      ></vouch-embed>
+        @error=${console.log}
+      ></vouch-embed-player>
     </div>
   `;
 };
 
 // More on how to set up stories at: https://storybook.js.org/docs/web-components/writing-stories/introduction
 const meta = {
-  title: 'Embed',
+  title: 'Embeds',
   tags: ['autodocs'],
-  render: (args) => _Embed(args),
-  component: 'vouch-embed'
-} satisfies Meta<EmbedProps>;
+  render: (args) => _PlayerEmbed(args),
+  component: 'vouch-embed-player'
+} satisfies Meta<PlayerEmbedProps>;
 
-type Story = StoryObj<EmbedArgs>;
+type Story = StoryObj<PlayerEmbedArgs>;
 
-const Embed: Story = {
+const Player: Story = {
   args: {
-    env: 'local',
+    env: 'dev',
     apiKey: 'TVik9uTMgE-PD25UTHIS6gyl0hMBWC7AT4dkpdlLBT4VIfDWZJrQiCk6Ak7m1',
     vouchId: '6JQEIPeStt',
     templateId: '357fc118-e179-4171-9446-ff2b8e9d1b29',
+    questions: [],
     aspectRatio: 0,
     preload: 'none',
     autoplay: false
@@ -63,4 +76,4 @@ const Embed: Story = {
 };
 
 export default meta;
-export { Embed };
+export { Player };

package/src/components/{Embed → PlayerEmbed}/controllers/event-forwarder.ts

@@ -1,27 +1,28 @@
 import { createRef, ref } from 'lit/directives/ref.js';
 
-import type { Embed } from '..';
+import type { PlayerEmbed } from '..';
 import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { DirectiveResult } from 'lit/directive.js';
 import type { Ref } from 'lit/directives/ref.js';
 
 import { forwardEvent } from '~/utils/events';
 
-type EmbedHost = ReactiveControllerHost & Embed;
+type PlayerEmbedHost = ReactiveControllerHost & PlayerEmbed;
 
 class EventForwardController implements ReactiveController {
-  host: EmbedHost;
+  host: PlayerEmbedHost;
 
   private _events: string[] = [];
   private _cleanup: (() => void)[] = [];
   private _forwardElementRef: Ref<HTMLElement> = createRef();
 
-  constructor(host: EmbedHost, events: string[]) {
+  constructor(host: PlayerEmbedHost, events: string[]) {
     this.host = host;
     this._events = events;
     host.addController(this);
   }
 
-  register() {
+  register(): DirectiveResult {
     return ref(this._forwardElementRef);
   }
 

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

@@ -0,0 +1,152 @@
+import { Task } from '@lit/task';
+import { v4 as uuidv4 } from 'uuid';
+
+import type { PlayerEmbed, PlayerEmbedProps } from '..';
+import type { ReactiveControllerHost } from 'lit';
+import type { Environment } from '~/utils/env';
+
+import { getEnvUrls } from '~/utils/env';
+
+type PlayerEmbedHost = ReactiveControllerHost & PlayerEmbed;
+
+type FetchTaskDeps = [
+  PlayerEmbedProps['env'],
+  PlayerEmbedProps['apiKey'],
+  PlayerEmbedProps['data'],
+  PlayerEmbedProps['vouchId'],
+  PlayerEmbedProps['templateId']
+];
+
+type FilterTaskDeps = [PlayerEmbedProps['data'], PlayerEmbedProps['questions']];
+
+class FetcherController {
+  host: PlayerEmbedHost;
+
+  private _fetching = false;
+  private _vouch: PlayerEmbedProps['data'];
+
+  set fetching(value) {
+    if (this._fetching !== value) {
+      this._fetching = value;
+      this.host.requestUpdate();
+    }
+  }
+  get fetching() {
+    return this._fetching;
+  }
+
+  private getVouch = async (env: Environment, apiKey: string, vouchId: string) => {
+    const { embedApiUrl } = getEnvUrls(env);
+
+    const cacheCheck = uuidv4();
+    const res = await fetch(`${embedApiUrl}/vouches/${vouchId}`, {
+      method: 'GET',
+      headers: [
+        ['X-Api-Key', apiKey],
+        ['X-Cache-Check', cacheCheck]
+      ]
+    });
+
+    const vouch = await res.json();
+    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 !== cacheCheck) {
+      fetch(`${embedApiUrl}/vouches/${vouchId}`, {
+        method: 'GET',
+        headers: [
+          ['X-Api-Key', apiKey],
+          ['Cache-Control', 'max-age=0']
+        ]
+      });
+    }
+
+    return vouch;
+  };
+
+  private getTemplate = async (env: Environment, apiKey: string, templateId: string) => {
+    const { embedApiUrl } = getEnvUrls(env);
+
+    const cacheCheck = uuidv4();
+    const res = await fetch(`${embedApiUrl}/templates/${templateId}`, {
+      method: 'GET',
+      headers: [
+        ['X-Api-Key', apiKey],
+        ['X-Cache-Check', cacheCheck]
+      ]
+    });
+    const template = await res.json();
+
+    // 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 !== cacheCheck) {
+      fetch(`${embedApiUrl}/templates/${templateId}`, {
+        method: 'GET',
+        headers: [
+          ['X-Api-Key', apiKey],
+          ['Cache-Control', 'max-age=0']
+        ]
+      });
+    }
+
+    return template;
+  };
+
+  constructor(host: PlayerEmbedHost) {
+    this.host = host;
+    new Task<FetchTaskDeps, void>(
+      this.host,
+      async ([env, apiKey, data, vouchId, templateId]: FetchTaskDeps) => {
+        try {
+          host.vouch = undefined;
+          host.template = undefined;
+
+          if (data) {
+            let template;
+            if (templateId) {
+              this.fetching = true;
+              template = await this.getTemplate(env, apiKey, templateId);
+            }
+            this._vouch = data;
+            host.template = template ?? data?.settings?.template?.instance;
+          } else if (vouchId) {
+            this.fetching = true;
+
+            const [vouch, template] = await Promise.all([
+              this.getVouch(env, apiKey, vouchId),
+              templateId ? this.getTemplate(env, apiKey, templateId) : null
+            ]);
+            this._vouch = vouch;
+            host.template = template ?? vouch?.settings?.template?.instance;
+          }
+        } finally {
+          this.fetching = false;
+        }
+      },
+      () => [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]
+    );
+  }
+}
+
+export { FetcherController };

package/src/components/PlayerEmbed/controllers/tracking/index.ts

@@ -0,0 +1,224 @@
+import type { PlayerEmbed } from '../..';
+import type { VideoEventDetail } from '@vouchfor/media-player';
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+
+import { findVouchId, getReportingMetadata, getUids } from './utils';
+import { getEnvUrls } from '~/utils/env';
+
+const MINIMUM_SEND_THRESHOLD = 1;
+
+type PlayerEmbedHost = ReactiveControllerHost & PlayerEmbed;
+
+type TrackingEvent = 'VOUCH_LOADED' | 'VOUCH_RESPONSE_VIEWED' | 'VIDEO_PLAYED' | 'VIDEO_STREAMED';
+type TrackingPayload = {
+  vouchId?: string;
+  answerId?: string;
+  streamStart?: number;
+  streamEnd?: number;
+};
+
+type BatchEvent = {
+  event: TrackingEvent;
+  payload: TrackingPayload & {
+    time: string;
+  };
+};
+
+type TimeMap = {
+  [key: string]: number;
+};
+
+type BooleanMap = {
+  [key: string]: boolean;
+};
+
+class TrackingController implements ReactiveController {
+  host: PlayerEmbedHost;
+
+  private _batchedEvents: BatchEvent[] = [];
+  private _hasPlayed = false;
+  private _hasLoaded: BooleanMap = {};
+  private _answersViewed: BooleanMap = {};
+  private _streamStartTime: TimeMap = {};
+  private _streamLatestTime: TimeMap = {};
+  private _currentlyPlayingVideo: VideoEventDetail | null = null;
+
+  constructor(host: PlayerEmbedHost) {
+    this.host = host;
+    host.addController(this);
+  }
+
+  private _createTrackingEvent = (event: TrackingEvent, payload?: TrackingPayload) => {
+    const vouchId = findVouchId(payload, this.host.vouch);
+
+    if (!vouchId || this.host.disableTracking) {
+      return;
+    }
+
+    this._batchedEvents.push({
+      event,
+      payload: {
+        ...payload,
+        vouchId,
+        time: new Date().toISOString()
+      }
+    });
+  };
+
+  private _sendTrackingEvent = () => {
+    if (this._batchedEvents.length <= 0) {
+      return;
+    }
+
+    const { publicApiUrl } = getEnvUrls(this.host.env);
+    const { client, tab, request, visitor } = getUids(this.host.env);
+
+    navigator.sendBeacon(
+      `${publicApiUrl}/api/batchevents`,
+      JSON.stringify({
+        payload: {
+          events: this._batchedEvents
+        },
+        context: {
+          'x-uid-client': client,
+          'x-uid-tab': tab,
+          'x-uid-request': request,
+          'x-uid-visitor': visitor,
+          'x-reporting-metadata': getReportingMetadata(this.host.trackingSource)
+        }
+      })
+    );
+
+    this._batchedEvents = [];
+  };
+
+  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._createTrackingEvent('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;
+    }
+
+    // Only send loaded event once per session
+    if (!this._hasLoaded[vouchId]) {
+      this._createTrackingEvent('VOUCH_LOADED', { vouchId });
+      this._hasLoaded[vouchId] = true;
+    }
+  };
+
+  private _handlePlay = () => {
+    // Only send the video played event once per session
+    if (!this._hasPlayed) {
+      this._createTrackingEvent('VIDEO_PLAYED', {
+        streamStart: this.host.currentTime
+      });
+      this._hasPlayed = true;
+    }
+  };
+
+  private _handleVideoPlay = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
+    // Only increment play count once per session
+    if (!this._answersViewed[key]) {
+      this._createTrackingEvent('VOUCH_RESPONSE_VIEWED', {
+        answerId: id
+      });
+      this._answersViewed[key] = true;
+    }
+  };
+
+  private _handleVideoTimeUpdate = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
+    if (
+      // We only want to count any time that the video is actually playing
+      !this.host.paused &&
+      // 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;
+
+      if (!this._streamStartTime[key]) {
+        this._streamStartTime[key] = node.currentTime;
+        this._streamLatestTime[key] = node.currentTime;
+      }
+    }
+  };
+
+  private _handleVideoPause = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
+    if (this._streamLatestTime[key] > this._streamStartTime[key] + MINIMUM_SEND_THRESHOLD) {
+      this._createTrackingEvent('VIDEO_STREAMED', {
+        answerId: id,
+        streamStart: this._streamStartTime[key],
+        streamEnd: this._streamLatestTime[key]
+      });
+    }
+    delete this._streamStartTime[key];
+    delete this._streamLatestTime[key];
+  };
+
+  private _pageUnloading = () => {
+    this._streamEnded();
+    this._sendTrackingEvent();
+  };
+
+  private _handleVisibilityChange = () => {
+    if (document.visibilityState === 'hidden') {
+      this._pageUnloading();
+    }
+  };
+
+  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:pause', this._handleVideoPause);
+      this.host.mediaPlayer?.addEventListener('video:timeupdate', this._handleVideoTimeUpdate);
+    });
+  }
+
+  hostDisconnected() {
+    // Send events if DOM node is destroyed
+    this._pageUnloading();
+
+    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:pause', this._handleVideoPause);
+    this.host.mediaPlayer?.removeEventListener('video:timeupdate', this._handleVideoTimeUpdate);
+  }
+}
+
+export { TrackingController };
+export type { TrackingEvent, TrackingPayload };

package/src/components/PlayerEmbed/controllers/tracking/utils.ts

@@ -0,0 +1,95 @@
+import { TEMPLATE_VERSION } from '@vouchfor/canvas-video';
+import { v4 as uuidv4 } from 'uuid';
+
+import type { TrackingPayload } from '.';
+import type { Vouch } from '@vouchfor/media-player';
+import type { Environment } from '~/utils/env';
+
+import packageJson from '~/../package.json';
+import { getEnvUrls } from '~/utils/env';
+
+function createVisitor(env: Environment) {
+  const { publicApiUrl } = getEnvUrls(env);
+  const visitorId = uuidv4();
+  navigator.sendBeacon(`${publicApiUrl}/api/visitor`, JSON.stringify({ visitorId }));
+  return visitorId;
+}
+
+function getUids(env: Environment) {
+  if (typeof window === 'undefined') {
+    return {
+      client: null,
+      tab: null,
+      request: uuidv4()
+    };
+  }
+
+  // Persisted for a user for the same device + browser, so we can e.g. search for all logs related to that browser
+  let visitorId = window.localStorage?.getItem?.('vouch-uid-visitor');
+  // Persisted for a user for the same device + browser, so we can e.g. search for all logs related to that browser
+  let clientId = window.localStorage?.getItem?.('vouch-uid-client');
+  // Persisted in session storage, so we can search for everything the user has done in a specific tab
+  let tabId = window.sessionStorage?.getItem?.('vouch-uid-tab');
+  // Not persisted, allows us to search for any logs related to a single FE request
+  // E.g. BE should pass this request ID through all other services to be able to group logs
+  const requestId = uuidv4();
+
+  // Cache uids
+  if (!visitorId) {
+    visitorId = createVisitor(env);
+    window.localStorage?.setItem?.('vouch-uid-visitor', visitorId);
+  }
+
+  if (!clientId) {
+    clientId = uuidv4();
+    window.localStorage?.setItem?.('vouch-uid-client', clientId);
+  }
+
+  if (!tabId) {
+    tabId = uuidv4();
+    window.sessionStorage?.setItem?.('vouch-uid-tab', tabId);
+  }
+
+  return {
+    client: clientId,
+    tab: tabId,
+    request: requestId,
+    visitor: visitorId
+  };
+}
+
+function findVouchId(payload?: TrackingPayload, vouch?: Vouch) {
+  if (payload && 'vouchId' in payload) {
+    return payload.vouchId;
+  }
+  return vouch?.id ?? null;
+}
+
+function getReportingMetadata(source = 'embedded_player') {
+  const [country, region] = Intl.DateTimeFormat().resolvedOptions().timeZone?.split?.('/') ?? [];
+
+  const utmParams: any = {};
+  [...new URLSearchParams(location.search).entries()].forEach(([key, value]) => {
+    if (/utm/.test(key)) {
+      const param = key.toLowerCase().replace(/[-_][a-z0-9]/g, (group) => group.slice(-1).toUpperCase());
+      utmParams[param] = value;
+    }
+  });
+
+  return {
+    source,
+    time: new Date(),
+    region,
+    country,
+    screenHeight: window.screen.height,
+    screenWidth: window.screen.width,
+    referrer: document.referrer,
+    currentUrl: location.href,
+    embedType: 'media-player-embed',
+    embedVersion: packageJson.version,
+    templateVersion: TEMPLATE_VERSION,
+    ...utmParams
+  };
+}
+
+export { getUids, findVouchId, getReportingMetadata };