when the YouTube link is the sole paragraph. const pOpen = "
" if hasSuffix(out, pOpen) { out = out[:len(out)-len(pOpen)] if hasPrefix(s, "
") { s = s[4:] } } thumbURL := "https://img.youtube.com/vi/" | ytID | "/hqdefault.jpg" // data-invidious-id triggers the Invidious player when clicked. // The fallback href still opens YouTube in a new tab. out = out | "" |
"![](\"")
" |
"" |
"
"
} else if isBandcampURL(href) {
// Bandcamp link: show as a plain link with a "▶ campion" button alongside.
out = out | "" |
"" | escapeHTMLAttr(href) | "" |
" \xe2\x96\xb6 campion" |
"
"
} else if isImageURL(href) {
orig := "\" data-orig-url=\"" | escapeHTMLAttr(href) | "\""
out = out | ""
if pic, ok2 := appSt.authorPics[ev.PubKey]; ok2 && pic != "" {
headerHTML = headerHTML | ""
}
headerHTML = headerHTML | "" | escapeHTML(name) | "
"
capturedEv := ev
for _, elemID := range elemIDs {
el := dom.GetElementById(elemID)
if el == 0 {
continue
}
clearChildren(el)
dom.SetStyle(el, "opacity", "1")
dom.SetStyle(el, "cursor", "pointer")
hdr := dom.CreateElement("div")
dom.SetInnerHTML(hdr, headerHTML)
dom.AppendChild(el, hdr)
body := dom.CreateElement("div")
dom.SetStyle(body, "fontSize", "13px")
dom.SetStyle(body, "lineHeight", "1.4")
dom.SetInnerHTML(body, renderEmbedText(text))
dom.AppendChild(el, body)
thisEl := el
dom.AddEventListener(thisEl, "click", dom.RegisterCallback(func() {
showNoteThread(capturedEv.ID, capturedEv.ID)
}))
}
}
// embedCoordEOSECleanup marks unfound coord embeds as not found.
func embedCoordEOSECleanup(subID string) {
coord, ok := appSt.embedCoordSubIDs[subID]
if !ok {
return
}
delete(appSt.embedCoordSubIDs, subID)
// Check if any other coord sub is still pending for this coord.
for _, other := range appSt.embedCoordSubIDs {
if other == coord {
return
}
}
elemIDs, ok := appSt.embedCoordCBs[coord]
if !ok {
return
}
delete(appSt.embedCoordCBs, coord)
for _, elemID := range elemIDs {
el := dom.GetElementById(elemID)
if el == 0 {
continue
}
dom.SetInnerHTML(el, "" | t("note_not_found") | "")
dom.SetStyle(el, "opacity", "0.5")
}
}
func makeCoordEmbedPlaceholder(coord string, kind uint32, pubkey, d string) (s string) {
appSt.embedCounter++
elemID := "emb-" | itoa(appSt.embedCounter)
appSt.embedCoordCBs[coord] = mxutil.Ensure(appSt.embedCoordCBs[coord], 1)
appSt.embedCoordCBs[coord] = push(appSt.embedCoordCBs[coord], elemID)
label := "Loading..."
if kind == uint32(30023) {
label = "Loading article..."
}
return "" |
"" | label | "
"
}
func makeEmbedPlaceholder(hexID string) (s string) {
appSt.embedCounter++
elemID := "emb-" | itoa(appSt.embedCounter)
appSt.embedCallbacks[hexID] = mxutil.Ensure(appSt.embedCallbacks[hexID], 1)
appSt.embedCallbacks[hexID] = push(appSt.embedCallbacks[hexID], elemID)
return "" |
"Loading note...
"
}
func resolveEmbeds() {
if len(appSt.embedCallbacks) == 0 && len(appSt.embedCoordCBs) == 0 {
return
}
if len(appSt.embedCallbacks) == 0 {
for coord := range appSt.embedCoordCBs {
resolveCoordEmbed(coord)
}
return
}
// Fill any embeds already in cache before requesting.
for hexID := range appSt.embedCallbacks {
if ev, ok := lookupEvent(hexID); ok && ev != nil {
fillEmbed(ev)
}
}
if len(appSt.embedCallbacks) == 0 {
return
}
// Only request IDs we haven't already sent to PROXY.
// If embedRequested is true but the event isn't in cache, clear the
// flag so we re-fetch - the event may have been evicted by rotation.
var ids []string
for hexID := range appSt.embedCallbacks {
if appSt.embedRequested[hexID] {
if _, ok2 := lookupEvent(hexID); ok2 {
continue
}
delete(appSt.embedRequested, hexID)
}
ids = mxutil.Ensure(ids, 1)
ids = push(ids, hexID)
appSt.embedRequested[hexID] = true
}
if len(ids) == 0 {
return
}
filter := "{\"ids\":["
for i, id := range ids {
if i > 0 {
filter = filter | ","
}
filter = filter | jstr(id)
}
filter = filter | "]}"
// REQ checks the local IDB cache.
appSt.embedCounter++
reqID := "emb-r-" | itoa(appSt.embedCounter)
appSt.embedSubIDs[reqID] = ids
routeMsg("[\"REQ\"," | jstr(reqID) | "," | filter | "]")
// PROXY fetches from relays - combine user relays + nevent relay hints.
seen := map[string]bool{}
var urls []string
for _, u := range readRelayURLs() {
if !seen[u] {
seen[u] = true
urls = mxutil.Ensure(urls, 1)
urls = push(urls, u)
}
}
for _, id := range ids {
hints := appSt.embedRelayHints[id]
if len(hints) == 0 {
hints = appSt.embedRelayHintsOld[id]
delete(appSt.embedRelayHintsOld, id)
} else {
delete(appSt.embedRelayHints, id)
}
for _, u := range hints {
if !seen[u] {
seen[u] = true
urls = mxutil.Ensure(urls, 1)
urls = push(urls, u)
}
}
}
if len(urls) > 0 {
proxyID := "emb-p-" | itoa(appSt.embedCounter)
appSt.embedSubIDs[proxyID] = ids
routeMsg(buildProxyMsg(proxyID, filter, urls))
}
// Coord embeds: one PROXY sub per pending coord.
for coord := range appSt.embedCoordCBs {
resolveCoordEmbed(coord)
}
}
// resolveCoordEmbed fires a PROXY fetch for one naddr coordinate.
func resolveCoordEmbed(coord string) {
// Parse "kind:pubkey:d" - split on first two colons.
ci := -1
for i := 0; i < len(coord); i++ {
if coord[i] == ':' {
ci = i
break
}
}
if ci < 0 {
return
}
kindStr := coord[:ci]
rest := coord[ci+1:]
pi := -1
for i := 0; i < len(rest); i++ {
if rest[i] == ':' {
pi = i
break
}
}
if pi < 0 {
return
}
pubkey := rest[:pi]
d := rest[pi+1:]
filter := "{\"kinds\":[" | kindStr | "],\"authors\":[" | jstr(pubkey) | "],\"#d\":[" | jstr(d) | "]}"
// Relay hints from the naddr TLV.
coordRelays := appSt.embedRelayHints[coord]
if len(coordRelays) > 0 {
delete(appSt.embedRelayHints, coord)
} else {
coordRelays = appSt.embedRelayHintsOld[coord]
delete(appSt.embedRelayHintsOld, coord)
}
var urls []string
seen := map[string]bool{}
for _, u := range readRelayURLs() {
if !seen[u] {
seen[u] = true
urls = mxutil.Ensure(urls, 1)
urls = push(urls, u)
}
}
for _, u := range coordRelays {
if !seen[u] {
seen[u] = true
urls = mxutil.Ensure(urls, 1)
urls = push(urls, u)
}
}
appSt.embedCounter++
if len(urls) > 0 {
proxyID := "emb-c-" | itoa(appSt.embedCounter)
appSt.embedCoordSubIDs[proxyID] = coord
routeMsg(buildProxyMsg(proxyID, filter, urls))
}
reqID := "emb-cr-" | itoa(appSt.embedCounter)
appSt.embedCoordSubIDs[reqID] = coord
routeMsg("[\"REQ\"," | jstr(reqID) | "," | filter | "]")
}
func renderEmbedText(s string) (sv string) {
s = markdown.Render(s)
s = convertMediaLinks(s)
return s
}
func fillEmbed(ev *nostr.Event) {
elemIDs, okw1 := appSt.embedCallbacks[ev.ID]
if !okw1 {
return
}
delete(appSt.embedCallbacks, ev.ID)
appSt.embedCacheCount++
if appSt.embedCacheCount > rotateEmbedMax {
rotateEmbedCaches()
}
name := ev.PubKey[:8] | "..."
if n, okv3 := appSt.authorNames[ev.PubKey]; okv3 && n != "" {
name = n
}
headerHTML := ""
if pic, okv2 := appSt.authorPics[ev.PubKey]; okv2 && pic != "" {
headerHTML = headerHTML | ""
}
headerHTML = headerHTML | "" | escapeHTML(name) | "
"
firstNL := -1
for i := 0; i < len(ev.Content); i++ {
if ev.Content[i] == '\n' {
firstNL = i
break
}
}
truncated := firstNL >= 0 && firstNL < len(ev.Content)-1
text := ev.Content
if truncated {
text = text[:firstNL]
}
embedEvID := ev.ID
embedRootID := getRootID(ev)
if embedRootID == "" {
embedRootID = embedEvID
}
for _, elemID := range elemIDs {
el := dom.GetElementById(elemID)
if el == 0 {
continue
}
clearChildren(el)
dom.SetStyle(el, "opacity", "1")
dom.SetStyle(el, "cursor", "pointer")
hdr := dom.CreateElement("div")
dom.SetInnerHTML(hdr, headerHTML)
dom.AppendChild(el, hdr)
body := dom.CreateElement("div")
dom.SetStyle(body, "fontSize", "13px")
dom.SetStyle(body, "lineHeight", "1.4")
dom.SetInnerHTML(body, renderEmbedText(text))
dom.AppendChild(el, body)
thisEl := el
dom.AddEventListener(thisEl, "click", dom.RegisterCallback(func() {
showNoteThread(embedRootID, embedEvID)
}))
}
if _, okv1 := appSt.authorNames[ev.PubKey]; !okv1 {
if !lookupFetchedK0(ev.PubKey) {
profile.Send(`["P_RESOLVE",` | jstr(ev.PubKey) | `]`)
}
}
}
// jsonGetNum extracts a numeric value for a given key from a JSON object.
func jsonGetNum(s, key string) (n int64) {
needle := "\"" | key | "\":"
idx := strIndex(s, needle)
if idx < 0 {
return 0
}
idx += len(needle)
// Skip whitespace.
for idx < len(s) && (s[idx] == ' ' || s[idx] == '\t') {
idx++
}
if idx >= len(s) {
return 0
}
for idx < len(s) && s[idx] >= '0' && s[idx] <= '9' {
n = n*10 + int64(s[idx]-'0')
idx++
}
return n
}
// jsonEsc escapes a string for embedding in a JSON value.
// defaultServiceURL derives a service subdomain URL from the current page origin.
// wss://smesh.lol + "invidious" → https://invidious.smesh.lol
func defaultServiceURL(sub string) (s string) {
local := localRelayURL()
var host string
if len(local) >= 6 && local[:6] == "wss://" {
host = local[6:]
} else if len(local) >= 5 && local[:5] == "ws://" {
host = local[5:]
} else {
return ""
}
// Only derive for non-localhost origins.
if host == "localhost" || len(host) > 9 && host[:9] == "127.0.0.1" {
return ""
}
return "https://" | sub | "." | host
}
// defaultBlossomURL derives the blossom server URL from the current page origin.
// wss://smesh.lol → https://smesh.lol/blossom
// --- Search ---
func activateSearchBar(btn dom.Element) {
if !appSt.searchBarActive {
appSt.searchReturnPage = appSt.activePage // remember where to return on manual close
}
appSt.searchBarActive = true
dom.SetStyle(btn, "background", "var(--accent)")
dom.SetStyle(btn, "color", "#fff")
dom.SetStyle(btn, "borderRadius", "4px")
dom.SetStyle(appSt.feedSelectEl, "display", "none")
dom.SetStyle(appSt.pageTitleEl, "display", "none")
dom.SetStyle(appSt.notifBarGroup, "display", "none")
dom.SetStyle(appSt.topBarRight, "display", "none")
dom.SetStyle(appSt.searchInputEl, "display", "block")
dom.SetStyle(appSt.searchInputEl, "flex", "1")
dom.SetStyle(appSt.searchSubmitBtn, "display", "block")
dom.Focus(appSt.searchInputEl)
}
// deactivateSearchBar restores the bar appearance only.
// Callers are responsible for any page navigation.
func deactivateSearchBar(btn dom.Element) {
appSt.searchBarActive = false
dom.SetStyle(btn, "background", "transparent")
dom.SetStyle(btn, "color", "var(--muted)")
dom.SetStyle(btn, "borderRadius", "4px")
dom.SetStyle(appSt.topBarRight, "display", "flex")
dom.SetStyle(appSt.searchInputEl, "display", "none")
dom.SetStyle(appSt.searchInputEl, "flex", "")
dom.SetStyle(appSt.searchSubmitBtn, "display", "none")
}
// closeSearch is called when the user explicitly closes search (clicks 🔍 again).
// Deactivates the bar and returns to the previous page.
func closeSearch(btn dom.Element) {
deactivateSearchBar(btn)
ret := appSt.searchReturnPage
if ret == "" || ret == "search" {
ret = "feed"
}
appSt.searchReturnPage = ""
appSt.activePage = "" // force switchPage to run
switchPage(ret)
}
// executeSearch submits a search query: #tag searches by t-tag, other text
// runs NIP-50 full-text search. Switches to the search page and subscribes.
func executeSearch(q string) {
q = trimStr(q)
if q == "" {
return
}
appSt.searchCurrentQ = q
appSt.searchResults = []*nostr.Event{:0}
appSt.searchSeen = map[string]bool{}
switchPage("search")
// URL reflects the current query.
dom.ReplaceState("/search?q=" | dom.EncodeURIComponent(q))
// Build filter and choose target relays.
var filter string
var searchRelayList []string
if len(q) > 1 && q[0] == '#' {
// Tag search works on all relays; cap at 5 to limit event burst.
tag := q[1:]
filter = "{\"kinds\":[1,1111],\"#t\":[" | jstr(tag) | "],\"limit\":10}"
searchRelayList = appSt.relayURLs
if len(searchRelayList) > 5 {
searchRelayList = searchRelayList[:5]
}
} else {
// Full-text search: only NIP-50 relays, capped at 3 to bound
// the event burst through the relay-proxy WASM.
filter = "{\"kinds\":[1,1111],\"search\":" | jstr(q) | ",\"limit\":10}"
searchRelayList = nip50Relays()
if len(searchRelayList) > 3 {
searchRelayList = searchRelayList[:3]
}
}
// Build filter bar (sticky, above results) then show loading.
clearChildren(appSt.searchContainer)
buildSearchFilterBar()
loading := dom.CreateElement("div")
dom.SetStyle(loading, "color", "var(--muted)")
dom.SetStyle(loading, "fontSize", "14px")
dom.SetStyle(loading, "padding", "16px")
dom.SetStyle(loading, "fontFamily", "'Fira Code', monospace")
if len(searchRelayList) == 0 {
dom.SetTextContent(loading, "no full-text search relays available \xe2\x80\x94 try #hashtag")
dom.AppendChild(appSt.searchContainer, loading)
return
}
relayWord := "relays"
if len(searchRelayList) == 1 {
relayWord = "relay"
}
dom.SetTextContent(loading, "searching " | itoa(len(searchRelayList)) | " " | relayWord | "...")
dom.AppendChild(appSt.searchContainer, loading)
routeMsg("[\"CLOSE\",\"search\"]")
routeMsg(buildProxyMsg("search", filter, searchRelayList))
}
func buildSearchFilterBar() {
// Rebuild the filter bar (recreate buttons so state labels are fresh).
if appSt.searchFilterBarEl != 0 {
dom.RemoveChild(appSt.searchPage, appSt.searchFilterBarEl)
}
bar := dom.CreateElement("div")
appSt.searchFilterBarEl = bar
dom.SetAttribute(bar, "class", "search-filter-bar")
dom.SetStyle(bar, "display", "flex")
dom.SetStyle(bar, "gap", "8px")
dom.SetStyle(bar, "padding", "8px 12px")
dom.SetStyle(bar, "borderBottom", "1px solid var(--border)")
dom.SetStyle(bar, "flexWrap", "wrap")
dom.SetStyle(bar, "alignItems", "center")
dom.SetStyle(bar, "position", "sticky")
dom.SetStyle(bar, "top", "0")
dom.SetStyle(bar, "background", "var(--bg2)")
dom.SetStyle(bar, "zIndex", "10")
followsBtn := searchFilterBtn("follows only", appSt.searchFollowsOnly)
dom.AddEventListener(followsBtn, "click", dom.RegisterCallback(func() {
appSt.searchFollowsOnly = !appSt.searchFollowsOnly
applySearchFilterBtn(followsBtn, appSt.searchFollowsOnly)
renderSearchResults()
}))
dom.AppendChild(bar, followsBtn)
sortBtn := searchFilterBtn("newest first", appSt.searchSortDesc)
dom.SetAttribute(sortBtn, "data-sort", "1")
dom.AddEventListener(sortBtn, "click", dom.RegisterCallback(func() {
appSt.searchSortDesc = !appSt.searchSortDesc
if appSt.searchSortDesc {
dom.SetTextContent(sortBtn, "newest first")
} else {
dom.SetTextContent(sortBtn, "oldest first")
}
applySearchFilterBtn(sortBtn, true)
renderSearchResults()
}))
dom.AppendChild(bar, sortBtn)
nsfwBtn := searchFilterBtn("nsfw", appSt.searchNSFW)
dom.AddEventListener(nsfwBtn, "click", dom.RegisterCallback(func() {
appSt.searchNSFW = !appSt.searchNSFW
applySearchFilterBtn(nsfwBtn, appSt.searchNSFW)
renderSearchResults()
}))
dom.AppendChild(bar, nsfwBtn)
// Insert filter bar BEFORE searchContainer in searchPage.
dom.InsertBefore(appSt.searchPage, bar, appSt.searchContainer)
}
func searchFilterBtn(label string, active bool) (e dom.Element) {
btn := dom.CreateElement("button")
dom.SetTextContent(btn, label)
dom.SetStyle(btn, "padding", "4px 12px")
dom.SetStyle(btn, "borderRadius", "4px")
dom.SetStyle(btn, "fontSize", "12px")
dom.SetStyle(btn, "cursor", "pointer")
dom.SetStyle(btn, "fontFamily", "'Fira Code', monospace")
applySearchFilterBtn(btn, active)
return btn
}
func applySearchFilterBtn(btn dom.Element, active bool) {
if active {
dom.SetStyle(btn, "background", "var(--accent)")
dom.SetStyle(btn, "color", "#fff")
dom.SetStyle(btn, "border", "none")
} else {
dom.SetStyle(btn, "background", "transparent")
dom.SetStyle(btn, "color", "var(--muted)")
dom.SetStyle(btn, "border", "1px solid var(--border)")
}
}
func handleSearchEvent(ev *nostr.Event) {
if ev.Kind != 1 && ev.Kind != 1111 {
return
}
if appSt.searchSeen[ev.ID] {
return
}
appSt.searchSeen[ev.ID] = true
if isMuted(ev.PubKey) {
return
}
if looksLikeJSONSpam(ev.Content) {
return
}
appSt.searchResults = mxutil.Ensure(appSt.searchResults, 1)
appSt.searchResults = push(appSt.searchResults, ev)
setEvent(ev.ID, ev)
}
const searchPageSize = 25 // results rendered per page / scroll load
// filteredSearchResults returns searchResults with current filters applied and sorted.
func filteredSearchResults() (ss []*nostr.Event) {
var filtered []*nostr.Event
for _, ev := range appSt.searchResults {
if appSt.searchFollowsOnly && !isFollowing(ev.PubKey) {
continue
}
if !appSt.searchNSFW {
if nostr.TagsGetFirst(ev.Tags, []byte("content-warning")) != nil {
continue
}
}
filtered = mxutil.Ensure(filtered, 1)
filtered = push(filtered, ev)
}
for i := 0; i < len(filtered); i++ {
for j := i + 1; j < len(filtered); j++ {
var swap bool
if appSt.searchSortDesc {
swap = filtered[j].CreatedAt > filtered[i].CreatedAt
} else {
swap = filtered[j].CreatedAt < filtered[i].CreatedAt
}
if swap {
filtered[i], filtered[j] = filtered[j], filtered[i]
}
}
}
return filtered
}
// renderSearchResults rebuilds the result list from scratch, rendering only
// the first searchPageSize results. Remaining results load on scroll.
func renderSearchResults() {
appSt.searchRendered = 0
clearChildren(appSt.searchContainer)
filtered := filteredSearchResults()
if len(filtered) == 0 {
empty := dom.CreateElement("div")
dom.SetTextContent(empty, "no results")
dom.SetStyle(empty, "color", "var(--muted)")
dom.SetStyle(empty, "fontSize", "14px")
dom.SetStyle(empty, "padding", "16px")
dom.SetStyle(empty, "fontFamily", "'Fira Code', monospace")
dom.AppendChild(appSt.searchContainer, empty)
return
}
end := len(filtered)
if end > searchPageSize {
end = searchPageSize
}
for i := 0; i < end; i++ {
dom.AppendChild(appSt.searchContainer, renderSearchResult(filtered[i]))
}
appSt.searchRendered = end
}
// appendSearchResults renders the next batch of results (called on scroll).
func appendSearchResults() {
filtered := filteredSearchResults()
if appSt.searchRendered >= len(filtered) {
return
}
end := appSt.searchRendered + searchPageSize
if end > len(filtered) {
end = len(filtered)
}
for i := appSt.searchRendered; i < end; i++ {
dom.AppendChild(appSt.searchContainer, renderSearchResult(filtered[i]))
}
appSt.searchRendered = end
}
func renderSearchResult(ev *nostr.Event) (e dom.Element) {
row := dom.CreateElement("div")
dom.SetStyle(row, "display", "flex")
dom.SetStyle(row, "flexDirection", "column")
dom.SetStyle(row, "padding", "10px 12px")
dom.SetStyle(row, "borderBottom", "1px solid var(--border)")
dom.SetStyle(row, "cursor", "pointer")
dom.SetStyle(row, "gap", "4px")
// Header: avatar + name + timestamp.
header := dom.CreateElement("div")
dom.SetStyle(header, "display", "flex")
dom.SetStyle(header, "alignItems", "center")
dom.SetStyle(header, "gap", "8px")
avatar := dom.CreateElement("img")
dom.SetAttribute(avatar, "width", "20")
dom.SetAttribute(avatar, "height", "20")
dom.SetAttribute(avatar, "referrerpolicy", "no-referrer")
dom.SetStyle(avatar, "borderRadius", "50%")
dom.SetStyle(avatar, "objectFit", "cover")
dom.SetStyle(avatar, "flexShrink", "0")
pk := ev.PubKey
if pic, ok := appSt.authorPics[pk]; ok && pic != "" {
setMediaSrc(avatar, pic)
dom.SetAttribute(avatar, "onerror", "this.style.display='none'")
} else {
dom.SetStyle(avatar, "display", "none")
}
dom.AppendChild(header, avatar)
name := dom.CreateElement("span")
dom.SetStyle(name, "fontSize", "14px")
dom.SetStyle(name, "fontWeight", "bold")
dom.SetStyle(name, "color", "var(--fg)")
dom.SetStyle(name, "flex", "1")
dom.SetStyle(name, "overflow", "hidden")
dom.SetStyle(name, "textOverflow", "ellipsis")
dom.SetStyle(name, "whiteSpace", "nowrap")
if n, ok := appSt.authorNames[pk]; ok && n != "" {
dom.SetTextContent(name, n)
} else {
npub := helpers.EncodeNpub(helpers.HexDecode(pk))
if len(npub) > 20 {
dom.SetTextContent(name, npub[:12] | "..." | npub[len(npub)-4:])
}
}
dom.AppendChild(header, name)
ts := dom.CreateElement("span")
dom.SetTextContent(ts, formatTime(ev.CreatedAt))
dom.SetStyle(ts, "fontSize", "11px")
dom.SetStyle(ts, "color", "var(--muted)")
dom.SetStyle(ts, "flexShrink", "0")
dom.AppendChild(header, ts)
dom.AppendChild(row, header)
// Two-line content preview (plain text, no markdown rendering).
preview := dom.CreateElement("div")
dom.SetStyle(preview, "fontSize", "13px")
dom.SetStyle(preview, "color", "var(--fg)")
dom.SetStyle(preview, "lineHeight", "1.4")
dom.SetStyle(preview, "overflow", "hidden")
dom.SetStyle(preview, "display", "-webkit-box")
dom.SetStyle(preview, "-webkit-line-clamp", "2")
dom.SetStyle(preview, "-webkit-box-orient", "vertical")
dom.SetStyle(preview, "wordBreak", "break-word")
content := ev.Content
if len(content) > 300 {
content = content[:300] | "..."
}
dom.SetTextContent(preview, content)
dom.AppendChild(row, preview)
// Click opens thread.
evID := ev.ID
evRootID := getRootID(ev)
if evRootID == "" {
evRootID = evID
}
dom.AddEventListener(row, "click", dom.RegisterCallback(func() {
showNoteThread(evRootID, evID)
}))
if _, cached := appSt.authorNames[pk]; !cached {
appSt.pendingNotes[pk] = mxutil.Ensure(appSt.pendingNotes[pk], 1)
appSt.pendingNotes[pk] = push(appSt.pendingNotes[pk], header)
if !lookupFetchedK0(pk) {
profile.Send(`["P_RESOLVE",` | jstr(pk) | `]`)
}
}
return row
}
// extractHashtags replaces #tag tokens with placeholders so markdown-it
// preserves them. Restored after rendering as clickable search spans.
func extractHashtags(s string, slots *[]string) (sv string) {
out := ""
i := 0
for i < len(s) {
if s[i] != '#' {
out = out | string([]byte{s[i]})
i++
continue
}
// Must be preceded by whitespace/start/newline to be a hashtag.
if i > 0 {
prev := s[i-1]
if prev != ' ' && prev != '\n' && prev != '\t' && prev != '\r' {
out = out | "#"
i++
continue
}
}
// Collect tag characters: letters, digits, underscores.
j := i + 1
for j < len(s) {
c := s[j]
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' {
j++
} else {
break
}
}
if j == i+1 {
// No tag characters after #.
out = out | "#"
i++
continue
}
tag := s[i+1 : j]
idx := len(*slots)
span := "#" | tag | ""
*slots = push(*slots, span)
out = out | "\x02HASH" | itoa(idx) | "\x02"
i = j
}
return out
}
// attachHashtagLinks wires click handlers on [data-search-tag] spans.
func attachHashtagLinks(rootp2 dom.Element) {
el := dom.QuerySelectorFrom(rootp2, "[data-search-tag]")
for el != 0 {
tag := dom.GetAttribute(el, "data-search-tag")
dom.RemoveAttribute(el, "data-search-tag")
if tag != "" {
capturedTag := tag
dom.AddEventListener(el, "click", dom.RegisterCallback(func() {
dom.SetProperty(appSt.searchInputEl, "value", "#" | capturedTag)
executeSearch("#" | capturedTag)
}))
}
el = dom.QuerySelectorFrom(rootp2, "[data-search-tag]")
}
}
// trimStr trims leading and trailing whitespace from s.
func trimStr(s string) (sv string) {
start := 0
for start < len(s) && (s[start] == ' ' || s[start] == '\t' || s[start] == '\n' || s[start] == '\r') {
start++
}
end := len(s)
for end > start && (s[end-1] == ' ' || s[end-1] == '\t' || s[end-1] == '\n' || s[end-1] == '\r') {
end--
}
return s[start:end]
}
// nip50Relays returns the subset of configured relay URLs that advertise NIP-50
// (full-text search) in their NIP-11 document.
func nip50Relays() (ss []string) {
var out []string
for i, url := range appSt.relayURLs {
if i < len(appSt.relayCaps) && hasNIP(appSt.relayCaps[i].supportedNIPs, 50) {
out = mxutil.Ensure(out, 1)
out = push(out, url)
}
}
return out
}
// looksLikeJSONSpam returns true if the content is a raw JSON object or array
// larger than 200 bytes. Catches protocol spam posted as kind 1 notes.
func looksLikeJSONSpam(content string) (ok bool) {
i := 0
for i < len(content) {
c := content[i]
if c == ' ' || c == '\n' || c == '\r' || c == '\t' {
i++
} else {
break
}
}
if i >= len(content) {
return false
}
open := content[i]
if open != '{' && open != '[' {
return false
}
// Scan for matching close bracket (up to 2000 chars).
limit := len(content)
if limit > 2000 {
limit = 2000
}
depth := 0
inStr := false
j := i
for j < limit {
c := content[j]
if inStr {
if c == '\\' && j+1 < limit {
j += 2
continue
}
if c == '"' {
inStr = false
}
} else {
if c == '"' {
inStr = true
} else if c == '{' || c == '[' {
depth++
} else if c == '}' || c == ']' {
depth--
if depth == 0 {
return j-i+1 > 200
}
}
}
j++
}
return false
}
func defaultBlossomURL() (s string) {
local := localRelayURL()
var base string
if len(local) >= 6 && local[:6] == "wss://" {
base = "https://" | local[6:]
} else if len(local) >= 5 && local[:5] == "ws://" {
base = "http://" | local[5:]
} else {
return ""
}
return base | "/blossom"
}
// parseJSONStringArray parses a JSON array of strings like ["a","b","c"].
func parseJSONStringArray(s string) (ss []string) {
var out []string
i := 0
for i < len(s) && s[i] != '[' {
i++
}
if i >= len(s) {
return nil
}
i++ // skip '['
for i < len(s) {
for i < len(s) && (s[i] == ' ' || s[i] == ',' || s[i] == '\n') {
i++
}
if i >= len(s) || s[i] == ']' {
break
}
if s[i] != '"' {
break
}
i++
start := i
for i < len(s) && s[i] != '"' {
if s[i] == '\\' {
i++
}
i++
}
if i <= len(s) {
out = mxutil.Ensure(out, 1)
out = push(out, s[start:i])
}
if i < len(s) {
i++ // skip closing '"'
}
}
return out
}
func jsonEsc(s string) (sv string) {
s = strReplace(s, "\\", "\\\\")
s = strReplace(s, "\"", "\\\"")
s = strReplace(s, "\n", "\\n")
s = strReplace(s, "\r", "\\r")
s = strReplace(s, "\t", "\\t")
return s
}
// strIndex finds substring in string. Returns -1 if not found.
func strIndex(s, sub string) (n int32) {
sl := len(sub)
for i := 0; i <= len(s)-sl; i++ {
if s[i:i+sl] == sub {
return i
}
}
return -1
}
// --- Helpers ---
// normalizeURL strips trailing slashes and lowercases the scheme+host.
func normalizeURL(u string) (s string) {
for len(u) > 0 && u[len(u)-1] == '/' {
u = u[:len(u)-1]
}
// Lowercase scheme and host (before first / after ://).
if len(u) > 6 && u[:6] == "wss://" {
rest := u[6:]
slash := strIndex(rest, "/")
if slash < 0 {
return u[:6] | toLower(rest)
}
return u[:6] | toLower(rest[:slash]) | rest[slash:]
}
if len(u) > 5 && u[:5] == "ws://" {
rest := u[5:]
slash := strIndex(rest, "/")
if slash < 0 {
return u[:5] | toLower(rest)
}
return u[:5] | toLower(rest[:slash]) | rest[slash:]
}
return u
}
func toLower(s string) (sv string) {
b := []byte{:len(s)}
for i := 0; i < len(s); i++ {
c := s[i]
if c >= 'A' && c <= 'Z' {
c += 32
}
b[i] = c
}
return string(b)
}
func showQRModal(npubStr string) {
svg := qrSVG(npubStr, 5)
if svg == "" {
return
}
scrim := dom.CreateElement("div")
dom.SetStyle(scrim, "position", "fixed")
dom.SetStyle(scrim, "inset", "0")
dom.SetStyle(scrim, "background", "rgba(0,0,0,0.6)")
dom.SetStyle(scrim, "display", "flex")
dom.SetStyle(scrim, "alignItems", "center")
dom.SetStyle(scrim, "justifyContent", "center")
dom.SetStyle(scrim, "zIndex", "9999")
dom.SetStyle(scrim, "cursor", "pointer")
dom.AddEventListener(scrim, "click", dom.RegisterCallback(func() {
dom.RemoveChild(dom.Body(), scrim)
}))
card := dom.CreateElement("div")
dom.SetStyle(card, "background", "white")
dom.SetStyle(card, "borderRadius", "16px")
dom.SetStyle(card, "padding", "24px")
dom.SetStyle(card, "display", "flex")
dom.SetStyle(card, "flexDirection", "column")
dom.SetStyle(card, "alignItems", "center")
dom.SetStyle(card, "cursor", "default")
dom.SetAttribute(card, "onclick", "event.stopPropagation()")
dom.SetInnerHTML(card, svg)
dom.AppendChild(scrim, card)
dom.AppendChild(dom.Body(), scrim)
}
func clearChildren(el dom.Element) {
dom.ReleaseChildren(el)
dom.SetInnerHTML(el, "")
}
func removeChildrenByPK(parent dom.Element, pk string) {
if parent == 0 {
return
}
var toRemove []dom.Element
child := dom.FirstElementChild(parent)
for child != 0 {
if dom.GetProperty(child, "musiquayPK") == pk {
toRemove = mxutil.Ensure(toRemove, 1)
toRemove = push(toRemove, child)
}
child = dom.NextSibling(child)
}
for _, el := range toRemove {
dom.RemoveChild(parent, el)
}
}
func itoa(n int32) (s string) {
if n == 0 {
return "0"
}
neg := false
if n < 0 {
neg = true
n = -n
}
var b [20]byte
i := len(b)
for n > 0 {
i--
b[i] = byte('0' + n%10)
n /= 10
}
if neg {
i--
b[i] = '-'
}
return string(b[i:])
}