nuartz 0.1.1 → 0.1.3

package/src/plugins/callout.test.ts

@@ -1,80 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { unified } from "unified"
-import remarkParse from "remark-parse"
-import remarkRehype from "remark-rehype"
-import rehypeStringify from "rehype-stringify"
-import { remarkCallout } from "./callout.js"
-
-async function process(md: string): Promise<string> {
-  const result = await unified()
-    .use(remarkParse)
-    .use(remarkCallout)
-    .use(remarkRehype)
-    .use(rehypeStringify)
-    .process(md)
-  return String(result)
-}
-
-describe("remarkCallout", () => {
-  it("transforms a basic note callout", async () => {
-    const html = await process("> [!note] My Title\n> Some content here")
-    expect(html).toContain('class="callout callout-note"')
-    expect(html).toContain('data-callout="note"')
-    expect(html).toContain('<div class="callout-title">My Title</div>')
-    expect(html).toContain("Some content here")
-  })
-
-  it.each([
-    "note", "warning", "tip", "info", "success", "danger", "question",
-    "abstract", "todo", "hint", "important", "check", "done",
-    "help", "faq", "caution", "attention", "failure", "fail",
-    "missing", "error", "bug", "example", "quote", "cite",
-  ])("supports callout type: %s", async (type) => {
-    const html = await process(`> [!${type}]\n> Content`)
-    expect(html).toContain(`callout-${type}`)
-    expect(html).toContain(`data-callout="${type}"`)
-  })
-
-  it("handles fold '+' (expanded)", async () => {
-    const html = await process("> [!note]+ Expandable\n> Content")
-    expect(html).toContain('data-callout-fold="+"')
-  })
-
-  it("handles fold '-' (collapsed)", async () => {
-    const html = await process("> [!tip]- Collapsed\n> Content")
-    expect(html).toContain('data-callout-fold="-"')
-  })
-
-  it("uses capitalized type as default title when no title given", async () => {
-    const html = await process("> [!warning]\n> Content")
-    expect(html).toContain('<div class="callout-title">Warning</div>')
-  })
-
-  it("uses custom title text", async () => {
-    const html = await process("> [!note] Custom Title Here\n> Content")
-    expect(html).toContain('<div class="callout-title">Custom Title Here</div>')
-  })
-
-  it("does not transform a regular blockquote", async () => {
-    const html = await process("> This is just a regular blockquote")
-    expect(html).not.toContain("callout")
-    expect(html).toContain("<blockquote>")
-  })
-
-  it("does not transform an unsupported callout type", async () => {
-    const html = await process("> [!unsupported]\n> Content")
-    expect(html).not.toContain("callout")
-    expect(html).toContain("<blockquote>")
-  })
-
-  it("is case-insensitive for callout type", async () => {
-    const html = await process("> [!NOTE] Title\n> Content")
-    expect(html).toContain('data-callout="note"')
-  })
-
-  it("preserves remaining content after the callout marker line", async () => {
-    const html = await process("> [!tip] Title\n> Line one\n> Line two")
-    expect(html).toContain("Line one")
-    expect(html).toContain("Line two")
-  })
-})

package/src/plugins/callout.ts

@@ -1,78 +0,0 @@
-import { visit } from "unist-util-visit"
-import type { Root, Blockquote, Paragraph, Text } from "mdast"
-import type { Plugin } from "unified"
-
-// All supported callout types (Obsidian-compatible)
-const CALLOUT_TYPES = new Set([
-  "note", "abstract", "summary", "tldr",
-  "info", "todo", "tip", "hint", "important",
-  "success", "check", "done",
-  "question", "help", "faq",
-  "warning", "caution", "attention",
-  "failure", "fail", "missing",
-  "danger", "error", "bug",
-  "example", "quote", "cite",
-])
-
-// [!type] or [!type]+ or [!type]- optionally followed by title
-const CALLOUT_REGEX = /^\[!(\w+)\]([+-]?)([ \t].*)?$/i
-
-export const remarkCallout: Plugin<[], Root> = () => {
-  return (tree) => {
-    visit(tree, "blockquote", (node: Blockquote) => {
-      const firstChild = node.children[0] as Paragraph | undefined
-      if (firstChild?.type !== "paragraph") return
-
-      const firstInline = firstChild.children[0] as Text | undefined
-      if (firstInline?.type !== "text") return
-
-      const firstLine = firstInline.value.split("\n")[0]
-      const match = firstLine.match(CALLOUT_REGEX)
-      if (!match) return
-
-      const [, rawType, fold, titleText] = match
-      const type = rawType.toLowerCase()
-      if (!CALLOUT_TYPES.has(type)) return
-
-      // Trim [!type] line from the paragraph
-      const remainder = firstInline.value.slice(firstLine.length).trimStart()
-      if (remainder) {
-        firstInline.value = remainder
-      } else {
-        firstChild.children.shift()
-        // remarkBreaks runs before this plugin and converts the line break after
-        // [!type] into a break node — remove any leading break nodes
-        while (firstChild.children.length > 0 && firstChild.children[0].type === "break") {
-          firstChild.children.shift()
-        }
-      }
-      // If the first paragraph is now empty, remove it entirely
-      if (firstChild.children.length === 0) {
-        node.children.shift()
-      }
-
-      const title = titleText?.trim() ?? type.charAt(0).toUpperCase() + type.slice(1)
-
-      const titleParagraph: Paragraph = {
-        type: "paragraph",
-        data: {
-          hName: "div",
-          hProperties: { className: "callout-title" },
-        },
-        children: [{ type: "text", value: title }],
-      }
-
-      node.children.unshift(titleParagraph)
-
-      node.data = {
-        ...node.data,
-        hName: "div",
-        hProperties: {
-          className: `callout callout-${type}`,
-          "data-callout": type,
-          "data-callout-fold": fold || null,
-        },
-      }
-    })
-  }
-}

package/src/plugins/comment.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { unified } from "unified"
-import remarkParse from "remark-parse"
-import remarkRehype from "remark-rehype"
-import rehypeStringify from "rehype-stringify"
-import { remarkObsidianComment } from "./comment.js"
-
-async function process(md: string): Promise<string> {
-  const result = await unified()
-    .use(remarkParse)
-    .use(remarkObsidianComment)
-    .use(remarkRehype)
-    .use(rehypeStringify)
-    .process(md)
-  return String(result)
-}
-
-describe("remarkObsidianComment", () => {
-  it("strips %%comment%% from output", async () => {
-    const html = await process("visible %%hidden%% text")
-    expect(html).not.toContain("hidden")
-    expect(html).toContain("visible")
-    expect(html).toContain("text")
-  })
-
-  it("strips multiple comments", async () => {
-    const html = await process("a %%one%% b %%two%% c")
-    expect(html).not.toContain("one")
-    expect(html).not.toContain("two")
-    expect(html).toContain("a")
-    expect(html).toContain("b")
-    expect(html).toContain("c")
-  })
-
-  it("leaves text without comments unchanged", async () => {
-    const html = await process("No comments here")
-    expect(html).toContain("No comments here")
-  })
-
-  it("handles comment at start of text", async () => {
-    const html = await process("%%removed%%visible")
-    expect(html).not.toContain("removed")
-    expect(html).toContain("visible")
-  })
-
-  it("handles comment at end of text", async () => {
-    const html = await process("visible%%removed%%")
-    expect(html).not.toContain("removed")
-    expect(html).toContain("visible")
-  })
-
-  it("does not match single %", async () => {
-    const html = await process("100% done")
-    expect(html).toContain("100% done")
-  })
-})

package/src/plugins/comment.ts

@@ -1,35 +0,0 @@
-import { visit } from "unist-util-visit"
-import type { Root, Text } from "mdast"
-import type { Plugin } from "unified"
-
-// matches %%...%% including across newlines within a paragraph node
-const COMMENT_REGEX = /%%[\s\S]*?%%/g
-
-export const remarkObsidianComment: Plugin<[], Root> = () => {
-  return (tree) => {
-    visit(tree, "text", (node: Text, index, parent) => {
-      if (!parent || index === undefined) return
-      if (!node.value.includes("%%")) return
-
-      const matches = [...node.value.matchAll(COMMENT_REGEX)]
-      if (!matches.length) return
-
-      const nodes: typeof parent.children = []
-      let lastIndex = 0
-
-      for (const match of matches) {
-        const [full] = match
-        const matchIndex = match.index!
-        if (matchIndex > lastIndex) {
-          nodes.push({ type: "text", value: node.value.slice(lastIndex, matchIndex) })
-        }
-        // strip the comment - push nothing
-        lastIndex = matchIndex + full.length
-      }
-      if (lastIndex < node.value.length) {
-        nodes.push({ type: "text", value: node.value.slice(lastIndex) })
-      }
-      parent.children.splice(index, 1, ...(nodes as any))
-    })
-  }
-}

package/src/plugins/highlight.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { unified } from "unified"
-import remarkParse from "remark-parse"
-import remarkRehype from "remark-rehype"
-import rehypeStringify from "rehype-stringify"
-import { remarkHighlight } from "./highlight.js"
-
-async function process(md: string): Promise<string> {
-  const result = await unified()
-    .use(remarkParse)
-    .use(remarkHighlight)
-    .use(remarkRehype, { allowDangerousHtml: true })
-    .use(rehypeStringify, { allowDangerousHtml: true })
-    .process(md)
-  return String(result)
-}
-
-describe("remarkHighlight", () => {
-  it("wraps ==text== in <mark> tags", async () => {
-    const html = await process("This is ==highlighted== text")
-    expect(html).toContain("<mark>highlighted</mark>")
-  })
-
-  it("handles multiple highlights in one line", async () => {
-    const html = await process("==first== and ==second==")
-    expect(html).toContain("<mark>first</mark>")
-    expect(html).toContain("<mark>second</mark>")
-  })
-
-  it("preserves surrounding text", async () => {
-    const html = await process("before ==middle== after")
-    expect(html).toContain("before ")
-    expect(html).toContain("<mark>middle</mark>")
-    expect(html).toContain(" after")
-  })
-
-  it("does not match single = signs", async () => {
-    const html = await process("a = b")
-    expect(html).not.toContain("<mark>")
-  })
-
-  it("does not match across newlines", async () => {
-    const html = await process("==start\nend==")
-    expect(html).not.toContain("<mark>")
-  })
-
-  it("leaves text without highlights unchanged", async () => {
-    const html = await process("No highlights here")
-    expect(html).not.toContain("<mark>")
-    expect(html).toContain("No highlights here")
-  })
-})

package/src/plugins/highlight.ts

@@ -1,32 +0,0 @@
-import { visit } from "unist-util-visit"
-import type { Root, Text } from "mdast"
-import type { Plugin } from "unified"
-
-const HIGHLIGHT_REGEX = /==([^=\n]+)==/g
-
-export const remarkHighlight: Plugin<[], Root> = () => {
-  return (tree) => {
-    visit(tree, "text", (node: Text, index, parent) => {
-      if (!parent || index === undefined) return
-      const matches = [...node.value.matchAll(HIGHLIGHT_REGEX)]
-      if (!matches.length) return
-
-      const nodes: typeof parent.children = []
-      let lastIndex = 0
-
-      for (const match of matches) {
-        const [full, content] = match
-        const matchIndex = match.index!
-        if (matchIndex > lastIndex) {
-          nodes.push({ type: "text", value: node.value.slice(lastIndex, matchIndex) })
-        }
-        nodes.push({ type: "html", value: `<mark>${content}</mark>` })
-        lastIndex = matchIndex + full.length
-      }
-      if (lastIndex < node.value.length) {
-        nodes.push({ type: "text", value: node.value.slice(lastIndex) })
-      }
-      parent.children.splice(index, 1, ...(nodes as any))
-    })
-  }
-}

package/src/plugins/tag.test.ts

@@ -1,80 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { unified } from "unified"
-import remarkParse from "remark-parse"
-import remarkRehype from "remark-rehype"
-import rehypeStringify from "rehype-stringify"
-import { remarkTag } from "./tag.js"
-
-async function process(md: string): Promise<string> {
-  const result = await unified()
-    .use(remarkParse)
-    .use(remarkTag)
-    .use(remarkRehype)
-    .use(rehypeStringify)
-    .process(md)
-  return String(result)
-}
-
-async function processWithData(md: string) {
-  const file = await unified()
-    .use(remarkParse)
-    .use(remarkTag)
-    .use(remarkRehype)
-    .use(rehypeStringify)
-    .process(md)
-  return { html: String(file), tags: (file.data as Record<string, unknown>).tags as string[] ?? [] }
-}
-
-describe("remarkTag", () => {
-  it("transforms #mytag into a tag link", async () => {
-    const html = await process("Hello #mytag world")
-    expect(html).toContain('href="/tags/mytag"')
-    expect(html).toContain('class="tag"')
-    expect(html).toContain("#mytag")
-  })
-
-  it("does not transform #123invalid (starts with number)", async () => {
-    const html = await process("Hello #123invalid world")
-    expect(html).not.toContain('class="tag"')
-    expect(html).toContain("#123invalid")
-  })
-
-  it("transforms #tag-with-hyphen", async () => {
-    const html = await process("A #tag-with-hyphen here")
-    expect(html).toContain('href="/tags/tag-with-hyphen"')
-    expect(html).toContain('class="tag"')
-  })
-
-  it("transforms #tag_with_underscore", async () => {
-    const html = await process("A #tag_with_underscore here")
-    expect(html).toContain('href="/tags/tag_with_underscore"')
-  })
-
-  it("handles multiple tags in one paragraph", async () => {
-    const html = await process("Tags: #first and #second")
-    expect(html).toContain('href="/tags/first"')
-    expect(html).toContain('href="/tags/second"')
-  })
-
-  it("collects tags into file.data.tags", async () => {
-    const { tags } = await processWithData("Hello #alpha and #beta")
-    expect(tags).toContain("alpha")
-    expect(tags).toContain("beta")
-  })
-
-  it("deduplicates collected tags", async () => {
-    const { tags } = await processWithData("#same #same #same")
-    expect(tags).toEqual(["same"])
-  })
-
-  it("preserves surrounding text", async () => {
-    const html = await process("before #tag after")
-    expect(html).toContain("before ")
-    expect(html).toContain(" after")
-  })
-
-  it("sets data-tag attribute", async () => {
-    const html = await process("#example")
-    expect(html).toContain('data-tag="example"')
-  })
-})

package/src/plugins/tag.ts

@@ -1,58 +0,0 @@
-import { visit } from "unist-util-visit"
-import type { Root, Text, PhrasingContent } from "mdast"
-import type { Plugin } from "unified"
-
-// #tag — must start with letter, can contain letters, digits, -, _
-const TAG_REGEX = /#([a-zA-Z][a-zA-Z0-9_-]*)/g
-
-export interface TagPluginResult {
-  tags: string[]
-}
-
-/**
- * Transforms inline #tags into links.
- * Collected tags are stored on the vfile data: `file.data.tags`
- */
-export const remarkTag: Plugin<[], Root> = () => {
-  return (tree, file) => {
-    const collected: string[] = []
-
-    visit(tree, "text", (node: Text, index, parent) => {
-      if (!parent || index === undefined) return
-
-      const matches = [...node.value.matchAll(TAG_REGEX)]
-      if (!matches.length) return
-
-      const nodes: PhrasingContent[] = []
-      let lastIndex = 0
-
-      for (const match of matches) {
-        const [full, tag] = match
-        const matchIndex = match.index!
-
-        if (matchIndex > lastIndex) {
-          nodes.push({ type: "text", value: node.value.slice(lastIndex, matchIndex) })
-        }
-
-        collected.push(tag)
-        nodes.push({
-          type: "link",
-          url: `/tags/${tag}`,
-          data: { hProperties: { className: "tag", "data-tag": tag } },
-          children: [{ type: "text", value: `#${tag}` }],
-        })
-
-        lastIndex = matchIndex + full.length
-      }
-
-      if (lastIndex < node.value.length) {
-        nodes.push({ type: "text", value: node.value.slice(lastIndex) })
-      }
-
-      parent.children.splice(index, 1, ...nodes)
-    })
-
-    const existing = (file.data.tags as string[] | undefined) ?? []
-    file.data.tags = [...new Set([...existing, ...collected])]
-  }
-}

package/src/plugins/wikilink.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { unified } from "unified"
-import remarkParse from "remark-parse"
-import remarkRehype from "remark-rehype"
-import rehypeStringify from "rehype-stringify"
-import { remarkWikilink } from "./wikilink.js"
-
-async function process(md: string, options?: Parameters<typeof remarkWikilink>[0]): Promise<string> {
-  const result = await unified()
-    .use(remarkParse)
-    .use(remarkWikilink, options)
-    .use(remarkRehype)
-    .use(rehypeStringify)
-    .process(md)
-  return String(result)
-}
-
-async function processWithData(md: string, options?: Parameters<typeof remarkWikilink>[0]) {
-  const file = await unified()
-    .use(remarkParse)
-    .use(remarkWikilink, options)
-    .use(remarkRehype)
-    .use(rehypeStringify)
-    .process(md)
-  return { html: String(file), links: (file.data as Record<string, unknown>).links as string[] ?? [] }
-}
-
-describe("remarkWikilink", () => {
-  it("transforms [[Page Name]] into a wikilink", async () => {
-    const html = await process("Visit [[Page Name]] for details")
-    expect(html).toContain('href="/page-name"')
-    expect(html).toContain('class="wikilink"')
-    expect(html).toContain("Page Name")
-  })
-
-  it("handles alias [[Page|Alias]]", async () => {
-    const html = await process("See [[Page|Custom Display]]")
-    expect(html).toContain('href="/page"')
-    expect(html).toContain("Custom Display")
-  })
-
-  it("handles heading [[Page#Heading]]", async () => {
-    const html = await process("Go to [[Page#My Section]]")
-    expect(html).toContain('href="/page#my-section"')
-    expect(html).toContain("Page > My Section")
-  })
-
-  it("handles heading with alias [[Page#Heading|Alias]]", async () => {
-    const html = await process("See [[Page#Section|Link Text]]")
-    expect(html).toContain('href="/page#section"')
-    expect(html).toContain("Link Text")
-  })
-
-  it("transforms ![[image.png]] into an embed image", async () => {
-    const html = await process("Here: ![[image.png]]")
-    expect(html).toContain("<img")
-    expect(html).toContain('src="/api/content/image.png"')
-    expect(html).toContain('class="embed-image"')
-  })
-
-  it("converts spaces to hyphens in href", async () => {
-    const html = await process("[[My Long Page Name]]")
-    expect(html).toContain('href="/my-long-page-name"')
-  })
-
-  it("accumulates links in file.data.links", async () => {
-    const { links } = await processWithData("[[Page A]] and [[Page B]]")
-    expect(links).toContain("Page A")
-    expect(links).toContain("Page B")
-  })
-
-  it("deduplicates collected links", async () => {
-    const { links } = await processWithData("[[Same]] and [[Same]]")
-    expect(links).toEqual(["Same"])
-  })
-
-  it("does not add embeds to outgoing links", async () => {
-    const { links } = await processWithData("![[image.png]]")
-    expect(links).toEqual([])
-  })
-
-  it("supports custom resolve function", async () => {
-    const html = await process("[[My Page]]", {
-      resolve: (target) => `/custom/${target.toLowerCase().replace(/\s+/g, "_")}`,
-    })
-    expect(html).toContain('href="/custom/my_page"')
-  })
-
-  it("supports custom baseUrl", async () => {
-    const html = await process("[[Page]]", { baseUrl: "/wiki/" })
-    expect(html).toContain('href="/wiki/page"')
-  })
-
-  it("sets data-target attribute", async () => {
-    const html = await process("[[My Page]]")
-    expect(html).toContain('data-target="My Page"')
-  })
-
-  it("sets data-heading attribute when heading present", async () => {
-    const html = await process("[[Page#Section]]")
-    expect(html).toContain('data-heading="Section"')
-  })
-
-  it("preserves surrounding text", async () => {
-    const html = await process("before [[Link]] after")
-    expect(html).toContain("before ")
-    expect(html).toContain(" after")
-  })
-})