nuartz 0.1.1 → 0.1.3

package/src/__tests__/markdown.test.ts

@@ -1,113 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { renderMarkdown } from "../markdown"
-
-describe("renderMarkdown", () => {
-  it("returns empty result for empty string", async () => {
-    const result = await renderMarkdown("")
-    expect(result.html).toBe("")
-    expect(result.toc).toEqual([])
-    expect(result.tags).toEqual([])
-    expect(result.links).toEqual([])
-  })
-
-  it("extracts heading into toc", async () => {
-    const result = await renderMarkdown("# Hello World")
-    expect(result.toc).toHaveLength(1)
-    expect(result.toc[0]).toMatchObject({
-      depth: 1,
-      text: "Hello World",
-    })
-    expect(result.toc[0].id).toBeTruthy()
-  })
-
-  it("builds nested toc tree", async () => {
-    const md = "# Top\n## Sub\n### Deep"
-    const result = await renderMarkdown(md)
-    expect(result.toc).toHaveLength(1)
-    expect(result.toc[0].text).toBe("Top")
-    expect(result.toc[0].children).toHaveLength(1)
-    expect(result.toc[0].children[0].text).toBe("Sub")
-    expect(result.toc[0].children[0].children).toHaveLength(1)
-    expect(result.toc[0].children[0].children[0].text).toBe("Deep")
-  })
-
-  it("parses frontmatter", async () => {
-    const md = `---
-title: My Page
-date: 2024-01-01
----
-
-Some content`
-    const result = await renderMarkdown(md)
-    expect(result.frontmatter.title).toBe("My Page")
-    // gray-matter parses YAML dates as Date objects
-    const date = result.frontmatter.date
-    const dateStr = date instanceof Date ? date.toISOString().split("T")[0] : date
-    expect(dateStr).toBe("2024-01-01")
-  })
-
-  it("extracts wikilinks into links array", async () => {
-    const result = await renderMarkdown("Check [[Some Page]] for details")
-    expect(result.links).toContain("Some Page")
-  })
-
-  it("extracts wikilink with alias", async () => {
-    const result = await renderMarkdown("See [[Target|display text]]")
-    expect(result.links).toContain("Target")
-    expect(result.html).toContain("display text")
-  })
-
-  it("extracts inline tags", async () => {
-    const result = await renderMarkdown("This has #mytag in it")
-    expect(result.tags).toContain("mytag")
-  })
-
-  it("merges frontmatter tags with inline tags and deduplicates", async () => {
-    const md = `---
-tags:
-  - alpha
-  - beta
----
-
-Content with #beta and #gamma`
-    const result = await renderMarkdown(md)
-    expect(result.tags).toContain("alpha")
-    expect(result.tags).toContain("beta")
-    expect(result.tags).toContain("gamma")
-    // beta should appear only once
-    const betaCount = result.tags.filter((t) => t === "beta").length
-    expect(betaCount).toBe(1)
-  })
-
-  it("renders callout with correct class", async () => {
-    const md = "> [!note]\n> Some note content"
-    const result = await renderMarkdown(md)
-    expect(result.html).toContain("callout")
-    expect(result.html).toContain("callout-note")
-  })
-
-  it("renders LaTeX with KaTeX", async () => {
-    const result = await renderMarkdown("Inline math: $x^2$")
-    expect(result.html).toContain("katex")
-  })
-
-  it("renders display math with KaTeX", async () => {
-    const result = await renderMarkdown("$$\nx^2 + y^2 = z^2\n$$")
-    expect(result.html).toContain("katex")
-  })
-
-  it("generates html for basic markdown", async () => {
-    const result = await renderMarkdown("Hello **world**")
-    expect(result.html).toContain("<strong>world</strong>")
-  })
-
-  it("does not include embed links in outgoing links", async () => {
-    const result = await renderMarkdown("![[image.png]]")
-    expect(result.links).not.toContain("image.png")
-  })
-
-  it("adds slug ids to headings via rehype-slug", async () => {
-    const result = await renderMarkdown("## My Section")
-    expect(result.html).toContain('id="my-section"')
-  })
-})

package/src/__tests__/search.test.ts

@@ -1,167 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { buildSearchIndex } from "../search"
-import type { MarkdownFile } from "../fs"
-
-function makeFile(overrides: Partial<MarkdownFile> & { slug: string }): MarkdownFile {
-  return {
-    filePath: `/${overrides.slug}.md`,
-    frontmatter: {},
-    raw: "",
-    ...overrides,
-  }
-}
-
-describe("buildSearchIndex", () => {
-  it("returns SearchEntry[] with slug, title, content, tags", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "hello",
-        frontmatter: { title: "Hello", tags: ["greeting"] },
-        raw: "---\ntitle: Hello\ntags:\n  - greeting\n---\nSome body text",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index).toHaveLength(1)
-    expect(index[0].slug).toBe("hello")
-    expect(index[0].title).toBe("Hello")
-    expect(index[0].content).toContain("Some body text")
-    expect(index[0].tags).toEqual(["greeting"])
-  })
-
-  it("excludes draft:true files", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "published",
-        frontmatter: { title: "Published" },
-        raw: "Public content",
-      }),
-      makeFile({
-        slug: "draft",
-        frontmatter: { title: "Draft", draft: true },
-        raw: "---\ntitle: Draft\ndraft: true\n---\nDraft content",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index).toHaveLength(1)
-    expect(index[0].slug).toBe("published")
-  })
-
-  it("strips heading markers from content", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "headings",
-        raw: "# Heading One\n## Heading Two\nBody",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index[0].content).not.toMatch(/^#/)
-    expect(index[0].content).toContain("Heading One")
-    expect(index[0].content).toContain("Body")
-  })
-
-  it("strips bold and italic markers", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "emphasis",
-        raw: "Some **bold** and *italic* and __also__ text",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index[0].content).not.toContain("**")
-    expect(index[0].content).not.toContain("*")
-    expect(index[0].content).not.toContain("__")
-    expect(index[0].content).toContain("bold")
-    expect(index[0].content).toContain("italic")
-  })
-
-  it("strips inline code", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "code",
-        raw: "Use `console.log` to debug",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index[0].content).not.toContain("`")
-  })
-
-  it("strips wikilinks keeping display text", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "links",
-        raw: "See [[My Page]] and [[Other|display]]",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    // wikilink regex captures target (first group), not alias
-    // [[My Page]] → "My Page", [[Other|display]] → "Other"
-    expect(index[0].content).toContain("My Page")
-    expect(index[0].content).toContain("Other")
-    expect(index[0].content).not.toContain("[[")
-    expect(index[0].content).not.toContain("]]")
-  })
-
-  it("uses last slug segment as title fallback", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "notes/deep/my-page",
-        frontmatter: {},
-        raw: "Content without title",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index[0].title).toBe("my-page")
-  })
-
-  it("includes frontmatter tags", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "tagged",
-        frontmatter: { tags: ["alpha", "beta"] },
-        raw: "---\ntags:\n  - alpha\n  - beta\n---\nContent",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index[0].tags).toEqual(["alpha", "beta"])
-  })
-
-  it("includes description from frontmatter", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "desc",
-        frontmatter: { title: "Desc", description: "A short summary" },
-        raw: "---\ntitle: Desc\ndescription: A short summary\n---\nBody",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index[0].description).toBe("A short summary")
-  })
-
-  it("returns empty array for empty input", () => {
-    const index = buildSearchIndex([])
-    expect(index).toEqual([])
-  })
-
-  it("strips code blocks from content", () => {
-    const files: MarkdownFile[] = [
-      makeFile({
-        slug: "codeblock",
-        raw: "Before\n```js\nconsole.log('hi')\n```\nAfter",
-      }),
-    ]
-
-    const index = buildSearchIndex(files)
-    expect(index[0].content).not.toContain("console.log")
-    expect(index[0].content).toContain("Before")
-    expect(index[0].content).toContain("After")
-  })
-})

package/src/backlinks.ts

@@ -1,52 +0,0 @@
-import type { RenderResult } from "./types.js"
-
-export interface BacklinkEntry {
-  slug: string
-  title: string
-  excerpt: string
-}
-
-export type BacklinkIndex = Map<string, BacklinkEntry[]>
-
-/**
- * Builds a backlink index from a collection of rendered pages.
- *
- * For each page, its outgoing wikilinks are read and the page is registered
- * as a backlink on every target it points to.
- *
- * @param pages - Map of slug → { result, raw content }
- * @returns Map of slug → pages that link to it
- */
-export function buildBacklinkIndex(
-  pages: Map<string, { result: RenderResult; raw: string }>
-): BacklinkIndex {
-  const index: BacklinkIndex = new Map()
-
-  for (const [slug, { result, raw }] of pages) {
-    const title = result.frontmatter.title ?? slug
-    const excerpt = raw.replace(/^---[\s\S]*?---/, "").trim().slice(0, 160) + "…"
-
-    for (const target of result.links) {
-      const normalizedTarget = target
-        .toLowerCase()
-        .replace(/\s+/g, "-")
-        .replace(/[^\w-]/g, "")
-
-      const existing = index.get(normalizedTarget) ?? []
-      existing.push({ slug, title, excerpt })
-      index.set(normalizedTarget, existing)
-    }
-  }
-
-  return index
-}
-
-/**
- * Looks up backlinks for a given slug.
- */
-export function getBacklinks(
-  index: BacklinkIndex,
-  slug: string
-): BacklinkEntry[] {
-  return index.get(slug) ?? []
-}

package/src/config.ts

@@ -1,63 +0,0 @@
-import type { RenderOptions } from "./types.js"
-
-export interface NuartzConfig {
-  /** Absolute path to the content directory */
-  contentDir: string
-
-  /** Site metadata */
-  site: {
-    title: string
-    description?: string
-    /** Production URL, e.g. "https://example.com". Defaults to "http://localhost:3000". */
-    baseUrl?: string
-    locale?: string
-  }
-
-  /** Markdown rendering options */
-  markdown?: RenderOptions
-
-  /** Features to enable/disable */
-  features?: {
-    wikilinks?: boolean
-    callouts?: boolean
-    tags?: boolean
-    backlinks?: boolean
-    toc?: boolean
-    search?: boolean
-    darkMode?: boolean
-  }
-
-  /**
-   * What to show on the home page (`/`).
-   * - `"index"` — render `content/index.md` (default). Falls back to recent notes if the file doesn't exist.
-   * - `"recent"` — show a list of all notes sorted by date.
-   */
-  homePage?: "index" | "recent"
-
-  /** Navigation */
-  nav?: {
-    /** Extra links in the header */
-    links?: Array<{ label: string; href: string; external?: boolean }>
-  }
-}
-
-const DEFAULT_FEATURES: Required<NuartzConfig["features"]> = {
-  wikilinks: true,
-  callouts: true,
-  tags: true,
-  backlinks: true,
-  toc: true,
-  search: true,
-  darkMode: true,
-}
-
-export function defineConfig(config: NuartzConfig): NuartzConfig & { site: { baseUrl: string } } {
-  return {
-    ...config,
-    site: {
-      baseUrl: "http://localhost:3000",
-      ...config.site,
-    },
-    features: { ...DEFAULT_FEATURES, ...config.features },
-  }
-}

package/src/fs.ts

@@ -1,131 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import matter from "gray-matter"
-import type { Frontmatter } from "./types.js"
-
-export interface MarkdownFile {
-  slug: string        // relative path without .md, e.g. "notes/foo"
-  filePath: string    // absolute file path
-  frontmatter: Frontmatter
-  raw: string
-}
-
-/**
- * Recursively walks a directory and returns all .md files.
- */
-export async function getAllMarkdownFiles(
-  contentDir: string
-): Promise<MarkdownFile[]> {
-  const results: MarkdownFile[] = []
-
-  async function walk(dir: string) {
-    let entries: { name: string; isDirectory(): boolean }[]
-    try {
-      entries = await fs.readdir(dir, { withFileTypes: true }) as { name: string; isDirectory(): boolean }[]
-    } catch {
-      return
-    }
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name)
-      if (entry.isDirectory()) {
-        await walk(fullPath)
-      } else if (entry.name.endsWith(".md") && !entry.name.startsWith("_")) {
-        const raw = await fs.readFile(fullPath, "utf-8")
-        const { data } = matter(raw)
-
-        // Skip draft or unpublished files
-        if (data.draft === true || data.published === false) continue
-
-        const relative = path.relative(contentDir, fullPath)
-        const slug = relative.replace(/\.md$/, "").replace(/\\/g, "/")
-        results.push({
-          slug,
-          filePath: fullPath,
-          frontmatter: data as Frontmatter,
-          raw,
-        })
-      }
-    }
-  }
-
-  await walk(contentDir)
-  return results
-}
-
-/**
- * Reads a single markdown file by slug.
- * Returns null if the file doesn't exist.
- */
-export async function getMarkdownBySlug(
-  contentDir: string,
-  slug: string
-): Promise<MarkdownFile | null> {
-  const filePath = path.join(contentDir, slug + ".md")
-  try {
-    const raw = await fs.readFile(filePath, "utf-8")
-    const { data } = matter(raw)
-    return { slug, filePath, frontmatter: data as Frontmatter, raw }
-  } catch {
-    return null
-  }
-}
-
-export interface FileTreeNode {
-  name: string
-  path: string
-  type: "file" | "folder"
-  children?: FileTreeNode[]
-}
-
-/**
- * Builds a nested file tree from a flat list of MarkdownFile entries.
- */
-export function buildFileTree(files: MarkdownFile[]): FileTreeNode[] {
-  const root: FileTreeNode[] = []
-  const nodeMap = new Map<string, FileTreeNode>()
-
-  const sortedFiles = [...files].sort((a, b) => a.slug.localeCompare(b.slug))
-
-  for (const file of sortedFiles) {
-    const parts = file.slug.split("/")
-    let parentList = root
-
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i]
-      const partPath = parts.slice(0, i + 1).join("/")
-      const isLast = i === parts.length - 1
-
-      if (isLast) {
-        const node: FileTreeNode = {
-          name: file.frontmatter.title ?? part,
-          path: file.slug,
-          type: "file",
-        }
-        parentList.push(node)
-      } else {
-        let folderNode = nodeMap.get(partPath)
-        if (!folderNode) {
-          folderNode = { name: part, path: partPath, type: "folder", children: [] }
-          nodeMap.set(partPath, folderNode)
-          parentList.push(folderNode)
-        }
-        parentList = folderNode.children!
-      }
-    }
-  }
-
-  // Sort each level: folders first, then files; alphabetically within each group
-  function sortNodes(nodes: FileTreeNode[]): FileTreeNode[] {
-    nodes.sort((a, b) => {
-      if (a.type !== b.type) return a.type === "folder" ? -1 : 1
-      return a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
-    })
-    for (const node of nodes) {
-      if (node.children) sortNodes(node.children)
-    }
-    return nodes
-  }
-
-  return sortNodes(root)
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-export { renderMarkdown } from "./markdown.js"
-export { buildBacklinkIndex, getBacklinks } from "./backlinks.js"
-export { getAllMarkdownFiles, getMarkdownBySlug, buildFileTree } from "./fs.js"
-export { buildSearchIndex } from "./search.js"
-export { defineConfig } from "./config.js"
-export type { NuartzConfig } from "./config.js"
-export type { SearchEntry } from "./search.js"
-export type { MarkdownFile, FileTreeNode } from "./fs.js"
-export type { BacklinkEntry, BacklinkIndex } from "./backlinks.js"
-export { remarkCallout } from "./plugins/callout.js"
-export { remarkTag } from "./plugins/tag.js"
-export { remarkWikilink } from "./plugins/wikilink.js"
-export { remarkHighlight } from "./plugins/highlight.js"
-export { remarkObsidianComment } from "./plugins/comment.js"
-export { remarkArrows } from "./plugins/arrows.js"
-export type { Frontmatter, RenderResult, RenderOptions, TocEntry } from "./types.js"

package/src/markdown.ts

@@ -1,131 +0,0 @@
-import matter from "gray-matter"
-import { unified } from "unified"
-import remarkParse from "remark-parse"
-import remarkFrontmatter from "remark-frontmatter"
-import remarkGfm from "remark-gfm"
-import remarkMath from "remark-math"
-import remarkRehype from "remark-rehype"
-import rehypeRaw from "rehype-raw"
-import rehypeSlug from "rehype-slug"
-import rehypeAutolinkHeadings from "rehype-autolink-headings"
-import type { ElementContent } from "hast"
-import rehypeKatex from "rehype-katex"
-import rehypeStringify from "rehype-stringify"
-import { visit } from "unist-util-visit"
-import type { Root as HastRoot, Element } from "hast"
-import type { Plugin } from "unified"
-
-import remarkBreaks from "remark-breaks"
-import { rehypePrettyCode } from "rehype-pretty-code"
-import { remarkCallout } from "./plugins/callout.js"
-import { remarkTag } from "./plugins/tag.js"
-import { remarkWikilink } from "./plugins/wikilink.js"
-import { remarkHighlight } from "./plugins/highlight.js"
-import { remarkObsidianComment } from "./plugins/comment.js"
-import { remarkArrows } from "./plugins/arrows.js"
-import type { Frontmatter, RenderResult, RenderOptions, TocEntry } from "./types.js"
-
-// Rehype plugin that extracts headings into vfile.data.toc
-const rehypeExtractToc: Plugin<[], HastRoot> = () => {
-  return (tree, file) => {
-    const toc: TocEntry[] = []
-
-    visit(tree, "element", (node: Element) => {
-      const match = node.tagName.match(/^h([1-6])$/)
-      if (!match) return
-
-      const depth = parseInt(match[1])
-      const id = (node.properties?.id as string) ?? ""
-      const text = extractText(node)
-
-      toc.push({ depth, text, id, children: [] })
-    })
-
-    file.data.toc = buildTocTree(toc)
-  }
-}
-
-function extractText(node: Element): string {
-  let text = ""
-  visit(node as unknown as HastRoot, "text", (n: { value: string }) => {
-    text += n.value
-  })
-  return text
-}
-
-function buildTocTree(flat: TocEntry[]): TocEntry[] {
-  const root: TocEntry[] = []
-  const stack: TocEntry[] = []
-
-  for (const entry of flat) {
-    while (stack.length > 0 && stack[stack.length - 1].depth >= entry.depth) {
-      stack.pop()
-    }
-    if (stack.length === 0) {
-      root.push(entry)
-    } else {
-      stack[stack.length - 1].children.push(entry)
-    }
-    stack.push(entry)
-  }
-
-  return root
-}
-
-export async function renderMarkdown(
-  content: string,
-  options: RenderOptions = {}
-): Promise<RenderResult> {
-  const { baseUrl = "/", resolveLink = (t) => t, knownSlugs } = options
-
-  // Parse frontmatter with gray-matter
-  const { data: frontmatter, content: body } = matter(content)
-
-  const file = await unified()
-    .use(remarkParse)
-    .use(remarkFrontmatter, ["yaml", "toml"])
-    .use(remarkObsidianComment)
-    .use(remarkGfm)
-    .use(remarkMath)
-    .use(remarkBreaks)
-    .use(remarkWikilink, { baseUrl, resolve: resolveLink, knownSlugs })
-    .use(remarkCallout)
-    .use(remarkTag)
-    .use(remarkHighlight)
-    .use(remarkArrows)
-    .use(remarkRehype, { allowDangerousHtml: true })
-    .use(rehypeRaw)
-    .use(rehypePrettyCode, {
-      theme: { light: "github-light", dark: "github-dark" },
-      keepBackground: false,
-    })
-    .use(rehypeSlug)
-    .use(rehypeAutolinkHeadings, {
-      behavior: "append",
-      properties: { className: "heading-anchor", ariaLabel: "Copy link to section" },
-      content: {
-        type: "element", tagName: "svg",
-        properties: { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none",
-          stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" },
-        children: [
-          { type: "element", tagName: "path", properties: { d: "M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71" }, children: [] },
-          { type: "element", tagName: "path", properties: { d: "M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71" }, children: [] },
-        ],
-      } as ElementContent,
-    })
-    .use(rehypeKatex)
-    .use(rehypeExtractToc)
-    .use(rehypeStringify)
-    .process(body)
-
-  return {
-    html: String(file),
-    frontmatter: frontmatter as Frontmatter,
-    toc: (file.data.toc as TocEntry[]) ?? [],
-    links: (file.data.links as string[]) ?? [],
-    tags: [
-      ...((frontmatter.tags as string[]) ?? []),
-      ...((file.data.tags as string[]) ?? []),
-    ].filter((t, i, a) => a.indexOf(t) === i),
-  }
-}

package/src/plugins/arrows.ts

@@ -1,14 +0,0 @@
-import { visit } from "unist-util-visit"
-import type { Root, Text } from "mdast"
-import type { Plugin } from "unified"
-
-export const remarkArrows: Plugin<[], Root> = () => {
-  return (tree) => {
-    visit(tree, "text", (node: Text) => {
-      node.value = node.value
-        .replace(/<-->/g, "↔")
-        .replace(/-->/g, "→")
-        .replace(/<--/g, "←")
-    })
-  }
-}