gofront 1.8.0 → 1.9.0

package/stdlib/gom/gom.go

@@ -0,0 +1,293 @@
+//go:build gofront
+
+//gofront:target js
+
+// Package gom builds DOM trees from Go values. A Node mounts itself into a
+// parent element; templ components are Nodes too. It is only available to js
+// packages and needs no import.
+package gom
+
+// A Node adds itself to the DOM element parent. refs, when not nil, is the
+// map that `ref="key"` attributes of templ components fill with elements.
+type Node interface {
+	Mount(parent any, refs any)
+}
+
+// NodeFunc adapts a function that mounts into an element to a Node.
+type NodeFunc func(parent any)
+
+func (f NodeFunc) Mount(parent any, refs any) {
+	f(parent)
+}
+
+// Group mounts its nodes one after another into the same parent.
+type Group []Node
+
+func (g Group) Mount(parent any, refs any) {
+	for _, n := range g {
+		if n != nil {
+			n.Mount(parent, refs)
+		}
+	}
+}
+
+type element struct {
+	tag      string
+	children []Node
+}
+
+func (e *element) Mount(parent any, refs any) {
+	el := document.createElement(e.tag)
+	for _, c := range e.children {
+		if c != nil {
+			c.Mount(el, refs)
+		}
+	}
+	parent.appendChild(el)
+}
+
+type text struct{ s string }
+
+func (t *text) Mount(parent any, refs any) {
+	parent.appendChild(document.createTextNode(t.s))
+}
+
+type attr struct{ name, value string }
+
+func (a *attr) Mount(el any, refs any) {
+	el.setAttribute(a.name, a.value)
+}
+
+type prop struct{ name, value string }
+
+func (p *prop) Mount(el any, refs any) {
+	el[p.name] = p.value
+}
+
+type style struct{ css string }
+
+func (s *style) Mount(parent any, refs any) {
+	el := document.createElement("style")
+	el.textContent = s.css
+	parent.appendChild(el)
+}
+
+// El is an element with the given tag, attributes and children.
+func El(tag string, children ...Node) Node {
+	return &element{tag: tag, children: children}
+}
+
+// Text is a text node.
+func Text(s string) Node {
+	return &text{s: s}
+}
+
+// Attr sets an attribute.
+func Attr(name, value string) Node {
+	return &attr{name: name, value: value}
+}
+
+// DataAttr sets the attribute data-<key>.
+func DataAttr(key, value string) Node {
+	return &attr{name: "data-" + key, value: value}
+}
+
+// If is n when cond holds, and an empty node otherwise.
+func If(cond bool, n Node) Node {
+	if cond {
+		return n
+	}
+	return Group{}
+}
+
+// Map applies f to every element of s; the nodes mount in order.
+func Map[T any](s []T, f func(T) Node) Node {
+	g := make(Group, 0, len(s))
+	for _, v := range s {
+		g = append(g, f(v))
+	}
+	return g
+}
+
+// Style is a <style> element with the given CSS text.
+func Style(css string) Node {
+	return &style{css: css}
+}
+
+func refOf(refs []any) any {
+	if len(refs) > 0 {
+		return refs[0]
+	}
+	return nil
+}
+
+// Mount replaces the content of the element matching the selector with node.
+// The optional refs map receives the elements of templ `ref` attributes.
+func Mount(sel string, node Node, refs ...any) {
+	el := document.querySelector(sel)
+	el.innerHTML = ""
+	node.Mount(el, refOf(refs))
+}
+
+// MountTo is like Mount but keeps the existing content.
+func MountTo(sel string, node Node, refs ...any) {
+	node.Mount(document.querySelector(sel), refOf(refs))
+}
+
+// Elements.
+
+func Div(children ...Node) Node { return El("div", children...) }
+
+func Section(children ...Node) Node { return El("section", children...) }
+
+func Article(children ...Node) Node { return El("article", children...) }
+
+func Aside(children ...Node) Node { return El("aside", children...) }
+
+func Header(children ...Node) Node { return El("header", children...) }
+
+func Footer(children ...Node) Node { return El("footer", children...) }
+
+func Main(children ...Node) Node { return El("main", children...) }
+
+func Nav(children ...Node) Node { return El("nav", children...) }
+
+func Figure(children ...Node) Node { return El("figure", children...) }
+
+func H1(children ...Node) Node { return El("h1", children...) }
+
+func H2(children ...Node) Node { return El("h2", children...) }
+
+func H3(children ...Node) Node { return El("h3", children...) }
+
+func H4(children ...Node) Node { return El("h4", children...) }
+
+func H5(children ...Node) Node { return El("h5", children...) }
+
+func H6(children ...Node) Node { return El("h6", children...) }
+
+func Span(children ...Node) Node { return El("span", children...) }
+
+func A(children ...Node) Node { return El("a", children...) }
+
+func Strong(children ...Node) Node { return El("strong", children...) }
+
+func Em(children ...Node) Node { return El("em", children...) }
+
+func Code(children ...Node) Node { return El("code", children...) }
+
+func Pre(children ...Node) Node { return El("pre", children...) }
+
+func Small(children ...Node) Node { return El("small", children...) }
+
+func Mark(children ...Node) Node { return El("mark", children...) }
+
+func P(children ...Node) Node { return El("p", children...) }
+
+func Br(children ...Node) Node { return El("br", children...) }
+
+func Hr(children ...Node) Node { return El("hr", children...) }
+
+func Ul(children ...Node) Node { return El("ul", children...) }
+
+func Ol(children ...Node) Node { return El("ol", children...) }
+
+func Li(children ...Node) Node { return El("li", children...) }
+
+func Dl(children ...Node) Node { return El("dl", children...) }
+
+func Dt(children ...Node) Node { return El("dt", children...) }
+
+func Dd(children ...Node) Node { return El("dd", children...) }
+
+func Form(children ...Node) Node { return El("form", children...) }
+
+func Input(children ...Node) Node { return El("input", children...) }
+
+func Button(children ...Node) Node { return El("button", children...) }
+
+func Textarea(children ...Node) Node { return El("textarea", children...) }
+
+func Select(children ...Node) Node { return El("select", children...) }
+
+func Option(children ...Node) Node { return El("option", children...) }
+
+func Label(children ...Node) Node { return El("label", children...) }
+
+func Fieldset(children ...Node) Node { return El("fieldset", children...) }
+
+func Legend(children ...Node) Node { return El("legend", children...) }
+
+func Img(children ...Node) Node { return El("img", children...) }
+
+func Video(children ...Node) Node { return El("video", children...) }
+
+func Audio(children ...Node) Node { return El("audio", children...) }
+
+func Canvas(children ...Node) Node { return El("canvas", children...) }
+
+func Table(children ...Node) Node { return El("table", children...) }
+
+func Thead(children ...Node) Node { return El("thead", children...) }
+
+func Tbody(children ...Node) Node { return El("tbody", children...) }
+
+func Tfoot(children ...Node) Node { return El("tfoot", children...) }
+
+func Tr(children ...Node) Node { return El("tr", children...) }
+
+func Th(children ...Node) Node { return El("th", children...) }
+
+func Td(children ...Node) Node { return El("td", children...) }
+
+// Attributes.
+
+func For(v string) Node { return Attr("for", v) }
+
+func Name(v string) Node { return Attr("name", v) }
+
+func Value(v string) Node { return Attr("value", v) }
+
+func Target(v string) Node { return Attr("target", v) }
+
+func Rel(v string) Node { return Attr("rel", v) }
+
+func Alt(v string) Node { return Attr("alt", v) }
+
+func Title(v string) Node { return Attr("title", v) }
+
+func Lang(v string) Node { return Attr("lang", v) }
+
+func Action(v string) Node { return Attr("action", v) }
+
+func Method(v string) Node { return Attr("method", v) }
+
+func AutoComplete(v string) Node { return Attr("autocomplete", v) }
+
+func Draggable(v string) Node { return Attr("draggable", v) }
+
+func Role(v string) Node { return Attr("role", v) }
+
+func StyleAttr(v string) Node { return Attr("style", v) }
+
+func AriaLabel(v string) Node { return Attr("aria-label", v) }
+
+func Disabled() Node { return Attr("disabled", "") }
+
+func Checked() Node { return Attr("checked", "") }
+
+func Selected() Node { return Attr("selected", "") }
+
+func Readonly() Node { return Attr("readonly", "") }
+
+// Properties.
+
+func Class(v string) Node { return &prop{name: "className", value: v} }
+
+func Type(v string) Node { return &prop{name: "type", value: v} }
+
+func Href(v string) Node { return &prop{name: "href", value: v} }
+
+func Src(v string) Node { return &prop{name: "src", value: v} }
+
+func Placeholder(v string) Node { return &prop{name: "placeholder", value: v} }

package/stdlib/html/html.go

@@ -0,0 +1,251 @@
+//go:build gofront
+
+//gofront:target both
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package html provides functions for escaping and unescaping HTML text.
+//
+// UnescapeString follows Go's algorithm for numeric references (including the
+// Windows-1252 replacement table) and for named references without a
+// semicolon, but knows a subset of Go's 2,231 entity names: the five that
+// EscapeString produces and apos, the 96 HTML 4 Latin-1 names (nbsp through
+// yuml) and these others: euro, hellip, mdash, ndash, lsquo, rsquo, sbquo,
+// ldquo, rdquo, bdquo, bull, trade, larr, rarr, uarr, darr, harr, hearts,
+// spades, clubs and diams. An unknown name is left as it is.
+package html
+
+var replacementTable = [...]rune{
+	'\u20AC', // First entry is what 0x80 should be replaced with.
+	'\u0081',
+	'\u201A',
+	'\u0192',
+	'\u201E',
+	'\u2026',
+	'\u2020',
+	'\u2021',
+	'\u02C6',
+	'\u2030',
+	'\u0160',
+	'\u2039',
+	'\u0152',
+	'\u008D',
+	'\u017D',
+	'\u008F',
+	'\u0090',
+	'\u2018',
+	'\u2019',
+	'\u201C',
+	'\u201D',
+	'\u2022',
+	'\u2013',
+	'\u2014',
+	'\u02DC',
+	'\u2122',
+	'\u0161',
+	'\u203A',
+	'\u0153',
+	'\u009D',
+	'\u017E',
+	'\u0178', // Last entry is 0x9F.
+	// 0x00->'\uFFFD' is handled programmatically.
+	// 0x0D->'\u000D' is a no-op.
+}
+
+// latin1 holds the HTML 4 names of the runes U+00A0 through U+00FF, in order.
+var latin1 = [...]string{
+	"nbsp", "iexcl", "cent", "pound", "curren", "yen", "brvbar", "sect",
+	"uml", "copy", "ordf", "laquo", "not", "shy", "reg", "macr",
+	"deg", "plusmn", "sup2", "sup3", "acute", "micro", "para", "middot",
+	"cedil", "sup1", "ordm", "raquo", "frac14", "frac12", "frac34", "iquest",
+	"Agrave", "Aacute", "Acirc", "Atilde", "Auml", "Aring", "AElig", "Ccedil",
+	"Egrave", "Eacute", "Ecirc", "Euml", "Igrave", "Iacute", "Icirc", "Iuml",
+	"ETH", "Ntilde", "Ograve", "Oacute", "Ocirc", "Otilde", "Ouml", "times",
+	"Oslash", "Ugrave", "Uacute", "Ucirc", "Uuml", "Yacute", "THORN", "szlig",
+	"agrave", "aacute", "acirc", "atilde", "auml", "aring", "aelig", "ccedil",
+	"egrave", "eacute", "ecirc", "euml", "igrave", "iacute", "icirc", "iuml",
+	"eth", "ntilde", "ograve", "oacute", "ocirc", "otilde", "ouml", "divide",
+	"oslash", "ugrave", "uacute", "ucirc", "uuml", "yacute", "thorn", "yuml",
+}
+
+// longestEntityWithoutSemicolon is the length of the longest name that may
+// appear without its closing semicolon.
+const longestEntityWithoutSemicolon = 6
+
+// entities is the entity table: every name with its semicolon, and the
+// legacy names (the Latin-1 ones, amp, lt, gt and quot) without it too.
+var entities = makeEntities()
+
+func makeEntities() map[string]rune {
+	m := make(map[string]rune)
+	for i, name := range latin1 {
+		m[name+";"] = rune(0xA0 + i)
+		m[name] = rune(0xA0 + i)
+	}
+	for name, r := range map[string]rune{"amp": '&', "lt": '<', "gt": '>', "quot": '"'} {
+		m[name+";"] = r
+		m[name] = r
+	}
+	for name, r := range map[string]rune{
+		"apos": '\'', "euro": 0x20AC, "hellip": 0x2026, "mdash": 0x2014,
+		"ndash": 0x2013, "lsquo": 0x2018, "rsquo": 0x2019, "sbquo": 0x201A,
+		"ldquo": 0x201C, "rdquo": 0x201D, "bdquo": 0x201E, "bull": 0x2022,
+		"trade": 0x2122, "larr": 0x2190, "uarr": 0x2191, "rarr": 0x2192,
+		"darr": 0x2193, "harr": 0x2194, "spades": 0x2660, "clubs": 0x2663,
+		"hearts": 0x2665, "diams": 0x2666,
+	} {
+		m[name+";"] = r
+	}
+	return m
+}
+
+// unescapeEntity reads an entity like "&lt;" at the start of s (s[0] is '&')
+// and returns the text it stands for and how many code units it spans. A
+// reference it does not know stands for itself, one unit long.
+func unescapeEntity(s string) (text string, n int) {
+	if len(s) <= 1 {
+		return "&", 1
+	}
+	i := 1
+	if s[i] == '#' {
+		if len(s) <= 3 { // We need to have at least "&#.".
+			return "&", 1
+		}
+		i++
+		c := s[i]
+		hex := false
+		if c == 'x' || c == 'X' {
+			hex = true
+			i++
+		}
+
+		var x rune
+		for i < len(s) {
+			c = s[i]
+			i++
+			if hex {
+				if '0' <= c && c <= '9' {
+					x = 16*x + rune(c) - '0'
+					continue
+				} else if 'a' <= c && c <= 'f' {
+					x = 16*x + rune(c) - 'a' + 10
+					continue
+				} else if 'A' <= c && c <= 'F' {
+					x = 16*x + rune(c) - 'A' + 10
+					continue
+				}
+			} else if '0' <= c && c <= '9' {
+				x = 10*x + rune(c) - '0'
+				continue
+			}
+			if c != ';' {
+				i--
+			}
+			break
+		}
+
+		if i <= 3 { // No characters matched.
+			return "&", 1
+		}
+
+		if 0x80 <= x && x <= 0x9F {
+			// Replace characters from Windows-1252 with UTF-8 equivalents.
+			x = replacementTable[x-0x80]
+		} else if x == 0 || (0xD800 <= x && x <= 0xDFFF) || x < 0 || x > 0x10FFFF {
+			// Replace invalid characters with the replacement character.
+			x = '\uFFFD'
+		}
+		return string(x), i
+	}
+
+	// Consume the maximum number of characters possible, with the
+	// consumed characters matching one of the named references.
+	for i < len(s) {
+		c := s[i]
+		i++
+		if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9' {
+			continue
+		}
+		if c != ';' {
+			i--
+		}
+		break
+	}
+
+	entityName := s[1:i]
+	if len(entityName) == 0 {
+		return "&", 1
+	}
+	entity := entities
+	if x := entity[entityName]; x != 0 {
+		return string(x), i
+	}
+	maxLen := len(entityName) - 1
+	if maxLen > longestEntityWithoutSemicolon {
+		maxLen = longestEntityWithoutSemicolon
+	}
+	for j := maxLen; j > 1; j-- {
+		if x := entity[entityName[:j]]; x != 0 {
+			return string(x), j + 1
+		}
+	}
+	return s[:i], i
+}
+
+// EscapeString escapes special characters like "<" to become "&lt;". It
+// escapes only five such characters: <, >, &, ' and ".
+// [UnescapeString](EscapeString(s)) == s always holds, but the converse isn't
+// always true.
+func EscapeString(s string) string {
+	out := ""
+	last := 0
+	for i := 0; i < len(s); i++ {
+		var rep string
+		switch s[i] {
+		case '&':
+			rep = "&amp;"
+		case '\'':
+			rep = "&#39;" // "&#39;" is shorter than "&apos;" and apos was not in HTML until HTML5.
+		case '<':
+			rep = "&lt;"
+		case '>':
+			rep = "&gt;"
+		case '"':
+			rep = "&#34;" // "&#34;" is shorter than "&quot;".
+		default:
+			continue
+		}
+		out += s[last:i] + rep
+		last = i + 1
+	}
+	if last == 0 {
+		return s
+	}
+	return out + s[last:]
+}
+
+// UnescapeString unescapes entities like "&lt;" to become "<". It unescapes a
+// larger range of entities than [EscapeString] escapes. For example, "&aacute;"
+// unescapes to "á", as does "&#225;" and "&#xE1;".
+// UnescapeString([EscapeString](s)) == s always holds, but the converse isn't
+// always true.
+func UnescapeString(s string) string {
+	out := ""
+	last := 0
+	for i := 0; i < len(s); {
+		if s[i] != '&' {
+			i++
+			continue
+		}
+		text, n := unescapeEntity(s[i:])
+		out += s[last:i] + text
+		i += n
+		last = i
+	}
+	if last == 0 {
+		return s
+	}
+	return out + s[last:]
+}

package/stdlib/internal/fmtrt/fmtrt.go

@@ -0,0 +1,163 @@
+//go:build gofront
+
+//gofront:target both
+
+// Package fmtrt is the contract between package fmt and the code the
+// compiler generates for each package that formats values.
+//
+// Go's fmt learns the type of every operand by reflection. Here the compiler
+// knows it statically: it describes an operand as an Arg (a kind, the value
+// in a field of that kind, and closures that reach the parts of a composite)
+// and fmt only reads the description. An operand that arrives through an
+// interface is described by the lookups packages register with Register.
+package fmtrt
+
+// The kinds of an Arg.
+const (
+	KNone       = iota // not described: format the value in V
+	KBool              // B
+	KInt               // I, any signed integer type
+	KUint              // U, any unsigned integer type
+	KFloat             // R, any float type
+	KComplex           // R and Im, any complex type
+	KString            // S
+	KStruct            // N fields, Field
+	KPtr               // Nil, Ptr, Inner
+	KSlice             // Nil, N elements, Elem
+	KArray             // N elements, Elem
+	KMap               // Nil, N entries, Entries
+	KFunc              // Nil, Ptr
+	KInterface         // V holds the operand, formatted by its dynamic type
+	KChan              // Nil, Ptr
+	KUnsafePtr         // Nil, Ptr
+)
+
+// Stringer, GoStringer and Error-only views of a value, kept apart from
+// package fmt so that the generated code needs only this package.
+type Stringer interface {
+	String() string
+}
+
+type GoStringer interface {
+	GoString() string
+}
+
+// Arg describes one operand.
+type Arg struct {
+	K    int    // the kind, one of the K constants
+	Size int    // the bit size of a number (8, 16, 32, 64 or 0 for int, uint and uintptr)
+	T    string // the Go type, as %T prints it
+	B    bool
+	I    int64
+	U    uint64
+	R    float64
+	Im   float64
+	S    string
+	V    any // the operand itself, when K is KNone or KInterface
+
+	// The methods of the static type that fmt calls. They are set only
+	// where Go would call them: the type's method set holds the method and,
+	// for a struct field, the field is exported.
+	Err   error
+	Str   Stringer
+	GoStr GoStringer
+
+	Nil     bool
+	N       int
+	Ptr     any
+	Boxed   bool // Ptr is a pointer to a scalar, boxed anew each time it is put in an Arg
+	IsBytes bool                      // a []byte or [N]byte, whose elements are in Bytes
+	Bytes   []byte
+	Field   func(i int) (string, Arg) // the name and value of field i
+	Elem    func(i int) Arg           // element i
+	Entries func() []Entry            // the entries of a map
+	Inner   func() Arg                // what a non-nil pointer points to
+}
+
+// Entry is one key and value of a map.
+type Entry struct {
+	Key Arg
+	Val Arg
+}
+
+type registry struct {
+	keys    []string
+	lookups []func(v any) (Arg, bool)
+	scalars []numbered
+}
+
+// numbered is a pointer to a scalar that has been given an id; same reports
+// whether a value is that pointer.
+type numbered struct {
+	same func(v any) bool
+	id   uint64
+}
+
+var reg = &registry{}
+
+func (r *registry) add(key string, f func(v any) (Arg, bool)) {
+	for _, k := range r.keys {
+		if k == key {
+			return
+		}
+	}
+	r.keys = append(r.keys, key)
+	r.lookups = append(r.lookups, f)
+}
+
+// Register adds a package's lookup, which describes the values of that
+// package's types held in an interface. A key registers once, so a call may
+// be repeated: it identifies the lookup, and it returns true so that it can
+// initialise a package-level variable.
+func Register(key string, f func(v any) (Arg, bool)) bool {
+	reg.add(key, f)
+	return true
+}
+
+// Lookup describes a value held in an interface by asking each registered
+// lookup in turn.
+func Lookup(v any) (Arg, bool) {
+	for _, f := range reg.lookups {
+		if a, ok := f(v); ok {
+			return a, true
+		}
+	}
+	return Arg{}, false
+}
+
+// PtrID returns a number that identifies the pointer, function or other
+// reference v; 0 for nil.
+func PtrID(v any) uint64 {
+	if v == nil {
+		return 0
+	}
+	return ptrID(v)
+}
+
+// ArgPtrID returns the identity number of the pointer, function or channel
+// that a holds. A pointer to a scalar is boxed anew each time it is put in an
+// Arg and the host would see a different object, so those are matched by
+// equality against the ones already numbered.
+func ArgPtrID(a Arg) uint64 {
+	if !a.Boxed {
+		return PtrID(a.Ptr)
+	}
+	p := a.Ptr
+	for _, n := range reg.scalars {
+		if n.same(p) {
+			return n.id
+		}
+	}
+	id := PtrID(p)
+	reg.remember(p, id)
+	return id
+}
+
+func (r *registry) remember(p any, id uint64) {
+	r.scalars = append(r.scalars, numbered{func(v any) bool { return v == p }, id})
+}
+
+// ptrID is the host's stable identity number for an object.
+//
+//gofront:intrinsic fmt_ptr_id
+func ptrID(v any) uint64