web/css: add css preprocessorweb/css/v0.1.0

3 files changed, 286 insertions, 0 deletions

diff --git a/web/css/css_processor.go b/web/css/css_processor.go
new file mode 100644
index 0000000..b2ebf44
--- /dev/null
+++ b/web/css/css_processor.go
@@ -0,0 +1,275 @@
+package web
+
+import (
+        "encoding/base64"
+        "fmt"
+        "io"
+        "io/fs"
+        "net/url"
+        "path/filepath"
+        "strings"
+
+        "github.com/aymerick/douceur/css"
+        "github.com/aymerick/douceur/parser"
+)
+
+// Consider https://github.com/tdewolff/minify
+
+func relativeRead(f fs.FS, path string) ([]byte, error) {
+        return fs.ReadFile(f, filepath.Join("./", filepath.Clean(path)))
+}
+
+func ParseWriteSheet(fsys fs.FS, f string, o io.Writer) error {
+        fc, err := relativeRead(fsys, f)
+        if err != nil {
+                return err
+        }
+
+        stylesheet, err := parser.Parse(string(fc))
+        if err != nil {
+                return err
+        }
+
+        for _, rule := range stylesheet.Rules {
+                if err := StringRule(fsys, o, rule); err != nil {
+                        return err
+                }
+        }
+
+        return nil
+}
+
+func StringRule(fsys fs.FS, out io.Writer, rule *css.Rule) error {
+        switch rule.Kind {
+        case css.QualifiedRule:
+                // Eliminate empty rule blocks
+                if len(rule.Declarations) == 0 && len(rule.Rules) == 0 {
+                        return nil
+                }
+
+                out.Write([]byte(strings.Join(rule.Selectors, ",")))
+        case css.AtRule:
+                switch rule.Name {
+                case "@import":
+                        path := rule.Prelude[len("url('") : len(rule.Prelude)-len("')")]
+                        return ParseWriteSheet(fsys, path, out)
+                case "@font-face":
+                        for _, decl := range rule.Declarations {
+                                if decl.Property == "src" {
+                                        if err := EmbedFont(fsys, decl); err != nil {
+                                                return err
+                                        }
+                                }
+                        }
+                }
+                out.Write([]byte(rule.Name))
+                out.Write([]byte(rule.Prelude))
+        default:
+                return fmt.Errorf("Unknown rule type")
+        }
+
+        if len(rule.Declarations) == 0 && len(rule.Rules) == 0 {
+                out.Write([]byte(";"))
+        } else {
+                out.Write([]byte("{"))
+
+                if rule.EmbedsRules() {
+                        for _, subRule := range rule.Rules {
+                                if err := StringRule(fsys, out, subRule); err != nil {
+                                        return err
+                                }
+                        }
+                } else {
+                        for _, decl := range rule.Declarations {
+                                if strings.Contains(decl.Value, "__csspre_embed=true") {
+                                        if err := EmbedDeclaration(fsys, decl); err != nil {
+                                                return err
+                                        }
+                                }
+
+                                fmt.Fprintf(out, "%s:%s", decl.Property, strings.ReplaceAll(decl.Value, "\n", ""))
+                                if decl.Important {
+                                        out.Write([]byte(" !important"))
+                                }
+                                out.Write([]byte(";"))
+                        }
+                }
+                out.Write([]byte("}"))
+        }
+        return nil
+}
+
+type TokenType int
+
+const (
+        QuotedString TokenType = iota
+        FunctionStart
+        Comma
+        Semicolon
+)
+
+type Token struct {
+        Type  TokenType
+        Value string
+}
+
+// Tokenize will tokenize a @font-face src string that contains one or
+// more comma separated values containing url and format functions (the
+// values of these functions must be quoted). It returns a slice of
+// tokens
+func Tokenize(v string) []Token {
+        out := []Token{}
+        buf := make([]byte, 0, 1024)
+        inStr := false
+
+        for i := 0; i < len(v); i++ {
+                switch c := v[i]; c {
+                case ' ', '\t', '\n':
+                        if inStr {
+                                buf = append(buf, c)
+                        }
+                        continue
+                case '"', '\'':
+                        if len(buf) != 0 {
+                                out = append(out, Token{QuotedString, string(buf)})
+                                inStr = false
+                                buf = buf[:0]
+                        } else {
+                                inStr = true
+                        }
+                case '(':
+                        out = append(out, Token{FunctionStart, string(buf)})
+                        buf = buf[:0]
+                case ')':
+                        continue
+                case ',':
+                        out = append(out, Token{Type: Comma})
+                        buf = buf[:0]
+                default:
+                        buf = append(buf, c)
+                }
+        }
+
+        // Semicolons get stripped out before the token stream gets to
+        // this point but add one anyhow to make life easier on downstream
+        // consumers.
+        out = append(out, Token{Type: Semicolon})
+
+        return out
+}
+
+// ParseFontSrc takes a list of Token tokens and parses them into
+// a map indexed by the font format.
+func ParseFontSrc(tokens []Token) (map[string]string, error) {
+        out := map[string]string{}
+
+        url, format, state := "", "", ""
+
+        for _, t := range tokens {
+                switch t.Type {
+                case FunctionStart:
+                        state = t.Value
+                case QuotedString:
+                        switch state {
+                        case "url":
+                                url = t.Value
+                        case "format":
+                                format = t.Value
+                        default:
+                                return nil, fmt.Errorf("Invalid state: %s", state)
+                        }
+                        state = ""
+                case Comma, Semicolon:
+                        if url == "" {
+                                return nil, fmt.Errorf("Invalid comma, no url specified")
+                        }
+                        if format == "" {
+                                return nil, fmt.Errorf("Invalid comma, no format specified")
+                        }
+                        if _, ok := out[format]; ok {
+                                return nil, fmt.Errorf("Font format %s already specified", format)
+                        }
+                        out[format] = url
+                        url, format, state = "", "", ""
+                }
+        }
+
+        return out, nil
+}
+
+// EmbedFont parses a @font-face src and embeds the woff font
+// variant, preserving links to the other variants. It will always make
+// the woff embed the first item in the list of fonts so that browsers
+// that pick the first match will use that one.
+func EmbedFont(fsys fs.FS, decl *css.Declaration) error {
+        font, err := ParseFontSrc(Tokenize(decl.Value))
+        if err != nil {
+                return err
+        }
+
+        i := 0
+        out := make([]string, len(font))
+
+        if woff, ok := font["woff"]; ok && !strings.HasPrefix(woff, "data:") {
+                if fc, err := relativeRead(fsys, woff); err != nil {
+                        return err
+                } else {
+                        enc := base64.StdEncoding.EncodeToString(fc)
+                        out[i] = fmt.Sprintf("url('data:application/octet-stream;base64,%s') format('woff')", enc)
+                        i++
+                        delete(font, "woff")
+                }
+        }
+
+        for format, value := range font {
+                out[i] = fmt.Sprintf("url('%s') format('%s')", value, format)
+                i++
+        }
+
+        decl.Value = strings.Join(out, ",")
+        return nil
+}
+
+func EmbedDeclaration(fsys fs.FS, decl *css.Declaration) error {
+        toks := Tokenize(decl.Value)
+
+        if len(toks) < 2 || (toks[0].Type != FunctionStart && toks[0].Value != "url") {
+                return fmt.Errorf("Error embedding url: Invalid argument, not a URL")
+        }
+
+        u, err := url.Parse(toks[1].Value)
+        if err != nil {
+                return err
+        }
+
+        if u.Scheme != "" || u.Host != "" {
+                return fmt.Errorf("Error embedding url: can only embed local files")
+        }
+
+        // This shouldn't ever happen if we made it this far
+        if u.Query().Get("__csspre_embed") != "true" {
+                return fmt.Errorf("Error embedding url: URL is not flagged for embedding")
+        }
+
+        fc, err := relativeRead(fsys, u.Path)
+        if err != nil {
+                return fmt.Errorf("Error embedding url: %w", err)
+        }
+
+        ft := filepath.Ext(u.Path)
+        img, ok := map[string]string{
+                ".svg":  "image/svg+xml",
+                ".jpg":  "image/jpeg",
+                ".jpeg": "image/jpeg",
+                ".png":  "image/png",
+                ".gif":  "image/gif",
+        }[ft]
+
+        if !ok {
+                return fmt.Errorf("Error embedding url: unknown file type %s", ft)
+        }
+
+        decl.Value = fmt.Sprintf("url(\"data:%s;base64,%s\")", img, base64.StdEncoding.EncodeToString(fc))
+
+        return nil
+}
diff --git a/web/css/go.mod b/web/css/go.mod
new file mode 100644
index 0000000..3a36d58
--- /dev/null
+++ b/web/css/go.mod
@@ -0,0 +1,7 @@
+module code.crute.us/mcrute/golib/web/css
+
+go 1.21.3
+
+require github.com/aymerick/douceur v0.2.0
+
+require github.com/gorilla/css v1.0.1 // indirect
diff --git a/web/css/go.sum b/web/css/go.sum
new file mode 100644
index 0000000..f4df343
--- /dev/null
+++ b/web/css/go.sum
@@ -0,0 +1,4 @@
+github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
+github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
+github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
+github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=