Fix errors found by linter

scripts/generators/categoriesGenerator.ts

@@ -1,55 +1,53 @@
-import { Generator } from './generator'
-import { Collection, Storage, Logger } from '@freearhey/core'
-import { Stream, Category, Playlist } from '../models'
-import { PUBLIC_DIR } from '../constants'
-
-type CategoriesGeneratorProps = {
-  streams: Collection
-  categories: Collection
-  logger: Logger
-}
-
-export class CategoriesGenerator implements Generator {
-  streams: Collection
-  categories: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, categories, logger }: CategoriesGeneratorProps) {
-    this.streams = streams
-    this.categories = categories
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate() {
-    const streams = this.streams.orderBy([(stream: Stream) => stream.getTitle()])
-
-    this.categories.forEach(async (category: Category) => {
-      let categoryStreams = streams
-        .filter((stream: Stream) => stream.hasCategory(category))
-        .map((stream: Stream) => {
-          const groupTitle = stream.categories
-            ? stream.categories
-                .map((category: Category) => category.name)
-                .sort()
-                .join(';')
-            : ''
-          stream.groupTitle = groupTitle
-
-          return stream
-        })
-
-      const playlist = new Playlist(categoryStreams, { public: true })
-      const filepath = `categories/${category.id}.m3u`
-      await this.storage.save(filepath, playlist.toString())
-      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-    })
-
-    const undefinedStreams = streams.filter((stream: Stream) => stream.noCategories())
-    const playlist = new Playlist(undefinedStreams, { public: true })
-    const filepath = `categories/undefined.m3u`
-    await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-}
+import { Generator } from './generator'
+import { Collection, Storage, Logger } from '@freearhey/core'
+import { Stream, Category, Playlist } from '../models'
+import { PUBLIC_DIR } from '../constants'
+
+type CategoriesGeneratorProps = {
+  streams: Collection
+  categories: Collection
+  logger: Logger
+}
+
+export class CategoriesGenerator implements Generator {
+  streams: Collection
+  categories: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, categories, logger }: CategoriesGeneratorProps) {
+    this.streams = streams
+    this.categories = categories
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate() {
+    const streams = this.streams.orderBy([(stream: Stream) => stream.getTitle()])
+
+    this.categories.forEach(async (category: Category) => {
+      const categoryStreams = streams
+        .filter((stream: Stream) => stream.hasCategory(category))
+        .map((stream: Stream) => {
+          const streamCategories = stream.categories
+            .map((category: Category) => category.name)
+            .sort()
+          const groupTitle = stream.categories ? streamCategories.join(';') : ''
+          stream.groupTitle = groupTitle
+
+          return stream
+        })
+
+      const playlist = new Playlist(categoryStreams, { public: true })
+      const filepath = `categories/${category.id}.m3u`
+      await this.storage.save(filepath, playlist.toString())
+      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    })
+
+    const undefinedStreams = streams.filter((stream: Stream) => stream.noCategories())
+    const playlist = new Playlist(undefinedStreams, { public: true })
+    const filepath = 'categories/undefined.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+  }
+}

scripts/generators/countriesGenerator.ts

@@ -1,85 +1,85 @@
-import { Generator } from './generator'
-import { Collection, Storage, Logger } from '@freearhey/core'
-import { Country, Region, Subdivision, Stream, Playlist } from '../models'
-import { PUBLIC_DIR } from '../constants'
-
-type CountriesGeneratorProps = {
-  streams: Collection
-  regions: Collection
-  subdivisions: Collection
-  countries: Collection
-  logger: Logger
-}
-
-export class CountriesGenerator implements Generator {
-  streams: Collection
-  countries: Collection
-  regions: Collection
-  subdivisions: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, countries, regions, subdivisions, logger }: CountriesGeneratorProps) {
-    this.streams = streams
-    this.countries = countries
-    this.regions = regions
-    this.subdivisions = subdivisions
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    let streams = this.streams
-      .orderBy([stream => stream.getTitle()])
-      .filter((stream: Stream) => stream.isSFW())
-    let regions = this.regions.filter((region: Region) => region.code !== 'INT')
-
-    this.countries.forEach(async (country: Country) => {
-      const countrySubdivisions = this.subdivisions.filter(
-        (subdivision: Subdivision) => subdivision.country === country.code
-      )
-
-      const countrySubdivisionsCodes = countrySubdivisions.map(
-        (subdivision: Subdivision) => `s/${subdivision.code}`
-      )
-
-      const countryAreaCodes = regions
-        .filter((region: Region) => region.countries.includes(country.code))
-        .map((region: Region) => `r/${region.code}`)
-        .concat(countrySubdivisionsCodes)
-        .add(`c/${country.code}`)
-
-      const countryStreams = streams.filter(stream =>
-        stream.broadcastArea.intersects(countryAreaCodes)
-      )
-
-      if (countryStreams.isEmpty()) return
-
-      const playlist = new Playlist(countryStreams, { public: true })
-      const filepath = `countries/${country.code.toLowerCase()}.m3u`
-      await this.storage.save(filepath, playlist.toString())
-      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-
-      countrySubdivisions.forEach(async (subdivision: Subdivision) => {
-        const subdivisionStreams = streams.filter(stream =>
-          stream.broadcastArea.includes(`s/${subdivision.code}`)
-        )
-
-        if (subdivisionStreams.isEmpty()) return
-
-        const playlist = new Playlist(subdivisionStreams, { public: true })
-        const filepath = `subdivisions/${subdivision.code.toLowerCase()}.m3u`
-        await this.storage.save(filepath, playlist.toString())
-        this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-      })
-    })
-
-    const internationalStreams = streams.filter(stream => stream.isInternational())
-    if (internationalStreams.notEmpty()) {
-      const playlist = new Playlist(internationalStreams, { public: true })
-      const filepath = `countries/int.m3u`
-      await this.storage.save(filepath, playlist.toString())
-      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-    }
-  }
-}
+import { Generator } from './generator'
+import { Collection, Storage, Logger } from '@freearhey/core'
+import { Country, Region, Subdivision, Stream, Playlist } from '../models'
+import { PUBLIC_DIR } from '../constants'
+
+type CountriesGeneratorProps = {
+  streams: Collection
+  regions: Collection
+  subdivisions: Collection
+  countries: Collection
+  logger: Logger
+}
+
+export class CountriesGenerator implements Generator {
+  streams: Collection
+  countries: Collection
+  regions: Collection
+  subdivisions: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, countries, regions, subdivisions, logger }: CountriesGeneratorProps) {
+    this.streams = streams
+    this.countries = countries
+    this.regions = regions
+    this.subdivisions = subdivisions
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    const streams = this.streams
+      .orderBy([stream => stream.getTitle()])
+      .filter((stream: Stream) => stream.isSFW())
+    const regions = this.regions.filter((region: Region) => region.code !== 'INT')
+
+    this.countries.forEach(async (country: Country) => {
+      const countrySubdivisions = this.subdivisions.filter(
+        (subdivision: Subdivision) => subdivision.country === country.code
+      )
+
+      const countrySubdivisionsCodes = countrySubdivisions.map(
+        (subdivision: Subdivision) => `s/${subdivision.code}`
+      )
+
+      const countryAreaCodes = regions
+        .filter((region: Region) => region.countries.includes(country.code))
+        .map((region: Region) => `r/${region.code}`)
+        .concat(countrySubdivisionsCodes)
+        .add(`c/${country.code}`)
+
+      const countryStreams = streams.filter(stream =>
+        stream.broadcastArea.intersects(countryAreaCodes)
+      )
+
+      if (countryStreams.isEmpty()) return
+
+      const playlist = new Playlist(countryStreams, { public: true })
+      const filepath = `countries/${country.code.toLowerCase()}.m3u`
+      await this.storage.save(filepath, playlist.toString())
+      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+
+      countrySubdivisions.forEach(async (subdivision: Subdivision) => {
+        const subdivisionStreams = streams.filter(stream =>
+          stream.broadcastArea.includes(`s/${subdivision.code}`)
+        )
+
+        if (subdivisionStreams.isEmpty()) return
+
+        const playlist = new Playlist(subdivisionStreams, { public: true })
+        const filepath = `subdivisions/${subdivision.code.toLowerCase()}.m3u`
+        await this.storage.save(filepath, playlist.toString())
+        this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+      })
+    })
+
+    const internationalStreams = streams.filter(stream => stream.isInternational())
+    if (internationalStreams.notEmpty()) {
+      const playlist = new Playlist(internationalStreams, { public: true })
+      const filepath = 'countries/int.m3u'
+      await this.storage.save(filepath, playlist.toString())
+      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    }
+  }
+}

scripts/generators/index.ts

@@ -1,10 +1,10 @@
-export * from './categoriesGenerator'
-export * from './countriesGenerator'
-export * from './languagesGenerator'
-export * from './regionsGenerator'
-export * from './indexGenerator'
-export * from './indexNsfwGenerator'
-export * from './indexCategoryGenerator'
-export * from './indexCountryGenerator'
-export * from './indexLanguageGenerator'
-export * from './indexRegionGenerator'
+export * from './categoriesGenerator'
+export * from './countriesGenerator'
+export * from './languagesGenerator'
+export * from './regionsGenerator'
+export * from './indexGenerator'
+export * from './indexNsfwGenerator'
+export * from './indexCategoryGenerator'
+export * from './indexCountryGenerator'
+export * from './indexLanguageGenerator'
+export * from './indexRegionGenerator'

scripts/generators/indexCategoryGenerator.ts

@@ -1,53 +1,53 @@
-import { Generator } from './generator'
-import { Collection, Storage, Logger } from '@freearhey/core'
-import { Stream, Playlist, Category } from '../models'
-import { PUBLIC_DIR } from '../constants'
-
-type IndexCategoryGeneratorProps = {
-  streams: Collection
-  logger: Logger
-}
-
-export class IndexCategoryGenerator implements Generator {
-  streams: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, logger }: IndexCategoryGeneratorProps) {
-    this.streams = streams
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    const streams = this.streams
-      .orderBy(stream => stream.getTitle())
-      .filter(stream => stream.isSFW())
-
-    let groupedStreams = new Collection()
-    streams.forEach((stream: Stream) => {
-      if (stream.noCategories()) {
-        const streamClone = stream.clone()
-        streamClone.groupTitle = 'Undefined'
-        groupedStreams.add(streamClone)
-        return
-      }
-
-      stream.categories.forEach((category: Category) => {
-        const streamClone = stream.clone()
-        streamClone.groupTitle = category.name
-        groupedStreams.push(streamClone)
-      })
-    })
-
-    groupedStreams = groupedStreams.orderBy(stream => {
-      if (stream.groupTitle === 'Undefined') return 'ZZ'
-      return stream.groupTitle
-    })
-
-    const playlist = new Playlist(groupedStreams, { public: true })
-    const filepath = 'index.category.m3u'
-    await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-}
+import { Generator } from './generator'
+import { Collection, Storage, Logger } from '@freearhey/core'
+import { Stream, Playlist, Category } from '../models'
+import { PUBLIC_DIR } from '../constants'
+
+type IndexCategoryGeneratorProps = {
+  streams: Collection
+  logger: Logger
+}
+
+export class IndexCategoryGenerator implements Generator {
+  streams: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, logger }: IndexCategoryGeneratorProps) {
+    this.streams = streams
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    const streams = this.streams
+      .orderBy(stream => stream.getTitle())
+      .filter(stream => stream.isSFW())
+
+    let groupedStreams = new Collection()
+    streams.forEach((stream: Stream) => {
+      if (stream.noCategories()) {
+        const streamClone = stream.clone()
+        streamClone.groupTitle = 'Undefined'
+        groupedStreams.add(streamClone)
+        return
+      }
+
+      stream.categories.forEach((category: Category) => {
+        const streamClone = stream.clone()
+        streamClone.groupTitle = category.name
+        groupedStreams.push(streamClone)
+      })
+    })
+
+    groupedStreams = groupedStreams.orderBy(stream => {
+      if (stream.groupTitle === 'Undefined') return 'ZZ'
+      return stream.groupTitle
+    })
+
+    const playlist = new Playlist(groupedStreams, { public: true })
+    const filepath = 'index.category.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+  }
+}

scripts/generators/indexCountryGenerator.ts

@@ -1,104 +1,104 @@
-import { Generator } from './generator'
-import { Collection, Storage, Logger } from '@freearhey/core'
-import { Stream, Playlist, Country, Subdivision, Region } from '../models'
-import { PUBLIC_DIR } from '../constants'
-
-type IndexCountryGeneratorProps = {
-  streams: Collection
-  regions: Collection
-  countries: Collection
-  subdivisions: Collection
-  logger: Logger
-}
-
-export class IndexCountryGenerator implements Generator {
-  streams: Collection
-  countries: Collection
-  regions: Collection
-  subdivisions: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, regions, countries, subdivisions, logger }: IndexCountryGeneratorProps) {
-    this.streams = streams
-    this.countries = countries
-    this.regions = regions
-    this.subdivisions = subdivisions
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    let groupedStreams = new Collection()
-
-    this.streams
-      .orderBy(stream => stream.getTitle())
-      .filter(stream => stream.isSFW())
-      .forEach(stream => {
-        if (stream.noBroadcastArea()) {
-          const streamClone = stream.clone()
-          streamClone.groupTitle = 'Undefined'
-          groupedStreams.add(streamClone)
-          return
-        }
-
-        if (stream.isInternational()) {
-          const streamClone = stream.clone()
-          streamClone.groupTitle = 'International'
-          groupedStreams.add(streamClone)
-        }
-
-        this.getStreamBroadcastCountries(stream).forEach((country: Country) => {
-          const streamClone = stream.clone()
-          streamClone.groupTitle = country.name
-          groupedStreams.add(streamClone)
-        })
-      })
-
-    groupedStreams = groupedStreams.orderBy((stream: Stream) => {
-      if (stream.groupTitle === 'International') return 'ZZ'
-      if (stream.groupTitle === 'Undefined') return 'ZZZ'
-
-      return stream.groupTitle
-    })
-
-    const playlist = new Playlist(groupedStreams, { public: true })
-    const filepath = 'index.country.m3u'
-    await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-
-  getStreamBroadcastCountries(stream: Stream) {
-    const groupedRegions = this.regions.keyBy((region: Region) => region.code)
-    const groupedCountries = this.countries.keyBy((country: Country) => country.code)
-    const groupedSubdivisions = this.subdivisions.keyBy(
-      (subdivision: Subdivision) => subdivision.code
-    )
-
-    let broadcastCountries = new Collection()
-
-    stream.broadcastArea.forEach(broadcastAreaCode => {
-      const [type, code] = broadcastAreaCode.split('/')
-      switch (type) {
-        case 'c':
-          broadcastCountries.add(code)
-          break
-        case 'r':
-          if (code !== 'INT' && groupedRegions.has(code)) {
-            broadcastCountries = broadcastCountries.concat(groupedRegions.get(code).countries)
-          }
-          break
-        case 's':
-          if (groupedSubdivisions.has(code)) {
-            broadcastCountries.add(groupedSubdivisions.get(code).country)
-          }
-          break
-      }
-    })
-
-    return broadcastCountries
-      .uniq()
-      .map(code => groupedCountries.get(code))
-      .filter(Boolean)
-  }
-}
+import { Generator } from './generator'
+import { Collection, Storage, Logger } from '@freearhey/core'
+import { Stream, Playlist, Country, Subdivision, Region } from '../models'
+import { PUBLIC_DIR } from '../constants'
+
+type IndexCountryGeneratorProps = {
+  streams: Collection
+  regions: Collection
+  countries: Collection
+  subdivisions: Collection
+  logger: Logger
+}
+
+export class IndexCountryGenerator implements Generator {
+  streams: Collection
+  countries: Collection
+  regions: Collection
+  subdivisions: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, regions, countries, subdivisions, logger }: IndexCountryGeneratorProps) {
+    this.streams = streams
+    this.countries = countries
+    this.regions = regions
+    this.subdivisions = subdivisions
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    let groupedStreams = new Collection()
+
+    this.streams
+      .orderBy(stream => stream.getTitle())
+      .filter(stream => stream.isSFW())
+      .forEach(stream => {
+        if (stream.noBroadcastArea()) {
+          const streamClone = stream.clone()
+          streamClone.groupTitle = 'Undefined'
+          groupedStreams.add(streamClone)
+          return
+        }
+
+        if (stream.isInternational()) {
+          const streamClone = stream.clone()
+          streamClone.groupTitle = 'International'
+          groupedStreams.add(streamClone)
+        }
+
+        this.getStreamBroadcastCountries(stream).forEach((country: Country) => {
+          const streamClone = stream.clone()
+          streamClone.groupTitle = country.name
+          groupedStreams.add(streamClone)
+        })
+      })
+
+    groupedStreams = groupedStreams.orderBy((stream: Stream) => {
+      if (stream.groupTitle === 'International') return 'ZZ'
+      if (stream.groupTitle === 'Undefined') return 'ZZZ'
+
+      return stream.groupTitle
+    })
+
+    const playlist = new Playlist(groupedStreams, { public: true })
+    const filepath = 'index.country.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+  }
+
+  getStreamBroadcastCountries(stream: Stream) {
+    const groupedRegions = this.regions.keyBy((region: Region) => region.code)
+    const groupedCountries = this.countries.keyBy((country: Country) => country.code)
+    const groupedSubdivisions = this.subdivisions.keyBy(
+      (subdivision: Subdivision) => subdivision.code
+    )
+
+    let broadcastCountries = new Collection()
+
+    stream.broadcastArea.forEach(broadcastAreaCode => {
+      const [type, code] = broadcastAreaCode.split('/')
+      switch (type) {
+        case 'c':
+          broadcastCountries.add(code)
+          break
+        case 'r':
+          if (code !== 'INT' && groupedRegions.has(code)) {
+            broadcastCountries = broadcastCountries.concat(groupedRegions.get(code).countries)
+          }
+          break
+        case 's':
+          if (groupedSubdivisions.has(code)) {
+            broadcastCountries.add(groupedSubdivisions.get(code).country)
+          }
+          break
+      }
+    })
+
+    return broadcastCountries
+      .uniq()
+      .map(code => groupedCountries.get(code))
+      .filter(Boolean)
+  }
+}

scripts/generators/indexGenerator.ts

@@ -1,32 +1,32 @@
-import { Collection, Logger, Storage } from '@freearhey/core'
-import { Stream, Playlist } from '../models'
-import { Generator } from './generator'
-import { PUBLIC_DIR } from '../constants'
-
-type IndexGeneratorProps = {
-  streams: Collection
-  logger: Logger
-}
-
-export class IndexGenerator implements Generator {
-  streams: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, logger }: IndexGeneratorProps) {
-    this.streams = streams
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    const sfwStreams = this.streams
-      .orderBy(stream => stream.getTitle())
-      .filter((stream: Stream) => stream.isSFW())
-
-    const playlist = new Playlist(sfwStreams, { public: true })
-    const filepath = 'index.m3u'
-    await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-}
+import { Collection, Logger, Storage } from '@freearhey/core'
+import { Stream, Playlist } from '../models'
+import { Generator } from './generator'
+import { PUBLIC_DIR } from '../constants'
+
+type IndexGeneratorProps = {
+  streams: Collection
+  logger: Logger
+}
+
+export class IndexGenerator implements Generator {
+  streams: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, logger }: IndexGeneratorProps) {
+    this.streams = streams
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    const sfwStreams = this.streams
+      .orderBy(stream => stream.getTitle())
+      .filter((stream: Stream) => stream.isSFW())
+
+    const playlist = new Playlist(sfwStreams, { public: true })
+    const filepath = 'index.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+  }
+}

scripts/generators/indexLanguageGenerator.ts

@@ -1,52 +1,52 @@
-import { Generator } from './generator'
-import { Collection, Storage, Logger } from '@freearhey/core'
-import { Stream, Playlist, Language } from '../models'
-import { PUBLIC_DIR } from '../constants'
-
-type IndexLanguageGeneratorProps = {
-  streams: Collection
-  logger: Logger
-}
-
-export class IndexLanguageGenerator implements Generator {
-  streams: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, logger }: IndexLanguageGeneratorProps) {
-    this.streams = streams
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    let groupedStreams = new Collection()
-    this.streams
-      .orderBy(stream => stream.getTitle())
-      .filter(stream => stream.isSFW())
-      .forEach(stream => {
-        if (stream.noLanguages()) {
-          const streamClone = stream.clone()
-          streamClone.groupTitle = 'Undefined'
-          groupedStreams.add(streamClone)
-          return
-        }
-
-        stream.languages.forEach((language: Language) => {
-          const streamClone = stream.clone()
-          streamClone.groupTitle = language.name
-          groupedStreams.add(streamClone)
-        })
-      })
-
-    groupedStreams = groupedStreams.orderBy((stream: Stream) => {
-      if (stream.groupTitle === 'Undefined') return 'ZZ'
-      return stream.groupTitle
-    })
-
-    const playlist = new Playlist(groupedStreams, { public: true })
-    const filepath = 'index.language.m3u'
-    await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-}
+import { Generator } from './generator'
+import { Collection, Storage, Logger } from '@freearhey/core'
+import { Stream, Playlist, Language } from '../models'
+import { PUBLIC_DIR } from '../constants'
+
+type IndexLanguageGeneratorProps = {
+  streams: Collection
+  logger: Logger
+}
+
+export class IndexLanguageGenerator implements Generator {
+  streams: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, logger }: IndexLanguageGeneratorProps) {
+    this.streams = streams
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    let groupedStreams = new Collection()
+    this.streams
+      .orderBy(stream => stream.getTitle())
+      .filter(stream => stream.isSFW())
+      .forEach(stream => {
+        if (stream.noLanguages()) {
+          const streamClone = stream.clone()
+          streamClone.groupTitle = 'Undefined'
+          groupedStreams.add(streamClone)
+          return
+        }
+
+        stream.languages.forEach((language: Language) => {
+          const streamClone = stream.clone()
+          streamClone.groupTitle = language.name
+          groupedStreams.add(streamClone)
+        })
+      })
+
+    groupedStreams = groupedStreams.orderBy((stream: Stream) => {
+      if (stream.groupTitle === 'Undefined') return 'ZZ'
+      return stream.groupTitle
+    })
+
+    const playlist = new Playlist(groupedStreams, { public: true })
+    const filepath = 'index.language.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+  }
+}

scripts/generators/indexNsfwGenerator.ts

@@ -1,30 +1,30 @@
-import { Collection, Logger, Storage } from '@freearhey/core'
-import { Stream, Playlist } from '../models'
-import { Generator } from './generator'
-import { PUBLIC_DIR } from '../constants'
-
-type IndexNsfwGeneratorProps = {
-  streams: Collection
-  logger: Logger
-}
-
-export class IndexNsfwGenerator implements Generator {
-  streams: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, logger }: IndexNsfwGeneratorProps) {
-    this.streams = streams
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    const allStreams = this.streams.orderBy((stream: Stream) => stream.getTitle())
-
-    const playlist = new Playlist(allStreams, { public: true })
-    const filepath = 'index.nsfw.m3u'
-    await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-}
+import { Collection, Logger, Storage } from '@freearhey/core'
+import { Stream, Playlist } from '../models'
+import { Generator } from './generator'
+import { PUBLIC_DIR } from '../constants'
+
+type IndexNsfwGeneratorProps = {
+  streams: Collection
+  logger: Logger
+}
+
+export class IndexNsfwGenerator implements Generator {
+  streams: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, logger }: IndexNsfwGeneratorProps) {
+    this.streams = streams
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    const allStreams = this.streams.orderBy((stream: Stream) => stream.getTitle())
+
+    const playlist = new Playlist(allStreams, { public: true })
+    const filepath = 'index.nsfw.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+  }
+}

scripts/generators/indexRegionGenerator.ts

@@ -1,83 +1,83 @@
-import { Generator } from './generator'
-import { Collection, Storage, Logger } from '@freearhey/core'
-import { Stream, Playlist, Region } from '../models'
-import { PUBLIC_DIR } from '../constants'
-
-type IndexRegionGeneratorProps = {
-  streams: Collection
-  regions: Collection
-  logger: Logger
-}
-
-export class IndexRegionGenerator implements Generator {
-  streams: Collection
-  regions: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, regions, logger }: IndexRegionGeneratorProps) {
-    this.streams = streams
-    this.regions = regions
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    let groupedStreams = new Collection()
-    this.streams
-      .orderBy((stream: Stream) => stream.getTitle())
-      .filter((stream: Stream) => stream.isSFW())
-      .forEach((stream: Stream) => {
-        if (stream.noBroadcastArea()) {
-          const streamClone = stream.clone()
-          streamClone.groupTitle = 'Undefined'
-          groupedStreams.push(streamClone)
-          return
-        }
-
-        this.getStreamRegions(stream).forEach((region: Region) => {
-          const streamClone = stream.clone()
-          streamClone.groupTitle = region.name
-          groupedStreams.push(streamClone)
-        })
-      })
-
-    groupedStreams = groupedStreams.orderBy((stream: Stream) => {
-      if (stream.groupTitle === 'Undefined') return 'ZZ'
-      return stream.groupTitle
-    })
-
-    const playlist = new Playlist(groupedStreams, { public: true })
-    const filepath = 'index.region.m3u'
-    await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-
-  getStreamRegions(stream: Stream) {
-    let streamRegions = new Collection()
-    stream.broadcastArea.forEach(broadcastAreaCode => {
-      const [type, code] = broadcastAreaCode.split('/')
-      switch (type) {
-        case 'r':
-          const groupedRegions = this.regions.keyBy((region: Region) => region.code)
-          streamRegions.add(groupedRegions.get(code))
-          break
-        case 's':
-          const [countryCode] = code.split('-')
-          const subdivisionRegions = this.regions.filter((region: Region) =>
-            region.countries.includes(countryCode)
-          )
-          streamRegions = streamRegions.concat(subdivisionRegions)
-          break
-        case 'c':
-          const countryRegions = this.regions.filter((region: Region) =>
-            region.countries.includes(code)
-          )
-          streamRegions = streamRegions.concat(countryRegions)
-          break
-      }
-    })
-
-    return streamRegions
-  }
-}
+import { Generator } from './generator'
+import { Collection, Storage, Logger } from '@freearhey/core'
+import { Stream, Playlist, Region } from '../models'
+import { PUBLIC_DIR } from '../constants'
+
+type IndexRegionGeneratorProps = {
+  streams: Collection
+  regions: Collection
+  logger: Logger
+}
+
+export class IndexRegionGenerator implements Generator {
+  streams: Collection
+  regions: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, regions, logger }: IndexRegionGeneratorProps) {
+    this.streams = streams
+    this.regions = regions
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    let groupedStreams = new Collection()
+    this.streams
+      .orderBy((stream: Stream) => stream.getTitle())
+      .filter((stream: Stream) => stream.isSFW())
+      .forEach((stream: Stream) => {
+        if (stream.noBroadcastArea()) {
+          const streamClone = stream.clone()
+          streamClone.groupTitle = 'Undefined'
+          groupedStreams.push(streamClone)
+          return
+        }
+
+        this.getStreamRegions(stream).forEach((region: Region) => {
+          const streamClone = stream.clone()
+          streamClone.groupTitle = region.name
+          groupedStreams.push(streamClone)
+        })
+      })
+
+    groupedStreams = groupedStreams.orderBy((stream: Stream) => {
+      if (stream.groupTitle === 'Undefined') return 'ZZ'
+      return stream.groupTitle
+    })
+
+    const playlist = new Playlist(groupedStreams, { public: true })
+    const filepath = 'index.region.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+  }
+
+  getStreamRegions(stream: Stream) {
+    let streamRegions = new Collection()
+    stream.broadcastArea.forEach(broadcastAreaCode => {
+      const [type, code] = broadcastAreaCode.split('/')
+      switch (type) {
+        case 'r':
+          const groupedRegions = this.regions.keyBy((region: Region) => region.code)
+          streamRegions.add(groupedRegions.get(code))
+          break
+        case 's':
+          const [countryCode] = code.split('-')
+          const subdivisionRegions = this.regions.filter((region: Region) =>
+            region.countries.includes(countryCode)
+          )
+          streamRegions = streamRegions.concat(subdivisionRegions)
+          break
+        case 'c':
+          const countryRegions = this.regions.filter((region: Region) =>
+            region.countries.includes(code)
+          )
+          streamRegions = streamRegions.concat(countryRegions)
+          break
+      }
+    })
+
+    return streamRegions
+  }
+}

scripts/generators/languagesGenerator.ts

@@ -1,50 +1,52 @@
-import { Generator } from './generator'
-import { Collection, Storage, Logger } from '@freearhey/core'
-import { Playlist, Language, Stream } from '../models'
-import { PUBLIC_DIR } from '../constants'
-
-type LanguagesGeneratorProps = { streams: Collection; logger: Logger }
-
-export class LanguagesGenerator implements Generator {
-  streams: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, logger }: LanguagesGeneratorProps) {
-    this.streams = streams
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    let streams = this.streams.orderBy(stream => stream.getTitle()).filter(stream => stream.isSFW())
-
-    let languages = new Collection()
-    streams.forEach((stream: Stream) => {
-      languages = languages.concat(stream.languages)
-    })
-
-    languages
-      .uniqBy((language: Language) => language.code)
-      .orderBy((language: Language) => language.name)
-      .forEach(async (language: Language) => {
-        const languageStreams = streams.filter(stream => stream.hasLanguage(language))
-
-        if (languageStreams.isEmpty()) return
-
-        const playlist = new Playlist(languageStreams, { public: true })
-        const filepath = `languages/${language.code}.m3u`
-        await this.storage.save(filepath, playlist.toString())
-        this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-      })
-
-    const undefinedStreams = streams.filter(stream => stream.noLanguages())
-
-    if (undefinedStreams.isEmpty()) return
-
-    const playlist = new Playlist(undefinedStreams, { public: true })
-    const filepath = 'languages/undefined.m3u'
-    await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-}
+import { Generator } from './generator'
+import { Collection, Storage, Logger } from '@freearhey/core'
+import { Playlist, Language, Stream } from '../models'
+import { PUBLIC_DIR } from '../constants'
+
+type LanguagesGeneratorProps = { streams: Collection; logger: Logger }
+
+export class LanguagesGenerator implements Generator {
+  streams: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, logger }: LanguagesGeneratorProps) {
+    this.streams = streams
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    const streams = this.streams
+      .orderBy(stream => stream.getTitle())
+      .filter(stream => stream.isSFW())
+
+    let languages = new Collection()
+    streams.forEach((stream: Stream) => {
+      languages = languages.concat(stream.languages)
+    })
+
+    languages
+      .uniqBy((language: Language) => language.code)
+      .orderBy((language: Language) => language.name)
+      .forEach(async (language: Language) => {
+        const languageStreams = streams.filter(stream => stream.hasLanguage(language))
+
+        if (languageStreams.isEmpty()) return
+
+        const playlist = new Playlist(languageStreams, { public: true })
+        const filepath = `languages/${language.code}.m3u`
+        await this.storage.save(filepath, playlist.toString())
+        this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+      })
+
+    const undefinedStreams = streams.filter(stream => stream.noLanguages())
+
+    if (undefinedStreams.isEmpty()) return
+
+    const playlist = new Playlist(undefinedStreams, { public: true })
+    const filepath = 'languages/undefined.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+  }
+}

scripts/generators/regionsGenerator.ts

@@ -1,51 +1,53 @@
-import { Generator } from './generator'
-import { Collection, Storage, Logger } from '@freearhey/core'
-import { Playlist, Subdivision, Region } from '../models'
-import { PUBLIC_DIR } from '../constants'
-
-type RegionsGeneratorProps = {
-  streams: Collection
-  regions: Collection
-  subdivisions: Collection
-  logger: Logger
-}
-
-export class RegionsGenerator implements Generator {
-  streams: Collection
-  regions: Collection
-  subdivisions: Collection
-  storage: Storage
-  logger: Logger
-
-  constructor({ streams, regions, subdivisions, logger }: RegionsGeneratorProps) {
-    this.streams = streams
-    this.regions = regions
-    this.subdivisions = subdivisions
-    this.storage = new Storage(PUBLIC_DIR)
-    this.logger = logger
-  }
-
-  async generate(): Promise<void> {
-    let streams = this.streams.orderBy(stream => stream.getTitle()).filter(stream => stream.isSFW())
-
-    this.regions.forEach(async (region: Region) => {
-      if (region.code === 'INT') return
-
-      const regionSubdivisionsCodes = this.subdivisions
-        .filter((subdivision: Subdivision) => region.countries.indexOf(subdivision.country) > -1)
-        .map((subdivision: Subdivision) => `s/${subdivision.code}`)
-
-      const regionCodes = region.countries
-        .map((code: string) => `c/${code}`)
-        .concat(regionSubdivisionsCodes)
-        .add(`r/${region.code}`)
-
-      const regionStreams = streams.filter(stream => stream.broadcastArea.intersects(regionCodes))
-
-      const playlist = new Playlist(regionStreams, { public: true })
-      const filepath = `regions/${region.code.toLowerCase()}.m3u`
-      await this.storage.save(filepath, playlist.toString())
-      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-    })
-  }
-}
+import { Generator } from './generator'
+import { Collection, Storage, Logger } from '@freearhey/core'
+import { Playlist, Subdivision, Region } from '../models'
+import { PUBLIC_DIR } from '../constants'
+
+type RegionsGeneratorProps = {
+  streams: Collection
+  regions: Collection
+  subdivisions: Collection
+  logger: Logger
+}
+
+export class RegionsGenerator implements Generator {
+  streams: Collection
+  regions: Collection
+  subdivisions: Collection
+  storage: Storage
+  logger: Logger
+
+  constructor({ streams, regions, subdivisions, logger }: RegionsGeneratorProps) {
+    this.streams = streams
+    this.regions = regions
+    this.subdivisions = subdivisions
+    this.storage = new Storage(PUBLIC_DIR)
+    this.logger = logger
+  }
+
+  async generate(): Promise<void> {
+    const streams = this.streams
+      .orderBy(stream => stream.getTitle())
+      .filter(stream => stream.isSFW())
+
+    this.regions.forEach(async (region: Region) => {
+      if (region.code === 'INT') return
+
+      const regionSubdivisionsCodes = this.subdivisions
+        .filter((subdivision: Subdivision) => region.countries.indexOf(subdivision.country) > -1)
+        .map((subdivision: Subdivision) => `s/${subdivision.code}`)
+
+      const regionCodes = region.countries
+        .map((code: string) => `c/${code}`)
+        .concat(regionSubdivisionsCodes)
+        .add(`r/${region.code}`)
+
+      const regionStreams = streams.filter(stream => stream.broadcastArea.intersects(regionCodes))
+
+      const playlist = new Playlist(regionStreams, { public: true })
+      const filepath = `regions/${region.code.toLowerCase()}.m3u`
+      await this.storage.save(filepath, playlist.toString())
+      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    })
+  }
+}