radiomanifest.js/radiomanifest.js

import fetch from "isomorphic-unfetch";
import shows from "./shows.js";
import calendar from "./calendar.js";

function getStreaminfoUrl(siteurl) {
  return siteurl + "/streaminfo.json"; // XXX: improve this logic
}
function getManifestUrl(siteurl) {
  return siteurl + "/radiomanifest.xml"; // XXX: improve this logic
}

function getAttribute(el, attr, default_value) {
  if (el.hasAttribute(attr)) return el.getAttribute(attr);
  return default_value;
}

/**
 * Represents everything we know about a radio. This includes, but is not limited to, radiomanifest.xml.
 */
class Radio {
  /**
   * @param {Array}  [sources] optional
   * @param {string} [scheduleURL]
   * @param {string} [showsURL]
   * @param {string} [feed]
   */
  constructor(sources, scheduleURL, showsURL, feed) {
    this.streaming = new RadioStreaming(sources);
    this.scheduleURL = scheduleURL;
    this.showsURL = showsURL;
    this.feed = feed;
    this.name = "";
    this.description = "";
    this.logo = null;
    this.shows = [];
    this.schedule = null;
  }

  /**
   * @returns {RadioStreaming}
   */
  getStreaming() {
    return this.streaming;
  }

  setName(name) {
    this.name = name;
  }

  /**
   * The radio name, as inferred by stream-meta
   *
   * @returns {string}
   */
  getName() {
    return this.name;
  }

  setDescription(desc) {
    this.description = desc;
  }

  /**
   * The description of the radio, as inferred by stream-meta
   *
   * @returns {string}
   */
  getDescription() {
    return this.description;
  }

  setLogo(logo) {
    this.logo = logo;
  }

  /**
   * @returns {string} the URL of the logo, or `null` if not found
   */
  getLogo() {
    return this.logo;
  }

  /**
   *
   * @returns {Array<RadioShow>}
   */
  getShows() {
    return this.shows;
  }

  /**
   * @returns {RadioShow} The lookup is exact and case-sensitive. If no such show can be found, `null`
   * is returned.
   */
  getShowByName(showName) {
    if (this.shows === undefined) return null;
    return this.shows.find((s) => s.name === showName);
  }

  /**
   * @returns {RadioSchedule} If no schedule is present, `null` is returned.
   */
  getSchedule() {
    return this.schedule;
  }

  /**
   * Find if a show is running at the given moment. If there's none, `null` is returned.
   * If possible, a complete {@link RadioShow} including full informations (from shows.xml) is returned.
   * If, instead, we know from the `schedule` that there must be a show, but have no additional detail, a
   * {@link RadioShow} object will be created on the fly.
   *
   * @param {ICAL.Time} [now] If omitted, the current time is used.
   * @returns {RadioShow} If we don't know what's going on at the given moment, `null` is returned.
   */
  getShowAtTime(now) {
    if (this.schedule === undefined || this.schedule === null) return null;
    return this.getSchedule().getNowShow(now);
  }

  /**
   * This static method can create a Radio object from a valid radiomanifest.xml file
   *
   * @param xml An already parsed xml block
   * @returns {Radio}
   */
  static fromDOM(xml) {
    const doc = xml.cloneNode(true);
    let res = doc.evaluate(
      "/radio-manifest/streaming/source",
      doc,
      null,
      XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
      null,
    );
    const sources = [];
    for (let i = 0; i < res.snapshotLength; i++) {
      const src = res.snapshotItem(i);

      if (!src.hasAttribute("priority")) {
        src.setAttribute("priority", "0");
      } else if (parseInt(src.getAttribute("priority"), 10) < 0) {
        continue;
      }
      sources.push(src);
    }

    res = doc.evaluate("/radio-manifest/schedule", doc);
    const scheduleEl = res.iterateNext();
    let scheduleURL = null;
    if (scheduleEl !== null) {
      scheduleURL = scheduleEl.getAttribute("src");
    }

    res = xml.evaluate("/radio-manifest/shows", xml);
    const showsEl = res.iterateNext();
    let showsURL = null;
    if (showsEl !== null) {
      showsURL = showsEl.getAttribute("src");
    }

    res = xml.evaluate("/radio-manifest/feed", xml);
    const feedEl = res.iterateNext();
    let feed = null;
    if (feedEl !== null) {
      feed = feedEl.getAttribute("src");
    }

    const manifest = new Radio(sources, scheduleURL, showsURL, feed);
    return manifest;
  }
}

/**
 * Represents the streaming capabilities of a radio.
 * This has probably been derived from the <streaming> block in radiomanifest.xml
 */
class RadioStreaming {
  constructor(sources) {
    this.sources = sources.sort(
      (a, b) => this.getPriority(a) < this.getPriority(b),
    );
  }

  /**
   * Get the list of possible options that are provided to the user
   * @returns {Array<string>}
   */
  getOptions() {
    return this.sources.map(function (x) {
      return x.getAttribute("name");
    });
  }

  /**
   * @private
   */
  getPriority(element) {
    return parseInt(getAttribute(element, "priority", "1"));
  }
  /**
   * @private
   */
  getTopPrioritySources() {
    var topPriority = this.getPriority(this.sources[0]);
    return this.sources.filter(
      (src) => parseInt(src.getAttribute("priority"), 10) === topPriority,
    );
  }
  /**
   * @return {string} url of the source. Note that this is much probably a playlist, in M3U format
   */
  getSource(name) {
    if (name === undefined) {
      return this.getTopPrioritySources()[0];
    }
    const s = this.sources.find(function (x) {
      return x.getAttribute("name") === name;
    });
    if (s === undefined) return s;
    return s.getAttribute("src");
  }

  /**
   * This is your go-to function whenever you need a list of URLs to play.
   * They will be picked honoring priorities, and expanding the playlist source
   * @return {Array<string>}
   */
  async pickURLs() {
    var allSources = this.getTopPrioritySources();
    var allAudios = [];
    for (let src of allSources) {
      let url = src.getAttribute("src");
      let resp = await fetch(url);
      allAudios.unshift(...parseM3U(await resp.text()));
    }
    return allAudios;
  }

  /**
   * Just like {@link RadioStreaming#pickURLs}, but get a single URL
   * @return {string}
   */
  async pickURL() {
    var allAudios = await this.pickURLs();
    return allAudios[0];
  }
}

/**
 * Create everything you need - **you should start from here**
 *
 * @param {string} siteurl URL of website you want to load
 * @param {Object} options options. Currenly unused
 * @return {Radio}
 */
async function get(siteurl, _options) {
  let resp = await fetch(getManifestUrl(siteurl));
  let text = await resp.text();

  const parser = new DOMParser();
  const dom = parser.parseFromString(text, "text/xml");
  const manifest = Radio.fromDOM(dom);

  try {
    manifest.shows = await shows.get(manifest);
  } catch (e) {
    console.error("Error while fetching shows file", e);
  }

  try {
    manifest.schedule = await calendar.get(manifest);
    if (manifest.schedule !== undefined) manifest.schedule.radio = manifest;
  } catch (e) {
    console.error("Error while fetching shows file", e);
  }

  resp = null;
  try {
    resp = await fetch(getStreaminfoUrl(siteurl));
  } catch (e) {
    true;
  }
  if (resp !== null) {
    try {
      text = await resp.text();

      const data = JSON.parse(text);
      const name = data["icy-name"];
      if (name !== undefined) {
        manifest.setName(name);
      }
      const desc = data["icy-description"];
      if (desc !== undefined) {
        manifest.setDescription(desc);
      }

      const logo = data["icy-logo"];
      if (desc !== undefined) {
        manifest.setLogo(logo);
      }
    } catch (e) {
      if (e instanceof SyntaxError) {
        true;
      } else {
        console.error("Error", e);
        throw e;
      }
    }
  }

  return manifest;
}

function parseM3U(body) {
  return body.split("\n").filter((line) => {
    if (line.startsWith("#")) {
      return false;
    } else {
      try {
        new URL(line);
        return true;
      } catch {
        return false;
      }
    }
  });
}

export default {
  get: get,
  objs: {
    Radio: Radio,
    RadioStreaming: RadioStreaming,
  },
  parsers: {
    M3U: parseM3U,
    radioManifest: Radio.fromDOM,
    shows: shows.parse,
  },
};