blumenjs 0.1.7 → 0.2.1

package/dist/templates/go-server/image.go

@@ -0,0 +1,200 @@
+package main
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"image"
+	"image/jpeg"
+	"image/png"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"golang.org/x/image/draw"
+)
+
+const (
+	imageCacheDir  = ".blumen/image-cache"
+	maxImageWidth  = 4096
+	defaultQuality = 80
+)
+
+func init() {
+	// Ensure cache directory exists
+	os.MkdirAll(imageCacheDir, 0755)
+}
+
+// ImageHandler serves optimized images with on-the-fly resizing and caching.
+// URL: /_blumen/image?src=/static/hero.jpg&w=800&q=80&blur=1
+func ImageHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		q := r.URL.Query()
+		src := q.Get("src")
+		widthStr := q.Get("w")
+		qualityStr := q.Get("q")
+		isBlur := q.Get("blur") == "1"
+
+		if src == "" {
+			http.Error(w, "Missing 'src' parameter", http.StatusBadRequest)
+			return
+		}
+
+		// Parse width
+		targetWidth := 0
+		if widthStr != "" {
+			var err error
+			targetWidth, err = strconv.Atoi(widthStr)
+			if err != nil || targetWidth <= 0 || targetWidth > maxImageWidth {
+				http.Error(w, "Invalid 'w' parameter", http.StatusBadRequest)
+				return
+			}
+		}
+
+		// Parse quality
+		quality := defaultQuality
+		if qualityStr != "" {
+			var err error
+			quality, err = strconv.Atoi(qualityStr)
+			if err != nil || quality < 1 || quality > 100 {
+				quality = defaultQuality
+			}
+		}
+
+		// Security: resolve the source path and ensure it's within the project
+		cleanSrc := strings.TrimPrefix(src, "/")
+		absPath, err := filepath.Abs(cleanSrc)
+		if err != nil {
+			http.Error(w, "Invalid path", http.StatusBadRequest)
+			return
+		}
+
+		// Ensure path is within the project directory
+		cwd, _ := os.Getwd()
+		if !strings.HasPrefix(absPath, cwd) {
+			http.Error(w, "Access denied", http.StatusForbidden)
+			return
+		}
+
+		// Check if file exists
+		if _, err := os.Stat(absPath); os.IsNotExist(err) {
+			http.Error(w, "Image not found", http.StatusNotFound)
+			return
+		}
+
+		// Generate cache key
+		cacheKey := generateCacheKey(src, targetWidth, quality, isBlur)
+		cachePath := filepath.Join(imageCacheDir, cacheKey+".jpg")
+
+		// Check disk cache
+		if cachedData, err := os.ReadFile(cachePath); err == nil {
+			serveCachedImage(w, cachedData)
+			return
+		}
+
+		// Process the image
+		processedData, err := processImage(absPath, targetWidth, quality, isBlur)
+		if err != nil {
+			log.Printf("Image processing error: %v", err)
+			http.ServeFile(w, r, absPath)
+			return
+		}
+
+		// Write to disk cache
+		os.WriteFile(cachePath, processedData, 0644)
+
+		// Serve the processed image
+		serveCachedImage(w, processedData)
+	}
+}
+
+func generateCacheKey(src string, width, quality int, blur bool) string {
+	data := fmt.Sprintf("%s-%d-%d-%v", src, width, quality, blur)
+	hash := sha256.Sum256([]byte(data))
+	return hex.EncodeToString(hash[:16])
+}
+
+func serveCachedImage(w http.ResponseWriter, data []byte) {
+	w.Header().Set("Content-Type", "image/jpeg")
+	w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
+	w.Header().Set("X-Blumen-Image", "optimized")
+	w.Header().Set("Content-Length", strconv.Itoa(len(data)))
+	w.WriteHeader(http.StatusOK)
+	w.Write(data)
+}
+
+func processImage(filePath string, targetWidth, quality int, blur bool) ([]byte, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("open image: %w", err)
+	}
+	defer file.Close()
+
+	img, format, err := image.Decode(file)
+	if err != nil {
+		return nil, fmt.Errorf("decode image (%s): %w", format, err)
+	}
+
+	bounds := img.Bounds()
+	origWidth := bounds.Dx()
+	origHeight := bounds.Dy()
+
+	// Calculate target dimensions maintaining aspect ratio
+	newWidth := origWidth
+	newHeight := origHeight
+
+	if targetWidth > 0 && targetWidth < origWidth {
+		ratio := float64(targetWidth) / float64(origWidth)
+		newWidth = targetWidth
+		newHeight = int(float64(origHeight) * ratio)
+	}
+
+	// Resize using high-quality bilinear interpolation
+	resized := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
+	draw.BiLinear.Scale(resized, resized.Bounds(), img, bounds, draw.Over, nil)
+
+	// For blur placeholders, downscale aggressively
+	var finalImg image.Image = resized
+	if blur {
+		blurWidth := 20
+		if newWidth < blurWidth {
+			blurWidth = newWidth
+		}
+		blurHeight := int(float64(newHeight) * (float64(blurWidth) / float64(newWidth)))
+		if blurHeight < 1 {
+			blurHeight = 1
+		}
+		blurred := image.NewRGBA(image.Rect(0, 0, blurWidth, blurHeight))
+		draw.BiLinear.Scale(blurred, blurred.Bounds(), resized, resized.Bounds(), draw.Over, nil)
+		finalImg = blurred
+	}
+
+	// Encode to JPEG
+	var buf bytes.Buffer
+
+	jpegQuality := quality
+	if blur {
+		jpegQuality = 30
+	}
+
+	err = jpeg.Encode(&buf, finalImg, &jpeg.Options{Quality: jpegQuality})
+	if err != nil {
+		return nil, fmt.Errorf("encode jpeg: %w", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// Ensure PNG decoder is registered
+func init() {
+	_ = png.Decode
+}