@saooti/octopus-sdk 40.0.3 → 40.1.0

package/src/components/mixins/player/playerTranscript.ts

@@ -1,113 +0,0 @@
-import classicApi from "../../../api/classicApi";
-import { defineComponent } from "vue";
-import { usePlayerStore } from "../../../stores/PlayerStore";
-import { mapState, mapActions } from "pinia";
-import { AdserverOtherEmission } from "@/stores/class/adserver/adserverOtherEmission";
-import { useVastStore } from "../../../stores/VastStore";
-export const playerTranscript = defineComponent({
-  computed: {
-    ...mapState(usePlayerStore, ["playerTranscript", "playerPodcast", "playerDelayStitching"]),
-    ...mapState(useVastStore, ["useVastPlayerPodcast"]),
-  },
-  methods: {
-    ...mapActions(usePlayerStore, ["playerUpdateTranscript", "playerUpdateChaptering", "playerUpdateDelayStitching"]),
-    async checkDelaytWithStitching(){
-      this.playerUpdateDelayStitching(0);
-      if(this.useVastPlayerPodcast){return;}
-      const audioPlayer = document.querySelector("#audio-player") as HTMLAudioElement;
-      if (!this.playerTranscript || !audioPlayer || !this.playerPodcast ||
-        audioPlayer.duration <= this.playerPodcast.duration / 1000 + 5) 
-      {
-        return;
-      }
-      const adserverConfig = await classicApi.fetchData<AdserverOtherEmission>({
-        api:0,
-        path:`ad/test/podcast/${this.playerPodcast.podcastId}`,
-        isNotAuth:true
-      });
-      const doubletsLength = adserverConfig.config.doublets.length;
-      if(1=== doubletsLength &&  "pre" === adserverConfig.config.doublets[0].timing.insertion){
-        this.playerUpdateDelayStitching( audioPlayer.duration - (this.playerPodcast.duration / 1000));
-      }else if(0===doubletsLength || 1=== doubletsLength &&  "post" === adserverConfig.config.doublets[0].timing.insertion){
-        return;
-      }else{
-        this.playerUpdateChaptering();
-        this.playerUpdateTranscript();
-      }
-    },
-    async getTranscription(): Promise<void> {
-      if (!this.playerPodcast) {
-        this.playerUpdateTranscript();
-        return;
-      }
-      const result = await classicApi.fetchData<string>({
-        api:11,
-        path:`response/${this.playerPodcast.podcastId}`,
-      });
-
-      const arrayTranscript = this.parseSrt(result);
-      const actualText =
-        arrayTranscript?.[0]?.startTime === 0 ? arrayTranscript[0].text : "";
-      if(!arrayTranscript){
-        return;
-      }
-      this.playerUpdateTranscript({
-        actual: 0,
-        actualText: actualText,
-        value: arrayTranscript
-      });
-    },
-    parseSrt(transcript: string) {
-      const result = [];
-      if (typeof transcript != "string") {
-        return;
-      }
-      if (transcript == null) {
-        return;
-      }
-      const pattern =
-      /(\d+)\n([\d:,]+)\s+-{2}>\s+([\d:,]+)\n([\s\S]*?(?=\n{2}|$))/gm;
-      transcript = transcript.replace(/\r\n|\r|\n|\t/g, "\n");
-      let matches;
-      while ((matches = pattern.exec(transcript)) != null) {
-        result.push({
-          startTime: this.srtTimeToSeconds(matches[2]),
-          endTime: this.srtTimeToSeconds(matches[3]),
-          text: matches[4],
-        });
-      }
-      return result;
-    },
-    srtTimeToSeconds(time: string): number {
-      const a = time.split(":");
-      return +a[0] * 60 * 60 + +a[1] * 60 + +parseFloat(a[2]);
-    },
-    onTimeUpdateTranscript(currentTime: number) {
-      if(!this.playerTranscript?.value.length){
-        return;
-      }
-      const startTime = (this.playerTranscript.value[this.playerTranscript.actual]?.startTime ?? 0) + this.playerDelayStitching;
-      if (startTime <= currentTime) {
-        this.playerTranscript.actualText = this.playerTranscript.value[this.playerTranscript?.actual]?.text ??"";
-      }
-      if (
-        (this.playerTranscript.value[this.playerTranscript.actual]?.endTime ??Infinity) + this.playerDelayStitching< currentTime
-      ) {
-        this.playerTranscript.actual += 1;
-        this.playerTranscript.actualText =
-          this.playerTranscript?.value[this.playerTranscript.actual]?.text ??
-          "";
-      }
-    },
-    
-    onSeekedTranscript(currentTime: number) {
-      if (this.playerTranscript) {
-        let newActual = 0;
-        while (currentTime >(this.playerTranscript.value[newActual]?.endTime ?? Infinity) + this.playerDelayStitching) {
-          newActual += 1;
-        }
-        this.playerTranscript.actual = newActual;
-      }
-    },
-  },
-});

package/src/components/mixins/player/playerVast.ts

@@ -1,198 +0,0 @@
-import { defineComponent } from "vue";
-import { loadScript } from "../loadScript";
-import { usePlayerStore } from "../../../stores/PlayerStore";
-import { useVastStore } from "../../../stores/VastStore";
-import { mapState, mapActions } from "pinia";
-
-let adsLoader: any;
-let adsManager:any;
-let adDisplayContainer:any;
-let adsRequest: any;
-
-export const playerVast = defineComponent({
-  mixins:[loadScript],
-  data() {
-    return {
-      imaLoaded: false as boolean,
-      isContentFinished: false as boolean,
-      audioContainer: null as HTMLAudioElement|null,
-      isAdRequested: false as boolean,
-      statusPlayerWhenLoaded: "" as string
-    };
-  },
-  computed: {
-    ...mapState(usePlayerStore, ["playerPodcast", "playerStatus","playerCurrentChange","playerVideo"]),
-    ...mapState(useVastStore, ["isAdPlaying", "currentAd", "isAdPaused", "isAdSkipped", "vastUrl"]),
-  },
-  watch:{
-    isAdPaused(){
-      this.onAdChangePlayingStatus();
-    },
-    isAdSkipped(){
-      this.onAdSkipped();
-    }
-  },
-  methods: {
-    ...mapActions(useVastStore, ["updateIsAdPlaying","updateIsAdPaused", "updateSkippableData", "updateCurrentAd", "updateProgressionData", "restartVastData"]),
-    ...mapActions(usePlayerStore, ["playerChangeStatus"]),
-    prepareIMA(){
-      if(!this.imaLoaded){
-        this.imaLoaded = true;
-        this.loadIMA();
-      }else{
-        this.initializeIMA();
-      }
-    },
-    loadIMA(){
-      this.loadScript('//imasdk.googleapis.com/js/sdkloader/ima3.js', true, (isIMALoaded:boolean) => {
-        if(isIMALoaded) {
-          this.initializeIMA();
-        }
-      });
-    },
-    initializeIMA(): void {
-      console.log("Initialize IMA");
-      this.initializeDisplayContainer();
-      if(!adDisplayContainer || !adsLoader){
-        return;
-      }
-    },
-    onRequestAd(vastUrl: string){
-      this.isAdRequested = true;
-      console.log("Request ad "+vastUrl);
-      this.initializeAdsRequest(vastUrl);
-      adsLoader.requestAds(adsRequest);
-    },
-    initializeDisplayContainer():void{
-      if(adDisplayContainer){return};
-      this.audioContainer = (document.getElementById('audio-player') as HTMLAudioElement); 
-      if(null===this.audioContainer){return;}
-      adDisplayContainer = new google.ima.AdDisplayContainer(document.getElementById('ad-container'), this.audioContainer);
-      adDisplayContainer.initialize();
-      this.initializeAdsLoader();
-    },
-    initializeAdsLoader():void{
-      adsLoader = new google.ima.AdsLoader(adDisplayContainer);
-      adsManager = null;
-      adsLoader.addEventListener(
-        google.ima.AdsManagerLoadedEvent.Type.ADS_MANAGER_LOADED,
-        this.onAdsManagerLoaded,
-        false
-      );
-      adsLoader.addEventListener(
-        google.ima.AdErrorEvent.Type.AD_ERROR,
-        this.onAdError,
-        false
-      );
-    },
-    initializeAdsRequest(vastUrl: string):void{
-      adsRequest = new google.ima.AdsRequest();
-      adsRequest.setAdWillAutoPlay(true);
-      adsRequest.adTagUrl = vastUrl;
-    },
-    onAdsManagerLoaded(adsManagerLoadedEvent: any) {
-      const adsRenderingSettings = new google.ima.AdsRenderingSettings();
-      adsRenderingSettings.restoreCustomPlaybackStateOnAdBreakComplete = true;
-      adsManager = adsManagerLoadedEvent.getAdsManager(this.audioContainer, adsRenderingSettings);
-      this.startAdManager();
-    },
-    startAdManager(){
-      console.log("Start manager");
-      this.initAdManagerEvents();
-      try {
-        adsManager.init(0, 0, google.ima.ViewMode.NORMAL);
-        adsManager.start();
-      } catch (adError) {
-        console.log(adError);
-        this.playerChangeStatus(false);
-        this.destroyAdManager();
-      }
-    },
-    initAdManagerEvents(){
-      adsManager.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR,this.onAdError);
-      adsManager.addEventListener(google.ima.AdEvent.Type.CONTENT_PAUSE_REQUESTED, this.onContentPauseRequested);
-      adsManager.addEventListener(google.ima.AdEvent.Type.CONTENT_RESUME_REQUESTED, this.onContentResumeRequested);
-      const events = [
-        google.ima.AdEvent.Type.ALL_ADS_COMPLETED, google.ima.AdEvent.Type.AD_PROGRESS,
-        google.ima.AdEvent.Type.COMPLETE, google.ima.AdEvent.Type.LOADED, 
-        google.ima.AdEvent.Type.PAUSED, google.ima.AdEvent.Type.STARTED,
-      ];
-      for (const index in events) {
-        adsManager.addEventListener(events[index], this.onAdEvent);
-      }
-    },
-    onAdError(adErrorEvent: any) {
-      console.log(adErrorEvent.getError());
-      this.destroyAdManager();
-    },
-    destroyAdManager(){
-      if(!adsManager){return;}
-      console.log("Destroy manager");
-      adsManager?.destroy();
-      adsManager = null;
-      this.restartVastData();
-      this.isContentFinished=false;
-      this.isAdRequested = false;
-    },
-    onAdEvent(adEvent: any) {
-      const ad = adEvent.getAd();
-      if(ad){
-        this.updateCurrentAd(ad);
-      }
-      switch (adEvent.type) {
-        case google.ima.AdEvent.Type.LOADED:
-          this.statusPlayerWhenLoaded= this.playerStatus;
-          if (!ad.isLinear()) {
-            this.playerChangeStatus(false);
-            this.isAdRequested = false;
-          }
-          break;
-        case google.ima.AdEvent.Type.STARTED:
-          console.log("Launched status : "+this.statusPlayerWhenLoaded);
-          if("PLAYING"!==this.statusPlayerWhenLoaded){
-            this.updateIsAdPaused(true);
-            adsManager.pause();
-          }
-          break;
-        case google.ima.AdEvent.Type.AD_PROGRESS:{
-          this.isAdRequested = false;
-          const adProgressData = adEvent.getAdData();
-          this.updateProgressionData(adProgressData.duration,adProgressData.currentTime);
-          this.updateSkippableData(
-            this.currentAd.getSkipTimeOffset()!== -1,
-            adsManager.getAdSkippableState(),
-            Math.ceil(this.currentAd.getSkipTimeOffset() - adProgressData.currentTime));
-          break;
-        }
-      }
-    },
-    onContentPauseRequested() {
-      this.updateIsAdPlaying(true);
-      this.playerChangeStatus(true);
-    },
-    onContentResumeRequested() {
-      this.updateIsAdPlaying(false);
-      if (!this.isContentFinished) {
-        this.playerChangeStatus(false);
-      }
-    },
-    contentEndedAdsLoader():void{
-      if (this.isAdPlaying) return;
-      this.isContentFinished = true;
-      adsLoader?.contentComplete();
-    },
-    onAdChangePlayingStatus(){
-      if(!adsManager){return;}
-      if(this.isAdPaused){
-        adsManager.pause();
-      }else{
-        adsManager.resume();
-      }
-    },
-    onAdSkipped(){
-      if(this.isAdSkipped){
-        adsManager.skip();
-      }
-    }
-  },
-});

package/src/components/mixins/podcast/countdown.ts

@@ -1,45 +0,0 @@
-import { defineComponent } from 'vue';
-export default defineComponent({
-  props: {
-    timeRemaining: { default: undefined, type: Number },
-  },
-  data() {
-    return {
-      seconds: 0 as number,
-      countdownTimer: undefined as ReturnType<typeof setTimeout> | undefined,
-      days: 0 as number,
-      hours: 0 as number,
-      minutes: 0 as number,
-      remainingSeconds: 0 as number,
-    };
-  },
-  mounted() {
-    if (!this.timeRemaining || this.timeRemaining <= 0) return;
-    this.seconds = this.timeRemaining;
-    this.countdownTimer = setInterval(() => {
-      this.timer();
-    }, 1000);
-  },
-  unmounted() {
-    clearInterval(this.countdownTimer as unknown as number);
-  },
-  methods: {
-    timer(): void {
-      this.days = Math.floor(this.seconds / 24 / 60 / 60);
-      const hoursLeft = Math.floor(this.seconds - this.days * 86400);
-      this.hours = Math.floor(hoursLeft / 3600);
-      const minutesLeft = Math.floor(hoursLeft - this.hours * 3600);
-      this.minutes = Math.floor(minutesLeft / 60);
-      this.remainingSeconds = this.seconds % 60;
-      if (0 === this.seconds) {
-        clearInterval(this.countdownTimer as unknown as number);
-        this.countdownTimer = undefined;
-      } else {
-        this.seconds--;
-      }
-    },
-    pad(n: number): string {
-      return/*  n < 10 ? "0" + n : */ n.toString();
-    },
-  },
-});

package/src/components/mixins/podcast/podcastView.ts

@@ -1,63 +0,0 @@
-import dayjs from "dayjs";
-import duration from "dayjs/plugin/duration";
-dayjs.extend(duration);
-
-// @ts-expect-error Bibliothèque non typée
-import humanizeDuration from "humanize-duration";
-import { defineComponent } from 'vue';
-export default defineComponent({
-  computed:{
-    isCounter(): boolean {
-      return (
-        this.isLiveReadyToRecord &&
-        undefined !== this.podcastConference &&
-        ("PLANNED" === this.podcastConference.status ||
-          "PENDING" === this.podcastConference.status)
-      );
-    },
-    timeRemaining(): number {
-      return !this.podcast
-        ? 0
-        : dayjs(this.podcast.pubDate).diff(dayjs(), "seconds");
-    },
-    isPlannedInProcessor(): boolean {
-      return "PLANNED" === this.podcast?.processingStatus;
-    },
-    isLiveReadyToRecord(): boolean {
-      return (
-        undefined !== this.podcast &&
-        undefined !== this.podcast.conferenceId &&
-        0 !== this.podcast.conferenceId &&
-        "READY_TO_RECORD" === this.podcast.processingStatus
-      );
-    },
-    date(): string {
-      if (!this.podcast || 1970 === dayjs(this.podcast.pubDate).year()) {
-        return "";
-      }
-      if (this.isLiveReadyToRecord) {
-        return dayjs(this.podcast.pubDate).format("D MMMM YYYY - HH:mm");
-      }
-      return dayjs(this.podcast.pubDate).format("D MMMM YYYY");
-    },
-    duration(): string {
-      if (!this.podcast || this.podcast.duration <= 1) return "";
-      if (this.podcast.duration > 600000) {
-        return humanizeDuration(this.podcast.duration, {
-          language: this.$i18n.locale,
-          largest: 1,
-          round: true,
-        });
-      }
-      return humanizeDuration(this.podcast.duration, {
-        language: this.$i18n.locale,
-        largest: 2,
-        round: true,
-      });
-    },
-    durationIso(): string {
-      if (!this.podcast || this.podcast.duration <= 1) return "";
-      return dayjs.duration({ milliseconds: this.podcast.duration }).toISOString();
-    },
-  }
-});

package/src/components/mixins/radio/fetchRadioData.ts

@@ -1,77 +0,0 @@
-import { defineComponent } from "vue";
-import { MediaRadio, MetadataRadio, NextAdvertising } from "@/stores/class/general/player";
-import classicApi from "../../../api/classicApi";
-import dayjs from "dayjs";
-import { Podcast } from "@/stores/class/general/podcast";
-export const fetchRadioData = defineComponent({
-  data() {
-    return {
-      radioInterval: undefined as ReturnType<typeof setTimeout> | undefined,
-    };
-  },
-  unmounted() {
-    clearInterval(this.radioInterval as unknown as number);
-  },
-  methods: {
-    async fetchRadioMetadata(
-      canalId: number,
-      previousTitle: string,
-      callbackMetadata: (
-        metadata: MediaRadio,
-        podcast: Podcast | undefined,
-        history: Array<MediaRadio>
-      ) => void,
-      callbackAdvertising?: (
-        nextAdvertising: NextAdvertising
-      ) => void,
-    ): Promise<void> {
-      const metadata = await classicApi.fetchData<MetadataRadio>({
-        api: 14,
-        path:  "player/playing/" + canalId,
-      });
-      if(callbackAdvertising){
-        callbackAdvertising(metadata.nextAdvertising);
-      }
-      const arrayMetadata = metadata.previously;
-      arrayMetadata.unshift(metadata.currently);
-      for (let index = 0, len = arrayMetadata.length; index < len; index++) {
-        if (
-          dayjs().valueOf() - 18000 >
-          dayjs(arrayMetadata[index].startDate).valueOf()
-        ) {
-          await this.useCallbackIfNewMetadata(previousTitle, arrayMetadata, index, len,callbackMetadata);
-          return;
-        }
-      }
-    },
-    async useCallbackIfNewMetadata(previousTitle: string, arrayMetadata: Array<MediaRadio>, index:number, len: number, callbackMetadata: (
-      metadata: MediaRadio,
-      podcast: Podcast | undefined,
-      history: Array<MediaRadio>
-    ) => void){
-      if (previousTitle !== arrayMetadata[index].title) {
-        const historyIndex = index + 1 < len ? index + 1 : index;
-        const history = arrayMetadata.slice(historyIndex, len);
-        if (arrayMetadata[index].podcastId) {
-          const data: Podcast = await classicApi.fetchData<Podcast>({
-            api: 0,
-            path: "podcast/" + arrayMetadata[index].podcastId,
-          });
-          callbackMetadata(arrayMetadata[index], data, history);
-        } else {
-          callbackMetadata(arrayMetadata[index], undefined, history);
-        }
-      }
-    },
-    displayTitle(metadata: MediaRadio): string {
-      let title = "";
-      if (metadata.title) {
-        title += metadata.title;
-      }
-      if (metadata.artist) {
-        title += " - " + metadata.artist;
-      }
-      return title;
-    },
-  },
-});

package/src/components/mixins/resizePhone.ts

@@ -1,26 +0,0 @@
-
-import debounce from './debounce';
-import { defineComponent } from 'vue';
-export default defineComponent({
-  data() {
-    return {
-      isPhone: false as boolean,
-      windowWidth: 0 as number,
-      debounceResizeEvent: undefined as undefined|((...args: any[]) => void)
-    };
-  },
-  created() {
-    this.debounceResizeEvent = debounce(this.handleResize, 500);
-    window.addEventListener('resize', this.debounceResizeEvent);
-    this.handleResize();
-  },
-  unmounted() {
-    window.removeEventListener('resize', this.debounceResizeEvent);
-  },
-  methods: {
-    handleResize(): void {
-      this.windowWidth= window.innerWidth;
-      this.isPhone =this.windowWidth < 960;
-    },
-  },
-});