将博客订阅格式改为Atom

// source: https://github.com/gsong/personal-site/blob/main/src/pages/atom.xml.ts
import type { APIContext } from "astro";

import { generateFeed } from "@/utils/feeds";

export async function GET(context: APIContext) {
  const feed = await generateFeed(context);
  return new Response(feed.atom1(), {
    headers: { "Content-Type": "application/atom+xml" },
  });
}

// source: https://github.com/gsong/personal-site/blob/main/src/pages/rss.xml.ts
import type { APIContext } from "astro";

import { generateFeed } from "@/utils/feeds";

export async function GET(context: APIContext) {
  const feed = await generateFeed(context);
  return new Response(feed.rss2(), {
    headers: { "Content-Type": "application/xml" },
  });
}

//utils.ts
// source:https://github.com/gsong/personal-site/blob/main/src/data/feeds/utils.ts
import type { Root as HastRoot, RootContent } from "hast";
import type { Root as MdastRoot } from "mdast";
import type { Plugin } from "unified";

import { Buffer } from "node:buffer";

import minifyHtml from "@minify-html/node";
import rehypeStringify from "rehype-stringify";
import remarkMarkers from "remark-flexible-markers";
import remarkMdx from "remark-mdx";
import remarkParse from "remark-parse";
import remarkRehype from "remark-rehype";
import { unified } from "unified";

type UrlLike = URL | string;

export async function mdxToHtml(
  mdxContent: string,
  site: UrlLike,
): Promise<string> {
  const result = await unified()
    .use(remarkParse)
    .use(remarkMdx)
    .use(remarkMarkers, { markerClassName: () => [] })
    .use(remarkRemoveToc)
    .use(remarkRemoveImports)
    .use(remarkRehype)
    .use(rehypeAbsoluteUrls, site)
    .use(rehypeStringify)
    .process(mdxContent);

  return minifyHtml
    .minify(Buffer.from(result.toString()), { keep_closing_tags: true })
    .toString();
}

export function createUrl(path: string, baseUrl: UrlLike): string | null {
  try {
    const fullUrl = new URL(path, baseUrl);
    return fullUrl.href;
  } catch (error) {
    console.error("Invalid path or base URL:", error);
    return null;
  }
}

// Remark plugins
const remarkRemoveImports: Plugin<[], MdastRoot> = () => {
  return (tree) => {
    tree.children = tree.children.filter((node) => node.type !== "mdxjsEsm");
    return tree;
  };
};

const remarkRemoveToc: Plugin<[], MdastRoot> = () => {
  return (tree: MdastRoot) => {
    tree.children = tree.children.filter((node) => {
      if (node.type === "heading" && node.depth === 2) {
        const text = node.children
          .filter((child) => child.type === "text")
          .map((child) => child.value)
          .join("")
          .trim();
        const tocRegex = /(table[ -]of[ -])?contents?|toc/i;
        return !tocRegex.test(text);
      }
      return true;
    });
    return tree;
  };
};

// Rehype plugins
const rehypeAbsoluteUrls: Plugin<[UrlLike], HastRoot> = (baseUrl) => {
  return (tree) => {
    const visit = (node: RootContent | HastRoot) => {
      if (node.type === "element") {
        if (node.tagName === "a" && node.properties?.href) {
          node.properties.href = createUrl(
            node.properties.href as string,
            baseUrl,
          );
        }
      }
      if ("children" in node) {
        node.children.forEach(visit);
      }
    };
    visit(tree);
    return tree;
  };
};

//index.ts
// source:https://github.com/gsong/personal-site/blob/main/src/data/feeds/index.ts
import type { APIContext } from "astro";
import type { Author, FeedOptions } from "feed";
import { USER_NAME, SITE_DESCRIPTION, SITE_LANGUAGE,  SITE_TITLE } from "@config";
import { getCollection } from "astro:content";
import { Feed } from "feed";

import { createUrl, mdxToHtml } from "./utils";

interface SiteAuthor extends Author {
  link: string;
}


export async function generateFeed(context: APIContext): Promise<Feed> {
  // biome-ignore lint/style/noNonNullAssertion: we know
  const site = context.site!.toString();
  const author: SiteAuthor = {
    name: USER_NAME,
    email: "[email protected]",
    link: site,
  };
  const feed = createFeedInstance(site, author);

  await addArticlesToFeed(feed, site, author);

  return feed;
}

function createFeedInstance(site: string, author: SiteAuthor): Feed {
  const feedOptions: FeedOptions = {
    title: SITE_TITLE,
    description: SITE_DESCRIPTION,
    id: site,
    link: site,
    language: SITE_LANGUAGE,
    image：createUrl("/favicon.png", 'https://linglilongyi.com') as string,
    favicon: createUrl("/favicon.ico", 'https://linglilongyi.com') as string,
    copyright: `Copyright ${new Date().getFullYear()} 绫里龙一`,
    feedLinks: {
      atom: createUrl("/rss.xml", site) as string,
    },
    author,
  };

  return new Feed(feedOptions);
}

async function addArticlesToFeed(
  feed: Feed,
  site: string,
  author: SiteAuthor,
): Promise<void> {
    const all_blog_posts = await getCollection("posts");
    const publishPosts = all_blog_posts.filter((post) => !post.data.draft);
    const sortedPosts = publishPosts.sort((a: any, b: any) => new Date(b.data.publishDate).getTime() - new Date(a.data.publishDate).getTime());
    const posts = sortedPosts.slice(0, 10);

  for (const post of posts) {
    
    const link = createUrl(`/posts/${post.id}`.replace(/\.md$/, '/'), site) as string;

    feed.addItem({
      title: post.data.title,
      guid: link,
      link,
      published: post.data.publishDate,
      date: post.data.updatedDate || post.data.publishDate,
      author: [author],
      description: await mdxToHtml(post.data.description, site),
      content: await mdxToHtml(post.body || "", site),
    });
  }
}