pico

created pr with 102.1 on 2026-01-04T04:57:34Z · by c8ef7d19

added 102.2 on 2026-01-04T15:06:18Z · by c8ef7d19


                      1:  e265f5e ! 1:  ff673f6 feat(prose): lists are back bby

added 102.3 on 2026-01-04T15:36:38Z · by c8ef7d19


                      1:  ff673f6 ! 1:  c86f5a4 feat(prose): lists are back bby

cmds

checkout latest patchset:

ssh pr.pico.sh print 102 | git am -3

checkout any patchset in a patch request:

ssh pr.pico.sh print 102.[rev] | git am -3

add changes to patch request:

git format-patch main --stdout | ssh pr.pico.sh pr add 102

Patchset `102.3` on 2026-01-04T15:36:38Z · commit c86f5a4

→ feat(prose): lists are back bby

Eric Bower 2026-01-04T04:35:04Z

feat(prose): lists are back bby

Eric Bower 2026-01-04T04:35:04Z

Semantic diff summary

2 added, 9 modified, 0 signature changed, 1 removed across 5 analyzed files (3 files skipped: unsupported file type)

pkg/apps/prose/api.go

chunk lines 90-96 modified
function_declaration postHandler modified
function_declaration rssBlogHandler modified
function_declaration rssHandler modified

pkg/apps/prose/config.go

function_declaration NewConfigSite modified

pkg/apps/prose/scp_hooks.go

chunk lines 2-8 modified
method_declaration metaLxt added
method_declaration metaMd added
method_declaration FileMeta removed

pkg/apps/prose/ssh.go

function_declaration StartSshServer modified

pkg/shared/listparser.go

chunk lines 34-50 modified
function_declaration TokenToMetaField modified

+109 -46 pkg/apps/prose/api.go #

......@@ -90,6 +90,7 @@ type PostPageData struct {
	Diff         template.HTML
	UpdatedAtISO string
	UpdatedAt    string
	List         *shared.ListParsedText
}

type HeaderTxt struct {

......@@ -427,22 +428,38 @@ func postHandler(w http.ResponseWriter, r *http.Request) {
	post, err := dbpool.FindPostWithSlug(slug, user.ID, cfg.Space)
	if err == nil {
		logger.Info("post found", "id", post.ID, "filename", post.FileSize)
		parsedText, err := shared.ParseText(post.Text)
		if err != nil {
			logger.Error("find post with slug", "err", err.Error())
		}
		ext := filepath.Ext(post.Filename)
		contents := template.HTML("")
		tags := []string{}
		unlisted := false
		var list *shared.ListParsedText

		switch ext {
		case ".lxt":
			list = shared.ListParseText(post.Text)
			tags = list.Tags
			if post.Hidden || post.PublishAt.After(time.Now()) {
				unlisted = true
			}
		case ".md":
			parsedText, err := shared.ParseText(post.Text)
			if err != nil {
				logger.Error("could not parse md text", "err", err.Error())
			}

		if parsedText.Image != "" {
			ogImage = parsedText.Image
		}
			if parsedText.Image != "" {
				ogImage = parsedText.Image
			}

		if parsedText.ImageCard != "" {
			ogImageCard = parsedText.ImageCard
		}
			if parsedText.ImageCard != "" {
				ogImageCard = parsedText.ImageCard
			}
			tags = parsedText.Tags

		unlisted := false
		if post.Hidden || post.PublishAt.After(time.Now()) {
			unlisted = true
			if post.Hidden || post.PublishAt.After(time.Now()) {
				unlisted = true
			}
			contents = template.HTML(parsedText.Html)
		}

		data = PostPageData{

......@@ -459,10 +476,10 @@ func postHandler(w http.ResponseWriter, r *http.Request) {
			UpdatedAtISO: post.UpdatedAt.Format(time.RFC3339),
			Username:     username,
			BlogName:     blogName,
			Contents:     template.HTML(parsedText.Html),
			Contents:     contents,
			HasCSS:       hasCSS,
			CssURL:       template.URL(cfg.CssURL(username)),
			Tags:         parsedText.Tags,
			Tags:         tags,
			Image:        template.URL(ogImage),
			ImageCard:    ogImageCard,
			Favicon:      template.URL(favicon),

......@@ -470,6 +487,7 @@ func postHandler(w http.ResponseWriter, r *http.Request) {
			Unlisted:     unlisted,
			Diff:         template.HTML(diff),
			WithStyles:   withStyles,
			List:         list,
		}
	} else {
		logger.Info("post not found")

......@@ -522,6 +540,7 @@ func postHandler(w http.ResponseWriter, r *http.Request) {
	}

	ts, err := shared.RenderTemplate(cfg, []string{
		cfg.StaticPath("html/list.partial.tmpl"),
		cfg.StaticPath("html/post.page.tmpl"),
	})

......@@ -651,7 +670,10 @@ func rssBlogHandler(w http.ResponseWriter, r *http.Request) {
		return
	}

	ts, err := template.ParseFiles(cfg.StaticPath("html/rss.page.tmpl"))
	ts, err := template.New("rss.page.tmpl").Funcs(shared.FuncMap).ParseFiles(
		cfg.StaticPath("html/list.partial.tmpl"),
		cfg.StaticPath("html/rss.page.tmpl"),
	)
	if err != nil {
		logger.Error("template parse file", "err", err.Error())
		http.Error(w, err.Error(), http.StatusInternalServerError)

......@@ -700,27 +722,48 @@ func rssBlogHandler(w http.ResponseWriter, r *http.Request) {
		if slices.Contains(cfg.HiddenPosts, post.Filename) {
			continue
		}
		parsed, err := shared.ParseText(post.Text)
		if err != nil {
			logger.Error("parse post text", "err", err.Error())
		}

		footer, err := dbpool.FindPostWithFilename("_footer.md", user.ID, cfg.Space)
		var footerHTML string
		if err == nil {
			footerParsed, err := shared.ParseText(footer.Text)
		content := ""
		ext := filepath.Ext(post.Filename)
		fmt.Println("HERE", post.Filename, ext)
		switch ext {
		case ".md":
			parsed, err := shared.ParseText(post.Text)
			if err != nil {
				logger.Error("parse footer text", "err", err.Error())
				logger.Error("parse post text", "err", err.Error())
			}
			footerHTML = footerParsed.Html
		}

		var tpl bytes.Buffer
		data := &PostPageData{
			Contents: template.HTML(parsed.Html + footerHTML),
		}
		if err := ts.Execute(&tpl, data); err != nil {
			continue
			footer, err := dbpool.FindPostWithFilename("_footer.md", user.ID, cfg.Space)
			var footerHTML string
			if err == nil {
				footerParsed, err := shared.ParseText(footer.Text)
				if err != nil {
					logger.Error("parse footer text", "err", err.Error())
				}
				footerHTML = footerParsed.Html
			}

			var tpl bytes.Buffer
			data := &PostPageData{
				Contents: template.HTML(parsed.Html + footerHTML),
			}
			if err := ts.Execute(&tpl, data); err != nil {
				logger.Error("md template", "err", err)
				continue
			}
			content = tpl.String()
		case ".lxt":
			parsed := shared.ListParseText(post.Text)
			var tpl bytes.Buffer
			data := &PostPageData{
				List: parsed,
			}
			if err := ts.Execute(&tpl, data); err != nil {
				logger.Error("lxt template", "err", err)
				continue
			}
			content = tpl.String()

		}

		realUrl := cfg.FullPostURL(curl, post.Username, post.Slug)

......@@ -730,7 +773,7 @@ func rssBlogHandler(w http.ResponseWriter, r *http.Request) {
			Id:          feedId,
			Title:       utils.FilenameToTitle(post.Filename, post.Title),
			Link:        &feeds.Link{Href: realUrl},
			Content:     tpl.String(),
			Content:     content,
			Updated:     *post.PublishAt,
			Created:     *post.PublishAt,
			Description: post.Description,

......@@ -769,7 +812,10 @@ func rssHandler(w http.ResponseWriter, r *http.Request) {
		return
	}

	ts, err := template.ParseFiles(cfg.StaticPath("html/rss.page.tmpl"))
	ts, err := template.New("rss.page.tmpl").Funcs(shared.FuncMap).ParseFiles(
		cfg.StaticPath("html/list.partial.tmpl"),
		cfg.StaticPath("html/rss.page.tmpl"),
	)
	if err != nil {
		logger.Error("template parse file", "err", err.Error())
		http.Error(w, err.Error(), http.StatusInternalServerError)

......@@ -788,17 +834,34 @@ func rssHandler(w http.ResponseWriter, r *http.Request) {

	var feedItems []*feeds.Item
	for _, post := range pager.Data {
		parsed, err := shared.ParseText(post.Text)
		if err != nil {
			logger.Error(err.Error())
		}
		content := ""
		ext := filepath.Ext(post.Filename)
		switch ext {
		case ".md":
			parsed, err := shared.ParseText(post.Text)
			if err != nil {
				logger.Error(err.Error())
			}

			var tpl bytes.Buffer
			data := &PostPageData{
				Contents: template.HTML(parsed.Html),
			}
			if err := ts.Execute(&tpl, data); err != nil {
				continue
			}
			content = tpl.String()
		case ".lxt":
			parsed := shared.ListParseText(post.Text)
			var tpl bytes.Buffer
			data := &PostPageData{
				List: parsed,
			}
			if err := ts.Execute(&tpl, data); err != nil {
				continue
			}
			content = tpl.String()

		var tpl bytes.Buffer
		data := &PostPageData{
			Contents: template.HTML(parsed.Html),
		}
		if err := ts.Execute(&tpl, data); err != nil {
			continue
		}

		realUrl := cfg.FullPostURL(curl, post.Username, post.Slug)

......@@ -810,7 +873,7 @@ func rssHandler(w http.ResponseWriter, r *http.Request) {
			Id:          realUrl,
			Title:       post.Title,
			Link:        &feeds.Link{Href: realUrl},
			Content:     tpl.String(),
			Content:     content,
			Created:     *post.PublishAt,
			Updated:     *post.UpdatedAt,
			Description: post.Description,

+1 -0 pkg/apps/prose/config.go #

......@@ -28,6 +28,7 @@ func NewConfigSite(service string) *shared.ConfigSite {
		Space:    "prose",
		AllowedExt: []string{
			".md",
			".lxt",
			".jpg",
			".jpeg",
			".png",

+51 -0 pkg/apps/prose/html/list.partial.tmpl #

......@@ -0,0 +1,51 @@
{{define "list"}}
{{$indent := 0}}
{{$mod := 0}}
<ul style="list-style-type: {{.ListType}};">
    {{range .Items}}
        {{if lt $indent .Indent}}
        <ul>
        {{else if gt $indent .Indent}}

        {{$mod = minus $indent .Indent}}
        {{range $y := intRange 1 $mod}}
        </li></ul>
        {{end}}

        {{else}}
        </li>
        {{end}}
        {{$indent = .Indent}}

        {{if .IsText}}
            {{if .Value}}
            <li>{{.Value}}
            {{end}}
        {{end}}

        {{if .IsURL}}
        <li><a href="{{.URL}}">{{.Value}}</a>
        {{end}}

        {{if .IsImg}}
        <li><img src="{{.URL}}" alt="{{.Value}}" />
        {{end}}

        {{if .IsBlock}}
        <li><blockquote>{{.Value}}</blockquote>
        {{end}}

        {{if .IsHeaderOne}}
        </ul><h2 class="text-xl font-bold">{{.Value}}</h2><ul style="list-style-type: {{$.ListType}};">
        {{end}}

        {{if .IsHeaderTwo}}
        </ul><h3 class="text-lg font-bold">{{.Value}}</h3><ul style="list-style-type: {{$.ListType}};">
        {{end}}

        {{if .IsPre}}
        <li><pre>{{.Value}}</pre>
        {{end}}
    {{end}}
</ul>
{{end}}

+5 -1 pkg/apps/prose/html/post.page.tmpl #

......@@ -65,7 +65,11 @@
</header>
<main>
    <article class="md">
        {{.Contents}}
        {{if .List}}
          {{template "list" .List}}
        {{else}}
          {{.Contents}}
        {{end}}

        <div class="tags">
          {{range .Tags}}

+5 -1 pkg/apps/prose/html/rss.page.tmpl #

......@@ -1,1 +1,5 @@
{{.Contents}}
{{if .List}}
  {{template "list" .List}}
{{else}}
  {{.Contents}}
{{end}}

+43 -1 pkg/apps/prose/scp_hooks.go #

......@@ -2,6 +2,7 @@ package prose

import (
	"fmt"
	"path/filepath"
	"strings"

	"slices"

......@@ -62,7 +63,29 @@ func (p *MarkdownHooks) FileValidate(s *pssh.SSHServerConnSession, data *filehan
	return true, nil
}

func (p *MarkdownHooks) FileMeta(s *pssh.SSHServerConnSession, data *filehandlers.PostMetaData) error {
func (p *MarkdownHooks) metaLxt(data *filehandlers.PostMetaData) error {
	parsedText := shared.ListParseText(data.Text)

	if parsedText.Title == "" {
		data.Title = utils.ToUpper(data.Slug)
	} else {
		data.Title = parsedText.Title
	}

	data.Aliases = parsedText.Aliases
	data.Tags = parsedText.Tags
	data.Description = parsedText.Description

	if parsedText.PublishAt != nil && !parsedText.PublishAt.IsZero() {
		data.PublishAt = parsedText.PublishAt
	}

	isHiddenFilename := slices.Contains(p.Cfg.HiddenPosts, data.Filename)
	data.Hidden = parsedText.Hidden || isHiddenFilename
	return nil
}

func (p *MarkdownHooks) metaMd(data *filehandlers.PostMetaData) error {
	parsedText, err := shared.ParseText(data.Text)
	if err != nil {
		return fmt.Errorf("%s: %w", data.Filename, err)

......@@ -84,6 +107,25 @@ func (p *MarkdownHooks) FileMeta(s *pssh.SSHServerConnSession, data *filehandler

	isHiddenFilename := slices.Contains(p.Cfg.HiddenPosts, data.Filename)
	data.Hidden = parsedText.Hidden || isHiddenFilename
	return nil
}

func (p *MarkdownHooks) FileMeta(s *pssh.SSHServerConnSession, data *filehandlers.PostMetaData) error {
	ext := filepath.Ext(data.Filename)
	switch ext {
	case ".lxt":
		err := p.metaLxt(data)
		if err != nil {
			return fmt.Errorf("%s: %w", data.Filename, err)
		}
	case ".md":
		err := p.metaMd(data)
		if err != nil {
			return fmt.Errorf("%s: %w", data.Filename, err)
		}
	default:
		return fmt.Errorf("%s: invalid filetype", data.Filename)
	}

	return nil
}

+1 -0 pkg/apps/prose/ssh.go #

......@@ -55,6 +55,7 @@ func StartSshServer() {
		".md":      filehandlers.NewScpPostHandler(dbh, cfg, hooks),
		".txt":     filehandlers.NewScpPostHandler(dbh, cfg, hooks),
		".css":     filehandlers.NewScpPostHandler(dbh, cfg, hooks),
		".lxt":     filehandlers.NewScpPostHandler(dbh, cfg, hooks),
		"fallback": uploadimgs.NewUploadImgHandler(dbh, cfg, st),
	}
	handler := filehandlers.NewFileHandlerRouter(cfg, dbh, fileMap)

+23 -6 pkg/shared/listparser.go #

......@@ -34,12 +34,17 @@ type ListItem struct {
}

type ListMetaData struct {
	PublishAt      *time.Time
	Title          string
	Description    string
	Layout         string
	Tags           []string
	ListType       string // https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type
	// prose
	PublishAt   *time.Time
	Title       string
	Description string
	Layout      string
	Tags        []string
	Hidden      bool
	Aliases     []string
	ListType    string // https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type

	// feeds
	DigestInterval string
	Cron           string
	Email          string

......@@ -103,12 +108,24 @@ func TokenToMetaField(meta *ListMetaData, token *SplitToken) error {
		meta.Description = token.Value
	case "list_type":
		meta.ListType = token.Value
	case "hidden":
		if token.Value == "true" {
			meta.Hidden = true
		} else {
			meta.Hidden = false
		}
	case "tags":
		tags := strings.Split(token.Value, ",")
		meta.Tags = make([]string, 0)
		for _, tag := range tags {
			meta.Tags = append(meta.Tags, strings.TrimSpace(tag))
		}
	case "aliases":
		aliases := strings.Split(token.Value, ",")
		meta.Aliases = make([]string, 0)
		for _, alias := range aliases {
			meta.Aliases = append(meta.Aliases, strings.TrimSpace(alias))
		}
	case "layout":
		meta.Layout = token.Value
	case "digest_interval":

...	...		@@ -427,22 +428,38 @@ func postHandler(w http.ResponseWriter, r *http.Request) {
427	428		post, err := dbpool.FindPostWithSlug(slug, user.ID, cfg.Space)
428	429		if err == nil {
429	430		logger.Info("post found", "id", post.ID, "filename", post.FileSize)
430		-	parsedText, err := shared.ParseText(post.Text)
431		-	if err != nil {
432		-	logger.Error("find post with slug", "err", err.Error())
433		-	}
	431	+	ext := filepath.Ext(post.Filename)
	432	+	contents := template.HTML("")
	433	+	tags := []string{}
	434	+	unlisted := false
	435	+	var list *shared.ListParsedText
	436	+
	437	+	switch ext {
	438	+	case ".lxt":
	439	+	list = shared.ListParseText(post.Text)
	440	+	tags = list.Tags
	441	+	if post.Hidden \|\| post.PublishAt.After(time.Now()) {
	442	+	unlisted = true
	443	+	}
	444	+	case ".md":
	445	+	parsedText, err := shared.ParseText(post.Text)
	446	+	if err != nil {
	447	+	logger.Error("could not parse md text", "err", err.Error())
	448	+	}
434	449
435		-	if parsedText.Image != "" {
436		-	ogImage = parsedText.Image
437		-	}
	450	+	if parsedText.Image != "" {
	451	+	ogImage = parsedText.Image
	452	+	}
438	453
439		-	if parsedText.ImageCard != "" {
440		-	ogImageCard = parsedText.ImageCard
441		-	}
	454	+	if parsedText.ImageCard != "" {
	455	+	ogImageCard = parsedText.ImageCard
	456	+	}
	457	+	tags = parsedText.Tags
442	458
443		-	unlisted := false
444		-	if post.Hidden \|\| post.PublishAt.After(time.Now()) {
445		-	unlisted = true
	459	+	if post.Hidden \|\| post.PublishAt.After(time.Now()) {
	460	+	unlisted = true
	461	+	}
	462	+	contents = template.HTML(parsedText.Html)
446	463		}
447	464
448	465		data = PostPageData{

...	...		@@ -459,10 +476,10 @@ func postHandler(w http.ResponseWriter, r *http.Request) {
459	476		UpdatedAtISO: post.UpdatedAt.Format(time.RFC3339),
460	477		Username: username,
461	478		BlogName: blogName,
462		-	Contents: template.HTML(parsedText.Html),
	479	+	Contents: contents,
463	480		HasCSS: hasCSS,
464	481		CssURL: template.URL(cfg.CssURL(username)),
465		-	Tags: parsedText.Tags,
	482	+	Tags: tags,
466	483		Image: template.URL(ogImage),
467	484		ImageCard: ogImageCard,
468	485		Favicon: template.URL(favicon),

...	...		@@ -522,6 +540,7 @@ func postHandler(w http.ResponseWriter, r *http.Request) {
522	540		}
523	541
524	542		ts, err := shared.RenderTemplate(cfg, []string{
	543	+	cfg.StaticPath("html/list.partial.tmpl"),
525	544		cfg.StaticPath("html/post.page.tmpl"),
526	545		})
527	546

...	...		@@ -700,27 +722,48 @@ func rssBlogHandler(w http.ResponseWriter, r *http.Request) {
700	722		if slices.Contains(cfg.HiddenPosts, post.Filename) {
701	723		continue
702	724		}
703		-	parsed, err := shared.ParseText(post.Text)
704		-	if err != nil {
705		-	logger.Error("parse post text", "err", err.Error())
706		-	}
707	725
708		-	footer, err := dbpool.FindPostWithFilename("_footer.md", user.ID, cfg.Space)
709		-	var footerHTML string
710		-	if err == nil {
711		-	footerParsed, err := shared.ParseText(footer.Text)
	726	+	content := ""
	727	+	ext := filepath.Ext(post.Filename)
	728	+	fmt.Println("HERE", post.Filename, ext)
	729	+	switch ext {
	730	+	case ".md":
	731	+	parsed, err := shared.ParseText(post.Text)
712	732		if err != nil {
713		-	logger.Error("parse footer text", "err", err.Error())
	733	+	logger.Error("parse post text", "err", err.Error())
714	734		}
715		-	footerHTML = footerParsed.Html
716		-	}
717	735
718		-	var tpl bytes.Buffer
719		-	data := &PostPageData{
720		-	Contents: template.HTML(parsed.Html + footerHTML),
721		-	}
722		-	if err := ts.Execute(&tpl, data); err != nil {
723		-	continue
	736	+	footer, err := dbpool.FindPostWithFilename("_footer.md", user.ID, cfg.Space)
	737	+	var footerHTML string
	738	+	if err == nil {
	739	+	footerParsed, err := shared.ParseText(footer.Text)
	740	+	if err != nil {
	741	+	logger.Error("parse footer text", "err", err.Error())
	742	+	}
	743	+	footerHTML = footerParsed.Html
	744	+	}
	745	+
	746	+	var tpl bytes.Buffer
	747	+	data := &PostPageData{
	748	+	Contents: template.HTML(parsed.Html + footerHTML),
	749	+	}
	750	+	if err := ts.Execute(&tpl, data); err != nil {
	751	+	logger.Error("md template", "err", err)
	752	+	continue
	753	+	}
	754	+	content = tpl.String()
	755	+	case ".lxt":
	756	+	parsed := shared.ListParseText(post.Text)
	757	+	var tpl bytes.Buffer
	758	+	data := &PostPageData{
	759	+	List: parsed,
	760	+	}
	761	+	if err := ts.Execute(&tpl, data); err != nil {
	762	+	logger.Error("lxt template", "err", err)
	763	+	continue
	764	+	}
	765	+	content = tpl.String()
	766	+
724	767		}
725	768
726	769		realUrl := cfg.FullPostURL(curl, post.Username, post.Slug)

...	...		@@ -788,17 +834,34 @@ func rssHandler(w http.ResponseWriter, r *http.Request) {
788	834
789	835		var feedItems []*feeds.Item
790	836		for _, post := range pager.Data {
791		-	parsed, err := shared.ParseText(post.Text)
792		-	if err != nil {
793		-	logger.Error(err.Error())
794		-	}
	837	+	content := ""
	838	+	ext := filepath.Ext(post.Filename)
	839	+	switch ext {
	840	+	case ".md":
	841	+	parsed, err := shared.ParseText(post.Text)
	842	+	if err != nil {
	843	+	logger.Error(err.Error())
	844	+	}
	845	+
	846	+	var tpl bytes.Buffer
	847	+	data := &PostPageData{
	848	+	Contents: template.HTML(parsed.Html),
	849	+	}
	850	+	if err := ts.Execute(&tpl, data); err != nil {
	851	+	continue
	852	+	}
	853	+	content = tpl.String()
	854	+	case ".lxt":
	855	+	parsed := shared.ListParseText(post.Text)
	856	+	var tpl bytes.Buffer
	857	+	data := &PostPageData{
	858	+	List: parsed,
	859	+	}
	860	+	if err := ts.Execute(&tpl, data); err != nil {
	861	+	continue
	862	+	}
	863	+	content = tpl.String()
795	864
796		-	var tpl bytes.Buffer
797		-	data := &PostPageData{
798		-	Contents: template.HTML(parsed.Html),
799		-	}
800		-	if err := ts.Execute(&tpl, data); err != nil {
801		-	continue
802	865		}
803	866
804	867		realUrl := cfg.FullPostURL(curl, post.Username, post.Slug)

...	...		@@ -90,6 +90,7 @@ type PostPageData struct {
90	90		Diff template.HTML
91	91		UpdatedAtISO string
92	92		UpdatedAt string
	93	+	List *shared.ListParsedText
93	94		}
94	95
95	96		type HeaderTxt struct {

...	...		@@ -470,6 +487,7 @@ func postHandler(w http.ResponseWriter, r *http.Request) {
470	487		Unlisted: unlisted,
471	488		Diff: template.HTML(diff),
472	489		WithStyles: withStyles,
	490	+	List: list,
473	491		}
474	492		} else {
475	493		logger.Info("post not found")

...	...		@@ -651,7 +670,10 @@ func rssBlogHandler(w http.ResponseWriter, r *http.Request) {
651	670		return
652	671		}
653	672
654		-	ts, err := template.ParseFiles(cfg.StaticPath("html/rss.page.tmpl"))
	673	+	ts, err := template.New("rss.page.tmpl").Funcs(shared.FuncMap).ParseFiles(
	674	+	cfg.StaticPath("html/list.partial.tmpl"),
	675	+	cfg.StaticPath("html/rss.page.tmpl"),
	676	+	)
655	677		if err != nil {
656	678		logger.Error("template parse file", "err", err.Error())
657	679		http.Error(w, err.Error(), http.StatusInternalServerError)

...	...		@@ -730,7 +773,7 @@ func rssBlogHandler(w http.ResponseWriter, r *http.Request) {
730	773		Id: feedId,
731	774		Title: utils.FilenameToTitle(post.Filename, post.Title),
732	775		Link: &feeds.Link{Href: realUrl},
733		-	Content: tpl.String(),
	776	+	Content: content,
734	777		Updated: *post.PublishAt,
735	778		Created: *post.PublishAt,
736	779		Description: post.Description,

...	...		@@ -769,7 +812,10 @@ func rssHandler(w http.ResponseWriter, r *http.Request) {
769	812		return
770	813		}
771	814
772		-	ts, err := template.ParseFiles(cfg.StaticPath("html/rss.page.tmpl"))
	815	+	ts, err := template.New("rss.page.tmpl").Funcs(shared.FuncMap).ParseFiles(
	816	+	cfg.StaticPath("html/list.partial.tmpl"),
	817	+	cfg.StaticPath("html/rss.page.tmpl"),
	818	+	)
773	819		if err != nil {
774	820		logger.Error("template parse file", "err", err.Error())
775	821		http.Error(w, err.Error(), http.StatusInternalServerError)

...	...		@@ -810,7 +873,7 @@ func rssHandler(w http.ResponseWriter, r *http.Request) {
810	873		Id: realUrl,
811	874		Title: post.Title,
812	875		Link: &feeds.Link{Href: realUrl},
813		-	Content: tpl.String(),
	876	+	Content: content,
814	877		Created: *post.PublishAt,
815	878		Updated: *post.UpdatedAt,
816	879		Description: post.Description,

...	...		@@ -28,6 +28,7 @@ func NewConfigSite(service string) *shared.ConfigSite {
28	28		Space: "prose",
29	29		AllowedExt: []string{
30	30		".md",
	31	+	".lxt",
31	32		".jpg",
32	33		".jpeg",
33	34		".png",

...	...		@@ -0,0 +1,51 @@
	1	+	{{define "list"}}
	2	+	{{$indent := 0}}
	3	+	{{$mod := 0}}
	4	+	<ul style="list-style-type: {{.ListType}};">
	5	+	{{range .Items}}
	6	+	{{if lt $indent .Indent}}
	7	+	<ul>
	8	+	{{else if gt $indent .Indent}}
	9	+
	10	+	{{$mod = minus $indent .Indent}}
	11	+	{{range $y := intRange 1 $mod}}
	12	+	</li></ul>
	13	+	{{end}}
	14	+
	15	+	{{else}}
	16	+	</li>
	17	+	{{end}}
	18	+	{{$indent = .Indent}}
	19	+
	20	+	{{if .IsText}}
	21	+	{{if .Value}}
	22	+	<li>{{.Value}}
	23	+	{{end}}
	24	+	{{end}}
	25	+
	26	+	{{if .IsURL}}
	27	+	<li><a href="{{.URL}}">{{.Value}}</a>
	28	+	{{end}}
	29	+
	30	+	{{if .IsImg}}
	31	+	<li><img src="{{.URL}}" alt="{{.Value}}" />
	32	+	{{end}}
	33	+
	34	+	{{if .IsBlock}}
	35	+	<li><blockquote>{{.Value}}</blockquote>
	36	+	{{end}}
	37	+
	38	+	{{if .IsHeaderOne}}
	39	+	</ul><h2 class="text-xl font-bold">{{.Value}}</h2><ul style="list-style-type: {{$.ListType}};">
	40	+	{{end}}
	41	+
	42	+	{{if .IsHeaderTwo}}
	43	+	</ul><h3 class="text-lg font-bold">{{.Value}}</h3><ul style="list-style-type: {{$.ListType}};">
	44	+	{{end}}
	45	+
	46	+	{{if .IsPre}}
	47	+	<li><pre>{{.Value}}</pre>
	48	+	{{end}}
	49	+	{{end}}
	50	+	</ul>
	51	+	{{end}}

...	...		@@ -65,7 +65,11 @@
65	65		</header>
66	66		<main>
67	67		<article class="md">
68		-	{{.Contents}}
	68	+	{{if .List}}
	69	+	{{template "list" .List}}
	70	+	{{else}}
	71	+	{{.Contents}}
	72	+	{{end}}
69	73
70	74		<div class="tags">
71	75		{{range .Tags}}

...	...		@@ -1,1 +1,5 @@
1		-	{{.Contents}}
	1	+	{{if .List}}
	2	+	{{template "list" .List}}
	3	+	{{else}}
	4	+	{{.Contents}}
	5	+	{{end}}

...	...		@@ -2,6 +2,7 @@ package prose
2	2
3	3		import (
4	4		"fmt"
	5	+	"path/filepath"
5	6		"strings"
6	7
7	8		"slices"

...	...		@@ -62,7 +63,29 @@ func (p MarkdownHooks) FileValidate(s pssh.SSHServerConnSession, data *filehan
62	63		return true, nil
63	64		}
64	65
65		-	func (p MarkdownHooks) FileMeta(s pssh.SSHServerConnSession, data *filehandlers.PostMetaData) error {
	66	+	func (p MarkdownHooks) metaLxt(data filehandlers.PostMetaData) error {
	67	+	parsedText := shared.ListParseText(data.Text)
	68	+
	69	+	if parsedText.Title == "" {
	70	+	data.Title = utils.ToUpper(data.Slug)
	71	+	} else {
	72	+	data.Title = parsedText.Title
	73	+	}
	74	+
	75	+	data.Aliases = parsedText.Aliases
	76	+	data.Tags = parsedText.Tags
	77	+	data.Description = parsedText.Description
	78	+
	79	+	if parsedText.PublishAt != nil && !parsedText.PublishAt.IsZero() {
	80	+	data.PublishAt = parsedText.PublishAt
	81	+	}
	82	+
	83	+	isHiddenFilename := slices.Contains(p.Cfg.HiddenPosts, data.Filename)
	84	+	data.Hidden = parsedText.Hidden \|\| isHiddenFilename
	85	+	return nil
	86	+	}
	87	+
	88	+	func (p MarkdownHooks) metaMd(data filehandlers.PostMetaData) error {
66	89		parsedText, err := shared.ParseText(data.Text)
67	90		if err != nil {
68	91		return fmt.Errorf("%s: %w", data.Filename, err)

...	...		@@ -84,6 +107,25 @@ func (p MarkdownHooks) FileMeta(s pssh.SSHServerConnSession, data *filehandler
84	107
85	108		isHiddenFilename := slices.Contains(p.Cfg.HiddenPosts, data.Filename)
86	109		data.Hidden = parsedText.Hidden \|\| isHiddenFilename
	110	+	return nil
	111	+	}
	112	+
	113	+	func (p MarkdownHooks) FileMeta(s pssh.SSHServerConnSession, data *filehandlers.PostMetaData) error {
	114	+	ext := filepath.Ext(data.Filename)
	115	+	switch ext {
	116	+	case ".lxt":
	117	+	err := p.metaLxt(data)
	118	+	if err != nil {
	119	+	return fmt.Errorf("%s: %w", data.Filename, err)
	120	+	}
	121	+	case ".md":
	122	+	err := p.metaMd(data)
	123	+	if err != nil {
	124	+	return fmt.Errorf("%s: %w", data.Filename, err)
	125	+	}
	126	+	default:
	127	+	return fmt.Errorf("%s: invalid filetype", data.Filename)
	128	+	}
87	129
88	130		return nil
89	131		}

...	...		@@ -55,6 +55,7 @@ func StartSshServer() {
55	55		".md": filehandlers.NewScpPostHandler(dbh, cfg, hooks),
56	56		".txt": filehandlers.NewScpPostHandler(dbh, cfg, hooks),
57	57		".css": filehandlers.NewScpPostHandler(dbh, cfg, hooks),
	58	+	".lxt": filehandlers.NewScpPostHandler(dbh, cfg, hooks),
58	59		"fallback": uploadimgs.NewUploadImgHandler(dbh, cfg, st),
59	60		}
60	61		handler := filehandlers.NewFileHandlerRouter(cfg, dbh, fileMap)

...	...		@@ -34,12 +34,17 @@ type ListItem struct {
34	34		}
35	35
36	36		type ListMetaData struct {
37		-	PublishAt *time.Time
38		-	Title string
39		-	Description string
40		-	Layout string
41		-	Tags []string
42		-	ListType string // https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type
	37	+	// prose
	38	+	PublishAt *time.Time
	39	+	Title string
	40	+	Description string
	41	+	Layout string
	42	+	Tags []string
	43	+	Hidden bool
	44	+	Aliases []string
	45	+	ListType string // https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type
	46	+
	47	+	// feeds
43	48		DigestInterval string
44	49		Cron string
45	50		Email string

...	...		@@ -103,12 +108,24 @@ func TokenToMetaField(meta ListMetaData, token SplitToken) error {
103	108		meta.Description = token.Value
104	109		case "list_type":
105	110		meta.ListType = token.Value
	111	+	case "hidden":
	112	+	if token.Value == "true" {
	113	+	meta.Hidden = true
	114	+	} else {
	115	+	meta.Hidden = false
	116	+	}
106	117		case "tags":
107	118		tags := strings.Split(token.Value, ",")
108	119		meta.Tags = make([]string, 0)
109	120		for _, tag := range tags {
110	121		meta.Tags = append(meta.Tags, strings.TrimSpace(tag))
111	122		}
	123	+	case "aliases":
	124	+	aliases := strings.Split(token.Value, ",")
	125	+	meta.Aliases = make([]string, 0)
	126	+	for _, alias := range aliases {
	127	+	meta.Aliases = append(meta.Aliases, strings.TrimSpace(alias))
	128	+	}
112	129		case "layout":
113	130		meta.Layout = token.Value
114	131		case "digest_interval":

pico

Patchset 102.3 on 2026-01-04T15:36:38Z · commit c86f5a4

Patchset `102.3` on 2026-01-04T15:36:38Z · commit c86f5a4