TV series, seasons and episodes

demo.ts

@@ -4,13 +4,13 @@ import { csfd } from './src';
 // csfd.setOptions({ optionsRequest: { credentials: 'include' } });
 
 // Parse movie
-csfd.movie(10135).then((movie) => console.log(movie));
+csfd.movie(621073).then((movie) => console.log(movie));
 
 // csfd.search('matrix').then((search) => console.log(search));
 // csfd.cinema(1, 'today').then((cinema) => console.log(cinema));
 
 // Parse creator
-csfd.creator(2120).then((creator) => console.log(creator));
+// csfd.creator(2120).then((creator) => console.log(creator));
 
 /**
  * USER RATINGS

src/dto/movie.ts

@@ -17,6 +17,16 @@ export interface CSFDMovie extends CSFDScreening {
   premieres: CSFDPremiere[];
   related: CSFDMovieListItem[];
   similar: CSFDMovieListItem[];
+  seasons: CSFDSeason[] | null;
+  episodes: CSFDSeason[] | null;
+  parent: CSFDParent | null;
+  episodeCode: string | null;
+  seasonName: string | null;
+}
+
+export interface CSFDParent {
+  season: { id: number; name: string } | null;
+  series: { id: number; name: string } | null;
 }
 
 export interface MovieJsonLd {
@@ -151,7 +161,6 @@ export type CSFDCreatorGroups =
   | 'Scénografie'
   | 'Kostýmy';
 
-
 export type CSFDCreatorGroupsEnglish =
   | 'Directed by'
   | 'Screenplay'
@@ -187,3 +196,10 @@ export interface CSFDPremiere {
 }
 
 export type CSFDBoxContent = 'Související' | 'Podobné';
+
+export interface CSFDSeason {
+  id: number;
+  name: string;
+  url: string;
+  info: string | null;
+}

src/helpers/global.helper.ts

@@ -16,6 +16,16 @@ export const parseIdFromUrl = (url: string): number => {
   return +id || null;
 };
 
+export const parseLastIdFromUrl = (url: string): number => {
+  if (url) {
+    const idSlug = url?.split('/')[3];
+    const id = idSlug?.split('-')[0];
+    return +id || null;
+  } else {
+    return null;
+  }
+};
+
 export const getColor = (cls: string): CSFDColorRating => {
   switch (cls) {
     case 'page-lightgrey':

src/helpers/movie.helper.ts

@@ -9,14 +9,22 @@ import {
   CSFDGenres,
   CSFDMovieCreator,
   CSFDMovieListItem,
+  CSFDParent,
   CSFDPremiere,
+  CSFDSeason,
   CSFDTitlesOther,
   CSFDVod,
   CSFDVodService,
   MovieJsonLd
 } from '../dto/movie';
 import { CSFDOptions } from '../types';
-import { addProtocol, getColor, parseISO8601Duration, parseIdFromUrl } from './global.helper';
+import {
+  addProtocol,
+  getColor,
+  parseISO8601Duration,
+  parseIdFromUrl,
+  parseLastIdFromUrl
+} from './global.helper';
 
 const CREATOR_LABELS: Record<
   string,
@@ -101,6 +109,26 @@ export const getMovieId = (el: HTMLElement): number => {
   return parseIdFromUrl(url);
 };
 
+export const getSeriesAndSeasonTitle = (
+  el: HTMLElement
+): { seriesName: string | null; seasonName: string | null } => {
+  const titleElement = el.querySelector('h1');
+  if (!titleElement) {
+    return { seriesName: null, seasonName: null };
+  }
+
+  const fullText = titleElement.innerText.trim();
+
+  // Check if there's a series part indicated by ' - '
+  if (fullText.includes(' - ')) {
+    const [seriesName, seasonName] = fullText.split(' - ').map((part) => part.trim());
+    return { seriesName, seasonName };
+  }
+
+  // If no series part found, return just the name
+  return { seriesName: fullText, seasonName: null };
+};
+
 export const getMovieTitle = (el: HTMLElement): string => {
   return el.querySelector('h1').innerText.split(`(`)[0].trim();
 };
@@ -321,6 +349,91 @@ export const getMovieCreators = (el: HTMLElement, options?: CSFDOptions): CSFDCr
   return creators;
 };
 
+export const getSeasonsOrEpisodes = (
+  el: HTMLElement,
+  serie?: { id: number; title: string }
+): CSFDSeason[] | null => {
+  const childrenList = el.querySelector('.film-episodes-list');
+  if (!childrenList) return null;
+
+  const childrenNodes = childrenList.querySelectorAll('.film-title');
+  if (!childrenNodes?.length) return [];
+
+  return childrenNodes.map((season) => {
+    const nameContainer = season.querySelector('.film-title-name');
+    const infoContainer = season.querySelector('.info');
+
+    return {
+      id: parseLastIdFromUrl(nameContainer?.getAttribute('href') || ''),
+      name: nameContainer?.textContent?.trim() || null,
+      url: nameContainer?.getAttribute('href') || null,
+      info: infoContainer?.textContent?.replace(/[{()}]/g, '').trim() || null
+    };
+  });
+};
+
+export const getEpisodeCode = (el: HTMLElement): string | null => {
+  const filmHeaderName = el.querySelector('.film-header-name h1');
+  if (!filmHeaderName) return null;
+
+  const text = filmHeaderName.textContent?.trim() || '';
+  const match = text.match(/\(([^)]+)\)/);
+  const code = match ? match[1] : null;
+
+  return code;
+};
+
+export const detectSeasonOrEpisodeListType = (el: HTMLElement) => {
+  const headerText = el.querySelector('.box-header h3')?.innerText.trim() ?? '';
+
+  if (headerText.includes('Série')) return 'seasons';
+  if (headerText.startsWith('Epizody')) return 'episodes';
+  return null;
+};
+
+export const getSeasonOrEpisodeParent = (
+  el: HTMLElement,
+  serie?: { id: number; name: string }
+): CSFDParent | null => {
+  // Try h2 first (for episodes), then h1 (for seasons)
+  let parents = el.querySelectorAll('.film-header h2 a');
+  if (parents.length === 0) {
+    parents = el.querySelectorAll('.film-header h1 a');
+  }
+
+  if (parents.length === 0) {
+    if (!serie) return null;
+    return { series: serie, season: null };
+  }
+
+  const [parentSeries, parentSeason] = parents;
+
+  const seriesId = parseIdFromUrl(parentSeries?.getAttribute('href'));
+  const seasonId = parseLastIdFromUrl(parentSeason?.getAttribute('href') || '');
+  const seriesName = parentSeries?.textContent?.trim() || null;
+  const seasonName = parentSeason?.textContent?.trim() || null;
+
+  const series = seriesId && seriesName ? { id: seriesId, name: seriesName } : null;
+  const season = seasonId && seasonName ? { id: seasonId, name: seasonName } : null;
+
+  if (!series && !season) return null;
+
+  return { series, season };
+};
+
+export const getMovieGroup = (
+  el: HTMLElement,
+  group: CSFDCreatorGroups | CSFDCreatorGroupsEnglish | CSFDCreatorGroupsSlovak
+): CSFDMovieCreator[] => {
+  const creators = el.querySelectorAll('.creators h4');
+  const element = creators.filter((elem) => elem.textContent.trim().includes(group))[0];
+  if (element?.parentNode) {
+    return parseMoviePeople(element.parentNode as HTMLElement);
+  } else {
+    return [];
+  }
+};
+
 export const getMovieType = (el: HTMLElement): string => {
   const type = el.querySelector('.film-header-name .type');
   return type?.innerText?.replace(/[{()}]/g, '') || 'film';

src/services/movie.service.ts

@@ -3,6 +3,8 @@ import { CSFDFilmTypes } from '../dto/global';
 import { CSFDMovie, MovieJsonLd } from '../dto/movie';
 import { fetchPage } from '../fetchers';
 import {
+  detectSeasonOrEpisodeListType,
+  getEpisodeCode,
   getMovieBoxMovies,
   getMovieColorRating,
   getMovieCreators,
@@ -21,7 +23,10 @@ import {
   getMovieTrivia,
   getMovieType,
   getMovieVods,
-  getMovieYear
+  getMovieYear,
+  getSeasonOrEpisodeParent,
+  getSeasonsOrEpisodes,
+  getSeriesAndSeasonTitle
 } from '../helpers/movie.helper';
 import { CSFDOptions } from '../types';
 import { movieUrl } from '../vars';
@@ -57,15 +62,21 @@ export class MovieScraper {
     pageClasses: string[],
     jsonLd: MovieJsonLd | null,
     options: CSFDOptions
-  ): CSFDMovie {
+  ) {
+    const type = getMovieType(el) as CSFDFilmTypes;
+    const { seriesName = null, seasonName = null } =
+      type === 'série' ? getSeriesAndSeasonTitle(el) : {};
+    const seasonOrEpisodeListType = detectSeasonOrEpisodeListType(el);
+
+    const title = type === 'série' && seriesName ? seriesName : getMovieTitle(el);
     return {
       id: movieId,
-      title: getMovieTitle(el),
+      title,
       year: getMovieYear(jsonLd),
       duration: getMovieDuration(jsonLd, el),
       descriptions: getMovieDescriptions(el),
       genres: getMovieGenres(el),
-      type: getMovieType(el) as CSFDFilmTypes,
+      type,
       url: movieUrl(movieId, { language: options?.language }),
       origins: getMovieOrigins(el),
       colorRating: getMovieColorRating(pageClasses),
@@ -80,7 +91,12 @@ export class MovieScraper {
       tags: getMovieTags(asideEl),
       premieres: getMoviePremieres(asideEl),
       related: getMovieBoxMovies(asideEl, 'Související'),
-      similar: getMovieBoxMovies(asideEl, 'Podobné')
+      similar: getMovieBoxMovies(asideEl, 'Podobné'),
+      seasons: seasonOrEpisodeListType === 'seasons' ? getSeasonsOrEpisodes(el) : null,
+      episodes: seasonOrEpisodeListType === 'episodes' ? getSeasonsOrEpisodes(el) : null,
+      parent: type === 'seriál' ? null : getSeasonOrEpisodeParent(el, { id: movieId, name: title }),
+      episodeCode: type === 'epizoda' ? getEpisodeCode(el) : null,
+      seasonName
     };
   }
 }

tests/fetchers.test.ts

@@ -159,25 +159,102 @@ describe('Live: Movie page. Fetch `10135-forrest-gump`', () => {
   });
 });
 
-describe('Live: Tv series', () => {
-  let movie: CSFDMovie = {} as CSFDMovie;
-  beforeAll(async () => {
-    movie = await csfd.movie(71924);
-  });
-  test('Year', () => {
-    expect(movie.year).toEqual<number>(1994);
+describe('Live: Series Patterns', () => {
+  // Pattern 1: Series with Seasons (The Simpsons)
+  describe('Series with Seasons (The Simpsons)', () => {
+    let movie: CSFDMovie;
+    beforeAll(async () => {
+      movie = await csfd.movie(72489);
+    });
+    test('Type and Title', () => {
+      expect(movie.type).toEqual<CSFDFilmTypes>('seriál');
+      expect(movie.title).toEqual('Simpsonovi');
+    });
+    test('Seasons', () => {
+      expect(movie.seasons).toBeDefined();
+      expect(movie.seasons!.length).toBeGreaterThan(20);
+    });
+    test('No Episodes on main page', () => {
+      expect(movie.episodes).toBeNull();
+    });
   });
-  test('Type', () => {
-    expect(movie.type).toEqual<CSFDFilmTypes>('seriál');
+
+  // Pattern 1: Season Page (The Simpsons S01)
+  describe('Season Page (The Simpsons S01)', () => {
+    let movie: CSFDMovie;
+    beforeAll(async () => {
+      movie = await csfd.movie(474212);
+    });
+    test('Type and Title', () => {
+      expect(movie.type).toEqual<CSFDFilmTypes>('série');
+      expect(movie.title).toEqual('Simpsonovi');
+      expect(movie.seasonName).toEqual('Série 1');
+    });
+    test('Parent Series', () => {
+      expect(movie.parent?.series?.id).toEqual(72489);
+      expect(movie.parent?.season).toBeNull();
+    });
+    test('Episodes', () => {
+      expect(movie.episodes).toBeDefined();
+      expect(movie.episodes!.length).toBeGreaterThan(0);
+    });
   });
-  test('Title', () => {
-    expect(movie.title).toEqual<string>('Království');
+
+  // Pattern 1: Episode Page (The Simpsons S01E08)
+  describe('Episode Page (The Simpsons S01E08)', () => {
+    let movie: CSFDMovie;
+    beforeAll(async () => {
+      movie = await csfd.movie(474220);
+    });
+    test('Type and Title', () => {
+      expect(movie.type).toEqual<CSFDFilmTypes>('epizoda');
+      expect(movie.title).toEqual('Mluvící hlava');
+    });
+    test('Episode Code', () => {
+      expect(movie.episodeCode).toEqual('S01E08');
+    });
+    test('Parents', () => {
+      expect(movie.parent?.series?.id).toEqual(72489);
+      expect(movie.parent?.season?.id).toEqual(474212);
+    });
   });
-  test('Duration', () => {
-    expect(movie.duration).toBeGreaterThan(50);
+
+  // Pattern 2: Series without Seasons (The Curse)
+  describe('Series without Seasons (The Curse)', () => {
+    let movie: CSFDMovie;
+    beforeAll(async () => {
+      movie = await csfd.movie(1431651);
+    });
+    test('Type and Title', () => {
+      expect(movie.type).toEqual<CSFDFilmTypes>('seriál');
+      expect(movie.title).toEqual('The Curse');
+    });
+    test('Episodes directly', () => {
+      expect(movie.episodes).toBeDefined();
+      expect(movie.episodes!.length).toBeGreaterThan(0);
+    });
+    test('No Seasons', () => {
+      expect(movie.seasons).toBeNull();
+    });
   });
-  test('Fetch not number', async () => {
-    await expect(csfd.movie('test' as any)).rejects.toThrow(Error);
+
+  // Pattern 2: Episode without Season (The Curse E01)
+  describe('Episode without Season (The Curse E01)', () => {
+    let movie: CSFDMovie;
+    beforeAll(async () => {
+      movie = await csfd.movie(1436408);
+    });
+    test('Type and Title', () => {
+      expect(movie.type).toEqual<CSFDFilmTypes>('epizoda');
+      expect(movie.title).toEqual('Kouzelná země');
+    });
+    test('Episode Code', () => {
+      expect(movie.episodeCode).toEqual('E01');
+    });
+    test('Parents', () => {
+      expect(movie.parent?.series?.id).toEqual(1431651);
+      expect(movie.parent?.season).toBeNull();
+    });
   });
 });