@icvdeveloper/common-module 1.4.13 → 2.0.0

package/dist/runtime/components/registration/RegistrationGroupSelect.vue

@@ -0,0 +1,142 @@
+<script lang="ts" setup>
+import { toRefs } from "vue";
+import { get } from 'lodash-es';
+import { Group } from "../../models/conference";
+import { useUserStore } from "../../store/user";
+import { useTemplateConfigsStore } from "../../store/templateConfigs";
+import { storeToRefs } from "pinia";
+
+type Props = {
+  content: any[];
+};
+
+const props = defineProps<Props>();
+
+const { content } = toRefs(props);
+
+const { globalConfigValue } = useTemplateConfigsStore();
+const { currentUser } = storeToRefs(useUserStore());
+
+const emit = defineEmits<{
+  (event: "setRegForm", value: string): void;
+}>();
+
+// computed
+const hasGroups = (): boolean => {
+  return content.value.length > 0;
+};
+
+const regButtonEnabled = (): boolean => {
+  return globalConfigValue("reg_button_enabled");
+}
+
+const regExternalUrl = (): string => {
+  const extRegUrl = globalConfigValue("external_reg_url");
+  if (extRegUrl.length > 0) return extRegUrl;
+  return '';
+};
+
+const regButtonAlias = (): string => {
+  let returnText = "Register";
+  const aliasText = globalConfigValue("reg_button_alias");
+  if (aliasText.length > 0) returnText = aliasText;
+  return returnText;
+};
+
+// methods
+const getRegisterText = (_group: Group): string => {
+  return _group.price as number > 0 ? "Buy Now" : "Register";
+};
+
+const formatCurrency = (_value: number): string => {
+    const val: number = _value / 100;
+    return val
+        .toLocaleString('en-US', {currency: 'USD', style: 'currency'})
+        .substring(1);
+};
+
+const setRegForm = (_code: string) => {
+  emit("setRegForm", _code);
+};
+
+const checkAlreadyRegistered = (_group_id: number): boolean => {
+  let hasGroups: boolean = false;
+  if (get(currentUser.value, 'group_ids', false) != false) {
+    const groupIds: number[] = currentUser.value.group_ids as number[];
+    hasGroups = groupIds.includes(_group_id);
+  }
+  return hasGroups;
+};
+</script>
+
+<template>
+  <div class="px-2">
+    <!-- If the conference has one or more groups -->
+    <template v-if="hasGroups() && regButtonEnabled() && regExternalUrl().length == 0">
+      <div
+        v-for="(group, index) in content"
+        :key="group.id"
+        class="flex flex-col justify-around p-6 m-2 text-center"
+        :class="index != content.length - 1 ? 'border-b border-gray-400' : ''"
+      >
+        <div class="flex flex-1 flex-col py-2">
+          <div class="flex-1 mb-2 text-xl font-bold">{{ group.name }}</div>
+          <div class="flex-1">{{ group.description }}</div>
+        </div>
+
+        <div class="flex flex-col grow-0 items-center justify-between">
+          <div
+            v-if="group.price"
+            class="text-lg mb-2"
+          >
+            {{ formatCurrency(group.price) }}
+          </div>
+          <button
+            v-if="group.type == 'media' || !checkAlreadyRegistered(group.id)"
+            class="btn btn-primary"
+            @click="setRegForm(group.code)"
+          >
+            {{ getRegisterText(group) }}
+          </button>
+          <span
+            v-else
+            class="text-red"
+          >
+            You are already registered for this access level for this event.
+          </span>
+        </div>
+      </div>
+    </template>
+
+    <!-- If the conference does not have any groups, or reg disabled -->
+    <div
+      v-if="!hasGroups() || !regButtonEnabled()"
+      class="px-2 md:px-4"
+    >
+      <div class="flex justify-around m-2 border-b border-gray-400 py-12 text-lg">
+        Sorry! There are no registration options available at this time.
+      </div>
+    </div>
+
+    <!-- If Registration External URL -->
+    <div
+      v-if="regButtonEnabled() && regExternalUrl().length > 0"
+      class="px-2 text-center"
+    >
+      <a
+        :href="regExternalUrl"
+        :target="/^http/.test(regExternalUrl()) ? '_blank' : '_self'"
+      >
+        <button
+          class="btn btn-primary my-2"
+          type="submit"
+        >
+          {{ regButtonAlias }}
+        </button>
+      </a>
+    </div>
+    <br>
+  </div>
+</template>
+
+<style></style>

package/dist/runtime/components/registration/StripePaymentForm.vue

@@ -0,0 +1,141 @@
+<script lang="ts" setup>
+import { ref, toRefs, unref, computed, onBeforeMount, onMounted } from 'vue';
+import { StripeElements, StripeElement } from 'vue-stripe-js'
+import { loadStripe } from '@stripe/stripe-js'
+
+type Props = {
+  stripeKey: string;
+  price: number;
+  errors?: Object;
+};
+
+const props = withDefaults(defineProps<Props>(), {
+  errors: () => {
+    return {};
+  }
+});
+
+const { stripeKey, price, errors } = toRefs(props);
+
+const stripeLoaded = ref<boolean>(false);
+const instanceOptions = ref({
+  // https://stripe.com/docs/js/initializing#init_stripe_js-options
+})
+const elementsOptions = ref({
+  // https://stripe.com/docs/js/elements_object/create#stripe_elements-options
+})
+const cardOptions = ref({
+  // https://stripe.com/docs/stripe.js#element-options
+  value: {
+    // postalCode: '12345',
+  },
+});
+
+// ref from StripeElement.vue
+const card = ref();
+// ref from StripeElements.vue
+const elms = ref();
+
+const emit = defineEmits<{
+  (event: "tokenGenerated", value: string): void;
+  (event: "onError"): void;
+}>();
+
+// computed
+const totalFormatted = computed((): string => {
+    return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD',
+        minimumFractionDigits: 2
+    })
+    .format(price.value / 100);
+});
+
+// methods
+const payWithStripe = (): void => {
+  // Get stripe element
+  const cardElement = card.value.stripeElement;
+
+  // Access instance methods, e.g. createToken()
+  // TODO - correctly type result if possible
+  elms.value.instance.createToken(cardElement).then((result: object) => {
+    // Handle result.error or result.token
+    if (result?.token) {
+      emit('tokenGenerated', result.token.id);
+    } else {
+      emit('onError');
+    }
+  })
+};
+
+defineExpose({
+  payWithStripe
+});
+
+onBeforeMount(() => {
+  const stripePromise = loadStripe(unref(stripeKey));
+  stripePromise.then((): void => {
+    stripeLoaded.value = true;
+  })
+});
+</script>
+
+<template>
+  <div class="border border-gray-200 rounded p-4">
+    <div class="py-3 mb-4 px-3 flex bg-gray-400 rounded text-white font-semibold">
+      <div class="flex-1">
+        Payment Information
+      </div>
+      <div class="flex-1 text-right">{{ totalFormatted }}</div>
+    </div>
+
+    <p class="text-red-600 my-3" v-if="errors.payment">
+      {{ errors.payment[0] }}
+    </p>
+
+    <StripeElements
+      v-if="stripeLoaded"
+      v-slot="{ elements, instance }"
+      ref="elms"
+      :stripe-key="stripeKey"
+      :instance-options="instanceOptions"
+      :elements-options="elementsOptions"
+    >
+      <StripeElement
+        ref="card"
+        :elements="elements"
+        :options="cardOptions"
+      />
+    </StripeElements>
+  </div>
+</template>
+
+<style>
+  .StripeElement {
+    box-sizing: border-box;
+
+    height: 40px;
+
+    padding: 10px 12px;
+
+    border: 1px solid transparent;
+    border-radius: 4px;
+    background-color: white;
+
+    box-shadow: 0 1px 3px 0 #e6ebf1;
+    -webkit-transition: box-shadow 150ms ease;
+    transition: box-shadow 150ms ease;
+  }
+
+  .StripeElement--focus {
+    box-shadow: 0 1px 3px 0 #cfd7df;
+  }
+
+  .StripeElement--invalid {
+    border-color: #fa755a;
+  }
+
+  .StripeElement--webkit-autofill {
+    background-color: #fefde5 !important;
+  }
+</style>

package/dist/runtime/composables/useAgenda.d.ts

@@ -81,5 +81,17 @@ export type UseAgendaMethods = {
      * show presenter description
      */
     showPresenterDescription: (presenter: Presenter, presentation: Presentation) => void;
+    /**
+     * emits handles player behavior for virtual template
+     */
+    playPresentation: (_track: Track, _presentation: Presentation, _conference: Conference, _isActiveAgenda: boolean, _isVirtual?: boolean) => void | null;
+    /**
+     * update the selectedPresentation
+     */
+    updateSelectedPresentation: (_conference: Conference) => void;
+    /**
+     * Save the current live Presentation for this Conference in store
+     */
+    setLivePresentations: (_event?: any) => void;
 };
 export declare const useAgenda: (conference: Ref<Conference>) => UseAgendaMethods;

package/dist/runtime/composables/useAgenda.mjs

@@ -1,15 +1,28 @@
 import { get, remove, cloneDeep, intersectionBy, pullAllBy } from "lodash-es";
 import { ref, computed, onBeforeMount } from "vue";
+import { useRoute } from "vue-router";
 import { storeToRefs } from "pinia";
 import { DateTime } from "luxon";
 import { useTemplateConfigsStore } from "../store/index.mjs";
 import { useAuthStore } from "../store/auth.mjs";
+import { useConferencesStore } from "../store/index.mjs";
 import { useAffiliatesStore } from "../store/affiliates.mjs";
+import { usePlayerConfigStore } from "../store/modalPlayerConfig.mjs";
+import {
+  commitLivePresentationsEventHook,
+  setIsPlayerVisibleEventHook,
+  setPlayerPresentationEventHook,
+  setPlayerConferenceEventHook
+} from "../composables/useEventHooks.mjs";
 export const useAgenda = (conference) => {
   const { setConferenceConfig, pagesConfigValue } = useTemplateConfigsStore();
+  console.log("setting conference config");
   setConferenceConfig(conference.value);
   const affiliateStore = useAffiliatesStore();
+  const route = useRoute();
   const { isLoggedIn } = storeToRefs(useAuthStore());
+  const { currentConference } = storeToRefs(useConferencesStore());
+  const { playerPresentation, livePresentations } = storeToRefs(usePlayerConfigStore());
   const selectedDay = ref(null);
   const allowAgendaFullAccess = pagesConfigValue("agenda.agendas_full_access", false);
   const displayTrackGroups = pagesConfigValue("agenda.group_tracks", "None");
@@ -25,7 +38,7 @@ export const useAgenda = (conference) => {
     return affiliateStore.getConferenceAffiliates(conference.value.id);
   });
   const horizontalTrackGroups = computed(() => {
-    return displayTrackGroups === "Horizonal";
+    return displayTrackGroups === "Horizontal";
   });
   const setSelectedDay = (day) => {
     selectedDay.value = day;
@@ -128,14 +141,6 @@ export const useAgenda = (conference) => {
     }
     return classes;
   };
-  onBeforeMount(() => {
-    if (!conference.value.hasOwnProperty("affiliates")) {
-      affiliateStore.getAffiliates(conference.value.id);
-    }
-    if (selectedDay.value === null) {
-      selectedDay.value = conference.value.days[0];
-    }
-  });
   const showInfoLink = () => {
     return pagesConfigValue("agenda.session_desc_link") !== "none";
   };
@@ -152,6 +157,89 @@ export const useAgenda = (conference) => {
       selectedPresenter.value = presenter;
     }
   };
+  const getPresentationPlayerType = (_presentation) => {
+    let playerType = _presentation.video_url || _presentation.type == "embed" ? "archive" : "live";
+    if (_presentation.external_type == "iframe") {
+      playerType = "iframe";
+    }
+    return playerType;
+  };
+  const playPresentation = (_track, _presentation, _conference, _isActiveAgenda, _isVirtual = false) => {
+    if (!_isVirtual) {
+      return null;
+    } else if (_presentation.type == "link" && _presentation.external_type != "iframe") {
+      openExternalLink(_presentation);
+    } else if ((route.name == "agenda-id" || _isActiveAgenda) && (_conference.state == "live" || _conference.state == "mixed") || _conference.state == "archive") {
+      const pres = _presentation;
+      pres.track = { "channel": _track.channel };
+      pres.access = _track.access;
+      setPlayerPresentationEventHook.trigger({
+        "player_type": getPresentationPlayerType(_presentation),
+        "data": pres
+      });
+      console.log({
+        "player_type": getPresentationPlayerType(_presentation),
+        "data": pres
+      });
+      setPlayerConferenceEventHook.trigger(_conference);
+      setIsPlayerVisibleEventHook.trigger(true);
+    } else {
+      return null;
+    }
+  };
+  const openExternalLink = (_presentation) => {
+    let ext_type = get(_presentation, "external_type", "new_window");
+    if (ext_type === null) {
+      ext_type = "new_window";
+    }
+    const tempUrl = _presentation.video_url;
+    const url = tempUrl;
+    return ext_type === "new_window" ? window.open(url, "_blank") : window.open(url, "_self");
+  };
+  const updateSelectedPresentation = (_conference) => {
+    const oldSelectedPres = playerPresentation.value.data;
+    _conference?.days?.some((day) => {
+      day?.tracks?.some((track) => {
+        track?.presentations?.some((pres) => {
+          if (pres.id == oldSelectedPres.id && (day.access || track.access)) {
+            const _pres = Object.assign({}, pres);
+            _pres.access = true;
+            setPlayerPresentationEventHook.trigger({
+              "player_type": getPresentationPlayerType(_pres),
+              "data": _pres
+            });
+            return true;
+          }
+        });
+      });
+    });
+  };
+  const setLivePresentations = (_event = {}) => {
+    const tempPres = Object.assign({}, livePresentations.value);
+    if (Object.keys(_event).length) {
+      _event.presentation.is_live ? tempPres[_event.track.id] = _event.presentation.id : delete tempPres[_event.track.id];
+      commitLivePresentationsEventHook.trigger(tempPres);
+    } else if (!Object.keys(livePresentations.value).length) {
+      currentConference.value.days.forEach((day) => {
+        day.tracks.forEach((track) => {
+          track.presentations.forEach((presentation) => {
+            if (presentation.is_live) {
+              tempPres[track.id] = presentation.id;
+            }
+          });
+        });
+      });
+      commitLivePresentationsEventHook.trigger(tempPres);
+    }
+  };
+  onBeforeMount(() => {
+    if (!Object.prototype.hasOwnProperty.call(conference.value, "affiliates")) {
+      affiliateStore.getAffiliates(conference.value.id);
+    }
+    if (selectedDay.value === null) {
+      selectedDay.value = conference.value.days[0];
+    }
+  });
   return {
     days,
     enabledSponsors,
@@ -171,6 +259,9 @@ export const useAgenda = (conference) => {
     showInfoLink,
     useAccordion,
     usePresenterModal,
-    showPresenterDescription
+    showPresenterDescription,
+    playPresentation,
+    updateSelectedPresentation,
+    setLivePresentations
   };
 };

package/dist/runtime/composables/useAuth.mjs

@@ -3,7 +3,7 @@ import { useTemplateConfigsStore } from "../store/templateConfigs.mjs";
 export const useAuth = () => {
   const { globalConfigValue } = useTemplateConfigsStore();
   const isLoginDisabled = computed(() => {
-    return !globalConfigValue("login_disabled") || globalConfigValue("login_process") === "disabled";
+    return globalConfigValue("login_disabled") || globalConfigValue("login_process") === "disabled";
   });
   return {
     isLoginDisabled

package/dist/runtime/composables/useConferenceHelpers.d.ts

@@ -20,7 +20,7 @@ export type UseConferenceHelpersMethods = {
     /**
      * Get conference webcast url
      */
-    getConferenceWebcastUrl: (_conference?: Conference) => string;
+    getConferenceWebcastUrl: (_conference: Conference, skipAgenda?: boolean) => string;
     /**
      * Get timezone display
      */
@@ -69,5 +69,9 @@ export type UseConferenceHelpersMethods = {
      * conference is Archived
      */
     conferenceIsArchived: (_conference?: Conference) => boolean;
+    /**
+     * string description of conference state
+     */
+    getConferenceStatusLabel: (_conference: Conference) => string;
 };
 export declare const useConferenceHelpers: (conference: Ref<Conference | null>) => UseConferenceHelpersMethods;

package/dist/runtime/composables/useConferenceHelpers.mjs

@@ -255,6 +255,19 @@ export const useConferenceHelpers = (conference) => {
     const _selectedConference = _getSelectedConference(_conference);
     return _selectedConference.state === ConferenceState.ARCHIVED;
   };
+  const getConferenceStatusLabel = (_conference) => {
+    switch (_conference.state) {
+      case "archive":
+        return "Archive";
+      case "upcoming":
+        return "Upcoming";
+      case "mixed":
+        return "Live";
+      case "live":
+        return "Live";
+    }
+    return "Archive";
+  };
   return {
     isSingleDayEvent,
     hasAccessToEvent,
@@ -272,6 +285,7 @@ export const useConferenceHelpers = (conference) => {
     showConferenceViewButton,
     conferenceIsLiveOrMixed,
     conferenceIsMixed,
-    conferenceIsArchived
+    conferenceIsArchived,
+    getConferenceStatusLabel
   };
 };

package/dist/runtime/composables/useEventHooks.d.ts

@@ -0,0 +1,26 @@
+import type { Conversation } from "../models/conversation";
+import type { User } from "../models/user";
+export type UserSearchParams = {
+    value?: string;
+    iterate?: boolean;
+};
+export declare const loginEventHook: import("@vueuse/shared").EventHook<boolean>;
+export declare const loggedOutEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const modalClosedEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const commitLivePresentationsEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const setIsPlayerVisibleEventHook: import("@vueuse/shared").EventHook<boolean>;
+export declare const setIsProfileVisibleEventHook: import("@vueuse/shared").EventHook<boolean>;
+export declare const setPlayerPresentationEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const setPlayerConferenceEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const createVideoChatAffiliateEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const createVideoChatEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const modalContentEventHook: import("@vueuse/shared").EventHook<ContentData>;
+export declare const hideConversationEventHook: import("@vueuse/shared").EventHook<Conversation>;
+export declare const chatSearchEventHook: import("@vueuse/shared").EventHook<UserSearchParams>;
+export declare const clearConversationEventHook: import("@vueuse/shared").EventHook<Conversation>;
+export declare const createConversationEventHook: import("@vueuse/shared").EventHook<User[]>;
+export declare const chatLoadUsersEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const chatUsersLoadedEventHook: import("@vueuse/shared").EventHook<any>;
+export declare const sendMessageEventHook: import("@vueuse/shared").EventHook<string>;
+export declare const setSelectedConversationEventHook: import("@vueuse/shared").EventHook<Conversation>;
+export declare const toggleChatWindowEventHook: import("@vueuse/shared").EventHook<boolean>;

package/dist/runtime/composables/useEventHooks.mjs

@@ -0,0 +1,21 @@
+import { createEventHook } from "@vueuse/core";
+export const loginEventHook = createEventHook();
+export const loggedOutEventHook = createEventHook();
+export const modalClosedEventHook = createEventHook();
+export const commitLivePresentationsEventHook = createEventHook();
+export const setIsPlayerVisibleEventHook = createEventHook();
+export const setIsProfileVisibleEventHook = createEventHook();
+export const setPlayerPresentationEventHook = createEventHook();
+export const setPlayerConferenceEventHook = createEventHook();
+export const createVideoChatAffiliateEventHook = createEventHook();
+export const createVideoChatEventHook = createEventHook();
+export const modalContentEventHook = createEventHook();
+export const hideConversationEventHook = createEventHook();
+export const chatSearchEventHook = createEventHook();
+export const clearConversationEventHook = createEventHook();
+export const createConversationEventHook = createEventHook();
+export const chatLoadUsersEventHook = createEventHook();
+export const chatUsersLoadedEventHook = createEventHook();
+export const sendMessageEventHook = createEventHook();
+export const setSelectedConversationEventHook = createEventHook();
+export const toggleChatWindowEventHook = createEventHook();

package/dist/runtime/composables/useEvents.d.ts

@@ -1,5 +1,5 @@
 import type { Ref, ComputedRef } from "vue";
-import type { Conference, Sponsor } from "../models/conference";
+import type { Conference, Sponsor, Presenter } from "../models/conference";
 export type UseEventsMethods = {
     /**
      * determine if logged in
@@ -37,9 +37,25 @@ export type UseEventsMethods = {
      * sorts an event's affiliates by level, then by name
      */
     getSponsors: (_affiliates: Array<Sponsor> | undefined) => Array<Sponsor>;
+    /**
+     * sorts an event's affiliates by level, then by name
+     */
+    getExhibitors: (_affiliates: Array<Sponsor> | undefined) => Array<Sponsor>;
     /**
      * returns the first affiliate set to role 'custom1'
      */
     getBrand: (_affiliates: Array<Sponsor>) => Sponsor | null;
+    /**
+     * formats presenters to {[key: string]: Presenter[]} if necessary
+     */
+    formatPresenters: (_presenters: Presenter[] | {
+        [key: string]: Presenter[];
+    } | {
+        [key: string]: {
+            [key: string]: Presenter[];
+        };
+    } | null | undefined) => {
+        [key: string]: Presenter[];
+    };
 };
 export declare const useEvents: () => UseEventsMethods;

package/dist/runtime/composables/useEvents.mjs

@@ -44,6 +44,15 @@ export const useEvents = () => {
     tempSponsors = sortBy(tempSponsors, ["level", "name"]);
     return tempSponsors;
   };
+  const getExhibitors = (_affiliates) => {
+    if (_affiliates === void 0) {
+      return [];
+    }
+    let tempSponsors = [];
+    tempSponsors = filter(_affiliates, { "role": "exhibitor" });
+    tempSponsors = sortBy(tempSponsors, ["level", "name"]);
+    return tempSponsors;
+  };
   const getBrand = (_affiliates) => {
     let i = 0;
     for (i; i < get(_affiliates, "length", 0); i++) {
@@ -53,6 +62,23 @@ export const useEvents = () => {
     }
     return null;
   };
+  const formatPresenters = (presenters) => {
+    let formattedPresenters = {};
+    if (presenters == null || presenters == void 0) {
+      return formattedPresenters;
+    } else {
+      if (presenters != null && presenters != void 0 && typeof presenters == "object") {
+        if (Array.isArray(Object.values(presenters)[0])) {
+          formattedPresenters = presenters;
+          return formattedPresenters;
+        }
+        if (Array.isArray(presenters)) {
+          formattedPresenters["presenters_all"] = presenters;
+        }
+      }
+    }
+    return formattedPresenters;
+  };
   return {
     isLoggedIn,
     loginModalVisible,
@@ -63,6 +89,8 @@ export const useEvents = () => {
     setConferenceToLoginTo,
     orderAffiliates,
     getSponsors,
-    getBrand
+    getExhibitors,
+    getBrand,
+    formatPresenters
   };
 };

package/dist/runtime/composables/useLogin.mjs

@@ -10,13 +10,17 @@ import { useConferenceHelpers } from "./useConferenceHelpers.mjs";
 export const useLogin = (conference) => {
   const { login } = useAuthStore();
   const { currentConference } = storeToRefs(useConferencesStore());
-  const { globalConfigValue } = storeToRefs(useTemplateConfigsStore());
+  const { portalConfig, globalConfigValue } = storeToRefs(useTemplateConfigsStore());
   const email = ref("");
   const password = ref("");
   const tooManySessions = ref(false);
   const loginError = ref(false);
   const router = useRouter();
-  const shouldRedirect = () => {
+  const handleRedirect = () => {
+    if (portalConfig.value?.meta?.id === 3 || portalConfig.value?.meta?.name === "Virtual Tradeshow Template") {
+      console.log("virtual template detected on login");
+      return;
+    }
     let redirectUrl = null;
     if (currentConference.value !== null) {
       if (globalConfigValue.value("login_redirect_enabled")) {
@@ -37,7 +41,7 @@ export const useLogin = (conference) => {
   };
   const handleLogin = (revoke = false) => {
     login({ email: email.value, password: password.value, revoke }).then(() => {
-      shouldRedirect();
+      handleRedirect();
     }).catch((error) => {
       if (error.response.status === 423) {
         tooManySessions.value = true;

package/dist/runtime/composables/usePresentation.mjs

@@ -41,7 +41,7 @@ export const usePresentation = (conference) => {
       if (presentation.type === "link") {
         return presentation.video_url;
       }
-      if ((presentation.video_url || presentation.type === "embed") && conferenceIsMixed) {
+      if ((presentation.video_url || presentation.type === "embed") && conferenceIsMixed(conference.value)) {
         return getArchivePresentationLinkDestination(presentation);
       }
       return `/upcoming-events/${conference.value.id}/webcast/${track.channel}`;