// 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)
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)
}
}
// Legacy compose_main bind table (internal); prefer when present.
if main, ok := page["main"]; ok {
bindsAny := table.AsBind(main)
arr, _ := bindsAny.([]any)
if len(arr) > 0 && dbURL != "" {
if tn, ok := table.BindTableName(arr); ok {
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
}
}
}
// Artifact Document: flat data_source / data_order / data_where (ADR 0007).
src, _ := page["data_source"].(string)
if src == "" || dbURL == "" {
return intro, nil, nil
}
data := selectPageData(dbURL, src, page, limit, offset)
if t, ok := data["total"].(float64); ok {
ti := int64(t)
total = &ti
}
rawRows, _ := data["rows"].([]any)
for _, v := range rawRows {
if m := projectArtifactRow(v); m != nil {
items = append(items, m)
}
}
return intro, items, total
}
// projectArtifactRow maps a DB row to card/article fields without compose binds.
func projectArtifactRow(row any) map[string]any {
obj, ok := row.(map[string]any)
if !ok || obj == nil {
return nil
}
m := map[string]any{}
if id, ok := obj["id"]; ok {
m["id"] = id
}
if t := text(obj["title"]); t != "" {
m["title"] = t
}
if s := text(obj["slug"]); s != "" {
m["href"] = s
} else if h := text(obj["href"]); h != "" {
m["href"] = h
}
// Detail pages prefer full content; list cards prefer summary.
if c := text(obj["content"]); c != "" {
m["body"] = c
} else if s := text(obj["summary"]); s != "" {
m["body"] = s
} else if b := text(obj["body"]); b != "" {
m["body"] = b
}
if tag := text(obj["tag"]); tag != "" {
m["tag"] = tag
}
if meta := text(obj["created_at"]); meta != "" {
m["meta"] = meta
} else if meta := text(obj["meta"]); meta != "" {
m["meta"] = meta
}
if len(m) == 0 {
return nil
}
return m
}
// listBind is one secondary page list (compose_list / 列表装配).
type listBind struct {
Items []map[string]any
Target string
HTML string
Rail bool
}
func isRailTarget(target string) bool {
t := strings.TrimSpace(strings.ToLower(target))
t = strings.TrimPrefix(t, "#")
switch t {
case "rail", "轨", "side-rail", "aside.side-rail", "新闻轨":
return true
default:
return false
}
}
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
}
limit := int64(200)
target := ""
if t, ok := em["target"].(string); ok {
target = t
}
if isRailTarget(target) {
limit = 24
}
data := selectPageData(dbURL, tn, sub, limit, 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, Target: target, Rail: isRailTarget(target)}
if lb.Rail {
lb.HTML = renderNewsRail(items)
} else {
lb.HTML = renderListSection(page, items)
}
out = append(out, lb)
}
return out
}
func renderNewsRail(items []map[string]any) string {
var list strings.Builder
if len(items) == 0 {
list.WriteString(`
暂无快讯,请在库表 news 中添加。
`)
} else {
for _, it := range items {
title := text(it["title"])
href := strings.TrimSpace(text(it["href"]))
if href == "" {
href = "#"
}
meta := text(it["meta"])
if len(meta) > 10 {
meta = meta[:10]
}
tag := text(it["tag"])
ext := strings.HasPrefix(href, "http://") || strings.HasPrefix(href, "https://")
list.WriteString(`
", 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(`