@au5ton/use-atom-feed/dist/use-atom-feed.esm.js

import { sanitize } from 'dompurify';
import useSWR from 'swr';
import { parseFeed } from 'htmlparser2';

/** searches for a tag in the node list, prevents recursive searches */

var findByTag = function findByTag(nodes, tagName) {
  return Array.from(nodes).find(function (e) {
    return e.nodeName === tagName;
  });
};
/** searches for nodes which have a matching tagName, prevents recursive searches */


var filterByTag = function filterByTag(nodes, tagName) {
  return Array.from(nodes).filter(function (e) {
    return e.nodeName === tagName;
  });
};
/** shortcut method for `findByTag()` that accesses children */


var findChildTag = function findChildTag(parent, tagName) {
  return findByTag(parent.children, tagName);
};
/** shortcut method for `filterByTag()` that accesses children */


var filterChildTags = function filterChildTags(parent, tagName) {
  return filterByTag(parent.children, tagName);
};
/** parses the feed */


function parseAtomFeed(data) {
  var parser = new DOMParser();
  var xml = parser.parseFromString(data, 'text/xml');
  var feed = findChildTag(xml, 'feed');

  if (feed) {
    var _sanitizeTextContent, _findChildTag$textCon, _findChildTag, _sanitizeTextContent2;

    return {
      id: (_sanitizeTextContent = sanitizeTextContent(findChildTag(feed, 'id'))) != null ? _sanitizeTextContent : '',
      title: parseAtomText(findChildTag(feed, 'title')),
      updated: new Date((_findChildTag$textCon = (_findChildTag = findChildTag(feed, 'updated')) == null ? void 0 : _findChildTag.textContent) != null ? _findChildTag$textCon : 0),
      entries: filterChildTags(feed, 'entry').map(function (e) {
        return parseAtomEntry(e);
      }),
      author: filterChildTags(feed, 'author').map(function (author) {
        return parseAtomPerson(author);
      }),
      link: filterChildTags(feed, 'link').map(function (link) {
        return parseAtomLink(link);
      }),
      category: filterChildTags(feed, 'category').map(function (category) {
        return parseAtomCategory(category);
      }),
      contributor: filterChildTags(feed, 'contributor').map(function (contributor) {
        return parseAtomPerson(contributor);
      }),
      generator: {
        value: (_sanitizeTextContent2 = sanitizeTextContent(findChildTag(feed, 'generator'))) != null ? _sanitizeTextContent2 : '',
        uri: sanitizeTextAttribute(findChildTag(feed, 'generator'), 'uri'),
        version: sanitizeTextAttribute(findChildTag(feed, 'generator'), 'version')
      },
      icon: sanitizeTextContent(findChildTag(feed, 'icon')),
      logo: sanitizeTextContent(findChildTag(feed, 'logo')),
      rights: parseAtomText(findChildTag(feed, 'rights')),
      subtitle: sanitizeTextContent(findChildTag(feed, 'subtitle'))
    };
  }

  throw Error('No <feed> tag found.');
}
function parseAtomEntry(entry) {
  var _sanitizeTextContent3, _findChildTag$textCon2, _findChildTag2, _findChildTag$textCon3, _findChildTag3;

  return {
    id: (_sanitizeTextContent3 = sanitizeTextContent(findChildTag(entry, 'id'))) != null ? _sanitizeTextContent3 : '',
    title: parseAtomText(findChildTag(entry, 'title')),
    updated: new Date((_findChildTag$textCon2 = (_findChildTag2 = findChildTag(entry, 'updated')) == null ? void 0 : _findChildTag2.textContent) != null ? _findChildTag$textCon2 : 0),
    author: filterChildTags(entry, 'author').map(function (author) {
      return parseAtomPerson(author);
    }),
    content: parseAtomContent(findChildTag(entry, 'content')),
    link: filterChildTags(entry, 'link').map(function (link) {
      return parseAtomLink(link);
    }),
    summary: parseAtomText(findChildTag(entry, 'summary')),
    category: filterChildTags(entry, 'category').map(function (category) {
      return parseAtomCategory(category);
    }),
    contributor: filterChildTags(entry, 'contributor').map(function (contributor) {
      return parseAtomPerson(contributor);
    }),
    published: findChildTag(entry, 'published') ? new Date((_findChildTag$textCon3 = (_findChildTag3 = findChildTag(entry, 'published')) == null ? void 0 : _findChildTag3.textContent) != null ? _findChildTag$textCon3 : 0) : undefined,
    rights: parseAtomText(findChildTag(entry, 'rights')),
    source: parseAtomSource(findChildTag(entry, 'source'))
  };
}
/** safely decode text content */

function safelyDecodeAtomText(type, element) {
  if (element !== undefined) {
    var _element$textContent;

    // If type="xhtml", then this element contains inline xhtml, wrapped in a div element.
    // This means that the existing `.innerHTML` is ready to be santized
    if (type === 'xhtml') return sanitize(element.innerHTML); // If type="html", then this element contains entity escaped html.
    // using `.textContent` will un-escape the text
    else if (type === 'html') return sanitize((_element$textContent = element.textContent) != null ? _element$textContent : ''); // If type="text", then this element contains plain text with no entity escaped html.
      // This means that the content of `.innerHTML` are **intended** to be safe.
      // However, we don't want to leave an attack vector open, so we're going to sanitize it anyway.
      else if (type === 'text') return sanitize(element.innerHTML);
  }

  return '';
}
/** shortcut for safely decoding the `.textContent` value of an element */

function sanitizeTextContent(element) {
  var _element$textContent2;

  return element !== undefined ? sanitize((_element$textContent2 = element == null ? void 0 : element.textContent) != null ? _element$textContent2 : '') : undefined;
}
/** shortcut for safely decoding the an attribute value of an element */

function sanitizeTextAttribute(element, attributeName) {
  return element !== undefined ? element.getAttribute(attributeName) !== null ? sanitize(element.getAttribute(attributeName)) : undefined : undefined;
}
function parseAtomContent(content) {
  var _sanitizeTextAttribut;

  var type = (_sanitizeTextAttribut = sanitizeTextAttribute(content, 'type')) != null ? _sanitizeTextAttribut : undefined;
  return {
    type: type,
    src: sanitizeTextAttribute(content, 'src'),
    value: safelyDecodeAtomText(type, content)
  };
}
function parseAtomText(text) {
  var _sanitizeTextAttribut2;

  var type = (_sanitizeTextAttribut2 = sanitizeTextAttribute(text, 'type')) != null ? _sanitizeTextAttribut2 : undefined;
  return {
    type: type,
    value: safelyDecodeAtomText(type, text)
  };
}
function parseAtomPerson(person) {
  var _findChildTag$textCon4, _findChildTag4;

  return {
    name: sanitize((_findChildTag$textCon4 = (_findChildTag4 = findChildTag(person, 'name')) == null ? void 0 : _findChildTag4.textContent) != null ? _findChildTag$textCon4 : ''),
    uri: sanitizeTextContent(findChildTag(person, 'uri')),
    email: sanitizeTextContent(findChildTag(person, 'email'))
  };
}
function parseAtomLink(link) {
  var _sanitizeTextAttribut3;

  return {
    href: (_sanitizeTextAttribut3 = sanitizeTextAttribute(link, 'href')) != null ? _sanitizeTextAttribut3 : '',
    rel: sanitizeTextAttribute(link, 'ref'),
    type: sanitizeTextAttribute(link, 'type'),
    hreflang: sanitizeTextAttribute(link, 'hreflang'),
    title: sanitizeTextAttribute(link, 'title'),
    length: sanitizeTextAttribute(link, 'length')
  };
}
function parseAtomCategory(category) {
  var _sanitizeTextAttribut4, _sanitizeTextAttribut5, _sanitizeTextAttribut6;

  return {
    term: (_sanitizeTextAttribut4 = sanitizeTextAttribute(category, 'term')) != null ? _sanitizeTextAttribut4 : '',
    scheme: (_sanitizeTextAttribut5 = sanitizeTextAttribute(category, 'scheme')) != null ? _sanitizeTextAttribut5 : undefined,
    label: (_sanitizeTextAttribut6 = sanitizeTextAttribute(category, 'label')) != null ? _sanitizeTextAttribut6 : undefined
  };
}
function parseAtomSource(source) {
  if (source !== undefined) {
    var _sanitizeTextContent4, _sanitizeTextContent5, _findChildTag$textCon5, _findChildTag5;

    return {
      id: (_sanitizeTextContent4 = sanitizeTextContent(findChildTag(source, 'id'))) != null ? _sanitizeTextContent4 : '',
      title: (_sanitizeTextContent5 = sanitizeTextContent(findChildTag(source, 'title'))) != null ? _sanitizeTextContent5 : '',
      updated: new Date((_findChildTag$textCon5 = (_findChildTag5 = findChildTag(source, 'title')) == null ? void 0 : _findChildTag5.textContent) != null ? _findChildTag$textCon5 : 0)
    };
  }

  return undefined;
}

var Parser = {
  __proto__: null,
  parseAtomFeed: parseAtomFeed,
  parseAtomEntry: parseAtomEntry,
  safelyDecodeAtomText: safelyDecodeAtomText,
  sanitizeTextContent: sanitizeTextContent,
  sanitizeTextAttribute: sanitizeTextAttribute,
  parseAtomContent: parseAtomContent,
  parseAtomText: parseAtomText,
  parseAtomPerson: parseAtomPerson,
  parseAtomLink: parseAtomLink,
  parseAtomCategory: parseAtomCategory,
  parseAtomSource: parseAtomSource
};

function isAtomFeed(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && typeof obj.id === "string" && isAtomTitle(obj.title) && obj.updated instanceof Date && Array.isArray(obj.entries) && obj.entries.every(function (e) {
    return isAtomEntry(e);
  }) && (typeof obj.author === "undefined" || Array.isArray(obj.author) && obj.author.every(function (e) {
    return isAtomAuthor(e);
  })) && (typeof obj.link === "undefined" || Array.isArray(obj.link) && obj.link.every(function (e) {
    return isAtomLink(e);
  })) && (typeof obj.category === "undefined" || Array.isArray(obj.category) && obj.category.every(function (e) {
    return isAtomCategory(e);
  })) && (typeof obj.contributor === "undefined" || Array.isArray(obj.contributor) && obj.contributor.every(function (e) {
    return isAtomContributor(e);
  })) && (typeof obj.generator === "undefined" || isAtomGenerator(obj.generator)) && (typeof obj.icon === "undefined" || typeof obj.icon === "string") && (typeof obj.logo === "undefined" || typeof obj.logo === "string") && (typeof obj.rights === "undefined" || isAtomRights(obj.rights)) && (typeof obj.subtitle === "undefined" || typeof obj.subtitle === "string");
}
function isAtomGenerator(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && typeof obj.value === "string" && (typeof obj.uri === "undefined" || typeof obj.uri === "string") && (typeof obj.version === "undefined" || typeof obj.version === "string");
}
function isAtomEntry(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && typeof obj.id === "string" && isAtomTitle(obj.title) && obj.updated instanceof Date && (typeof obj.author === "undefined" || Array.isArray(obj.author) && obj.author.every(function (e) {
    return isAtomAuthor(e);
  })) && (typeof obj.content === "undefined" || isAtomContent(obj.content)) && (typeof obj.link === "undefined" || Array.isArray(obj.link) && obj.link.every(function (e) {
    return isAtomLink(e);
  })) && (typeof obj.summary === "undefined" || isAtomSummary(obj.summary)) && (typeof obj.category === "undefined" || Array.isArray(obj.category) && obj.category.every(function (e) {
    return isAtomCategory(e);
  })) && (typeof obj.contributor === "undefined" || Array.isArray(obj.contributor) && obj.contributor.every(function (e) {
    return isAtomContributor(e);
  })) && (typeof obj.published === "undefined" || obj.published instanceof Date) && (typeof obj.rights === "undefined" || isAtomRights(obj.rights)) && (typeof obj.source === "undefined" || isAtomSource(obj.source));
}
function isAtomSource(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && typeof obj.id === "string" && typeof obj.title === "string" && obj.updated instanceof Date;
}
function isAtomCategory(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && typeof obj.term === "string" && (typeof obj.scheme === "undefined" || typeof obj.scheme === "string") && (typeof obj.label === "undefined" || typeof obj.label === "string");
}
function isAtomContent(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && (typeof obj.type === "undefined" || obj.type === "text" || obj.type === "html" || obj.type === "xhtml") && (typeof obj.src === "undefined" || typeof obj.src === "string") && typeof obj.value === "string";
}
function isAtomLink(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && typeof obj.href === "string" && (typeof obj.rel === "undefined" || obj.rel === "alternate" || obj.rel === "enclosure" || obj.rel === "related" || obj.rel === "self" || obj.rel === "via") && (typeof obj.type === "undefined" || typeof obj.type === "string") && (typeof obj.hreflang === "undefined" || typeof obj.hreflang === "string") && (typeof obj.title === "undefined" || typeof obj.title === "string") && (typeof obj.length === "undefined" || typeof obj.length === "string");
}
function isAtomPerson(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && typeof obj.name === "string" && (typeof obj.uri === "undefined" || typeof obj.uri === "string") && (typeof obj.email === "undefined" || typeof obj.email === "string");
}
function isAtomLinkRelType(obj, _argumentName) {
  return obj === "alternate" || obj === "enclosure" || obj === "related" || obj === "self" || obj === "via";
}
function isAtomAuthor(obj, _argumentName) {
  return isAtomPerson(obj);
}
function isAtomContributor(obj, _argumentName) {
  return isAtomPerson(obj);
}
function isAtomText(obj, _argumentName) {
  return (obj !== null && typeof obj === "object" || typeof obj === "function") && (typeof obj.type === "undefined" || obj.type === "text" || obj.type === "html" || obj.type === "xhtml") && typeof obj.value === "string";
}
function isAtomTextType(obj, _argumentName) {
  return obj === "text" || obj === "html" || obj === "xhtml";
}
function isAtomTitle(obj, _argumentName) {
  return isAtomText(obj);
}
function isAtomSummary(obj, _argumentName) {
  return isAtomText(obj);
}
function isAtomRights(obj, _argumentName) {
  return isAtomText(obj);
}

var index_guard = {
  __proto__: null,
  isAtomFeed: isAtomFeed,
  isAtomGenerator: isAtomGenerator,
  isAtomEntry: isAtomEntry,
  isAtomSource: isAtomSource,
  isAtomCategory: isAtomCategory,
  isAtomContent: isAtomContent,
  isAtomLink: isAtomLink,
  isAtomPerson: isAtomPerson,
  isAtomLinkRelType: isAtomLinkRelType,
  isAtomAuthor: isAtomAuthor,
  isAtomContributor: isAtomContributor,
  isAtomText: isAtomText,
  isAtomTextType: isAtomTextType,
  isAtomTitle: isAtomTitle,
  isAtomSummary: isAtomSummary,
  isAtomRights: isAtomRights
};

/**
 * The React hook used for reading the Atom feed.
 * @param feedURL The URL of the Atom feed
 * @param options Options that are passed to `useSWR()` behind the scenes.
 *  More info: https://swr.vercel.app/docs/options#options
 * @returns The decoded Atom feed or any errors seen along the way
 */

function useAtomFeed(feedURL, options) {
  var fetcher = function fetcher(url) {
    return fetch(url).then(function (res) {
      return res.text();
    });
  };

  var _useSWR = useSWR(feedURL, fetcher, options),
      data = _useSWR.data,
      error = _useSWR.error,
      isValidating = _useSWR.isValidating; // if data is defined


  if (data) {
    // attempt to decode
    try {
      var decoded = parseFeed(data, {
        xmlMode: true
      }); // return a good decode

      return {
        data: decoded,
        error: error,
        isValidating: isValidating
      };
    } catch (parseError) {
      // return a decode failure
      return {
        data: undefined,
        error: parseError,
        isValidating: isValidating
      };
    }
  } else {
    // data is undefined
    return {
      data: undefined,
      error: error,
      isValidating: isValidating
    };
  }
}

export { index_guard as Guards, Parser, useAtomFeed };
//# sourceMappingURL=use-atom-feed.esm.js.map