node-csfd-api 3.0.0-next.21 → 3.0.0-next.22

package/esm/services/cinema.service.js

@@ -0,0 +1,30 @@
+import { parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import { cinemasUrl } from '../vars';
+import { getCinemaId, getCinemaUrl, getCoords, getGroupedFilmsByDate, parseCinema } from './../helpers/cinema.helper';
+export class CinemaScraper {
+    async cinemas(district = 1, period = 'today') {
+        const url = cinemasUrl(district, period);
+        const response = await fetchPage(url);
+        const cinemasHtml = parse(response);
+        const contentNode = cinemasHtml.querySelectorAll('#snippet--cinemas section.box');
+        this.buildCinemas(contentNode);
+        return this.cinema;
+    }
+    buildCinemas(contentNode) {
+        const cinemas = [];
+        contentNode.forEach((x) => {
+            const cinemaInfo = parseCinema(x);
+            const cinema = {
+                id: getCinemaId(x),
+                name: cinemaInfo === null || cinemaInfo === void 0 ? void 0 : cinemaInfo.name,
+                city: cinemaInfo === null || cinemaInfo === void 0 ? void 0 : cinemaInfo.city,
+                url: getCinemaUrl(x),
+                coords: getCoords(x),
+                screenings: getGroupedFilmsByDate(x)
+            };
+            cinemas.push(cinema);
+        });
+        this.cinema = cinemas;
+    }
+}

package/esm/services/creator.service.js

@@ -0,0 +1,28 @@
+import { parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import { getBio, getBirthdayInfo, getFilms, getName, getPhoto } from '../helpers/creator.helper';
+import { creatorUrl } from '../vars';
+export class CreatorScraper {
+    async creator(creatorId) {
+        const url = creatorUrl(+creatorId);
+        const response = await fetchPage(url);
+        const creatorHtml = parse(response);
+        const asideNode = creatorHtml.querySelector('.creator-about');
+        const filmsNode = creatorHtml.querySelector('.creator-filmography');
+        this.buildCreator(+creatorId, asideNode, filmsNode);
+        return this.person;
+    }
+    buildCreator(id, asideEl, filmsNode) {
+        var _a, _b, _c;
+        this.person = {
+            id,
+            name: getName(asideEl),
+            birthday: (_a = getBirthdayInfo(asideEl)) === null || _a === void 0 ? void 0 : _a.birthday,
+            birthplace: (_b = getBirthdayInfo(asideEl)) === null || _b === void 0 ? void 0 : _b.birthPlace,
+            photo: getPhoto(asideEl),
+            age: ((_c = getBirthdayInfo(asideEl)) === null || _c === void 0 ? void 0 : _c.age) || null,
+            bio: getBio(asideEl),
+            films: getFilms(filmsNode)
+        };
+    }
+}

package/esm/services/movie.service.js

@@ -0,0 +1,54 @@
+import { parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import { getBoxMovies, getColorRating, getDescriptions, getDuration, getGenres, getGroup, getOrigins, getPoster, getPremieres, getRandomPhoto, getRating, getRatingCount, getTags, getTitle, getTitlesOther, getTrivia, getType, getVods, getYear } from '../helpers/movie.helper';
+import { movieUrl } from '../vars';
+export class MovieScraper {
+    async movie(movieId) {
+        const url = movieUrl(+movieId);
+        const response = await fetchPage(url);
+        const movieHtml = parse(response);
+        const pageClasses = movieHtml.querySelector('.page-content').classNames.split(' ');
+        const asideNode = movieHtml.querySelector('.aside-movie-profile');
+        const movieNode = movieHtml.querySelector('.main-movie-profile');
+        const jsonLd = movieHtml.querySelector('script[type="application/ld+json"]').innerText;
+        this.buildMovie(+movieId, movieNode, asideNode, pageClasses, jsonLd);
+        return this.film;
+    }
+    buildMovie(movieId, el, asideEl, pageClasses, jsonLd) {
+        this.film = {
+            id: movieId,
+            title: getTitle(el),
+            year: getYear(jsonLd),
+            duration: getDuration(jsonLd, el),
+            descriptions: getDescriptions(el),
+            genres: getGenres(el),
+            type: getType(el),
+            url: movieUrl(movieId),
+            origins: getOrigins(el),
+            colorRating: getColorRating(pageClasses),
+            rating: getRating(asideEl),
+            ratingCount: getRatingCount(asideEl),
+            titlesOther: getTitlesOther(el),
+            poster: getPoster(el),
+            photo: getRandomPhoto(el),
+            trivia: getTrivia(el),
+            creators: {
+                directors: getGroup(el, 'Režie'),
+                writers: getGroup(el, 'Scénář'),
+                cinematography: getGroup(el, 'Kamera'),
+                music: getGroup(el, 'Hudba'),
+                actors: getGroup(el, 'Hrají'),
+                basedOn: getGroup(el, 'Předloha'),
+                producers: getGroup(el, 'Produkce'),
+                filmEditing: getGroup(el, 'Střih'),
+                costumeDesign: getGroup(el, 'Kostýmy'),
+                productionDesign: getGroup(el, 'Scénografie')
+            },
+            vod: getVods(asideEl),
+            tags: getTags(asideEl),
+            premieres: getPremieres(asideEl),
+            related: getBoxMovies(asideEl, 'Související'),
+            similar: getBoxMovies(asideEl, 'Podobné')
+        };
+    }
+}

package/esm/services/search.service.js

@@ -0,0 +1,76 @@
+import { parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import { parseIdFromUrl } from '../helpers/global.helper';
+import { getAvatar, getUser, getUserRealName, getUserUrl } from '../helpers/search-user.helper';
+import { getColorRating, getOrigins, getPoster, getTitle, getType, getUrl, getYear, parsePeople } from '../helpers/search.helper';
+import { searchUrl } from '../vars';
+export class SearchScraper {
+    async search(text) {
+        const url = searchUrl(text);
+        const response = await fetchPage(url);
+        const html = parse(response);
+        const moviesNode = html.querySelectorAll('.main-movies article');
+        const usersNode = html.querySelectorAll('.main-users article');
+        const tvSeriesNode = html.querySelectorAll('.main-series article');
+        return this.parseSearch(moviesNode, usersNode, tvSeriesNode);
+    }
+    parseSearch(moviesNode, usersNode, tvSeriesNode) {
+        const movies = [];
+        const users = [];
+        const tvSeries = [];
+        moviesNode.forEach((m) => {
+            const url = getUrl(m);
+            const movie = {
+                id: parseIdFromUrl(url),
+                title: getTitle(m),
+                year: getYear(m),
+                url: `https://www.csfd.cz${url}`,
+                type: getType(m),
+                colorRating: getColorRating(m),
+                poster: getPoster(m),
+                origins: getOrigins(m),
+                creators: {
+                    directors: parsePeople(m, 'directors'),
+                    actors: parsePeople(m, 'actors')
+                }
+            };
+            movies.push(movie);
+        });
+        usersNode.forEach((m) => {
+            const url = getUserUrl(m);
+            const user = {
+                id: parseIdFromUrl(url),
+                user: getUser(m),
+                userRealName: getUserRealName(m),
+                avatar: getAvatar(m),
+                url: `https://www.csfd.cz${url}`
+            };
+            users.push(user);
+        });
+        tvSeriesNode.forEach((m) => {
+            const url = getUrl(m);
+            const user = {
+                id: parseIdFromUrl(url),
+                title: getTitle(m),
+                year: getYear(m),
+                url: `https://www.csfd.cz${url}`,
+                type: getType(m),
+                colorRating: getColorRating(m),
+                poster: getPoster(m),
+                origins: getOrigins(m),
+                creators: {
+                    directors: parsePeople(m, 'directors'),
+                    actors: parsePeople(m, 'actors')
+                }
+            };
+            tvSeries.push(user);
+        });
+        const search = {
+            movies: movies,
+            users: users,
+            tvSeries: tvSeries,
+            creators: []
+        };
+        return search;
+    }
+}

package/esm/services/user-ratings.service.js

@@ -0,0 +1,80 @@
+import { parse } from 'node-html-parser';
+import { fetchPage } from '../fetchers';
+import { getColorRating, getDate, getId, getTitle, getType, getUrl, getUserRating, getYear, sleep } from '../helpers/user-ratings.helper';
+import { userRatingsUrl } from '../vars';
+export class UserRatingsScraper {
+    constructor() {
+        this.films = [];
+    }
+    async userRatings(user, config) {
+        let allMovies = [];
+        const url = userRatingsUrl(user);
+        const response = await fetchPage(url);
+        const items = parse(response);
+        const movies = items.querySelectorAll('.box-user-rating .table-container tbody tr');
+        // Get number of pages
+        const pagesNode = items.querySelector('.pagination');
+        const pages = +(pagesNode === null || pagesNode === void 0 ? void 0 : pagesNode.childNodes[pagesNode.childNodes.length - 4].rawText) || 1;
+        allMovies = this.getPage(config, movies);
+        if (config === null || config === void 0 ? void 0 : config.allPages) {
+            console.log('User', user, url);
+            console.log('Fetching all pages', pages);
+            for (let i = 2; i <= pages; i++) {
+                console.log('Fetching page', i, 'out of', pages, '...');
+                const url = userRatingsUrl(user, i);
+                const response = await fetchPage(url);
+                const items = parse(response);
+                const movies = items.querySelectorAll('.box-user-rating .table-container tbody tr');
+                allMovies = [...this.getPage(config, movies)];
+                // Sleep
+                if (config.allPagesDelay) {
+                    await sleep(config.allPagesDelay);
+                }
+            }
+            return allMovies;
+        }
+        return allMovies;
+    }
+    getPage(config, movies) {
+        var _a, _b, _c, _d;
+        if (config) {
+            if (((_a = config.includesOnly) === null || _a === void 0 ? void 0 : _a.length) && ((_b = config.excludes) === null || _b === void 0 ? void 0 : _b.length)) {
+                console.warn(`node-csfd-api:
+        You can not use both parameters 'includesOnly' and 'excludes'.
+        Parameter 'includesOnly' will be used now:`, config.includesOnly);
+            }
+        }
+        for (const el of movies) {
+            const type = getType(el);
+            // Filtering includesOnly
+            if ((_c = config === null || config === void 0 ? void 0 : config.includesOnly) === null || _c === void 0 ? void 0 : _c.length) {
+                if (config.includesOnly.some((include) => type === include)) {
+                    this.buildUserRatings(el);
+                }
+                // Filter exludes
+            }
+            else if ((_d = config === null || config === void 0 ? void 0 : config.excludes) === null || _d === void 0 ? void 0 : _d.length) {
+                if (!config.excludes.some((exclude) => type === exclude)) {
+                    this.buildUserRatings(el);
+                }
+            }
+            else {
+                // Without filtering
+                this.buildUserRatings(el);
+            }
+        }
+        return this.films;
+    }
+    buildUserRatings(el) {
+        this.films.push({
+            id: getId(el),
+            title: getTitle(el),
+            year: getYear(el),
+            type: getType(el),
+            url: getUrl(el),
+            colorRating: getColorRating(el),
+            userDate: getDate(el),
+            userRating: getUserRating(el)
+        });
+    }
+}

package/esm/types/fetchers/fetch.polyfill.d.ts

@@ -0,0 +1 @@
+export declare const fetchSafe: typeof fetch;

package/esm/types/fetchers/index.d.ts

@@ -0,0 +1 @@
+export declare const fetchPage: (url: string) => Promise<string>;

package/esm/types/helpers/cinema.helper.d.ts

@@ -0,0 +1,18 @@
+import { CSFDCinemaGroupedFilmsByDate, CSFDCinemaMeta, CSFDCinemaMovie } from 'interfaces/cinema.interface';
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating } from '../interfaces/global';
+export declare const getColorRating: (el: HTMLElement) => CSFDColorRating;
+export declare const getCinemaId: (el: HTMLElement | null) => number;
+export declare const getId: (url: string) => number | null;
+export declare const getCoords: (el: HTMLElement | null) => {
+    lat: number;
+    lng: number;
+} | null;
+export declare const getCinemaUrl: (el: HTMLElement | null) => string;
+export declare const parseCinema: (el: HTMLElement | null) => {
+    city: string;
+    name: string;
+};
+export declare const getGroupedFilmsByDate: (el: HTMLElement | null) => CSFDCinemaGroupedFilmsByDate[];
+export declare const getFilms: (date: string, el: HTMLElement | null) => CSFDCinemaMovie[];
+export declare const parseMeta: (meta: string[]) => CSFDCinemaMeta[];

package/esm/types/helpers/creator.helper.d.ts

@@ -0,0 +1,17 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDCreatorScreening } from '../interfaces/creator.interface';
+import { CSFDColorRating } from '../interfaces/global';
+export declare const getColorRating: (el: HTMLElement) => CSFDColorRating;
+export declare const getId: (url: string) => number;
+export declare const getName: (el: HTMLElement | null) => string;
+export declare const getBirthdayInfo: (el: HTMLElement | null) => {
+    birthday: string;
+    age: number;
+    birthPlace: string;
+};
+export declare const getBio: (el: HTMLElement | null) => string;
+export declare const getPhoto: (el: HTMLElement | null) => string;
+export declare const parseBirthday: (text: string) => any;
+export declare const parseAge: (text: string) => any;
+export declare const parseBirthPlace: (text: string) => any;
+export declare const getFilms: (el: HTMLElement | null) => CSFDCreatorScreening[];

package/esm/types/helpers/global.helper.d.ts

@@ -0,0 +1,17 @@
+import { CSFDColorRating } from '../interfaces/global';
+import { Colors } from '../interfaces/user-ratings.interface';
+export declare const parseIdFromUrl: (url: string) => number;
+export declare const getColor: (cls: string) => CSFDColorRating;
+export declare const parseColor: (quality: Colors) => CSFDColorRating;
+export declare const addProtocol: (url: string) => string;
+export declare const getDuration: (matches: any[]) => {
+    sign: string;
+    years: any;
+    months: any;
+    weeks: any;
+    days: any;
+    hours: any;
+    minutes: any;
+    seconds: any;
+};
+export declare const parseISO8601Duration: (iso: string) => number;

package/esm/types/helpers/movie.helper.d.ts

@@ -0,0 +1,25 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating } from '../interfaces/global';
+import { CSFDBoxContent, CSFDCreator, CSFDCreatorGroups, CSFDGenres, CSFDMovieListItem, CSFDPremiere, CSFDTitlesOther, CSFDVod } from '../interfaces/movie.interface';
+export declare const getId: (el: HTMLElement) => number;
+export declare const getTitle: (el: HTMLElement) => string;
+export declare const getGenres: (el: HTMLElement) => CSFDGenres[];
+export declare const getOrigins: (el: HTMLElement) => string[];
+export declare const getColorRating: (bodyClasses: string[]) => CSFDColorRating;
+export declare const getRating: (el: HTMLElement) => number;
+export declare const getRatingCount: (el: HTMLElement) => number;
+export declare const getYear: (el: string) => number;
+export declare const getDuration: (jsonLdRaw: string, el: HTMLElement) => number;
+export declare const getTitlesOther: (el: HTMLElement) => CSFDTitlesOther[];
+export declare const getPoster: (el: HTMLElement | null) => string;
+export declare const getRandomPhoto: (el: HTMLElement | null) => string;
+export declare const getTrivia: (el: HTMLElement | null) => string[];
+export declare const getDescriptions: (el: HTMLElement) => string[];
+export declare const parsePeople: (el: HTMLElement) => CSFDCreator[];
+export declare const getGroup: (el: HTMLElement, group: CSFDCreatorGroups) => CSFDCreator[];
+export declare const getType: (el: HTMLElement) => string;
+export declare const getVods: (el: HTMLElement | null) => CSFDVod[];
+export declare const getBoxContent: (el: HTMLElement, box: string) => HTMLElement;
+export declare const getBoxMovies: (el: HTMLElement, boxName: CSFDBoxContent) => CSFDMovieListItem[];
+export declare const getPremieres: (el: HTMLElement) => CSFDPremiere[];
+export declare const getTags: (el: HTMLElement) => string[];

package/esm/types/helpers/search-user.helper.d.ts

@@ -0,0 +1,5 @@
+import { HTMLElement } from 'node-html-parser';
+export declare const getUser: (el: HTMLElement) => string;
+export declare const getUserRealName: (el: HTMLElement) => string;
+export declare const getAvatar: (el: HTMLElement) => string;
+export declare const getUserUrl: (el: HTMLElement) => string;

package/esm/types/helpers/search.helper.d.ts

@@ -0,0 +1,11 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating, CSFDFilmTypes } from '../interfaces/global';
+import { CSFDCreator } from '../interfaces/movie.interface';
+export declare const getType: (el: HTMLElement) => CSFDFilmTypes;
+export declare const getTitle: (el: HTMLElement) => string;
+export declare const getYear: (el: HTMLElement) => number;
+export declare const getUrl: (el: HTMLElement) => string;
+export declare const getColorRating: (el: HTMLElement) => CSFDColorRating;
+export declare const getPoster: (el: HTMLElement) => string;
+export declare const getOrigins: (el: HTMLElement) => string[];
+export declare const parsePeople: (el: HTMLElement, type: "directors" | "actors") => CSFDCreator[];

package/esm/types/helpers/user-ratings.helper.d.ts

@@ -0,0 +1,13 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating, CSFDFilmTypes, CSFDStars } from '../interfaces/global';
+import { Colors } from '../interfaces/user-ratings.interface';
+export declare const getId: (el: HTMLElement) => number;
+export declare const getUserRating: (el: HTMLElement) => CSFDStars;
+export declare const getType: (el: HTMLElement) => CSFDFilmTypes;
+export declare const getTitle: (el: HTMLElement) => string;
+export declare const getYear: (el: HTMLElement) => number;
+export declare const getColorRating: (el: HTMLElement) => CSFDColorRating;
+export declare const getDate: (el: HTMLElement) => string;
+export declare const getUrl: (el: HTMLElement) => string;
+export declare const parseColor: (quality: Colors) => CSFDColorRating;
+export declare const sleep: (ms: number) => Promise<unknown>;

package/esm/types/index.d.ts

@@ -0,0 +1,24 @@
+import { CSFDCinema, CSFDCinemaPeriod } from 'interfaces/cinema.interface';
+import { CSFDCreator } from './interfaces/creator.interface';
+import { CSFDMovie } from './interfaces/movie.interface';
+import { CSFDSearch } from './interfaces/search.interface';
+import { CSFDUserRatingConfig, CSFDUserRatings } from './interfaces/user-ratings.interface';
+import { CinemaScraper } from './services/cinema.service';
+import { CreatorScraper } from './services/creator.service';
+import { MovieScraper } from './services/movie.service';
+import { SearchScraper } from './services/search.service';
+import { UserRatingsScraper } from './services/user-ratings.service';
+export declare class Csfd {
+    private userRatingsService;
+    private movieService;
+    private creatorService;
+    private searchService;
+    private cinemaService;
+    constructor(userRatingsService: UserRatingsScraper, movieService: MovieScraper, creatorService: CreatorScraper, searchService: SearchScraper, cinemaService: CinemaScraper);
+    userRatings(user: string | number, config?: CSFDUserRatingConfig): Promise<CSFDUserRatings[]>;
+    movie(movie: number): Promise<CSFDMovie>;
+    creator(creator: number): Promise<CSFDCreator>;
+    search(text: string): Promise<CSFDSearch>;
+    cinema(district: number | string, period: CSFDCinemaPeriod): Promise<CSFDCinema[]>;
+}
+export declare const csfd: Csfd;

package/esm/types/interfaces/cinema.interface.d.ts

@@ -0,0 +1,23 @@
+import { CSFDMovieListItem } from './movie.interface';
+export interface CSFDCinema {
+    id: number;
+    name: string;
+    city: string;
+    url: string;
+    coords: {
+        lat: number;
+        lng: number;
+    };
+    region?: string;
+    screenings: CSFDCinemaGroupedFilmsByDate[];
+}
+export interface CSFDCinemaGroupedFilmsByDate {
+    date: string;
+    films: CSFDCinemaMovie[];
+}
+export interface CSFDCinemaMovie extends CSFDMovieListItem {
+    meta: CSFDCinemaMeta[];
+    showTimes: string[];
+}
+export type CSFDCinemaMeta = 'dubbing' | '3D' | 'subtitles' | string;
+export type CSFDCinemaPeriod = 'today' | 'weekend' | 'week' | 'tomorrow' | 'month';

package/esm/types/interfaces/creator.interface.d.ts

@@ -0,0 +1,12 @@
+import { CSFDScreening } from './global';
+export interface CSFDCreator {
+    id: number;
+    name: string;
+    birthday: string;
+    birthplace: string;
+    photo: string;
+    age: number | string;
+    bio: string;
+    films: CSFDCreatorScreening[];
+}
+export type CSFDCreatorScreening = Omit<CSFDScreening, 'url' | 'type'>;

package/esm/types/interfaces/global.d.ts

@@ -0,0 +1,22 @@
+export interface CSFDScreening {
+    id: number;
+    title: string;
+    year: number;
+    url: string;
+    type: CSFDFilmTypes;
+    /**
+     * Overall aggregated rating. (On the web usually represented by colors).
+     *
+     * 'unknown': unknown (gray color)
+     *
+     * 'good': 70% – 100 % (red color)
+     *
+     * 'average': 30% - 69% (blue color)
+     *
+     * 'bad': 0% - 29% (black color)
+     */
+    colorRating: CSFDColorRating;
+}
+export type CSFDColorRating = 'bad' | 'average' | 'good' | 'unknown';
+export type CSFDStars = 0 | 1 | 2 | 3 | 4 | 5;
+export type CSFDFilmTypes = 'film' | 'TV film' | 'pořad' | 'seriál' | 'divadelní záznam' | 'koncert' | 'série' | 'studentský film' | 'amatérský film' | 'hudební videoklip' | 'epizoda';

package/esm/types/interfaces/movie.interface.d.ts

@@ -0,0 +1,66 @@
+import { CSFDScreening } from './global';
+export interface CSFDMovie extends CSFDScreening {
+    rating: number | null;
+    poster: string;
+    photo: string;
+    ratingCount: number | null;
+    duration: number | string;
+    titlesOther: CSFDTitlesOther[];
+    origins: string[];
+    descriptions: string[];
+    trivia: string[];
+    genres: CSFDGenres[] | string[];
+    creators: CSFDCreators;
+    vod: CSFDVod[];
+    tags: string[];
+    premieres: CSFDPremiere[];
+    related: CSFDMovieListItem[];
+    similar: CSFDMovieListItem[];
+}
+export type CSFDVodService = 'Netflix' | 'hbogo' | 'Prime Video' | 'Apple TV+' | 'iTunes' | 'KVIFF.TV' | 'Edisonline' | 'o2tv' | 'SledovaniTV' | 'Starmax' | 'DAFilms' | 'FILMY ČESKY A ZADARMO' | 'Youtube Česká filmová klasika' | 'VAPET' | 'VOREL FILM' | 'ivysilani' | 'Google Play' | 'Voyo' | 'DVD';
+export interface CSFDVod {
+    title: CSFDVodService;
+    url: string;
+}
+export interface CSFDCreators {
+    directors: CSFDCreator[];
+    writers: CSFDCreator[];
+    cinematography: CSFDCreator[];
+    music: CSFDCreator[];
+    actors: CSFDCreator[];
+    basedOn: CSFDCreator[];
+    producers: CSFDCreator[];
+    filmEditing: CSFDCreator[];
+    costumeDesign: CSFDCreator[];
+    productionDesign: CSFDCreator[];
+}
+export interface CSFDTitlesOther {
+    country: string;
+    title: string;
+}
+export interface CSFDCreator {
+    /**
+     * CSFD person ID.
+     *
+     * You can always assemble url from ID like this:
+     *
+     * `https://www.csfd.cz/tvurce/${id}`
+     */
+    id: number;
+    name: string;
+    url: string;
+}
+export interface CSFDMovieListItem {
+    id: number;
+    title: string;
+    url: string;
+}
+export type CSFDGenres = 'Akční' | 'Animovaný' | 'Dobrodružný' | 'Dokumentární' | 'Drama' | 'Experimentální' | 'Fantasy' | 'Film-Noir' | 'Historický' | 'Horor' | 'Hudební' | 'IMAX' | 'Katastrofický' | 'Komedie' | 'Krátkometrážní' | 'Krimi' | 'Loutkový' | 'Muzikál' | 'Mysteriózní' | 'Naučný' | 'Podobenství' | 'Poetický' | 'Pohádka' | 'Povídkový' | 'Psychologický' | 'Publicistický' | 'Reality-TV' | 'Road movie' | 'Rodinný' | 'Romantický' | 'Sci-Fi' | 'Soutěžní' | 'Sportovní' | 'Stand-up' | 'Talk-show' | 'Taneční' | 'Telenovela' | 'Thriller' | 'Válečný' | 'Western' | 'Zábavný' | 'Životopisný';
+export type CSFDCreatorGroups = 'Režie' | 'Scénář' | 'Kamera' | 'Hudba' | 'Hrají' | 'Produkce' | 'Střih' | 'Předloha' | 'Scénografie' | 'Kostýmy';
+export interface CSFDPremiere {
+    country: string;
+    format: string;
+    date: string;
+    company: string;
+}
+export type CSFDBoxContent = 'Související' | 'Podobné';

package/esm/types/interfaces/search.interface.d.ts

@@ -0,0 +1,27 @@
+import { CSFDScreening } from './global';
+import { CSFDCreator } from './movie.interface';
+export interface CSFDSearch {
+    movies: CSFDSearchMovie[];
+    tvSeries: CSFDSearchMovie[];
+    creators: CSFDSearchCreator[];
+    users: CSFDSearchUser[];
+}
+export interface CSFDSearchMovie extends CSFDScreening {
+    poster: string;
+    origins: string[];
+    creators: CSFDSearchCreators;
+}
+export interface CSFDSearchUser {
+    id: number;
+    user: string;
+    userRealName: string;
+    avatar: string;
+    url: string;
+}
+export interface CSFDSearchCreator extends CSFDCreator {
+    image: string;
+}
+export interface CSFDSearchCreators {
+    directors: CSFDCreator[];
+    actors: CSFDCreator[];
+}

package/esm/types/interfaces/user-ratings.interface.d.ts

@@ -0,0 +1,18 @@
+import { CSFDFilmTypes, CSFDScreening, CSFDStars } from './global';
+export interface CSFDUserRatings extends CSFDScreening {
+    userRating: CSFDStars;
+    userDate: string;
+}
+export interface CSFDUserRatingConfig {
+    includesOnly?: CSFDFilmTypes[];
+    excludes?: CSFDFilmTypes[];
+    /**
+     * Fetch all ratings. (Warning: Use it wisely. Can be detected and banned. Consider using it together with `allPagesDelay` attribute)
+     */
+    allPages?: boolean;
+    /**
+     * Delay on each page request. In milliseconds
+     */
+    allPagesDelay?: number;
+}
+export type Colors = 'lightgrey' | 'blue' | 'red' | 'grey';

package/esm/types/services/cinema.service.d.ts

@@ -0,0 +1,6 @@
+import { CSFDCinema, CSFDCinemaPeriod } from '../interfaces/cinema.interface';
+export declare class CinemaScraper {
+    private cinema;
+    cinemas(district?: number, period?: CSFDCinemaPeriod): Promise<CSFDCinema[]>;
+    private buildCinemas;
+}

package/esm/types/services/creator.service.d.ts

@@ -0,0 +1,6 @@
+import { CSFDCreator } from '../interfaces/creator.interface';
+export declare class CreatorScraper {
+    private person;
+    creator(creatorId: number): Promise<CSFDCreator>;
+    private buildCreator;
+}

package/esm/types/services/movie.service.d.ts

@@ -0,0 +1,6 @@
+import { CSFDMovie } from '../interfaces/movie.interface';
+export declare class MovieScraper {
+    private film;
+    movie(movieId: number): Promise<CSFDMovie>;
+    private buildMovie;
+}

package/esm/types/services/search.service.d.ts

@@ -0,0 +1,5 @@
+import { CSFDSearch } from '../interfaces/search.interface';
+export declare class SearchScraper {
+    search(text: string): Promise<CSFDSearch>;
+    private parseSearch;
+}

package/esm/types/services/user-ratings.service.d.ts

@@ -0,0 +1,7 @@
+import { CSFDUserRatingConfig, CSFDUserRatings } from '../interfaces/user-ratings.interface';
+export declare class UserRatingsScraper {
+    private films;
+    userRatings(user: string | number, config?: CSFDUserRatingConfig): Promise<CSFDUserRatings[]>;
+    private getPage;
+    private buildUserRatings;
+}

package/esm/types/vars.d.ts

@@ -0,0 +1,6 @@
+import { CSFDCinemaPeriod } from 'interfaces/cinema.interface';
+export declare const userRatingsUrl: (user: string | number, page?: number) => string;
+export declare const movieUrl: (movie: number) => string;
+export declare const creatorUrl: (creator: number | string) => string;
+export declare const cinemasUrl: (district: number | string, period: CSFDCinemaPeriod) => string;
+export declare const searchUrl: (text: string) => string;

package/esm/vars.js

@@ -0,0 +1,7 @@
+export const userRatingsUrl = (user, page) => `https://www.csfd.cz/uzivatel/${encodeURIComponent(user)}/hodnoceni/${page ? '?page=' + page : ''}`;
+export const movieUrl = (movie) => `https://www.csfd.cz/film/${encodeURIComponent(movie)}/prehled/`;
+export const creatorUrl = (creator) => `https://www.csfd.cz/tvurce/${encodeURIComponent(creator)}`;
+export const cinemasUrl = (district, period) => {
+    return `https://www.csfd.cz/kino/?period=${period}&district=${district}`;
+};
+export const searchUrl = (text) => `https://www.csfd.cz/hledat/?q=${encodeURIComponent(text)}`;