prime8dev

markdown_images.go (4835B)

---

 package tui
 
 import (
 	"fmt"
 	"image/color"
 	"net/http"
 	"regexp"
 	"strings"
 	"sync"
 	"time"
 
 	"github.com/charmbracelet/x/ansi"
 	"github.com/eliukblau/pixterm/pkg/ansimage"
 )
 
 // README images are pulled out before markdown rendering and drawn here,
 // scaled to fit a capped box, because go-term-markdown scales every image to
 // the full line width with no height limit.
 
 const (
 	imageToken   = "PRIME8IMAGE"
 	imageMaxCols = 96
 	imageMaxRows = 24
 )
 
 var (
 	mdImageRE      = regexp.MustCompile(`!\[([^\]]*)\]\(\s*<?([^)\s>]+)>?(?:\s+"[^"]*")?\s*\)`)
 	htmlImgSrcRE   = regexp.MustCompile(`(?i)<img\b[^>]*\bsrc\s*=\s*["']([^"']+)["'][^>]*>`)
 	htmlTagRE      = regexp.MustCompile(`<[^>]*>`)
 	mdLinkWrapRE   = regexp.MustCompile(`\[\s*(!\[[^\]]*\]\([^)]*\))\s*\]\([^)]*\)`)
 	imageTokenRE   = regexp.MustCompile(`^\s*` + imageToken + `(\d+)\s*$`)
 	imageCache     sync.Map // key "url|cols" -> []string
 	imageClient    = &http.Client{Timeout: 5 * time.Second}
 	imageFetchLock sync.Mutex
 )
 
 // imageSources returns the image URLs on a line that holds nothing but
 // images (markdown, linked badges, or HTML <img>), or nil.
 func imageSources(line string) []string {
 	rest := mdLinkWrapRE.ReplaceAllString(line, "$1")
 	var srcs []string
 	for _, m := range mdImageRE.FindAllStringSubmatch(rest, -1) {
 		srcs = append(srcs, m[2])
 	}
 	rest = mdImageRE.ReplaceAllString(rest, "")
 	for _, m := range htmlImgSrcRE.FindAllStringSubmatch(rest, -1) {
 		srcs = append(srcs, m[1])
 	}
 	rest = htmlImgSrcRE.ReplaceAllString(rest, "")
 	if strings.TrimSpace(htmlTagRE.ReplaceAllString(rest, "")) != "" {
 		return nil
 	}
 	return srcs
 }
 
 // extractImages swaps every image-only line (outside code fences) for a
 // placeholder paragraph and returns the rendered images in token order.
 func extractImages(markdown string, width int) (string, [][]string) {
 	lines := strings.Split(markdown, "\n")
 	out := make([]string, 0, len(lines))
 	var blocks [][]string
 	fence := ""
 	for _, line := range lines {
 		if m := fenceOpenRE.FindStringSubmatch(line); m != nil {
 			switch {
 			case fence == "":
 				fence = m[1][:1]
 			case strings.HasPrefix(m[1], fence):
 				fence = ""
 			}
 			out = append(out, line)
 			continue
 		}
 		if fence != "" {
 			out = append(out, line)
 			continue
 		}
 		srcs := imageSources(line)
 		if len(srcs) == 0 {
 			out = append(out, line)
 			continue
 		}
 		var block []string
 		for _, src := range srcs {
 			if len(block) > 0 {
 				block = append(block, "")
 			}
 			block = append(block, renderImageBlock(src, width)...)
 		}
 		out = append(out, "", fmt.Sprintf("%s%d", imageToken, len(blocks)), "")
 		blocks = append(blocks, block)
 	}
 	return strings.Join(out, "\n"), blocks
 }
 
 // imageBox is the cell box an image is fitted into: the pane width and a
 // third of it in rows (a cell is about twice as tall as wide, so roughly a
 // 3:2 box), capped at imageMaxCols x imageMaxRows.
 func imageBox(width int) (cols, rows int) {
 	cols = max(min(width, imageMaxCols), 8)
 	rows = max(min(cols/3, imageMaxRows), 4)
 	return cols, rows
 }
 
 // renderImageBlock draws one image fitted into imageBox(width), keeping its
 // aspect, or a dim link line when it can't be fetched or decoded.
 func renderImageBlock(src string, width int) []string {
 	cols, rows := imageBox(width)
 	key := fmt.Sprintf("%s|%d", src, cols)
 	if v, ok := imageCache.Load(key); ok {
 		return v.([]string)
 	}
 	lines := fetchImageLines(src, cols, rows)
 	if lines == nil {
 		lines = []string{dimStyle.Render("[image] " + src)}
 	}
 	imageCache.Store(key, lines)
 	return lines
 }
 
 func fetchImageLines(src string, cols, rows int) []string {
 	if !strings.HasPrefix(src, "http://") && !strings.HasPrefix(src, "https://") {
 		return nil
 	}
 	imageFetchLock.Lock()
 	defer imageFetchLock.Unlock()
 	res, err := imageClient.Get(src)
 	if err != nil {
 		return nil
 	}
 	defer res.Body.Close()
 	if res.StatusCode != http.StatusOK {
 		return nil
 	}
 	// ansimage sizes are in pixels; a half-block cell is 1 wide, 2 tall.
 	img, err := ansimage.NewScaledFromReader(res.Body, rows*2, cols,
 		color.Black, ansimage.ScaleModeFit, ansimage.NoDithering)
 	if err != nil {
 		return nil
 	}
 	return strings.Split(strings.TrimRight(img.Render(), "\n"), "\n")
 }
 
 func restoreImages(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 := imageTokenRE.FindStringSubmatch(plain)
 		var idx int
 		if m == nil {
 			out = append(out, line)
 			continue
 		}
 		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+l)
 		}
 	}
 	return strings.Join(out, "\n")
 }