@molecule/api-feed-rss 1.0.0

package/dist/index.js

@@ -0,0 +1,72 @@
+/**
+ * RSS / Atom / JSON Feed **producer** for molecule.dev — pure-function
+ * serializers that turn a single normalized {@link Feed} structure into
+ * a valid RSS 2.0, Atom 1.0, or JSON Feed 1.1 document.
+ *
+ * Companion to `@molecule/api-feed-rss-parser` (the consumer side). Both
+ * packages share a similar normalized shape, so apps can ingest external
+ * feeds, store the items, and re-publish them through this package
+ * without intermediate translation layers.
+ *
+ * Apps that use this:
+ * - `blog` — emit `/feed.rss`, `/feed.atom`, `/feed.json` for posts.
+ * - `news-aggregator` — re-publish curated cross-source feeds.
+ * - `podcast` — RSS 2.0 with the iTunes namespace (set `feed.itunes`).
+ *
+ * @example One serializer per call
+ * ```ts
+ * import { serializeRss2, serializeAtom1, serializeJsonFeed } from '@molecule/api-feed-rss'
+ *
+ * const feed = {
+ *   title: 'My Blog',
+ *   link: 'https://example.com',
+ *   description: 'Posts about software',
+ *   items: [{ id: '1', title: 'Hello', link: 'https://example.com/p/1' }],
+ * }
+ *
+ * const rss = serializeRss2(feed)
+ * const atom = serializeAtom1(feed)
+ * const json = serializeJsonFeed(feed)
+ * ```
+ *
+ * @example HTTP handler with caching — Express adapter
+ * ```ts
+ * import { createFeedHandler, type Feed } from '@molecule/api-feed-rss'
+ *
+ * const loadFromDb = async (): Promise<Feed> => ({ title: 'My Feed', link: 'https://example.com', description: 'Latest posts', items: [] }) // your DB lookup
+ * const app = { get(_path: string, _fn: (req: any, res: any) => void): void {} } // your Express app
+ *
+ * const handle = createFeedHandler({
+ *   loadFeed: async () => loadFromDb(),
+ *   cacheTtlMs: 60_000,
+ * })
+ *
+ * // Serves GET /feed.rss, /feed.atom, /feed.json (keyed by extension).
+ * // The handler returns { status, headers, body } — map those onto any
+ * // framework's response (Fastify/Hono/raw http look the same).
+ * app.get('/feed.:ext', async (req, res) => {
+ *   const result = await handle({
+ *     extension: req.params.ext,
+ *     ifNoneMatch: req.get('If-None-Match'),
+ *   })
+ *   res.status(result.status).set(result.headers).send(result.body)
+ * })
+ * ```
+ *
+ * **Security**: every user-supplied field is escaped before serialization.
+ * RSS / Atom XML use {@link escapeXml} for text nodes, {@link escapeAttr}
+ * for attributes, {@link escapeUrl} for URL attributes (which neutralizes
+ * `javascript:` URIs), and {@link wrapCdata} for HTML content (with
+ * `]]>` splitting). JSON Feed relies on `JSON.stringify` for escaping.
+ *
+ * @module
+ */
+export * from './browser-guard.js';
+export * from './escape.js';
+export * from './handler.js';
+export * from './serializeAtom1.js';
+export * from './serializeFeed.js';
+export * from './serializeJsonFeed.js';
+export * from './serializeRss2.js';
+export * from './types.js';
+export * from './utilities.js';

package/dist/serializeAtom1.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Atom 1.0 serializer — accepts a {@link Feed} structure and returns a
+ * complete Atom 1.0 XML document string.
+ *
+ * @module
+ */
+import type { Feed, SerializeAtom1Options } from './types.js';
+/**
+ * Serialize a {@link Feed} to a complete Atom 1.0 XML document.
+ *
+ * Conforms to RFC 4287:
+ * - Declares `xmlns="http://www.w3.org/2005/Atom"` on the root.
+ * - Always emits required `<id>`, `<title>`, `<updated>` elements.
+ * - Each entry has `<id>`, `<title>`, `<updated>`.
+ * - HTML content is wrapped in CDATA inside `<content type="html">` /
+ *   `<summary type="html">`. Plain-text content uses `type="text"` with
+ *   raw escaping.
+ *
+ * **All user-supplied content is escaped** — text fields run through
+ * {@link escapeXml}, attribute values through {@link escapeAttr}, URLs
+ * through {@link escapeUrl} (which neutralizes `javascript:` URIs), and
+ * HTML-bearing fields are CDATA-wrapped via {@link wrapCdata}.
+ *
+ * @example
+ * ```ts
+ * import { serializeAtom1 } from '@molecule/api-feed-rss'
+ *
+ * const xml = serializeAtom1({
+ *   title: 'My Blog',
+ *   link: 'https://example.com',
+ *   description: 'Posts about software',
+ *   feedUrl: 'https://example.com/feed.atom',
+ *   updatedAt: new Date(),
+ *   items: [
+ *     {
+ *       id: 'urn:uuid:123',
+ *       title: 'Hello, world!',
+ *       link: 'https://example.com/posts/hello',
+ *       publishedAt: new Date(),
+ *       content: '<p>First post.</p>',
+ *     },
+ *   ],
+ * })
+ * ```
+ *
+ * @param feed - The feed structure to serialize.
+ * @param options - See {@link SerializeAtom1Options}.
+ * @returns Complete Atom 1.0 XML document string.
+ * @throws {FeedSerializeError} when required fields are missing.
+ */
+export declare function serializeAtom1(feed: Feed, options?: SerializeAtom1Options): string;
+//# sourceMappingURL=serializeAtom1.d.ts.map

package/dist/serializeAtom1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeAtom1.d.ts","sourceRoot":"","sources":["../src/serializeAtom1.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAwB,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAyFnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,qBAA0B,GAAG,MAAM,CA6CtF"}

package/dist/serializeAtom1.js

@@ -0,0 +1,176 @@
+/**
+ * Atom 1.0 serializer — accepts a {@link Feed} structure and returns a
+ * complete Atom 1.0 XML document string.
+ *
+ * @module
+ */
+import { escapeAttr, escapeUrl, escapeXml, wrapCdata } from './escape.js';
+import { assertFeedShape, indent, toIso } from './utilities.js';
+const ATOM_NS = 'http://www.w3.org/2005/Atom';
+/**
+ * Render an `<author>` block. Atom requires `<name>`; `<email>` and
+ * `<uri>` are optional. The `name` is supplied by callers — empty names
+ * fall back to `'Anonymous'` to keep the document well-formed.
+ *
+ * @param author - The author record.
+ * @param pretty - Whether to pretty-print children.
+ * @returns `<author>...</author>` XML string.
+ */
+function renderAuthor(author, pretty) {
+    const name = author.name && author.name !== '' ? author.name : 'Anonymous';
+    const parts = [`<name>${escapeXml(name)}</name>`];
+    if (author.email)
+        parts.push(`<email>${escapeXml(author.email)}</email>`);
+    if (author.url)
+        parts.push(`<uri>${escapeUrl(author.url)}</uri>`);
+    if (!pretty)
+        return `<author>${parts.join('')}</author>`;
+    return `<author>\n${indent(parts.join('\n'), 2)}\n</author>`;
+}
+/**
+ * Render a single `<entry>`.
+ *
+ * @param item - Feed item.
+ * @param feedUpdated - ISO timestamp used as `<updated>` fallback.
+ * @param pretty - Whether to pretty-print children.
+ * @returns `<entry>...</entry>` XML string.
+ */
+function renderEntry(item, feedUpdated, pretty) {
+    const lines = [];
+    lines.push(`<id>${escapeXml(item.id)}</id>`);
+    lines.push(`<title>${escapeXml(item.title)}</title>`);
+    if (item.link) {
+        lines.push(`<link rel="alternate" href="${escapeAttr(item.link)}"/>`);
+    }
+    // Atom requires <updated>. Fall back: item.updatedAt → publishedAt → feed updated.
+    const updated = toIso(item.updatedAt) ?? toIso(item.publishedAt) ?? feedUpdated;
+    lines.push(`<updated>${escapeXml(updated)}</updated>`);
+    const published = toIso(item.publishedAt);
+    if (published)
+        lines.push(`<published>${escapeXml(published)}</published>`);
+    if (item.authors) {
+        for (const author of item.authors) {
+            lines.push(renderAuthor(author, pretty));
+        }
+    }
+    if (item.categories) {
+        for (const cat of item.categories) {
+            lines.push(`<category term="${escapeAttr(cat)}"/>`);
+        }
+    }
+    if (item.summary !== undefined) {
+        lines.push(`<summary type="html">${wrapCdata(item.summary)}</summary>`);
+    }
+    if (item.content !== undefined) {
+        const isHtml = item.contentIsHtml !== false;
+        if (isHtml) {
+            lines.push(`<content type="html">${wrapCdata(item.content)}</content>`);
+        }
+        else {
+            lines.push(`<content type="text">${escapeXml(item.content)}</content>`);
+        }
+    }
+    if (item.enclosures) {
+        for (const enc of item.enclosures) {
+            const attrs = [
+                `rel="enclosure"`,
+                `href="${escapeAttr(enc.url)}"`,
+                `type="${escapeAttr(enc.type ?? 'application/octet-stream')}"`,
+            ];
+            if (Number.isFinite(enc.length))
+                attrs.push(`length="${escapeAttr(String(enc.length))}"`);
+            if (enc.title)
+                attrs.push(`title="${escapeAttr(enc.title)}"`);
+            lines.push(`<link ${attrs.join(' ')}/>`);
+        }
+    }
+    if (!pretty)
+        return `<entry>${lines.join('')}</entry>`;
+    return `<entry>\n${indent(lines.join('\n'), 2)}\n</entry>`;
+}
+/**
+ * Serialize a {@link Feed} to a complete Atom 1.0 XML document.
+ *
+ * Conforms to RFC 4287:
+ * - Declares `xmlns="http://www.w3.org/2005/Atom"` on the root.
+ * - Always emits required `<id>`, `<title>`, `<updated>` elements.
+ * - Each entry has `<id>`, `<title>`, `<updated>`.
+ * - HTML content is wrapped in CDATA inside `<content type="html">` /
+ *   `<summary type="html">`. Plain-text content uses `type="text"` with
+ *   raw escaping.
+ *
+ * **All user-supplied content is escaped** — text fields run through
+ * {@link escapeXml}, attribute values through {@link escapeAttr}, URLs
+ * through {@link escapeUrl} (which neutralizes `javascript:` URIs), and
+ * HTML-bearing fields are CDATA-wrapped via {@link wrapCdata}.
+ *
+ * @example
+ * ```ts
+ * import { serializeAtom1 } from '@molecule/api-feed-rss'
+ *
+ * const xml = serializeAtom1({
+ *   title: 'My Blog',
+ *   link: 'https://example.com',
+ *   description: 'Posts about software',
+ *   feedUrl: 'https://example.com/feed.atom',
+ *   updatedAt: new Date(),
+ *   items: [
+ *     {
+ *       id: 'urn:uuid:123',
+ *       title: 'Hello, world!',
+ *       link: 'https://example.com/posts/hello',
+ *       publishedAt: new Date(),
+ *       content: '<p>First post.</p>',
+ *     },
+ *   ],
+ * })
+ * ```
+ *
+ * @param feed - The feed structure to serialize.
+ * @param options - See {@link SerializeAtom1Options}.
+ * @returns Complete Atom 1.0 XML document string.
+ * @throws {FeedSerializeError} when required fields are missing.
+ */
+export function serializeAtom1(feed, options = {}) {
+    assertFeedShape(feed, 'atom-1.0');
+    const pretty = options.pretty !== false;
+    const xmlDecl = options.xmlDeclaration ?? '<?xml version="1.0" encoding="UTF-8"?>';
+    const feedUpdated = toIso(feed.updatedAt) ?? new Date().toISOString();
+    const root = [];
+    // <id> for the feed: the feedUrl if set, else the link.
+    const feedId = feed.feedUrl ?? feed.link;
+    root.push(`<id>${escapeXml(feedId)}</id>`);
+    root.push(`<title>${escapeXml(feed.title)}</title>`);
+    if (feed.description) {
+        root.push(`<subtitle>${escapeXml(feed.description)}</subtitle>`);
+    }
+    root.push(`<updated>${escapeXml(feedUpdated)}</updated>`);
+    root.push(`<link rel="alternate" href="${escapeAttr(feed.link)}"/>`);
+    if (feed.feedUrl) {
+        root.push(`<link rel="self" href="${escapeAttr(feed.feedUrl)}" type="application/atom+xml"/>`);
+    }
+    if (feed.language) {
+        // Atom uses xml:lang on the root, but we also expose it as an element
+        // for convenience. The xml:lang attribute is added on the root open tag below.
+    }
+    if (feed.imageUrl) {
+        root.push(`<logo>${escapeUrl(feed.imageUrl)}</logo>`);
+        root.push(`<icon>${escapeUrl(feed.imageUrl)}</icon>`);
+    }
+    if (feed.copyright) {
+        root.push(`<rights>${escapeXml(feed.copyright)}</rights>`);
+    }
+    if (feed.authors) {
+        for (const author of feed.authors) {
+            root.push(renderAuthor(author, pretty));
+        }
+    }
+    for (const item of feed.items) {
+        root.push(renderEntry(item, feedUpdated, pretty));
+    }
+    const langAttr = feed.language ? ` xml:lang="${escapeAttr(feed.language)}"` : '';
+    if (!pretty) {
+        return `${xmlDecl}<feed xmlns="${ATOM_NS}"${langAttr}>${root.join('')}</feed>`;
+    }
+    return `${xmlDecl}\n<feed xmlns="${ATOM_NS}"${langAttr}>\n${indent(root.join('\n'), 2)}\n</feed>`;
+}

package/dist/serializeFeed.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Format-discriminated dispatcher used by the HTTP handler factory.
+ *
+ * @module
+ */
+import type { Feed, FeedOutputFormat } from './types.js';
+/**
+ * The MIME type each format is served with.
+ */
+export declare const FEED_CONTENT_TYPES: Record<FeedOutputFormat, string>;
+/**
+ * Serialize a {@link Feed} to the body string for a given output format.
+ *
+ * Delegates to {@link serializeRss2} / {@link serializeAtom1} /
+ * {@link serializeJsonFeed}. Useful when callers want a single entry
+ * point keyed by a runtime-determined format (e.g. inside a route
+ * handler dispatching on the URL extension).
+ *
+ * @param feed - The feed structure.
+ * @param format - Target output format.
+ * @returns Serialized body string.
+ */
+export declare function serializeFeed(feed: Feed, format: FeedOutputFormat): string;
+//# sourceMappingURL=serializeFeed.d.ts.map

package/dist/serializeFeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeFeed.d.ts","sourceRoot":"","sources":["../src/serializeFeed.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAExD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAI/D,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAI1E"}

package/dist/serializeFeed.js

@@ -0,0 +1,35 @@
+/**
+ * Format-discriminated dispatcher used by the HTTP handler factory.
+ *
+ * @module
+ */
+import { serializeAtom1 } from './serializeAtom1.js';
+import { serializeJsonFeed } from './serializeJsonFeed.js';
+import { serializeRss2 } from './serializeRss2.js';
+/**
+ * The MIME type each format is served with.
+ */
+export const FEED_CONTENT_TYPES = {
+    'rss-2.0': 'application/rss+xml; charset=utf-8',
+    'atom-1.0': 'application/atom+xml; charset=utf-8',
+    'json-feed': 'application/feed+json; charset=utf-8',
+};
+/**
+ * Serialize a {@link Feed} to the body string for a given output format.
+ *
+ * Delegates to {@link serializeRss2} / {@link serializeAtom1} /
+ * {@link serializeJsonFeed}. Useful when callers want a single entry
+ * point keyed by a runtime-determined format (e.g. inside a route
+ * handler dispatching on the URL extension).
+ *
+ * @param feed - The feed structure.
+ * @param format - Target output format.
+ * @returns Serialized body string.
+ */
+export function serializeFeed(feed, format) {
+    if (format === 'rss-2.0')
+        return serializeRss2(feed);
+    if (format === 'atom-1.0')
+        return serializeAtom1(feed);
+    return serializeJsonFeed(feed);
+}

package/dist/serializeJsonFeed.d.ts

@@ -0,0 +1,43 @@
+/**
+ * JSON Feed 1.1 serializer — accepts a {@link Feed} structure and returns
+ * a complete JSON Feed document string.
+ *
+ * @module
+ */
+import type { Feed, SerializeJsonFeedOptions } from './types.js';
+/**
+ * Serialize a {@link Feed} to a complete JSON Feed 1.1 document.
+ *
+ * The output conforms to https://www.jsonfeed.org/version/1.1/ — the
+ * entire payload is built as plain JS objects then `JSON.stringify`-ed,
+ * so all string content is naturally JSON-escaped. No CDATA / XML
+ * escaping is applicable.
+ *
+ * @example
+ * ```ts
+ * import { serializeJsonFeed } from '@molecule/api-feed-rss'
+ *
+ * const json = serializeJsonFeed({
+ *   title: 'My Blog',
+ *   link: 'https://example.com',
+ *   description: 'Posts about software',
+ *   feedUrl: 'https://example.com/feed.json',
+ *   items: [
+ *     {
+ *       id: 'https://example.com/posts/hello',
+ *       title: 'Hello, world!',
+ *       link: 'https://example.com/posts/hello',
+ *       publishedAt: new Date(),
+ *       content: '<p>First post.</p>',
+ *     },
+ *   ],
+ * }, { pretty: true })
+ * ```
+ *
+ * @param feed - The feed structure to serialize.
+ * @param options - See {@link SerializeJsonFeedOptions}.
+ * @returns Complete JSON Feed 1.1 document string.
+ * @throws {FeedSerializeError} when required fields are missing.
+ */
+export declare function serializeJsonFeed(feed: Feed, options?: SerializeJsonFeedOptions): string;
+//# sourceMappingURL=serializeJsonFeed.d.ts.map

package/dist/serializeJsonFeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeJsonFeed.d.ts","sourceRoot":"","sources":["../src/serializeJsonFeed.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAc,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAmB5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,wBAA6B,GAAG,MAAM,CAsE5F"}

package/dist/serializeJsonFeed.js

@@ -0,0 +1,128 @@
+/**
+ * JSON Feed 1.1 serializer — accepts a {@link Feed} structure and returns
+ * a complete JSON Feed document string.
+ *
+ * @module
+ */
+import { assertFeedShape, toIso } from './utilities.js';
+const JSON_FEED_VERSION = 'https://jsonfeed.org/version/1.1';
+/**
+ * Map a {@link FeedAuthor} to the JSON Feed 1.1 author shape.
+ *
+ * @param author - The author record.
+ * @returns Object containing the populated subset of name / url / avatar.
+ */
+function jsonAuthor(author) {
+    const out = {};
+    if (author.name)
+        out.name = author.name;
+    if (author.url)
+        out.url = author.url;
+    if (author.avatarUrl)
+        out.avatar = author.avatarUrl;
+    return out;
+}
+/**
+ * Serialize a {@link Feed} to a complete JSON Feed 1.1 document.
+ *
+ * The output conforms to https://www.jsonfeed.org/version/1.1/ — the
+ * entire payload is built as plain JS objects then `JSON.stringify`-ed,
+ * so all string content is naturally JSON-escaped. No CDATA / XML
+ * escaping is applicable.
+ *
+ * @example
+ * ```ts
+ * import { serializeJsonFeed } from '@molecule/api-feed-rss'
+ *
+ * const json = serializeJsonFeed({
+ *   title: 'My Blog',
+ *   link: 'https://example.com',
+ *   description: 'Posts about software',
+ *   feedUrl: 'https://example.com/feed.json',
+ *   items: [
+ *     {
+ *       id: 'https://example.com/posts/hello',
+ *       title: 'Hello, world!',
+ *       link: 'https://example.com/posts/hello',
+ *       publishedAt: new Date(),
+ *       content: '<p>First post.</p>',
+ *     },
+ *   ],
+ * }, { pretty: true })
+ * ```
+ *
+ * @param feed - The feed structure to serialize.
+ * @param options - See {@link SerializeJsonFeedOptions}.
+ * @returns Complete JSON Feed 1.1 document string.
+ * @throws {FeedSerializeError} when required fields are missing.
+ */
+export function serializeJsonFeed(feed, options = {}) {
+    assertFeedShape(feed, 'json-feed');
+    const out = {
+        version: JSON_FEED_VERSION,
+        title: feed.title,
+        home_page_url: feed.link,
+    };
+    if (feed.feedUrl)
+        out.feed_url = feed.feedUrl;
+    if (feed.description)
+        out.description = feed.description;
+    if (feed.language)
+        out.language = feed.language;
+    if (feed.imageUrl) {
+        out.icon = feed.imageUrl;
+        out.favicon = feed.imageUrl;
+    }
+    if (feed.authors && feed.authors.length > 0) {
+        out.authors = feed.authors.map(jsonAuthor);
+    }
+    out.items = feed.items.map((item) => {
+        const obj = {
+            id: item.id,
+            title: item.title,
+        };
+        if (item.link) {
+            obj.url = item.link;
+            obj.external_url = item.link;
+        }
+        if (item.summary !== undefined)
+            obj.summary = item.summary;
+        if (item.content !== undefined) {
+            const isHtml = item.contentIsHtml !== false;
+            if (isHtml)
+                obj.content_html = item.content;
+            else
+                obj.content_text = item.content;
+        }
+        const datePublished = toIso(item.publishedAt);
+        if (datePublished)
+            obj.date_published = datePublished;
+        const dateModified = toIso(item.updatedAt);
+        if (dateModified)
+            obj.date_modified = dateModified;
+        if (item.authors && item.authors.length > 0) {
+            obj.authors = item.authors.map(jsonAuthor);
+        }
+        if (item.categories && item.categories.length > 0) {
+            obj.tags = [...item.categories];
+        }
+        if (item.enclosures && item.enclosures.length > 0) {
+            obj.attachments = item.enclosures.map((enc) => {
+                const att = {
+                    url: enc.url,
+                    mime_type: enc.type ?? 'application/octet-stream',
+                };
+                if (Number.isFinite(enc.length))
+                    att.size_in_bytes = enc.length;
+                if (Number.isFinite(enc.durationSeconds)) {
+                    att.duration_in_seconds = enc.durationSeconds;
+                }
+                if (enc.title)
+                    att.title = enc.title;
+                return att;
+            });
+        }
+        return obj;
+    });
+    return options.pretty ? JSON.stringify(out, null, 2) : JSON.stringify(out);
+}

package/dist/serializeRss2.d.ts

@@ -0,0 +1,48 @@
+/**
+ * RSS 2.0 serializer — accepts a {@link Feed} structure and returns a
+ * complete RSS 2.0 XML document string.
+ *
+ * @module
+ */
+import type { Feed, SerializeRss2Options } from './types.js';
+/**
+ * Serialize a {@link Feed} to a complete RSS 2.0 XML document.
+ *
+ * The output is valid RSS 2.0 — declares the `dc`, `content`, and `atom`
+ * namespaces always, plus `itunes` when {@link Feed.itunes} is present.
+ *
+ * **All user-supplied content is escaped** — text fields run through
+ * {@link escapeXml}, attribute values through {@link escapeAttr}, URLs
+ * through {@link escapeUrl} (which neutralizes `javascript:` URIs), and
+ * HTML-bearing fields (`description`, `content:encoded`,
+ * `itunes:summary`) are CDATA-wrapped via {@link wrapCdata} with
+ * `]]>` splitting.
+ *
+ * @example
+ * ```ts
+ * import { serializeRss2 } from '@molecule/api-feed-rss'
+ *
+ * const xml = serializeRss2({
+ *   title: 'My Blog',
+ *   link: 'https://example.com',
+ *   description: 'Posts about software',
+ *   feedUrl: 'https://example.com/feed.xml',
+ *   items: [
+ *     {
+ *       id: 'https://example.com/posts/hello',
+ *       title: 'Hello, world!',
+ *       link: 'https://example.com/posts/hello',
+ *       publishedAt: new Date(),
+ *       content: '<p>First post.</p>',
+ *     },
+ *   ],
+ * })
+ * ```
+ *
+ * @param feed - The feed structure to serialize.
+ * @param options - See {@link SerializeRss2Options}.
+ * @returns Complete RSS 2.0 XML document string.
+ * @throws {FeedSerializeError} when required fields are missing.
+ */
+export declare function serializeRss2(feed: Feed, options?: SerializeRss2Options): string;
+//# sourceMappingURL=serializeRss2.d.ts.map

package/dist/serializeRss2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeRss2.d.ts","sourceRoot":"","sources":["../src/serializeRss2.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAY,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAyGtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,oBAAyB,GAAG,MAAM,CAiGpF"}