@knpkv/confluence-to-markdown 0.5.0 → 0.6.0

package/test/schemas/ConversionSchema.test.ts

@@ -1,159 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import { Effect, Schema } from "effect"
-import { ConfluenceToMarkdown, DocumentFromHast, DocumentFromMdast } from "../../src/schemas/ConversionSchema.js"
-import { HastFromHtml } from "../../src/schemas/hast/index.js"
-import { MdastFromMarkdown } from "../../src/schemas/mdast/index.js"
-
-describe("ConversionSchema", () => {
-  describe("DocumentFromHast", () => {
-    it.effect("converts simple HAST root to Document", () =>
-      Effect.gen(function*() {
-        const html = "<h1>Title</h1><p>Hello world</p>"
-        const hast = yield* Schema.decode(HastFromHtml)(html)
-        const doc = yield* Schema.decode(DocumentFromHast)(hast)
-
-        expect(doc.version).toBe(1)
-        expect(doc.children.length).toBe(2)
-        expect(doc.children[0]?._tag).toBe("Heading")
-        expect(doc.children[1]?._tag).toBe("Paragraph")
-      }))
-
-    it.effect("handles code blocks", () =>
-      Effect.gen(function*() {
-        const html = "<pre><code>const x = 1</code></pre>"
-        const hast = yield* Schema.decode(HastFromHtml)(html)
-        const doc = yield* Schema.decode(DocumentFromHast)(hast)
-
-        expect(doc.children[0]?._tag).toBe("CodeBlock")
-      }))
-
-    it.effect("handles empty input", () =>
-      Effect.gen(function*() {
-        const html = ""
-        const hast = yield* Schema.decode(HastFromHtml)(html)
-        const doc = yield* Schema.decode(DocumentFromHast)(hast)
-
-        expect(doc.children.length).toBe(0)
-      }))
-  })
-
-  describe("DocumentFromMdast", () => {
-    it.effect("converts simple MDAST root to Document", () =>
-      Effect.gen(function*() {
-        const md = "# Title\n\nHello world"
-        const mdast = yield* Schema.decode(MdastFromMarkdown)(md)
-        const doc = yield* Schema.decode(DocumentFromMdast)(mdast)
-
-        expect(doc.version).toBe(1)
-        expect(doc.children.length).toBe(2)
-        expect(doc.children[0]?._tag).toBe("Heading")
-        expect(doc.children[1]?._tag).toBe("Paragraph")
-      }))
-
-    it.effect("handles code blocks", () =>
-      Effect.gen(function*() {
-        const md = "```ts\nconst x = 1\n```"
-        const mdast = yield* Schema.decode(MdastFromMarkdown)(md)
-        const doc = yield* Schema.decode(DocumentFromMdast)(mdast)
-
-        expect(doc.children[0]?._tag).toBe("CodeBlock")
-      }))
-
-    it.effect("handles lists", () =>
-      Effect.gen(function*() {
-        const md = "- Item 1\n- Item 2"
-        const mdast = yield* Schema.decode(MdastFromMarkdown)(md)
-        const doc = yield* Schema.decode(DocumentFromMdast)(mdast)
-
-        expect(doc.children[0]?._tag).toBe("List")
-      }))
-  })
-
-  describe("ConfluenceToMarkdown", () => {
-    it.effect("decodes simple Confluence HTML to Markdown", () =>
-      Effect.gen(function*() {
-        const html = "<h1>Title</h1><p>Hello world</p>"
-        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
-
-        expect(md).toContain("# Title")
-        expect(md).toContain("Hello world")
-      }))
-
-    it.effect("decodes code blocks", () =>
-      Effect.gen(function*() {
-        const html = "<pre><code class=\"language-ts\">const x = 1</code></pre>"
-        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
-
-        expect(md).toContain("```")
-        expect(md).toContain("const x = 1")
-      }))
-
-    it.effect("decodes inline formatting", () =>
-      Effect.gen(function*() {
-        const html = "<p><strong>bold</strong> and <em>italic</em></p>"
-        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
-
-        expect(md).toContain("**bold**")
-        expect(md).toContain("_italic_")
-      }))
-
-    it.effect("encodes Markdown to basic HTML (structure only)", () =>
-      Effect.gen(function*() {
-        const md = "# Title\n\nHello world"
-        const html = yield* Schema.encode(ConfluenceToMarkdown)(md)
-
-        // Note: basic HTML encoding only preserves structure, not content
-        expect(html).toContain("<h1>")
-        expect(html).toContain("<p>")
-      }))
-
-    it.effect("handles links", () =>
-      Effect.gen(function*() {
-        const html = "<p><a href=\"https://example.com\">Click here</a></p>"
-        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
-
-        expect(md).toContain("[Click here](https://example.com)")
-      }))
-
-    it.effect("handles horizontal rules", () =>
-      Effect.gen(function*() {
-        const html = "<hr />"
-        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
-
-        expect(md).toContain("---")
-      }))
-
-    it.effect("handles lists", () =>
-      Effect.gen(function*() {
-        const html = "<ul><li><p>Item 1</p></li><li><p>Item 2</p></li></ul>"
-        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
-
-        expect(md).toContain("- ")
-        expect(md).toContain("Item 1")
-        expect(md).toContain("Item 2")
-      }))
-
-    it.effect("handles tables", () =>
-      Effect.gen(function*() {
-        const html = "<table><tr><th>A</th></tr><tr><td>1</td></tr></table>"
-        const md = yield* Schema.decode(ConfluenceToMarkdown)(html)
-
-        expect(md).toContain("|")
-        expect(md).toContain("---")
-      }))
-  })
-
-  describe("roundtrip", () => {
-    it.effect("HTML -> Markdown -> HTML preserves structure", () =>
-      Effect.gen(function*() {
-        // Start from HTML since that direction is fully supported
-        const originalHtml = "<h1>Hello</h1><p>World</p>"
-        const md = yield* Schema.decode(ConfluenceToMarkdown)(originalHtml)
-        const html = yield* Schema.encode(ConfluenceToMarkdown)(md)
-
-        // Structure is preserved
-        expect(html).toContain("<h1>")
-        expect(html).toContain("<p>")
-      }))
-  })
-})

package/test/schemas/HastSchema.test.ts

@@ -1,138 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import * as Schema from "effect/Schema"
-import {
-  getTextContent,
-  HastFromHtml,
-  HastNodeSchema,
-  HastRootSchema,
-  isHastElement,
-  isHastText,
-  makeHastElement,
-  makeHastRoot,
-  makeHastText
-} from "../../src/schemas/hast/index.js"
-
-describe("HastSchema", () => {
-  describe("constructors", () => {
-    it("creates text node", () => {
-      const node = makeHastText("hello")
-      expect(node._tag).toBe("text")
-      expect(node.value).toBe("hello")
-    })
-
-    it("creates element node", () => {
-      const node = makeHastElement("div", { class: "test" }, [makeHastText("child")])
-      expect(node._tag).toBe("element")
-      expect(node.tagName).toBe("div")
-      expect(node.properties.class).toBe("test")
-      expect(node.children).toHaveLength(1)
-    })
-
-    it("creates root node", () => {
-      const root = makeHastRoot([makeHastElement("p", {}, [makeHastText("text")])])
-      expect(root._tag).toBe("root")
-      expect(root.children).toHaveLength(1)
-    })
-  })
-
-  describe("type guards", () => {
-    it("isHastText returns true for text node", () => {
-      expect(isHastText(makeHastText("hello"))).toBe(true)
-      expect(isHastText(makeHastElement("div"))).toBe(false)
-    })
-
-    it("isHastElement returns true for element node", () => {
-      expect(isHastElement(makeHastElement("div"))).toBe(true)
-      expect(isHastElement(makeHastText("hello"))).toBe(false)
-    })
-  })
-
-  describe("getTextContent", () => {
-    it("extracts text from text node", () => {
-      expect(getTextContent(makeHastText("hello"))).toBe("hello")
-    })
-
-    it("extracts text from nested elements", () => {
-      const el = makeHastElement("div", {}, [
-        makeHastText("hello "),
-        makeHastElement("strong", {}, [makeHastText("world")])
-      ])
-      expect(getTextContent(el)).toBe("hello world")
-    })
-  })
-
-  describe("HastNodeSchema", () => {
-    it("validates text node", () => {
-      const result = Schema.decodeUnknownEither(HastNodeSchema)(makeHastText("test"))
-      expect(Either.isRight(result)).toBe(true)
-    })
-
-    it("validates element node", () => {
-      const result = Schema.decodeUnknownEither(HastNodeSchema)(makeHastElement("p"))
-      expect(Either.isRight(result)).toBe(true)
-    })
-  })
-
-  describe("HastRootSchema", () => {
-    it("validates root node", () => {
-      const root = makeHastRoot([makeHastElement("p", {}, [makeHastText("text")])])
-      const result = Schema.decodeUnknownEither(HastRootSchema)(root)
-      expect(Either.isRight(result)).toBe(true)
-    })
-  })
-})
-
-describe("HastFromHtml", () => {
-  describe("decode (HTML -> HAST)", () => {
-    it.effect("parses simple HTML", () =>
-      Effect.gen(function*() {
-        const hast = yield* Schema.decode(HastFromHtml)("<p>Hello</p>")
-        expect(hast._tag).toBe("root")
-        expect(hast.children).toHaveLength(1)
-        const p = hast.children[0]
-        expect(isHastElement(p) && p.tagName).toBe("p")
-      }))
-
-    it.effect("parses nested HTML", () =>
-      Effect.gen(function*() {
-        const hast = yield* Schema.decode(HastFromHtml)("<div><p>Text</p></div>")
-        expect(hast.children).toHaveLength(1)
-        const div = hast.children[0]
-        if (isHastElement(div)) {
-          expect(div.tagName).toBe("div")
-          expect(div.children).toHaveLength(1)
-        }
-      }))
-
-    it.effect("parses HTML with attributes", () =>
-      Effect.gen(function*() {
-        const hast = yield* Schema.decode(HastFromHtml)("<a href=\"https://example.com\">Link</a>")
-        const a = hast.children[0]
-        if (isHastElement(a)) {
-          expect(a.properties.href).toBe("https://example.com")
-        }
-      }))
-  })
-
-  describe("encode (HAST -> HTML)", () => {
-    it.effect("stringifies HAST to HTML", () =>
-      Effect.gen(function*() {
-        const hast = makeHastRoot([
-          makeHastElement("p", {}, [makeHastText("Hello")])
-        ])
-        const html = yield* Schema.encode(HastFromHtml)(hast)
-        expect(html).toContain("<p>")
-        expect(html).toContain("Hello")
-      }))
-
-    it.effect("roundtrips HTML", () =>
-      Effect.gen(function*() {
-        const original = "<p>Test paragraph</p>"
-        const hast = yield* Schema.decode(HastFromHtml)(original)
-        const html = yield* Schema.encode(HastFromHtml)(hast)
-        expect(html.replace(/\s/g, "")).toBe(original.replace(/\s/g, ""))
-      }))
-  })
-})

package/test/schemas/MdastSchema.test.ts

@@ -1,145 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import * as Schema from "effect/Schema"
-import {
-  isMdastHeading,
-  isMdastParagraph,
-  isMdastText,
-  makeMdastHeading,
-  makeMdastParagraph,
-  makeMdastRoot,
-  makeMdastText,
-  MdastFromMarkdown,
-  MdastRootSchema,
-  MdastTextSchema
-} from "../../src/schemas/mdast/index.js"
-
-describe("MdastSchema", () => {
-  describe("constructors", () => {
-    it("creates text node", () => {
-      const node = makeMdastText("hello")
-      expect(node.type).toBe("text")
-      expect(node.value).toBe("hello")
-    })
-
-    it("creates heading node", () => {
-      const node = makeMdastHeading(2, [makeMdastText("Title")])
-      expect(node.type).toBe("heading")
-      expect(node.depth).toBe(2)
-      expect(node.children).toHaveLength(1)
-    })
-
-    it("creates paragraph node", () => {
-      const node = makeMdastParagraph([makeMdastText("content")])
-      expect(node.type).toBe("paragraph")
-      expect(node.children).toHaveLength(1)
-    })
-
-    it("creates root node", () => {
-      const root = makeMdastRoot([makeMdastParagraph([makeMdastText("text")])])
-      expect(root.type).toBe("root")
-      expect(root.children).toHaveLength(1)
-    })
-  })
-
-  describe("type guards", () => {
-    it("isMdastText returns true for text node", () => {
-      expect(isMdastText(makeMdastText("hello"))).toBe(true)
-      expect(isMdastText(makeMdastHeading(1, []))).toBe(false)
-    })
-
-    it("isMdastHeading returns true for heading node", () => {
-      expect(isMdastHeading(makeMdastHeading(1, []))).toBe(true)
-      expect(isMdastHeading(makeMdastText("hello"))).toBe(false)
-    })
-
-    it("isMdastParagraph returns true for paragraph node", () => {
-      expect(isMdastParagraph(makeMdastParagraph([]))).toBe(true)
-      expect(isMdastParagraph(makeMdastText("hello"))).toBe(false)
-    })
-  })
-
-  describe("MdastTextSchema", () => {
-    it("validates text node", () => {
-      const result = Schema.decodeUnknownEither(MdastTextSchema)(makeMdastText("test"))
-      expect(Either.isRight(result)).toBe(true)
-    })
-
-    it("rejects invalid type", () => {
-      const result = Schema.decodeUnknownEither(MdastTextSchema)({ type: "other", value: "x" })
-      expect(Either.isLeft(result)).toBe(true)
-    })
-  })
-
-  describe("MdastRootSchema", () => {
-    it("validates root node", () => {
-      const root = makeMdastRoot([makeMdastParagraph([makeMdastText("text")])])
-      const result = Schema.decodeUnknownEither(MdastRootSchema)(root)
-      expect(Either.isRight(result)).toBe(true)
-    })
-  })
-})
-
-describe("MdastFromMarkdown", () => {
-  describe("decode (Markdown -> MDAST)", () => {
-    it.effect("parses heading", () =>
-      Effect.gen(function*() {
-        const mdast = yield* Schema.decode(MdastFromMarkdown)("# Hello")
-        expect(mdast.type).toBe("root")
-        expect(mdast.children).toHaveLength(1)
-        const heading = mdast.children[0]
-        expect(heading.type).toBe("heading")
-      }))
-
-    it.effect("parses paragraph", () =>
-      Effect.gen(function*() {
-        const mdast = yield* Schema.decode(MdastFromMarkdown)("Hello world")
-        expect(mdast.children).toHaveLength(1)
-        expect(mdast.children[0].type).toBe("paragraph")
-      }))
-
-    it.effect("parses code block", () =>
-      Effect.gen(function*() {
-        const mdast = yield* Schema.decode(MdastFromMarkdown)("```ts\nconst x = 1\n```")
-        expect(mdast.children).toHaveLength(1)
-        const code = mdast.children[0]
-        expect(code.type).toBe("code")
-      }))
-
-    it.effect("parses list", () =>
-      Effect.gen(function*() {
-        const mdast = yield* Schema.decode(MdastFromMarkdown)("- item 1\n- item 2")
-        expect(mdast.children).toHaveLength(1)
-        expect(mdast.children[0].type).toBe("list")
-      }))
-  })
-
-  describe("encode (MDAST -> Markdown)", () => {
-    it.effect("stringifies heading", () =>
-      Effect.gen(function*() {
-        const mdast = makeMdastRoot([
-          makeMdastHeading(1, [makeMdastText("Title")])
-        ])
-        const md = yield* Schema.encode(MdastFromMarkdown)(mdast)
-        expect(md.trim()).toBe("# Title")
-      }))
-
-    it.effect("stringifies paragraph", () =>
-      Effect.gen(function*() {
-        const mdast = makeMdastRoot([
-          makeMdastParagraph([makeMdastText("Hello world")])
-        ])
-        const md = yield* Schema.encode(MdastFromMarkdown)(mdast)
-        expect(md.trim()).toBe("Hello world")
-      }))
-
-    it.effect("roundtrips markdown", () =>
-      Effect.gen(function*() {
-        const original = "# Title\n\nParagraph text."
-        const mdast = yield* Schema.decode(MdastFromMarkdown)(original)
-        const md = yield* Schema.encode(MdastFromMarkdown)(mdast)
-        expect(md.trim()).toBe(original)
-      }))
-  })
-})

package/test/schemas/nodes/block/BlockSchema.test.ts

@@ -1,173 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import type { UnsupportedBlock } from "../../../../src/ast/BlockNode.js"
-import {
-  CodeBlock,
-  Heading,
-  Paragraph,
-  Table,
-  TableCell,
-  TableRow,
-  ThematicBreak
-} from "../../../../src/ast/BlockNode.js"
-import { Text } from "../../../../src/ast/InlineNode.js"
-import { makeMdastHeading, makeMdastParagraph, makeMdastText } from "../../../../src/schemas/mdast/index.js"
-import { blockNodeFromMdast, blockNodeToHast, blockNodeToMdast } from "../../../../src/schemas/nodes/block/index.js"
-
-describe("BlockSchema", () => {
-  describe("blockNodeToHast", () => {
-    it("converts Heading to hast h element", () => {
-      const heading = new Heading({ level: 2, children: [new Text({ value: "Title" })] })
-      const result = blockNodeToHast(heading)
-      expect(result._tag).toBe("element")
-      expect(result.tagName).toBe("h2")
-    })
-
-    it("converts Paragraph to hast p element", () => {
-      const para = new Paragraph({ children: [new Text({ value: "Hello" })] })
-      const result = blockNodeToHast(para)
-      expect(result._tag).toBe("element")
-      expect(result.tagName).toBe("p")
-    })
-
-    it("converts CodeBlock to hast pre/code elements", () => {
-      const code = new CodeBlock({ code: "const x = 1", language: "ts" })
-      const result = blockNodeToHast(code)
-      expect(result._tag).toBe("element")
-      expect(result.tagName).toBe("pre")
-      expect(result.properties?.dataLanguage).toBe("ts")
-    })
-
-    it("converts ThematicBreak to hast hr element", () => {
-      const hr = new ThematicBreak({})
-      const result = blockNodeToHast(hr)
-      expect(result._tag).toBe("element")
-      expect(result.tagName).toBe("hr")
-    })
-
-    it("converts Table to hast table element", () => {
-      const table = new Table({
-        header: new TableRow({
-          cells: [new TableCell({ isHeader: true, children: [new Text({ value: "Col" })] })]
-        }),
-        rows: [
-          new TableRow({
-            cells: [new TableCell({ children: [new Text({ value: "Val" })] })]
-          })
-        ]
-      })
-      const result = blockNodeToHast(table)
-      expect(result._tag).toBe("element")
-      expect(result.tagName).toBe("table")
-    })
-  })
-
-  describe("blockNodeToMdast", () => {
-    it("converts Heading to mdast heading", () => {
-      const heading = new Heading({ level: 1, children: [new Text({ value: "Title" })] })
-      const result = blockNodeToMdast(heading)
-      expect(result.type).toBe("heading")
-    })
-
-    it("converts Paragraph to mdast paragraph", () => {
-      const para = new Paragraph({ children: [new Text({ value: "Hello" })] })
-      const result = blockNodeToMdast(para)
-      expect(result.type).toBe("paragraph")
-    })
-
-    it("converts CodeBlock to mdast code", () => {
-      const code = new CodeBlock({ code: "const x = 1", language: "ts" })
-      const result = blockNodeToMdast(code)
-      expect(result.type).toBe("code")
-      expect((result as { value: string }).value).toBe("const x = 1")
-    })
-
-    it("converts ThematicBreak to mdast thematicBreak", () => {
-      const hr = new ThematicBreak({})
-      const result = blockNodeToMdast(hr)
-      expect(result.type).toBe("thematicBreak")
-    })
-
-    it("converts Table to mdast table", () => {
-      const table = new Table({ rows: [] })
-      const result = blockNodeToMdast(table)
-      expect(result.type).toBe("table")
-    })
-  })
-
-  describe("blockNodeFromMdast", () => {
-    it("converts mdast heading to Heading", () => {
-      const mdast = makeMdastHeading(2, [makeMdastText("Title")])
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("Heading")
-      expect((result as Heading).level).toBe(2)
-    })
-
-    it("converts mdast paragraph to Paragraph", () => {
-      const mdast = makeMdastParagraph([makeMdastText("Hello")])
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("Paragraph")
-    })
-
-    it("converts mdast code to CodeBlock", () => {
-      const mdast = { type: "code" as const, value: "const x = 1", lang: "ts" }
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("CodeBlock")
-      expect((result as CodeBlock).code).toBe("const x = 1")
-      expect((result as CodeBlock).language).toBe("ts")
-    })
-
-    it("converts mdast thematicBreak to ThematicBreak", () => {
-      const mdast = { type: "thematicBreak" as const }
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("ThematicBreak")
-    })
-
-    it("converts mdast blockquote to BlockQuote", () => {
-      const mdast = {
-        type: "blockquote" as const,
-        children: [makeMdastParagraph([makeMdastText("Quote")])]
-      }
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("BlockQuote")
-    })
-
-    it("converts mdast list to List", () => {
-      const mdast = {
-        type: "list" as const,
-        ordered: true,
-        children: [{
-          type: "listItem" as const,
-          children: [makeMdastParagraph([makeMdastText("Item")])]
-        }]
-      }
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("List")
-    })
-
-    it("converts mdast html to UnsupportedBlock", () => {
-      const mdast = { type: "html" as const, value: "<custom>x</custom>" }
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("UnsupportedBlock")
-      expect((result as UnsupportedBlock).rawMarkdown).toBe("<custom>x</custom>")
-    })
-  })
-
-  describe("roundtrip", () => {
-    it("Heading roundtrips through MDAST", () => {
-      const original = new Heading({ level: 3, children: [new Text({ value: "Title" })] })
-      const mdast = blockNodeToMdast(original)
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("Heading")
-      expect((result as Heading).level).toBe(3)
-    })
-
-    it("CodeBlock roundtrips through MDAST", () => {
-      const original = new CodeBlock({ code: "x = 1", language: "py" })
-      const mdast = blockNodeToMdast(original)
-      const result = blockNodeFromMdast(mdast)
-      expect(result._tag).toBe("CodeBlock")
-      expect((result as CodeBlock).code).toBe("x = 1")
-      expect((result as CodeBlock).language).toBe("py")
-    })
-  })
-})