markdownblog/src/lib/markdown.ts

import fs from 'fs';
import path from 'path';
import matter from 'gray-matter';
import { marked } from 'marked';
import DOMPurify from 'dompurify';
import { JSDOM } from 'jsdom';
import chokidar from 'chokidar';
import type { FSWatcher } from 'chokidar';
import hljs from 'highlight.js';

export interface Post {
  slug: string;
  title: string;
  date: string;
  tags: string[];
  summary: string;
  content: string;
  createdAt: Date;
  author: string;
}

const postsDirectory = path.join(process.cwd(), 'posts');

// Function to get file creation date
function getFileCreationDate(filePath: string): Date {
  const stats = fs.statSync(filePath);
  return stats.birthtime;
}

const renderer = new marked.Renderer();
renderer.code = (code, infostring, escaped) => {
  const lang = (infostring || '').match(/\S*/)?.[0];
  const highlighted = lang && hljs.getLanguage(lang)
    ? hljs.highlight(code, { language: lang }).value
    : hljs.highlightAuto(code).value;
  const langClass = lang ? `language-${lang}` : '';
  return `<pre><code class="hljs ${langClass}">${highlighted}</code></pre>`;
};

marked.setOptions({
  gfm: true,
  breaks: true,
  renderer,
});

export async function getPostBySlug(slug: string): Promise<Post> {
  const realSlug = slug.replace(/\.md$/, '');
  const fullPath = path.join(postsDirectory, `${realSlug}.md`);
  const fileContents = fs.readFileSync(fullPath, 'utf8');
  const { data, content } = matter(fileContents);
  const createdAt = getFileCreationDate(fullPath);

  let processedContent = '';
  try {
    const rawHtml = marked.parse(content);
    const window = new JSDOM('').window;
    const purify = DOMPurify(window);
    processedContent = purify.sanitize(rawHtml as string, {
      ALLOWED_TAGS: [
        'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
        'p', 'a', 'ul', 'ol', 'li', 'blockquote',
        'pre', 'code', 'em', 'strong', 'del',
        'hr', 'br', 'img', 'table', 'thead', 'tbody',
        'tr', 'th', 'td', 'div', 'span', 'iframe'
      ],
      ALLOWED_ATTR: [
        'class', 'id', 'style',
        'href', 'target', 'rel',
        'src', 'alt', 'title', 'width', 'height',
        'frameborder', 'allowfullscreen'
      ],
      ALLOWED_URI_REGEXP: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
    });
  } catch (err) {
    console.error(`Error processing markdown for ${realSlug}:`, err);
    processedContent = `<div class="error-message">
      <p>Error processing markdown content. Please check the console for details.</p>
      <pre>${err instanceof Error ? err.message : 'Unknown error'}</pre>
    </div>`;
  }

  return {
    slug: realSlug,
    title: data.title,
    date: data.date,
    tags: data.tags || [],
    summary: data.summary,
    content: processedContent,
    createdAt,
    author: process.env.NEXT_PUBLIC_BLOG_OWNER || 'Anonymous',
  };
}

export async function getAllPosts(): Promise<Post[]> {
  const fileNames = fs.readdirSync(postsDirectory);
  const allPostsData = await Promise.all(
    fileNames
      .filter((fileName) => fileName.endsWith('.md'))
      .map(async (fileName) => {
        const slug = fileName.replace(/\.md$/, '');
        return getPostBySlug(slug);
      })
  );

  // Sort by creation date (newest first)
  return allPostsData.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
}

export async function getPostsByTag(tag: string): Promise<Post[]> {
  const allPosts = await getAllPosts();
  return allPosts.filter((post) => post.tags.includes(tag));
}

// File watcher setup
let watcher: FSWatcher | null = null;
let onChangeCallback: (() => void) | null = null;

export function watchPosts(callback: () => void) {
  if (watcher) {
    watcher.close();
  }

  onChangeCallback = callback;
  watcher = chokidar.watch(postsDirectory, {
    ignored: /(^|[\/\\])\../, // ignore dotfiles
    persistent: true
  });

  watcher
    .on('add', handleFileChange)
    .on('change', handleFileChange)
    .on('unlink', handleFileChange);
}

function handleFileChange() {
  if (onChangeCallback) {
    onChangeCallback();
  }
}

export function stopWatching() {
  if (watcher) {
    watcher.close();
    watcher = null;
  }
  onChangeCallback = null;
}