123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308
import { SAXParser } from "../deps.ts";import type {  Atom,  DeserializationResult,  Feed,  JsonFeed,  RSS1,  RSS2,} from "./types/mod.ts";import type { ResolverResult } from "./resolvers/types/resolver_result.ts";import { FeedParseType, FeedType } from "./types/mod.ts";import {  isAtomCDataField,  resolveAtomField,  resolveRss1Field,  resolveRss2Field,} from "./resolvers/mod.ts";import {  toFeed,  toJsonFeed,  toLegacyAtom,  toLegacyRss1,  toLegacyRss2,} from "./mappers/mod.ts";
/** * Parse Atom or RSS into a common Feed type * @param Atom or RSS XML string */export async function parseFeed(input: string): Promise<Feed> {  if (!input) {    throw new Error("Input was undefined, null or empty");  }
  const { data, feedType } = await parse(input);  return toFeed(feedType, data)!;}
export interface Options {  outputJsonFeed?: boolean;}
/** * @deprecated The method should not be used, please use the parseFeed method instead. */export const deserializeFeed = (async (  input: string,  options?: Options,) => {  const { data, feedType } = await parse(input);  let legacyFeed;  switch (feedType) {    case FeedType.Rss1:      legacyFeed = toLegacyRss1(data) as any;      break;    case FeedType.Rss2:      legacyFeed = toLegacyRss2(data) as any;      break;    case FeedType.Atom:      legacyFeed = toLegacyAtom(data) as any;      break;    default:      legacyFeed = data;      break;  }
  const result: DeserializationResult<Atom | RSS1 | RSS2 | JsonFeed> & {    originalFeedType?: FeedType;  } = {    feed: options?.outputJsonFeed      ? toJsonFeed(feedType, legacyFeed)      : legacyFeed,    feedType: options?.outputJsonFeed ? FeedType.JsonFeed : feedType,    originalFeedType: feedType,  };
  return result;}) as {  (input: string): Promise<DeserializationResult<Atom | RSS1 | RSS2>>;  (    input: string,    options: Options & { outputJsonFeed: false },  ): Promise<DeserializationResult<Atom | RSS1 | RSS2>>;  (    input: string,    options: Options & { outputJsonFeed: true },  ): Promise<    DeserializationResult<JsonFeed> & { originalFeedType: FeedType }  >;  (    input: string,    options?: Options,  ): Promise<DeserializationResult<Atom | JsonFeed | RSS1 | RSS2>>;};
const parse = (input: string) =>  new Promise<{ feedType: FeedType; data: any }>(    (resolve, reject) => {      if (!input) {        reject(new Error("Input was undefined, null or empty"));        return;      }
      //	Handle invalid feed documents by converting the description field to CDATA.      input = input        .replaceAll(          /<description>(?!(\s*<!\[CDATA))/g,          `<description><![CDATA[`,        )        .replaceAll(/(?<!\]\]>\s*)<\/description>/g, `]]></description>`);
      let cDataLevel: number;      let cDataBuilder: string;      let cDataActive: boolean;      let feedType: FeedType;
      let currentTag: OpenTag | undefined;      const stack: any[] = [{}];      const parser = new SAXParser(false, {        trim: true,        lowercase: true,      });
      let resolveField: (        nodeName: string,      ) => ResolverResult;
      let isCDataField: (nodeName: string) => boolean;
      parser.oncdata = parser.ontext = (text: string): void => {        if (cDataActive) {          cDataBuilder += text;        } else {          stack[stack.length - 1].value = text.trim();        }      };
      const onOpenTag = (node: OpenTag): void => {        currentTag = node;        const attributeNames = Object.keys(node.attributes);
        if (cDataActive) {          const attributes = attributeNames            .map((key) => `${key}="${(node.attributes as any)[key]}"`)            .join(" ")            .trim();
          if (attributes.length) {            cDataBuilder += `<${node.name} ${attributes}${(node.isSelfClosing              ? " /"              : "")}>`;          } else {            cDataBuilder += `<${node.name}${(node.isSelfClosing ? " /" : "")}>`;          }
          cDataLevel++;          return;        }
        if (isCDataField(node.name)) {          cDataActive = true;          cDataBuilder = "";          cDataLevel = 0;        }
        const newNode = attributeNames.reduce((builder, attrName) => {          const val = (node.attributes as any)[attrName];          if (val !== undefined && val !== null) {            const { name, isInt, isFloat, isDate } = resolveField(attrName);
            if (isInt) {              builder[name] = parseInt(val);            } else if (isFloat) {              builder[name] = parseFloat(val);            } else if (isDate) {              builder[name + "Raw"] = val;              builder[name] = new Date(val);            } else {              builder[name] = val;            }          }
          return builder;        }, {} as any);
        stack.push(newNode);      };
      parser.onclosetag = (nodeName: string) => {        const currentStartTag = currentTag;        currentTag = undefined;        if (cDataActive && cDataLevel) {          if (!currentStartTag?.isSelfClosing) {            cDataBuilder += `</${nodeName}>`;          }
          cDataLevel--;          return;        }
        let node = stack.pop();
        if (stack.length === 0) {          Object.assign(parser, {            onopentag: undefined,            onclosetag: undefined,            ontext: undefined,            oncdata: undefined,          });
          const result = {            feedType: feedType,            data: node,          };
          resolve(result);          return;        }
        const targetNode = stack[stack.length - 1];        const {          name,          isArray,          isInt,          isFloat,          isDate,        } = resolveField(nodeName);
        if (cDataActive) {          node.value = cDataBuilder;          targetNode[name] = node;          cDataBuilder = "";          cDataActive = false;          cDataLevel = 0;          return;        }
        if (node.value !== undefined && node.value !== null) {          if (isInt) {            node.value = parseInt(node.value);          } else if (isFloat) {            node.value = parseFloat(node.value);          } else if (isDate) {            targetNode[name + "Raw"] = { value: node.value };            node.value = new Date(node.value);          }        }
        if (isArray) {          if (!targetNode[name]) {            targetNode[name] = [node];          } else {            targetNode[name].push(node);          }        } else {          const isEmpty = (typeof node === "object") &&            Object.keys(node).length === 0 &&            !(node instanceof Date);          try {            if (!isEmpty) {              targetNode[name] = node;            }          } catch {            console.warn(              `Failed to add property ${name} on node`,              targetNode,            );          }        }      };
      parser.onopentag = (node: OpenTag) => {        switch (node.name) {          case FeedParseType.Atom:            feedType = FeedType.Atom;            isCDataField = isAtomCDataField;            resolveField = resolveAtomField;            break;          case FeedParseType.Rss2:            feedType = FeedType.Rss2;            isCDataField = () => false;            resolveField = resolveRss2Field;            break;          case FeedParseType.Rss1:            feedType = FeedType.Rss1;            isCDataField = () => false;            resolveField = resolveRss1Field;            break;          default:            reject(new Error(`Type ${node.name} is not supported`));            break;        }        parser.onopentag = onOpenTag;      };
      parser        .write(input)        .close()        .flush();    },  );
interface OpenTag {  name: string;  attributes: {};  isSelfClosing: boolean;}