static.go

package main

import (
	"crypto/sha256"
	"embed"
	"encoding/hex"
	"fmt"
	"io"
	"mime"
	"net/http"
	"os"
	"path"
	"regexp"
	"time"

	"github.com/evanw/esbuild/pkg/api"
)

//go:embed static/*
var staticFiles embed.FS

func patchCSS() {
	// patch the output CSS so we have more control over the color variables
	index, err := os.Open("static/index.css")
	if err != nil {
		fmt.Fprintf(os.Stderr, "Reading output css: %v\n", err)
		os.Exit(1)
	}
	out, _ := io.ReadAll(index)
	reg := regexp.MustCompile(`@media \(prefers-color-scheme: (\w+)\)\{\.markdown-body,\[data-theme=\w+\]\{(.*?)\}\}`)
	// captures theme (light, dark) and raw rules
	out = reg.ReplaceAll(out, []byte("[data-theme=$1]{$2}"))
	//os.WriteFile("static/index.css", out, 0644)

	hasher := sha256.New()
	hasher.Write(out)
	etag := `W/"` + hex.EncodeToString(hasher.Sum(nil)) + `"`

	stat, _ := index.Stat()
	indexModTime := stat.ModTime()

	http.HandleFunc("/index.css", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/css")
		w.Header().Set("Last-Modified", indexModTime.UTC().Format(http.TimeFormat))
		w.Header().Set("ETag", etag)
		w.Write(out)
	})
}

func serveStatic() {
	entries, err := staticFiles.ReadDir("static")
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to list static files: %v\n", err)
		os.Exit(1)
	}

	for _, entry := range entries {
		if entry.IsDir() {
			continue
		}

		name := entry.Name()
		route := "/" + name
		assetPath := "static/" + name

		ext := path.Ext(name)

		if ext == ".js" || ext == ".css" {
			continue
		}

		content, err := staticFiles.ReadFile(assetPath)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Unable to embed %s: %v\n", name, err)
			continue
		}

		contentType := mime.TypeByExtension(ext)
		if contentType == "" {
			contentType = "application/octet-stream"
		}

		info, _ := entry.Info()
		modTime := info.ModTime()

		hasher := sha256.New()
		hasher.Write(content)
		hasher.Write([]byte(modTime.UTC().Format(http.TimeFormat)))
		etag := `W/"` + hex.EncodeToString(hasher.Sum(nil)) + `"`

		func(route string, content []byte, etag string) {
			http.HandleFunc(route, func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set("Content-Type", contentType)
				w.Header().Set("Last-Modified", modTime.UTC().Format(http.TimeFormat))
				w.Header().Set("ETag", etag)

				if match := r.Header.Get("If-None-Match"); match != "" {
					if match == etag {
						w.WriteHeader(http.StatusNotModified)
						return
					}
				}

				if t, err := http.ParseTime(r.Header.Get("If-Modified-Since")); err == nil && modTime.Before(t.Add(1*time.Second)) {
					w.WriteHeader(http.StatusNotModified)
					return
				}

				w.Write(content)
			})
		}(route, content, etag)
	}
}

func serveScripts() {

	// build board js when script is ran
	api.Build(api.BuildOptions{
		EntryPoints:       []string{"views/theme.ts", "views/nav.ts", "views/board.ts", "views/index.css"},
		Outdir:            "static/",
		Bundle:            true,
		Write:             true,
		MinifyWhitespace:  true,
		MinifyIdentifiers: true,
		MinifySyntax:      true,
		Banner: map[string]string{
			"js": "'use strict';",
		},
		Format:   api.FormatCommonJS,
		Platform: api.PlatformBrowser,
		LogLevel: api.LogLevelInfo,
	})

	compileTime := time.Now()
	jsFiles := []string{"nav.js", "board.js", "theme.js"}
	for _, name := range jsFiles {
		route := "/" + name
		path := "static/" + name
		content, err := os.ReadFile(path)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Unable to embed %s: %v\n", name, err)
			continue
		}

		hasher := sha256.New()
		hasher.Write(content)
		etag := `W/"` + hex.EncodeToString(hasher.Sum(nil)) + `"`

		http.HandleFunc(route, func(w http.ResponseWriter, r *http.Request) {
			w.Header().Set("Content-Type", "application/javascript")
			w.Header().Set("Last-Modified", compileTime.UTC().Format(http.TimeFormat))
			w.Header().Set("ETag", etag)

			if match := r.Header.Get("If-None-Match"); match != "" {
				if match == etag {
					w.WriteHeader(http.StatusNotModified)
					return
				}
			}

			if t, err := http.ParseTime(r.Header.Get("If-Modified-Since")); err == nil && compileTime.Before(t.Add(1*time.Second)) {
				w.WriteHeader(http.StatusNotModified)
				return
			}

			w.Write(content)
		})
	}
}