@saooti/octopus-sdk 41.7.3 → 41.8.0

package/.claude/settings.local.json

@@ -8,7 +8,8 @@
       "Bash(npm audit:*)",
       "Bash(python3:*)",
       "Bash(node --version:*)",
-      "Bash(npm:*)"
+      "Bash(npm:*)",
+      "Bash(npx vitest:*)"
     ]
   }
 }

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # CHANGELOG
 
+## 41.8.0 (18/03/2026)
+
+**Features**
+
+- **14083** - Ajout des fonctionnalités de saisons et types d'épisodes
+  - Ajout des propriétés relatives aux saisons sur les émissions et les épisodes
+  - `PodcastFilterList` permet de regrouper les épisodes en saisons
+  - `EmissionPage` affiche ses épisodes en saisons si définies
+  - `PodcastModuleBox` affiche le numéro de saison et d'épisode du podcast si
+    définis et que le `seasonMode` permet leur affichage
+- Ajout d'une classe `required` pour afficher une asterisque sur les champs
+  requis
+
+**Fix**
+
+- **14291** - Activation du bouton de génération de la transcription suite à
+  correction des droits
+
 ## 41.7.3 (11/03/2026)
 
 **Features**

package/index.ts

@@ -134,6 +134,7 @@ export { useSharePlatforms, SharePlatformName, type SharePlatform } from "./src/
 export { useSharePath } from "./src/components/composable/share/useSharePath.ts";
 export { useOrgaComputed } from "./src/components/composable/useOrgaComputed.ts";
 export { useSeoTitleUrl } from "./src/components/composable/route/useSeoTitleUrl.ts";
+export { useSeasonsManagement } from "./src/components/composable/useSeasonsManagement.ts";
 
 //helper
 import domHelper from "./src/helper/domHelper.ts";
@@ -166,8 +167,8 @@ export { playlistApi } from "./src/api/playlistApi.ts";
 export { podcastApi, PodcastSort, type PodcastSearchOptions } from "./src/api/podcastApi.ts";
 
 // Types
-export { type Emission, emptyEmissionData } from "./src/stores/class/general/emission.ts";
-export { type Podcast, type PodcastAvailability } from "./src/stores/class/general/podcast.ts";
+export { type Emission, SeasonMode, emptyEmissionData } from "./src/stores/class/general/emission.ts";
+export { type Podcast, type PodcastAvailability, PodcastType } from "./src/stores/class/general/podcast.ts";
 export { type Playlist, type PlaylistRule } from "./src/stores/class/general/playlist.ts";
 export { type Annotations } from "./src/stores/class/general";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saooti/octopus-sdk",
-  "version": "41.7.3",
+  "version": "41.8.0",
   "private": false,
   "description": "Javascript SDK for using octopus",
   "author": "Saooti",

package/src/api/emissionApi.ts

@@ -2,6 +2,7 @@ import classicApi from "./classicApi";
 import { ModuleApi } from "./apiConnection";
 import { mapFromGetAll } from "./apiUtils";
 import { Emission } from "@/stores/class/general/emission";
+import { ListClassicReturn } from "@/stores/class/general/listReturn";
 
 /**
  * Retrieve an emission by ID
@@ -25,7 +26,49 @@ async function getAllById(emissionIds: Array<number>): Promise<Record<string, Em
     return mapFromGetAll(emissionIds, get, '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(query?: string, options?: {
+    /** The index of the first element to retrieve */
+    first?: number;
+    /** The number of elements to retrieve */
+    size?: number;
+    specialTreatment?: boolean;
+    distributedBy?: string;
+    /** Filter by organisation */
+    organisationId?: string|string[];
+}): Promise<ListClassicReturn<Emission>> {
+    return classicApi.fetchData<ListClassicReturn<Emission>>({
+        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: number): Promise<void> {
+    return classicApi.putData({
+        api: ModuleApi.DEFAULT,
+        path: 'emission/seasons/reset/' + emissionId
+    });
+}
 export const emissionApi = {
     get,
-    getAllById
+    getAllById,
+    search,
+    resetSeasons
 };

package/src/api/podcastApi.ts

@@ -1,4 +1,4 @@
-import { Podcast, PodcastProcessingStatus, SimplifiedPodcast } from '../stores/class/general/podcast';
+import { Podcast, PodcastProcessingStatus, PodcastType, SimplifiedPodcast } from '../stores/class/general/podcast';
 import { ListClassicReturn } from '../stores/class/general/listReturn';
 import { useAuthStore } from '../stores/AuthStore';
 import classicApi from './classicApi';
@@ -17,7 +17,9 @@ export enum PodcastSort {
     POPULARITY = 'POPULARITY',
     SCORE = 'SCORE',
     UPDATE_ASC = 'UPDATE_ASC',
-    UPDATE_DESC = 'UPDATE_DESC'
+    UPDATE_DESC = 'UPDATE_DESC',
+    /** Smart sort using seasons settings */
+    SEASONAL = 'SEASONAL'
 }
 
 export enum PodcastMonetisation {
@@ -68,11 +70,15 @@ export interface PodcastSearchOptions extends Paginable<PodcastSort> {
     tags?: Array<string>;
     /** Filter by beneficiaries/rights holder reference */
     beneficiaries?: Array<string>;
+    /** Filter by seasons */
+    season?: Array<number>;
+    /** Filter by season episode number */
+    seasonEpisode?: Array<number>;
+    /** Filter by episode type */
+    episodeType?: PodcastType;
 }
 
 async function downloadRegister(podcastId: number, parameters?: Record<string,unknown>): Promise<{ location: string; downloadId: number }> {
-    const authStore = useAuthStore();
-
     return classicApi.fetchData<{
         location: string;
         downloadId: number;
@@ -137,7 +143,7 @@ function processSearchParameters(search: PodcastSearchOptions): FetchParam {
  * @param adaptParameters If true, some adjustments will be made to the parameters
  * @return A list of simplified podcasts
  */
-function search(options: PodcastSearchOptions, adaptParameters?: boolean): Promise<ListClassicReturn<SimplifiedPodcast>> {
+async function search(options: PodcastSearchOptions, adaptParameters?: boolean): Promise<ListClassicReturn<SimplifiedPodcast>> {
     return classicApi.fetchData<ListClassicReturn<SimplifiedPodcast>>({
         api: ModuleApi.DEFAULT,
         path: 'v2/podcast/search',
@@ -146,6 +152,21 @@ function search(options: PodcastSearchOptions, adaptParameters?: boolean): Promi
     });
 }
 
+/**
+ * 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: PodcastSearchOptions, adaptParameters?: boolean): Promise<number> {
+    const result = await search({
+        ...options,
+        size: 0
+    }, adaptParameters);
+
+    return result.count;
+}
+
 /**
  * Retrieve the podcasts matching the search criterias, with all their data.
  * This query is longer, because it also needs to retrieve organisations &
@@ -185,6 +206,7 @@ async function searchFull(options:PodcastSearchOptions, adaptParameters?: boolea
 }
 
 export const podcastApi = {
+    count,
     downloadRegister,
     get,
     search,

package/src/components/composable/useRights.ts

@@ -150,7 +150,7 @@ export const useRights = () => {
     }
 
     function canEditTranscript(): boolean {
-        return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION');
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION');
     }
 
     function canSeeHistory(): boolean {

package/src/components/composable/useSeasonsManagement.ts

@@ -0,0 +1,43 @@
+import { Podcast } from "@/stores/class/general/podcast";
+import { Emission, SeasonMode } from "../../stores/class/general/emission";
+
+/**
+ * Composable to facilitate seasons operations
+ */
+export const useSeasonsManagement = () => {
+    /**
+     * Indicates that seasons are enabled on the given emission
+     * @param emission The emission to check for seasons
+     * @returns True if seasons are enabled, false otherwise
+     */
+    function areSeasonsEnabled(emission: Emission): boolean {
+        return [
+            SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,
+            SeasonMode.SEASON_WITH_PODCAST_NUMBERING
+        ].includes(emission.seasonMode);
+    }
+
+    /**
+     * Simple formatter to display season/episode of the given podcast
+     * @param podcast The podcast to check
+     * @returns A string describing the season/episode of the podcast or null
+     *          if no seasons are defined
+     */
+    function formatSeason(podcast: Podcast): string|null {
+        switch (podcast.emission.seasonMode) {
+            case SeasonMode.NO_SEASON:
+                return null;
+
+            case SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING:
+                return `S${podcast.seasonNumber}`;
+
+            case SeasonMode.SEASON_WITH_PODCAST_NUMBERING:
+                return `S${podcast.seasonNumber}·E${podcast.seasonEpisodeNumber}`;
+        }
+    }
+
+    return {
+        areSeasonsEnabled,
+        formatSeason
+    }
+}

package/src/components/display/podcasts/PodcastFilterList.vue

@@ -18,7 +18,9 @@
         :label="t('Search')"
       />
     </div>
+
     <PodcastList
+      v-if="!showSeasons"
       :first="dfirst"
       :size="dsize"
       :iab-id="iabId"
@@ -34,6 +36,36 @@
       :force-update-parameters="forceUpdateParameters"
       @fetch="fetch"
     />
+    <ClassicNav
+      v-else
+      v-model:active-tab="activeSeasonTab"
+      :tab-number="seasons.length"
+    >
+      <template v-for="season in seasons" #[tabNameSlot(season)]>
+        {{ $t('Podcast - Season N', { season }) }}
+      </template>
+
+      <template v-for="season in seasons" #[tabContentSlot(season)] :key="season">
+        <PodcastList
+          class="flex-grow-1"
+          :first="dfirst"
+          :size="dsize"
+          :iab-id="iabId"
+          :query="query"
+          :participant-id="participantId"
+          :emission-id="emissionId"
+          :organisation-id="productorId"
+          :sort-criteria="sort"
+          :reload="reloadList"
+          :include-hidden="editRight"
+          :show-count="showCount"
+          :display-sort-text="false"
+          :force-update-parameters="forceUpdateParameters"
+          :seasons="[season]"
+          @fetch="fetch($event, season)"
+        />
+      </template>
+    </ClassicNav>
   </section>
 </template>
 
@@ -44,28 +76,43 @@ import { Category } from "@/stores/class/general/category";
 import { defineAsyncComponent, ref, Ref, computed, watch } from "vue";
 import { Podcast } from "@/stores/class/general/podcast";
 import { useI18n } from "vue-i18n";
+import ClassicNav from "../../misc/ClassicNav.vue";
+import { Emission } from "@/stores/class/general/emission";
+import { useSeasonsManagement } from "../../composable/useSeasonsManagement";
+import { PodcastSort } from "../../../api/podcastApi";
 const CategoryChooser = defineAsyncComponent(
   () => import("../categories/CategoryChooser.vue"),
 );
 
 //Props 
-const props = defineProps({
-  first: { default: 0, type: Number },
-  size: { default: 30, type: Number },
-  query: { default: undefined, type: String },
-  participantId: { default: undefined, type: Number },
-  name: { default: undefined, type: String },
-  emissionId: { default: undefined, type: Number },
-  categoryFilter: { default: false, type: Boolean },
-  reload: { default: false, type: Boolean },
-  editRight: { default: false, type: Boolean },
-  productorId: { default: () => [], type: Array as () => Array<string> },
-  showCount: { default: false, type: Boolean },
-  forceUpdateParameters: { default: false, type: Boolean },
-})
+const props = withDefaults(defineProps<{
+  first?: number;
+  size?: number;
+  query?: string;
+  participantId?: number;
+  name?: string;
+  emissionId?: number;
+  categoryFilter?: boolean;
+  reload?: boolean;
+  editRight?: boolean;
+  productorId?: Array<string>;
+  showCount?: boolean;
+  forceUpdateParameters?: boolean;
+  /**
+   * Emission for which to display podcasts
+   * If set, will check for seasons
+   */
+  emission?: Emission;
+}>(), {
+  first: 0,
+  size: 30
+});
 
 //Emits
-const emit = defineEmits(["fetch", "update:query"]);
+const emit = defineEmits<{
+  (e: "fetch", podcasts: Array<Podcast>, season: number|undefined): void;
+  (e: "update:query", query: string): void;
+}>();
 
 //Data 
 const dfirst = ref(props.first);
@@ -76,6 +123,7 @@ const iabId : Ref<number | undefined>= ref(undefined);
 
 //Composables
 const { t } = useI18n();
+const { areSeasonsEnabled } = useSeasonsManagement();
 
 //Computed
 const titleFilter = computed(() => {
@@ -84,7 +132,32 @@ const titleFilter = computed(() => {
     : t("All podcast emission button");
 });
 const query = computed(() => searchPattern.value.length > 3 ? searchPattern.value : "");
-const sort = computed(() =>  !query.value.length ? "DATE" : "SCORE");
+
+const showSeasons = computed(() => {
+  return props.emission !== undefined && areSeasonsEnabled(props.emission) && props.emission.seasonCount > 0;
+});
+
+const activeSeasonTab = ref(showSeasons.value ? (props.emission?.seasonCount ?? 1) - 1 : 0);
+
+const sort = computed((): PodcastSort => {
+  if(showSeasons.value === true) {
+    return PodcastSort.SEASONAL;
+  } else if(!query.value.length) {
+    return PodcastSort.DATE;
+  } else {
+    return PodcastSort.SCORE;
+  }
+});
+
+const seasons = computed((): Array<number> => {
+  const ary: Array<number> = [];
+  if (showSeasons.value === true) {
+    for (let i = 1; i <= props.emission.seasonCount; i++) {
+      ary.push(i);
+    }
+  }
+  return ary;
+});
 
 //Watch
 watch(()=>props.reload, () => {
@@ -98,7 +171,16 @@ watch(searchPattern, () => {
 function onCategorySelected(category: Category | undefined): void {
   iabId.value = category?.id ? category.id : undefined;
 }
-function fetch(podcasts: Array<Podcast>): void {
-  emit("fetch", podcasts);
+function fetch(podcasts: Array<Podcast>, season?: number): void {
+  emit("fetch", podcasts, season);
+}
+
+/** Name of the slot for the tab's title */
+function tabNameSlot(season: number): string {
+  return `${season - 1}`;
+}
+/** Name of the slot for the tab's content */
+function tabContentSlot(season: number): string {
+  return `tab${season - 1}`;
 }
 </script>

package/src/components/display/podcasts/PodcastInlineListTemplate.vue

@@ -5,8 +5,9 @@
         {{ title }}
       </component>
     </div>
+
     <div v-if="!podcastId" class="d-flex justify-content-between">
-      <div class="d-flex">
+      <div v-if="!noSort" class="d-flex">
         <button
           class="btn btn-underline"
           :class="{ active: !popularSort }"
@@ -82,6 +83,8 @@ const props = defineProps({
   noRubriquageId: { default: () => [], type: Array as () => Array<number> },
   podcastId: { default: undefined, type: Number },
   titleTag: { default: "h2", type: String },
+  /** Hide sort options */
+  noSort: { default: false, type: Boolean }
 })
 
 //Emits

package/src/components/display/podcasts/PodcastList.vue

@@ -83,6 +83,7 @@ const props = withDefaults(defineProps<{
   includeHidden?: boolean;
   showCount?: boolean;
   displaySortText?: boolean;
+  /** Criteria to sort on */
   sortCriteria?: PodcastSort;
   validity?: 'true'|'false'|''|boolean; // TODO improve this
   rubriqueId?: Array<number>;
@@ -96,6 +97,8 @@ const props = withDefaults(defineProps<{
   beneficiaries?: Array<string>;
   /** The emission groups to filter on */
   emissionGroups?: Array<EmissionGroup>;
+  /** The seasons to filter on */
+  seasons?: Array<number>;
 }>(), {
   first: 0,
   size: 30,
@@ -223,7 +226,8 @@ async function fetchContent(reset: boolean): Promise<void> {
     processingStatus: [PodcastProcessingStatus.Ready, PodcastProcessingStatus.Processing],
     withVideo: props.withVideo,
     tags: props.includeTag?.length ? props.includeTag : undefined,
-    beneficiaries: props.beneficiaries ?? undefined
+    beneficiaries: props.beneficiaries ?? undefined,
+    season: props.seasons
   };
 
   try {

package/src/components/display/podcasts/PodcastModuleBox.vue

@@ -88,6 +88,12 @@
             {{ podcast.organisation.name }}
           </router-link>
         </div>
+        <div v-if="showSeasonNumber" class="mb-1">
+          {{ `${t('Podcast - Season')} : ${podcast.seasonNumber}` }}
+        </div>
+        <div v-if="showSeasonEpisodeNumber" class="mb-1">
+          {{ `${t('Podcast - Episode number')} : ${podcast.seasonEpisodeNumber}` }}
+        </div>
         <div v-if="'' !== photoCredit" class="mb-1">
           {{ t("Photo credits") + " : " + photoCredit }}
         </div>
@@ -161,8 +167,12 @@ import { state } from "../../../stores/ParamSdkStore";
 import { useAuthStore } from "../../../stores/AuthStore";
 import displayHelper from "../../../helper/displayHelper";
 import {usePodcastView} from "../../composable/podcasts/usePodcastView";
-import { Podcast } from "@/stores/class/general/podcast";
-import { Conference } from "@/stores/class/conference/conference";
+import { Podcast } from "../../../stores/class/general/podcast";
+import { Conference } from "../../../stores/class/conference/conference";
+import { useI18n } from "vue-i18n";
+import { useRouter } from "vue-router";
+import { useSeasonsManagement } from "../../composable/useSeasonsManagement";
+import { SeasonMode } from "../../../stores/class/general/emission";
 
 import { defineAsyncComponent, toRefs, computed } from "vue";
 const ErrorMessage = defineAsyncComponent(
@@ -193,8 +203,6 @@ const Countdown = defineAsyncComponent(() => import("../live/CountDown.vue"));
 const TagList = defineAsyncComponent(() => import("./TagList.vue"));
 const ShareAnonymous = defineAsyncComponent(() => import("../sharing/ShareAnonymous.vue"));
 const PodcastRubriqueList = defineAsyncComponent(() => import("./PodcastRubriqueList.vue"));
-import { useI18n } from "vue-i18n";
-import { useRouter } from "vue-router";
 
 //Props 
 const props = defineProps<{
@@ -222,6 +230,7 @@ const {
 } = usePodcastView(propsRef.podcast, propsRef.podcastConference);
 const authStore = useAuthStore();
 const router = useRouter();
+const { areSeasonsEnabled } = useSeasonsManagement();
 
 //Computed
 const podcastRubriques = computed(() => {
@@ -279,6 +288,14 @@ const tags = computed(() => {
   return tags;
 });
 
+const showSeasonNumber = computed((): boolean => {
+  return areSeasonsEnabled(props.podcast.emission) && props.podcast.seasonNumber !== undefined;
+});
+
+const showSeasonEpisodeNumber = computed((): boolean => {
+  return props.podcast.emission.seasonMode === SeasonMode.SEASON_WITH_PODCAST_NUMBERING && props.podcast.seasonEpisodeNumber !== undefined;
+});
+
 //Methods
 function formatCredits(credits: string|undefined): string {
   if (credits === undefined) {

package/src/components/display/podcasts/PodcastSwiperList.vue

@@ -11,6 +11,7 @@
     :rubrique-id="rubriqueId"
     :no-rubriquage-id="noRubriquageId"
     :title-tag="titleTag"
+    :no-sort="noSort"
     @sort-chrono="sortChrono"
     @sort-popular="sortPopular"
   >
@@ -59,10 +60,14 @@ const props = defineProps({
   rubriquageId: { default: () => [], type: Array as () => Array<number> },
   noRubriquageId: { default: () => [], type: Array as () => Array<number> },
   query: { default: undefined, type: String },
+  /** Filter on season */
+  season: { default: undefined, type: Number },
   lastThreeMonths: { default: false, type: Boolean },
   titleTag: { default: "h2", type: String },
   /** The podcast from which suggestions are made */
-  podcastId: { type: Number }
+  podcastId: { type: Number },
+  /** Hide sort options */
+  noSort: { default: false, type: Boolean }
 })
 
 //Emits
@@ -104,6 +109,7 @@ onBeforeMount(()=>{
 
 //Methods
 async function fetchNext(): Promise<void> {
+  // TODO use podcastApi
   const data = await classicApi.fetchData<ListClassicReturn<Podcast>>({
     api: 0,
     path: "podcast/search",
@@ -123,10 +129,10 @@ async function fetchNext(): Promise<void> {
       sort: popularSort.value ? "POPULARITY" : "DATE",
       query: props.query,
       includeStatus: ["READY", "PROCESSING"],
-      after:
-      popularSort.value && props.lastThreeMonths
+      after: popularSort.value && props.lastThreeMonths
           ? dayjs().subtract(3, "months").toISOString()
           : undefined,
+      season: props.season
     },
     specialTreatement: true,
   });

package/src/components/form/ClassicRadio.vue

@@ -10,12 +10,12 @@
                                      `selected` : true if the option is selected
 -->
 <template>
-  <div role="radiogroup" class="d-flex" :class="isColumn ? 'flex-column' : ''">
+  <div role="radiogroup" class="d-flex" :class="isColumn !== false ? 'flex-column' : ''">
     <div
       v-for="option in options"
       :key="option.title"
       class="octopus-form-item"
-      :class="isColumn ? 'd-flex flex-nowrap align-items-center' : 'me-2'"
+      :class="isColumn !== false ? 'd-flex flex-nowrap align-items-center' : 'me-2'"
     >
       <input
         :id="idRadio + option.value"
@@ -37,22 +37,21 @@
 
 <script setup generic="T extends { title: string; value: string|undefined; }" lang="ts">
 //Props 
-const { textInit } = defineProps({
-  idRadio: { default: "", type: String },
-  isDisabled: { default: false, type: Boolean },
-  options: {
-    default: () => [],
-    type: Array as () => Array<T>,
-  },
-  textInit: { default: undefined, type: String },
-  isColumn: { default: true, type: Boolean },
-})
+const { textInit, isColumn = true } = defineProps<{
+  options: Array<T>;
+  textInit?: string;
+  idRadio?: string;
+  isDisabled?: boolean;
+  isColumn?: boolean;
+}>();
 
 //Emits
-const emit = defineEmits(["update:textInit"]);
+const emit = defineEmits<{
+  (e: 'update:textInit', value: string): void;
+}>();
 
 //Methods
-function onChange(value:string){
+function onChange(value: string){
   emit('update:textInit', value)
 }
 

package/src/components/misc/TopBar.vue

@@ -14,7 +14,13 @@
       :options="options?.topBarMainContent"
     />
   </header>
-  <div v-if="generalStore.contentToDisplay" class="header-content-bg" :style="headerBackgroundImage" :class="{ scrolled: scrolled, 'header-force-blur':needToBlur }" >
+
+  <div
+    v-if="generalStore.contentToDisplay"
+    class="header-content-bg"
+    :style="headerBackgroundImage"
+    :class="{ scrolled: scrolled, 'header-force-blur':needToBlur }"
+  >
     <div class="header-additional-content header-content">
       <h1 v-if="!scrolled" class="text-truncate">
         {{ titleToDisplay }}

package/src/components/pages/EmissionPage.vue

@@ -54,7 +54,7 @@
                 :just-buttons="true"
               />
               <div class="ms-2 fw-bold">
-                {{ t("Listen to the latest episode") }}
+                {{ messageListenEpisode }}
               </div>
             </div>
 
@@ -99,6 +99,7 @@
             :size="ps"
             :show-count="true"
             :emission-id="emissionId"
+            :emission="emission"
             :category-filter="false"
             :edit-right="editRight"
             :productor-id="[emission.orga.id]"
@@ -138,6 +139,7 @@ import { useSimplePageParam } from "../composable/route/useSimplePageParam";
 import ErrorMessage from "../misc/ErrorMessage.vue";
 import ClassicHelpButton from "../misc/ClassicHelpButton.vue";
 import { emissionApi } from "../../api/emissionApi";
+import { useSeasonsManagement } from "../composable/useSeasonsManagement";
 
 const ShareAnonymous = defineAsyncComponent(() => import("../display/sharing/ShareAnonymous.vue"));
 const PodcastFilterList = defineAsyncComponent(
@@ -193,15 +195,16 @@ const { t } = useI18n();
 const { useProxyImageUrl } = useImageProxy();
 const { isPodcastmaker, isEditRights, authOrgaId } = useOrgaComputed();
 const { updatePathParams } = useSeoTitleUrl();
-const {handle403} = useErrorHandler();
+const { handle403 } = useErrorHandler();
 const filterStore = useFilterStore();
-const generalStore= useGeneralStore();
-const route= useRoute();
+const generalStore = useGeneralStore();
+const route = useRoute();
 const {
   searchPattern,
   paginateFirst,
   isInit
 } = useSimplePageParam(props, true);
+const { areSeasonsEnabled, formatSeason } = useSeasonsManagement();
 
 
 //Computed
@@ -209,9 +212,17 @@ const name = computed(() => emission.value?.name ?? "");
 const description = computed(() => emission.value?.description ?? "");
 const editRight = computed(() => isEditRights(emission.value?.orga.id));
 
+const messageListenEpisode = computed((): string => {
+  const base = t("Listen to the latest episode");
+  if (lastPodcast.value !== undefined && areSeasonsEnabled(emission.value)) {
+    return base + ` (${formatSeason(lastPodcast.value)})`;
+  } else {
+    return base;
+  }
+});
 
 //Watch
-watch(()=>props.emissionId, () => {getEmissionDetails()}, {immediate: true});
+watch(() => props.emissionId, getEmissionDetails, { immediate: true });
 
 
 onBeforeUnmount(() => {
@@ -248,12 +259,13 @@ async function getEmissionDetails(): Promise<void> {
     initError();
   }
 }
-function podcastsFetched(podcasts: Array<Podcast>) {
+function podcastsFetched(podcasts: Array<Podcast>, season: number|undefined) {
+  if (season !== undefined && season !== emission.value?.seasonCount) {
+    return;
+  }
+
   for (const podcast of podcasts) {
-    if (
-      "READY" === podcast.processingStatus &&
-      podcast.availability.visibility
-    ) {
+    if ("READY" === podcast.processingStatus && podcast.availability.visibility) {
       lastPodcast.value = podcast;
       return;
     }

package/src/locale/de.json

@@ -417,5 +417,11 @@
   "Podcast": "Folge",
   "Player - Transcription - AI Warning": "Die Transkription basiert auf KI und kann Fehler enthalten, bitte teilen Sie uns dies mit.",
   "All organisations": "Alle Organisationen",
-  "Emission subtitle": "Untertitel der Sendung"
+  "Emission subtitle": "Untertitel der Sendung",
+  "Podcast type - Full": "Standard",
+  "Podcast type - Trailer": "Anhänger",
+  "Podcast type - Bonus": "Boni",
+  "Podcast - Season N": "Saison {season}",
+  "Podcast - Season": "Jahreszeit",
+  "Podcast - Episode number": "Episodennummer"
 }

package/src/locale/en.json

@@ -417,5 +417,11 @@
   "Podcast": "Episode",
   "Player - Transcription - AI Warning": "The transcription is based on AI and may contain errors, please let us know.",
   "All organisations": "All organizations",
-  "Emission subtitle": "Subtitle of the show"
+  "Emission subtitle": "Subtitle of the show",
+  "Podcast type - Full": "Standard",
+  "Podcast type - Trailer": "Trailer",
+  "Podcast type - Bonus": "Bonuses",
+  "Podcast - Season N": "Saison {season}",
+  "Podcast - Season": "Season",
+  "Podcast - Episode number": "Episode number"
 }

package/src/locale/es.json

@@ -417,5 +417,11 @@
   "Podcast": "Episodio",
   "Player - Transcription - AI Warning": "La transcripción se basa en IA y puede contener errores, háganoslo saber.",
   "All organisations": "Todas las organizaciones",
-  "Emission subtitle": "Subtítulo del programa"
+  "Emission subtitle": "Subtítulo del programa",
+  "Podcast type - Full": "Estándar",
+  "Podcast type - Trailer": "Tráiler",
+  "Podcast type - Bonus": "Bonificaciones",
+  "Podcast - Season N": "Temporada {season}",
+  "Podcast - Season": "Estación",
+  "Podcast - Episode number": "Número de episodio"
 }

package/src/locale/fr.json

@@ -440,5 +440,11 @@
   "SmartLink - To emission on podcastmaker": "Page officielle de l'émission - {organisation}",
   "SmartLink - To playlist on podcastmaker": "Page officielle de la playlist - {organisation}",
   "Miniplayer - Parameters - Auto height": "Hauteur automatique",
-  "Player - Transcription - AI Warning": "La transcription est basée sur une IA et peut comporter des erreurs, n’hésitez pas à nous en informer."
+  "Player - Transcription - AI Warning": "La transcription est basée sur une IA et peut comporter des erreurs, n’hésitez pas à nous en informer.",
+  "Podcast type - Full": "Standard",
+  "Podcast type - Trailer": "Trailer",
+  "Podcast type - Bonus": "Bonus",
+  "Podcast - Season N": "Saison {season}",
+  "Podcast - Season": "Saison",
+  "Podcast - Episode number": "Numéro d'épisode"
 }

package/src/locale/it.json

@@ -418,5 +418,11 @@
     "Podcast": "Episodio",
     "Player - Transcription - AI Warning": "La trascrizione si basa sull'intelligenza artificiale e potrebbe contenere errori, faccelo sapere.",
     "All organisations": "Tutte le organizzazioni",
-    "Emission subtitle": "Sottotitolo dello spettacolo"
+    "Emission subtitle": "Sottotitolo dello spettacolo",
+    "Podcast type - Full": "Standard",
+    "Podcast type - Trailer": "Rimorchio",
+    "Podcast type - Bonus": "Bonus",
+    "Podcast - Season N": "Stagione {season}",
+    "Podcast - Season": "Stagione",
+    "Podcast - Episode number": "Numero dell'episodio"
 }

package/src/locale/sl.json

@@ -416,5 +416,11 @@
   "Podcast": "Epizoda",
   "Player - Transcription - AI Warning": "Transkripcija temelji na umetni inteligenci in lahko vsebuje napake, zato nas obvestite.",
   "All organisations": "Vse organizacije",
-  "Emission subtitle": "Podnaslov oddaje"
+  "Emission subtitle": "Podnaslov oddaje",
+  "Podcast type - Full": "Standardno",
+  "Podcast type - Trailer": "Napovednik",
+  "Podcast type - Bonus": "Bonusi",
+  "Podcast - Season N": "Sezona {season}",
+  "Podcast - Season": "Sezona",
+  "Podcast - Episode number": "Številka epizode"
 }

package/src/stores/class/general/emission.ts

@@ -4,6 +4,18 @@ import { Person } from "../user/person";
 import { ItuneCategory } from "./ituneCategory";
 import { Annotations } from ".";
 
+/**
+ * Season settings for emissions
+ */
+export enum SeasonMode {
+  /** This emission doesn't have seasons */
+  NO_SEASON = 'NO_SEASON',
+  /** This emission has seasons and episodes are ordered by date */
+  SEASON_WITHOUT_PODCAST_NUMBERING = 'SEASON_WITHOUT_PODCAST_NUMBERING',
+  /** This emission has seasons and episodes are ordered manually */
+  SEASON_WITH_PODCAST_NUMBERING = 'SEASON_WITH_PODCAST_NUMBERING'
+}
+
 /**
  * An emission
  */
@@ -40,6 +52,12 @@ export interface Emission {
   tags?: string[];
   /** The ids of groups this emission belongs to */
   groupIds?: Array<number>
+  /** Seasons configuration */
+  seasonMode: SeasonMode;
+  /** Number of seasons on this emission */
+  seasonCount: number;
+  /** Indicates that the emission has explicit content */
+  explicit?: boolean;
 }
 
 export function emptyEmissionData(orga?: Organisation): Emission {
@@ -54,5 +72,7 @@ export function emptyEmissionData(orga?: Organisation): Emission {
     rubriqueIds: [],
     monetisable: "UNDEFINED",
     limits: {},
+    seasonMode: SeasonMode.NO_SEASON,
+    seasonCount: 0
   };
 }

package/src/stores/class/general/podcast.ts

@@ -17,6 +17,13 @@ export enum PodcastProcessingStatus {
   All = "ALL"
 }
 
+/** Type of episode */
+export enum PodcastType {
+  FULL = 'full',
+  TRAILER = 'trailer',
+  BONUS = 'bonus'
+}
+
 /** Describe the availability of the podcast */
 export interface PodcastAvailability {
   date?: number | null;
@@ -46,6 +53,8 @@ export interface Podcast {
   availability: PodcastAvailability;
   /** Description of the podcast */
   description?: string;
+  /** Optional summary of the podcast */
+  summary?: string;
   /** Publishing date */
   pubDate?: string;
   /** The status of the processing of the audio file */
@@ -56,6 +65,14 @@ export interface Podcast {
   ofTags?: Array<string>;
   /** List of beneficiaries/rights holders */
   beneficiaries: Array<string>;
+  /** Indicates that the episode has explicit content */
+  explicit?: boolean;
+  /** Type of episode */
+  seasonEpisodeType: PodcastType;
+  /** Number of season in which podcast belongs */
+  seasonNumber?: number;
+  /** Order of the episode in the season */
+  seasonEpisodeNumber?: number;
 
   createdAt?: string;
   createdByUserId?: string;

package/src/style/general.scss

@@ -47,6 +47,13 @@ main, #app{
     font-family: var(--octopus-font-family);
   }
 
+  // Display an asterisk for required fields
+  label.required:after {
+    content: "*";
+    font-weight: bold;
+    margin-left: 3px;
+  }
+
   /** Link style */
   a{
     word-break: break-word;

package/tests/api/podcastApi.spec.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+
+vi.mock('../../src/api/classicApi', () => ({
+    default: {
+        fetchData: vi.fn()
+    }
+}));
+
+import classicApi from '../../src/api/classicApi';
+import { podcastApi } from '../../src/api/podcastApi';
+
+const baseOptions = { organisationId: ['org-1'] };
+
+describe('podcastApi', () => {
+    describe('count', () => {
+        beforeEach(() => {
+            vi.mocked(classicApi.fetchData).mockResolvedValue({ count: 42, result: [], sort: null });
+        });
+
+        it('returns the count from search results', async () => {
+            const result = await podcastApi.count(baseOptions);
+            expect(result).toBe(42);
+        });
+
+        it('calls search with size 0', async () => {
+            await podcastApi.count(baseOptions);
+            expect(classicApi.fetchData).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    parameters: expect.objectContaining({ size: 0 })
+                })
+            );
+        });
+
+        it('forwards other options to search', async () => {
+            await podcastApi.count({ ...baseOptions, emissionId: 5 });
+            expect(classicApi.fetchData).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    parameters: expect.objectContaining({ organisationId: ['org-1'], emissionId: 5 })
+                })
+            );
+        });
+    });
+});

package/tests/components/composable/useSeasonsManagement.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { useSeasonsManagement } from '@/components/composable/useSeasonsManagement';
+import { emptyEmissionData, SeasonMode } from '@/stores/class/general/emission';
+import { emptyPodcastData } from '@/stores/class/general/podcast';
+
+const { areSeasonsEnabled, formatSeason } = useSeasonsManagement();
+
+describe('useSeasonsManagement', () => {
+    describe('areSeasonsEnabled', () => {
+        it.each([
+            SeasonMode.SEASON_WITH_PODCAST_NUMBERING,
+            SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,
+        ])('returns true for %s', (seasonMode) => {
+            expect(areSeasonsEnabled({ ...emptyEmissionData(), seasonMode })).toBe(true);
+        });
+
+        it('returns false for NO_SEASON', () => {
+            expect(areSeasonsEnabled(emptyEmissionData())).toBe(false);
+        });
+    });
+
+    describe('formatSeason', () => {
+        it.each([
+            { seasonMode: SeasonMode.NO_SEASON,                         seasonNumber: 1, seasonEpisodeNumber: 1, expected: null    },
+            { seasonMode: SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,  seasonNumber: 2, seasonEpisodeNumber: 1, expected: 'S2'    },
+            { seasonMode: SeasonMode.SEASON_WITH_PODCAST_NUMBERING,     seasonNumber: 2, seasonEpisodeNumber: 5, expected: 'S2·E5' },
+        ])('formats $seasonMode as $expected', ({ seasonMode, seasonNumber, seasonEpisodeNumber, expected }) => {
+            const podcast = emptyPodcastData();
+            podcast.seasonNumber = seasonNumber;
+            podcast.seasonEpisodeNumber = seasonEpisodeNumber;
+            podcast.emission.seasonMode = seasonMode;
+            expect(formatSeason(podcast)).toBe(expected);
+        });
+    });
+});

package/tests/components/display/podcasts/PodcastFilterList.spec.ts

@@ -0,0 +1,33 @@
+import '@tests/mocks/i18n';
+
+import PodcastFilterList from '@/components/display/podcasts/PodcastFilterList.vue';
+import { emptyEmissionData, SeasonMode } from '@/stores/class/general/emission';
+import { mount as testMount } from '@tests/utils';
+import { describe, expect, it } from 'vitest';
+
+const mount = (props: Record<string, unknown> = {}) =>
+    testMount(PodcastFilterList, { shallow: true, props });
+
+describe('PodcastFilterList', () => {
+    describe('season display', () => {
+        it.each([
+            { desc: 'no emission provided', props: {} },
+            { desc: 'emission has NO_SEASON mode', props: { emission: { ...emptyEmissionData(), seasonMode: SeasonMode.NO_SEASON, seasonCount: 3 } } },
+            { desc: 'emission has seasons but seasonCount is 0', props: { emission: { ...emptyEmissionData(), seasonMode: SeasonMode.SEASON_WITH_PODCAST_NUMBERING, seasonCount: 0 } } },
+        ])('shows a plain list when $desc', async ({ props }) => {
+            const wrapper = await mount(props);
+            expect(wrapper.find('podcast-list-stub').exists()).toBe(true);
+            expect(wrapper.find('classic-nav-stub').exists()).toBe(false);
+        });
+
+        it.each([
+            SeasonMode.SEASON_WITH_PODCAST_NUMBERING,
+            SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,
+        ])('shows a season nav when seasonMode is %s', async (seasonMode) => {
+            const emission = { ...emptyEmissionData(), seasonMode, seasonCount: 3 };
+            const wrapper = await mount({ emission });
+            expect(wrapper.find('classic-nav-stub').exists()).toBe(true);
+            expect(wrapper.find('podcast-list-stub').exists()).toBe(false);
+        });
+    });
+});

package/tests/components/display/podcasts/PodcastInlineListTemplate.spec.ts

@@ -0,0 +1,23 @@
+import '@tests/mocks/i18n';
+import '@tests/mocks/useRouter';
+
+import PodcastInlineListTemplate from '@/components/display/podcasts/PodcastInlineListTemplate.vue';
+import { mount as testMount } from '@tests/utils';
+import { describe, expect, it } from 'vitest';
+
+const mount = (props: Record<string, unknown> = {}) =>
+    testMount(PodcastInlineListTemplate, { shallow: true, props });
+
+describe('PodcastInlineListTemplate', () => {
+    describe('noSort prop', () => {
+        it('shows sort buttons by default', async () => {
+            const wrapper = await mount();
+            expect(wrapper.find('.btn-underline').exists()).toBe(true);
+        });
+
+        it('hides sort buttons when noSort is true', async () => {
+            const wrapper = await mount({ noSort: true });
+            expect(wrapper.find('.btn-underline').exists()).toBe(false);
+        });
+    });
+});

package/tests/components/display/podcasts/PodcastModuleBox.spec.ts

@@ -2,47 +2,74 @@ import '@tests/mocks/i18n';
 import '@tests/mocks/useRouter';
 
 import PodcastModuleBox from '@/components/display/podcasts/PodcastModuleBox.vue';
+import { SeasonMode } from '@/stores/class/general/emission';
 import { emptyPodcastData, Podcast } from '@/stores/class/general/podcast';
-import { mount, setupAuthStore } from '@tests/utils';
+import { mount as testMount, setupAuthStore } from '@tests/utils';
 import { describe, expect, it } from 'vitest';
 import { initialize } from '@/stores/ParamSdkStore';
 
+const mount = (podcast: Podcast) => testMount(PodcastModuleBox, {
+    props: { podcast },
+    stubs: ['ShareAnonymous', 'LikeSection'],
+    beforeMount: setupAuthStore()
+});
+
 describe('PodcastModuleBox', () => {
     describe('date display', () => {
         const podcast: Podcast = emptyPodcastData();
         podcast.pubDate = '2025-12-01T10:21:31.000+00:00';
 
         it('shows the date without time by default', async() => {
-            const wrapper = await mount(PodcastModuleBox, {
-                props: { podcast },
-                stubs: ['ShareAnonymous', 'LikeSection'],
-                beforeMount: setupAuthStore()
-            });
+            const wrapper = await mount(podcast);
             expect(wrapper.text()).toContain('1 December 2025');
             expect(wrapper.text()).not.toContain('11:21');
         });
 
-        it('shows the date without time when disable in SdkParams', async() => {
-            const wrapper = await mount(PodcastModuleBox, {
-                props: { podcast },
-                stubs: ['ShareAnonymous', 'LikeSection'],
-                beforeMount: setupAuthStore()
-            });
+        it('shows the date with time when enabled in SdkParams', async() => {
+            initialize({ generalParameters: { showTimeWithDates: true } });
+            const wrapper = await mount(podcast);
             expect(wrapper.text()).toContain('1 December 2025');
-            expect(wrapper.text()).not.toContain('11:21');
+            expect(wrapper.text()).toContain('11:21');
         });
+    });
 
-        it('shows the date with time when enabled in SdkParams', async() => {
-            initialize({
-                generalParameters: { showTimeWithDates: true }
+    describe('season info', () => {
+        function makePodcast(seasonMode = SeasonMode.NO_SEASON, overrides: Partial<Podcast> = {}) {
+            const podcast = emptyPodcastData();
+            podcast.emission.seasonMode = seasonMode;
+            return { ...podcast, ...overrides };
+        }
+
+        describe('season number', () => {
+            it('hidden when seasonNumber is not set', async () => {
+                const wrapper = await mount(makePodcast(SeasonMode.SEASON_WITH_PODCAST_NUMBERING));
+                expect(wrapper.text()).not.toContain('Podcast - Season');
             });
-            const wrapper = await mount(PodcastModuleBox, {
-                props: { podcast },
-                stubs: ['ShareAnonymous', 'LikeSection'],
-                beforeMount: setupAuthStore()
+
+            it('hidden when emission has no season mode', async () => {
+                const wrapper = await mount(makePodcast(SeasonMode.NO_SEASON, { seasonNumber: 2 }));
+                expect(wrapper.text()).not.toContain('Podcast - Season');
+            });
+
+            it.each([
+                SeasonMode.SEASON_WITH_PODCAST_NUMBERING,
+                SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,
+            ])('shown for %s', async (seasonMode) => {
+                const wrapper = await mount(makePodcast(seasonMode, { seasonNumber: 2 }));
+                expect(wrapper.text()).toContain('Podcast - Season : 2');
+            });
+        });
+
+        describe('episode number', () => {
+            it('hidden for SEASON_WITHOUT_PODCAST_NUMBERING', async () => {
+                const wrapper = await mount(makePodcast(SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING, { seasonEpisodeNumber: 5 }));
+                expect(wrapper.text()).not.toContain('Podcast - Episode number');
+            });
+
+            it('shown for SEASON_WITH_PODCAST_NUMBERING', async () => {
+                const wrapper = await mount(makePodcast(SeasonMode.SEASON_WITH_PODCAST_NUMBERING, { seasonEpisodeNumber: 5 }));
+                expect(wrapper.text()).toContain('Podcast - Episode number : 5');
             });
-            expect(wrapper.text()).toContain('1 December 2025');
-            expect(wrapper.text()).toContain('11:21');
         });
     });
 });

package/tests/components/pages/EmissionPage.spec.ts

@@ -0,0 +1,86 @@
+import '@tests/mocks/i18n';
+import '@tests/mocks/useRouter';
+
+import EmissionPage from '@/components/pages/EmissionPage.vue';
+import { emptyEmissionData, SeasonMode } from '@/stores/class/general/emission';
+import { emptyPodcastData, PodcastProcessingStatus } from '@/stores/class/general/podcast';
+import { mount, VueWrapper } from '@tests/utils';
+import { describe, expect, it, vi } from 'vitest';
+import { nextTick } from 'vue';
+
+vi.mock('@/api/emissionApi', () => ({
+    emissionApi: { get: vi.fn() }
+}));
+vi.mock('@/components/composable/route/useSeoTitleUrl.ts', () => ({
+    useSeoTitleUrl: () => ({ updatePathParams: vi.fn() })
+}));
+vi.mock('@/components/composable/useImageProxy', () => ({
+    useImageProxy: () => ({ useProxyImageUrl: vi.fn() })
+}));
+
+import { emissionApi } from '@/api/emissionApi';
+
+const publicOrga = { id: 'org-1', name: 'Test', imageUrl: '', privacy: 'PUBLIC' };
+
+function makeEmission(seasonMode: SeasonMode) {
+    return { ...emptyEmissionData(), seasonMode, seasonCount: 2, orga: publicOrga };
+}
+
+function makeReadyPodcast(seasonMode: SeasonMode = SeasonMode.NO_SEASON) {
+    const podcast = emptyPodcastData();
+    podcast.processingStatus = PodcastProcessingStatus.Ready;
+    podcast.seasonNumber = 1;
+    podcast.seasonEpisodeNumber = 3;
+    podcast.emission.seasonMode = seasonMode;
+    return podcast;
+}
+
+async function mountPage(seasonMode: SeasonMode) {
+    vi.mocked(emissionApi.get).mockResolvedValue(makeEmission(seasonMode));
+    return mount(EmissionPage, { shallow: true, props: { emissionId: 1 } });
+}
+
+async function triggerFetch(wrapper: VueWrapper, seasonMode: SeasonMode, season?: number) {
+    await wrapper.findComponent({ name: 'PodcastFilterList' }).vm.$emit('fetch', [makeReadyPodcast(seasonMode)], season);
+    await nextTick();
+}
+
+describe('EmissionPage', () => {
+    describe('messageListenEpisode', () => {
+        it('does not show season info before any podcast is fetched', async () => {
+            const wrapper = await mountPage(SeasonMode.SEASON_WITH_PODCAST_NUMBERING);
+            expect(wrapper.text()).not.toContain('S1·E3');
+        });
+
+        it('shows base message without season info for NO_SEASON emission', async () => {
+            const wrapper = await mountPage(SeasonMode.NO_SEASON);
+            await triggerFetch(wrapper, SeasonMode.NO_SEASON);
+            expect(wrapper.text()).toContain('Listen to the latest episode');
+            expect(wrapper.text()).not.toContain('(S');
+        });
+
+        it.each([
+            { seasonMode: SeasonMode.SEASON_WITH_PODCAST_NUMBERING,    expected: 'Listen to the latest episode (S1·E3)' },
+            { seasonMode: SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING, expected: 'Listen to the latest episode (S1)'    },
+        ])('appends season info for $seasonMode', async ({ seasonMode, expected }) => {
+            const wrapper = await mountPage(seasonMode);
+            await triggerFetch(wrapper, seasonMode);
+            expect(wrapper.text()).toContain(expected);
+        });
+    });
+
+    describe('podcastsFetched season filtering', () => {
+        // seasonCount is 2 in makeEmission
+        it.each([undefined, 2])('shows lastPodcast when season is %s', async (season) => {
+            const wrapper = await mountPage(SeasonMode.SEASON_WITH_PODCAST_NUMBERING);
+            await triggerFetch(wrapper, SeasonMode.SEASON_WITH_PODCAST_NUMBERING, season);
+            expect(wrapper.text()).toContain('Listen to the latest episode');
+        });
+
+        it('ignores podcasts from earlier seasons', async () => {
+            const wrapper = await mountPage(SeasonMode.SEASON_WITH_PODCAST_NUMBERING);
+            await triggerFetch(wrapper, SeasonMode.SEASON_WITH_PODCAST_NUMBERING, 1);
+            expect(wrapper.text()).not.toContain('Listen to the latest episode');
+        });
+    });
+});