node-csfd-api 5.3.0 → 5.4.0

package/src/helpers/movie.helper.mjs

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+import { addProtocol, getColor, parseDate, parseFilmType, parseISO8601Duration, parseIdFromUrl, parseLastIdFromUrl } from "./global.helper.mjs";
+
+//#region src/helpers/movie.helper.ts
+const CREATOR_LABELS = {
+	en: {
+		directors: "Directed by",
+		writers: "Screenplay",
+		cinematography: "Cinematography",
+		music: "Composer",
+		actors: "Cast",
+		basedOn: "Based on",
+		producers: "Produced by",
+		filmEditing: "Editing",
+		costumeDesign: "Costumes",
+		productionDesign: "Production design",
+		casting: "Casting",
+		sound: "Sound",
+		makeup: "Make-up"
+	},
+	cs: {
+		directors: "Režie",
+		writers: "Scénář",
+		cinematography: "Kamera",
+		music: "Hudba",
+		actors: "Hrají",
+		basedOn: "Předloha",
+		producers: "Produkce",
+		filmEditing: "Střih",
+		costumeDesign: "Kostýmy",
+		productionDesign: "Scénografie",
+		casting: "Casting",
+		sound: "Zvuk",
+		makeup: "Masky"
+	},
+	sk: {
+		directors: "Réžia",
+		writers: "Scenár",
+		cinematography: "Kamera",
+		music: "Hudba",
+		actors: "Hrajú",
+		basedOn: "Predloha",
+		producers: "Produkcia",
+		filmEditing: "Strih",
+		costumeDesign: "Kostýmy",
+		productionDesign: "Scénografia",
+		casting: "Casting",
+		sound: "Zvuk",
+		makeup: "Masky"
+	}
+};
+/**
+* Maps language-specific movie creator group labels.
+* @param language - The language code (e.g., 'en', 'cs')
+* @param key - The key of the creator group (e.g., 'directors', 'writers')
+* @returns The localized label for the creator group
+*/
+const getLocalizedCreatorLabel = (language, key) => {
+	return (CREATOR_LABELS[language || "cs"] || CREATOR_LABELS["cs"])[key];
+};
+const getSeriesAndSeasonTitle = (el) => {
+	const titleElement = el.querySelector("h1");
+	if (!titleElement) return {
+		seriesName: null,
+		seasonName: null
+	};
+	const fullText = titleElement.innerText.trim();
+	if (fullText.includes(" - ")) {
+		const [seriesName, seasonName] = fullText.split(" - ").map((part) => part.trim());
+		return {
+			seriesName,
+			seasonName
+		};
+	}
+	return {
+		seriesName: fullText,
+		seasonName: null
+	};
+};
+const getMovieTitle = (el) => {
+	return el.querySelector("h1").innerText.split(`(`)[0].trim();
+};
+const getMovieGenres = (el) => {
+	return el.querySelector(".genres").textContent.split(" / ");
+};
+const getMovieOrigins = (el) => {
+	return el.querySelector(".origin").textContent.split(",")[0].split(" / ");
+};
+const getMovieColorRating = (bodyClasses) => {
+	return getColor(bodyClasses[1]);
+};
+const getMovieRating = (el) => {
+	const rating = el.querySelector(".film-rating-average").textContent?.replace(/%/g, "").trim();
+	const ratingInt = parseInt(rating);
+	if (Number.isInteger(ratingInt)) return ratingInt;
+	else return null;
+};
+const getMovieRatingCount = (el) => {
+	const ratingCount = +(el.querySelector(".box-rating-container .counter")?.textContent)?.replace(/[(\s)]/g, "");
+	if (Number.isInteger(ratingCount)) return ratingCount;
+	else return null;
+};
+const getMovieYear = (jsonLd) => {
+	if (jsonLd && jsonLd.dateCreated) return +jsonLd.dateCreated;
+	return null;
+};
+const getMovieDuration = (jsonLd, el) => {
+	if (jsonLd && jsonLd.duration) try {
+		return parseISO8601Duration(jsonLd.duration);
+	} catch (e) {}
+	try {
+		const timeString = el.querySelector(".origin").innerText.split(",");
+		if (timeString.length > 2) {
+			const hoursMins = timeString.pop().trim().split("(")[0].trim().split("min")[0].split("h");
+			return hoursMins.length > 1 ? +hoursMins[0] * 60 + +hoursMins[1] : +hoursMins[0];
+		} else return null;
+	} catch (error) {
+		return null;
+	}
+};
+const getMovieTitlesOther = (el) => {
+	const namesNode = el.querySelectorAll(".film-names li");
+	if (!namesNode.length) return [];
+	return namesNode.map((el) => {
+		const country = el.querySelector("img.flag").attributes.alt;
+		const title = el.textContent.trim().split("\n")[0];
+		if (country && title) return {
+			country,
+			title
+		};
+		else return null;
+	}).filter((x) => x);
+};
+const getMoviePoster = (el) => {
+	const poster = el.querySelector(".film-posters img");
+	if (poster) if (poster.classNames?.includes("empty-image")) return null;
+	else return addProtocol(poster.attributes.src.split("?")[0].replace(/\/w140\//, "/w1080/"));
+	else return null;
+};
+const getMovieRandomPhoto = (el) => {
+	const image = el.querySelector(".gallery-item picture img")?.attributes?.src;
+	if (image) return image.replace(/\/w663\//, "/w1326/");
+	else return null;
+};
+const getMovieTrivia = (el) => {
+	const triviaNodes = el.querySelectorAll(".article-trivia ul li");
+	if (triviaNodes?.length) return triviaNodes.map((node) => node.textContent.trim().replace(/(\r\n|\n|\r|\t)/gm, ""));
+	else return null;
+};
+const getMovieDescriptions = (el) => {
+	return el.querySelectorAll(".body--plots .plot-full p, .body--plots .plots .plots-item p").map((movie) => movie.textContent?.trim().replace(/(\r\n|\n|\r|\t)/gm, ""));
+};
+const parseMoviePeople = (el) => {
+	return el.querySelectorAll("a").filter((x) => x.classNames.length === 0).map((person) => {
+		return {
+			id: parseIdFromUrl(person.attributes.href),
+			name: person.innerText.trim(),
+			url: `https://www.csfd.cz${person.attributes.href}`
+		};
+	});
+};
+const getMovieCreators = (el, options) => {
+	const creators = {
+		directors: [],
+		writers: [],
+		cinematography: [],
+		music: [],
+		actors: [],
+		basedOn: [],
+		producers: [],
+		filmEditing: [],
+		costumeDesign: [],
+		productionDesign: []
+	};
+	const groups = el.querySelectorAll(".creators h4");
+	const localizedLabels = [
+		"directors",
+		"writers",
+		"cinematography",
+		"music",
+		"actors",
+		"basedOn",
+		"producers",
+		"filmEditing",
+		"costumeDesign",
+		"productionDesign"
+	].map((key) => ({
+		key,
+		label: getLocalizedCreatorLabel(options?.language, key)
+	}));
+	for (const group of groups) {
+		const text = group.textContent.trim();
+		for (const { key, label } of localizedLabels) if (text.includes(label)) {
+			if (group.parentNode) creators[key] = parseMoviePeople(group.parentNode);
+			break;
+		}
+	}
+	return creators;
+};
+const getSeasonsOrEpisodes = (el) => {
+	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");
+		const href = nameContainer?.getAttribute("href");
+		const url = href ? href.startsWith("/") ? `https://www.csfd.cz${href}` : href : null;
+		return {
+			id: parseLastIdFromUrl(href || ""),
+			title: nameContainer?.textContent?.trim() || null,
+			url,
+			info: infoContainer?.textContent?.replace(/[{()}]/g, "").trim() || null
+		};
+	});
+};
+const getEpisodeCode = (el) => {
+	const filmHeaderName = el.querySelector(".film-header-name h1");
+	if (!filmHeaderName) return null;
+	const match = (filmHeaderName.textContent?.trim() || "").match(/\(([^)]+)\)/);
+	return match ? match[1] : null;
+};
+const detectSeasonOrEpisodeListType = (el) => {
+	const headerText = el.querySelector(".box-header h3")?.innerText.trim() ?? "";
+	if (headerText.includes("Série")) return "seasons";
+	if (headerText.startsWith("Epizody")) return "episodes";
+	return null;
+};
+const getSeasonOrEpisodeParent = (el) => {
+	let parents = el.querySelectorAll(".film-header h2 a");
+	if (parents.length === 0) parents = el.querySelectorAll(".film-header h1 a");
+	if (parents.length === 0) return null;
+	const [parentSeries, parentSeason] = parents;
+	const seriesId = parseIdFromUrl(parentSeries?.getAttribute("href"));
+	const seasonId = parseLastIdFromUrl(parentSeason?.getAttribute("href") || "");
+	const seriesTitle = parentSeries?.textContent?.trim() || null;
+	const seasonTitle = parentSeason?.textContent?.trim() || null;
+	const series = seriesId && seriesTitle ? {
+		id: seriesId,
+		title: seriesTitle
+	} : null;
+	const season = seasonId && seasonTitle ? {
+		id: seasonId,
+		title: seasonTitle
+	} : null;
+	if (!series && !season) return null;
+	return {
+		series,
+		season
+	};
+};
+const getMovieType = (el) => {
+	return parseFilmType(el.querySelector(".film-header-name .type")?.innerText?.replace(/[{()}]/g, "") || "film");
+};
+const getMovieVods = (el) => {
+	let vods = [];
+	if (el) vods = el.querySelectorAll(".box-buttons-vod .vod-badge a").map((btn) => {
+		return {
+			title: btn.textContent.trim(),
+			url: btn.attributes.href
+		};
+	});
+	return vods.length ? vods : [];
+};
+const getBoxContent = (el, box) => {
+	return el.querySelectorAll("section.box .box-header").find((header) => header.querySelector("h3")?.textContent.trim().includes(box))?.parentNode;
+};
+const getMovieBoxMovies = (el, boxName) => {
+	const movieListItem = [];
+	const movieTitleNodes = getBoxContent(el, boxName)?.querySelectorAll(".article-header .film-title-name");
+	if (movieTitleNodes?.length) for (const item of movieTitleNodes) movieListItem.push({
+		id: parseIdFromUrl(item.attributes.href),
+		title: item.textContent.trim(),
+		url: `https://www.csfd.cz${item.attributes.href}`
+	});
+	return movieListItem;
+};
+const getMoviePremieres = (el) => {
+	const premiereNodes = el.querySelectorAll(".box-premieres li");
+	const premiere = [];
+	for (const premiereNode of premiereNodes) {
+		const title = premiereNode.querySelector("p + span").attributes.title;
+		if (title) {
+			const [dateRaw, ...company] = title?.split(" ");
+			const date = parseDate(dateRaw);
+			if (date) premiere.push({
+				country: premiereNode.querySelector(".flag")?.attributes.title || null,
+				format: premiereNode.querySelector("p").textContent.trim()?.split(" od")[0],
+				date,
+				company: company.join(" ")
+			});
+		}
+	}
+	return premiere;
+};
+const getMovieTags = (el) => {
+	return el.querySelectorAll(".box-content a[href*=\"/tag/\"]").map((tag) => tag.textContent);
+};
+
+//#endregion
+export { detectSeasonOrEpisodeListType, getEpisodeCode, getMovieBoxMovies, getMovieColorRating, getMovieCreators, getMovieDescriptions, getMovieDuration, getMovieGenres, getMovieOrigins, getMoviePoster, getMoviePremieres, getMovieRandomPhoto, getMovieRating, getMovieRatingCount, getMovieTags, getMovieTitle, getMovieTitlesOther, getMovieTrivia, getMovieType, getMovieVods, getMovieYear, getSeasonOrEpisodeParent, getSeasonsOrEpisodes, getSeriesAndSeasonTitle };

package/src/helpers/search-creator.helper.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { addProtocol } from "./global.helper.mjs";
+
+//#region src/helpers/search-creator.helper.ts
+const getCreatorName = (el) => {
+	return el.querySelector(".user-title").text.trim();
+};
+const getCreatorImage = (el) => {
+	const image = el.querySelector("img").attributes.src;
+	return addProtocol(image);
+};
+const getCreatorUrl = (el) => {
+	return el.querySelector(".user-title a").attributes.href;
+};
+
+//#endregion
+export { getCreatorImage, getCreatorName, getCreatorUrl };

package/src/helpers/search-user.helper.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { addProtocol } from "./global.helper.mjs";
+import { NodeType } from "node-html-parser";
+
+//#region src/helpers/search-user.helper.ts
+const getUser = (el) => {
+	return el.querySelector(".user-title-name").text;
+};
+const getUserRealName = (el) => {
+	const p = el.querySelector(".article-content p");
+	if (!p) return null;
+	const textNodes = p.childNodes.filter((n) => n.nodeType === NodeType.TEXT_NODE && n.rawText.trim() !== "");
+	return textNodes.length ? textNodes[0].rawText.trim() : null;
+};
+const getAvatar = (el) => {
+	const image = el.querySelector(".article-img img").attributes.src;
+	return addProtocol(image);
+};
+const getUserUrl = (el) => {
+	return el.querySelector(".user-title-name").attributes.href;
+};
+
+//#endregion
+export { getAvatar, getUser, getUserRealName, getUserUrl };

package/src/helpers/search.helper.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { addProtocol, parseColor, parseFilmType, parseIdFromUrl } from "./global.helper.mjs";
+
+//#region src/helpers/search.helper.ts
+const getSearchType = (el) => {
+	const type = el.querySelectorAll(".film-title-info .info")[1];
+	return parseFilmType(type?.innerText?.replace(/[{()}]/g, "")?.trim() || "film");
+};
+const getSearchTitle = (el) => {
+	return el.querySelector(".film-title-name").text;
+};
+const getSearchYear = (el) => {
+	return +el.querySelectorAll(".film-title-info .info")[0]?.innerText.replace(/[{()}]/g, "");
+};
+const getSearchUrl = (el) => {
+	return el.querySelector(".film-title-name").attributes.href;
+};
+const getSearchColorRating = (el) => {
+	return parseColor(el.querySelector(".article-header i.icon").classNames.split(" ").pop());
+};
+const getSearchPoster = (el) => {
+	const image = el.querySelector("img").attributes.src;
+	return addProtocol(image);
+};
+const getSearchOrigins = (el) => {
+	const originsRaw = el.querySelector(".article-content p .info")?.text;
+	if (!originsRaw) return [];
+	return (originsRaw?.split(", ")?.[0])?.split("/").map((country) => country.trim());
+};
+const parseSearchPeople = (el, type) => {
+	let who;
+	if (type === "directors") who = "Režie:";
+	if (type === "actors") who = "Hrají:";
+	const peopleNode = Array.from(el && el.querySelectorAll(".article-content p")).find((el) => el.textContent.includes(who));
+	if (peopleNode) return Array.from(peopleNode.querySelectorAll("a")).map((person) => {
+		return {
+			id: parseIdFromUrl(person.attributes.href),
+			name: person.innerText.trim(),
+			url: `https://www.csfd.cz${person.attributes.href}`
+		};
+	});
+	else return [];
+};
+
+//#endregion
+export { getSearchColorRating, getSearchOrigins, getSearchPoster, getSearchTitle, getSearchType, getSearchUrl, getSearchYear, parseSearchPeople };

package/src/helpers/user-ratings.helper.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { parseColor, parseDate, parseFilmType, parseIdFromUrl } from "./global.helper.mjs";
+
+//#region src/helpers/user-ratings.helper.ts
+const getUserRatingId = (el) => {
+	const url = el.querySelector("td.name .film-title-name").attributes.href;
+	return parseIdFromUrl(url);
+};
+const getUserRating = (el) => {
+	const ratingText = el.querySelector("td.star-rating-only .stars").classNames.split(" ").pop();
+	return ratingText.includes("stars-") ? +ratingText.split("-").pop() : 0;
+};
+const getUserRatingType = (el) => {
+	const typeNode = el.querySelector("td.name .film-title-info .info ~ .info");
+	return parseFilmType(typeNode ? typeNode.text : "film");
+};
+const getUserRatingTitle = (el) => {
+	return el.querySelector("td.name .film-title-name").text;
+};
+const getUserRatingYear = (el) => {
+	const yearNode = el.querySelector("td.name .film-title-info .info");
+	return yearNode ? +yearNode.text || null : null;
+};
+const getUserRatingColorRating = (el) => {
+	return parseColor(el.querySelector("td.name .icon").classNames.split(" ").pop());
+};
+const getUserRatingDate = (el) => {
+	return parseDate(el.querySelector("td.date-only").text.trim());
+};
+const getUserRatingUrl = (el) => {
+	return `https://www.csfd.cz${el.querySelector("td.name .film-title-name").attributes.href}`;
+};
+
+//#endregion
+export { getUserRating, getUserRatingColorRating, getUserRatingDate, getUserRatingId, getUserRatingTitle, getUserRatingType, getUserRatingUrl, getUserRatingYear };

package/src/helpers/user-reviews.helper.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { parseColor, parseDate, parseFilmType, parseIdFromUrl } from "./global.helper.mjs";
+
+//#region src/helpers/user-reviews.helper.ts
+const getUserReviewId = (el) => {
+	const url = el.querySelector(".film-title-name").attributes.href;
+	return parseIdFromUrl(url);
+};
+const getUserReviewRating = (el) => {
+	const ratingText = el.querySelector(".star-rating .stars").classNames.split(" ").pop();
+	return ratingText.includes("stars-") ? +ratingText.split("-").pop() : 0;
+};
+const getUserReviewType = (el) => {
+	const typeNode = el.querySelector(".film-title-info .info ~ .info");
+	return parseFilmType(typeNode ? typeNode.text.slice(1, -1) : "film");
+};
+const getUserReviewTitle = (el) => {
+	return el.querySelector(".film-title-name").text;
+};
+const getUserReviewYear = (el) => {
+	const infoSpan = el.querySelector(".film-title-info .info");
+	return infoSpan ? +infoSpan.text.replace(/[()]/g, "") || null : null;
+};
+const getUserReviewColorRating = (el) => {
+	return parseColor(el.querySelector(".film-title-inline i.icon")?.classNames.split(" ").pop());
+};
+const getUserReviewDate = (el) => {
+	return parseDate(el.querySelector(".article-header-date-content .info time").text.trim());
+};
+const getUserReviewUrl = (el) => {
+	return `https://www.csfd.cz${el.querySelector(".film-title-name").attributes.href}`;
+};
+const getUserReviewText = (el) => {
+	return el.querySelector(".comment").text.trim();
+};
+const getUserReviewPoster = (el) => {
+	const img = el.querySelector(".article-img img");
+	const srcset = img?.attributes.srcset;
+	if (srcset) {
+		const poster3x = srcset.split(",").map((s) => s.trim()).find((s) => s.endsWith("3x"));
+		if (poster3x) return `https:${poster3x.replace(/\s+3x$/, "").trim()}`;
+	}
+	const src = img?.attributes.src;
+	return src ? `https:${src}` : null;
+};
+
+//#endregion
+export { getUserReviewColorRating, getUserReviewDate, getUserReviewId, getUserReviewPoster, getUserReviewRating, getUserReviewText, getUserReviewTitle, getUserReviewType, getUserReviewUrl, getUserReviewYear };

package/src/index.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { CinemaScraper } from "./services/cinema.service.mjs";
+import { CreatorScraper } from "./services/creator.service.mjs";
+import { MovieScraper } from "./services/movie.service.mjs";
+import { SearchScraper } from "./services/search.service.mjs";
+import { UserRatingsScraper } from "./services/user-ratings.service.mjs";
+import { UserReviewsScraper } from "./services/user-reviews.service.mjs";
+
+//#region src/index.ts
+var Csfd = class {
+	constructor(userRatingsService, userReviewsService, movieService, creatorService, searchService, cinemaService, defaultOptions) {
+		this.userRatingsService = userRatingsService;
+		this.userReviewsService = userReviewsService;
+		this.movieService = movieService;
+		this.creatorService = creatorService;
+		this.searchService = searchService;
+		this.cinemaService = cinemaService;
+		this.defaultOptions = defaultOptions;
+	}
+	setOptions({ request, language }) {
+		if (request !== void 0) this.defaultOptions = {
+			...this.defaultOptions,
+			request
+		};
+		if (language !== void 0) this.defaultOptions = {
+			...this.defaultOptions,
+			language
+		};
+	}
+	async userRatings(user, config, options) {
+		const opts = options ?? this.defaultOptions;
+		return this.userRatingsService.userRatings(user, config, opts);
+	}
+	async userReviews(user, config, options) {
+		const opts = options ?? this.defaultOptions;
+		return this.userReviewsService.userReviews(user, config, opts);
+	}
+	async movie(movie, options) {
+		const opts = options ?? this.defaultOptions;
+		return this.movieService.movie(+movie, opts);
+	}
+	async creator(creator, options) {
+		const opts = options ?? this.defaultOptions;
+		return this.creatorService.creator(+creator, opts);
+	}
+	async search(text, options) {
+		const opts = options ?? this.defaultOptions;
+		return this.searchService.search(text, opts);
+	}
+	async cinema(district, period, options) {
+		const opts = options ?? this.defaultOptions;
+		return this.cinemaService.cinemas(+district, period, opts);
+	}
+};
+const movieScraper = new MovieScraper();
+const userRatingsScraper = new UserRatingsScraper();
+const userReviewsScraper = new UserReviewsScraper();
+const cinemaScraper = new CinemaScraper();
+const creatorScraper = new CreatorScraper();
+const searchScraper = new SearchScraper();
+const csfd = new Csfd(userRatingsScraper, userReviewsScraper, movieScraper, creatorScraper, searchScraper, cinemaScraper);
+
+//#endregion
+export { csfd };

package/src/services/cinema.service.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { fetchPage } from "../fetchers/index.mjs";
+import { cinemasUrl } from "../vars.mjs";
+import { getCinemaCoords, getCinemaId, getCinemaUrl, getGroupedFilmsByDate, parseCinema } from "../helpers/cinema.helper.mjs";
+import { parse } from "node-html-parser";
+
+//#region src/services/cinema.service.ts
+var CinemaScraper = class {
+	async cinemas(district = 1, period = "today", options) {
+		const contentNode = parse(await fetchPage(cinemasUrl(district, period, { language: options?.language }), { ...options?.request })).querySelectorAll("#snippet--cinemas section[id*=\"cinema-\"]");
+		return this.buildCinemas(contentNode);
+	}
+	buildCinemas(contentNode) {
+		const cinemas = [];
+		contentNode.forEach((x) => {
+			const cinemaInfo = parseCinema(x);
+			const cinema = {
+				id: getCinemaId(x),
+				name: cinemaInfo?.name,
+				city: cinemaInfo?.city,
+				url: getCinemaUrl(x),
+				coords: getCinemaCoords(x),
+				screenings: getGroupedFilmsByDate(x)
+			};
+			cinemas.push(cinema);
+		});
+		return cinemas;
+	}
+};
+
+//#endregion
+export { CinemaScraper };

package/src/services/creator.service.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { fetchPage } from "../fetchers/index.mjs";
+import { creatorUrl } from "../vars.mjs";
+import { getCreatorBio, getCreatorBirthdayInfo, getCreatorFilms, getCreatorName, getCreatorPhoto } from "../helpers/creator.helper.mjs";
+import { parse } from "node-html-parser";
+
+//#region src/services/creator.service.ts
+var CreatorScraper = class {
+	async creator(creatorId, options) {
+		const id = Number(creatorId);
+		if (isNaN(id)) throw new Error("node-csfd-api: creatorId must be a valid number");
+		const creatorHtml = parse(await fetchPage(creatorUrl(id, { language: options?.language }), { ...options?.request }));
+		const asideNode = creatorHtml.querySelector(".creator-about");
+		const filmsNode = creatorHtml.querySelector(".creator-filmography");
+		return this.buildCreator(+creatorId, asideNode, filmsNode);
+	}
+	buildCreator(id, asideEl, filmsNode) {
+		const birthdayInfo = getCreatorBirthdayInfo(asideEl);
+		return {
+			id,
+			name: getCreatorName(asideEl),
+			birthday: birthdayInfo?.birthday,
+			birthplace: birthdayInfo?.birthPlace,
+			photo: getCreatorPhoto(asideEl),
+			age: birthdayInfo?.age || null,
+			bio: getCreatorBio(asideEl),
+			films: getCreatorFilms(filmsNode)
+		};
+	}
+};
+
+//#endregion
+export { CreatorScraper };

package/src/services/movie.service.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { fetchPage } from "../fetchers/index.mjs";
+import { movieUrl } from "../vars.mjs";
+import { detectSeasonOrEpisodeListType, getEpisodeCode, getMovieBoxMovies, getMovieColorRating, getMovieCreators, getMovieDescriptions, getMovieDuration, getMovieGenres, getMovieOrigins, getMoviePoster, getMoviePremieres, getMovieRandomPhoto, getMovieRating, getMovieRatingCount, getMovieTags, getMovieTitle, getMovieTitlesOther, getMovieTrivia, getMovieType, getMovieVods, getMovieYear, getSeasonOrEpisodeParent, getSeasonsOrEpisodes, getSeriesAndSeasonTitle } from "../helpers/movie.helper.mjs";
+import { parse } from "node-html-parser";
+
+//#region src/services/movie.service.ts
+var MovieScraper = class {
+	async movie(movieId, options) {
+		const id = Number(movieId);
+		if (isNaN(id)) throw new Error("node-csfd-api: movieId must be a valid number");
+		const movieHtml = parse(await fetchPage(movieUrl(id, { language: options?.language }), { ...options?.request }));
+		const pageClasses = movieHtml.querySelector(".page-content").classNames.split(" ");
+		const asideNode = movieHtml.querySelector(".aside-movie-profile");
+		const movieNode = movieHtml.querySelector(".main-movie-profile");
+		const jsonLdString = movieHtml.querySelector("script[type=\"application/ld+json\"]").innerText;
+		let jsonLd = null;
+		try {
+			jsonLd = JSON.parse(jsonLdString);
+		} catch (e) {
+			console.error("node-csfd-api: Error parsing JSON-LD", e);
+		}
+		return this.buildMovie(+movieId, movieNode, asideNode, pageClasses, jsonLd, options);
+	}
+	buildMovie(movieId, el, asideEl, pageClasses, jsonLd, options) {
+		const type = getMovieType(el);
+		const { seriesName = null, seasonName = null } = type === "season" ? getSeriesAndSeasonTitle(el) : {};
+		const seasonOrEpisodeListType = detectSeasonOrEpisodeListType(el);
+		return {
+			id: movieId,
+			title: type === "season" && seriesName ? seriesName : getMovieTitle(el),
+			year: getMovieYear(jsonLd),
+			duration: getMovieDuration(jsonLd, el),
+			descriptions: getMovieDescriptions(el),
+			genres: getMovieGenres(el),
+			type,
+			url: movieUrl(movieId, { language: options?.language }),
+			origins: getMovieOrigins(el),
+			colorRating: getMovieColorRating(pageClasses),
+			rating: getMovieRating(asideEl),
+			ratingCount: getMovieRatingCount(asideEl),
+			titlesOther: getMovieTitlesOther(el),
+			poster: getMoviePoster(el),
+			photo: getMovieRandomPhoto(el),
+			trivia: getMovieTrivia(el),
+			creators: getMovieCreators(el, options),
+			vod: getMovieVods(asideEl),
+			tags: getMovieTags(asideEl),
+			premieres: getMoviePremieres(asideEl),
+			related: getMovieBoxMovies(asideEl, "Související"),
+			similar: getMovieBoxMovies(asideEl, "Podobné"),
+			seasons: seasonOrEpisodeListType === "seasons" ? getSeasonsOrEpisodes(el) : null,
+			episodes: seasonOrEpisodeListType === "episodes" ? getSeasonsOrEpisodes(el) : null,
+			parent: type === "season" || type === "episode" ? getSeasonOrEpisodeParent(el) : null,
+			episodeCode: type === "episode" ? getEpisodeCode(el) : null,
+			seasonName
+		};
+	}
+};
+
+//#endregion
+export { MovieScraper };