@hutusi/amytis 1.5.6 → 1.7.0

package/src/lib/markdown.ts

@@ -68,6 +68,7 @@ export interface PostData {
   readingTime: string;
   content: string;
   headings: Heading[];
+  contentLocales?: Record<string, { content: string; title?: string; excerpt?: string; headings?: Heading[] }>;
 }
 
 export function calculateReadingTime(content: string): string {
@@ -238,7 +239,7 @@ export function getAllPosts(): PostData[] {
       
       if (match) {
         dateFromFileName = match[1];
-        if (siteConfig.includeDateInUrl) {
+        if (siteConfig.posts?.includeDateInUrl) {
           slug = rawName;
         } else {
           slug = match[2];
@@ -266,7 +267,7 @@ export function getAllPosts(): PostData[] {
                let sDate = undefined;
                if (sMatch) {
                  sDate = sMatch[1];
-                 sSlug = siteConfig.includeDateInUrl ? sRawName : sMatch[2];
+                 sSlug = siteConfig.posts?.includeDateInUrl ? sRawName : sMatch[2];
                }
                
                allPostsData.push(parseMarkdownFile(
@@ -294,7 +295,7 @@ export function getAllPosts(): PostData[] {
                      
                      if (sMatch) {
                        sDate = sMatch[1];
-                       sSlug = siteConfig.includeDateInUrl ? sItem.name : sMatch[2];
+                       sSlug = siteConfig.posts?.includeDateInUrl ? sItem.name : sMatch[2];
                      }
 
                      allPostsData.push(parseMarkdownFile(
@@ -338,7 +339,7 @@ export function getAllPosts(): PostData[] {
         return false;
       }
 
-      if (!siteConfig.showFuturePosts) {
+      if (!siteConfig.posts?.showFuturePosts) {
         const postDate = new Date(post.date);
         const now = new Date();
         if (postDate > now) return false;
@@ -396,7 +397,7 @@ function findPostFile(name: string, targetSlug: string): PostData | null {
 export function getPostBySlug(slug: string): PostData | null {
   let post: PostData | null = null;
 
-  if (siteConfig.includeDateInUrl) {
+  if (siteConfig.posts?.includeDateInUrl) {
     post = findPostFile(slug, slug);
   } else {
     post = findPostFile(slug, slug);
@@ -445,7 +446,7 @@ export function getPostBySlug(slug: string): PostData | null {
     return null;
   }
 
-  if (!siteConfig.showFuturePosts) {
+  if (!siteConfig.posts?.showFuturePosts) {
       const postDate = new Date(post.date);
       const now = new Date();
       if (postDate > now) return null;
@@ -453,18 +454,53 @@ export function getPostBySlug(slug: string): PostData | null {
   return post;
 }
 
+/**
+ * Load the content and frontmatter of a locale variant file, e.g. about.zh.mdx.
+ * Returns null when the file does not exist or cannot be parsed.
+ */
+function loadLocaleContent(slug: string, locale: string): { content: string; title?: string; excerpt?: string; headings?: Heading[] } | null {
+  for (const ext of ['.mdx', '.md']) {
+    const filePath = path.join(pagesDirectory, `${slug}.${locale}${ext}`);
+    if (fs.existsSync(filePath)) {
+      try {
+        const { data, content } = matter(fs.readFileSync(filePath, 'utf8'));
+        const body = content.replace(/^\s*#\s+[^\n]+/, '').trim();
+        return {
+          content: body,
+          title: typeof data.title === 'string' ? data.title : undefined,
+          excerpt: typeof data.excerpt === 'string' ? data.excerpt : undefined,
+          headings: getHeadings(body),
+        };
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Collect contentLocales for all non-default locales that have a variant file.
+ */
+function attachContentLocales(page: PostData, slug: string): PostData {
+  const defaultLocale = siteConfig.i18n.defaultLocale;
+  const otherLocales = siteConfig.i18n.locales.filter(l => l !== defaultLocale);
+  const contentLocales: NonNullable<PostData['contentLocales']> = {};
+  for (const locale of otherLocales) {
+    const localeData = loadLocaleContent(slug, locale);
+    if (localeData !== null) contentLocales[locale] = localeData;
+  }
+  return Object.keys(contentLocales).length > 0 ? { ...page, contentLocales } : page;
+}
+
 export function getPageBySlug(slug: string): PostData | null {
   try {
     let fullPath = path.join(pagesDirectory, `${slug}.mdx`);
     if (!fs.existsSync(fullPath)) {
       fullPath = path.join(pagesDirectory, `${slug}.md`);
     }
-    
-    if (!fs.existsSync(fullPath)) {
-      return null;
-    }
-
-    return parseMarkdownFile(fullPath, slug);
+    if (!fs.existsSync(fullPath)) return null;
+    return attachContentLocales(parseMarkdownFile(fullPath, slug), slug);
   } catch {
     return null;
   }
@@ -473,11 +509,21 @@ export function getPageBySlug(slug: string): PostData | null {
 export function getAllPages(): PostData[] {
   const items = fs.readdirSync(pagesDirectory, { withFileTypes: true });
   return items
-    .filter(item => item.isFile() && (item.name.endsWith('.mdx') || item.name.endsWith('.md')))
+    .filter(item => {
+      if (!item.isFile()) return false;
+      if (!item.name.endsWith('.mdx') && !item.name.endsWith('.md')) return false;
+      // Exclude locale variant files (e.g. about.zh.mdx, about.en.mdx) — they are not standalone routes
+      const base = item.name.replace(/\.mdx?$/, '');
+      const parts = base.split('.');
+      if (parts.length > 1 && siteConfig.i18n.locales.includes(parts[parts.length - 1])) {
+        return false;
+      }
+      return true;
+    })
     .map(item => {
       const slug = item.name.replace(/\.mdx?$/, '');
       const fullPath = path.join(pagesDirectory, item.name);
-      return parseMarkdownFile(fullPath, slug);
+      return attachContentLocales(parseMarkdownFile(fullPath, slug), slug);
     });
 }
 
@@ -658,6 +704,16 @@ export function getFeaturedPosts(): PostData[] {
   return allPosts.filter(post => post.featured);
 }
 
+export function getAdjacentPosts(slug: string): { prev: PostData | null; next: PostData | null } {
+  const allPosts = getAllPosts(); // sorted desc by date (newest first)
+  const index = allPosts.findIndex(p => p.slug === slug);
+  if (index === -1) return { prev: null, next: null };
+  return {
+    prev: index < allPosts.length - 1 ? allPosts[index + 1] : null, // older post
+    next: index > 0 ? allPosts[index - 1] : null,                   // newer post
+  };
+}
+
 export function getFeaturedSeries(): Record<string, PostData[]> {
   const allSeries = getAllSeries();
   const featuredSeries: Record<string, PostData[]> = {};
@@ -1001,7 +1057,7 @@ export function getAllFlows(): FlowData[] {
   return flows
     .filter(flow => {
       if (process.env.NODE_ENV === 'production' && flow.draft) return false;
-      if (!siteConfig.showFuturePosts) {
+      if (!siteConfig.posts?.showFuturePosts) {
         const flowDate = new Date(flow.date);
         const now = new Date();
         if (flowDate > now) return false;

package/src/lib/search-utils.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, test } from 'bun:test';
+import { getResultType, getDateFromUrl, cleanTitle, stripMarkdown } from './search-utils';
+
+// ─── getResultType ────────────────────────────────────────────────────────────
+
+describe('getResultType', () => {
+  test('returns Flow for flow URLs', () => {
+    expect(getResultType('/flows/2026/01/15/')).toBe('Flow');
+  });
+
+  test('returns Flow for any path containing /flows/', () => {
+    expect(getResultType('/flows/2024/12/31/')).toBe('Flow');
+  });
+
+  test('returns Book for book chapter URLs', () => {
+    expect(getResultType('/books/my-book/chapter-1/')).toBe('Book');
+  });
+
+  test('returns Book for book index URLs', () => {
+    expect(getResultType('/books/my-book/')).toBe('Book');
+  });
+
+  test('returns Post for post URLs', () => {
+    expect(getResultType('/posts/my-post/')).toBe('Post');
+  });
+
+  test('returns Post for root static pages', () => {
+    expect(getResultType('/about/')).toBe('Post');
+  });
+
+  test('returns Post for paginated post pages', () => {
+    expect(getResultType('/posts/page/2/')).toBe('Post');
+  });
+});
+
+// ─── getDateFromUrl ───────────────────────────────────────────────────────────
+
+describe('getDateFromUrl', () => {
+  test('extracts YYYY-MM-DD from a flow URL', () => {
+    expect(getDateFromUrl('/flows/2026/01/15/')).toBe('2026-01-15');
+  });
+
+  test('pads single-digit month and day correctly', () => {
+    expect(getDateFromUrl('/flows/2024/03/07/')).toBe('2024-03-07');
+  });
+
+  test('returns empty string for post URLs', () => {
+    expect(getDateFromUrl('/posts/my-post/')).toBe('');
+  });
+
+  test('returns empty string for book URLs', () => {
+    expect(getDateFromUrl('/books/my-book/chapter/')).toBe('');
+  });
+
+  test('returns empty string when flow URL has no trailing slash', () => {
+    // Pagefind always returns URLs with trailing slash; guard against edge case
+    expect(getDateFromUrl('/flows/2024/12/31')).toBe('');
+  });
+
+  test('returns empty string for the root path', () => {
+    expect(getDateFromUrl('/')).toBe('');
+  });
+});
+
+// ─── cleanTitle ───────────────────────────────────────────────────────────────
+
+describe('cleanTitle', () => {
+  test('strips " | Site Name" suffix', () => {
+    expect(cleanTitle('My Post | My Site')).toBe('My Post');
+  });
+
+  test('returns the title unchanged when there is no suffix', () => {
+    expect(cleanTitle('My Post')).toBe('My Post');
+  });
+
+  test('strips only the last " | " occurrence (keeps earlier pipes)', () => {
+    expect(cleanTitle('Part A | Part B | Site')).toBe('Part A | Part B');
+  });
+
+  test('handles an empty string', () => {
+    expect(cleanTitle('')).toBe('');
+  });
+
+  test('handles a title that is only a site suffix', () => {
+    expect(cleanTitle(' | Site')).toBe('');
+  });
+});
+
+// ─── stripMarkdown ────────────────────────────────────────────────────────────
+
+describe('stripMarkdown', () => {
+  test('strips fenced code blocks', () => {
+    const input = 'Hello\n```js\nconst x = 1;\n```\nWorld';
+    expect(stripMarkdown(input)).toBe('Hello World');
+  });
+
+  test('strips inline code', () => {
+    expect(stripMarkdown('Use `npm install` to install')).toBe('Use to install');
+  });
+
+  test('strips image syntax', () => {
+    expect(stripMarkdown('![alt text](image.png) after')).toBe('after');
+  });
+
+  test('converts links to their visible text', () => {
+    expect(stripMarkdown('See [the docs](https://example.com) here')).toBe('See the docs here');
+  });
+
+  test('strips HTML and JSX tags', () => {
+    expect(stripMarkdown('<div class="foo">content</div>')).toBe('content');
+  });
+
+  test('strips ATX heading markers (# through ######)', () => {
+    expect(stripMarkdown('## Introduction')).toBe('Introduction');
+    expect(stripMarkdown('###### Deep heading')).toBe('Deep heading');
+  });
+
+  test('strips bold and italic with asterisks', () => {
+    expect(stripMarkdown('**bold** and *italic* text')).toBe('bold and italic text');
+  });
+
+  test('strips bold and italic with underscores', () => {
+    expect(stripMarkdown('__bold__ and _italic_ text')).toBe('bold and italic text');
+  });
+
+  test('strips GFM strikethrough markers', () => {
+    expect(stripMarkdown('~~deleted~~ and ~~removed~~')).toBe('deleted and removed');
+  });
+
+  test('strips unordered list markers', () => {
+    expect(stripMarkdown('- item one\n- item two')).toBe('item one item two');
+  });
+
+  test('strips blockquote markers', () => {
+    expect(stripMarkdown('> quoted text')).toBe('quoted text');
+  });
+
+  test('strips ordered list markers', () => {
+    expect(stripMarkdown('1. First\n2. Second')).toBe('First Second');
+  });
+
+  test('normalizes multiple spaces and newlines to a single space', () => {
+    expect(stripMarkdown('word1   word2\n\nword3')).toBe('word1 word2 word3');
+  });
+
+  test('trims leading and trailing whitespace', () => {
+    expect(stripMarkdown('  hello world  ')).toBe('hello world');
+  });
+
+  test('caps output at 2000 characters', () => {
+    const long = 'a'.repeat(3000);
+    expect(stripMarkdown(long).length).toBe(2000);
+  });
+
+  test('returns empty string for empty input', () => {
+    expect(stripMarkdown('')).toBe('');
+  });
+
+  test('handles mixed markdown in one passage', () => {
+    const input = '## Title\n\n**Bold** and [link](http://example.com).\n\n- item\n\n> quote';
+    expect(stripMarkdown(input)).toBe('Title Bold and link. item quote');
+  });
+});

package/src/lib/search-utils.ts

@@ -0,0 +1,39 @@
+export type ContentType = 'All' | 'Post' | 'Flow' | 'Book';
+
+/** Derive content type from a Pagefind result URL. */
+export function getResultType(url: string): Exclude<ContentType, 'All'> {
+  if (url.includes('/flows/')) return 'Flow';
+  if (url.includes('/books/')) return 'Book';
+  return 'Post';
+}
+
+/** Extract YYYY-MM-DD from a flow URL like /flows/2026/01/15/ */
+export function getDateFromUrl(url: string): string {
+  const m = url.match(/\/flows\/(\d{4})\/(\d{2})\/(\d{2})\//);
+  return m ? `${m[1]}-${m[2]}-${m[3]}` : '';
+}
+
+/** Strip the " | Site Name" suffix that Pagefind picks up from <title>. */
+export function cleanTitle(raw: string): string {
+  const i = raw.lastIndexOf(' | ');
+  return i >= 0 ? raw.slice(0, i) : raw;
+}
+
+/** Strip markdown/MDX syntax to plain text for full-content indexing. */
+export function stripMarkdown(text: string): string {
+  return text
+    .replace(/```[\s\S]*?```/g, ' ')           // fenced code blocks
+    .replace(/`[^`\n]+`/g, ' ')                // inline code
+    .replace(/!\[.*?\]\(.*?\)/g, '')            // images
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')   // links → text
+    .replace(/<[^>]+>/g, ' ')                   // HTML/JSX/MDX tags
+    .replace(/^#{1,6}\s+/gm, '')               // heading markers
+    .replace(/\*{1,2}([^*\n]+)\*{1,2}/g, '$1') // bold/italic (*)
+    .replace(/_{1,2}([^_\n]+)_{1,2}/g, '$1')   // bold/italic (_)
+    .replace(/~~([^~\n]+)~~/g, '$1')            // strikethrough
+    .replace(/^\s*[-*+>]\s+/gm, '')             // lists + blockquotes
+    .replace(/^\s*\d+\.\s+/gm, '')              // ordered lists
+    .replace(/\s+/g, ' ')                       // normalize whitespace
+    .trim()
+    .slice(0, 2000);                             // cap for index size
+}

package/src/types/pagefind.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Type declarations for Pagefind's JS API.
+ * Pagefind is generated at build time (`pagefind --site out`) and
+ * loaded at runtime via a dynamic import. The module does not exist
+ * at compile time, so we declare it manually here.
+ *
+ * Docs: https://pagefind.app/docs/api/
+ */
+declare module '/pagefind/pagefind.js' {
+  export interface PagefindSearchFragment {
+    /** URL of the matching page, e.g. "/posts/my-post/" */
+    url: string;
+    /** Excerpt with matched terms wrapped in <mark> tags */
+    excerpt: string;
+    /** Metadata extracted from the page */
+    meta: {
+      title?: string;
+      image?: string;
+      /** Any custom data-pagefind-meta keys defined in the site */
+      [key: string]: string | undefined;
+    };
+    word_count: number;
+  }
+
+  export interface PagefindSearchResult {
+    /** Unique result ID, e.g. "en_6fceec9" */
+    id: string;
+    /** Load the full result data (lazy, returns only the matching page chunk) */
+    data: () => Promise<PagefindSearchFragment>;
+  }
+
+  export interface PagefindSearchResponse {
+    results: PagefindSearchResult[];
+    unfilteredResultCount: number;
+  }
+
+  /** Initialise Pagefind — must be called before search() */
+  export function init(): Promise<void>;
+
+  /** Run a search and return lazy result handles */
+  export function search(query: string): Promise<PagefindSearchResponse>;
+}

package/src/components/TableOfContents.tsx

@@ -1,158 +0,0 @@
-'use client';
-
-import { useState, useEffect, useCallback } from 'react';
-import { Heading } from '@/lib/markdown';
-import { useLanguage } from '@/components/LanguageProvider';
-
-export default function TableOfContents({ headings }: { headings: Heading[] }) {
-  const { t } = useLanguage();
-  const [activeId, setActiveId] = useState<string>('');
-  const [readProgress, setReadProgress] = useState(0);
-
-  // Track scroll position and active heading
-  const handleScroll = useCallback(() => {
-    // Calculate read progress
-    const scrollTop = window.scrollY;
-    const docHeight = document.documentElement.scrollHeight - window.innerHeight;
-    const progress = docHeight > 0 ? (scrollTop / docHeight) * 100 : 0;
-    setReadProgress(Math.min(100, Math.max(0, progress)));
-
-    // Find active heading
-    const headingElements = headings
-      .map(h => document.getElementById(h.id))
-      .filter(Boolean) as HTMLElement[];
-
-    if (headingElements.length === 0) return;
-
-    // Find the heading that's currently in view
-    const scrollPosition = scrollTop + 100; // Offset for navbar
-
-    let currentHeading = headingElements[0];
-    for (const heading of headingElements) {
-      if (heading.offsetTop <= scrollPosition) {
-        currentHeading = heading;
-      } else {
-        break;
-      }
-    }
-
-    if (currentHeading) {
-      setActiveId(currentHeading.id);
-    }
-  }, [headings]);
-
-  useEffect(() => {
-    // Initial check on mount via animation frame to avoid cascading render error
-    const rafId = requestAnimationFrame(handleScroll);
-
-    window.addEventListener('scroll', handleScroll, { passive: true });
-    return () => {
-      cancelAnimationFrame(rafId);
-      window.removeEventListener('scroll', handleScroll);
-    };
-  }, [handleScroll]);
-
-  // Smooth scroll to heading
-  const scrollToHeading = (e: React.MouseEvent<HTMLAnchorElement>, id: string) => {
-    e.preventDefault();
-    const element = document.getElementById(id);
-    if (element) {
-      const offset = 80; // Navbar height
-      const elementPosition = element.getBoundingClientRect().top + window.scrollY;
-      window.scrollTo({
-        top: elementPosition - offset,
-        behavior: 'smooth'
-      });
-      // Update URL without scrolling
-      history.pushState(null, '', `#${id}`);
-    }
-  };
-
-  if (headings.length === 0) return null;
-
-  // Find active index for progress calculation
-  const activeIndex = headings.findIndex(h => h.id === activeId);
-
-  return (
-    <nav
-      className="hidden lg:block sticky top-28 self-start w-56 pl-6 max-h-[calc(100vh-8rem)] overflow-y-auto scrollbar-hide"
-      aria-label="Table of contents"
-    >
-      {/* Header with progress */}
-      <div className="flex items-center justify-between mb-4 pb-3 border-b border-muted/10">
-        <h2 className="text-[10px] font-sans font-bold uppercase tracking-widest text-muted">
-          {t('on_this_page')}
-        </h2>
-        <span className="text-[10px] font-mono text-muted/60">
-          {Math.round(readProgress)}%
-        </span>
-      </div>
-
-      {/* Progress bar */}
-      <div className="h-0.5 bg-muted/10 rounded-full overflow-hidden mb-5">
-        <div
-          className="h-full bg-accent/50 rounded-full transition-all duration-150"
-          style={{ width: `${readProgress}%` }}
-        />
-      </div>
-
-      {/* Headings list */}
-      <ul className="space-y-1 relative">
-        {/* Active indicator line */}
-        <div className="absolute left-0 top-0 bottom-0 w-px bg-muted/10" />
-
-        {headings.map((heading, index) => {
-          const isActive = heading.id === activeId;
-          const isPast = activeIndex > -1 && index < activeIndex;
-          const isH3 = heading.level === 3;
-
-          return (
-            <li
-              key={heading.id}
-              className={`relative ${isH3 ? 'pl-4' : ''}`}
-            >
-              {/* Active indicator */}
-              {isActive && (
-                <div
-                  className="absolute left-0 w-0.5 bg-accent rounded-full transition-all duration-200"
-                  style={{
-                    top: '4px',
-                    height: 'calc(100% - 8px)'
-                  }}
-                />
-              )}
-
-              <a
-                href={`#${heading.id}`}
-                onClick={(e) => scrollToHeading(e, heading.id)}
-                className={`block py-1.5 pl-4 text-sm leading-snug transition-all duration-200 ${
-                  isActive
-                    ? 'text-accent font-medium'
-                    : isPast
-                      ? 'text-foreground/60 hover:text-foreground'
-                      : 'text-muted/70 hover:text-foreground'
-                }`}
-                aria-current={isActive ? 'location' : undefined}
-              >
-                {heading.text}
-              </a>
-            </li>
-          );
-        })}
-      </ul>
-
-      {/* Back to top */}
-      {readProgress > 20 && (
-        <button
-          onClick={() => window.scrollTo({ top: 0, behavior: 'smooth' })}
-          className="mt-6 pt-4 border-t border-muted/10 w-full text-left text-xs text-muted hover:text-accent transition-colors flex items-center gap-1.5"
-        >
-          <svg className="w-3 h-3" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
-            <path strokeLinecap="round" strokeLinejoin="round" d="M5 10l7-7m0 0l7 7m-7-7v18" />
-          </svg>
-          {t('back_to_top')}
-        </button>
-      )}
-    </nav>
-  );
-}