Add kit package

Author: adrianpk

docs/features.md

@@ -17,6 +17,7 @@
 | `middleware` | Request ID, role-based access, rate limiting, locale detection, static cache |
 | `render` | Template FuncMap utilities, i18n integration |
 | `render/ui` | UI components (Badge, Chip, Price, Stat, Button, Link, Form, Input, Alert, Toast) |
+| `kit` | UI kit with dependency injection, HTMX-first components, emoji support, CSRF integration |
 | `modal` | Modal dialog configuration |
 | `pagination` | Generic pagination (`Result[T]`) |
 | `i18n` | Internationalization with YAML translation files |

kit/assets.go

@@ -0,0 +1,154 @@
+package kit
+
+import (
+	"embed"
+	"io"
+	"io/fs"
+	"net/http"
+	"path"
+	"strings"
+)
+
+// Assets manages static assets with overlay support.
+type Assets struct {
+	embeds  embed.FS
+	overlay fs.FS
+	prefix  string
+}
+
+// NewAssets creates a new asset manager.
+func NewAssets(embeds embed.FS) *Assets {
+	return &Assets{
+		embeds: embeds,
+		prefix: "/static",
+	}
+}
+
+// WithOverlay sets a filesystem overlay for asset customization.
+func (a *Assets) WithOverlay(overlay fs.FS) *Assets {
+	a.overlay = overlay
+	return a
+}
+
+// WithPrefix sets the URL prefix.
+func (a *Assets) WithPrefix(prefix string) *Assets {
+	a.prefix = prefix
+	return a
+}
+
+// Prefix returns the URL prefix.
+func (a *Assets) Prefix() string {
+	return a.prefix
+}
+
+// URL returns the full URL for an asset.
+func (a *Assets) URL(assetPath string) string {
+	if !strings.HasPrefix(assetPath, "/") {
+		assetPath = "/" + assetPath
+	}
+	return a.prefix + assetPath
+}
+
+// Open opens a file, checking overlay first.
+func (a *Assets) Open(name string) (fs.File, error) {
+	name = strings.TrimPrefix(name, "/")
+
+	if a.overlay != nil {
+		if f, err := a.overlay.Open(name); err == nil {
+			return f, nil
+		}
+	}
+
+	return a.embeds.Open(name)
+}
+
+// Read reads a file completely.
+func (a *Assets) Read(name string) ([]byte, error) {
+	f, err := a.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	return io.ReadAll(f)
+}
+
+// Handler returns an http.Handler for serving assets.
+func (a *Assets) Handler() http.Handler {
+	return http.StripPrefix(a.prefix, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		name := strings.TrimPrefix(r.URL.Path, "/")
+		if name == "" {
+			http.NotFound(w, r)
+			return
+		}
+
+		f, err := a.Open(name)
+		if err != nil {
+			http.NotFound(w, r)
+			return
+		}
+		defer f.Close()
+
+		stat, err := f.Stat()
+		if err != nil {
+			http.NotFound(w, r)
+			return
+		}
+
+		if stat.IsDir() {
+			http.NotFound(w, r)
+			return
+		}
+
+		content, err := io.ReadAll(f)
+		if err != nil {
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+
+		contentType := getContentType(name)
+		w.Header().Set("Content-Type", contentType)
+		w.Write(content)
+	}))
+}
+
+func getContentType(name string) string {
+	ext := strings.ToLower(path.Ext(name))
+	switch ext {
+	case ".css":
+		return "text/css; charset=utf-8"
+	case ".js":
+		return "application/javascript; charset=utf-8"
+	case ".json":
+		return "application/json; charset=utf-8"
+	case ".html", ".htm":
+		return "text/html; charset=utf-8"
+	case ".svg":
+		return "image/svg+xml"
+	case ".png":
+		return "image/png"
+	case ".jpg", ".jpeg":
+		return "image/jpeg"
+	case ".gif":
+		return "image/gif"
+	case ".ico":
+		return "image/x-icon"
+	case ".woff":
+		return "font/woff"
+	case ".woff2":
+		return "font/woff2"
+	case ".ttf":
+		return "font/ttf"
+	default:
+		return "application/octet-stream"
+	}
+}
+
+// Assets returns an asset manager for the kit.
+func (k *Kit) Assets() *Assets {
+	assets := NewAssets(k.embeds)
+	if k.overlay != nil {
+		assets.WithOverlay(k.overlay)
+	}
+	return assets
+}

kit/assets_test.go

@@ -0,0 +1,169 @@
+package kit
+
+import (
+	"embed"
+	"io/fs"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"testing/fstest"
+)
+
+//go:embed testdata/*
+var testEmbeds embed.FS
+
+func TestAssetsURL(t *testing.T) {
+	assets := NewAssets(testEmbeds)
+
+	tests := []struct {
+		path string
+		want string
+	}{
+		{"style.css", "/static/style.css"},
+		{"/style.css", "/static/style.css"},
+		{"js/app.js", "/static/js/app.js"},
+	}
+
+	for _, tt := range tests {
+		got := assets.URL(tt.path)
+		if got != tt.want {
+			t.Errorf("URL(%q) = %q, want %q", tt.path, got, tt.want)
+		}
+	}
+}
+
+func TestAssetsPrefix(t *testing.T) {
+	assets := NewAssets(testEmbeds).WithPrefix("/assets")
+
+	if assets.Prefix() != "/assets" {
+		t.Errorf("Prefix() = %q, want %q", assets.Prefix(), "/assets")
+	}
+
+	url := assets.URL("style.css")
+	if url != "/assets/style.css" {
+		t.Errorf("URL() = %q, want %q", url, "/assets/style.css")
+	}
+}
+
+func TestAssetsOverlay(t *testing.T) {
+	overlay := fstest.MapFS{
+		"custom.css": &fstest.MapFile{Data: []byte("/* custom */")},
+	}
+
+	assets := NewAssets(testEmbeds).WithOverlay(overlay)
+
+	content, err := assets.Read("custom.css")
+	if err != nil {
+		t.Fatalf("Read() error = %v", err)
+	}
+
+	if string(content) != "/* custom */" {
+		t.Errorf("Read() = %q, want %q", string(content), "/* custom */")
+	}
+}
+
+func TestAssetsOpenNotFound(t *testing.T) {
+	assets := NewAssets(testEmbeds)
+
+	_, err := assets.Open("nonexistent.css")
+	if err == nil {
+		t.Error("Open() expected error for nonexistent file")
+	}
+}
+
+func TestAssetsHandler(t *testing.T) {
+	overlay := fstest.MapFS{
+		"test.css": &fstest.MapFile{Data: []byte("body { color: red; }")},
+	}
+
+	assets := NewAssets(testEmbeds).WithOverlay(overlay)
+	handler := assets.Handler()
+
+	tests := []struct {
+		path       string
+		wantStatus int
+		wantType   string
+	}{
+		{"/static/test.css", http.StatusOK, "text/css; charset=utf-8"},
+		{"/static/notfound.css", http.StatusNotFound, ""},
+		{"/static/", http.StatusNotFound, ""},
+	}
+
+	for _, tt := range tests {
+		req := httptest.NewRequest(http.MethodGet, tt.path, nil)
+		w := httptest.NewRecorder()
+
+		handler.ServeHTTP(w, req)
+
+		if w.Code != tt.wantStatus {
+			t.Errorf("Handler(%q) status = %d, want %d", tt.path, w.Code, tt.wantStatus)
+		}
+
+		if tt.wantType != "" && w.Header().Get("Content-Type") != tt.wantType {
+			t.Errorf("Handler(%q) content-type = %q, want %q",
+				tt.path, w.Header().Get("Content-Type"), tt.wantType)
+		}
+	}
+}
+
+func TestGetContentType(t *testing.T) {
+	tests := []struct {
+		name string
+		want string
+	}{
+		{"style.css", "text/css; charset=utf-8"},
+		{"app.js", "application/javascript; charset=utf-8"},
+		{"data.json", "application/json; charset=utf-8"},
+		{"page.html", "text/html; charset=utf-8"},
+		{"icon.svg", "image/svg+xml"},
+		{"photo.png", "image/png"},
+		{"photo.jpg", "image/jpeg"},
+		{"photo.jpeg", "image/jpeg"},
+		{"anim.gif", "image/gif"},
+		{"favicon.ico", "image/x-icon"},
+		{"font.woff", "font/woff"},
+		{"font.woff2", "font/woff2"},
+		{"font.ttf", "font/ttf"},
+		{"unknown.xyz", "application/octet-stream"},
+	}
+
+	for _, tt := range tests {
+		got := getContentType(tt.name)
+		if got != tt.want {
+			t.Errorf("getContentType(%q) = %q, want %q", tt.name, got, tt.want)
+		}
+	}
+}
+
+func TestAssetsHandlerDirectory(t *testing.T) {
+	overlay := fstest.MapFS{
+		"subdir/file.txt": &fstest.MapFile{Data: []byte("test")},
+	}
+
+	assets := NewAssets(testEmbeds).WithOverlay(overlay)
+	handler := assets.Handler()
+
+	req := httptest.NewRequest(http.MethodGet, "/subdir", nil)
+	w := httptest.NewRecorder()
+
+	handler.ServeHTTP(w, req)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("Handler for directory status = %d, want %d", w.Code, http.StatusNotFound)
+	}
+}
+
+type errorFS struct{}
+
+func (errorFS) Open(name string) (fs.File, error) {
+	return nil, fs.ErrNotExist
+}
+
+func TestAssetsOverlayFallback(t *testing.T) {
+	assets := NewAssets(testEmbeds).WithOverlay(errorFS{})
+
+	_, err := assets.Open("testdata/sample.txt")
+	if err != nil {
+		t.Errorf("Open() should fall back to embeds, got error: %v", err)
+	}
+}