@saooti/octopus-sdk 42.0.3 → 42.0.5

package/dist/classicApi-BKNiWOG4.mjs

@@ -0,0 +1,1790 @@
+import { computed, nextTick, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { useRoute } from "vue-router";
+import { defineStore } from "pinia";
+import dayjs from "dayjs";
+import axios, { AxiosError } from "axios";
+//#region src/stores/ParamSdkStore.ts
+var state = {
+	generalParameters: {
+		forceOrganisationId: void 0,
+		forceRubriqueId: void 0,
+		podcastmaker: false,
+		buttonPlus: true,
+		isLiveTab: true,
+		isCaptchaTest: true,
+		podcastItem: 13.5
+	},
+	podcastPage: {
+		ShareButtons: true,
+		mainRubrique: 0,
+		downloadButton: false,
+		descriptionOrSummary: "description"
+	},
+	emissionsPage: {
+		itemPlayer: false,
+		rubriquage: void 0,
+		mainRubrique: void 0,
+		buttonMore: false,
+		progressBar: false
+	},
+	emissionPage: {},
+	player: { isVideoPage: false },
+	searchPage: { sortCriteria: void 0 },
+	smartLink: { showOnlyFirstParagraphInDescription: false },
+	presentationItems: { tags: "none" }
+};
+function definedProps(obj) {
+	if (obj === void 0) return {};
+	else return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+var ParamSdkStore_default = {
+	initialize: function initialize(initObject) {
+		state.generalParameters = Object.assign(state.generalParameters, definedProps(initObject.generalParameters));
+		state.podcastPage = Object.assign(state.podcastPage, definedProps(initObject.podcastPage));
+		state.emissionsPage = Object.assign(state.emissionsPage, definedProps(initObject.emissionsPage));
+		state.emissionPage = Object.assign(state.emissionPage, definedProps(initObject.emissionPage));
+		state.player = Object.assign(state.player, definedProps(initObject.player));
+		state.searchPage = Object.assign(state.searchPage, definedProps(initObject.searchPage));
+		state.smartLink = Object.assign(state.smartLink, definedProps(initObject.smartLink));
+		state.presentationItems = Object.assign(state.presentationItems, definedProps(initObject.presentationItems));
+	},
+	state
+};
+//#endregion
+//#region src/stores/ApiStore.ts
+var useApiStore = defineStore("ApiStore", {
+	state: () => ({
+		apiUrl: "",
+		billingUrl: "",
+		chapteringUrl: "",
+		commentUrl: "",
+		frontendUrl: "",
+		hlsUrl: "",
+		imageUrl: "",
+		importerUrl: "",
+		keycloakUrl: "",
+		keycloakOpenAiUrl: "",
+		mediaUrl: "",
+		miniplayerUrl: "",
+		openAiUrl: "",
+		processorUrl: "",
+		radioUrl: "",
+		recoUrl: "",
+		rtmpUrl: "",
+		speechToTextUrl: "",
+		textToSpeechUrl: "",
+		studioUrl: "",
+		videoMakerUrl: "",
+		storageUrl: "",
+		statRadioUrl: ""
+	}),
+	actions: { initApis(initParam) {
+		this.apiUrl = initParam.apiUrl;
+		this.billingUrl = initParam.billingUrl;
+		this.chapteringUrl = initParam.chapteringUrl;
+		this.commentUrl = initParam.commentUrl;
+		this.frontendUrl = initParam.frontendUrl;
+		this.hlsUrl = initParam.hlsUrl;
+		this.imageUrl = initParam.imageUrl;
+		this.importerUrl = initParam.importerUrl;
+		this.keycloakUrl = initParam.keycloakUrl;
+		this.keycloakOpenAiUrl = initParam.keycloakOpenAiUrl;
+		this.mediaUrl = initParam.mediaUrl;
+		this.miniplayerUrl = initParam.miniplayerUrl;
+		this.openAiUrl = initParam.openAiUrl;
+		this.processorUrl = initParam.processorUrl;
+		this.radioUrl = initParam.radioUrl;
+		this.recoUrl = initParam.recoUrl;
+		this.rtmpUrl = initParam.rtmpUrl;
+		this.speechToTextUrl = initParam.speechToTextUrl;
+		this.textToSpeechUrl = initParam.textToSpeechUrl;
+		this.studioUrl = initParam.studioUrl;
+		this.videoMakerUrl = initParam.videoMakerUrl;
+		this.storageUrl = initParam.storageUrl;
+		this.statRadioUrl = initParam.statRadioUrl;
+	} }
+});
+//#endregion
+//#region src/api/apiConnection.ts
+var ModuleApi = /* @__PURE__ */ function(ModuleApi) {
+	ModuleApi[ModuleApi["DEFAULT"] = 0] = "DEFAULT";
+	ModuleApi[ModuleApi["MEDIA"] = 1] = "MEDIA";
+	ModuleApi[ModuleApi["COMMENT"] = 2] = "COMMENT";
+	ModuleApi[ModuleApi["KEYCLOAK"] = 3] = "KEYCLOAK";
+	ModuleApi[ModuleApi["FRONTOFFICE"] = 4] = "FRONTOFFICE";
+	ModuleApi[ModuleApi["PLAYER"] = 6] = "PLAYER";
+	ModuleApi[ModuleApi["STORAGE"] = 8] = "STORAGE";
+	ModuleApi[ModuleApi["STUDIO"] = 9] = "STUDIO";
+	ModuleApi[ModuleApi["PROCESSOR"] = 10] = "PROCESSOR";
+	ModuleApi[ModuleApi["SPEECHTOTEXT"] = 11] = "SPEECHTOTEXT";
+	ModuleApi[ModuleApi["VIDEOMAKER"] = 12] = "VIDEOMAKER";
+	ModuleApi[ModuleApi["RECOMMENDATION"] = 13] = "RECOMMENDATION";
+	ModuleApi[ModuleApi["RADIO"] = 14] = "RADIO";
+	ModuleApi[ModuleApi["IMPORTER"] = 15] = "IMPORTER";
+	ModuleApi[ModuleApi["TEXTTOSPEECH"] = 16] = "TEXTTOSPEECH";
+	ModuleApi[ModuleApi["BILLING"] = 17] = "BILLING";
+	ModuleApi[ModuleApi["OPENAI"] = 18] = "OPENAI";
+	ModuleApi[ModuleApi["CHAPTERING"] = 19] = "CHAPTERING";
+	ModuleApi[ModuleApi["KEYCLOAKOPENAI"] = 20] = "KEYCLOAKOPENAI";
+	return ModuleApi;
+}(ModuleApi || {});
+function getApiUrl(moduleName) {
+	const api = useApiStore();
+	switch (moduleName) {
+		case 1: return api.mediaUrl;
+		case 2: return api.commentUrl;
+		case 3: return api.keycloakUrl;
+		case 4: return "";
+		case 6: return api.miniplayerUrl;
+		case 8: return api.storageUrl;
+		case 9: return api.studioUrl;
+		case 10: return api.processorUrl;
+		case 11: return api.speechToTextUrl;
+		case 12: return api.videoMakerUrl;
+		case 13: return api.recoUrl;
+		case 14: return api.radioUrl;
+		case 15: return api.importerUrl;
+		case 16: return api.textToSpeechUrl;
+		case 17: return api.billingUrl;
+		case 18: return api.openAiUrl;
+		case 19: return api.chapteringUrl;
+		case 20: return api.keycloakOpenAiUrl;
+		default: return api.apiUrl;
+	}
+}
+//#endregion
+//#region src/stores/SaveFetchStore.ts
+var useSaveFetchStore = defineStore("SaveFetchStore", {
+	state: () => ({
+		orgaPublicAttributes: {},
+		orgaLiveEnabled: {},
+		orgaData: {},
+		orgaRubriques: {}
+	}),
+	actions: {
+		async getOrgaAttributes(orgaId) {
+			if (this.orgaPublicAttributes[orgaId]) return this.orgaPublicAttributes[orgaId];
+			const authStore = useAuthStore();
+			if (orgaId === authStore.authOrganisation.id && authStore.authOrganisation.attributes && Object.keys(authStore.authOrganisation.attributes).length > 1) this.orgaPublicAttributes[orgaId] = authStore.authOrganisation.attributes;
+			else this.orgaPublicAttributes[orgaId] = await classicApi_default.fetchData({
+				api: 0,
+				path: "organisation/attributes/" + orgaId
+			});
+			return this.orgaPublicAttributes[orgaId];
+		},
+		forceUpdateAttributes(orgaId, attributes) {
+			this.orgaPublicAttributes[orgaId] = attributes;
+		},
+		async getOrgaLiveEnabled(orgaId) {
+			if (!orgaId.length) return false;
+			if (this.orgaLiveEnabled[orgaId]) return this.orgaLiveEnabled[orgaId];
+			this.orgaLiveEnabled[orgaId] = await classicApi_default.fetchData({
+				api: 0,
+				path: "organisation/liveEnabled/" + orgaId
+			});
+			return this.orgaLiveEnabled[orgaId];
+		},
+		async getOrgaData(orgaId) {
+			if (this.orgaData[orgaId]) return this.orgaData[orgaId];
+			const authStore = useAuthStore();
+			if (orgaId === authStore.authOrganisation.id) this.orgaData[orgaId] = authStore.authOrganisation;
+			else this.orgaData[orgaId] = await classicApi_default.fetchData({
+				api: 0,
+				path: "organisation/" + orgaId
+			});
+			return this.orgaData[orgaId];
+		},
+		forceUpdateData(orgaId, data) {
+			this.orgaData[orgaId] = data;
+		},
+		async getOrgaRubriques(orgaId) {
+			if (this.orgaRubriques[orgaId]) return this.orgaRubriques[orgaId];
+			this.orgaRubriques[orgaId] = await classicApi_default.fetchData({
+				api: 0,
+				path: "rubriquage/find/" + orgaId
+			});
+			return this.orgaRubriques[orgaId];
+		},
+		forceUpdateRubriques(orgaId) {
+			delete this.orgaRubriques[orgaId];
+		}
+	}
+});
+//#endregion
+//#region src/stores/NotificationStore.ts
+var useNotificationStore = defineStore("notifications", () => {
+	const notificationQueue = ref([]);
+	/**
+	* Add a notification to the queue
+	* @param notification The notification to add
+	*/
+	function addNotification(notification) {
+		notificationQueue.value.push(notification);
+	}
+	/** Remove the current notification from the queue */
+	function clearNotification() {
+		const notif = currentNotification.value;
+		if (notif !== null) {
+			const idx = notificationQueue.value.indexOf(notif);
+			notificationQueue.value.splice(idx, 1);
+			if (notif.closeCallback) notif.closeCallback();
+		}
+	}
+	/** The currently active notification */
+	const currentNotification = computed(() => {
+		if (notificationQueue.value.length > 0) return notificationQueue.value[0];
+	});
+	return {
+		addNotification,
+		currentNotification,
+		clearNotification
+	};
+});
+//#endregion
+//#region src/api/apiUtils.ts
+/**
+* Utility function to easily convert a list of IDs to a map of id => element
+* @param ID The type of ID for the element
+* @param T The type of element to retrieve
+* @param ids The list of ids
+* @param getter A function that given an ID, returns a promise of the matching element
+* @param key The key for the ID
+* @return A promise containing a map of ID => element
+*/
+async function mapFromGetAll(ids, getter, key) {
+	const results = {};
+	const promises = [];
+	ids.forEach((id) => {
+		const promise = getter(id).then((elt) => results["" + elt[key]] = elt);
+		promises.push(promise);
+	});
+	await Promise.all(promises);
+	return results;
+}
+//#endregion
+//#region src/api/emissionApi.ts
+/**
+* Retrieve an emission by ID
+* @param emissionId The ID of the emission
+* @return An emission
+*/
+async function get$6(emissionId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "emission/" + emissionId
+	});
+}
+/**
+* Retrieve all emissions specified by their IDs
+* @param emissionIds A list of emission IDs. For better result, they
+should be unique.
+* @return The matching emissions
+*/
+async function getAllById$3(emissionIds) {
+	return mapFromGetAll(emissionIds, get$6, "emissionId");
+}
+/**
+* Search for emissions
+* @param query A filter on the name of the emission
+* @param options Optional options to filter the results
+*/
+async function search$3(query, options) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "emission/search",
+		parameters: {
+			query,
+			first: options?.first ?? 0,
+			size: options?.size ?? 10,
+			distributedBy: options?.distributedBy,
+			organisationId: options?.organisationId
+		},
+		specialTreatement: options?.specialTreatment ?? true
+	});
+}
+/**
+* Remove seasons data from emission
+* @param emissionId The ID of the emission for which to remove the data
+*/
+async function resetSeasons(emissionId) {
+	return classicApi_default.putData({
+		api: ModuleApi.DEFAULT,
+		path: "emission/seasons/reset/" + emissionId
+	});
+}
+var emissionApi = {
+	get: get$6,
+	getAllById: getAllById$3,
+	search: search$3,
+	resetSeasons
+};
+//#endregion
+//#region src/api/transcriptionApi.ts
+/** State of the translation */
+var TranslationState = /* @__PURE__ */ function(TranslationState) {
+	/** Translation in progress */
+	TranslationState["TRANSLATING"] = "TRANSLATING";
+	/** Translation is finished */
+	TranslationState["FINISHED"] = "FINISHED";
+	/** Translation has failed */
+	TranslationState["FAILED"] = "FAILED";
+	/** AI limit has exceeded during translation */
+	TranslationState["AI_LIMIT_EXCEEDED"] = "AI_LIMIT_EXCEEDED";
+	return TranslationState;
+}({});
+/**
+* Returns the translations defined on the podcast
+* @param podcastId ID of the podcast
+* @returns Promise containing the translation data for the podcast
+*/
+async function getTranslations(podcastId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.SPEECHTOTEXT,
+		path: `transcription/${podcastId}/languages`
+	});
+}
+/**
+* Returns the translation in a given language for the podcast
+* @param podcastId ID of the podcast
+* @param language The target language
+* @param mayCreate *(optional)* If set to true, request creation if not available
+* @returns The transcription
+*/
+async function getTranslation(podcastId, language, mayCreate) {
+	let path = `transcription/${podcastId}/languages/${language}/srt`;
+	if (mayCreate !== void 0) path = `${path}?mayCreateIfNotExists=${mayCreate}`;
+	let found = false;
+	let timeout = 1e3;
+	const timeoutStep = 100;
+	while (!found) {
+		const result = await classicApi_default.fetchData({
+			api: ModuleApi.SPEECHTOTEXT,
+			path
+		});
+		if (typeof result === "string") {
+			found = true;
+			return result;
+		}
+		await new Promise((resolve) => setTimeout(resolve, timeout));
+		timeout += timeoutStep;
+		if (timeout >= 60 * 1e3) break;
+	}
+	throw new Error("Timeout lors de la récupération de la transcription");
+}
+/**
+* Get raw transcription for the given podcast
+* @param podcastId ID of the podcast
+* @returns The raw transcript
+*/
+async function getRawTranscription(podcastId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.SPEECHTOTEXT,
+		path: `transcription/text/${podcastId}`
+	});
+}
+/**
+* Generate the transcription on the given podcast
+* @param podcastId ID of the podcast on which to do the transcription
+* @param langauge Target language. Should be the native language of the podcast
+* @param params Transcription parameters
+*/
+async function generateTranscription(podcastId, language, params) {
+	await classicApi_default.postData({
+		api: ModuleApi.SPEECHTOTEXT,
+		path: `convert/${language}/${podcastId}`,
+		dataToSend: params
+	});
+}
+/**
+* Regenerate the transcription on the given podcast
+* Currently does the same as `generateTranscription`, but should be used when
+* relevant in case of future evolutions.
+* @param podcastId ID of the podcast on which to do the transcription
+* @param langauge Target language. Should be the native language of the podcast
+* @param params Transcription parameters
+*/
+async function regenerateTranscription(podcastId, language, params) {
+	await classicApi_default.putData({
+		api: ModuleApi.SPEECHTOTEXT,
+		path: `regenerate/${language}/${podcastId}`,
+		dataToSend: params
+	});
+}
+/**
+* Change the visibility of the podcast
+* @param podcastId ID of the podcast for which to change the visibility
+* @param visibility New visibility state
+*/
+async function changeTranscriptionVisibility(podcastId, visibility) {
+	await classicApi_default.putData({
+		api: 11,
+		path: "visibility/" + podcastId,
+		parameters: { visibility }
+	});
+}
+/**
+* Update the transcription of a podcast
+* @param podcastId ID of the podcast
+* @param transcript The new transcript
+*/
+async function updateTranscription(podcastId, transcript) {
+	await classicApi_default.postData({
+		api: ModuleApi.SPEECHTOTEXT,
+		path: "update/" + podcastId,
+		dataToSend: { file: new File([transcript], "file") },
+		contentType: "formData"
+	});
+}
+/**
+* Update the translation of a podcast
+* @param podcastId ID of the podcast
+* @param transcript The new translation
+*/
+async function updateTranslation(podcastId, language, translation) {
+	await classicApi_default.putData({
+		api: ModuleApi.SPEECHTOTEXT,
+		path: `transcription/${podcastId}/languages/${language}/srt`,
+		dataToSend: translation,
+		raw: true
+	});
+}
+var transcriptionApi = {
+	changeTranscriptionVisibility,
+	getTranslations,
+	getTranslation,
+	getRawTranscription,
+	generateTranscription,
+	regenerateTranscription,
+	updateTranscription,
+	updateTranslation
+};
+//#endregion
+//#region src/api/groupsApi.ts
+var BASE_PATH = "emission/groups/";
+/**
+* Add an emission to a list of groups
+* @param emission The emission to add to the groups
+* @param groups The list of groups to add the emission to
+*/
+async function addToGroups(emission, groups) {
+	if (groups.length === 0) return;
+	let emissionId;
+	if (typeof emission === "object") emissionId = emission.emissionId;
+	else emissionId = emission;
+	let groupIds;
+	if (typeof groups[0] === "object") groupIds = groups.map((g) => g.groupId);
+	else groupIds = groups;
+	return classicApi_default.putData({
+		api: ModuleApi.DEFAULT,
+		path: "emission/groups/add/" + emissionId,
+		dataToSend: groupIds
+	});
+}
+/**
+* Create a new group
+*/
+async function create(group) {
+	return classicApi_default.postData({
+		api: ModuleApi.DEFAULT,
+		path: BASE_PATH,
+		dataToSend: group
+	});
+}
+/**
+* Delete a group
+*/
+async function remove(groupId) {
+	return classicApi_default.deleteData({
+		api: ModuleApi.DEFAULT,
+		path: BASE_PATH + groupId
+	});
+}
+/**
+* Retrieve a group by its ID
+* @param groupId The ID of the group to retrieve
+* @return The group
+*/
+async function get$5(groupId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: BASE_PATH + groupId
+	});
+}
+/**
+* Retrieve all groups specified by their IDs
+* @param groupIds A list of group IDs. For better result, they
+should be unique.
+* @return The matching groups
+*/
+async function getAllById$2(groupIds) {
+	return mapFromGetAll(groupIds, get$5, "groupId");
+}
+/**
+* Remove an emission from a list of groups
+* @param emission The emission to remove from the groups
+* @param groups The list of groups to remove the emission from
+*/
+async function removeFromGroups(emission, groups) {
+	if (groups.length === 0) return;
+	let emissionId;
+	if (typeof emission === "object") emissionId = emission.emissionId;
+	else emissionId = emission;
+	let groupIds;
+	if (typeof groups[0] === "object") groupIds = groups.map((g) => g.groupId);
+	else groupIds = groups;
+	return classicApi_default.putData({
+		api: ModuleApi.DEFAULT,
+		path: "emission/groups/remove/" + emissionId,
+		dataToSend: groupIds
+	});
+}
+/**
+* Update a group
+*/
+async function update(group) {
+	return classicApi_default.putData({
+		api: ModuleApi.DEFAULT,
+		path: BASE_PATH,
+		dataToSend: group
+	});
+}
+/**
+* Count number of groups
+*/
+async function count$1(parameters) {
+	return (await search$2({
+		...parameters,
+		size: 0
+	})).count;
+}
+/**
+* Search groups
+*/
+async function search$2(parameters) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "emission/groups/search",
+		parameters
+	});
+}
+/**
+* Search for all groups, without pagination
+*/
+async function searchNoPagination(parameters) {
+	const result = [];
+	let index = 0;
+	while (true) {
+		const response = await search$2({
+			...parameters,
+			first: index,
+			size: 1
+		});
+		result.push(...response.result);
+		index += response.result.length;
+		if (index >= response.count || response.result.length === 0) break;
+	}
+	return result;
+}
+var groupsApi = {
+	addToGroups,
+	count: count$1,
+	create,
+	remove,
+	get: get$5,
+	getAllById: getAllById$2,
+	removeFromGroups,
+	update,
+	search: search$2,
+	searchNoPagination
+};
+//#endregion
+//#region src/api/organisationApi.ts
+/**
+* Retrieve an organisation by ID
+* @param organisationId The ID of the organisation
+* @return An organisation
+*/
+async function get$4(organisationId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "organisation/" + organisationId
+	});
+}
+/**
+* Retrieve all organisations specified by their IDs
+* @param organisationIds A list of organisation IDs. For better result, they
+should be unique.
+* @return The matching organisations
+*/
+async function getAllById$1(organisationIds) {
+	return mapFromGetAll(organisationIds, get$4, "id");
+}
+/**
+* Retrieve the attributes of a given organisation
+* @param organisationId The ID of the organisation
+* @returns The attributes of the organisation
+*/
+async function getAttributes(organisationId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "organisation/attributes/" + organisationId
+	});
+}
+var organisationApi = {
+	get: get$4,
+	getAllById: getAllById$1,
+	getAttributes
+};
+//#endregion
+//#region src/helper/arrayHelper.ts
+function unique(value, index, array) {
+	return array.indexOf(value) === index;
+}
+//#endregion
+//#region src/api/playlistApi.ts
+/**
+* Retrieve playlist data
+* @param playlistId The ID of the playlist
+* @return The playlist
+*/
+async function get$3(playlistId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "playlist/" + playlistId
+	});
+}
+/**
+* Retrieve the podcasts defined in the playlist
+* @param playlistId The ID of the playlist
+* @return A list of simplified podcasts
+*/
+async function getContent(playlistId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "v2/playlist/" + playlistId + "/content"
+	});
+}
+/**
+* Retrieve the podcasts defined in the playlist, with all their data
+* This query is longer, because it also needs to retrieve organisations &
+* emissions.
+* @param playlistId The ID of the playlist
+* @return A list of podcasts
+*/
+async function getContentFull(playlistId) {
+	const simplified = await this.getContent(playlistId);
+	const full = [];
+	const organisationIds = simplified.map((p) => p.organisationId).filter(unique);
+	const emissionIds = simplified.map((p) => p.emissionId).filter(unique);
+	const organisations = await organisationApi.getAllById(organisationIds);
+	const emissions = await emissionApi.getAllById(emissionIds);
+	simplified.forEach((s) => {
+		const organisation = organisations[s.organisationId];
+		const emission = emissions[s.emissionId];
+		full.push({
+			...s,
+			organisation,
+			emission
+		});
+	});
+	return full;
+}
+/**
+* Search for playlists based on criterias
+*/
+async function search$1(options) {
+	return await classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "playlist/search",
+		specialTreatement: true,
+		parameters: options
+	});
+}
+/**
+* API to manage playlists
+*/
+var playlistApi = {
+	get: get$3,
+	getContent,
+	getContentFull,
+	search: search$1
+};
+//#endregion
+//#region src/api/participantApi.ts
+/**
+* Retrieve a participant by ID
+* @param participantId The ID of the participant
+* @return A participant
+*/
+async function get$2(participantId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "participant/" + participantId
+	});
+}
+/**
+* Retrieve all participants specified by their IDs
+* @param participantIds A list of participant IDs. For better result, they
+should be unique.
+* @return The matching participants
+*/
+async function getAllById(participantIds) {
+	return mapFromGetAll(participantIds, get$2, "participantId");
+}
+var participantApi = {
+	get: get$2,
+	getAllById
+};
+//#endregion
+//#region \0rolldown_dynamic_import_helper.js
+var _rolldown_dynamic_import_helper_default = (glob, path, segments) => {
+	const query = path.lastIndexOf("?");
+	const v = glob[query === -1 || query < path.lastIndexOf("/") ? path : path.slice(0, query)];
+	if (v) return typeof v === "function" ? v() : Promise.resolve(v);
+	return new Promise((_, reject) => {
+		(typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(reject.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + path + (path.split("/").length !== segments ? ". Note that variables only represent file names one level deep." : ""))));
+	});
+};
+//#endregion
+//#region src/i18n.ts
+var i18nInstance = null;
+/**
+* Register the app's i18n instance so it can be reached from code that
+* doesn't run inside a component setup, where useI18n() is unavailable.
+*/
+function registerI18n(instance) {
+	i18nInstance = instance;
+}
+function getI18n() {
+	if (!i18nInstance) throw new Error("i18n instance accessed before registerI18n() was called");
+	return i18nInstance;
+}
+function setI18nLanguage(i18n, locale) {
+	i18n.locale.value = locale;
+	const html = document.querySelector("html");
+	if (html) html.setAttribute("lang", locale);
+}
+async function loadLocaleMessages(i18n, locale, isAuthenticated, isEducation) {
+	if (!i18n.messages[locale] || 0 === Object.keys(i18n.messages[locale]).length) {
+		let messages = await _rolldown_dynamic_import_helper_default(/* #__PURE__ */ Object.assign({
+			"./locale/educationen.ts": () => import("./educationen-B0PNsHqt.mjs"),
+			"./locale/educationfr.ts": () => import("./educationfr-DnXyASTX.mjs"),
+			"./locale/messages.ts": () => import("./messages-Czjqh0tU.mjs")
+		}), `./locale/${locale}.ts`, 3);
+		messages = messages.default;
+		if (isEducation && ("fr" === locale || "en" === locale)) {
+			const messagesEdu = await _rolldown_dynamic_import_helper_default(/* #__PURE__ */ Object.assign({
+				"./locale/educationen.ts": () => import("./educationen-B0PNsHqt.mjs"),
+				"./locale/educationfr.ts": () => import("./educationfr-DnXyASTX.mjs")
+			}), `./locale/education${locale}.ts`, 3);
+			messages = {
+				...messages,
+				...messagesEdu.default
+			};
+		}
+		i18n.setLocaleMessage(locale, messages);
+	}
+	setI18nLanguage(i18n, locale);
+	return nextTick();
+}
+//#endregion
+//#region src/api/podcastApi.ts
+var PodcastSort = /* @__PURE__ */ function(PodcastSort) {
+	PodcastSort["DATE"] = "DATE";
+	PodcastSort["DATE_ASC"] = "DATE_ASC";
+	PodcastSort["NAME"] = "NAME";
+	PodcastSort["LAST_PODCAST_DESC"] = "LAST_PODCAST_DESC";
+	PodcastSort["POPULARITY"] = "POPULARITY";
+	PodcastSort["SCORE"] = "SCORE";
+	PodcastSort["UPDATE_ASC"] = "UPDATE_ASC";
+	PodcastSort["UPDATE_DESC"] = "UPDATE_DESC";
+	/** Smart sort using seasons settings */
+	PodcastSort["SEASONAL"] = "SEASONAL";
+	return PodcastSort;
+}({});
+async function downloadRegister(podcastId, parameters) {
+	try {
+		return await classicApi_default.fetchData({
+			api: ModuleApi.DEFAULT,
+			path: "podcast/download/register/" + podcastId + ".mp3",
+			parameters,
+			headers: { "X-Extra-UA": "Saooti Player" }
+		});
+	} catch (e) {
+		if (e instanceof AxiosError && e.status === 403) {
+			const error = e.response.data;
+			if (error.includes("is blacklisted") || error.includes("is not whitelisted")) {
+				const { addNotification } = useNotificationStore();
+				const t = getI18n().global.t;
+				addNotification({
+					type: "error",
+					title: t("Generic - Content unavailable - Country blocked - Title"),
+					message: t("Generic - Content unavailable - Country blocked - Message")
+				});
+			}
+		}
+		return Promise.reject(e);
+	}
+}
+/**
+* Get a podcast by its ID
+*/
+function get$1(podcastId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "podcast/" + podcastId
+	});
+}
+/**
+* Convert easy to use PodcastSearchOptions to the actual FetchParams used by
+* the endpoint.
+*/
+function processSearchParameters(search) {
+	const parameters = {};
+	Object.keys(search).forEach((key) => {
+		const value = search[key];
+		if (value === void 0 || value === null) return;
+		if (key === "beneficiaries") parameters.beneficiary = value;
+		else if (key === "processingStatus") parameters.includeStatus = value;
+		else if (key === "tags") parameters.includeTag = value;
+		else if (key === "pubDateBefore") parameters.before = value;
+		else if (key === "pubDateAfter") parameters.after = value;
+		else if (key === "pageSize") parameters.size = value;
+		else parameters[key] = value;
+	});
+	return parameters;
+}
+/**
+* Search for podcasts. Retrieved podcasts are 'incomplete', some of their
+* properties are only IDs.
+* Use `searchFull` to get full podcasts, but more queries will be made
+* @param options The search criterias
+* @param adaptParameters If true, some adjustments will be made to the parameters
+* @return A list of simplified podcasts
+*/
+async function search(options, adaptParameters) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "v2/podcast/search",
+		parameters: processSearchParameters(options),
+		specialTreatement: adaptParameters
+	});
+}
+/**
+* Count podcasts matching the filters
+* @param options The search criterias
+* @param adaptParameters If true, some adjustments will be made to the parameters
+* @return A list of simplified podcasts
+*/
+async function count(options, adaptParameters) {
+	return (await search({
+		...options,
+		size: 0
+	}, adaptParameters)).count;
+}
+/**
+* Retrieve the podcasts matching the search criterias, with all their data.
+* This query is longer, because it also needs to retrieve organisations &
+* emissions.
+* @param options The search criterias
+* @param adaptParameters If true, some adjustments will be made to the parameters
+* @return A list of podcasts
+*/
+async function searchFull(options, adaptParameters) {
+	const podcasts = await search(options, adaptParameters);
+	const full = {
+		count: podcasts.count,
+		sort: podcasts.sort,
+		result: []
+	};
+	const organisationIds = podcasts.result.map((p) => p.organisationId).filter(unique);
+	const emissionIds = podcasts.result.map((p) => p.emissionId).filter(unique);
+	const participantIds = podcasts.result.map((p) => p.animatorId ?? []).flat().filter(unique);
+	const organisationsPromise = organisationApi.getAllById(organisationIds);
+	const emissionsPromise = emissionApi.getAllById(emissionIds);
+	const participantsPromise = participantApi.getAllById(participantIds);
+	const [organisations, emissions, participants] = await Promise.all([
+		organisationsPromise,
+		emissionsPromise,
+		participantsPromise
+	]);
+	podcasts.result.forEach((s) => {
+		const organisation = organisations[s.organisationId];
+		const emission = emissions[s.emissionId];
+		const animators = s.animatorId?.map((id) => participants[id]);
+		full.result.push({
+			...s,
+			organisation,
+			emission,
+			animators
+		});
+	});
+	return full;
+}
+var podcastApi = {
+	count,
+	downloadRegister,
+	get: get$1,
+	search,
+	searchFull
+};
+//#endregion
+//#region src/api/radioApi.ts
+/**
+* Retrieve a radio canal by its id
+* @param radioId Id of the radio to retrieve
+* @returns The canal data
+*/
+async function get(radioId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.RADIO,
+		path: `canal/${radioId}`
+	});
+}
+/**
+* Retrieve all radio canal by organisation
+* @param organisationId Id of the organisation
+* @returns The list of canal data
+*/
+async function getAll$1(organisationId) {
+	return await classicApi_default.fetchData({
+		api: ModuleApi.RADIO,
+		path: "canal/orga/" + organisationId + "/"
+	});
+}
+/**
+* Set the default ambiance for the given canal
+* @param canalId ID of the canal to change
+* @param ambiance New ambiance settings
+* @returns The modified ambiance
+*/
+async function setDefaultAmbiance(canalId, ambiance) {
+	return await classicApi_default.putData({
+		api: ModuleApi.RADIO,
+		path: `ambiance/canal/${canalId}/default`,
+		dataToSend: ambiance
+	});
+}
+var radioApi = {
+	get,
+	getAll: getAll$1,
+	setDefaultAmbiance
+};
+//#endregion
+//#region src/api/aggregatorsApi.ts
+/**
+* Return the list of predefined aggregators
+*/
+async function getPredefined() {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "rss/aggregator/distributions"
+	});
+}
+/**
+* Return the list of all user-defined aggregators
+* @param organisationId If defined, the aggregators will be filtered for this
+*                       organisation
+*/
+async function getAll(organisationId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "rss/aggregator/list",
+		parameters: organisationId ? { organisationId } : void 0
+	});
+}
+/**
+* Return the list of all user-defined aggregators, without filter data.
+* This doesn't require to be authenticated.
+* @param organisationId If defined, the aggregators will be filtered for this
+*                       organisation
+*/
+async function getAllNoAuth(organisationId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "rss/aggregator/noauth/list",
+		parameters: organisationId ? { organisationId } : void 0
+	});
+}
+var aggregatorsApi = {
+	getPredefined,
+	getAll,
+	getAllNoAuth
+};
+//#endregion
+//#region src/api/mediathequeApi.ts
+/**
+* Retrieve all cartouchier from the given organisation
+* @param organisationId The ID of the organisation
+* @param options Filtering options
+* @returns List of cartouchier belonging to the organisation
+*/
+async function getAllCartouchiers(organisationId, options) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.MEDIA,
+		path: `cartouchier/list/${organisationId}`,
+		parameters: options
+	});
+}
+/**
+* Retrieve all mix from the given organisation
+* @param organisationId The ID of the organisation
+* @returns List of mix belonging to the organisation
+*/
+async function getAllMix(organisationId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.MEDIA,
+		path: `mix/${organisationId}`
+	});
+}
+/**
+* Delete mix with the given id
+* @param mixId The ID of the mix to delete
+*/
+async function deleteMix(mixId) {
+	await classicApi_default.deleteData({
+		api: ModuleApi.MEDIA,
+		path: `mix/${mixId}`
+	});
+}
+/**
+* Retrieve all playlist from the given organisation
+* @param organisationId The ID of the organisation
+* @param options Filtering options
+* @returns List of playlist belonging to the organisation
+*/
+async function getAllPlaylists(organisationId, options) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.MEDIA,
+		path: `playlist/${organisationId}`,
+		parameters: options
+	});
+}
+/**
+* Delete playlist with the given id
+* @param playlistId The ID of the playlist to delete
+*/
+async function deletePlaylist(playlistId) {
+	await classicApi_default.deleteData({
+		api: ModuleApi.MEDIA,
+		path: `playlist/${playlistId}`
+	});
+}
+var mediathequeApi = {
+	getAllCartouchiers,
+	getAllMix,
+	deleteMix,
+	getAllPlaylists,
+	deletePlaylist
+};
+//#endregion
+//#region src/stores/CacheStore.ts
+var useCacheStore = defineStore("cache", () => {
+	const cachedData = {};
+	async function getData(key, callback) {
+		let cache = cachedData[key];
+		if (isDataEmptyOrExpired(cache)) {
+			const data = callback();
+			cache = {
+				data,
+				expiration: dayjs().add(30, "minutes")
+			};
+			cachedData[key] = cache;
+			data.catch(() => invalidate(key));
+		}
+		return cache.data;
+	}
+	function invalidate(key) {
+		delete cachedData[key];
+	}
+	function isDataEmptyOrExpired(data) {
+		if (!data) return true;
+		else return dayjs().isAfter(data.expiration);
+	}
+	return {
+		getData,
+		invalidate
+	};
+});
+//#endregion
+//#region src/api/rubriquesApi.ts
+/**
+* Find rubriquages according to criterias
+* @param organisationIds List of organisation IDs for which to retrieve the
+*                        rubriquage
+* @param searchOptions Additional search options
+*/
+async function searchRubriquages(organisationIds, searchOptions, options) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "rubriquage/find",
+		parameters: {
+			organisationId: organisationIds,
+			...searchOptions
+		},
+		specialTreatement: options?.adaptParameters
+	});
+}
+/**
+* Create a new rubriquage
+* @param data The new rubriquage data
+* @returns The created rubriquage
+*/
+async function createRubriquage(data) {
+	return classicApi_default.postData({
+		api: ModuleApi.DEFAULT,
+		path: "rubriquage/",
+		dataToSend: data
+	});
+}
+/**
+* Fetch rubriquage data by ID
+* @param rubriquageId ID of the rubriquage to fetch
+* @returns The rubriquage
+*/
+async function getRubriquage(rubriquageId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: `rubriquage/${rubriquageId}`
+	});
+}
+/**
+* Update the values of the rubriquage
+* @param data The new rubriquage data
+* @returns The updated rubriquage
+*/
+async function updateRubriquage(data) {
+	return classicApi_default.putData({
+		api: ModuleApi.DEFAULT,
+		path: "rubriquage/",
+		dataToSend: data
+	});
+}
+/**
+* Delete a rubriquage
+* @param data Either the rubriquage to delete, or its ID
+* @returns An empty promise
+*/
+async function deleteRubriquage(data) {
+	const rubriquageId = typeof data === "object" ? data.rubriquageId : data;
+	await classicApi_default.deleteData({
+		api: ModuleApi.DEFAULT,
+		path: "rubriquage/" + rubriquageId
+	});
+}
+async function searchRubriques(searchOptions) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: "rubrique/search",
+		parameters: searchOptions
+	});
+}
+/**
+* Fetch rubrique data by ID
+* @see getCachedRubrique
+* @param rubriqueId ID of the rubrique to fetch
+* @returns The rubrique
+*/
+async function getRubrique(rubriqueId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: `rubrique/${rubriqueId}`
+	});
+}
+/**
+* Fetch rubrique data by ID
+* If the rubrique is available in the cache, return it from the cache
+* @param rubriqueId ID of the rubrique to fetch
+* @returns The rubrique
+*/
+async function getCachedRubrique(rubriqueId) {
+	return useCacheStore().getData(`rubrique-${rubriqueId}`, () => getRubrique(rubriqueId));
+}
+/**
+* List the rubrique IDS associated to the given user
+* @param userId The ID of the user for which to retrieve this data
+* @returns The list of IDs of rubriques
+*/
+async function listUserScope(userId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: `rubrique/user/list/rubriques/${userId}`
+	});
+}
+/**
+* List the user IDS associated to the given rubrique
+* @param rubriqueId The ID of the rubrique for which to retrieve this data
+* @returns The list of IDs of users
+*/
+async function listUsersScopedByRubrique(rubriqueId) {
+	return classicApi_default.fetchData({
+		api: ModuleApi.DEFAULT,
+		path: `rubrique/user/list/users/${rubriqueId}`
+	});
+}
+/**
+* Update the associated rubriques to the user
+* @param userId The ID of the user for which to change the rights scope
+* @param previousScope Previous rubrique IDs
+* @param rubriqueIds New rubrique IDs to set
+* @returns A promise
+*/
+async function setUserScope(userId, previousScope, rubriqueIds) {
+	const associatedIds = [];
+	const dissociatedIds = [];
+	const promises = [];
+	const allIds = /* @__PURE__ */ new Set();
+	previousScope.forEach(allIds.add, allIds);
+	rubriqueIds.forEach(allIds.add, allIds);
+	allIds.forEach((id) => {
+		const inOld = previousScope.includes(id);
+		const inNew = rubriqueIds.includes(id);
+		if (inOld && !inNew) dissociatedIds.push(id);
+		else if (!inOld && inNew) associatedIds.push(id);
+	});
+	if (associatedIds.length > 0) promises.push(classicApi_default.postData({
+		api: ModuleApi.DEFAULT,
+		path: "rubrique/user/associate",
+		dataToSend: {
+			rubriqueIds: associatedIds,
+			userIds: [userId]
+		}
+	}));
+	if (dissociatedIds.length > 0) promises.push(classicApi_default.postData({
+		api: ModuleApi.DEFAULT,
+		path: "rubrique/user/dissociate",
+		dataToSend: {
+			rubriqueIds: dissociatedIds,
+			userIds: [userId]
+		}
+	}));
+	return Promise.all(promises).then();
+}
+var rubriquesApi = {
+	createRubriquage,
+	getRubriquage,
+	getRubrique,
+	getCachedRubrique,
+	searchRubriquages,
+	searchRubriques,
+	updateRubriquage,
+	deleteRubriquage,
+	listUserScope,
+	listUsersScopedByRubrique,
+	setUserScope
+};
+//#endregion
+//#region src/stores/AuthStore.ts
+var useAuthStore = defineStore("AuthStore", {
+	state: () => ({
+		authReload: 0,
+		authName: "",
+		authRole: [],
+		authOrgaId: void 0,
+		authParam: {
+			accessToken: void 0,
+			refreshToken: void 0,
+			expiration: void 0
+		},
+		authProfile: void 0,
+		authOrganisation: {
+			id: "",
+			name: "",
+			imageUrl: "",
+			description: void 0,
+			monetisable: void 0,
+			location: void 0,
+			comments: void 0,
+			attributes: { RSS_CONTACT: void 0 }
+		},
+		authVideoConfig: { active: false }
+	}),
+	getters: {
+		/** Indicates that the user is authenticated */
+		isAuthenticated() {
+			return this.authParam.accessToken !== void 0;
+		},
+		isRoleAdmin() {
+			return this.authRole.includes("ADMIN");
+		},
+		isRoleAnimator() {
+			return this.authRole.includes("ANIMATION");
+		},
+		isRoleUsers() {
+			return this.authRole.includes("USERS");
+		},
+		isRoleOrganisation() {
+			return this.authRole.includes("ORGANISATION");
+		},
+		isRoleProduction() {
+			return this.authRole.includes("PRODUCTION");
+		},
+		isRolePublication() {
+			return this.authRole.includes("PODCAST_VALIDATION");
+		},
+		isRoleContribution() {
+			return this.authRole.includes("PODCAST_CRUD");
+		},
+		isRolePlaylists() {
+			return this.authRole.includes("PLAYLISTS");
+		},
+		isRoleComments() {
+			return this.authRole.includes("COMMENTS_MODERATION");
+		},
+		isRoleEditor() {
+			return this.authRole.includes("EDITION");
+		},
+		isRoleAnalytics() {
+			return this.authRole.includes("ANALYTICS");
+		},
+		isRoleAdvertising() {
+			return this.authRole.includes("ADVERTISING");
+		},
+		isRoleLive() {
+			return this.authRole.includes("LIVE");
+		},
+		isRoleRadio() {
+			return this.authRole.includes("RADIO");
+		},
+		isRoleBillingAdmin() {
+			return this.authRole.includes("BILLING_ADMIN");
+		},
+		isRoleBillingViewer() {
+			return this.authRole.includes("BILLING_VIEWER");
+		},
+		isOneOfRoleProduction() {
+			return this.authRole.includes("PRODUCTION") || this.authRole.includes("RESTRICTED_PRODUCTION");
+		},
+		isRoleRestrictedProduction() {
+			return this.authRole.includes("RESTRICTED_PRODUCTION");
+		},
+		isGarRole() {
+			return this.authProfile?.attributes?.["GAR"];
+		},
+		isVideoOrga() {
+			return this.authVideoConfig.active;
+		},
+		userScope() {
+			if (!this.authProfile) return [-1];
+			if (this.authRole.includes("ADMIN") || this.authRole.includes("ORGANISATION")) return [];
+			else return this.authProfile.scope;
+		}
+	},
+	actions: {
+		authUpdate(authentication) {
+			this.authName = authentication.name ?? this.authName;
+			this.authOrgaId = authentication.organisationId ?? this.authOrgaId;
+			this.authOrgaName = authentication.organisationName ?? this.authOrgaName;
+			this.authRole = authentication.role ?? this.authRole;
+		},
+		authUpdateParam(oAuthParam) {
+			this.authParam = oAuthParam;
+		},
+		authUpdateProfile(profile) {
+			this.authProfile = profile;
+			this.authName = profile.firstname + " " + profile.lastname;
+		},
+		authUpdateOrganisation(organisation) {
+			this.authOrganisation = organisation;
+			const saveFetchStore = useSaveFetchStore();
+			saveFetchStore.forceUpdateAttributes(organisation.id, organisation.attributes ?? {});
+			saveFetchStore.forceUpdateData(organisation.id, organisation);
+		},
+		async fetchProfileAsynchrone() {
+			try {
+				const organisationData = await classicApi_default.fetchData({
+					api: 0,
+					path: "organisation/attributes/" + encodeURI(this.authOrganisation.id)
+				});
+				this.authVideoConfig = await classicApi_default.fetchData({
+					api: 0,
+					path: "video/config/" + encodeURI(this.authOrganisation.id)
+				});
+				const organisation = {
+					...this.authOrganisation,
+					attributes: organisationData
+				};
+				if (organisation.attributes?.SEPA) {
+					const orgaSepa = Object.getOwnPropertyDescriptor(organisation.attributes, "SEPA");
+					if (orgaSepa) Object.defineProperty(organisation.attributes, "iban", orgaSepa);
+					delete organisation.attributes["SEPA"];
+				}
+				this.authUpdateOrganisation(organisation);
+			} catch {
+				if (this.authReload > 5) return;
+				this.authReload += 1;
+				await new Promise((resolve) => setTimeout(resolve, 500 * this.authReload));
+				await this.fetchProfileAsynchrone();
+			}
+		},
+		async fetchProfile() {
+			try {
+				const profileDataPromise = classicApi_default.fetchData({
+					api: 20,
+					path: "userinfo"
+				});
+				const availablesOrganisationsPromise = classicApi_default.fetchData({
+					api: 0,
+					path: "user/me/organisations"
+				});
+				const [profileData, availablesOrganisations] = await Promise.all([profileDataPromise, availablesOrganisationsPromise]);
+				const scope = [];
+				try {
+					const s = await rubriquesApi.listUserScope(profileData.sub);
+					scope.push(...s);
+				} catch (e) {
+					console.error(e);
+					scope.push(-1);
+				}
+				const array = (availablesOrganisations ?? []).toSorted(function(a, b) {
+					if (a.name.toLowerCase() < b.name.toLowerCase()) return -1;
+					if (a.name.toLowerCase() > b.name.toLowerCase()) return 1;
+					return 0;
+				});
+				const profile = {
+					firstname: profileData.given_name,
+					lastname: profileData.family_name,
+					email: profileData.email,
+					userId: profileData.sub,
+					attributes: {
+						CGUValid: profileData.CGUValid,
+						GAR: profileData.GAR,
+						description: profileData.description,
+						imageUrl: profileData.imageUrl,
+						active_organisation: profileData.active_organisation
+					},
+					organisations: array,
+					scope
+				};
+				this.authUpdateProfile(profile);
+				if (!profileData.active_organisation) return;
+				const activeOrganisation = await classicApi_default.fetchData({
+					api: 0,
+					path: "organisation/" + profileData.active_organisation
+				});
+				this.authUpdate({
+					organisationId: activeOrganisation.id,
+					organisationName: activeOrganisation.name
+				});
+				this.authUpdateOrganisation(activeOrganisation);
+				this.fetchProfileAsynchrone();
+			} catch (error) {
+				console.error(error);
+				if (this.authReload > 5) {
+					const { addNotification } = useNotificationStore();
+					const { t } = useI18n();
+					addNotification({
+						type: "error",
+						title: t("Auth error - Couldn't retrieve user info - Title"),
+						message: t("Auth error - Couldn't retrieve user info - Message")
+					});
+					return;
+				}
+				this.authReload += 1;
+				await new Promise((resolve) => setTimeout(resolve, 500 * this.authReload));
+				await this.fetchProfile();
+			}
+		}
+	}
+});
+//#endregion
+//#region src/stores/FilterStore.ts
+/**
+* Store managing data regarding the filters to apply to know which
+* podcasts to show.
+*/
+var useFilterStore = defineStore("FilterStore", () => {
+	const _filterOrgaId = ref(null);
+	const filterImgUrl = ref();
+	const filterName = ref();
+	const filterRubriquage = ref([]);
+	const filterRubrique = ref([]);
+	const filterRubriqueDisplay = ref([]);
+	const filterLive = ref(false);
+	const filterIab = ref();
+	const route = useRoute();
+	const authStore = useAuthStore();
+	/**
+	* ID of the current organisation.
+	*/
+	const filterOrgaId = computed(() => {
+		if (route?.query.viewall === "true") return;
+		else if (route?.query.productor) return route.query.productor;
+		else if (_filterOrgaId.value === null) return authStore.authOrgaId;
+		else return _filterOrgaId.value ?? void 0;
+	});
+	/** Update stored organisation ID only if not already set */
+	function updateOrgaIfNecessary(orgaId) {
+		if (orgaId && filterOrgaId.value === void 0 && state.generalParameters.podcastmaker !== true) _filterOrgaId.value = orgaId;
+	}
+	/**
+	* The ID of the current organisation, regardless of other options.
+	* Use this if you want to know the organisation of the user even in
+	* unfocused mode (ie viewall = true)
+	*/
+	const realOrgaId = computed(() => {
+		return _filterOrgaId.value ?? void 0;
+	});
+	function filterUpdateOrga(filter) {
+		if (filter.imgUrl || !filter.orgaId) filterImgUrl.value = filter.imgUrl;
+		if (filter.name || !filter.orgaId) filterName.value = filter.name;
+		if (filter.rubriquageArray) filterRubriquage.value = filter.rubriquageArray;
+		filterLive.value = filter.isLive ?? false;
+		filterIab.value = void 0;
+		_filterOrgaId.value = filter.orgaId ?? null;
+	}
+	function filterUpdateIab(iab) {
+		filterIab.value = iab;
+	}
+	function filterUpdateRubrique(rubriqueFilter) {
+		filterRubrique.value = rubriqueFilter;
+	}
+	function filterUpdateRubriqueDisplay(rubriques) {
+		filterRubriqueDisplay.value = rubriques.filter((rubrique) => rubrique);
+	}
+	return {
+		filterOrgaId,
+		realOrgaId,
+		updateOrgaIfNecessary,
+		filterUpdateOrga,
+		filterUpdateIab,
+		filterUpdateRubrique,
+		filterUpdateRubriqueDisplay,
+		filterImgUrl,
+		filterName,
+		filterRubriquage,
+		filterRubrique,
+		filterRubriqueDisplay,
+		filterLive,
+		filterIab
+	};
+});
+//#endregion
+//#region src/helper/fetchHelper.ts
+var fetchHelper_default = {
+	async createAuthenticatedFetchHeader(forceRefresh = false) {
+		const authStore = useAuthStore();
+		if ("" === authStore.authName) return {};
+		const currentTime = dayjs();
+		const expirationDate = dayjs(authStore.authParam.expiration);
+		if (currentTime.isAfter(expirationDate) || forceRefresh) return { Authorization: "Bearer " + await this.updateAccessToken() };
+		else return { Authorization: "Bearer " + authStore.authParam.accessToken };
+	},
+	async updateAccessToken() {
+		const authStore = useAuthStore();
+		const data = await this.refreshToken();
+		if (!data) return "";
+		authStore.authParam.expiration = data.expiration;
+		authStore.authParam.accessToken = data.accessToken;
+		authStore.authParam.refreshToken = data.refreshToken;
+		return data.accessToken;
+	},
+	async refreshTokenLoop() {
+		const authStore = useAuthStore();
+		const currentTime = dayjs();
+		const expirationDate = dayjs(authStore.authParam.expiration);
+		if (currentTime.isAfter(expirationDate)) await this.updateAccessToken();
+		const millisecondDifference = dayjs(authStore.authParam.expiration).diff(dayjs(), "millisecond");
+		setTimeout(() => {
+			this.refreshTokenLoop();
+		}, Math.max(millisecondDifference - 5e3, 0));
+	},
+	async refreshToken() {
+		const authStore = useAuthStore();
+		const response = await classicApi_default.postData({
+			api: 20,
+			path: "token",
+			contentType: "urlencoded",
+			dataToSend: {
+				client_id: authStore.authParam.clientId,
+				grant_type: "refresh_token",
+				refresh_token: authStore.authParam.refreshToken
+			},
+			isNotAuth: true,
+			catchFunction: () => {
+				const filterStore = useFilterStore();
+				filterStore.filterOrgaId = void 0;
+				filterStore.filterImgUrl = void 0;
+				window.location.href = "/logout";
+			}
+		});
+		if (response) return {
+			accessToken: response.access_token,
+			refreshToken: response.refresh_token,
+			expiration: dayjs().add(response.expires_in, "seconds").toDate()
+		};
+	},
+	getMediaContent(media) {
+		if (!media) return "";
+		const apiStore = useApiStore();
+		const authStore = useAuthStore();
+		let timing = "#t=" + (media.cueIn ?? 0);
+		if (media.cueOut) timing += "," + media.cueOut;
+		return apiStore.mediaUrl + "media/content/" + media?.mediaId + "?access_token=" + authStore.authParam.accessToken + timing;
+	},
+	getUriSearchParams(parameters) {
+		const _return = new URLSearchParams();
+		for (const [key, value] of Object.entries(parameters)) if (void 0 !== value && null !== value && "" !== value && (!Array.isArray(value) || Array.isArray(value) && value.length)) _return.append(key, value.toString());
+		return _return;
+	},
+	transformObjectValueToString(object) {
+		const objectString = {};
+		for (const key in object) {
+			const value = object[key];
+			if (null !== value && "object" === typeof value) objectString[key] = JSON.stringify(value);
+			else if (value) objectString[key] = value.toString();
+		}
+		return objectString;
+	}
+};
+//#endregion
+//#region src/api/classicApi.ts
+var classicApi_default = {
+	async fetchData(params) {
+		let paramsString = "";
+		if (params.parameters) {
+			if (params.specialTreatement) params.parameters = this.adjustParameters(params);
+			const parameters = fetchHelper_default.getUriSearchParams(params.parameters).toString();
+			paramsString = parameters.length ? "?" + parameters : "";
+		}
+		let authHeaders = {};
+		if (!params.isNotAuth) authHeaders = await fetchHelper_default.createAuthenticatedFetchHeader(params.forceRefresh);
+		const url = getApiUrl(params.api) + params.path + paramsString;
+		return (await axios.get(url, {
+			headers: {
+				...params.headers,
+				...authHeaders
+			},
+			...params.responseType
+		})).data;
+	},
+	async postData(params) {
+		let paramsString = "";
+		if (params.parameters) {
+			const parameters = fetchHelper_default.getUriSearchParams(params.parameters).toString();
+			paramsString = parameters.length ? "?" + parameters : "";
+		}
+		const url = getApiUrl(params.api) + params.path + paramsString;
+		let authHeaders = {};
+		if (!params.isNotAuth) authHeaders = await fetchHelper_default.createAuthenticatedFetchHeader(params.forceRefresh);
+		let typeHeader = {};
+		let dataToSend;
+		if ("formData" === params.contentType) {
+			typeHeader = { "Content-Type": "multipart/form-data; charset=utf-8" };
+			dataToSend = new FormData();
+			for (const key in params.dataToSend) {
+				const value = params.dataToSend[key];
+				if (void 0 !== value) dataToSend.append(key, value);
+			}
+		} else if ("text" === params.contentType) {
+			typeHeader = { "Content-Type": "text/plain" };
+			dataToSend = params.dataToSend;
+		} else if ("urlencoded" === params.contentType) {
+			typeHeader = { "Content-Type": "  application/x-www-form-urlencoded" };
+			dataToSend = params.dataToSend;
+		} else if (null != params.dataToSend || void 0 != params.dataToSend) {
+			typeHeader = { "Content-Type": "application/json; charset=utf-8" };
+			dataToSend = JSON.stringify(params.dataToSend);
+		}
+		if (params.noContentType) typeHeader = {};
+		return (await axios.post(url, dataToSend, { headers: {
+			...params.headers,
+			...typeHeader,
+			...authHeaders
+		} }).catch((error) => {
+			if (params.catchFunction) params.catchFunction();
+			else {
+				const axiosError = error;
+				return Promise.reject(axiosError);
+			}
+		}))?.data;
+	},
+	async putData(params) {
+		let paramsString = "";
+		if (params.parameters) {
+			const parameters = fetchHelper_default.getUriSearchParams(params.parameters).toString();
+			paramsString = parameters.length ? "?" + parameters : "";
+		}
+		const url = getApiUrl(params.api) + params.path + paramsString;
+		let authHeaders = {};
+		if (!params.isNotAuth) authHeaders = await fetchHelper_default.createAuthenticatedFetchHeader(params.forceRefresh);
+		let typeHeader = {};
+		let dataToSend;
+		if ("formData" === params.contentType) {
+			typeHeader = { "Content-Type": "multipart/form-data; charset=utf-8" };
+			dataToSend = new FormData();
+			for (const key in params.dataToSend) {
+				const value = params.dataToSend[key];
+				if (void 0 !== value) dataToSend.append(key, value);
+			}
+		} else if (params.raw === true && params.dataToSend) {
+			typeHeader = { "Content-Type": "text/plain; charset=utf-8" };
+			dataToSend = params.dataToSend;
+		} else if (null != params.dataToSend || void 0 != params.dataToSend) {
+			typeHeader = { "Content-Type": "application/json; charset=utf-8" };
+			dataToSend = params.dataToSend;
+		}
+		if (params.noContentType) typeHeader = {};
+		return (await axios.put(url, dataToSend, { headers: {
+			...params.headers,
+			...typeHeader,
+			...authHeaders
+		} })).data;
+	},
+	async deleteData(params) {
+		let paramsString = "";
+		if (params.parameters) {
+			const parameters = fetchHelper_default.getUriSearchParams(params.parameters).toString();
+			paramsString = parameters.length ? "?" + parameters : "";
+		}
+		const url = getApiUrl(params.api) + params.path + paramsString;
+		let authHeaders = {};
+		if (!params.isNotAuth) authHeaders = await fetchHelper_default.createAuthenticatedFetchHeader(params.forceRefresh);
+		let dataToSend;
+		if ("formData" === params.contentType) {
+			dataToSend = new FormData();
+			for (const key in params.dataToSend) {
+				const value = params.dataToSend[key];
+				if (void 0 !== value) dataToSend.append(key, value);
+			}
+		} else dataToSend = params.dataToSend;
+		return (await axios.delete(url, {
+			headers: {
+				...params.headers,
+				...authHeaders
+			},
+			data: dataToSend
+		})).data;
+	},
+	adjustParameters(params) {
+		const parametersUpdated = params.parameters ?? {};
+		if (params.path.includes("podcast/search")) if (!params.parameters?.includeHidden || params.isNotAuth) parametersUpdated.validity = true;
+		else {
+			parametersUpdated.includeStatus = [
+				"READY",
+				"PLANNED",
+				"PROCESSING",
+				"ERROR"
+			];
+			if (!parametersUpdated.notLive) parametersUpdated.includeStatus.push("READY_TO_RECORD");
+		}
+		if (state.generalParameters.forceOrganisationId) {
+			if (!parametersUpdated.organisationId || !parametersUpdated.organisationId?.length) parametersUpdated.organisationId = state.generalParameters.forceOrganisationId;
+			else if (Array.isArray(parametersUpdated.organisationId) && 1 === parametersUpdated.organisationId.length && "" === parametersUpdated.organisationId[0]) parametersUpdated.organisationId = void 0;
+		}
+		if (void 0 !== state.generalParameters.forceRubriqueId) {
+			if (!parametersUpdated.rubriqueId) parametersUpdated.rubriqueId = [];
+			parametersUpdated.rubriqueId = parametersUpdated.rubriqueId.concat([state.generalParameters.forceRubriqueId].flat());
+		}
+		if (void 0 !== state.generalParameters.forceNoRubriquageId) {
+			if (!parametersUpdated.noRubriquageId) parametersUpdated.noRubriquageId = [];
+			parametersUpdated.noRubriquageId.push(...[state.generalParameters.forceNoRubriquageId].flat());
+		}
+		return parametersUpdated;
+	}
+};
+//#endregion
+export { getApiUrl as C, state as E, ModuleApi as S, ParamSdkStore_default as T, TranslationState as _, rubriquesApi as a, useNotificationStore as b, radioApi as c, loadLocaleMessages as d, registerI18n as f, groupsApi as g, organisationApi as h, useAuthStore as i, PodcastSort as l, unique as m, fetchHelper_default as n, mediathequeApi as o, playlistApi as p, useFilterStore as r, aggregatorsApi as s, classicApi_default as t, podcastApi as u, transcriptionApi as v, useApiStore as w, useSaveFetchStore as x, emissionApi as y };
+
+//# sourceMappingURL=classicApi-BKNiWOG4.mjs.map