Merge pull request #2138 from iptv-org/patch-2026.04.4

Patch 2026.04.4

Author: StrangeDrVN

package-lock.json

@@ -17,11 +17,12 @@
   "devDependencies": {
     "@eslint/js": "^9.39.1",
     "@freearhey/core": "^0.15.0",
-    "@iptv-org/sdk": "^1.3.0",
+    "@iptv-org/sdk": "^1.4.0",
     "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/kit": "^2.49.1",
+    "@sveltejs/kit": "^2.58.0",
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@tailwindcss/line-clamp": "^0.4.4",
-    "@tailwindcss/vite": "^4.1.17",
+    "@tailwindcss/vite": "^4.2.4",
     "@types/cli-progress": "^3.11.6",
     "@types/qs": "^6.14.0",
     "@zerodevx/svelte-toast": "^0.9.6",
@@ -43,9 +44,9 @@
     "tsx": "^4.20.3",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.0",
-    "vite": "^7.2.6",
+    "vite": "^8.0.10",
     "vite-plugin-mkcert": "^1.17.12",
-    "vitest": "^4.0.14"
+    "vitest": "^4.1.5"
   },
   "overrides": {
     "esbuild": "0.23.1"

package.json

@@ -1,2 +1,3 @@
 export const SITE_ORIGIN = 'https://iptv-org.github.io'
 export const DATA_DIR = './temp/data'
+export const DEFAULT_QUERY = 'is_closed:false'

src/constants.ts

@@ -1,2 +1,3 @@
 export * from './clickOutside'
+export * from './scrollToSelected'
 export * from './tippy'

src/lib/actions/index.ts

@@ -0,0 +1,28 @@
+import type { Action } from 'svelte/action'
+
+export const scrollToSelected: Action<HTMLElement, boolean> = (node, isSelected) => {
+  const scroll = (active: boolean) => {
+    const container = node.parentElement
+    if (active && container) {
+      const containerRect = container.getBoundingClientRect()
+      const nodeRect = node.getBoundingClientRect()
+
+      const distanceFromContainerLeft = nodeRect.left - containerRect.left
+      const halfContainerWidth = containerRect.width / 2
+      const halfNodeWidth = nodeRect.width / 2
+      const targetScrollLeft =
+        container.scrollLeft + distanceFromContainerLeft - halfContainerWidth + halfNodeWidth
+
+      container.scrollTo({
+        left: targetScrollLeft,
+        behavior: 'auto'
+      })
+    }
+  }
+
+  scroll(isSelected)
+
+  return {
+    update: scroll
+  }
+}

src/lib/actions/scrollToSelected.ts

@@ -16,63 +16,108 @@ interface Config {
   dataDir?: string
 }
 
-export async function loadData(config: Config = {}) {
+type ProcessedData = {
+  countries: Country[]
+  channels: Channel[]
+  feeds: Feed[]
+  streams: Stream[]
+  channelsKeyById: Map<string, Channel>
+}
+
+export let processedData: ProcessedData | undefined
+
+export async function loadData(config: Config = {}): Promise<ProcessedData> {
   const dataDir = config.dataDir || DATA_DIR
 
   const dataManager = new sdk.DataManager({ dataDir })
   await dataManager.downloadToMemory()
   dataManager.loadFromMemory()
   const rawData = dataManager.getRawData()
+  processedData = processData(rawData)
 
-  return processData(rawData)
+  return processedData
 }
 
-export async function loadDataFromDisk(config: Config = {}) {
+export async function loadDataFromDisk(config: Config = {}): Promise<ProcessedData> {
   const dataDir = config.dataDir || DATA_DIR
 
   const dataManager = new sdk.DataManager({ dataDir })
   await dataManager.loadFromDisk()
   const rawData = dataManager.getRawData()
+  processedData = processData(rawData)
 
-  return processData(rawData)
+  return processedData
 }
 
-function processData(rawData: sdk.Types.RawData) {
-  const feedsKeyByStreamId = rawData.feeds.reduce((acc, data: sdk.Types.FeedData) => {
-    const feed = new Feed(data)
-    acc.set(feed.getStreamId(), feed)
-    return acc
-  }, new Map())
-  const logosGroupedByChannel2 = Map.groupBy(
-    rawData.logos.map((data: sdk.Types.LogoData) => new Logo(data)),
+function processData(rawData: sdk.Types.RawData): ProcessedData {
+  const channelsGroupedByName = Map.groupBy(
+    rawData.channels,
+    (channel: sdk.Types.ChannelData) => channel.name
+  )
+  const feedsKeyByStreamId: Map<string, Feed> = rawData.feeds.reduce(
+    (acc, data: sdk.Types.FeedData) => {
+      const feed = new Feed(data)
+      acc.set(feed.getStreamId(), feed)
+      return acc
+    },
+    new Map()
+  )
+  const channelsKeyById2: Map<string, Channel> = rawData.channels.reduce(
+    (acc, data: sdk.Types.ChannelData) => {
+      const channel = new Channel(data)
+      channel.hasUniqueName = channelsGroupedByName.get(channel.name).length === 1
+      acc.set(channel.id, channel)
+      return acc
+    },
+    new Map()
+  )
+  const logosGroupedByChannel2: Map<string, Logo[]> = Map.groupBy(
+    rawData.logos.map((data: sdk.Types.LogoData) =>
+      new Logo(data).withChannel(channelsKeyById2.get(data.channel))
+    ),
     (logo: Logo) => logo.channel
   )
-  const categoriesKeyById = rawData.categories.reduce((acc, data: sdk.Types.CategoryData) => {
-    const category = new sdk.Models.Category(data)
-    acc.set(category.id, category)
-    return acc
-  }, new Map())
-  const countriesKeyByCode = rawData.countries.reduce((acc, data: sdk.Types.CountryData) => {
-    const country = new Country(data)
-    acc.set(country.code, country)
-    return acc
-  }, new Map())
-  const channelsKeyById = rawData.channels.reduce((acc, data: sdk.Types.ChannelData) => {
-    const channel = new Channel(data)
-    const logos = logosGroupedByChannel2.get(channel.id)
-    const categories = channel.categories.map((id: string) => categoriesKeyById.get(id))
-    const country = countriesKeyByCode.get(channel.country)
-    channel.withLogos(logos).withCategories(categories).withCountry(country)
-    acc.set(channel.id, channel)
-    return acc
-  }, new Map())
+  const categoriesKeyById: Map<string, sdk.Models.Category> = rawData.categories.reduce(
+    (acc, data: sdk.Types.CategoryData) => {
+      const category = new sdk.Models.Category(data)
+      acc.set(category.id, category)
+      return acc
+    },
+    new Map()
+  )
+  const countriesKeyByCode: Map<string, Country> = rawData.countries.reduce(
+    (acc, data: sdk.Types.CountryData) => {
+      const country = new Country(data)
+      acc.set(country.code, country)
+      return acc
+    },
+    new Map()
+  )
+  const channelsKeyById: Map<string, Channel> = rawData.channels.reduce(
+    (acc, data: sdk.Types.ChannelData) => {
+      const channel = new Channel(data)
+      const logos = logosGroupedByChannel2.get(channel.id)
+      const categories = channel.categories.map((id: string) => categoriesKeyById.get(id))
+      const country = countriesKeyByCode.get(channel.country)
+      channel.withLogos(logos).withCategories(categories).withCountry(country)
+      channel.hasUniqueName = channelsGroupedByName.get(channel.name).length === 1
+      acc.set(channel.id, channel)
+      return acc
+    },
+    new Map()
+  )
 
   const logos = rawData.logos.map((data: sdk.Types.LogoData) => {
     const logo = new Logo(data)
+    const feed = feedsKeyByStreamId.get(logo.getStreamId())
+    const channel = channelsKeyById.get(logo.channel)
+
+    if (feed && channel) feed.withChannel(channel)
+
+    if (feed) logo.withFeed(feed)
+    if (channel) logo.withChannel(channel)
 
     return logo
-      .withFeed(feedsKeyByStreamId.get(logo.getStreamId()))
-      .withChannel(channelsKeyById.get(logo.channel))
   })
 
   const logosGroupedByStreamId = Map.groupBy(logos, (logo: Logo) => logo.getStreamId())
@@ -100,7 +145,7 @@ function processData(rawData: sdk.Types.RawData) {
     acc.set(city.code, city)
     return acc
   }, new Map())
-  const subdivisionsKeyByCode = rawData.subdivisions.reduce(
+  const subdivisionsKeyByCode: Map<string, sdk.Models.Subdivision> = rawData.subdivisions.reduce(
     (acc, data: sdk.Types.SubdivisionData) => {
       const subdivision = new sdk.Models.Subdivision(data)
       acc.set(subdivision.code, subdivision)
@@ -109,16 +154,22 @@ function processData(rawData: sdk.Types.RawData) {
     new Map()
   )
 
-  const regionsKeyByCode = rawData.regions.reduce((acc, data: sdk.Types.RegionData) => {
-    const region = new sdk.Models.Region(data)
-    acc.set(region.code, region)
-    return acc
-  }, new Map())
-  const timezonesKeyById = rawData.timezones.reduce((acc, data: sdk.Types.TimezoneData) => {
-    const timezone = new sdk.Models.Timezone(data)
-    acc.set(timezone.id, timezone)
-    return acc
-  }, new Map())
+  const regionsKeyByCode: Map<string, sdk.Models.Region> = rawData.regions.reduce(
+    (acc, data: sdk.Types.RegionData) => {
+      const region = new sdk.Models.Region(data)
+      acc.set(region.code, region)
+      return acc
+    },
+    new Map()
+  )
+  const timezonesKeyById: Map<string, sdk.Models.Timezone> = rawData.timezones.reduce(
+    (acc, data: sdk.Types.TimezoneData) => {
+      const timezone = new sdk.Models.Timezone(data)
+      acc.set(timezone.id, timezone)
+      return acc
+    },
+    new Map()
+  )
   const feeds = rawData.feeds.map((data: sdk.Types.FeedData) => {
     const feed = new Feed(data)
 
@@ -130,7 +181,7 @@ function processData(rawData: sdk.Types.RawData) {
     const streams = streamsGroupedById.get(feed.getStreamId())
     const guides = guidesGroupedByStreamId.get(feed.getStreamId())
     const locations = feed.broadcast_area.map((rawCode: string) => {
-      let name
+      let name: string | undefined
       const [type, code] = rawCode.split('/')
       switch (type) {
         case 'ct': {
@@ -170,6 +221,16 @@ function processData(rawData: sdk.Types.RawData) {
       .withChannel(channel)
   })
 
+  const graph = buildGraph(rawData.channels)
+
+  const edgesTo = new Map<string, string[]>()
+  const edgesFrom = new Map<string, string>()
+  for (const edge of graph.edges) {
+    if (!edgesTo.has(edge.to)) edgesTo.set(edge.to, [])
+    edgesTo.get(edge.to)!.push(edge.from)
+    edgesFrom.set(edge.from, edge.to)
+  }
+
   const logosGroupedByChannel = Map.groupBy(logos, (logo: Logo) => logo.channel)
   const feedsGroupedByChannel = Map.groupBy(feeds, (feed: Feed) => feed.channel)
   const blocklistRecords = rawData.blocklist.map(
@@ -179,15 +240,28 @@ function processData(rawData: sdk.Types.RawData) {
     blocklistRecords,
     (record: BlocklistRecord) => record.channel
   )
-  const channels = rawData.channels.map((data: sdk.Types.ChannelData) => {
-    const channel = new Channel(data)
+
+  const finalChannelsKeyById = new Map<string, Channel>()
+  const channels = rawData.channels.map((channelData: sdk.Types.ChannelData) => {
+    const channel = new Channel(channelData)
     const categories = channel.categories.map((id: string) => categoriesKeyById.get(id))
-    return channel
+    const history = getChannelHistory(channel.id, edgesTo, edgesFrom, channelsKeyById)
+
+    channel
       .withLogos(logosGroupedByChannel.get(channel.id))
       .withFeeds(feedsGroupedByChannel.get(channel.id))
       .withCategories(categories)
       .withCountry(countriesKeyByCode.get(channel.country))
       .withBlocklistRecords(blocklistRecordsGroupedByChannel.get(channel.id))
+
+    if (history.length > 1) {
+      channel.withHistory(history)
+    }
+
+    channel.hasUniqueName = channelsGroupedByName.get(channel.name).length === 1
+
+    finalChannelsKeyById.set(channel.id, channel)
+    return channel
   })
 
   const channelsGroupedByCountry = Map.groupBy(channels, (channel: Channel) => channel.country)
@@ -200,6 +274,77 @@ function processData(rawData: sdk.Types.RawData) {
     countries,
     channels,
     feeds,
-    streams
+    streams,
+    channelsKeyById: finalChannelsKeyById
+  }
+}
+
+function buildGraph(channels: sdk.Types.ChannelData[]) {
+  const graph = {
+    edges: [],
+    nodes: []
   }
+
+  channels.forEach((channel: sdk.Types.ChannelData) => {
+    graph.nodes.push({ id: channel.id, label: channel.name })
+
+    if (channel.replaced_by) {
+      const target = channel.replaced_by.split('@')[0]
+
+      if (target !== channel.id) {
+        graph.edges.push({ from: channel.id, to: target })
+      }
+    }
+  })
+
+  return graph
+}
+
+function getChannelHistory(
+  targetId: string,
+  edgesTo: Map<string, string[]>,
+  edgesFrom: Map<string, string>,
+  channelsKeyById: Map<string, Channel>
+): (Channel | Channel[])[] {
+  const visited = new Set<string>()
+
+  const getAncestors = (id: string): (Channel | Channel[])[] => {
+    if (visited.has(id)) return []
+    visited.add(id)
+
+    const parentIds = edgesTo.get(id) || []
+    if (parentIds.length === 0) return []
+
+    if (parentIds.length > 1) {
+      const multiParents = parentIds
+        .map(pId => channelsKeyById.get(pId))
+        .filter((p): p is Channel => !!p)
+      return multiParents.length > 0 ? [multiParents] : []
+    }
+
+    const parentId = parentIds[0]
+    const parentNode = channelsKeyById.get(parentId)
+    const ancestors = getAncestors(parentId)
+
+    return parentNode ? [...ancestors, parentNode] : ancestors
+  }
+
+  const successors: Channel[] = []
+  const visitedSuccessors = new Set<string>([targetId])
+  let current = targetId
+
+  while (true) {
+    const nextId = edgesFrom.get(current)
+    const nextNode = nextId ? channelsKeyById.get(nextId) : null
+    if (!nextId || !nextNode || visitedSuccessors.has(nextId)) break
+
+    successors.push(nextNode)
+    visitedSuccessors.add(nextId)
+    current = nextId
+  }
+
+  const targetNode = channelsKeyById.get(targetId)
+  const ancestors = getAncestors(targetId)
+
+  return [...ancestors, targetNode, ...successors].filter((n): n is Channel | Channel[] => !!n)
 }

src/lib/api.ts

@@ -15,7 +15,7 @@
   function _onClick() {
     const streams = new Collection(Array.from($selectedStreams)).sortBy(
       [
-        (stream: Stream) => stream.channel.toLowerCase(),
+        (stream: Stream) => stream.getFullTitle(),
         (stream: Stream) => stream.getVerticalResolution(),
         (stream: Stream) => stream.url
       ],