prime8dev

markdown_wide.go (3974B)

---

 package tui
 
 import (
 	"fmt"
 	"regexp"
 	"strings"
 
 	"github.com/charmbracelet/x/ansi"
 )
 
 // Preformatted blocks (code, ascii diagrams) wider than the pane are pulled
 // out before markdown rendering and put back verbatim afterwards, so they
 // overflow (and scroll horizontally) instead of wrapping. Narrow blocks keep
 // the renderer's own styling and highlighting.
 
 const wideBlockToken = "PRIME8WIDEBLOCK"
 
 var (
 	fenceOpenRE   = regexp.MustCompile("^ {0,3}(`{3,}|~{3,})")
 	listItemRE    = regexp.MustCompile(`^\s*([-*+]|\d+[.)])\s`)
 	wideTokenRE   = regexp.MustCompile(`^\s*` + wideBlockToken + `(\d+)\s*$`)
 	codeGutter    = "┃ "
 	codeGutterLen = ansi.StringWidth(codeGutter)
 )
 
 // extractWideBlocks replaces every preformatted block whose longest line does
 // not fit in width with a placeholder paragraph.
 func extractWideBlocks(markdown string, width int) (string, [][]string) {
 	lines := strings.Split(markdown, "\n")
 	out := make([]string, 0, len(lines))
 	var blocks [][]string
 
 	emit := func(original []string, body []string) {
 		if blockWidth(body)+codeGutterLen <= width {
 			out = append(out, original...)
 			return
 		}
 		out = append(out, "", fmt.Sprintf("%s%d", wideBlockToken, len(blocks)), "")
 		blocks = append(blocks, body)
 	}
 
 	for i := 0; i < len(lines); i++ {
 		line := lines[i]
 
 		if m := fenceOpenRE.FindStringSubmatch(line); m != nil {
 			fence := m[1]
 			end := -1
 			for j := i + 1; j < len(lines); j++ {
 				t := strings.TrimSpace(lines[j])
 				if strings.HasPrefix(t, fence[:3]) && strings.Trim(t, fence[:1]) == "" && len(t) >= len(fence) {
 					end = j
 					break
 				}
 			}
 			if end < 0 {
 				out = append(out, lines[i:]...)
 				break
 			}
 			emit(lines[i:end+1], expandTabs(lines[i+1:end]))
 			i = end
 			continue
 		}
 
 		if isIndentedCode(line) && precededByBlankParagraph(lines, i) {
 			j := i
 			for j < len(lines) && (isIndentedCode(lines[j]) || strings.TrimSpace(lines[j]) == "") {
 				j++
 			}
 			for j > i && strings.TrimSpace(lines[j-1]) == "" {
 				j--
 			}
 			body := make([]string, 0, j-i)
 			for _, l := range lines[i:j] {
 				l = expandTabs([]string{l})[0]
 				if len(l) >= 4 {
 					l = l[4:]
 				} else {
 					l = ""
 				}
 				body = append(body, l)
 			}
 			emit(lines[i:j], body)
 			i = j - 1
 			continue
 		}
 
 		out = append(out, line)
 	}
 
 	return strings.Join(out, "\n"), blocks
 }
 
 func isIndentedCode(line string) bool {
 	return strings.HasPrefix(line, "    ") || strings.HasPrefix(line, "\t")
 }
 
 // precededByBlankParagraph reports whether an indented line starts a code
 // block rather than continuing a list item.
 func precededByBlankParagraph(lines []string, i int) bool {
 	if i == 0 {
 		return true
 	}
 	if strings.TrimSpace(lines[i-1]) != "" {
 		return false
 	}
 	for j := i - 1; j >= 0; j-- {
 		if strings.TrimSpace(lines[j]) == "" {
 			continue
 		}
 		return !listItemRE.MatchString(lines[j]) && !isIndentedCode(lines[j])
 	}
 	return true
 }
 
 func expandTabs(lines []string) []string {
 	out := make([]string, len(lines))
 	for i, l := range lines {
 		out[i] = strings.ReplaceAll(l, "\t", "    ")
 	}
 	return out
 }
 
 func blockWidth(lines []string) int {
 	w := 0
 	for _, l := range lines {
 		w = max(w, ansi.StringWidth(l))
 	}
 	return w
 }
 
 // restoreWideBlocks swaps the placeholders back for the verbatim block lines.
 func restoreWideBlocks(rendered string, blocks [][]string) string {
 	if len(blocks) == 0 {
 		return rendered
 	}
 	lines := strings.Split(rendered, "\n")
 	out := make([]string, 0, len(lines))
 	for _, line := range lines {
 		plain := ansi.Strip(line)
 		m := wideTokenRE.FindStringSubmatch(plain)
 		if m == nil {
 			out = append(out, line)
 			continue
 		}
 		var idx int
 		if _, err := fmt.Sscanf(m[1], "%d", &idx); err != nil || idx >= len(blocks) {
 			out = append(out, line)
 			continue
 		}
 		indent := plain[:len(plain)-len(strings.TrimLeft(plain, " "))]
 		for _, l := range blocks[idx] {
 			out = append(out, indent+dimStyle.Render(codeGutter)+rowStyle.Render(l))
 		}
 	}
 	return strings.Join(out, "\n")
 }