@saooti/octopus-sdk 42.2.0 → 42.2.1

package/dist/classicApi-CkDHWZG1.mjs

@@ -0,0 +1,1908 @@
+import { computed, effectScope, nextTick, ref, toRef, watch } 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",
+		displayEmissionTitleInHeader: false
+	},
+	emissionsPage: {
+		itemPlayer: false,
+		rubriquage: void 0,
+		mainRubrique: void 0,
+		buttonMore: false,
+		progressBar: false,
+		displayEmissionTitleInHeader: 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/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/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
+	});
+}
+/**
+* Retrieve the video configuration of a given organisation
+* @param organisationId The ID of the organisation
+* @returns The video configuration of the organisation
+*/
+async function getVideoConfig(organisationId) {
+	return useCacheStore().getData(`org-video-config-${organisationId}`, () => {
+		return classicApi_default.fetchData({
+			api: ModuleApi.DEFAULT,
+			path: "video/config/" + encodeURI(organisationId)
+		});
+	});
+}
+var organisationApi = {
+	get: get$4,
+	getAllById: getAllById$1,
+	getAttributes,
+	getVideoConfig
+};
+//#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-BqVF4jGm.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/class/rubrique/rubriquage.ts
+var RUBRIQUAGE_HOMEORDER_RESET = -2;
+var RubriquageMode = /* @__PURE__ */ function(RubriquageMode) {
+	RubriquageMode["OPTIONAL"] = "OPTIONAL";
+	RubriquageMode["MANDATORY"] = "MANDATORY";
+	RubriquageMode["RESTRICTIVE"] = "RESTRICTIVE";
+	return RubriquageMode;
+}({});
+//#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
+	});
+}
+/**
+* Find rubriquages according to criterias
+* @param organisationId ID of the organisation for which to retrieve the
+rubriquage
+* @returns The found rubriquage
+*/
+async function findRestrictiveRubriquage(organisationId) {
+	return (await searchRubriquages([organisationId])).find((r) => r.mode === RubriquageMode.RESTRICTIVE);
+}
+/**
+* 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,
+	findRestrictiveRubriquage,
+	getRubriquage,
+	getRubrique,
+	getCachedRubrique,
+	searchRubriquages,
+	searchRubriques,
+	updateRubriquage,
+	deleteRubriquage,
+	listUserScope,
+	listUsersScopedByRubrique,
+	setUserScope
+};
+//#endregion
+//#region src/helper/slugify.ts
+function slugify(name) {
+	return name.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+//#endregion
+//#region src/components/composable/useSubOrganisations.ts
+var subOrganisations = ref([]);
+var selectedSubOrganisation = ref(null);
+var loadingPromise = null;
+var watchInitialized = false;
+function slugifySubOrganisation(subOrga) {
+	return slugify(subOrga.name);
+}
+/**
+* Composable to manage suborganisation.
+* Allows for selecting (= focusing), unselecting, listing, etc
+* @param organisationId ID of the current organisation
+* @param slugFunc Function to slugify the suborganisation ids
+*/
+var useSubOrganisations = (organisationId, slugFunc = slugifySubOrganisation) => {
+	if (!watchInitialized) {
+		watchInitialized = true;
+		if (subOrganisations.value.length === 0 && !loadingPromise) updateList();
+		effectScope(true).run(() => {
+			watch(organisationId, updateList);
+		});
+	}
+	async function updateList() {
+		unselectSubOrganisation();
+		loadingPromise = rubriquesApi.findRestrictiveRubriquage(organisationId.value);
+		const rubriquage = await loadingPromise;
+		loadingPromise = null;
+		if (rubriquage) subOrganisations.value = rubriquage.rubriques.map((r) => ({
+			id: r.rubriqueId,
+			name: r.name,
+			podcastCount: r.podcastCount ?? 0,
+			annotations: r.annotations ?? {}
+		}));
+		else subOrganisations.value = [];
+	}
+	async function getSubOrganisation(id) {
+		if (loadingPromise) await loadingPromise;
+		let findFunc;
+		if (typeof id === "string") findFunc = (c) => slugFunc(c) === id;
+		else findFunc = (c) => c.id === id;
+		const subOrga = subOrganisations.value.find(findFunc);
+		if (subOrga) return Promise.resolve(subOrga);
+		else return Promise.reject(`Sub organisation ${id} not found`);
+	}
+	function selectSubOrganisation(subOrganisation) {
+		if (selectedSubOrganisation.value) unselectSubOrganisation();
+		selectedSubOrganisation.value = subOrganisation;
+		ParamSdkStore_default.state.generalParameters.forceRubriqueId = [ParamSdkStore_default.state.generalParameters.forceRubriqueId ?? [], subOrganisation.id].flat();
+	}
+	function unselectSubOrganisation() {
+		if (!selectedSubOrganisation.value) return;
+		const data = ParamSdkStore_default.state.generalParameters.forceRubriqueId;
+		if (Array.isArray(data)) {
+			const idx = data.findIndex((id) => id === selectedSubOrganisation.value.id);
+			if (idx >= 0) data.splice(idx, 1);
+			ParamSdkStore_default.state.generalParameters.forceRubriqueId = data;
+		} else ParamSdkStore_default.state.generalParameters.forceRubriqueId = void 0;
+		selectedSubOrganisation.value = null;
+	}
+	return {
+		/** Currently selected/focused suborganisation */
+		selectSubOrganisation,
+		/** Change the currently selected/focused suborganisation */
+		selectedSubOrganisation,
+		/** Remove the focus on the suborganisation */
+		unselectSubOrganisation,
+		/** List of available suborganisations */
+		subOrganisations,
+		/**
+		* Get a suborganisation by its ID or sluggified name
+		* @param id Either the numeric ID or the sluggified name of the orga
+		* @returns A promise of the matching sub organisation
+		*/
+		getSubOrganisation
+	};
+};
+//#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 organisationApi.getVideoConfig(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();
+				if (scope.length > 0) {
+					const { selectSubOrganisation, getSubOrganisation } = useSubOrganisations(toRef(activeOrganisation, "id"));
+					selectSubOrganisation(await getSubOrganisation(scope[0]));
+				}
+			} 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 { state as A, emissionApi as C, getApiUrl as D, ModuleApi as E, useApiStore as O, transcriptionApi as S, useSaveFetchStore as T, playlistApi as _, useSubOrganisations as a, groupsApi as b, RUBRIQUAGE_HOMEORDER_RESET as c, aggregatorsApi as d, radioApi as f, registerI18n as g, loadLocaleMessages as h, useAuthStore as i, ParamSdkStore_default as k, RubriquageMode as l, podcastApi as m, fetchHelper_default as n, slugify as o, PodcastSort as p, useFilterStore as r, rubriquesApi as s, classicApi_default as t, mediathequeApi as u, unique as v, useNotificationStore as w, TranslationState as x, organisationApi as y };
+
+//# sourceMappingURL=classicApi-CkDHWZG1.mjs.map