m3u-parser-generator
Version:
Library to parse and generate m3u or m3u8 IPTV playlist files
254 lines (231 loc) • 8.41 kB
text/typescript
import {
M3uPlaylist,
M3uMedia,
M3uAttributes,
M3uDirectives,
M3U_COMMENT,
} from "./m3u-playlist";
/**
* Custom data mapping, that defines parsing of unknown directives.
* Directive can belong to whole playlist, or specific media.
*/
export interface M3uCustomDataMapping {media?: string[], playlist?: string[]}
/**
* Interface to configure m3u parser
*/
export interface M3uParserConfig {
/**
* Ignore errors in file and try to parse it with it
*/
ignoreErrors?: boolean;
/**
* Custom mapping for unknown directives, that can be partially parsed too and added to parsed object
*/
customDataMapping?: M3uCustomDataMapping,
}
/**
* M3u parser class to parse m3u playlist string to playlist object
*/
export class M3uParser {
/**
* Constructor of class
* @param config - to configure parser behaviour
*/
constructor(private readonly config?: M3uParserConfig) { }
/**
* Get m3u attributes object from attributes string
* @param attributesString e.g. 'tvg-id="" group-title=""'
* @returns attributes object e.g. {"tvg-id": "", "group-title": ""}
* @private
*/
private getAttributes(attributesString: string): M3uAttributes {
const attributes: M3uAttributes = new M3uAttributes();
if (!attributesString) {
return attributes;
}
const attributeValuePair = attributesString.match(/[^ ]*?=".*?"/g) ?? []; // regex to find `attribute="value"`
attributeValuePair.forEach((item) => {
const [key, value] = item.split('="');
attributes[key] = value.replace('"', '');
});
return attributes;
}
/**
* Process media method parse trackInformation and fill media with parsed info
* @param trackInformation - media substring of m3u string line e.g. '-1 tvg-id="" group-title="",Tv Name'
* @param media - actual m3u media object
* @private
*/
private processMedia(trackInformation: string, media: M3uMedia): void {
const firstCommaIndex = trackInformation.indexOf(',');
const durationAttributes = trackInformation.substring(0, firstCommaIndex);
media.name = trackInformation.substring(firstCommaIndex + 1);
const firstSpaceIndex = durationAttributes.indexOf(' ');
const durationEndIndex = firstSpaceIndex > 0 ? firstSpaceIndex : durationAttributes.length;
media.duration = Number(durationAttributes.substring(0, durationEndIndex));
const attributes = durationAttributes.substring(durationEndIndex + 1);
media.attributes = this.getAttributes(attributes);
}
/**
* Process directive method detects directive on line and call proper method to another processing
* @param item - actual line of m3u playlist string e.g. '#EXTINF:-1 tvg-id="" group-title="",Tv Name'
* @param playlist - m3u playlist object processed until now
* @param media - actual m3u media object
* @private
*/
private processDirective(item: string, playlist: M3uPlaylist, media: M3uMedia): void {
const firstSemicolonIndex = item.indexOf(':');
const directive = item.substring(0, firstSemicolonIndex);
const trackInformation = item.substring(firstSemicolonIndex + 1);
switch(directive) {
case M3uDirectives.EXTINF: {
this.processMedia(trackInformation, media);
break;
}
case M3uDirectives.EXTGRP: {
media.group = trackInformation;
break;
}
case M3uDirectives.EXTBYT: {
media.bytes = Number(trackInformation);
break;
}
case M3uDirectives.EXTIMG: {
media.image = trackInformation;
break;
}
case M3uDirectives.EXTALB: {
media.album = trackInformation;
break;
}
case M3uDirectives.EXTART: {
media.artist = trackInformation;
break;
}
case M3uDirectives.EXTGENRE: {
media.genre = trackInformation;
break;
}
case M3uDirectives.PLAYLIST: {
playlist.title = trackInformation;
break;
}
case M3uDirectives.EXTATTRFROMURL: {
media.extraAttributesFromUrl = trackInformation;
break;
}
case M3uDirectives.EXTHTTP: {
media.extraHttpHeaders = JSON.parse(trackInformation);
break;
}
case M3uDirectives.KODIPROP: {
const [key, ...valueParts] = trackInformation.split('=');
const value = valueParts.join('='); // in case value contains '=', ie. '#KODIPROP:inputstream.adaptive.license_key=https://example.com/license.php?id=example'
if(!media.kodiProps) {
media.kodiProps = new Map<string, string>();
}
media.kodiProps.set(key, value);
break;
}
default: {
this.processCustomData(playlist, media, trackInformation, directive);
}
}
}
/**
* Process custom unknown directive and add it into playlist or media object, based on mapping configuration
* @param playlist - m3u playlist object processed until now
* @param media - actual m3u media object
* @param trackInformation - track information, whole part of string after directive and semicolon
* @param directive - unknown directive e.g. #EXT-CUSTOM
* @private
*/
private processCustomData(
playlist: M3uPlaylist,
media: M3uMedia,
trackInformation: string,
directive: string,
): void {
if (this.config?.customDataMapping?.media && this.config.customDataMapping.media.includes(directive)) {
media.customData.push({directive, value: trackInformation});
} else if (this.config?.customDataMapping?.playlist && this.config.customDataMapping.playlist.includes(directive)) {
playlist.customData.push({directive, value: trackInformation});
}
}
/**
* Process attributes in #EXTM3U line
* @param item - first line of m3u playlist string e.g. '#EXTM3U url-tvg="http://example.com/tvg.xml"'
* @param playlist - m3u playlist object processed until now
* @private
*/
private processExtM3uAttributes(item: string, playlist: M3uPlaylist): void {
if(item.startsWith(M3uDirectives.EXTM3U)) {
const firstSpaceIndex = item.indexOf(' ');
if(firstSpaceIndex > 0) {
const attributes = item.substring(firstSpaceIndex + 1);
playlist.attributes = this.getAttributes(attributes);
}
}
}
/**
* Get playlist returns m3u playlist object parsed from m3u string lines
* @param lines - m3u string lines
* @returns parsed m3u playlist object
* @private
*/
private getPlaylist(lines: string[]): M3uPlaylist {
const playlist = new M3uPlaylist();
let media = new M3uMedia('');
this.processExtM3uAttributes(lines[0], playlist);
lines.forEach(item => {
if (this.isDirective(item)) {
this.processDirective(item, playlist, media);
} else {
media.location = item;
playlist.medias.push(media);
media = new M3uMedia('');
}
});
return playlist;
}
/**
* Is directive method detect if line contains m3u directive
* @param item - string line of playlist
* @returns true if it is line with directive, otherwise false
* @private
*/
private isDirective(item: string): boolean {
return item[0] === M3U_COMMENT;
}
/**
* Is valid m3u method detect if first line of playlist contains #EXTM3U directive
* @param firstLine - first line of m3u playlist string
* @returns true if line starts with #EXTM3U, false otherwise
* @private
*/
private isValidM3u(firstLine: string[]): boolean {
return firstLine[0].startsWith(M3uDirectives.EXTM3U);
}
/**
* Parse is method to parse m3u playlist string into m3u playlist object.
* Playlist need to contain #EXTM3U directive on first line.
* All lines are trimmed and blank ones are removed.
* @param m3uString - whole m3u playlist string
* @returns parsed m3u playlist object
* @example
* ```ts
* const playlist = M3uParser.parse(m3uString);
* playlist.medias.forEach(media => media.location);
* ```
*/
parse(m3uString: string): M3uPlaylist {
if (!this.config?.ignoreErrors && !m3uString) {
throw new Error(`m3uString can't be null!`);
}
const lines = m3uString.split('\n').map(item => item.trim()).filter(item => item != '');
if (!this.config?.ignoreErrors && !this.isValidM3u(lines)) {
throw new Error(`Missing ${M3uDirectives.EXTM3U} directive!`);
}
return this.getPlaylist(lines);
}
}