// Package render ports HTML shell rendering from the Rust web plugin.
package render
import (
"fmt"
"strings"
"github.com/marqdo/marqdo/plugins/web/internal/assets"
"github.com/marqdo/marqdo/plugins/web/internal/db"
"github.com/marqdo/marqdo/plugins/web/internal/form"
"github.com/marqdo/marqdo/plugins/web/internal/table"
)
func esc(s string) string {
r := strings.NewReplacer(
"&", "&",
"<", "<",
">", ">",
`"`, """,
)
return r.Replace(s)
}
func text(v any) string {
switch t := v.(type) {
case nil:
return ""
case string:
return t
case bool:
if t {
return "true"
}
return "false"
case float64:
if t == float64(int64(t)) {
return fmt.Sprintf("%d", int64(t))
}
return fmt.Sprint(t)
default:
return fmt.Sprint(t)
}
}
func classAttr(css string) string {
if css == "" {
return ""
}
return fmt.Sprintf(` class="%s"`, esc(css))
}
func isSimpleIdent(s string) bool {
if s == "" {
return false
}
for _, c := range s {
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' {
continue
}
if c > 127 {
continue
}
return false
}
return true
}
func isDBBindBack(back string) bool {
s := table.NormalizeRef(back)
if s == "" || strings.Contains(s, "://") || strings.HasPrefix(s, "/") ||
strings.HasPrefix(s, "#") || strings.HasPrefix(s, "?") {
return false
}
sp := table.ParseSitePath(s)
switch sp.Kind {
case table.SitePathDbField:
return true
case table.SitePathLibMember:
return isSimpleIdent(sp.Lib) && isSimpleIdent(sp.Member)
case table.SitePathPlain:
parts := strings.Split(sp.Plain, ".")
n := 0
for _, p := range parts {
if p != "" {
n++
if !isSimpleIdent(p) {
return false
}
}
}
return n == 2
}
return false
}
type navLink struct {
label string
href string
class string
media string
}
type navWhen int
const (
navAlways navWhen = iota
navHide
navAuth
navGuest
)
func parseNavWhen(raw string) navWhen {
t := strings.TrimSpace(raw)
switch t {
case "", "*", "always", "Always", "真", "yes", "on", "show", "all":
return navAlways
case "hide", "never", "off", "no", "假", "否", "0", "false", "False":
return navHide
case "auth", "user", "登录", "已登录", "logged_in", "logged-in":
return navAuth
case "guest", "anon", "anonymous", "访客", "匿名", "未登录":
return navGuest
default:
return navAlways
}
}
func pageAuthState(page map[string]any) *bool {
if page == nil {
return nil
}
for _, k := range []string{"_nav_user", "user", "username", "_user"} {
if v, ok := page[k]; ok {
b := false
switch t := v.(type) {
case nil:
b = false
case bool:
b = t
case string:
b = strings.TrimSpace(t) != ""
case float64:
b = int64(t) != 0
default:
b = true
}
return &b
}
}
for _, k := range []string{"_logged_in", "logged_in"} {
if v, ok := page[k]; ok {
switch t := v.(type) {
case bool:
return &t
case string:
b := false
switch strings.TrimSpace(t) {
case "1", "true", "True", "yes", "on", "真", "是":
b = true
}
return &b
case float64:
b := int64(t) != 0
return &b
}
}
}
return nil
}
func navWhenVisible(when navWhen, auth *bool) bool {
switch when {
case navAlways:
return true
case navHide:
return false
case navAuth:
if auth == nil {
return true
}
return *auth
case navGuest:
if auth == nil {
return true
}
return !*auth
}
return true
}
func selectPageData(url, tableName string, page map[string]any, limit, offset int64) map[string]any {
var where any
if q, ok := page["query"]; ok {
// Expand `{param}` placeholders from dynamic route params (ABI: 查询条件).
where = resolvePlaceholders(q, pageParams(page))
}
order, _ := page["order"].(string)
opts := db.SelectOpts{Where: where, Order: order}
if _, ok := page["paginate"]; ok || offset > 0 {
opts.Offset = &offset
}
out, err := db.Select(url, tableName, limit, opts)
if err != nil {
return map[string]any{"rows": []any{}}
}
return out
}
func pageParams(page map[string]any) map[string]any {
if page == nil {
return nil
}
p, _ := page["params"].(map[string]any)
return p
}
// resolvePlaceholders walks query / route values and replaces `{name}` with
// page.params[name]. Unmatched placeholders are left as `{name}` for debugging.
func resolvePlaceholders(v any, params map[string]any) any {
if len(params) == 0 {
return v
}
switch t := v.(type) {
case string:
return resolveParamsString(t, params)
case map[string]any:
out := make(map[string]any, len(t))
for k, val := range t {
out[k] = resolvePlaceholders(val, params)
}
return out
case []any:
out := make([]any, len(t))
for i, val := range t {
out[i] = resolvePlaceholders(val, params)
}
return out
default:
return v
}
}
// ResolveRouteParams substitutes `{name}` in a route pattern using params.
func ResolveRouteParams(pattern string, params map[string]any) string {
return resolveParamsString(pattern, params)
}
func resolveParamsString(s string, params map[string]any) string {
if !strings.Contains(s, "{") || len(params) == 0 {
return s
}
var out strings.Builder
rest := s
for {
start := strings.Index(rest, "{")
if start < 0 {
out.WriteString(rest)
break
}
out.WriteString(rest[:start])
rest = rest[start+1:]
end := strings.Index(rest, "}")
if end < 0 {
out.WriteByte('{')
out.WriteString(rest)
break
}
key := rest[:end]
if val, ok := params[key]; ok {
out.WriteString(text(val))
} else {
out.WriteByte('{')
out.WriteString(key)
out.WriteByte('}')
}
rest = rest[end+1:]
}
return out.String()
}
func resolveLinks(raw any, dbURL string, page map[string]any) []navLink {
if raw == nil {
return nil
}
auth := pageAuthState(page)
bindsAny := table.AsBind(raw)
arr, _ := bindsAny.([]any)
var rows []map[string]any
if len(arr) > 0 {
hasDB := false
for _, b := range arr {
m, _ := b.(map[string]any)
back, _ := m["back"].(string)
if isDBBindBack(back) {
hasDB = true
break
}
}
if hasDB {
if dbURL == "" {
return nil
}
tn, ok := table.BindTableName(arr)
if !ok {
return nil
}
data := selectPageData(dbURL, tn, map[string]any{}, 200, 0)
rawRows, _ := data["rows"].([]any)
projected := table.ProjectRows(arr, rawRows)
parr, _ := projected.([]any)
for _, it := range parr {
if m, ok := it.(map[string]any); ok {
rows = append(rows, m)
}
}
} else {
for _, b := range arr {
if m, ok := b.(map[string]any); ok {
rows = append(rows, m)
}
}
}
} else {
rows = table.AsNavRows(raw)
}
var out []navLink
for _, m := range rows {
label, href := table.NavLabelHref(m)
if label == "" {
continue
}
media, whenRaw, class := table.NavMediaWhenClass(m)
if whenRaw == "" {
if v, ok := m["when"]; ok {
whenRaw = text(v)
} else if v, ok := m["当"]; ok {
whenRaw = text(v)
}
}
if media == "" {
if v, ok := m["media"]; ok {
media = text(v)
} else if v, ok := m["媒体"]; ok {
media = text(v)
}
}
when := parseNavWhen(whenRaw)
if !navWhenVisible(when, auth) {
continue
}
out = append(out, navLink{label: label, href: href, class: class, media: media})
}
return out
}
func navMediaClassMapMany(groups ...[]navLink) (string, [][2]string) {
var pairs [][2]string
var css strings.Builder
for _, links := range groups {
for _, link := range links {
media := strings.TrimSpace(link.media)
if media == "" {
continue
}
dup := false
for _, p := range pairs {
if p[0] == media {
dup = true
break
}
}
if dup {
continue
}
class := fmt.Sprintf("nav-mq-%d", len(pairs))
css.WriteString(fmt.Sprintf(
"@media not %s { li.%s { display:none !important; } }\n",
media, class,
))
pairs = append(pairs, [2]string{media, class})
}
}
return css.String(), pairs
}
func renderULWithMQ(links []navLink, class string, mqPairs [][2]string) string {
var s strings.Builder
s.WriteString(fmt.Sprintf(`
`, esc(class)))
for _, link := range links {
mq := strings.TrimSpace(link.media)
mqClass := ""
if mq != "" {
for _, p := range mqPairs {
if p[0] == mq {
mqClass = p[1]
break
}
}
}
liClass := link.class
if mqClass != "" {
if liClass != "" {
liClass += " "
}
liClass += mqClass
}
if liClass == "" {
s.WriteString(fmt.Sprintf(`
")
return s.String()
}
func resolveMain(page map[string]any, dbURL string) (intro string, items []map[string]any, total *int64) {
intro, _ = page["intro"].(string)
main, ok := page["main"]
if !ok {
return intro, nil, nil
}
bindsAny := table.AsBind(main)
arr, _ := bindsAny.([]any)
if len(arr) == 0 {
return intro, nil, nil
}
if dbURL == "" {
return intro, nil, nil
}
tn, ok := table.BindTableName(arr)
if !ok {
return intro, nil, nil
}
limit := int64(200)
offset := int64(0)
if p, ok := page["paginate"].(map[string]any); ok {
if v, ok := p["limit"].(float64); ok {
limit = int64(v)
}
if v, ok := p["offset"].(float64); ok {
offset = int64(v)
}
}
data := selectPageData(dbURL, tn, page, limit, offset)
if t, ok := data["total"].(float64); ok {
ti := int64(t)
total = &ti
}
rawRows, _ := data["rows"].([]any)
projected := table.ProjectRows(arr, rawRows)
parr, _ := projected.([]any)
for _, v := range parr {
if m, ok := v.(map[string]any); ok {
items = append(items, m)
}
}
return intro, items, total
}
// listBind is one secondary page list (compose_list / 列表装配).
type listBind struct {
Items []map[string]any
Target string
HTML string
}
func resolveLists(page map[string]any, dbURL string) []listBind {
raw, ok := page["lists"].([]any)
if !ok || len(raw) == 0 || dbURL == "" {
return nil
}
var out []listBind
for _, entry := range raw {
em, ok := entry.(map[string]any)
if !ok {
continue
}
bindsAny := table.AsBind(em["main"])
arr, _ := bindsAny.([]any)
if len(arr) == 0 {
continue
}
tn, ok := table.BindTableName(arr)
if !ok {
continue
}
sub := map[string]any{"params": pageParams(page)}
if q, ok := em["query"]; ok {
sub["query"] = q
}
if o, ok := em["order"].(string); ok {
sub["order"] = o
}
data := selectPageData(dbURL, tn, sub, 200, 0)
rawRows, _ := data["rows"].([]any)
projected := table.ProjectRows(arr, rawRows)
parr, _ := projected.([]any)
var items []map[string]any
for _, v := range parr {
if m, ok := v.(map[string]any); ok {
items = append(items, m)
}
}
lb := listBind{Items: items}
if t, ok := em["target"].(string); ok {
lb.Target = t
}
lb.HTML = renderListSection(page, items)
out = append(out, lb)
}
return out
}
func renderListSection(page map[string]any, items []map[string]any) string {
var s strings.Builder
s.WriteString(`
`)
if len(items) == 0 {
s.WriteString(`
还没有条目。
`)
} else {
s.WriteString(`
`)
for _, it := range items {
s.WriteString(renderListItem(page, it))
}
s.WriteString(`
`)
}
s.WriteString(`
`)
return s.String()
}
func renderListItem(page map[string]any, it map[string]any) string {
title := text(it["title"])
body := text(it["body"])
meta := text(it["meta"])
href := text(it["href"])
if href != "" {
return `
` + renderCard(page, it) + `
`
}
var s strings.Builder
s.WriteString(`
`)
s.WriteString(`
`)
if title != "" {
s.WriteString(fmt.Sprintf(`%s`, esc(title)))
}
if meta != "" {
s.WriteString(fmt.Sprintf(``, esc(meta)))
}
s.WriteString(`
`)
if body != "" {
escaped := esc(body)
escaped = strings.ReplaceAll(escaped, "\n", " ")
s.WriteString(fmt.Sprintf(`
%s
`, escaped))
}
s.WriteString(`
`)
return s.String()
}
func applyListTargets(intro string, lists []listBind) (string, string) {
rest := strings.Builder{}
for _, lb := range lists {
if lb.HTML == "" {
continue
}
if lb.Target != "" && intro != "" {
if injected, ok := injectHTMLIntoID(intro, lb.Target, lb.HTML); ok {
intro = injected
continue
}
}
rest.WriteString(lb.HTML)
}
return intro, rest.String()
}
func fieldCSS(obj map[string]any, field string) string {
css, _ := obj["_css"].(map[string]any)
if css == nil {
return ""
}
s, _ := css[field].(string)
return s
}
func partSrcPrefix(page map[string]any) string {
r, _ := page["_route"].(string)
r = resolveParamsString(r, pageParams(page))
if r == "" || r == "/" {
return ""
}
for len(r) > 1 && strings.HasSuffix(r, "/") {
r = r[:len(r)-1]
}
if strings.HasPrefix(r, "/") {
return r
}
return "/" + r
}
func slotAttrs(slot string, parts map[string]any, page map[string]any) string {
prefix := partSrcPrefix(page)
a := fmt.Sprintf(` data-slot="%s"`, esc(slot))
for id, cfg := range parts {
cm, ok := cfg.(map[string]any)
if !ok {
continue
}
s, _ := cm["slot"].(string)
if s == "" {
s, _ = cm["fragment"].(string)
}
if s == slot || (slot == "sidebar" && id == "side") || (slot == "main" && id == "index") {
a += fmt.Sprintf(` data-slot-src="%s/_part/%s"`, esc(prefix), esc(id))
break
}
}
return a
}
func slotClass(page map[string]any, slot, base string) string {
extra := ""
if sc, ok := page["slot_class"].(map[string]any); ok {
extra, _ = sc[slot].(string)
}
if extra == "" {
return base
}
return base + " " + extra
}
const shellVars = `
:root { --ink:#1c1917; --muted:#57534e; --paper:#fafaf9; --line:#e7e5e4; --accent:#0f766e; }
body { margin:0; font-family: "IBM Plex Sans", "Noto Sans SC", sans-serif; background:var(--paper); color:var(--ink); }
a { color:var(--ink); text-decoration:none; }
a:hover { color:var(--accent); }
`
const shellLayout = `
body { display:grid; min-height:100vh; grid-template-rows:auto 1fr auto; }
body.has-sidebar { grid-template-columns:14rem 1fr; grid-template-areas:"top top" "side main" "foot foot"; }
body.no-sidebar { grid-template-areas:"top" "main" "foot"; }
@media (max-width:720px) {
body.has-sidebar { grid-template-columns:1fr; grid-template-areas:"top" "main" "foot" "side"; }
body.has-sidebar aside.side { border-right:0; border-top:1px solid var(--line); }
}
body.layout-stacked { display:flex; flex-direction:column; min-height:100vh; }
body.layout-stacked header.topnav, body.layout-stacked aside.side, body.layout-stacked main.main, body.layout-stacked footer.foot { width:100%; }
body.layout-stacked aside.side { border-right:0; border-bottom:1px solid var(--line); }
body.layout-bare { display:block; min-height:100vh; }
body.layout-bare main.main { padding:1.5rem 1.25rem 2rem; }
header.topnav { grid-area:top; border-bottom:1px solid var(--line); padding:.85rem 1.25rem; background:#fff; }
aside.side { grid-area:side; border-right:1px solid var(--line); padding:1.25rem 1rem; background:#f5f5f4; }
main.main { grid-area:main; padding:1.5rem 1.25rem 2rem; }
footer.foot { grid-area:foot; border-top:1px solid var(--line); padding:.85rem 1.25rem; color:var(--muted); background:#fff; }
ul.nav, ul.side-nav, ul.foot-nav { list-style:none; margin:0; padding:0; display:flex; flex-wrap:wrap; gap:.35rem 1rem; }
ul.side-nav { flex-direction:column; }
`
const shellWidgets = `
.content.cards { display:grid; gap:1rem; margin-top:1.25rem; grid-template-columns:repeat(auto-fill,minmax(16rem,1fr)); }
.content.cards article { background:#fff; border:1px solid var(--line); border-radius:6px; padding:1rem; }
.main-intro h1 { margin:0 0 .75rem; font-size:2rem; }
.main-intro p { color:var(--muted); }
.site-form { margin-top:1.25rem; max-width:28rem; }
.article { background:#fff; border:1px solid var(--line); border-radius:8px; padding:2rem; margin-top:1.5rem; }
.article-title { margin:0 0 .75rem; font-size:2rem; }
.article-body { line-height:1.75; color:var(--ink); }
.article-body.md { line-height: 1.75; }
.article-body.md pre { background:#f5f5f4; border:1px solid var(--line); border-radius:6px; padding:1rem; overflow-x:auto; }
.article-body.md code { font-size:.9em; }
.pagination { display:flex; gap:1rem; align-items:center; margin:1.5rem 0; font-size:.95rem; }
`
func shellCSSFor(mode string) string {
switch strings.ToLower(strings.TrimSpace(mode)) {
case "off", "none", "false", "0":
return ""
case "minimal", "min", "vars":
return shellVars
default:
return shellVars + shellLayout + shellWidgets
}
}
func resolveShellCSS(page map[string]any) string {
raw := "full"
if s, ok := page["shell_css"].(string); ok {
raw = s
} else if s, ok := page["壳样式"].(string); ok {
raw = s
}
return shellCSSFor(raw)
}
func normalizeLayout(raw string) string {
switch strings.ToLower(strings.TrimSpace(raw)) {
case "", "auto", "default":
return ""
case "sidebar", "side":
return "sidebar"
case "stacked", "stack", "column":
return "stacked"
case "bare", "main", "none":
return "bare"
case "rail":
return "rail"
default:
return raw
}
}
func resolveLayout(page map[string]any) string {
raw := ""
if s, ok := page["layout"].(string); ok {
raw = s
} else if s, ok := page["布局"].(string); ok {
raw = s
}
return normalizeLayout(raw)
}
func headHTML(page map[string]any, defaultTitle string) string {
pageTitle := defaultTitle
if meta, ok := page["meta"].(map[string]any); ok {
if t := text(meta["title"]); t != "" {
pageTitle = t
}
}
var s strings.Builder
s.WriteString(fmt.Sprintf("%s", esc(pageTitle)))
if meta, ok := page["meta"].(map[string]any); ok {
for k, v := range meta {
if k == "title" {
continue
}
val := text(v)
if val == "" {
continue
}
switch {
case k == "description":
s.WriteString(fmt.Sprintf(``, esc(val)))
case k == "canonical":
s.WriteString(fmt.Sprintf(``, esc(val)))
case k == "icon" || k == "favicon":
s.WriteString(fmt.Sprintf(``, esc(val)))
case strings.HasPrefix(k, "og:"):
s.WriteString(fmt.Sprintf(``, esc(k), esc(val)))
default:
s.WriteString(fmt.Sprintf(``, esc(k), esc(val)))
}
}
}
if head, ok := page["head"]; ok {
links := assets.HeadLinksFromJSON(head)
assetVersion := ""
if v, ok := page["asset_version"].(string); ok {
assetVersion = v
} else if v, ok := page["资源版本"].(string); ok {
assetVersion = v
}
s.WriteString(assets.RenderHeadLinksWithVersion(links, assetVersion))
}
return s.String()
}
func renderCard(page map[string]any, it map[string]any) string {
title := text(it["title"])
body := text(it["body"])
href := text(it["href"])
meta := text(it["meta"])
tag := text(it["tag"])
tc := classAttr(fieldCSS(it, "title"))
bc := classAttr(fieldCSS(it, "body"))
var card strings.Builder
card.WriteString(``)
if href != "" {
prefix := "/post/"
if p, ok := page["link_prefix"].(string); ok {
prefix = p
}
card.WriteString(fmt.Sprintf(``, esc(prefix+href)))
}
if meta != "" {
card.WriteString(fmt.Sprintf(`
", bc, esc(body)))
}
if href != "" {
card.WriteString("")
}
card.WriteString("")
return card.String()
}
func renderArticle(it map[string]any) string {
title := text(it["title"])
body := text(it["body"])
meta := text(it["meta"])
tag := text(it["tag"])
var s strings.Builder
s.WriteString(``)
if meta != "" {
s.WriteString(fmt.Sprintf(`
%s
`, esc(meta)))
}
s.WriteString(fmt.Sprintf(`
%s
`, esc(title)))
if tag != "" {
s.WriteString(fmt.Sprintf(`
%s
`, esc(tag)))
}
if body != "" {
s.WriteString(markdownToHTML(body))
}
s.WriteString("")
return s.String()
}
func renderPagination(page map[string]any, total int64, itemCount int) string {
p, ok := page["paginate"].(map[string]any)
if !ok {
return ""
}
offset := int64(0)
limit := int64(10)
if v, ok := p["offset"].(float64); ok {
offset = int64(v)
}
if v, ok := p["limit"].(float64); ok {
limit = int64(v)
}
if limit <= 0 {
return ""
}
path := "/"
if s, ok := p["path"].(string); ok {
path = s
}
var s strings.Builder
s.WriteString(`")
return s.String()
}
func formMountID(target string) string {
t := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(target), "#"))
if t == "" {
return ""
}
for _, c := range t {
if c == ' ' || c == '\t' || c == '\n' || c == '"' || c == '\'' || c == '<' || c == '>' {
return ""
}
}
return t
}
// injectHTMLIntoID puts payload inside the first element with id="…" / id='…'.
func injectHTMLIntoID(haystack, id, payload string) (string, bool) {
id = formMountID(id)
if id == "" {
return "", false
}
patterns := []string{`id="` + id + `"`, `id='` + id + `'`}
for _, pat := range patterns {
idx := strings.Index(haystack, pat)
if idx < 0 {
continue
}
tagStart := strings.LastIndex(haystack[:idx], "<")
if tagStart < 0 {
continue
}
if tagStart+1 >= len(haystack) {
continue
}
afterLt := haystack[tagStart+1]
if afterLt == '/' || afterLt == '!' {
continue
}
nameEnd := tagStart + 1
for nameEnd < len(haystack) {
c := haystack[nameEnd]
if c == ' ' || c == '\t' || c == '\n' || c == '>' || c == '/' {
break
}
nameEnd++
}
tagName := strings.TrimSpace(haystack[tagStart+1 : nameEnd])
if tagName == "" {
continue
}
afterID := idx + len(pat)
rel := strings.IndexByte(haystack[afterID:], '>')
if rel < 0 {
continue
}
openGt := afterID + rel
if openGt > 0 && haystack[openGt-1] == '/' {
continue
}
close := "" + tagName + ">"
rest := haystack[openGt+1:]
closeRel := strings.Index(strings.ToLower(rest), strings.ToLower(close))
if closeRel < 0 {
continue
}
closeIdx := openGt + 1 + closeRel
var out strings.Builder
out.Grow(len(haystack) + len(payload))
out.WriteString(haystack[:openGt+1])
out.WriteString(payload)
out.WriteString(haystack[closeIdx:])
return out.String(), true
}
return "", false
}
func pageFormHTML(page map[string]any) (formID string, html string) {
if page == nil {
return "", ""
}
id, _ := page["form_id"].(string)
id = strings.TrimSpace(id)
if id == "" {
return "", ""
}
frm, ok := page["form"].(map[string]any)
if !ok || frm == nil {
return "", ""
}
ctx := &form.RequestContext{
Params: pageParams(page),
}
if u, ok := page["_nav_user"].(string); ok {
ctx.Username = u
}
if r, ok := page["_route"].(string); ok && r != "" {
ctx.ReturnPath = r
ctx.Path = r
}
return id, form.RenderBodyCtx(frm, id, nil, nil, "", ctx)
}
func pushIntro(buf *strings.Builder, intro string) {
pushIntroAndForm(buf, intro, nil)
}
// pushIntroAndForm writes intro and optional composed form (GAP-11 form_target inject).
func pushIntroAndForm(buf *strings.Builder, intro string, page map[string]any) {
formID, formHTML := pageFormHTML(page)
target := ""
if page != nil {
if t, ok := page["form_target"].(string); ok {
target = t
} else if t, ok := page["target"].(string); ok {
target = t
} else if t, ok := page["form_slot"].(string); ok {
target = t
} else if t, ok := page["表单插槽"].(string); ok {
target = t
}
}
if formHTML != "" && target != "" && intro != "" {
if injected, ok := injectHTMLIntoID(intro, target, formHTML); ok {
buf.WriteString(fmt.Sprintf(`