@vouchfor/embeds 0.0.0-experiment.cd9e84e → 0.0.0-experiment.cfa2fea

package/src/components/DialogEmbed/DialogPortal.ts

@@ -0,0 +1,126 @@
+import { 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 { styleMap } from 'lit/directives/style-map.js';
+
+import type { DialogEmbedProps } from '.';
+import type { MediaPlayer } from '@vouchfor/media-player';
+
+import './DialogOverlay';
+
+@customElement('vouch-embed-dialog-portal')
+class DialogPortal extends LitElement {
+  @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 _mediaPlayerRef = createRef<MediaPlayer>();
+
+  @state() open = false;
+
+  private _handleToggle = ({ detail }: CustomEvent<string>) => {
+    // Because we have to attach this listener to the document since this element is portalled outside of the button,
+    // we also have to make sure that this player is actually the one we want to open and play by passing in an ID
+    // from the button wrapper parent and checking against that same ID we pass as the event detail
+    if (this.id === detail) {
+      this.open = !this.open;
+
+      if (this.open) {
+        if (!this.disableAutoplay && this._mediaPlayerRef?.value) {
+          this._mediaPlayerRef.value.muted = false;
+          this._mediaPlayerRef.value.play();
+        }
+      } else {
+        this._mediaPlayerRef?.value?.pause();
+      }
+    }
+  };
+
+  // We could do the same thing on close and check for the correct ID but it doesn't really matter
+  private _handleClose = () => {
+    this.open = false;
+    this._mediaPlayerRef?.value?.pause();
+  };
+
+  private _handleDocumentKeyUp = (e: KeyboardEvent) => {
+    if (e.key === 'Escape') {
+      this._handleClose();
+    }
+  };
+
+  connectedCallback(): void {
+    super.connectedCallback();
+    document.addEventListener('dialogembed:click', this._handleToggle);
+    document.addEventListener('keyup', this._handleDocumentKeyUp);
+    document.addEventListener('close:click', this._handleClose);
+    document.addEventListener('overlay:click', this._handleClose);
+  }
+
+  disconnectedCallback(): void {
+    super.disconnectedCallback();
+    document.removeEventListener('dialogembed:click', this._handleToggle);
+    document.removeEventListener('keyup', this._handleDocumentKeyUp);
+    document.removeEventListener('close:click', this._handleClose);
+    document.removeEventListener('overlay:click', this._handleClose);
+  }
+
+  protected createRenderRoot(): HTMLElement | DocumentFragment {
+    // We must create a new node here because portalling into the same node (document.body) causes the second
+    // element to overwrite the first for some reason (not behaviour really stated in the docs)
+    // I am fairly certain this function is only run once as the default behaviour creates the open shadow root
+    // and returns that shadow root in this function: https://lit.dev/docs/components/shadow-dom/#implementing-createrenderroot
+    const newNode = document.createElement('div');
+    document.body.appendChild(newNode);
+    return newNode;
+  }
+
+  render() {
+    return html`
+      <vouch-embed-dialog-overlay ?open=${this.open} aspectRatio=${this.aspectRatio}>
+        <vouch-embed-player
+          ${ref(this._mediaPlayerRef)}
+          style=${styleMap({
+            maxWidth: '100%',
+            maxHeight: '100%'
+          })}
+          ?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-player>
+      </vouch-embed-dialog-overlay>
+    `;
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'vouch-embed-dialog-portal': DialogPortal;
+  }
+
+  namespace JSX {
+    interface IntrinsicElements {
+      'vouch-embed-dialog-portal': DialogPortal;
+    }
+  }
+}
+
+export { DialogPortal };

package/src/components/DialogEmbed/index.ts

@@ -0,0 +1,97 @@
+import { css, html, LitElement } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import { ifDefined } from 'lit/directives/if-defined.js';
+import { v4 as uuidv4 } from 'uuid';
+
+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 _id = uuidv4();
+
+  private _handleRootClick = () => {
+    this.dispatchEvent(new CustomEvent('dialogembed:click', { detail: this._id, 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
+        id=${this._id}
+        ?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,49 +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)}
         @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
@@ -64,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/{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]
+    );
   }
 }