view

Overview ¶

Package view is a thin, ergonomic layer over the standard library's html/template, modelled on Laravel's Blade view layer.

It loads templates from any fs.FS — an embed.FS for a single-binary deploy, or an on-disk directory with hot-reload during development — and adds the conveniences a real app needs on top of html/template:

• Named views resolved by path (e.g. "pages/home").
• Layouts: a view declares its layout and its body is injected into the layout's {{block "content"}} placeholder.
• Partials / includes and reusable components via {{template ...}}.
• A batteries-included FuncMap (dict, default, date/string/number helpers) plus injectable route/asset/url helpers so this package never imports the web layer — it stays a leaf.
• Auto-escaping is inherited from html/template (contextual, on by default).
• Per-render data merged over shared globals.

The package is deliberately a leaf: Engine.Render writes rendered bytes to any io.Writer the caller passes (an http.ResponseWriter, a bytes.Buffer for mail, etc.). It does not import the web package, so the web layer depends on view and not the other way around.

Layouts ¶

A layout is an ordinary template that yields to its child via a block:

{{/* layouts/app.html */}}
<html><body><main>{{block "content" .}}{{end}}</main></body></html>

A view redefines that block and declares which layout wraps it through the {{layout "name"}} directive on its first line:

{{layout "layouts/app"}}
{{define "content"}}<h1>Hello {{.Name}}</h1>{{end}}

Render then executes the layout with the view's "content" definition in scope. A view without a {{layout}} directive is rendered standalone.

Partials and components ¶

Any loaded template is addressable by name, so partials and components are just {{template "name" .}}; pass several values into a component with dict:

{{template "partials/nav" .}}
{{template "components/button" (dict "label" "Save" "kind" "primary")}}

Usage ¶

//go:embed templates
var tplFS embed.FS

eng, err := view.New(tplFS, view.Options{Root: "templates"})
// ...
eng.Render(w, "pages/home", map[string]any{"Name": "Ada"})

Rendering mail ¶

Because Render targets any io.Writer, the mail package can render an HTML body without view importing mail:

var buf bytes.Buffer
eng.Render(&buf, "emails/welcome", data)
msg := mail.NewMessage().To(addr).HTML(buf.String()).Build()

package main

import (
	"bytes"
	"fmt"
	"html/template"
	"testing/fstest"

	"github.com/devituz/lagodev/view"
)

func main() {
	files := fstest.MapFS{
		// Layout: yields to the child view through {{block "content"}}.
		"templates/layouts/app.html": &fstest.MapFile{Data: []byte(
			`<html><body><main>{{block "content" .}}{{end}}</main></body></html>`,
		)},
		// Reusable component, addressed by name and fed values via dict.
		"templates/components/button.html": &fstest.MapFile{Data: []byte(
			`<button class="{{.kind}}">{{.label}}</button>`,
		)},
		// Page: declares its layout, redefines "content", calls the component
		// and the custom "badge" func.
		"templates/pages/home.html": &fstest.MapFile{Data: []byte(
			`{{layout "layouts/app"}}` +
				`{{define "content"}}` +
				`<h1>{{upper .Name}}</h1>` +
				`{{badge .Role}}` +
				`{{template "components/button" (dict "label" "Save" "kind" "primary")}}` +
				`{{end}}`,
		)},
	}

	eng, err := view.New(files, view.Options{
		Root: "templates",
		Funcs: template.FuncMap{
			// Custom func: renders a small role badge (trusted markup).
			"badge": func(role string) template.HTML {
				return template.HTML(`<span class="badge">` + role + `</span>`)
			},
		},
	})
	if err != nil {
		panic(err)
	}

	var buf bytes.Buffer
	if err := eng.Render(&buf, "pages/home", map[string]any{
		"Name": "ada",
		"Role": "admin",
	}); err != nil {
		panic(err)
	}

	fmt.Println(buf.String())
}

Output:
<html><body><main><h1>ADA</h1><span class="badge">admin</span><button class="primary">Save</button></main></body></html>