@vouchfor/embeds 0.0.0-experiment.0b5c8d1 → 0.0.0-experiment.0e35ffd

package/src/components/PlayerEmbed/MultiEmbed.stories.ts

@@ -0,0 +1,135 @@
+import { html } from 'lit';
+import { ifDefined } from 'lit/directives/if-defined.js';
+
+import type { PlayerEmbedProps } from '.';
+import type { Meta, StoryObj } from '@storybook/web-components';
+
+import '.';
+
+type MultiEmbedArgs = PlayerEmbedProps & {
+  apiKey1?: string;
+  apiKey2?: string;
+  apiKey3?: string;
+  vouchId1?: string;
+  vouchId2?: string;
+  vouchId3?: string;
+  showVouch?: boolean;
+};
+
+const _MultiEmbed = ({
+  vouchId1,
+  vouchId2,
+  vouchId3,
+  templateId,
+  questions,
+  preload,
+  autoplay,
+  env,
+  apiKey1,
+  apiKey2,
+  apiKey3,
+  controls,
+  aspectRatio
+}: MultiEmbedArgs) => {
+  return html`
+    <div style="height: 33vh">
+      <vouch-embed-player
+        env=${ifDefined(env)}
+        apiKey=${ifDefined(apiKey1)}
+        vouchId=${ifDefined(vouchId1)}
+        templateId=${ifDefined(templateId)}
+        .questions=${questions}
+        .controls=${controls}
+        ?autoplay=${autoplay}
+        preload=${ifDefined(preload)}
+        aspectRatio=${ifDefined(aspectRatio)}
+        @error=${console.log}
+      ></vouch-embed-player>
+    </div>
+    <div style="height: 33vh">
+      <vouch-embed-player
+        env=${ifDefined(env)}
+        apiKey=${ifDefined(apiKey2)}
+        vouchId=${ifDefined(vouchId2)}
+        templateId=${ifDefined(templateId)}
+        .questions=${questions}
+        .controls=${controls}
+        ?autoplay=${autoplay}
+        preload=${ifDefined(preload)}
+        aspectRatio=${ifDefined(aspectRatio)}
+        @error=${console.log}
+      ></vouch-embed-player>
+    </div>
+    <div style="height: 33vh">
+      <vouch-embed-player
+        env=${ifDefined(env)}
+        apiKey=${ifDefined(apiKey3)}
+        vouchId=${ifDefined(vouchId3)}
+        templateId=${ifDefined(templateId)}
+        .questions=${questions}
+        .controls=${controls}
+        ?autoplay=${autoplay}
+        preload=${ifDefined(preload)}
+        aspectRatio=${ifDefined(aspectRatio)}
+        @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: 'Embeds',
+  tags: ['autodocs'],
+  render: (args) => _MultiEmbed(args),
+  component: 'vouch-embed-player'
+} satisfies Meta<PlayerEmbedProps>;
+
+type Story = StoryObj<MultiEmbedArgs>;
+
+const MultiPlayer: Story = {
+  args: {
+    env: 'dev',
+    apiKey1: 'TVik9uTMgE-PD25UTHIS6gyl0hMBWC7AT4dkpdlLBT4VIfDWZJrQiCk6Ak7m1',
+    vouchId1: '6JQEIPeStt',
+    apiKey2: 'TVik9uTMgE-PD25UTHIS6gyl0hMBWC7AT4dkpdlLBT4VIfDWZJrQiCk6Ak7m1',
+    vouchId2: '6JQEIPeStt',
+    apiKey3: 'TVik9uTMgE-PD25UTHIS6gyl0hMBWC7AT4dkpdlLBT4VIfDWZJrQiCk6Ak7m1',
+    vouchId3: '6JQEIPeStt',
+    templateId: '357fc118-e179-4171-9446-ff2b8e9d1b29',
+    questions: [],
+    aspectRatio: 0,
+    preload: 'none',
+    autoplay: false,
+    controls: [
+      'progress',
+      'play-large',
+      'navigation',
+      'play',
+      'volume',
+      'current-time',
+      'duration',
+      'speed',
+      'captions',
+      'fullscreen',
+      'preview',
+      'languages'
+    ]
+  },
+  argTypes: {
+    env: {
+      control: 'radio',
+      options: ['local', 'dev', 'staging', 'prod']
+    },
+    preload: {
+      control: 'radio',
+      options: ['auto', 'none']
+    }
+  },
+  parameters: {
+    layout: 'fullscreen'
+  }
+};
+
+export default meta;
+export { MultiPlayer };

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

@@ -1,52 +1,78 @@
 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)}
         @error=${console.log}
-      ></vouch-embed>
+      ></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
+    autoplay: false,
+    controls: [
+      'progress',
+      'play-large',
+      'navigation',
+      'play',
+      'volume',
+      'current-time',
+      'duration',
+      'speed',
+      'captions',
+      'fullscreen',
+      'preview',
+      'languages'
+    ]
   },
   argTypes: {
     env: {
@@ -64,4 +90,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/{Embed → PlayerEmbed}/controllers/fetcher.ts

@@ -1,26 +1,29 @@
 import { Task } from '@lit/task';
 import { v4 as uuidv4 } from 'uuid';
 
-import type { Embed, EmbedProps } from '..';
+import type { PlayerEmbed, PlayerEmbedProps } from '..';
 import type { ReactiveControllerHost } from 'lit';
 import type { Environment } from '~/utils/env';
 
 import { getEnvUrls } from '~/utils/env';
 
-type EmbedHost = ReactiveControllerHost & Embed;
+type PlayerEmbedHost = ReactiveControllerHost & PlayerEmbed;
 
-type TaskDeps = [
-  EmbedProps['env'],
-  EmbedProps['apiKey'],
-  EmbedProps['data'],
-  EmbedProps['vouchId'],
-  EmbedProps['templateId']
+type FetchTaskDeps = [
+  PlayerEmbedProps['env'],
+  PlayerEmbedProps['apiKey'],
+  PlayerEmbedProps['data'],
+  PlayerEmbedProps['vouchId'],
+  PlayerEmbedProps['templateId']
 ];
 
+type FilterTaskDeps = [PlayerEmbedProps['data'], PlayerEmbedProps['questions']];
+
 class FetcherController {
-  host: EmbedHost;
+  host: PlayerEmbedHost;
 
   private _fetching = false;
+  private _vouch: PlayerEmbedProps['data'];
 
   set fetching(value) {
     if (this._fetching !== value) {
@@ -94,11 +97,11 @@ class FetcherController {
     return template;
   };
 
-  constructor(host: EmbedHost) {
+  constructor(host: PlayerEmbedHost) {
     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 → PlayerEmbed/controllers/tracking/index.ts}

@@ -1,15 +1,13 @@
-import { v4 as uuidv4 } from 'uuid';
-
-import type { Embed } from '..';
+import type { PlayerEmbed } from '../..';
 import type { VideoEventDetail } from '@vouchfor/media-player';
 import type { ReactiveController, ReactiveControllerHost } from 'lit';
 
-import packageJson from '../../../../package.json';
+import { findVouchId, getReportingMetadata, getUids } from './utils';
 import { getEnvUrls } from '~/utils/env';
 
 const MINIMUM_SEND_THRESHOLD = 1;
 
-type EmbedHost = ReactiveControllerHost & Embed;
+type PlayerEmbedHost = ReactiveControllerHost & PlayerEmbed;
 
 type TrackingEvent = 'VOUCH_LOADED' | 'VOUCH_RESPONSE_VIEWED' | 'VIDEO_PLAYED' | 'VIDEO_STREAMED';
 type TrackingPayload = {
@@ -19,6 +17,13 @@ type TrackingPayload = {
   streamEnd?: number;
 };
 
+type BatchEvent = {
+  event: TrackingEvent;
+  payload: TrackingPayload & {
+    time: string;
+  };
+};
+
 type TimeMap = {
   [key: string]: number;
 };
@@ -28,12 +33,9 @@ type BooleanMap = {
 };
 
 class TrackingController implements ReactiveController {
-  host: EmbedHost;
-
-  private _tabId: string | undefined = undefined;
-  private _clientId: string | undefined = undefined;
-  private _visitorId: string | undefined = undefined;
+  host: PlayerEmbedHost;
 
+  private _batchedEvents: BatchEvent[] = [];
   private _hasPlayed = false;
   private _hasLoaded: BooleanMap = {};
   private _answersViewed: BooleanMap = {};
@@ -41,124 +43,53 @@ class TrackingController implements ReactiveController {
   private _streamLatestTime: TimeMap = {};
   private _currentlyPlayingVideo: VideoEventDetail | null = null;
 
-  constructor(host: EmbedHost) {
+  constructor(host: PlayerEmbedHost) {
     this.host = host;
     host.addController(this);
   }
 
-  private _findVouchId(payload?: TrackingPayload) {
-    if (payload && 'vouchId' in payload) {
-      return payload.vouchId;
-    }
-    if (this.host.vouch) {
-      return this.host.vouch.id;
-    }
-    return null;
-  }
-
-  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);
-    }
+  private _createTrackingEvent = (event: TrackingEvent, payload?: TrackingPayload) => {
+    const vouchId = findVouchId(payload, this.host.vouch);
 
-    if (tabId !== this._tabId) {
-      this._tabId = tabId;
-      window.sessionStorage?.setItem?.('vouch-uid-tab', tabId);
+    if (!vouchId || this.host.disableTracking) {
+      return;
     }
 
-    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;
+    this._batchedEvents.push({
+      event,
+      payload: {
+        ...payload,
+        vouchId,
+        time: new Date().toISOString()
       }
     });
-
-    return {
-      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 vouchId = this._findVouchId(payload);
-
-    if (!vouchId || this.host.disableTracking) {
+  private _sendTrackingEvent = () => {
+    if (this._batchedEvents.length <= 0) {
       return;
     }
 
     const { publicApiUrl } = getEnvUrls(this.host.env);
-    const { client, tab, request, visitor } = this._getUids();
+    const { client, tab, request, visitor } = getUids(this.host.env);
 
     navigator.sendBeacon(
-      `${publicApiUrl}/api/v2/events`,
+      `${publicApiUrl}/api/batchevents`,
       JSON.stringify({
-        event,
         payload: {
-          ...payload,
-          vouchId
+          events: this._batchedEvents
         },
         context: {
           'x-uid-client': client,
           'x-uid-tab': tab,
           'x-uid-request': request,
           'x-uid-visitor': visitor,
-          'x-reporting-metadata': this._getReportingMetadata(),
-          'x-embeds-version': packageJson.version
+          'x-reporting-metadata': getReportingMetadata(this.host.trackingSource)
         }
       })
     );
+
+    this._batchedEvents = [];
   };
 
   private _streamEnded = () => {
@@ -168,7 +99,7 @@ class TrackingController implements ReactiveController {
       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', {
+        this._createTrackingEvent('VIDEO_STREAMED', {
           answerId: id,
           streamStart: this._streamStartTime[key],
           streamEnd: this._streamLatestTime[key]
@@ -188,7 +119,7 @@ class TrackingController implements ReactiveController {
 
     // Only send loaded event once per session
     if (!this._hasLoaded[vouchId]) {
-      this._sendTrackingEvent('VOUCH_LOADED', { vouchId });
+      this._createTrackingEvent('VOUCH_LOADED', { vouchId });
       this._hasLoaded[vouchId] = true;
     }
   };
@@ -196,43 +127,43 @@ class TrackingController implements ReactiveController {
   private _handlePlay = () => {
     // Only send the video played event once per session
     if (!this._hasPlayed) {
-      this._sendTrackingEvent('VIDEO_PLAYED', {
+      this._createTrackingEvent('VIDEO_PLAYED', {
         streamStart: this.host.currentTime
       });
       this._hasPlayed = true;
     }
   };
 
-  private _handleVideoPlay = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
+  private _handleVideoPlay = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
     // Only increment play count once per session
     if (!this._answersViewed[key]) {
-      this._sendTrackingEvent('VOUCH_RESPONSE_VIEWED', {
+      this._createTrackingEvent('VOUCH_RESPONSE_VIEWED', {
         answerId: id
       });
       this._answersViewed[key] = true;
     }
-
-    if (!this._streamStartTime[key]) {
-      this._streamStartTime[key] = node.currentTime;
-      this._streamLatestTime[key] = node.currentTime;
-    }
   };
 
   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 &&
+      !this.host.paused
       // Only update the latest time if this event fires for the currently active video
-      id === this.host.scene?.video?.id
+      // 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._sendTrackingEvent('VIDEO_STREAMED', {
+      this._createTrackingEvent('VIDEO_STREAMED', {
         answerId: id,
         streamStart: this._streamStartTime[key],
         streamEnd: this._streamLatestTime[key]
@@ -244,9 +175,7 @@ class TrackingController implements ReactiveController {
 
   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();
+    this._sendTrackingEvent();
   };
 
   private _handleVisibilityChange = () => {
@@ -275,7 +204,9 @@ class TrackingController implements ReactiveController {
   }
 
   hostDisconnected() {
-    this._streamEnded();
+    // Send events if DOM node is destroyed
+    this._pageUnloading();
+
     if ('onvisibilitychange' in document) {
       document.removeEventListener('visibilitychange', this._handleVisibilityChange);
     } else {
@@ -290,3 +221,4 @@ class TrackingController implements ReactiveController {
 }
 
 export { TrackingController };
+export type { TrackingEvent, TrackingPayload };