@icvdeveloper/common-module 0.0.1

package/dist/runtime/components/forms/TextInput.vue

@@ -0,0 +1,22 @@
+<script lang="ts" setup>
+type Props = {
+  modelValue: string;
+  placeholder: string;
+  type: string;
+};
+
+const props = defineProps<Props>();
+
+const emit = defineEmits<{
+  (event: "update:modelValue", value: string): void;
+}>();
+
+// methods
+const changeInput = (e) => {
+  emit("update:modelValue", e.target.value);
+};
+</script>
+
+<template>
+  <input :value="props.modelValue" @change="changeInput" />
+</template>

package/dist/runtime/components/layouts/Accordion.vue

@@ -0,0 +1,76 @@
+<script lang="ts" setup>
+type Props = {
+  title?: string;
+  tabContent?: {
+    content?: string;
+    label?: string;
+    type?: string;
+  };
+  contentObject?: object;
+};
+
+const props = withDefaults(defineProps<Props>(), {
+  title: "",
+  tabContent: () => ({}),
+  contentObject: () => ({}),
+});
+
+// data
+const { title, tabContent, contentObject } = toRefs(props);
+const active = ref<boolean>(false);
+
+// computed
+const tabTitleValues = computed(() => {
+  if (title.value) {
+    return {
+      title: title.value,
+      classes: "",
+    };
+  } else {
+    return {
+      title: tabContent.value.label,
+      classes: "pl-4",
+    };
+  }
+});
+</script>
+
+<template>
+  <div>
+    <a
+      v-if="tabContent.type === 'url'"
+      :href="tabContent.content"
+      target="_blank"
+      class="py-3 block no-underline w-full font-hairline inline-flex items-center text-md my-1"
+      :class="tabTitleValues.classes"
+    >
+      <span class="flex-initial">
+        {{ tabTitleValues.title }}
+      </span>
+    </a>
+    <a
+      v-else
+      href="#"
+      class="py-3 block no-underline w-full font-hairline inline-flex items-center text-md my-1"
+      :class="tabTitleValues.classes"
+      @click.prevent="active = !active"
+    >
+      <span class="flex-initial"> {{ tabTitleValues.title }}&nbsp;&nbsp; </span>
+      <span
+        v-show="!active"
+        class="font-black flex-initial"
+        style="width: 0.75rem"
+      >
+        <CommonSvgIcon icon="downarrow"></CommonSvgIcon>
+      </span>
+      <span
+        v-show="active"
+        class="font-black flex-initial"
+        style="width: 0.75rem"
+      >
+        <CommonSvgIcon class="invert" icon="downarrow"></CommonSvgIcon>
+      </span>
+    </a>
+    <div v-show="active"><slot /></div>
+  </div>
+</template>

package/dist/runtime/components/presenters/PresenterListing.vue

@@ -0,0 +1,89 @@
+<script lang="ts" setup>
+import { Presenter } from "../../models/conference";
+import { usePresenter } from "../../composables/usePresenter";
+
+type Props = {
+  presenter: Presenter;
+  textClass?: string;
+  linkClass?: string;
+  enableBio?: boolean;
+  showBio?: boolean;
+  isSmallGroupedTrack?: boolean;
+};
+
+const props = withDefaults(defineProps<Props>(), {
+  textClass: "font-medium text-lg",
+  linkClass: "",
+  enableBio: true,
+  showBio: false,
+  isSmallGroupedTrack: false,
+});
+
+const emit = defineEmits(["clicked"]);
+
+const { presenter, textClass, linkClass, enableBio, isSmallGroupedTrack } =
+  toRefs(props);
+const { fullName, titleCompany } = usePresenter(presenter);
+
+// methods
+const handleClick = () => {
+  if (enableBio.value) {
+    emit("clicked");
+  }
+};
+</script>
+
+<template>
+  <div :class="textClass">
+    <p class="my-1">
+      <a
+        v-if="enableBio"
+        class="cursor-pointer"
+        :class="linkClass"
+        @click="handleClick()"
+        >{{ fullName }}</a
+      >
+      <span v-else>{{ fullName }}</span>
+      <span
+        v-if="presenter.role == 'moderator'"
+        class="text-grey-dark"
+        :class="isSmallGroupedTrack ? 'new-line' : 'no-new-line'"
+        >Moderator</span
+      >
+      <span
+        v-if="titleCompany"
+        class="font-light paragraph-color-1"
+        :class="isSmallGroupedTrack ? 'new-line' : 'new-line-responsive'"
+        >{{ titleCompany }}</span
+      >
+    </p>
+    <p
+      v-if="showBio && presenter.biography"
+      class="font-light text-base paragraph-color-1"
+      v-html="presenter.biography"
+    ></p>
+  </div>
+</template>
+
+<style scoped lang="scss">
+.new-line:before {
+  content: "\a ";
+  white-space: pre;
+}
+.no-new-line:before {
+  content: " - ";
+  white-space: normal;
+}
+@media (max-width: 991px) {
+  .new-line-responsive:before {
+    content: "\a ";
+    white-space: pre;
+  }
+}
+@media (min-width: 992px) {
+  .new-line-responsive:before {
+    content: " - ";
+    white-space: normal;
+  }
+}
+</style>

package/dist/runtime/components/presenters/PresenterModal.vue

@@ -0,0 +1,83 @@
+<script lang="ts" setup>
+import { Presenter } from "../../models/conference";
+import { usePresenter } from "../../composables/usePresenter";
+
+type Props = {
+  presenter: Presenter;
+  useIcon?: boolean;
+  isSmallGroupedTrack: boolean;
+};
+
+const props = withDefaults(defineProps<Props>(), {
+  useIcon: true,
+});
+
+const { presenter, useIcon, isSmallGroupedTrack } = toRefs(props);
+const modalVisible = ref<boolean>(false);
+
+// methods
+const { fullName, presenterImageStyle, itemWidthStyle, isGrayScale } =
+  usePresenter(presenter);
+</script>
+
+<template>
+  <div>
+    <div v-if="useIcon" class="presenter-icon cursor-pointer">
+      <CommonSvgIcon icon="info" :greyscale="isGrayScale"></CommonSvgIcon>
+    </div>
+
+    <CommonPresenterListing
+      v-else
+      :presenter="presenter"
+      :enable-bio="true"
+      :show-bio="false"
+      text-class="font-bold text-base"
+      link-class="agenda-presenter-color"
+      :is-small-grouped-track="isSmallGroupedTrack"
+    >
+    </CommonPresenterListing>
+
+    <CommonModal :visible="modalVisible" @trigger="modalVisible = false">
+      <template #modal-title>
+        <div
+          class="flex flex-col lg:flex-row w-full pb-8 mb-8 border-b border-solid border-grey-light"
+        >
+          <div class="flex-1 mb-6 lg:mb-0 lg:flex-initial flex justify-center">
+            <div
+              v-if="presenter.photo"
+              :style="presenterImageStyle"
+              class="border-white border-2 shadow-md bg-white"
+            >
+              <img
+                :src="presenter.photo"
+                class="invisible"
+                :style="itemWidthStyle"
+              />
+            </div>
+          </div>
+          <div class="flex-1 pl-4 text-center lg:text-left flex">
+            <div class="flex-1 self-center">
+              <h1
+                class="flex-1 font-light mb-0 body-color-4 presenter-name-color"
+              >
+                {{ fullName }}
+              </h1>
+              <p
+                class="flex-1 font-normal text-base pt-2 leading-tight mb-0 body-color-5 presenter-title-color"
+              >
+                {{ presenter.title }}<br />{{ presenter.company }}
+              </p>
+            </div>
+          </div>
+        </div>
+      </template>
+      <template #modal-body>
+        <p class="font-normal text-center lg:text-left">
+          <CommonDynamicHtml
+            :template="presenter.biography"
+          ></CommonDynamicHtml>
+        </p>
+      </template>
+    </CommonModal>
+  </div>
+</template>

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

@@ -0,0 +1,81 @@
+import { Ref, ComputedRef } from "nuxt/dist/app/compat/capi";
+import { Conference, Day, Presentation, Presenter, Sponsor, Track, TrackGroup } from "../models/conference";
+export declare type UseAgendaMethods = {
+    /**
+     * conference days.
+     */
+    days: ComputedRef<Day[]>;
+    /**
+     * Selected day.
+     */
+    selectedDay: Ref<Day | null>;
+    /**
+     * Enabled Sponsors
+     */
+    enabledSponsors: ComputedRef<Sponsor[]>;
+    /**
+     * Display Track Groups
+     */
+    displayTrackGroups: string;
+    /**
+     * Horizonal track groups
+     */
+    horizontalTrackGroups: ComputedRef<boolean>;
+    /**
+     * Selected presenter
+     */
+    selectedPresenter: Ref<Presenter | null>;
+    /**
+     * Set selected day
+     */
+    setSelectedDay: (day: Day) => void;
+    /**
+     * show tab dates
+     */
+    showTabDates: (day: Day) => boolean;
+    /**
+     * should show sponsors
+     */
+    shouldShowSponsors: (day: Day) => boolean;
+    /**
+     * Get combined track list.
+     */
+    getCombinedTrackList: (day: Day) => Track[] | TrackGroup[];
+    /**
+     * Has Presentations
+     */
+    hasPresentations: (track: Track | TrackGroup) => boolean;
+    /**
+     * is grouped Track
+     */
+    isGroupedTrack: (track: Track | TrackGroup) => boolean;
+    /**
+     * is small grouped track
+     */
+    isSmallGroupedTrack: (track: Track | TrackGroup) => boolean;
+    /**
+     * get tracks
+     */
+    getTracks: (track: Track | TrackGroup) => Track[];
+    /**
+     * get track classes
+     */
+    getTrackClasses: (track: Track | TrackGroup, index: number) => string;
+    /**
+     * show info link
+     */
+    showInfoLink: () => boolean;
+    /**
+     * use accordion
+     */
+    useAccordion: () => boolean;
+    /**
+     * use presenter modal
+     */
+    usePresenterModal: () => boolean;
+    /**
+     * show presenter description
+     */
+    showPresenterDescription: (presenter: Presenter, presentation: Presentation) => void;
+};
+export declare const useAgenda: (conference: Ref<Conference>) => UseAgendaMethods;

package/dist/runtime/composables/useAgenda.mjs

@@ -0,0 +1,178 @@
+import { get, remove, cloneDeep, intersectionBy, pullAllBy } from "lodash";
+import { storeToRefs } from "pinia";
+import { differenceInSeconds } from "date-fns";
+import { useAffiliatesStore } from "../store/affiliates.mjs";
+export const useAgenda = (conference) => {
+  const { setConferenceConfig, pagesConfigValue } = useTemplateConfigsStore();
+  setConferenceConfig(conference.value);
+  const affiliateStore = useAffiliatesStore();
+  const { isLoggedIn } = storeToRefs(useAuthStore());
+  const selectedDay = ref(null);
+  const displayTrackGroups = pagesConfigValue("agenda.group_tracks", "None");
+  const selectedPresenter = ref(null);
+  const days = computed(() => {
+    const data = conference.value.days;
+    if (isLoggedIn.value) {
+      remove(data, ["access", false]);
+    }
+    return data;
+  });
+  const enabledSponsors = computed(() => {
+    return affiliateStore.getConferenceAffiliates(conference.value.id);
+  });
+  const horizontalTrackGroups = computed(() => {
+    return displayTrackGroups === "Horizonal";
+  });
+  const setSelectedDay = (day) => {
+    selectedDay.value = day;
+  };
+  const showTabDates = (day) => {
+    return pagesConfigValue("agenda.tab_dates", true) && get(day, "date_visible", true);
+  };
+  const shouldShowSponsors = (day) => {
+    return day.sponsors.length > 0 && pagesConfigValue("agenda.sponsors");
+  };
+  const getCombinedTrackList = (day) => {
+    const trackGroups = cloneDeep(day.track_groups ?? {});
+    const tracks = cloneDeep(day.tracks ?? {});
+    if (isLoggedIn.value) {
+      remove(tracks, ["access", false]);
+    }
+    if (displayTrackGroups === "None") {
+      tracks.sort((trackA, trackB) => {
+        return differenceInSeconds(
+          new Date(trackA.date),
+          new Date(trackB.date)
+        );
+      });
+      return tracks;
+    }
+    let duplicateTracks = [];
+    trackGroups.forEach((trackGroup) => {
+      duplicateTracks = intersectionBy(tracks, trackGroup.tracks, "id");
+      pullAllBy(tracks, duplicateTracks, "id");
+      if (isLoggedIn.value) {
+        remove(trackGroup.tracks, ["access", false]);
+      }
+      trackGroup.tracks.sort((trackA, trackB) => {
+        return differenceInSeconds(
+          new Date(trackA.date),
+          new Date(trackB.date)
+        );
+      });
+      trackGroup.type = "track_group";
+    });
+    tracks.forEach((track) => {
+      track.type = "track";
+    });
+    const combinedArray = trackGroups.concat(tracks);
+    combinedArray.sort((trackA, trackB) => {
+      return differenceInSeconds(new Date(trackA.date), new Date(trackB.date));
+    });
+    return combinedArray;
+  };
+  const hasPresentations = (track) => {
+    if (track.type === "track_group") {
+      for (let i = 0; i < get(track, "tracks.length", 0); i++) {
+        if (get(track.tracks[i], "presentations.length", 0) > 0) {
+          return true;
+        }
+      }
+      return false;
+    } else {
+      return get(track, "presentations.length", 0) > 0;
+    }
+  };
+  const isGroupedTrack = (track) => {
+    return track.type === "track_group" && horizontalTrackGroups.value === true;
+  };
+  const isSmallGroupedTrack = (track) => {
+    if (isGroupedTrack(track)) {
+      if (get(track, "tracks.length", 0) > 1) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const getTracks = (track) => {
+    if (track.type === "track_group") {
+      return track.tracks;
+    } else {
+      return [track];
+    }
+  };
+  const getTrackClasses = (track, index) => {
+    let classes = "";
+    if (isGroupedTrack(track)) {
+      switch (index) {
+        case 0:
+        case 4:
+          classes += "agenda-grouped-track-color-1";
+          break;
+        case 1:
+        case 5:
+          classes += "agenda-grouped-track-color-2";
+          break;
+        case 2:
+        case 6:
+          classes += "agenda-grouped-track-color-3";
+          break;
+        case 3:
+        case 7:
+          classes += "agenda-grouped-track-color-4";
+          break;
+      }
+      if (get(track, "tracks.length", 0) === 1) {
+        classes += " lg:flex-row";
+      }
+    } else {
+      classes = "lg:flex-row";
+    }
+    return classes;
+  };
+  onBeforeMount(() => {
+    if (!affiliateStore.hasFetchedAffilites(conference.value.id)) {
+      affiliateStore.getAffiliates(conference.value.id);
+    }
+    if (selectedDay.value === null) {
+      selectedDay.value = conference.value.days[0];
+    }
+  });
+  const showInfoLink = () => {
+    return pagesConfigValue("agenda.session_desc_link") !== "none";
+  };
+  const useAccordion = () => {
+    return pagesConfigValue("agenda.use_accordion");
+  };
+  const usePresenterModal = () => {
+    return pagesConfigValue("agenda.use_presenter_modal");
+  };
+  const showPresenterDescription = (presenter, presentation) => {
+    if (selectedPresenter.value.presentationId === presentation.id && selectedPresenter.value.id === presenter.id) {
+      selectedPresenter.value = null;
+    } else {
+      selectedPresenter.value = presenter;
+    }
+  };
+  return {
+    days,
+    enabledSponsors,
+    selectedDay,
+    displayTrackGroups,
+    horizontalTrackGroups,
+    selectedPresenter,
+    setSelectedDay,
+    showTabDates,
+    shouldShowSponsors,
+    getCombinedTrackList,
+    hasPresentations,
+    isGroupedTrack,
+    isSmallGroupedTrack,
+    getTracks,
+    getTrackClasses,
+    showInfoLink,
+    useAccordion,
+    usePresenterModal,
+    showPresenterDescription
+  };
+};

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

@@ -0,0 +1,7 @@
+export declare type UseAnalyticsMethods = {
+    /**
+     * Fire event to google analytics
+     */
+    fireEvent: (event: string, label: string) => void;
+};
+export declare const useAnalytics: () => UseAnalyticsMethods;

package/dist/runtime/composables/useAnalytics.mjs

@@ -0,0 +1,10 @@
+import { useV3plusCommonModule } from "./useV3plusCommonModule.mjs";
+export const useAnalytics = () => {
+  const module = useV3plusCommonModule();
+  const fireEvent = (event, label) => {
+    module.analytics.click(event, label);
+  };
+  return {
+    fireEvent
+  };
+};

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

@@ -0,0 +1 @@
+export declare const useApi: () => any;

package/dist/runtime/composables/useApi.mjs

@@ -0,0 +1,16 @@
+import { useAuthStore } from "../store/auth.mjs";
+import { useV3plusCommonModule } from "./useV3plusCommonModule.mjs";
+export const useApi = () => {
+  const authStore = useAuthStore();
+  const commonModule = useV3plusCommonModule();
+  const headers = {
+    "X-Portal-Token": commonModule.options.portalHash
+  };
+  if (useAuthStore().isLoggedIn) {
+    headers.Authorization = `Bearer ${authStore.user.token}`;
+  }
+  return $fetch.create({
+    baseURL: commonModule.options.apiUrl,
+    headers
+  });
+};

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

@@ -0,0 +1,65 @@
+import { Ref } from "vue";
+import { Conference } from "../models/conference";
+export declare type UseConferenceHelpersMethods = {
+    /**
+     * Determine if conference is a single day event
+     */
+    isSingleDayEvent: (conference?: Conference) => boolean;
+    /**
+     * Determine if the webcast button should be shown
+     */
+    showConferenceWebcastButton: (conference?: Conference) => boolean;
+    /**
+     * get webcast button text
+     */
+    getConferenceWebcastButtonText: (conference?: Conference) => string;
+    /**
+     * Get conference webcast url
+     */
+    getConferenceWebcastUrl: (conference?: Conference) => string;
+    /**
+     * Get conference display date.
+     */
+    getConferenceDisplayDate: (conference?: Conference) => string;
+    /**
+     * Determine if show view archive button should be shown
+     */
+    showViewArchiveButton: (conference?: Conference) => boolean;
+    /**
+     * get view archive button text
+     */
+    getViewArchiveUrl: (conference?: Conference) => string;
+    /**
+     * get view archive button text
+     */
+    getViewArchiveButtonText: (conference?: Conference) => string;
+    /**
+     * determine if reg button should be shown
+     */
+    showConferenceRegButton: (conference?: Conference) => boolean;
+    /**
+     * Get conference registration url
+     */
+    getConferenceRegUrl: (conference?: Conference) => string;
+    /**
+     * get conference registration text
+     */
+    getConferenceRegText: (conference?: Conference) => string;
+    /**
+     * Show conference View button
+     */
+    showConferenceViewButton: (conference?: Conference) => boolean;
+    /**
+     * conference is live
+     */
+    conferenceIsLive: (conference?: Conference) => boolean;
+    /**
+     * conference is mixed
+     */
+    conferenceIsMixed: (conference?: Conference) => boolean;
+    /**
+     * conference is Archived
+     */
+    conferenceIsArchived: (conference?: Conference) => boolean;
+};
+export declare const useConferenceHelpers: (conferences: Ref<Conference> | Ref<Conference[]>) => UseConferenceHelpersMethods;