@vouchfor/embeds 0.0.0-experiment.e828084 → 0.0.0-experiment.eb79200

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vouchfor/embeds",
-  "version": "0.0.0-experiment.e828084",
+  "version": "0.0.0-experiment.eb79200",
   "license": "MIT",
   "author": "Aaron Williams",
   "main": "dist/es/embeds.js",
@@ -35,10 +35,12 @@
     "**/*.{md,json,yml}": "prettier --write"
   },
   "dependencies": {
-    "@vouchfor/media-player": "0.0.0-experiment.e828084"
+    "@lit/task": "1.0.0",
+    "@vouchfor/media-player": "0.0.0-experiment.eb79200",
+    "uuid": "^9.0.1"
   },
   "peerDependencies": {
-    "lit": "^2.7.5"
+    "lit": "^3.0.2"
   },
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4-fix.0",

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

@@ -0,0 +1,82 @@
+import { html } from 'lit';
+import { ifDefined } from 'lit/directives/if-defined.js';
+
+import type { EmbedProps } from './';
+import type { Meta, StoryObj } from '@storybook/web-components';
+
+import './';
+
+type EmbedArgs = EmbedProps & {
+  showVouch?: boolean;
+};
+
+const _Embed = ({
+  vouchHashId,
+  preload,
+  autoplay,
+  env,
+  apiKey,
+  controls,
+  enableTracking,
+  trackingSource,
+
+  resolution,
+  aspectRatio
+}: EmbedArgs) => {
+  return html`
+    <div style="height: 100vh">
+      <vouch-embed
+        env=${ifDefined(env)}
+        apiKey=${ifDefined(apiKey)}
+        ?autoplay=${autoplay}
+        ?enableTracking=${enableTracking}
+        vouchHashId=${ifDefined(vouchHashId)}
+        resolution=${ifDefined(resolution)}
+        aspectRatio=${ifDefined(aspectRatio)}
+        preload=${ifDefined(preload)}
+        .controls=${controls}
+        trackingSource=${ifDefined(trackingSource)}
+      ></vouch-embed>
+    </div>
+  `;
+};
+
+// More on how to set up stories at: https://storybook.js.org/docs/web-components/writing-stories/introduction
+const meta = {
+  title: 'Embed',
+  tags: ['autodocs'],
+  render: (args) => _Embed(args),
+  component: 'vouch-embed'
+} satisfies Meta<EmbedProps>;
+
+type Story = StoryObj<EmbedArgs>;
+
+const Embed: Story = {
+  args: {
+    env: 'dev',
+    apiKey: 'TVik9uTMgE-PD25UTHIS6gyl0hMBWC7AT4dkpdlLBT4VIfDWZJrQiCk6Ak7m1',
+    vouchHashId: '6JQEIPeStt',
+    resolution: 1080,
+    aspectRatio: 0,
+    preload: 'none',
+    autoplay: false,
+    enableTracking: true,
+    trackingSource: 'media_player_storybook'
+  },
+  argTypes: {
+    env: {
+      control: 'radio',
+      options: ['prod', 'staging', 'dev']
+    },
+    preload: {
+      control: 'radio',
+      options: ['auto', 'none']
+    }
+  },
+  parameters: {
+    layout: 'fullscreen'
+  }
+};
+
+export default meta;
+export { Embed };

package/src/components/Embed/controllers/event-forwarder.ts

@@ -0,0 +1,47 @@
+import { createRef, ref } from 'lit/directives/ref.js';
+
+import type { Embed } from '..';
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { Ref } from 'lit/directives/ref.js';
+
+import { forwardEvent } from '~/utils/events';
+
+type EmbedHost = ReactiveControllerHost & Embed;
+
+class EventForwardController implements ReactiveController {
+  host: EmbedHost;
+
+  private _events: string[] = [];
+  private _cleanup: (() => void)[] = [];
+  private _forwardElementRef: Ref<HTMLElement> = createRef();
+
+  constructor(host: EmbedHost, events: string[]) {
+    this.host = host;
+    this._events = events;
+    host.addController(this);
+  }
+
+  register() {
+    return ref(this._forwardElementRef);
+  }
+
+  hostConnected() {
+    // Guaranteed to have the element ref in the RAF callback because of how the lit lifecycle works
+    requestAnimationFrame(() => {
+      this._events.forEach((event) => {
+        if (this._forwardElementRef.value) {
+          this._cleanup.push(forwardEvent(event, this._forwardElementRef.value, this.host));
+        }
+      });
+    });
+  }
+
+  hostDisconnected() {
+    this._cleanup.forEach((fn) => {
+      fn();
+    });
+    this._cleanup = [];
+  }
+}
+
+export { EventForwardController };

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

@@ -0,0 +1,43 @@
+import { Task } from '@lit/task';
+
+import type { Embed, EmbedProps } from '..';
+import type { ReactiveControllerHost } from 'lit';
+
+import { getEnvUrls } from '~/utils/env';
+
+type EmbedHost = ReactiveControllerHost & Embed;
+
+type TaskDeps = [EmbedProps['env'], EmbedProps['apiKey'], EmbedProps['vouchHashId']];
+
+class FetcherController {
+  host: EmbedHost;
+
+  constructor(host: EmbedHost) {
+    this.host = host;
+    new Task<TaskDeps, void>(
+      this.host,
+      async ([env, apiKey, vouchHashId]: TaskDeps) => {
+        try {
+          if (vouchHashId) {
+            host.fetching = true;
+
+            const { embedApiUrl } = getEnvUrls(env);
+
+            const data = await fetch(`${embedApiUrl}/vouches/${vouchHashId}`, {
+              method: 'GET',
+              headers: [['X-Api-Key', apiKey]]
+            }).then((response) => response.json());
+
+            host.data = data;
+            host.instance = data?.settings?.template?.instance;
+          }
+        } finally {
+          host.fetching = false;
+        }
+      },
+      () => [host.env, host.apiKey, host.vouchHashId]
+    );
+  }
+}
+
+export { FetcherController };

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

@@ -0,0 +1,268 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import type { Embed } from '..';
+import type { VideoEventDetail } from '@vouchfor/media-player';
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+
+import { getEnvUrls } from '~/utils/env';
+
+const STREAMED_THROTTLE = 2000;
+
+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;
+};
+
+type TimeMap = {
+  [key: string]: number;
+};
+
+type BooleanMap = {
+  [key: string]: boolean;
+};
+
+class TrackingController implements ReactiveController {
+  host: EmbedHost;
+
+  private _tabId: string | undefined = undefined;
+  private _clientId: string | undefined = undefined;
+  private _visitorId: string | undefined = undefined;
+
+  private _hasPlayed = false;
+  private _hasLoaded: BooleanMap = {};
+  private _answersViewed: BooleanMap = {};
+  private _streamedTime: TimeMap = {};
+  private _streamedPrevTimestamp: TimeMap = {};
+
+  constructor(host: EmbedHost) {
+    this.host = host;
+    host.addController(this);
+  }
+
+  private _findVouchId() {
+    if (this.host.data) {
+      if ('uuid' in this.host.data) {
+        return this.host.data.uuid;
+      }
+      return this.host.data.id;
+    }
+  }
+
+  private _createVisitor = (visitorId: string) => {
+    const { publicApiUrl } = getEnvUrls(this.host.env);
+    window.localStorage?.setItem?.('vouch-uid-visitor', visitorId);
+    navigator.sendBeacon(`${publicApiUrl}/api/visitor`, JSON.stringify({ visitorId }));
+    return visitorId;
+  };
+
+  private _getUids() {
+    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
+    const visitorId =
+      this._visitorId || window.localStorage?.getItem?.('vouch-uid-visitor') || this._createVisitor(uuidv4());
+    // Persisted for a user for the same device + browser, so we can e.g. search for all logs related to that browser
+    const clientId = this._clientId || window.localStorage?.getItem?.('vouch-uid-client') || uuidv4();
+    // Persisted in session storage, so we can search for everything the user has done in a specific tab
+    const tabId = this._tabId || window.sessionStorage?.getItem?.('vouch-uid-tab') || uuidv4();
+    // 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 and persist uids
+    if (visitorId !== this._visitorId) {
+      this._visitorId = visitorId;
+      window.localStorage?.setItem?.('vouch-uid-visitor', visitorId);
+    }
+
+    if (clientId !== this._clientId) {
+      this._clientId = clientId;
+      window.localStorage?.setItem?.('vouch-uid-client', clientId);
+    }
+
+    if (tabId !== this._tabId) {
+      this._tabId = tabId;
+      window.sessionStorage?.setItem?.('vouch-uid-tab', tabId);
+    }
+
+    return {
+      client: clientId,
+      tab: tabId,
+      request: requestId,
+      visitor: visitorId
+    };
+  }
+
+  private _getReportingMetadata = () => {
+    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 might be embeds, could be playlink etc.
+      source: this.host.trackingSource,
+      time: new Date(),
+      region,
+      country,
+      screenHeight: window.screen.height,
+      screenWidth: window.screen.width,
+      referrer: document.referrer,
+      currentUrl: location.href,
+      ...utmParams
+    };
+  };
+
+  private _sendTrackingEvent = (event: TrackingEvent, payload: TrackingPayload) => {
+    const { publicApiUrl } = getEnvUrls(this.host.env);
+    const { client, tab, request, visitor } = this._getUids();
+
+    // Don't send tracking if we don't have a source
+    if (this.host.enableTracking && this.host.trackingSource) {
+      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>) => {
+    if (!vouchId) {
+      return;
+    }
+
+    // Only send loaded event once per session
+    if (!this._hasLoaded[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;
+    }
+    // Only increment play count once per session
+    if (!this._answersViewed[id]) {
+      this._sendTrackingEvent('VOUCH_RESPONSE_VIEWED', {
+        vouchId,
+        answerId: id
+      });
+      this._answersViewed[id] = true;
+    }
+    this._streamedTime[id] = node.currentTime;
+    this._streamedPrevTimestamp[id] = Date.now();
+  };
+
+  private _handleVideoTimeUpdate = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
+    const vouchId = this._findVouchId();
+    if (!vouchId) {
+      return;
+    }
+    const currentTimestamp = Date.now();
+    if (
+      !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._sendTrackingEvent('VIDEO_STREAMED', {
+        vouchId,
+        answerId: id,
+        streamStart: this._streamedTime[id],
+        streamEnd: node.currentTime
+      });
+      this._streamedTime[id] = node.currentTime;
+      this._streamedPrevTimestamp[id] = currentTimestamp;
+    }
+  };
+
+  private _handleVideoPause = ({ detail: { id, node } }: CustomEvent<VideoEventDetail>) => {
+    const vouchId = this._findVouchId();
+    if (!vouchId) {
+      return;
+    }
+    // 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
+    });
+    delete this._streamedTime[id];
+    delete this._streamedPrevTimestamp[id];
+  };
+
+  hostConnected() {
+    if (this.host.enableTracking && this.host.trackingSource) {
+      requestAnimationFrame(() => {
+        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() {
+    if (this.host.enableTracking && this.host.trackingSource) {
+      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 };

package/src/components/Embed/index.ts

@@ -0,0 +1,204 @@
+import { html, LitElement } from 'lit';
+import { customElement, state, property } from 'lit/decorators.js';
+import { ifDefined } from 'lit/directives/if-defined.js';
+import { createRef, ref } from 'lit/directives/ref.js';
+
+import type { Scene } 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';
+
+import { EventForwardController } from './controllers/event-forwarder';
+import { FetcherController } from './controllers/fetcher';
+import { TrackingController } from './controllers/tracking';
+
+import '@vouchfor/media-player';
+
+type EmbedProps = Pick<
+  MediaPlayerProps,
+  'data' | 'resolution' | 'aspectRatio' | 'preload' | 'autoplay' | 'controls'
+> & {
+  env: Environment;
+  apiKey: string;
+  vouchHashId?: string;
+  enableTracking?: boolean;
+  trackingSource?: string;
+};
+
+@customElement('vouch-embed')
+class Embed extends LitElement {
+  private _mediaPlayerRef: Ref<MediaPlayer> = createRef();
+
+  @property({ type: Object, attribute: 'data' }) propData: EmbedProps['data'];
+  @property({ type: String }) vouchHashId: EmbedProps['vouchHashId'];
+
+  @property({ type: String }) env: EmbedProps['env'] = 'prod';
+  @property({ type: String }) apiKey: EmbedProps['apiKey'] = '';
+
+  @property({ type: String }) preload: EmbedProps['preload'] = 'auto';
+  @property({ type: Boolean }) autoplay: EmbedProps['autoplay'] = false;
+  @property({ type: Boolean }) enableTracking: EmbedProps['enableTracking'] = false;
+  @property({ type: String }) trackingSource: EmbedProps['trackingSource'] = 'media_player';
+
+  @property({ type: Number }) resolution: EmbedProps['resolution'] = 1080;
+  @property({ type: Number }) aspectRatio: EmbedProps['aspectRatio'] = 0;
+  @property({ type: Array }) controls: EmbedProps['controls'];
+
+  @state() data: MediaPlayerProps['data'];
+  @state() instance: MediaPlayerProps['instance'];
+  @state() fetching = false;
+
+  private eventController = new EventForwardController(this, [
+    'durationchange',
+    'ended',
+    'error',
+    'loadeddata',
+    'pause',
+    'stalled',
+    'play',
+    'playing',
+    'ratechange',
+    'scenechange',
+    'seeking',
+    'seeked',
+    'timeupdate',
+    'volumechange',
+    'waiting',
+
+    'video:loadeddata',
+    'video:seeked',
+    'video:play',
+    'video:playing',
+    'video:pause',
+    'video:stalled',
+    'video:timeupdate',
+    'video:ended',
+    'video:error'
+  ]);
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  private trackingController = new TrackingController(this);
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  private fetcherController = new FetcherController(this);
+
+  get waiting() {
+    return this._mediaPlayerRef.value?.waiting;
+  }
+
+  get seeking() {
+    return this._mediaPlayerRef.value?.seeking;
+  }
+
+  get paused() {
+    return this._mediaPlayerRef.value?.paused;
+  }
+
+  get captions() {
+    return this._mediaPlayerRef.value?.captions;
+  }
+
+  get fullscreen() {
+    return this._mediaPlayerRef.value?.fullscreen;
+  }
+
+  get duration() {
+    return this._mediaPlayerRef.value?.duration;
+  }
+
+  set currentTime(value: number) {
+    if (this._mediaPlayerRef.value) {
+      this._mediaPlayerRef.value.currentTime = value;
+    }
+  }
+  get currentTime() {
+    return this._mediaPlayerRef.value?.currentTime ?? 0;
+  }
+
+  set playbackRate(value: number) {
+    if (this._mediaPlayerRef.value) {
+      this._mediaPlayerRef.value.playbackRate = value;
+    }
+  }
+  get playbackRate() {
+    return this._mediaPlayerRef.value?.playbackRate ?? 1;
+  }
+
+  set volume(value: number) {
+    if (this._mediaPlayerRef.value) {
+      this._mediaPlayerRef.value.volume = value;
+    }
+  }
+  get volume() {
+    return this._mediaPlayerRef.value?.volume ?? 1;
+  }
+
+  set muted(value: boolean) {
+    if (this._mediaPlayerRef.value) {
+      this._mediaPlayerRef.value.muted = value;
+    }
+  }
+  get muted() {
+    return this._mediaPlayerRef.value?.muted ?? false;
+  }
+
+  get scene(): Scene | null {
+    return this._mediaPlayerRef.value?.scene ?? null;
+  }
+
+  get scenes(): Scene[] {
+    return this._mediaPlayerRef.value?.scenes ?? [];
+  }
+
+  get videoState() {
+    return this._mediaPlayerRef.value?.videoState;
+  }
+
+  get mediaPlayer() {
+    return this._mediaPlayerRef.value;
+  }
+
+  play() {
+    this._mediaPlayerRef.value?.play();
+  }
+
+  pause() {
+    this._mediaPlayerRef.value?.pause();
+  }
+
+  setScene(index: number) {
+    this._mediaPlayerRef.value?.setScene(index);
+  }
+
+  render() {
+    return html`
+      <vmp-media-player
+        ${ref(this._mediaPlayerRef)}
+        ${this.eventController.register()}
+        ?autoplay=${this.autoplay}
+        ?loading=${this.fetching}
+        .data=${this.data}
+        .instance=${this.instance}
+        resolution=${ifDefined(this.resolution)}
+        aspectRatio=${ifDefined(this.aspectRatio)}
+        preload=${ifDefined(this.preload)}
+        .controls=${this.controls}
+      ></vmp-media-player>
+    `;
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'vouch-embed': Embed;
+  }
+
+  namespace JSX {
+    interface IntrinsicElements {
+      'vouch-embed': Embed;
+    }
+  }
+}
+
+export { Embed };
+export type { EmbedProps };

package/src/index.ts

@@ -1 +1 @@
-export { InlineEmbed } from '~/components/InlineEmbed';
+export { Embed } from '~/components/Embed';