@saooti/octopus-sdk 42.1.0 → 42.1.2

package/dist/PlayerComponent-CUHTRJic.mjs

@@ -0,0 +1,929 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { A as state, O as useApiStore, S as transcriptionApi, T as useSaveFetchStore, i as useAuthStore, m as podcastApi, n as fetchHelper_default, t as classicApi_default, y as organisationApi } from "./classicApi-ChvwoPGT.mjs";
+import { n as usePlayerStore, t as PlayerStatus } from "./PlayerStore-7vhL8Npe.mjs";
+import { t as useGeneralStore } from "./GeneralStore-CUlq_NjO.mjs";
+import { t as useTranslation } from "./useTranslation-Dsw1HxX9.mjs";
+import { t as stringHelper_default } from "./stringHelper-DFr4Khve.mjs";
+import { t as useVastStore } from "./VastStore-BPwOrXvb.mjs";
+import { t as usePlayerLogicProgress } from "./usePlayerLogicProgress-C-gsD-ec.mjs";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineAsyncComponent, defineComponent, nextTick, normalizeClass, normalizeStyle, onMounted, openBlock, ref, renderSlot, watch } from "vue";
+import { useRoute } from "vue-router";
+import dayjs from "dayjs";
+//#region src/components/composable/player/usePlayerLive.ts
+var Hls = null;
+var maxMinutesSessionId = 1;
+var usePlayerLive = (hlsReady) => {
+	const { listenTime, initLiveDownloadId, setDownloadId, onTimeUpdateProgress } = usePlayerLogicProgress();
+	const audioElement = ref(null);
+	const hls = ref(null);
+	const hlsRetryTimeout = ref(void 0);
+	const playPromise = ref(void 0);
+	const errorHls = ref(false);
+	const playerStore = usePlayerStore();
+	const apiStore = useApiStore();
+	const authStore = useAuthStore();
+	function needToAddToken(url) {
+		if (authStore.authParam.accessToken && ("SECURED" === playerStore.playerLive?.organisation?.privacy || playerStore.playerRadio?.secured)) {
+			const baseDomain = apiStore.frontendUrl.replace(/^https?:\/\//, "");
+			return url.includes(baseDomain);
+		}
+		return false;
+	}
+	function onPlay() {
+		playerStore.playerChangeStatus(PlayerStatus.PAUSED === playerStore.playerStatus);
+	}
+	function playRadio() {
+		if (!playerStore.playerRadio) return;
+		handleSessionIdRadio();
+		playerStore.playerUpdatePlayerHlsUrl(playerStore.playerRadio.url + "?origin=octopus&sessionId=" + playerStore.playerRadio.sessionId);
+		playHls();
+	}
+	function handleSessionIdRadio() {
+		if (!playerStore.playerRadio) return;
+		if (playerStore.playerRadio.sessionId && dayjs().diff(dayjs(playerStore.playerRadio.dateSessionId), "m") < maxMinutesSessionId) return;
+		playerStore.playerRadio.sessionId = stringHelper_default.uuidv4();
+	}
+	function playLive() {
+		if (!playerStore.playerHlsIdentifier) return;
+		playerStore.playerUpdatePlayerHlsUrl(`${apiStore.hlsUrl}live/${playerStore.playerHlsIdentifier}/index.m3u8`);
+		playHls();
+	}
+	async function playHls() {
+		try {
+			if (null === audioElement.value) audioElement.value = document.getElementById("audio-player");
+			if (null === audioElement.value || !playerStore.playerHlsUrl) {
+				setTimeout(playHls, 1e3);
+				return;
+			}
+			const ua = navigator.userAgent.toLowerCase();
+			const isAndroid = ua.indexOf("android") > -1;
+			const isChrome = ua.indexOf("chrome") > -1;
+			if (audioElement.value.canPlayType("application/vnd.apple.mpegurl") && !isChrome && !isAndroid) {
+				let url = playerStore.playerHlsUrl;
+				if (needToAddToken(url)) if (url.includes("?")) url += "&access_token=" + authStore.authParam.accessToken;
+				else url += "?access_token=" + authStore.authParam.accessToken;
+				audioElement.value.src = url;
+				await initLiveDownloadId();
+				hlsReady.value = true;
+				await audioElement.value.play();
+				onPlay();
+			} else await initHls();
+		} catch (e) {
+			console.error(e);
+			onHlsError();
+		}
+	}
+	function onHlsError() {
+		if ("STOPPED" !== playerStore.playerStatus && void 0 === hlsRetryTimeout.value) hlsRetryTimeout.value = setTimeout(() => {
+			errorHls.value = false;
+			playHls();
+			hlsRetryTimeout.value = void 0;
+		}, 5e3);
+	}
+	async function initHls() {
+		if (null === Hls) await import("hls.js").then((hlsLibrary) => {
+			Hls = hlsLibrary.default;
+		});
+		if (!Hls.isSupported()) throw new Error("Hls is not supported ! ");
+		hls.value = new Hls({
+			autoStartLoad: true,
+			liveDurationInfinity: true,
+			backBufferLength: 10,
+			maxBufferLength: 60,
+			xhrSetup: (xhr, url) => {
+				if (needToAddToken(url)) xhr.setRequestHeader("Authorization", "Bearer " + authStore.authParam.accessToken);
+			}
+		});
+		hls.value.on(Hls.Events.MANIFEST_PARSED, async () => {
+			await initLiveDownloadId();
+			hlsReady.value = true;
+			if (true === errorHls.value) return;
+			setTimeout(() => {
+				playPromise.value = audioElement.value.play();
+				playPromise.value.then(() => {
+					playPromise.value = void 0;
+					onPlay();
+				}).catch((e) => {
+					console.error(e);
+					onHlsError();
+					playPromise.value = void 0;
+				});
+			}, 500);
+		});
+		hls.value.on(Hls.Events.ERROR, async (name, data) => {
+			if (data.details === "bufferStalledError") {
+				console.warn("playback is stalling…");
+				playerStore.playerStatus = PlayerStatus.LOADING;
+				hls.value.destroy();
+				setTimeout(initHls, 500);
+				return;
+			}
+			console.error("An error occured: " + name + " / " + data.details);
+			console.error(data);
+			if (data.fatal && data.type === Hls.ErrorTypes.MEDIA_ERROR) {
+				console.warn("Trying to recover...");
+				hls.value.recoverMediaError();
+			}
+			errorHls.value = true;
+			if (void 0 === playPromise.value && data.fatal) onHlsError();
+		});
+		hls.value.loadSource(playerStore.playerHlsUrl);
+		hls.value.attachMedia(audioElement.value);
+	}
+	async function endingLive() {
+		clearTimeout(hlsRetryTimeout.value);
+		hlsRetryTimeout.value = void 0;
+		if (null === audioElement.value) return;
+		audioElement.value = null;
+		const audio = document.getElementById("audio-player");
+		if (audio && hls.value) {
+			hls.value.destroy();
+			hls.value = null;
+		} else audio.pause();
+		audio.src = "";
+	}
+	return {
+		listenTime,
+		setDownloadId,
+		onTimeUpdateProgress,
+		playLive,
+		endingLive,
+		playRadio,
+		onPlay
+	};
+};
+//#endregion
+//#region src/helper/loadScript.ts
+function loadScript(src, async, callback) {
+	const firstElement = document.getElementsByTagName("head")[0] || document.documentElement, scriptElement = document.createElement("script");
+	scriptElement.type = "text/javascript";
+	scriptElement.src = src;
+	scriptElement.async = async;
+	scriptElement.addEventListener("load", function() {
+		if (callback && typeof callback === "function") callback(true);
+	}, false);
+	scriptElement.addEventListener("error", function() {
+		firstElement.removeChild(scriptElement);
+		if (callback && typeof callback === "function") callback(false);
+	}, false);
+	firstElement.insertBefore(scriptElement, firstElement.firstChild);
+}
+//#endregion
+//#region src/components/composable/player/usePlayerVast.ts
+var adsLoader;
+var adsManager;
+var adDisplayContainer;
+var adsRequest;
+var usePlayerVast = () => {
+	const imaLoaded = ref(false);
+	const isContentFinished = ref(false);
+	const audioContainer = ref(null);
+	const isAdRequested = ref(false);
+	const statusPlayerWhenLoaded = ref("");
+	const dateForSessionId = ref(void 0);
+	const playerStore = usePlayerStore();
+	const vastStore = useVastStore();
+	watch(() => vastStore.isAdPaused, () => {
+		onAdChangePlayingStatus();
+	});
+	watch(() => vastStore.isAdSkipped, () => {
+		onAdSkipped();
+	});
+	function prepareIMA() {
+		if (!imaLoaded.value) {
+			imaLoaded.value = true;
+			loadIMA();
+		} else initializeIMA();
+	}
+	function loadIMA() {
+		loadScript("//imasdk.googleapis.com/js/sdkloader/ima3.js", true, (isIMALoaded) => {
+			if (isIMALoaded) initializeIMA();
+		});
+	}
+	function initializeIMA() {
+		console.log("Initialize IMA");
+		initializeDisplayContainer();
+		if (!adDisplayContainer || !adsLoader) return;
+	}
+	function onRequestAd(vastUrl) {
+		isAdRequested.value = true;
+		console.log("Request ad " + vastUrl);
+		initializeAdsRequest(vastUrl);
+		adsLoader.requestAds(adsRequest);
+	}
+	function initializeDisplayContainer() {
+		if (adDisplayContainer) return;
+		audioContainer.value = document.getElementById("audio-player");
+		if (null === audioContainer.value) return;
+		adDisplayContainer = new google.ima.AdDisplayContainer(document.getElementById("ad-container"), audioContainer.value);
+		adDisplayContainer.initialize();
+		initializeAdsLoader();
+	}
+	function initializeAdsLoader() {
+		adsLoader = new google.ima.AdsLoader(adDisplayContainer);
+		adsManager = null;
+		adsLoader.addEventListener(google.ima.AdsManagerLoadedEvent.Type.ADS_MANAGER_LOADED, onAdsManagerLoaded, false);
+		adsLoader.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR, onAdError, false);
+	}
+	function initializeAdsRequest(vastUrl) {
+		adsRequest = new google.ima.AdsRequest();
+		adsRequest.setAdWillAutoPlay(true);
+		adsRequest.adTagUrl = vastUrl;
+	}
+	function onAdsManagerLoaded(adsManagerLoadedEvent) {
+		const adsRenderingSettings = new google.ima.AdsRenderingSettings();
+		adsRenderingSettings.restoreCustomPlaybackStateOnAdBreakComplete = true;
+		adsManager = adsManagerLoadedEvent.getAdsManager(audioContainer.value, adsRenderingSettings);
+		startAdManager();
+	}
+	function startAdManager() {
+		console.log("Start manager");
+		initAdManagerEvents();
+		try {
+			adsManager.init(0, 0, google.ima.ViewMode.NORMAL);
+			adsManager.start();
+		} catch (adError) {
+			console.log(adError);
+			playerStore.playerChangeStatus(false);
+			destroyAdManager();
+		}
+	}
+	function initAdManagerEvents() {
+		adsManager.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR, onAdError);
+		adsManager.addEventListener(google.ima.AdEvent.Type.CONTENT_PAUSE_REQUESTED, onContentPauseRequested);
+		adsManager.addEventListener(google.ima.AdEvent.Type.CONTENT_RESUME_REQUESTED, 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], onAdEvent);
+	}
+	function onAdError(adErrorEvent) {
+		console.log(adErrorEvent.getError());
+		destroyAdManager();
+	}
+	function destroyAdManager() {
+		if (!adsManager) return;
+		console.log("Destroy manager");
+		adsManager?.destroy();
+		adsManager = null;
+		vastStore.restartVastData();
+		isContentFinished.value = false;
+		isAdRequested.value = false;
+	}
+	function onAdEvent(adEvent) {
+		const ad = adEvent.getAd();
+		if (ad) vastStore.updateCurrentAd(ad);
+		switch (adEvent.type) {
+			case google.ima.AdEvent.Type.LOADED:
+				statusPlayerWhenLoaded.value = playerStore.playerStatus;
+				if (!ad.isLinear()) {
+					playerStore.playerChangeStatus(false);
+					isAdRequested.value = false;
+				}
+				break;
+			case google.ima.AdEvent.Type.STARTED:
+				console.log("Launched status : " + statusPlayerWhenLoaded.value);
+				if ("PLAYING" !== statusPlayerWhenLoaded.value) {
+					vastStore.updateIsAdPaused(true);
+					adsManager.pause();
+				}
+				break;
+			case google.ima.AdEvent.Type.AD_PROGRESS: {
+				isAdRequested.value = false;
+				const adProgressData = adEvent.getAdData();
+				vastStore.updateProgressionData(adProgressData.duration, adProgressData.currentTime);
+				vastStore.updateSkippableData(vastStore.currentAd.getSkipTimeOffset() !== -1, adsManager.getAdSkippableState(), Math.ceil(vastStore.currentAd.getSkipTimeOffset() - adProgressData.currentTime));
+				break;
+			}
+		}
+	}
+	function onContentPauseRequested() {
+		vastStore.updateIsAdPlaying(true);
+		playerStore.playerChangeStatus(true);
+	}
+	function onContentResumeRequested() {
+		if (!isContentFinished.value) playerStore.playerChangeStatus(false);
+		nextTick(() => {
+			vastStore.updateIsAdPlaying(false);
+			vastStore.updateResetSessionId(false);
+		});
+	}
+	function contentEndedAdsLoader() {
+		if (vastStore.isAdPlaying) return;
+		isContentFinished.value = true;
+		adsLoader?.contentComplete();
+	}
+	function onAdChangePlayingStatus() {
+		if (!adsManager) return;
+		if (vastStore.isAdPaused) {
+			adsManager.pause();
+			dateForSessionId.value = dayjs().toISOString();
+		} else {
+			adsManager.resume();
+			if (!vastStore.resetSessionId && dayjs().diff(dayjs(dateForSessionId.value), "m") > 1) vastStore.updateResetSessionId(true);
+		}
+	}
+	function onAdSkipped() {
+		if (vastStore.isAdSkipped) adsManager.skip();
+	}
+	return {
+		isAdRequested,
+		prepareIMA,
+		onRequestAd,
+		destroyAdManager,
+		contentEndedAdsLoader
+	};
+};
+//#endregion
+//#region src/components/composable/player/usePlayerStitching.ts
+var usePlayerStitching = () => {
+	const { isAdRequested, prepareIMA, onRequestAd, destroyAdManager, contentEndedAdsLoader } = usePlayerVast();
+	const radioInterval = ref(void 0);
+	const route = useRoute();
+	const playerStore = usePlayerStore();
+	const vastStore = useVastStore();
+	const saveFetchStore = useSaveFetchStore();
+	const radioNextAdvertisingStartDate = computed(() => {
+		return playerStore.playerRadio?.nextAdvertising?.startDate;
+	});
+	watch(() => playerStore.playerCurrentChange, () => {
+		if (playerStore.playerCurrentChange && playerStore.playerCurrentChange > 0 && !checkUsePlayerPodcastStitching()) return;
+		onPlayerChange();
+	});
+	watch(() => playerStore.playerElapsedSeconds, () => {
+		if (!checkUsePlayerPodcastStitching()) return;
+		if (!isAdRequested.value && checkAdNeedToBeLaunch()) {
+			onRequestAd(vastStore.adPositionsPodcasts[playerStore.playerCurrentChange ?? 0][vastStore.adPositionIndex].vastUrl);
+			vastStore.updateAdPositionIndex(vastStore.adPositionIndex + 1);
+		}
+	});
+	watch(radioNextAdvertisingStartDate, () => {
+		if (!radioNextAdvertisingStartDate.value) return;
+		defineRadioInterval();
+	}, { immediate: true });
+	onMounted(() => {
+		vastStore.updateuseVastPlayerPodcast("true" === route.query.vast);
+	});
+	function checkUsePlayerPodcastStitching() {
+		return vastStore.useVastPlayerPodcast;
+	}
+	function defineRadioInterval() {
+		clearRadioInterval();
+		const timeRemaining = dayjs(radioNextAdvertisingStartDate.value).diff(dayjs(), "millisecond");
+		console.log("TimeRemaining " + timeRemaining);
+		if (timeRemaining < 0) return;
+		radioInterval.value = setTimeout(() => {
+			radioIntervalExecute();
+		}, timeRemaining);
+	}
+	async function radioIntervalExecute() {
+		if ("PAUSED" === playerStore.playerStatus) return;
+		const vastUrl = await getVastUrl(playerStore.playerRadio?.nextAdvertising?.tag ?? "5e385e1b51c86", playerStore.playerRadio?.nextAdvertising?.adCount ?? 1);
+		console.log("vastUrl " + vastUrl);
+		onRequestAd(vastUrl);
+	}
+	function clearRadioInterval() {
+		clearInterval(radioInterval.value);
+		radioInterval.value = void 0;
+	}
+	function checkAdNeedToBeLaunch() {
+		if (!playerStore.playerCurrentChange || !vastStore.adPositionsPodcasts[playerStore.playerCurrentChange]?.[vastStore.adPositionIndex]) return false;
+		return vastStore.adPositionsPodcasts[playerStore.playerCurrentChange][vastStore.adPositionIndex]?.seconds <= playerStore.playerElapsedSeconds;
+	}
+	async function onPlayerChange() {
+		destroyAdManager();
+		if (null == playerStore.playerCurrentChange) return;
+		prepareIMA();
+		await fetchPodcastAdConfig();
+	}
+	async function fetchPodcastAdConfig() {
+		if (!playerStore.playerCurrentChange || !playerStore.playerPodcast || playerStore.playerCurrentChange && vastStore.adPositionsPodcasts[playerStore.playerCurrentChange]) return;
+		const adserverConfig = await classicApi_default.fetchData({
+			api: 0,
+			path: `ad/test/podcast/${playerStore.playerCurrentChange}`,
+			isNotAuth: true
+		});
+		if (!adserverConfig || "SOUNDCAST_VAST" !== adserverConfig.config?.server) {
+			vastStore.updateAdPositionsPodcasts(playerStore.playerCurrentChange, []);
+			return;
+		}
+		const podcastDurationSeconds = Math.round((playerStore.playerPodcast?.duration ?? 0) / 1e3);
+		const selectedAdPositions = await selectCorrectAdPositions(generateAllAdPositions(adserverConfig.config.doublets, podcastDurationSeconds), podcastDurationSeconds, adserverConfig.config.minIntervalDuration, adserverConfig.config.minTailDuration);
+		vastStore.updateAdPositionsPodcasts(playerStore.playerCurrentChange, selectedAdPositions);
+	}
+	function generateAllAdPositions(doublets, podcastDuration) {
+		const adPositions = [];
+		if (doublets.some((element) => {
+			return "TAG_NO_AD" === element.tag;
+		})) return [];
+		for (const doublet of doublets) {
+			if (!doublet.tag) continue;
+			let seconds = 0;
+			if ("post" === doublet.timing.insertion) seconds = podcastDuration;
+			else if ("mid" === doublet.timing.insertion) {
+				const mesure = doublet.timing.mesure ?? 0;
+				switch (doublet.timing.unit) {
+					case "MILLISECOND":
+						seconds = mesure * 1e3;
+						break;
+					case "MINUTE":
+						seconds = Math.round(mesure / 60);
+						break;
+					case "PERCENT":
+						seconds = Math.round(mesure * podcastDuration / 100);
+						break;
+					default:
+						seconds = mesure;
+						break;
+				}
+			}
+			adPositions.push({
+				impressId: doublet.tag,
+				policy: doublet.timing.insertion,
+				seconds,
+				vastUrl: ""
+			});
+		}
+		return adPositions.sort((a, b) => {
+			if (a.seconds > b.seconds) return 1;
+			return b.seconds > a.seconds ? -1 : 0;
+		});
+	}
+	async function selectCorrectAdPositions(allAdPositions, podcastDuration, minIntervalDuration, minTailDuration) {
+		const adPositions = [];
+		let previousPosition = -1;
+		for (const adPosition of allAdPositions) switch (adPosition.policy) {
+			case "pre":
+				adPositions.push(await defineVastUrl(adPosition));
+				previousPosition = 0;
+				break;
+			case "mid":
+				if (adPosition.seconds > podcastDuration - minTailDuration) continue;
+				if (previousPosition >= 0 && adPosition.seconds < previousPosition + minIntervalDuration) continue;
+				adPositions.push(await defineVastUrl(adPosition));
+				previousPosition = adPosition.seconds;
+				break;
+			case "post":
+				if (previousPosition >= 0 && previousPosition > podcastDuration - minIntervalDuration) continue;
+				adPositions.push(await defineVastUrl(adPosition));
+				break;
+			default: break;
+		}
+		return adPositions;
+	}
+	async function defineVastUrl(adPosition) {
+		adPosition.vastUrl = await getVastUrl(adPosition.impressId, 1);
+		return adPosition;
+	}
+	async function getVastUrl(tag, adCount) {
+		const baseUrl = "https://api.soundcast.io/v1/vast/" + tag;
+		let keywords = [];
+		if (playerStore.playerPodcast?.tags?.length) {
+			if ("true" === (await saveFetchStore.getOrgaAttributes(playerStore.playerPodcast.organisation.id))["AD_CONFIG_PODCAST_TAG"]) keywords = playerStore.playerPodcast.tags.map((e) => {
+				return "tag:" + e;
+			});
+		}
+		const parameters = fetchHelper_default.getUriSearchParams({
+			adCount: adCount ?? 1,
+			pageUrl: document.referrer,
+			keywords
+		});
+		return baseUrl + "?" + parameters.toString();
+	}
+	return { contentEndedAdsLoader };
+};
+//#endregion
+//#region src/components/composable/player/usePlayerTranscript.ts
+/** Contains the language of the transcript being generated */
+var generatingTranscriptLanguage = ref(null);
+var usePlayerTranscript = () => {
+	const playerStore = usePlayerStore();
+	const vastStore = useVastStore();
+	const { getMostRelevantLanguage } = useTranslation();
+	async function checkDelaytWithStitching() {
+		playerStore.playerUpdateDelayStitching(0);
+		if (vastStore.useVastPlayerPodcast) return;
+		const audioPlayer = document.querySelector("#audio-player");
+		if (!playerStore.playerTranscript || !audioPlayer || !playerStore.playerPodcast || audioPlayer.duration <= playerStore.playerPodcast.duration / 1e3 + 5) return;
+		const adserverConfig = await classicApi_default.fetchData({
+			api: 0,
+			path: `ad/test/podcast/${playerStore.playerPodcast.podcastId}`,
+			isNotAuth: true
+		});
+		if (adserverConfig.config.doublets.filter((doublet) => !["pre", "post"].includes(doublet.timing.insertion)).length > 0) {
+			console.warn("This episode's ad settings doesn't allow for transcription");
+			playerStore.playerUpdateChaptering();
+			playerStore.playerUpdateTranscript();
+			return;
+		}
+		if (adserverConfig.config.doublets.filter((doublet) => doublet.timing.insertion === "pre").length > 0) playerStore.playerUpdateDelayStitching(audioPlayer.duration - playerStore.playerPodcast.duration / 1e3);
+	}
+	async function getTranscription() {
+		generatingTranscriptLanguage.value = null;
+		if (!playerStore.playerPodcast) {
+			playerStore.playerUpdateTranscript();
+			return;
+		}
+		const podcastId = playerStore.playerPodcast.podcastId;
+		const { ready, available } = await getMostRelevantLanguage(await transcriptionApi.getTranslations(podcastId));
+		const arrayTranscript = parseSrt(await transcriptionApi.getTranslation(podcastId, ready));
+		const actualText = arrayTranscript?.[0]?.startTime === 0 ? arrayTranscript[0].text : "";
+		if (!arrayTranscript) return;
+		playerStore.playerUpdateTranscript({
+			actual: 0,
+			actualText,
+			value: arrayTranscript
+		});
+		if (available !== void 0 && ready !== available) {
+			generatingTranscriptLanguage.value = available;
+			const arrayTranscript = parseSrt(await transcriptionApi.getTranslation(podcastId, available, true));
+			const actualText = arrayTranscript?.[0]?.startTime === 0 ? arrayTranscript[0].text : "";
+			if (!arrayTranscript) return;
+			playerStore.playerUpdateTranscript({
+				actual: playerStore.playerTranscript?.actual,
+				actualText,
+				value: arrayTranscript
+			});
+			generatingTranscriptLanguage.value = null;
+		}
+	}
+	function parseSrt(transcript) {
+		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: srtTimeToSeconds(matches[2]),
+			endTime: srtTimeToSeconds(matches[3]),
+			text: matches[4]
+		});
+		return result;
+	}
+	function srtTimeToSeconds(time) {
+		const a = time.split(":");
+		return +a[0] * 60 * 60 + +a[1] * 60 + +parseFloat(a[2]);
+	}
+	function onTimeUpdateTranscript(currentTime) {
+		if (!playerStore.playerTranscript?.value.length) return;
+		if ((playerStore.playerTranscript.value[playerStore.playerTranscript.actual]?.startTime ?? 0) + playerStore.playerDelayStitching <= currentTime) playerStore.playerTranscript.actualText = playerStore.playerTranscript.value[playerStore.playerTranscript?.actual]?.text ?? "";
+		if ((playerStore.playerTranscript.value[playerStore.playerTranscript.actual]?.endTime ?? Infinity) + playerStore.playerDelayStitching < currentTime) {
+			playerStore.playerTranscript.actual += 1;
+			playerStore.playerTranscript.actualText = playerStore.playerTranscript?.value[playerStore.playerTranscript.actual]?.text ?? "";
+		}
+	}
+	function onSeekedTranscript(currentTime) {
+		if (playerStore.playerTranscript) {
+			let newActual = 0;
+			while (currentTime > (playerStore.playerTranscript.value[newActual]?.endTime ?? Infinity) + playerStore.playerDelayStitching) newActual += 1;
+			playerStore.playerTranscript.actual = newActual;
+		}
+	}
+	return {
+		checkDelaytWithStitching,
+		getTranscription,
+		onTimeUpdateTranscript,
+		onSeekedTranscript,
+		generatingTranscriptLanguage
+	};
+};
+//#endregion
+//#region src/stores/class/securisation/privateOrganisation.ts
+var OrganisationPrivacy = /* @__PURE__ */ function(OrganisationPrivacy) {
+	OrganisationPrivacy["SECURED"] = "SECURED";
+	OrganisationPrivacy["PRIVATE"] = "PRIVATE";
+	OrganisationPrivacy["PUBLIC"] = "PUBLIC";
+	return OrganisationPrivacy;
+}({});
+//#endregion
+//#region src/components/composable/player/usePlayerLogic.ts
+var usePlayerLogic = (forceHide) => {
+	const hlsReady = ref(false);
+	const { listenTime, onPlay, setDownloadId, onTimeUpdateProgress, playLive, endingLive, playRadio } = usePlayerLive(hlsReady);
+	const { contentEndedAdsLoader } = usePlayerStitching();
+	const { getTranscription, onTimeUpdateTranscript, onSeekedTranscript, checkDelaytWithStitching } = usePlayerTranscript();
+	const playerError = ref(false);
+	const listenError = ref(false);
+	const percentLiveProgress = ref(0);
+	const durationLivePosition = ref(0);
+	const displayAlertBar = ref(false);
+	const audioUrlToPlay = ref("");
+	const playerStore = usePlayerStore();
+	const generalStore = useGeneralStore();
+	const vastStore = useVastStore();
+	const authStore = useAuthStore();
+	watch(() => getAudioUrl(), async () => {
+		playerError.value = false;
+		let download = true;
+		if (playerStore.playerMedia || !playerStore.playerPodcast || playerStore.playerVideo || !playerStore.playerPodcast.availability.visibility || listenError.value) {
+			download = false;
+			const podcast = playerStore.playerPodcast;
+			if (podcast && !podcast.availability.visibility) {
+				let organisation = null;
+				if (podcast.organisation) organisation = podcast.organisation;
+				else if ("organisationId" in podcast) organisation = await organisationApi.get(podcast.organisationId);
+				if (organisation.privacy === OrganisationPrivacy.SECURED) download = true;
+			}
+		}
+		if (download) {
+			const response = await podcastApi.downloadRegister(playerStore.playerPodcast.podcastId, getAudioUrlParameters());
+			setDownloadId(response.downloadId.toString());
+			audioUrlToPlay.value = response.location;
+		} else audioUrlToPlay.value = getAudioUrl();
+	});
+	watch(() => playerStore.playerPodcast, async () => {
+		reInitPlayer();
+		getTranscription();
+	}, { deep: true });
+	watch(() => playerStore.playerLive, async (_, oldLive) => {
+		if (playerStore.playerVideo) return;
+		nextTick(async () => {
+			hlsReady.value = false;
+			reInitPlayer(oldLive !== void 0);
+			playLive();
+		});
+	}, { deep: true });
+	watch(() => playerStore.playerRadio, async (_, oldRadio) => {
+		nextTick(async () => {
+			hlsReady.value = false;
+			reInitPlayer(oldRadio !== void 0);
+			playRadio();
+		});
+	});
+	watch(() => playerStore.playerStatus, async () => {
+		const audioPlayer = document.querySelector("#audio-player");
+		if (!audioPlayer) return;
+		if (playerStore.playerLive && !hlsReady.value) return;
+		if ("PAUSED" === playerStore.playerStatus && playerStore.playerRadio) {
+			playerStore.playerRadio.dateSessionId = dayjs().toISOString();
+			hlsReady.value = false;
+			reInitPlayer();
+			endingLive();
+		} else if ("PAUSED" === playerStore.playerStatus) audioPlayer.pause();
+		else if ("PLAYING" === playerStore.playerStatus && playerStore.playerRadio) handlePlayRadio();
+		else if ("PLAYING" === playerStore.playerStatus) audioPlayer.play();
+	});
+	function handlePlayRadio() {
+		if (!playerStore.playerRadio) return;
+		if (playerStore.playerRadio.isInit) {
+			if (vastStore.isAdPlaying && !vastStore.resetSessionId) playerStore.playerRadio.dateSessionId = dayjs().toISOString();
+			playRadio();
+		} else playerStore.playerRadio.isInit = true;
+	}
+	function getAudioUrlParameters(addToken) {
+		if (!playerStore.playerPodcast) return {};
+		const parameters = {
+			origin: "octopus",
+			accepted: vastStore.useVastPlayerPodcast
+		};
+		if (authStore.authOrgaId) parameters.distributorId = authStore.authOrgaId;
+		if (generalStore.consentTcf) parameters.consent = generalStore.consentTcf;
+		if (addToken && "SECURED" === playerStore.playerPodcast.organisation.privacy && authStore.authParam.accessToken) parameters.access_token = authStore.authParam.accessToken;
+		return parameters;
+	}
+	function getAudioUrl() {
+		if (playerStore.playerMedia) return playerStore.playerMedia.audioUrl ?? "";
+		if (!playerStore.playerPodcast || playerStore.playerVideo) return "";
+		if (!playerStore.playerPodcast.availability.visibility || "PROCESSING" === playerStore.playerPodcast.processingStatus) return playerStore.playerPodcast.audioStorageUrl;
+		if (listenError.value) return playerStore.playerPodcast.audioStorageUrl;
+		return playerStore.playerPodcast.podcastId + ".mp3?" + fetchHelper_default.getUriSearchParams(getAudioUrlParameters(), true);
+	}
+	function reInitPlayer(force = false) {
+		setDownloadId(null);
+		listenError.value = false;
+		if (force || playerStore.playerLive || playerStore.playerRadio) endingLive();
+	}
+	function stopPlayer() {
+		playerStore.playerPlay();
+	}
+	function onError() {
+		if (playerStore.playerPodcast && "" !== audioUrlToPlay.value && !listenError.value) listenError.value = true;
+		else if (playerStore.playerPodcast && "" !== audioUrlToPlay.value || playerStore.playerMedia) playerError.value = true;
+	}
+	function streamDurationForSafari(mediaTarget) {
+		let streamDuration = mediaTarget.duration;
+		if (Infinity === streamDuration) {
+			const seekable = mediaTarget.seekable;
+			if (seekable && seekable.length > 0) try {
+				streamDuration = seekable.end(seekable.length - 1);
+			} catch (e) {
+				console.error(e);
+			}
+			else streamDuration = mediaTarget.currentTime;
+		}
+		return streamDuration;
+	}
+	function onTimeUpdatePodcast(streamDuration, currentTime) {
+		displayAlertBar.value = false;
+		percentLiveProgress.value = 0;
+		playerStore.playerUpdateElapsed(currentTime / streamDuration, streamDuration);
+		onTimeUpdateTranscript(currentTime);
+	}
+	function onTimeUpdateLive(streamDuration, currentTime) {
+		if (!playerStore.playerLive) return;
+		const scheduledDuration = playerStore.playerLive.duration / 1e3;
+		if (scheduledDuration > streamDuration) {
+			displayAlertBar.value = false;
+			percentLiveProgress.value = streamDuration / scheduledDuration * 100;
+			playerStore.playerUpdateElapsed(currentTime / scheduledDuration, scheduledDuration);
+		} else {
+			percentLiveProgress.value = 100;
+			displayAlertBar.value = true;
+			durationLivePosition.value = scheduledDuration / streamDuration * 100;
+			playerStore.playerUpdateElapsed(currentTime / streamDuration, streamDuration);
+		}
+	}
+	function onTimeUpdate(event) {
+		if (playerStore.playerRadio) return;
+		const mediaTarget = event.currentTarget;
+		if (playerStore.playerPodcast || playerStore.playerLive) onTimeUpdateProgress(mediaTarget.currentTime);
+		const streamDuration = streamDurationForSafari(mediaTarget);
+		if (!streamDuration) return;
+		if (!mediaTarget.currentTime) return;
+		if (!playerStore.playerLive) {
+			onTimeUpdatePodcast(streamDuration, mediaTarget.currentTime);
+			return;
+		}
+		onTimeUpdateLive(streamDuration, mediaTarget.currentTime);
+	}
+	function onSeeked(event) {
+		const currentTime = event.currentTarget.currentTime;
+		onSeekedTranscript(currentTime);
+	}
+	function onFinished() {
+		setDownloadId(null);
+		contentEndedAdsLoader();
+		if (playerStore.playerLive) endingLive();
+		if (state.player.stayOpenOnFinish !== true) forceHide.value = true;
+	}
+	return {
+		audioUrlToPlay,
+		listenTime,
+		playerError,
+		percentLiveProgress,
+		durationLivePosition,
+		displayAlertBar,
+		hlsReady,
+		checkDelaytWithStitching,
+		stopPlayer,
+		onError,
+		onTimeUpdate,
+		onSeeked,
+		onFinished,
+		onPlay
+	};
+};
+//#endregion
+//#region src/components/misc/player/PlayerComponent.vue?vue&type=script&setup=true&lang.ts
+var PlayerComponent_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "PlayerComponent",
+	emits: ["hide"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		__expose();
+		const PlayerVideo = defineAsyncComponent(() => import("./PlayerVideo-Dq7OHOig.mjs"));
+		const PlayerCompact = defineAsyncComponent(() => import("./PlayerCompact-B-WRNyqn.mjs"));
+		const PlayerLarge = defineAsyncComponent(() => import("./PlayerLarge-Kt-pV6N_.mjs"));
+		const emit = __emit;
+		const displayWithTimeout = ref(false);
+		const forceHide = ref(false);
+		const { audioUrlToPlay, listenTime, playerError, percentLiveProgress, durationLivePosition, displayAlertBar, hlsReady, checkDelaytWithStitching, stopPlayer, onError, onTimeUpdate, onSeeked, onFinished, onPlay } = usePlayerLogic(forceHide);
+		const playerStore = usePlayerStore();
+		const route = useRoute();
+		const display = computed(() => {
+			return "STOPPED" !== playerStore.playerStatus;
+		});
+		const isNotVideoPage = computed(() => {
+			return "video" !== route.name;
+		});
+		watch(() => playerStore.playerHeight, async () => {
+			emit("hide", 0 === playerStore.playerHeight);
+		});
+		watch(display, async () => {
+			if (display.value) displayWithTimeout.value = display.value;
+			else setTimeout(() => {
+				displayWithTimeout.value = display.value;
+			}, 3e3);
+		});
+		function onHidden() {
+			if (forceHide.value) {
+				playerStore.playerPlay();
+				forceHide.value = false;
+			}
+		}
+		function onPause() {
+			if ("PLAYING" === playerStore.playerStatus) playerStore.playerChangeStatus(true);
+		}
+		const __returned__ = {
+			PlayerVideo,
+			PlayerCompact,
+			PlayerLarge,
+			emit,
+			displayWithTimeout,
+			forceHide,
+			audioUrlToPlay,
+			listenTime,
+			playerError,
+			percentLiveProgress,
+			durationLivePosition,
+			displayAlertBar,
+			hlsReady,
+			checkDelaytWithStitching,
+			stopPlayer,
+			onError,
+			onTimeUpdate,
+			onSeeked,
+			onFinished,
+			onPlay,
+			playerStore,
+			route,
+			display,
+			isNotVideoPage,
+			onHidden,
+			onPause
+		};
+		Object.defineProperty(__returned__, "__isScriptSetup", {
+			enumerable: false,
+			value: true
+		});
+		return __returned__;
+	}
+});
+//#endregion
+//#region src/components/misc/player/PlayerComponent.vue
+var PlayerComponent_exports = /* @__PURE__ */ __exportAll({ default: () => PlayerComponent_default });
+var _hoisted_1 = ["src"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	return openBlock(), createElementBlock("section", {
+		id: "octopus-player-component",
+		class: normalizeClass(["player-container", {
+			"player-video": $setup.playerStore.playerVideo,
+			"overflow-hidden": !$setup.display
+		}]),
+		style: normalizeStyle({ height: $setup.playerStore.playerHeight }),
+		onTransitionend: $setup.onHidden
+	}, [
+		createElementVNode("audio", {
+			id: "audio-player",
+			src: !$setup.playerStore.playerLive && !$setup.playerStore.playerRadio ? $setup.audioUrlToPlay : void 0,
+			autoplay: "",
+			onTimeupdate: _cache[0] || (_cache[0] = (...args) => $setup.onTimeUpdate && $setup.onTimeUpdate(...args)),
+			onEnded: _cache[1] || (_cache[1] = (...args) => $setup.onFinished && $setup.onFinished(...args)),
+			onPlaying: _cache[2] || (_cache[2] = (...args) => $setup.onPlay && $setup.onPlay(...args)),
+			"on:durationChange": _cache[3] || (_cache[3] = (...args) => $setup.onTimeUpdate && $setup.onTimeUpdate(...args)),
+			onError: _cache[4] || (_cache[4] = (...args) => $setup.onError && $setup.onError(...args)),
+			onSeeked: _cache[5] || (_cache[5] = (...args) => $setup.onSeeked && $setup.onSeeked(...args)),
+			onPause: $setup.onPause,
+			onLoadedmetadata: _cache[6] || (_cache[6] = (...args) => $setup.checkDelaytWithStitching && $setup.checkDelaytWithStitching(...args))
+		}, null, 40, _hoisted_1),
+		_cache[9] || (_cache[9] = createElementVNode("div", { id: "ad-container" }, null, -1)),
+		$setup.displayWithTimeout ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [renderSlot(_ctx.$slots, "above"), $setup.playerStore.playerVideo && $setup.isNotVideoPage ? (openBlock(), createBlock($setup["PlayerVideo"], { key: 0 })) : !$setup.playerStore.playerVideo ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [!$setup.playerStore.playerLargeVersion ? (openBlock(), createBlock($setup["PlayerCompact"], {
+			key: 0,
+			"player-error": $setup.playerError,
+			"display-alert-bar": $setup.displayAlertBar,
+			"percent-live-progress": $setup.percentLiveProgress,
+			"duration-live-position": $setup.durationLivePosition,
+			"listen-time": $setup.listenTime,
+			"hls-ready": $setup.hlsReady,
+			onStopPlayer: $setup.stopPlayer,
+			onChangePlayerLargeVersion: _cache[7] || (_cache[7] = ($event) => $setup.playerStore.playerUpdateLargeVersion(true))
+		}, null, 8, [
+			"player-error",
+			"display-alert-bar",
+			"percent-live-progress",
+			"duration-live-position",
+			"listen-time",
+			"hls-ready",
+			"onStopPlayer"
+		])) : (openBlock(), createBlock($setup["PlayerLarge"], {
+			key: 1,
+			"player-error": $setup.playerError,
+			"display-alert-bar": $setup.displayAlertBar,
+			"percent-live-progress": $setup.percentLiveProgress,
+			"duration-live-position": $setup.durationLivePosition,
+			"listen-time": $setup.listenTime,
+			"hls-ready": $setup.hlsReady,
+			onStopPlayer: $setup.stopPlayer,
+			onChangePlayerLargeVersion: _cache[8] || (_cache[8] = ($event) => $setup.playerStore.playerUpdateLargeVersion(false))
+		}, null, 8, [
+			"player-error",
+			"display-alert-bar",
+			"percent-live-progress",
+			"duration-live-position",
+			"listen-time",
+			"hls-ready",
+			"onStopPlayer"
+		]))], 64)) : createCommentVNode("v-if", true)], 64)) : createCommentVNode("v-if", true)
+	], 38);
+}
+var PlayerComponent_default = /*#__PURE__*/ _plugin_vue_export_helper_default(PlayerComponent_vue_vue_type_script_setup_true_lang_default, [["render", _sfc_render], ["__file", "/home/julien/Workspace/octopus-sdk/src/components/misc/player/PlayerComponent.vue"]]);
+//#endregion
+export { PlayerComponent_exports as n, usePlayerTranscript as r, PlayerComponent_default as t };
+
+//# sourceMappingURL=PlayerComponent-CUHTRJic.mjs.map