this repo has no description
tangled.org
1// heavily inspired by: https://github.com/kaleocheng/goldmark-extensions
2
3package extension
4
5import (
6 "regexp"
7
8 "github.com/yuin/goldmark"
9 "github.com/yuin/goldmark/ast"
10 "github.com/yuin/goldmark/parser"
11 "github.com/yuin/goldmark/renderer"
12 "github.com/yuin/goldmark/renderer/html"
13 "github.com/yuin/goldmark/text"
14 "github.com/yuin/goldmark/util"
15)
16
17// An AtNode struct represents an AtNode
18type AtNode struct {
19 Handle string
20 ast.BaseInline
21}
22
23var _ ast.Node = &AtNode{}
24
25// Dump implements Node.Dump.
26func (n *AtNode) Dump(source []byte, level int) {
27 ast.DumpHelper(n, source, level, nil, nil)
28}
29
30// KindAt is a NodeKind of the At node.
31var KindAt = ast.NewNodeKind("At")
32
33// Kind implements Node.Kind.
34func (n *AtNode) Kind() ast.NodeKind {
35 return KindAt
36}
37
38var atRegexp = regexp.MustCompile(`(^|\s|\()(@)([a-zA-Z0-9.-]+)(\b)`)
39var markdownLinkRegexp = regexp.MustCompile(`(?ms)\[.*\]\(.*\)`)
40
41type atParser struct{}
42
43// NewAtParser return a new InlineParser that parses
44// at expressions.
45func NewAtParser() parser.InlineParser {
46 return &atParser{}
47}
48
49func (s *atParser) Trigger() []byte {
50 return []byte{'@'}
51}
52
53func (s *atParser) Parse(parent ast.Node, block text.Reader, pc parser.Context) ast.Node {
54 line, segment := block.PeekLine()
55 m := atRegexp.FindSubmatchIndex(line)
56 if m == nil {
57 return nil
58 }
59
60 if !util.IsSpaceRune(block.PrecendingCharacter()) {
61 return nil
62 }
63
64 // Check for all links in the markdown to see if the handle found is inside one
65 linksIndexes := markdownLinkRegexp.FindAllIndex(block.Source(), -1)
66 for _, linkMatch := range linksIndexes {
67 if linkMatch[0] < segment.Start && segment.Start < linkMatch[1] {
68 return nil
69 }
70 }
71
72 atSegment := text.NewSegment(segment.Start, segment.Start+m[1])
73 block.Advance(m[1])
74 node := &AtNode{}
75 node.AppendChild(node, ast.NewTextSegment(atSegment))
76 node.Handle = string(atSegment.Value(block.Source())[1:])
77 return node
78}
79
80// atHtmlRenderer is a renderer.NodeRenderer implementation that
81// renders At nodes.
82type atHtmlRenderer struct {
83 html.Config
84}
85
86// NewAtHTMLRenderer returns a new AtHTMLRenderer.
87func NewAtHTMLRenderer(opts ...html.Option) renderer.NodeRenderer {
88 r := &atHtmlRenderer{
89 Config: html.NewConfig(),
90 }
91 for _, opt := range opts {
92 opt.SetHTMLOption(&r.Config)
93 }
94 return r
95}
96
97// RegisterFuncs implements renderer.NodeRenderer.RegisterFuncs.
98func (r *atHtmlRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {
99 reg.Register(KindAt, r.renderAt)
100}
101
102func (r *atHtmlRenderer) renderAt(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {
103 if entering {
104 w.WriteString(`<a href="/@`)
105 w.WriteString(n.(*AtNode).Handle)
106 w.WriteString(`" class="mention font-bold">`)
107 } else {
108 w.WriteString("</a>")
109 }
110 return ast.WalkContinue, nil
111}
112
113type atExt struct{}
114
115// At is an extension that allow you to use at expression like '@user.bsky.social' .
116var AtExt = &atExt{}
117
118func (e *atExt) Extend(m goldmark.Markdown) {
119 m.Parser().AddOptions(parser.WithInlineParsers(
120 util.Prioritized(NewAtParser(), 500),
121 ))
122 m.Renderer().AddOptions(renderer.WithNodeRenderers(
123 util.Prioritized(NewAtHTMLRenderer(), 500),
124 ))
125}