veryroundbird.house
1package pages
2
3import (
4 "crypto/hmac"
5 "crypto/sha256"
6 "encoding/hex"
7 "errors"
8 "fmt"
9 "html"
10 "html/template"
11 "log"
12 "math"
13 "net/url"
14 "path/filepath"
15 "reflect"
16 "strings"
17 "time"
18
19 "github.com/dustin/go-humanize"
20 "github.com/go-enry/go-enry/v2"
21 "github.com/microcosm-cc/bluemonday"
22 "tangled.sh/tangled.sh/core/appview/filetree"
23 "tangled.sh/tangled.sh/core/appview/pages/markup"
24)
25
26func (p *Pages) funcMap() template.FuncMap {
27 return template.FuncMap{
28 "split": func(s string) []string {
29 return strings.Split(s, "\n")
30 },
31 "truncateAt30": func(s string) string {
32 if len(s) <= 30 {
33 return s
34 }
35 return s[:30] + "…"
36 },
37 "splitOn": func(s, sep string) []string {
38 return strings.Split(s, sep)
39 },
40 "int64": func(a int) int64 {
41 return int64(a)
42 },
43 "add": func(a, b int) int {
44 return a + b
45 },
46 "now": func() time.Time {
47 return time.Now()
48 },
49 // the absolute state of go templates
50 "add64": func(a, b int64) int64 {
51 return a + b
52 },
53 "sub": func(a, b int) int {
54 return a - b
55 },
56 "f64": func(a int) float64 {
57 return float64(a)
58 },
59 "addf64": func(a, b float64) float64 {
60 return a + b
61 },
62 "subf64": func(a, b float64) float64 {
63 return a - b
64 },
65 "mulf64": func(a, b float64) float64 {
66 return a * b
67 },
68 "divf64": func(a, b float64) float64 {
69 if b == 0 {
70 return 0
71 }
72 return a / b
73 },
74 "negf64": func(a float64) float64 {
75 return -a
76 },
77 "cond": func(cond interface{}, a, b string) string {
78 if cond == nil {
79 return b
80 }
81
82 if boolean, ok := cond.(bool); boolean && ok {
83 return a
84 }
85
86 return b
87 },
88 "didOrHandle": func(did, handle string) string {
89 if handle != "" {
90 return fmt.Sprintf("@%s", handle)
91 } else {
92 return did
93 }
94 },
95 "assoc": func(values ...string) ([][]string, error) {
96 if len(values)%2 != 0 {
97 return nil, fmt.Errorf("invalid assoc call, must have an even number of arguments")
98 }
99 pairs := make([][]string, 0)
100 for i := 0; i < len(values); i += 2 {
101 pairs = append(pairs, []string{values[i], values[i+1]})
102 }
103 return pairs, nil
104 },
105 "append": func(s []string, values ...string) []string {
106 s = append(s, values...)
107 return s
108 },
109 "commaFmt": humanize.Comma,
110 "relTimeFmt": humanize.Time,
111 "shortRelTimeFmt": func(t time.Time) string {
112 return humanize.CustomRelTime(t, time.Now(), "", "", []humanize.RelTimeMagnitude{
113 {time.Second, "now", time.Second},
114 {2 * time.Second, "1s %s", 1},
115 {time.Minute, "%ds %s", time.Second},
116 {2 * time.Minute, "1min %s", 1},
117 {time.Hour, "%dmin %s", time.Minute},
118 {2 * time.Hour, "1hr %s", 1},
119 {humanize.Day, "%dhrs %s", time.Hour},
120 {2 * humanize.Day, "1d %s", 1},
121 {20 * humanize.Day, "%dd %s", humanize.Day},
122 {8 * humanize.Week, "%dw %s", humanize.Week},
123 {humanize.Year, "%dmo %s", humanize.Month},
124 {18 * humanize.Month, "1y %s", 1},
125 {2 * humanize.Year, "2y %s", 1},
126 {humanize.LongTime, "%dy %s", humanize.Year},
127 {math.MaxInt64, "a long while %s", 1},
128 })
129 },
130 "longTimeFmt": func(t time.Time) string {
131 return t.Format("Jan 2, 2006, 3:04 PM MST")
132 },
133 "iso8601DateTimeFmt": func(t time.Time) string {
134 return t.Format("2006-01-02T15:04:05-07:00")
135 },
136 "iso8601DurationFmt": func(duration time.Duration) string {
137 days := int64(duration.Hours() / 24)
138 hours := int64(math.Mod(duration.Hours(), 24))
139 minutes := int64(math.Mod(duration.Minutes(), 60))
140 seconds := int64(math.Mod(duration.Seconds(), 60))
141 return fmt.Sprintf("P%dD%dH%dM%dS", days, hours, minutes, seconds)
142 },
143 "durationFmt": func(duration time.Duration) string {
144 return durationFmt(duration, [4]string{"d", "hr", "min", "s"})
145 },
146 "longDurationFmt": func(duration time.Duration) string {
147 return durationFmt(duration, [4]string{"days", "hours", "minutes", "seconds"})
148 },
149 "byteFmt": humanize.Bytes,
150 "length": func(slice any) int {
151 v := reflect.ValueOf(slice)
152 if v.Kind() == reflect.Slice || v.Kind() == reflect.Array {
153 return v.Len()
154 }
155 return 0
156 },
157 "splitN": func(s, sep string, n int) []string {
158 return strings.SplitN(s, sep, n)
159 },
160 "escapeHtml": func(s string) template.HTML {
161 if s == "" {
162 return template.HTML("<br>")
163 }
164 return template.HTML(s)
165 },
166 "unescapeHtml": func(s string) string {
167 return html.UnescapeString(s)
168 },
169 "nl2br": func(text string) template.HTML {
170 return template.HTML(strings.Replace(template.HTMLEscapeString(text), "\n", "<br>", -1))
171 },
172 "unwrapText": func(text string) string {
173 paragraphs := strings.Split(text, "\n\n")
174
175 for i, p := range paragraphs {
176 lines := strings.Split(p, "\n")
177 paragraphs[i] = strings.Join(lines, " ")
178 }
179
180 return strings.Join(paragraphs, "\n\n")
181 },
182 "sequence": func(n int) []struct{} {
183 return make([]struct{}, n)
184 },
185 // take atmost N items from this slice
186 "take": func(slice any, n int) any {
187 v := reflect.ValueOf(slice)
188 if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
189 return nil
190 }
191 if v.Len() == 0 {
192 return nil
193 }
194 return v.Slice(0, min(n, v.Len())).Interface()
195 },
196
197 "markdown": func(text string) template.HTML {
198 rctx := &markup.RenderContext{RendererType: markup.RendererTypeDefault}
199 return template.HTML(bluemonday.UGCPolicy().Sanitize(rctx.RenderMarkdown(text)))
200 },
201 "isNil": func(t any) bool {
202 // returns false for other "zero" values
203 return t == nil
204 },
205 "list": func(args ...any) []any {
206 return args
207 },
208 "dict": func(values ...any) (map[string]any, error) {
209 if len(values)%2 != 0 {
210 return nil, errors.New("invalid dict call")
211 }
212 dict := make(map[string]any, len(values)/2)
213 for i := 0; i < len(values); i += 2 {
214 key, ok := values[i].(string)
215 if !ok {
216 return nil, errors.New("dict keys must be strings")
217 }
218 dict[key] = values[i+1]
219 }
220 return dict, nil
221 },
222 "deref": func(v any) any {
223 val := reflect.ValueOf(v)
224 if val.Kind() == reflect.Ptr && !val.IsNil() {
225 return val.Elem().Interface()
226 }
227 return nil
228 },
229 "i": func(name string, classes ...string) template.HTML {
230 data, err := icon(name, classes)
231 if err != nil {
232 log.Printf("icon %s does not exist", name)
233 data, _ = icon("airplay", classes)
234 }
235 return template.HTML(data)
236 },
237 "cssContentHash": CssContentHash,
238 "fileTree": filetree.FileTree,
239 "pathEscape": func(s string) string {
240 return url.PathEscape(s)
241 },
242 "pathUnescape": func(s string) string {
243 u, _ := url.PathUnescape(s)
244 return u
245 },
246
247 "tinyAvatar": func(handle string) string {
248 return p.avatarUri(handle, "tiny")
249 },
250 "fullAvatar": func(handle string) string {
251 return p.avatarUri(handle, "")
252 },
253 "langColor": enry.GetColor,
254 "layoutSide": func() string {
255 return "col-span-1 md:col-span-2 lg:col-span-3"
256 },
257 "layoutCenter": func() string {
258 return "col-span-1 md:col-span-8 lg:col-span-6"
259 },
260 }
261}
262
263func (p *Pages) avatarUri(handle, size string) string {
264 handle = strings.TrimPrefix(handle, "@")
265
266 secret := p.avatar.SharedSecret
267 h := hmac.New(sha256.New, []byte(secret))
268 h.Write([]byte(handle))
269 signature := hex.EncodeToString(h.Sum(nil))
270
271 sizeArg := ""
272 if size != "" {
273 sizeArg = fmt.Sprintf("size=%s", size)
274 }
275 return fmt.Sprintf("%s/%s/%s?%s", p.avatar.Host, signature, handle, sizeArg)
276}
277
278func icon(name string, classes []string) (template.HTML, error) {
279 iconPath := filepath.Join("static", "icons", name)
280
281 if filepath.Ext(name) == "" {
282 iconPath += ".svg"
283 }
284
285 data, err := Files.ReadFile(iconPath)
286 if err != nil {
287 return "", fmt.Errorf("icon %s not found: %w", name, err)
288 }
289
290 // Convert SVG data to string
291 svgStr := string(data)
292
293 svgTagEnd := strings.Index(svgStr, ">")
294 if svgTagEnd == -1 {
295 return "", fmt.Errorf("invalid SVG format for icon %s", name)
296 }
297
298 classTag := ` class="` + strings.Join(classes, " ") + `"`
299
300 modifiedSVG := svgStr[:svgTagEnd] + classTag + svgStr[svgTagEnd:]
301 return template.HTML(modifiedSVG), nil
302}
303
304func durationFmt(duration time.Duration, names [4]string) string {
305 days := int64(duration.Hours() / 24)
306 hours := int64(math.Mod(duration.Hours(), 24))
307 minutes := int64(math.Mod(duration.Minutes(), 60))
308 seconds := int64(math.Mod(duration.Seconds(), 60))
309
310 chunks := []struct {
311 name string
312 amount int64
313 }{
314 {names[0], days},
315 {names[1], hours},
316 {names[2], minutes},
317 {names[3], seconds},
318 }
319
320 parts := []string{}
321
322 for _, chunk := range chunks {
323 if chunk.amount != 0 {
324 parts = append(parts, fmt.Sprintf("%d%s", chunk.amount, chunk.name))
325 }
326 }
327
328 return strings.Join(parts, " ")
329}