node-csfd-api-racintom 1.0.0

package/server.ts

@@ -0,0 +1,66 @@
+import express from 'express';
+import packageJson from './package.json';
+import { csfd } from './src';
+import { CSFDFilmTypes } from './src/interfaces/global';
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+app.get('/', (_, res) => {
+  res.json({
+    name: packageJson.name,
+    version: packageJson.version,
+    docs: packageJson.homepage,
+    links: ['/movie/:id', '/creator/:id', '/search/:query', '/user-ratings/:id']
+  });
+});
+
+app.get(['/movie/', '/creator/', '/search/', '/user-ratings/'], (req, res) => {
+  res.json({ error: `ID is missing. Provide ID like this: ${req.url}${req.url.endsWith('/') ? '' : '/'}1234` });
+});
+
+app.get('/movie/:id', async (req, res) => {
+  try {
+    const movie = await csfd.movie(+req.params.id);
+    res.json(movie);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch movie data' });
+  }
+});
+
+app.get('/creator/:id', async (req, res) => {
+  try {
+    const result = await csfd.creator(+req.params.id);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch creator data: ' + error });
+  }
+});
+
+app.get('/search/:query', async (req, res) => {
+  try {
+    const result = await csfd.search(req.params.query);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch search data: ' + error });
+  }
+});
+
+app.get('/user-ratings/:id', async (req, res) => {
+  const { allPages, allPagesDelay, excludes, includesOnly } = req.query;
+  try {
+    const result = await csfd.userRatings(req.params.id, {
+      allPages: allPages === 'true',
+      allPagesDelay: allPagesDelay ? +allPagesDelay : undefined,
+      excludes: excludes ? (excludes as string).split(',') as CSFDFilmTypes[] : undefined,
+      includesOnly: includesOnly ? (includesOnly as string).split(',') as CSFDFilmTypes[] : undefined
+    });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch user-ratings data: ' + error });
+  }
+});
+
+app.listen(port, () => {
+  console.log(`API is running on http://localhost:${port}`);
+});

package/src/fetchers/fetch.polyfill.ts

@@ -0,0 +1,7 @@
+// Check if `fetch` is available in global scope (nodejs 18+) or in window (browser). If not, use cross-fetch polyfill.
+import { fetch as crossFetch } from 'cross-fetch';
+export const fetchSafe =
+  (typeof fetch === 'function' && fetch) || // ServiceWorker fetch (Cloud Functions + Chrome extension)
+  (typeof global === 'object' && global.fetch) || // Node.js 18+ fetch
+  (typeof window !== 'undefined' && window.fetch) || // Browser fetch
+  crossFetch; // Polyfill fetch

package/src/fetchers/index.ts

@@ -0,0 +1,25 @@
+import { fetchSafe } from './fetch.polyfill';
+
+const USER_AGENTS = [
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36',
+  'Mozilla/5.0 (iPhone; CPU iPhone OS 14_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/87.0.4280.77 Mobile/15E148 Safari/604.1',
+  'Mozilla/5.0 (Linux; Android 10; SM-A205U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.101 Mobile Safari/537.36',
+  'Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.101 Mobile Safari/537.36'
+];
+
+const headers = {
+  'User-Agent': USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)]
+};
+
+export const fetchPage = async (url: string): Promise<string> => {
+  try {
+    const response = await fetchSafe(url, { headers });
+    if (response.status >= 400 && response.status < 600) {
+      throw new Error(`node-csfd-api: Bad response ${response.status} for url: ${url}`);
+    }
+    return await response.text();
+  } catch (e) {
+    console.error(e);
+    return 'Error';
+  }
+};

package/src/helpers/creator.helper.ts

@@ -0,0 +1,95 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDCreatorScreening } from '../interfaces/creator.interface';
+import { CSFDColorRating } from '../interfaces/global';
+import { Colors } from '../interfaces/user-ratings.interface';
+import { addProtocol, parseColor, parseIdFromUrl } from './global.helper';
+
+export const getColorRating = (el: HTMLElement): CSFDColorRating => {
+  return parseColor(el?.classNames.split(' ').pop() as Colors);
+};
+
+export const getId = (url: string): number => {
+  if (url) {
+    return parseIdFromUrl(url);
+  }
+  return null;
+};
+
+export const getName = (el: HTMLElement | null): string => {
+  return el.querySelector('h1').innerText.trim();
+};
+
+export const getBirthdayInfo = (
+  el: HTMLElement | null
+): { birthday: string; age: number; birthPlace: string } => {
+  const infoBlock = el.querySelector('h1 + p');
+  const text = infoBlock?.innerHTML.trim();
+
+  const birthPlaceRow = infoBlock?.querySelector('.info-place')?.innerHTML.trim();
+  const ageRow = infoBlock?.querySelector('.info')?.innerHTML.trim();
+
+  let birthday: string = '';
+
+  if (text) {
+    const parts = text.split('\n');
+    const birthdayRow = parts.find((x) => x.includes('nar.'));
+    birthday = birthdayRow ? parseBirthday(birthdayRow) : '';
+  }
+
+  const age = ageRow ? +parseAge(ageRow) : null;
+  const birthPlace = birthPlaceRow ? parseBirthPlace(birthPlaceRow) : '';
+
+  return { birthday, age, birthPlace };
+};
+
+export const getBio = (el: HTMLElement | null): string => {
+  return el.querySelector('.article-content p')?.text.trim().split('\n')[0].trim() || null;
+};
+
+export const getPhoto = (el: HTMLElement | null): string => {
+  const image = el.querySelector('img').attributes.src;
+  return addProtocol(image);
+};
+
+export const parseBirthday = (text: string): any => {
+  return text.replace(/nar./g, '').trim();
+};
+
+export const parseAge = (text: string): any => {
+  return text.trim().replace(/\(/g, '').replace(/let\)/g, '').trim();
+};
+
+export const parseBirthPlace = (text: string): any => {
+  return text.trim().replace(/<br>/g, '').trim();
+};
+
+export const getFilms = (el: HTMLElement | null): CSFDCreatorScreening[] => {
+  const filmNodes = el.querySelectorAll('.box')[0]?.querySelectorAll('table tr');
+  let yearCache: number;
+  const films = filmNodes.map((filmNode) => {
+    const id = getId(filmNode.querySelector('td.name .film-title-name')?.attributes.href);
+    const title = filmNode.querySelector('.name')?.text.trim();
+    const year = +filmNode.querySelector('.year')?.text.trim();
+    const colorRating = getColorRating(filmNode.querySelector('.name .icon'));
+
+    // Cache year from previous film because there is a gap between movies with same year
+    if (year) {
+      yearCache = +year;
+    }
+
+    if (id && title) {
+      return {
+        id,
+        title,
+        year: year || yearCache,
+        colorRating
+      };
+    }
+    return {};
+  });
+  // Remove empty objects
+  const filmsUnique = films.filter(
+    (value) => Object.keys(value).length !== 0
+  ) as CSFDCreatorScreening[];
+  return filmsUnique;
+};

package/src/helpers/global.helper.ts

@@ -0,0 +1,70 @@
+import { CSFDColorRating } from '../interfaces/global';
+import { Colors } from '../interfaces/user-ratings.interface';
+
+export const parseIdFromUrl = (url: string): number => {
+  if (url) {
+    const idSlug = url?.split('/')[2];
+    const id = idSlug?.split('-')[0];
+    return +id || null;
+  } else {
+    return null;
+  }
+};
+
+export const getColor = (cls: string): CSFDColorRating => {
+  switch (cls) {
+    case 'page-lightgrey':
+      return 'unknown';
+    case 'page-red':
+      return 'good';
+    case 'page-blue':
+      return 'average';
+    case 'page-grey':
+      return 'bad';
+    default:
+      return 'unknown';
+  }
+};
+
+export const parseColor = (quality: Colors): CSFDColorRating => {
+  switch (quality) {
+    case 'lightgrey':
+      return 'unknown';
+    case 'red':
+      return 'good';
+    case 'blue':
+      return 'average';
+    case 'grey':
+      return 'bad';
+    default:
+      return 'unknown';
+  }
+};
+
+export const addProtocol = (url: string): string => {
+  return url.startsWith('//') ? 'https:' + url : url;
+};
+
+export const getDuration = (matches: any[]) => {
+  return {
+    sign: matches[1] === undefined ? '+' : '-',
+    years: matches[2] === undefined ? 0 : matches[2],
+    months: matches[3] === undefined ? 0 : matches[3],
+    weeks: matches[4] === undefined ? 0 : matches[4],
+    days: matches[5] === undefined ? 0 : matches[5],
+    hours: matches[6] === undefined ? 0 : matches[6],
+    minutes: matches[7] === undefined ? 0 : matches[7],
+    seconds: matches[8] === undefined ? 0 : matches[8]
+  };
+};
+
+export const parseISO8601Duration = (iso: string): number => {
+  const iso8601DurationRegex =
+    /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
+
+  const matches = iso.match(iso8601DurationRegex);
+
+  const duration = getDuration(matches);
+
+  return +duration.minutes;
+};

package/src/helpers/movie.helper.ts

@@ -0,0 +1,276 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating } from '../interfaces/global';
+import {
+  CSFDBoxContent,
+  CSFDCreator,
+  CSFDCreatorGroups,
+  CSFDGenres,
+  CSFDMovieListItem,
+  CSFDPremiere, CSFDSeasons,
+  CSFDTitlesOther,
+  CSFDVod,
+  CSFDVodService
+} from '../interfaces/movie.interface';
+import { addProtocol, getColor, parseISO8601Duration, parseIdFromUrl } from './global.helper';
+
+export const getId = (el: HTMLElement): number => {
+  const url = el.querySelector('.tabs .tab-nav-list a').attributes.href;
+  return parseIdFromUrl(url);
+};
+
+export const getTitle = (el: HTMLElement): string => {
+  return el.querySelector('h1').innerText.split(`(`)[0].trim();
+};
+
+export const getGenres = (el: HTMLElement): CSFDGenres[] => {
+  const genresRaw = el.querySelector('.genres').textContent;
+  return genresRaw.split(' / ') as CSFDGenres[];
+};
+
+export const getOrigins = (el: HTMLElement): string[] => {
+  const originsRaw = el.querySelector('.origin').textContent;
+  const origins = originsRaw.split(',')[0];
+  return origins.split(' / ');
+};
+
+export const getColorRating = (bodyClasses: string[]): CSFDColorRating => {
+  return getColor(bodyClasses[1]);
+};
+
+export const getRating = (el: HTMLElement): number => {
+  const ratingRaw = el.querySelector('.film-rating-average').textContent;
+  const rating = ratingRaw?.replace(/%/g, '').trim();
+  const ratingInt = parseInt(rating);
+
+  if (Number.isInteger(ratingInt)) {
+    return ratingInt;
+  } else {
+    return null;
+  }
+};
+
+export const getRatingCount = (el: HTMLElement): number => {
+  const ratingCountRaw = el.querySelector('.box-rating-container .counter')?.textContent;
+  const ratingCount = +ratingCountRaw?.replace(/[(\s)]/g, '');
+  if (Number.isInteger(ratingCount)) {
+    return ratingCount;
+  } else {
+    return null;
+  }
+};
+
+export const getYear = (el: string): number => {
+  try {
+    const jsonLd = JSON.parse(el);
+    return +jsonLd.dateCreated;
+  } catch (error) {
+    console.error('node-csfd-api: Error parsing JSON-LD', error);
+    return null;
+  }
+};
+
+export const getDuration = (jsonLdRaw: string, el: HTMLElement): number => {
+  let duration = null;
+  try {
+    const jsonLd = JSON.parse(jsonLdRaw);
+    duration = jsonLd.duration;
+    return parseISO8601Duration(duration);
+  } catch (error) {
+    const origin = el.querySelector('.origin').innerText;
+    const timeString = origin.split(',');
+    if (timeString.length > 2) {
+      // Get last time elelment
+      const timeString2 = timeString.pop().trim();
+      // Clean it
+      const timeRaw = timeString2.split('(')[0].trim();
+      // Split by minutes and hours
+      const hoursMinsRaw = timeRaw.split('min')[0];
+      const hoursMins = hoursMinsRaw.split('h');
+      // Resolve hours + minutes format
+      duration = hoursMins.length > 1 ? +hoursMins[0] * 60 + +hoursMins[1] : +hoursMins[0];
+      return duration;
+    } else {
+      return null;
+    }
+  }
+};
+
+export const getTitlesOther = (el: HTMLElement): CSFDTitlesOther[] => {
+  const namesNode = el.querySelectorAll('.film-names li');
+
+  if (!namesNode.length) {
+    return [];
+  }
+
+  const titlesOther = 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;
+    }
+  });
+
+  return titlesOther.filter((x) => x);
+};
+
+export const getPoster = (el: HTMLElement | null): string => {
+  const poster = el.querySelector('.film-posters img');
+  // Resolve empty image
+  if (poster) {
+    if (poster.classNames?.includes('empty-image')) {
+      return null;
+    } else {
+      // Full sized image (not thumb)
+      const imageThumb = poster.attributes.src.split('?')[0];
+      const image = imageThumb.replace(/\/w140\//, '/w1080/');
+      return addProtocol(image);
+    }
+  } else {
+    return null;
+  }
+};
+
+export const getRandomPhoto = (el: HTMLElement | null): string => {
+  const imageNode = el.querySelector('.gallery-item picture img');
+  const image = imageNode?.attributes?.src;
+  if (image) {
+    return image.replace(/\/w663\//, '/w1326/');
+  } else {
+    return null;
+  }
+};
+
+export const getTrivia = (el: HTMLElement | null): string[] => {
+  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;
+  }
+};
+
+export const getDescriptions = (el: HTMLElement): string[] => {
+  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, ''));
+};
+
+export const parsePeople = (el: HTMLElement): CSFDCreator[] => {
+  const people = el.querySelectorAll('a');
+  return (
+    people
+      // Filter out "more" links
+      .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}`
+        };
+      })
+  );
+};
+
+export const getGroup = (el: HTMLElement, group: CSFDCreatorGroups): CSFDCreator[] => {
+  const creators = el.querySelectorAll('.creators h4');
+  const element = creators.filter((elem) => elem.textContent.trim().includes(group))[0];
+  if (element?.parentNode) {
+    return parsePeople(element.parentNode as HTMLElement);
+  } else {
+    return [];
+  }
+};
+
+export const getType = (el: HTMLElement): string => {
+  const type = el.querySelector('.film-header-name .type');
+  return type?.innerText?.replace(/[{()}]/g, '') || 'film';
+};
+
+export const getVods = (el: HTMLElement | null): CSFDVod[] => {
+  let vods: CSFDVod[] = [];
+  if (el) {
+    const buttons = el.querySelectorAll('.box-buttons .button');
+    const buttonsVod = buttons.filter((x) => !x.classNames.includes('button-social'));
+    vods = buttonsVod.map((btn) => {
+      return {
+        title: btn.textContent.trim() as CSFDVodService,
+        url: btn.attributes.href
+      };
+    });
+  }
+  return vods.length ? vods : [];
+};
+
+// Get box content
+export const getBoxContent = (el: HTMLElement, box: string): HTMLElement => {
+  const headers = el.querySelectorAll('section.box .box-header');
+  return headers.find((header) => header.querySelector('h3').textContent.trim().includes(box))
+    ?.parentNode;
+};
+
+export const getBoxMovies = (el: HTMLElement, boxName: CSFDBoxContent): CSFDMovieListItem[] => {
+  const movieListItem: CSFDMovieListItem[] = [];
+  const box = getBoxContent(el, boxName);
+  const movieTitleNodes = box?.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;
+};
+
+export const getPremieres = (el: HTMLElement): CSFDPremiere[] => {
+  const premiereNodes = el.querySelectorAll('.box-premieres li');
+  const premiere: CSFDPremiere[] = [];
+  for (const premiereNode of premiereNodes) {
+    const title = premiereNode.querySelector('p + span').attributes.title;
+
+    if (title) {
+      const [date, ...company] = title?.split(' ');
+
+      premiere.push({
+        country: premiereNode.querySelector('.flag')?.attributes.title || null,
+        format: premiereNode.querySelector('p').textContent.trim()?.split(' od')[0],
+        date,
+        company: company.join(' ')
+      });
+    }
+  }
+  return premiere;
+};
+
+export const getTags = (el: HTMLElement): string[] => {
+  const tagsRaw = el.querySelectorAll('.box-content a[href*="/podrobne-vyhledavani/?tag="]');
+  return tagsRaw.map((tag) => tag.textContent);
+};
+
+export const getSeasonsInfo = (el: HTMLElement): CSFDSeasons => {
+  const seasonsList = el.querySelector('.film-episodes-list')
+  if (seasonsList === null) {
+    return null
+  }
+
+  const seasons = seasonsList.querySelectorAll('.film-title')
+
+  return seasons.map(season => {
+    const nameContainer = season.querySelector('.film-title-name')
+    const infoContainer = season.querySelector('.film-title-info')
+
+    return {
+      linkToDetail: nameContainer.getAttribute('href'),
+      name: nameContainer.textContent,
+      additionalInfo: infoContainer.textContent
+    }
+  })
+}

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

@@ -0,0 +1,19 @@
+import { HTMLElement } from 'node-html-parser';
+import { addProtocol } from './global.helper';
+
+export const getUser = (el: HTMLElement): string => {
+  return el.querySelector('.user-title-name').text;
+};
+
+export const getUserRealName = (el: HTMLElement): string => {
+  return el.querySelector('.user-real-name')?.text.trim() || null;
+};
+
+export const getAvatar = (el: HTMLElement): string => {
+  const image = el.querySelector('.article-img img').attributes.src;
+  return addProtocol(image);
+};
+
+export const getUserUrl = (el: HTMLElement): string => {
+  return el.querySelector('.user-title-name').attributes.href;
+};

package/src/helpers/search.helper.ts

@@ -0,0 +1,66 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating, CSFDFilmTypes } from '../interfaces/global';
+import { CSFDCreator } from '../interfaces/movie.interface';
+import { Colors } from '../interfaces/user-ratings.interface';
+import { addProtocol, parseColor, parseIdFromUrl } from './global.helper';
+
+type Creator = 'Režie:' | 'Hrají:';
+
+export const getType = (el: HTMLElement): CSFDFilmTypes => {
+  const type = el.querySelectorAll('.film-title-info .info')[1];
+  return (type?.innerText.replace(/[{()}]/g, '') || 'film') as CSFDFilmTypes;
+};
+
+export const getTitle = (el: HTMLElement): string => {
+  return el.querySelector('.film-title-name').text;
+};
+
+export const getYear = (el: HTMLElement): number => {
+  return +el.querySelectorAll('.film-title-info .info')[0]?.innerText.replace(/[{()}]/g, '');
+};
+
+export const getUrl = (el: HTMLElement): string => {
+  return el.querySelector('.film-title-name').attributes.href;
+};
+
+export const getColorRating = (el: HTMLElement): CSFDColorRating => {
+  return parseColor(
+    el.querySelector('.article-header i.icon').classNames.split(' ').pop() as Colors
+  );
+};
+
+export const getPoster = (el: HTMLElement): string => {
+  const image = el.querySelector('img').attributes.src;
+  return addProtocol(image);
+};
+
+export const getOrigins = (el: HTMLElement): string[] => {
+  const originsRaw = el.querySelector('.article-content p .info')?.text;
+  if (!originsRaw) return [];
+  const originsAll = originsRaw?.split(', ')?.[0];
+  return originsAll?.split('/').map((country) => country.trim());
+};
+
+export const parsePeople = (el: HTMLElement, type: 'directors' | 'actors'): CSFDCreator[] => {
+  let who: Creator;
+  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) {
+    const people = Array.from(peopleNode.querySelectorAll('a')) as unknown as HTMLElement[];
+
+    return people.map((person) => {
+      return {
+        id: parseIdFromUrl(person.attributes.href),
+        name: person.innerText.trim(),
+        url: `https://www.csfd.cz${person.attributes.href}`
+      };
+    });
+  } else {
+    return [];
+  }
+};

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

@@ -0,0 +1,62 @@
+import { HTMLElement } from 'node-html-parser';
+import { CSFDColorRating, CSFDFilmTypes, CSFDStars } from '../interfaces/global';
+import { Colors } from '../interfaces/user-ratings.interface';
+import { parseIdFromUrl } from './global.helper';
+
+export const getId = (el: HTMLElement): number => {
+  const url = el.querySelector('td.name .film-title-name').attributes.href;
+  return parseIdFromUrl(url);
+};
+
+export const getUserRating = (el: HTMLElement): CSFDStars => {
+  const ratingText = el.querySelector('td.star-rating-only .stars').classNames.split(' ').pop();
+
+  const rating = ratingText.includes('stars-') ? +ratingText.split('-').pop() : 0;
+  return rating as CSFDStars;
+};
+
+export const getType = (el: HTMLElement): CSFDFilmTypes => {
+  const typeText = el.querySelectorAll('td.name .film-title-info .info');
+
+  return (typeText.length > 1 ? typeText[1].text.slice(1, -1) : 'film') as CSFDFilmTypes;
+};
+
+export const getTitle = (el: HTMLElement): string => {
+  return el.querySelector('td.name .film-title-name').text;
+};
+
+export const getYear = (el: HTMLElement): number => {
+  return +el.querySelectorAll('td.name .film-title-info .info')[0]?.text.slice(1, -1) || null;
+};
+
+export const getColorRating = (el: HTMLElement): CSFDColorRating => {
+  const color = parseColor(el.querySelector('td.name .icon').classNames.split(' ').pop() as Colors);
+  return color;
+};
+
+export const getDate = (el: HTMLElement): string => {
+  return el.querySelector('td.date-only').text.trim();
+};
+
+export const getUrl = (el: HTMLElement): string => {
+  const url = el.querySelector('td.name .film-title-name').attributes.href;
+  return `https://www.csfd.cz${url}`;
+};
+
+export const parseColor = (quality: Colors): CSFDColorRating => {
+  switch (quality) {
+    case 'lightgrey':
+      return 'unknown';
+    case 'red':
+      return 'good';
+    case 'blue':
+      return 'average';
+    case 'grey':
+      return 'bad';
+    default:
+      return 'unknown';
+  }
+};
+
+// Sleep in loop
+export const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));