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