mirrors/nitter
Watch
1
0
Fork
You've already forked nitter
 0
mirror of https://github.com/zedeus/nitter synced 2026-10-26 20:53:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'zedeus:master' into master

Browse source
This commit is contained in:
Salastil 2026-08-14 22:57:40 -04:00 • committed by GitHub
commit 162a15f7a8
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
40 changed files with 1552 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

57
src/api.nim
View file

@ -35,8 +35,8 @@ proc userTweetsUrl(id: string; cursor: string): ApiReq =
proc userTweetsAndRepliesUrl(id: string; cursor: string): ApiReq =
return apiReq(graphUserTweetsAndRepliesV2, restIdVars % [id, cursor, "20"], userTweetsFieldToggles, skipTid=true)
proc tweetDetailUrl(id: string; cursor: string): ApiReq =
return apiReq(graphTweet, tweetVars % [id, cursor])
proc tweetDetailUrl(id, cursor: string; mode = Relevance): ApiReq =
return apiReq(graphTweet, tweetVars % [id, cursor, $mode])
# let cookieVars = tweetDetailVars % [id, cursor]
# result = ApiReq(
# cookie: apiUrl(graphTweetDetail, cookieVars, tweetDetailFieldToggles),
@ -230,21 +230,28 @@ proc getGraphTweetResult*(id: string): Future[Tweet] {.async.} =
js = await fetch(url)
result = parseGraphTweetResult(js)
proc getGraphTweet(id: string; after=""): Future[Conversation] {.async.} =
proc getTweetByRestId*(id: string): Future[Tweet] {.async.} =
if id.len == 0: return
let
url = apiReq(graphTweetResultByRestId, tweetByRestIdVars % id, articleFieldToggles)
js = await fetch(url)
result = parseTweetByRestId(js)
proc getGraphTweet(id: string; after=""; mode = Relevance): Future[Conversation] {.async.} =
if id.len == 0: return
let
cursor = cursorParam(after)
js = await fetch(tweetDetailUrl(id, cursor))
js = await fetch(tweetDetailUrl(id, cursor, mode))
result = parseGraphConversation(js, id)
proc getReplies*(id, after: string): Future[Result[Chain]] {.async.} =
result = (await getGraphTweet(id, after)).replies
proc getReplies*(id, after: string; mode = Relevance): Future[Result[Chain]] {.async.} =
result = (await getGraphTweet(id, after, mode)).replies
result.beginning = after.len == 0
proc getTweet*(id: string; after=""): Future[Conversation] {.async.} =
result = await getGraphTweet(id)
proc getTweet*(id: string; after=""; mode = Relevance): Future[Conversation] {.async.} =
result = await getGraphTweet(id, mode=mode)
if after.len > 0:
result.replies = await getReplies(id, after)
result.replies = await getReplies(id, after, mode)
proc getGraphEditHistory*(id: string): Future[EditHistory] {.async.} =
if id.len == 0: return
@ -263,12 +270,19 @@ proc getGraphTweetSearch*(query: Query; after=""): Future[Timeline] {.async.} =
if q.len == 0 or q == emptyQuery:
return Timeline(query: query, beginning: true)
let product =
case query.kind
of top: "Top"
# profile media feeds (RSS, multi-user timelines) must stay chronological
of media: (if query.fromUser.len == 0: "Media" else: "Latest")
else: "Latest"
var
variables = %*{
"rawQuery": q,
"count": 20,
"querySource": "typed_query",
"product": "Latest",
"product": product,
"withGrokTranslatedBio":true,
"withQuickPromoteEligibilityTweetFields":false
}
@ -283,33 +297,40 @@ proc getGraphTweetSearch*(query: Query; after=""): Future[Timeline] {.async.} =
# when no more items are available the API just returns the last page in
# full. this detects that and clears the page instead.
if after.len > 0 and result.bottom.len > 0 and maxId.len == 0 and
after[0..<64] == result.bottom[0..<64]:
let prefix = min(64, min(after.len, result.bottom.len))
if prefix > 0 and maxId.len == 0 and
after[0..<prefix] == result.bottom[0..<prefix]:
result.content.setLen(0)
proc getGraphUserSearch*(query: Query; after=""): Future[Result[User]] {.async.} =
proc getGraphProductSearch[T](query: Query; product: string;
after=""): Future[Result[T]] {.async.} =
if query.text.len == 0:
return Result[User](query: query, beginning: true)
return Result[T](query: query, beginning: true)
var
variables = %*{
"rawQuery": query.text,
"count": 20,
"querySource": "typed_query",
"product": "People",
"product": product,
"withGrokTranslatedBio":true,
"withQuickPromoteEligibilityTweetFields":false
}
if after.len > 0:
variables["cursor"] = % after
result.beginning = false
let
let
url = apiReq(graphSearchTimeline, $variables)
js = await fetch(url)
result = parseGraphSearch[User](js, after)
result = parseGraphSearch[T](js, after)
result.query = query
proc getGraphUserSearch*(query: Query; after=""): Future[Result[User]] =
getGraphProductSearch[User](query, "People", after)
proc getGraphListSearch*(query: Query; after=""): Future[Result[ListSearchResult]] =
getGraphProductSearch[ListSearchResult](query, "Lists", after)
proc getPhotoRail*(id: string): Future[PhotoRail] {.async.} =
if id.len == 0: return
let js = await fetch(mediaUrl(id, "", 30))

11
src/consts.nim
View file

@ -35,7 +35,7 @@ const
graphCommunityModerators* = "GBMT3GOWy5dYsYC4XJfvow/moderatorsSliceTimeline_Query"
graphCommunityHashtags* = "40DyrMxfCknGuZwE-keW_Q/CommunityHashtagsTimeline"
graphTweetResultByRestId* = "qtXMy1p5Y62uCskc_NUPJw/TweetResultByRestId"
graphTweetResultByRestId* = "4hhGRbehkcUVTKf8n0f0xw/TweetResultByRestId"
graphTweetResultsByRestIds* = "Sc9EUQTZNEH-wzegn-nHvQ/TweetResultsByRestIds"
graphBroadcast* = "FJLCzpXCLPM1jUZqmM7oEA/BroadcastQuery"
@ -92,6 +92,7 @@ const
tweetVars* = """{
"postId": "$1",
$2
"ranking_mode": "$3",
"includeHasBirdwatchNotes": false,
"includePromotedContent": false,
"withBirdwatchNotes": true,
@ -165,6 +166,14 @@ const
articleFieldToggles* = """{"withArticleRichContentState":true,"withArticlePlainText":false,"withArticleSummaryText":true,"withArticleVoiceOver":true}"""
tweetByRestIdVars* = """{
"tweetId": "$1",
"includePromotedContent": false,
"withBirdwatchNotes": false,
"withVoice": false,
"withCommunity": false
}""".replace(" ", "").replace("\n", "")
communityTweetsVars* = """{
"communityId": "$1", $2
"count": 20,

4
src/nitter.nim
View file

@ -81,8 +81,8 @@ routes:
if request.path.len == 0 or request.path[0] != '/':
halt Http400
# skip all file URLs
cond "." notin request.path
# skip all file URLs (except Twitter widget compatibility)
cond "." notin request.path or request.path == "/embed/Tweet.html"
applyUrlPrefs()
get "/":

125
src/parser.nim
View file

@ -206,6 +206,20 @@ proc parseGraphCommunity*(js: JsonNode): Community =
if tag.len > 0:
result.hashtags.add tag
proc parseListObject(js: JsonNode; owner: User): List =
List(
id: js{"id_str"}.getStr,
name: js{"name"}.getStr,
username: owner.username,
userId: owner.id,
description: js{"description"}.getStr,
members: js{"member_count"}.getInt,
banner: select(
js{"custom_banner_media", "media_info", "original_img_url"},
js{"default_banner_media", "media_info", "original_img_url"}
).getImageStr
)
proc parseGraphList*(js: JsonNode): List =
if js.isNull: return
@ -215,15 +229,17 @@ proc parseGraphList*(js: JsonNode): List =
if list.isNull:
return
result = List(
id: list{"id_str"}.getStr,
name: list{"name"}.getStr,
username: list{"user_results", "result", "legacy", "screen_name"}.getStr,
userId: list{"user_results", "result", "rest_id"}.getStr,
description: list{"description"}.getStr,
members: list{"member_count"}.getInt,
banner: list{"custom_banner_media", "media_info", "original_img_url"}.getImageStr
result = parseListObject(list, parseGraphUser(list))
proc parseGraphSearchList(js: JsonNode): ListSearchResult =
let owner = parseGraphUser(js)
result = ListSearchResult(
list: parseListObject(js, owner),
owner: owner,
followersContext: js{"followers_context"}.getStr
)
for url in js{"facepile_urls"}:
result.facepiles.add url.getStr
proc parsePoll(js: JsonNode): Poll =
let vals = js{"binding_values"}
@ -694,10 +710,26 @@ proc parseGraphTweet*(js: JsonNode): Tweet =
with birdwatch, js{"birdwatch_pivot"}:
result.note = parseCommunityNote(birdwatch)
proc getConvSection(js: JsonNode): string =
let details = select(
js{"item", "client_event_info", "details"},
js{"item", "clientEventInfo", "details"}
)
select(
details{"conversation_details", "conversation_section"},
details{"conversationDetails", "conversationSection"}
).getStr
proc parseGraphThread(js: JsonNode): tuple[thread: Chain; self: bool] =
var checkedSection = false
for t in ? js{"content", "items"}:
let entryId = t.getEntryId
if "tweet-" in entryId and "promoted" notin entryId:
if not checkedSection:
checkedSection = true
if getConvSection(t) == "RelatedTweet":
result.thread.related = true
let tweet = t.getTweetResult("item")
if tweet.notNull:
result.thread.content.add parseGraphTweet(tweet)
@ -719,6 +751,10 @@ proc parseGraphTweetResult*(js: JsonNode): Tweet =
with tweet, js{"data", "tweet_result", "result"}:
result = parseGraphTweet(tweet)
proc parseTweetByRestId*(js: JsonNode): Tweet =
with tweet, js{"data", "tweetResult", "result"}:
result = parseGraphTweet(tweet)
proc parseGraphTweetResults*(js: JsonNode): seq[Tweet] =
let results = js{"data", "tweetResult"}
if results.kind != JArray: return
@ -758,7 +794,8 @@ proc parseGraphConversation*(js: JsonNode; tweetId: string): Conversation =
result.before.content.add tweet
elif not entryId.endsWith(tweetId):
result.before.content.add Tweet(id: entryId.getId)
elif entryId.startsWith("conversationthread"):
elif entryId.startsWith("conversationthread") or
entryId.startsWith("tweetdetailrelatedtweets"):
let (thread, self) = parseGraphThread(e)
if self:
result.after = thread
@ -808,20 +845,31 @@ proc parseGraphEditHistory*(js: JsonNode; tweetId: string): EditHistory =
if tweetResult.notNull:
result.history.add parseGraphTweet(tweetResult)
iterator extractTweetsFromModuleItems(items: JsonNode): Tweet =
for item in items:
with tweetResult, item.getTweetResult("item"):
let tweet = parseGraphTweet(tweetResult)
if not tweet.available:
tweet.id = item.getEntryId.getId
yield tweet
iterator extractListsFromItems(items: JsonNode): ListSearchResult =
for item in items:
with listJs, item{"item", "itemContent", "list"}:
let r = parseGraphSearchList(listJs)
if r.list.id.len > 0:
yield r
proc extractTweetsFromEntry*(e: JsonNode): seq[Tweet] =
with tweetResult, getTweetResult(e):
var tweet = parseGraphTweet(tweetResult)
let tweet = parseGraphTweet(tweetResult)
if not tweet.available:
tweet.id = e.getEntryId.getId
result.add tweet
return
for item in e{"content", "items"}:
with tweetResult, item.getTweetResult("item"):
var tweet = parseGraphTweet(tweetResult)
if not tweet.available:
tweet.id = item.getEntryId.getId
result.add tweet
for tweet in extractTweetsFromModuleItems(e{"content", "items"}):
result.add tweet
proc parseGraphTimeline*(js: JsonNode; after=""): Profile =
result = Profile(tweets: Timeline(beginning: after.len == 0))
@ -836,12 +884,8 @@ proc parseGraphTimeline*(js: JsonNode; after=""): Profile =
for i in instructions:
if i{"moduleItems"}.notNull:
for item in i{"moduleItems"}:
with tweetResult, item.getTweetResult("item"):
let tweet = parseGraphTweet(tweetResult)
if not tweet.available:
tweet.id = item.getEntryId.getId
result.tweets.content.add tweet
for tweet in extractTweetsFromModuleItems(i{"moduleItems"}):
result.tweets.content.add tweet
continue
if i{"entries"}.notNull:
@ -876,18 +920,13 @@ proc parseGraphPhotoRail*(js: JsonNode): PhotoRail =
for i in instructions:
if i{"moduleItems"}.notNull:
for item in i{"moduleItems"}:
with tweetResult, item.getTweetResult("item"):
let t = parseGraphTweet(tweetResult)
if not t.available:
t.id = item.getEntryId.getId
for t in extractTweetsFromModuleItems(i{"moduleItems"}):
let photo = extractGalleryPhoto(t)
if photo.url.len > 0:
result.add photo
let photo = extractGalleryPhoto(t)
if photo.url.len > 0:
result.add photo
if result.len == 16:
return
if result.len == 16:
return
continue
if i.getTypeName != "TimelineAddEntries":
@ -904,7 +943,7 @@ proc parseGraphPhotoRail*(js: JsonNode): PhotoRail =
if result.len == 16:
return
proc parseGraphSearch*[T: User | Tweets](js: JsonNode; after=""): Result[T] =
proc parseGraphSearch*[T: User | Tweets | ListSearchResult](js: JsonNode; after=""): Result[T] =
result = Result[T](beginning: after.len == 0)
let instructions = select(
@ -920,19 +959,27 @@ proc parseGraphSearch*[T: User | Tweets](js: JsonNode; after=""): Result[T] =
for e in instruction{"entries"}:
let entryId = e.getEntryId
when T is Tweets:
if entryId.startsWith("tweet"):
with tweetRes, getTweetResult(e):
let tweet = parseGraphTweet(tweetRes)
if not tweet.available:
tweet.id = entryId.getId
if entryId.startsWith("tweet") or entryId.startsWith("search-grid"):
for tweet in extractTweetsFromEntry(e):
result.content.add tweet
elif T is User:
if entryId.startsWith("user"):
with userRes, e{"content", "itemContent"}:
result.content.add parseGraphUser(userRes)
elif T is ListSearchResult:
if entryId.startsWith("list-search"):
for list in extractListsFromItems(e{"content", "items"}):
result.content.add list
if entryId.startsWith("cursor-bottom"):
result.bottom = e{"content", "value"}.getStr
elif typ == "TimelineAddToModule":
when T is Tweets:
for tweet in extractTweetsFromModuleItems(instruction{"moduleItems"}):
result.content.add tweet
elif T is ListSearchResult:
for list in extractListsFromItems(instruction{"moduleItems"}):
result.content.add list
elif typ == "TimelineReplaceEntry":
if instruction{"entry_id_to_replace"}.getStr.startsWith("cursor-bottom"):
result.bottom = instruction{"entry", "content", "value"}.getStr

10
src/parserutils.nim
View file

@ -98,9 +98,9 @@ proc getTimeFromMsStr*(js: JsonNode): DateTime =
proc getId*(id: string): int64 {.inline.} =
let start = id.rfind("-")
if start < 0:
return parseBiggestInt(id)
return parseBiggestInt(id[start + 1 ..< id.len])
try:
parseBiggestInt(if start < 0: id else: id[start + 1 ..< id.len])
except ValueError: 0'i64
proc getId*(js: JsonNode): int64 {.inline.} =
case js.kind
@ -233,9 +233,9 @@ proc replacedWith(runes: seq[Rune]; repls: openArray[ReplaceSlice];
symbol = $runes[rep.slice.a]
result.add a(symbol & name, href = "/search?f=tweets&q=%23" & name)
of rkMention:
result.add a($runes[rep.slice], href = rep.url, title = rep.display)
result.add a($runes[rep.slice], href = rep.url, title = escape(rep.display))
of rkUrl:
result.add a(rep.display, href = rep.url)
result.add a(escape(rep.display), href = rep.url)
of rkRemove:
discard

3
src/prefs_impl.nim
View file

@ -78,6 +78,9 @@ genPrefs:
hideReplies(checkbox, false):
"Hide tweet replies"
hideRelated(checkbox, true):
"Hide related tweets under replies"
hideCommunityNotes(checkbox, false):
"Hide community notes"

8
src/query.nim
View file

@ -34,7 +34,7 @@ proc initQuery*(pms: Table[string, string]; name=""): Query =
proc getMediaQuery*(name: string): Query =
Query(
kind: media,
kind: QueryKind.media,
filters: @["twimg", "native_video"],
fromUser: @[name],
sep: "OR"
@ -64,7 +64,7 @@ proc genQueryParam*(query: Query; maxId=""): string =
else:
param &= ")"
if query.fromUser.len > 0 and query.kind in {posts, media}:
if query.fromUser.len > 0 and query.kind in {posts, QueryKind.media}:
param &= " (filter:self_threads OR -filter:replies)"
if "nativeretweets" notin query.excludes:
@ -104,7 +104,9 @@ proc genQueryUrl*(query: Query): string =
if query.view.len > 0:
params.add "view=" & encodeUrl(query.view)
if query.kind in {tweets, users}:
# media doubles as the profile media tab, where f isn't part of the URL scheme
if query.kind in {tweets, users, lists, top} or
(query.kind == QueryKind.media and query.fromUser.len == 0):
params.add &"f={query.kind}"
if query.text.len > 0:
params.add "q=" & encodeUrl(query.text)

118
src/routes/embed.nim
View file

@ -1,29 +1,79 @@
# SPDX-License-Identifier: AGPL-3.0-only
import asyncdispatch, strutils, strformat, options
import asyncdispatch, strutils, strformat, json
import jester, karax/vdom
import ".."/[types, api]
import ".."/[types, api, formatters]
import ../views/[embed, tweet, general]
include "../views/oembed.nimf"
import router_utils
export api, embed, vdom, tweet, general, router_utils
proc parseTweetPath(path: string): tuple[username, id: string] =
let parts = path.split('/')
if parts.len >= 3 and parts[1] in ["status", "statuses"]:
let tweetId = parts[2].split('?')[0].split('#')[0]
if tweetId.len > 0 and tweetId.allCharsInSet(Digits):
return (parts[0], tweetId)
return ("", "")
proc parseTweetUrl*(url: string; cfg: Config): tuple[username, id: string] =
var path = url
if path.startsWith("https://"):
path = path[8..^1]
elif path.startsWith("http://"):
path = path[7..^1]
const twitterPrefixes = ["twitter.com/", "x.com/", "mobile.twitter.com/",
"www.twitter.com/", "www.x.com/"]
for prefix in twitterPrefixes:
if path.startsWith(prefix):
return parseTweetPath(path[prefix.len..^1])
let nitterPrefix = cfg.hostname & "/"
if path.startsWith(nitterPrefix):
return parseTweetPath(path[nitterPrefix.len..^1])
# Fall back: strip any hostname and try to parse as a tweet path.
# Handles requests where the URL's host differs from cfg.hostname
# (e.g. localhost in dev/CI, or a reverse proxy with a different domain).
let slashPos = path.find('/')
if slashPos > 0:
let afterHost = path[slashPos + 1..^1]
let parsed = parseTweetPath(afterHost)
if parsed.username.len > 0:
return parsed
return ("", "")
proc createEmbedRouter*(cfg: Config) =
router embed:
get "/i/videos/tweet/@id":
let tweet = await getGraphTweetResult(@"id")
if tweet == nil or not tweet.hasVideos:
resp Http404
let
id = @"id"
tweet = await getTweetByRestId(id)
prefs = requestPrefs()
if tweet == nil:
resp renderErrorEmbed("Tweet not found", prefs, cfg, request, tweetId=id)
if not tweet.hasVideos:
resp renderErrorEmbed("No video in tweet", prefs, cfg, request,
tweetId=id, username=tweet.user.username)
resp renderVideoEmbed(tweet, cfg, request)
get "/@user/status/@id/embed":
let
tweet = await getGraphTweetResult(@"id")
id = @"id"
user = @"user"
tweet = await getTweetByRestId(id)
prefs = requestPrefs()
path = getPath()
if tweet == nil:
resp Http404
resp renderErrorEmbed("Tweet not found", prefs, cfg, request,
tweetId=id, username=user)
resp renderTweetEmbed(tweet, path, prefs, cfg, request)
@ -34,3 +84,57 @@ proc createEmbedRouter*(cfg: Config) =
redirect(&"/i/status/{id}/embed")
else:
resp Http404
get "/api/oembed":
responseHeaders().get.add(("Access-Control-Allow-Origin", "*"))
let
url = @"url"
format = @"format"
if format.len > 0 and format != "json":
resp Http501, "Only JSON format is supported"
if url.len == 0:
resp Http400, "Missing url parameter"
let (username, tweetId) = parseTweetUrl(url, cfg)
if username.len == 0 or tweetId.len == 0:
resp Http400, "Invalid tweet URL"
let tweet = await getTweetByRestId(tweetId)
if tweet == nil:
resp Http404
let
maxwidthParam = @"maxwidth"
maxwidth = if maxwidthParam.len > 0:
try: clamp(parseInt(maxwidthParam), 220, 550)
except ValueError: 550
else: 550
embedUrl = getUrlPrefix(cfg) & "/" & tweet.user.username & "/status/" & tweetId & "/embed"
authorUrl = getUrlPrefix(cfg) & "/" & tweet.user.username
title = stripHtml(tweet.text)
var response = %*{
"version": "1.0",
"type": "rich",
"provider_name": cfg.title,
"provider_url": getUrlPrefix(cfg),
"title": title,
"author_name": tweet.user.fullname,
"author_url": authorUrl,
"url": embedUrl,
"width": maxwidth,
"height": newJNull(),
"cache_age": "3153600000",
"html": renderOembedIframe(embedUrl, maxwidth)
}
if tweet.media.len > 0:
let thumbUrl = getUrlPrefix(cfg) & getPicUrl(tweet.media[0].getThumb)
response["thumbnail_url"] = %thumbUrl
response["thumbnail_width"] = %maxwidth
response["thumbnail_height"] = %maxwidth
respJson response

2
src/routes/router_utils.nim
View file

@ -4,7 +4,7 @@ from jester import Request, cookies
import ../views/general
import ".."/[utils, prefs, types]
export utils, prefs, types, uri
export utils, prefs, types, uri, json
template savePref*(pref, value: string; req: Request; expire=false) =
if not expire or pref in cookies(req):

2
src/routes/rss.nim
View file

@ -68,7 +68,7 @@ proc createRssRouter*(cfg: Config) =
let
prefs = requestPrefs()
query = initQuery(params(request))
if query.kind != tweets:
if query.kind notin {QueryKind.tweets, QueryKind.top, QueryKind.media}:
resp Http400, showError("Only Tweet searches are allowed for RSS feeds.", cfg)
let

20
src/routes/search.nim
View file

@ -20,9 +20,21 @@ proc createSearchRouter*(cfg: Config) =
let
prefs = requestPrefs()
query = initQuery(params(request))
title = "Search" & (if q.len > 0: " (" & q & ")" else: "")
var query = initQuery(params(request))
# x.com URL compat: f=user and f=list map to our kind names
# (f=live already falls back to tweets/Latest; f=media matches natively)
if @"f" == "user":
query.kind = users
elif @"f" == "list":
query.kind = lists
# media searches support view modes, defaulting like /user/media
if query.kind == QueryKind.media and
query.view notin ["timeline", "grid", "gallery"]:
query.view = prefs.mediaView.toLowerAscii
case query.kind
of users:
if "," in q:
@ -33,12 +45,16 @@ proc createSearchRouter*(cfg: Config) =
except InternalError:
users = Result[User](beginning: true, query: query)
resp renderMain(renderUserSearch(users, prefs), request, cfg, prefs, title)
of tweets:
of tweets, top, QueryKind.media:
let
tweets = await getGraphTweetSearch(query, getCursor())
rss = if cfg.enableRSSSearch: "/search/rss?" & genQueryUrl(query) else: ""
resp renderMain(renderTweetSearch(tweets, prefs, getPath()),
request, cfg, prefs, title, rss=rss)
of lists:
let listResults = await getGraphListSearch(query, getCursor())
resp renderMain(renderListSearch(listResults, prefs, getPath()),
request, cfg, prefs, title)
else:
resp Http404, showError("Invalid search", cfg)

18
src/routes/status.nim
View file

@ -21,16 +21,18 @@ proc createStatusRouter*(cfg: Config) =
if id.len > 19 or id.any(c => not c.isDigit):
resp Http404, showError("Invalid tweet ID", cfg)
let prefs = requestPrefs()
let
prefs = requestPrefs()
sort = parseEnum[RankingMode](@"sort".toLowerAscii.capitalizeAscii, Relevance)
# used for the infinite scroll feature
if @"scroll".len > 0:
let replies = await getReplies(id, getCursor())
let replies = await getReplies(id, getCursor(), sort)
if replies.content.len == 0:
resp Http204
resp $renderReplies(replies, prefs, getPath())
resp $renderReplies(replies, prefs, getPath(), sort=sort)
let conv = await getTweet(id, getCursor())
let conv = await getTweet(id, getCursor(), sort)
if conv == nil or conv.tweet == nil or conv.tweet.id == 0:
var error = "Tweet not found"
@ -64,9 +66,13 @@ proc createStatusRouter*(cfg: Config) =
elif card.video.isSome():
images = @[card.video.get().thumb]
let html = renderConversation(conv, prefs, getPath() & "#m")
let
tweetUrl = getUrlPrefix(cfg) & "/" & conv.tweet.user.username & "/status/" & $conv.tweet.id
oembedUrl = getUrlPrefix(cfg) & "/api/oembed?url=" & encodeUrl(tweetUrl)
let html = renderConversation(conv, prefs, getPath() & "#m", sort)
resp renderMain(html, request, cfg, prefs, title, desc, ogTitle,
images=images, video=video)
images=images, video=video, oembed=oembedUrl)
get "/@name/status/@id/history/?":
cond '.' notin @"name"

2
src/routes/timeline.nim
View file

@ -53,7 +53,7 @@ proc fetchProfile*(after: string; query: Query; skipRail=false): Future[Profile]
let
rail =
skipIf(skipRail or query.kind == media, @[]):
skipIf(skipRail or query.kind == QueryKind.media, @[]):
getCachedPhotoRail(userId)
user = getCachedUser(name)

74
src/sass/search.scss
View file

@ -107,6 +107,80 @@
grid-column-gap: 10px;
}
.list-result {
display: flex;
align-items: flex-start;
.list-result-banner {
flex-shrink: 0;
width: 56px;
height: 56px;
margin-right: 10px;
border-radius: 8px;
overflow: hidden;
background-color: var(--darker_grey);
// stay above the tweet-link overlay's hover background
z-index: 1;
img {
width: 100%;
height: 100%;
object-fit: cover;
}
}
.list-result-body {
min-width: 0;
pointer-events: none;
z-index: 1;
a {
pointer-events: all;
}
}
.list-result-title {
align-items: baseline;
}
.list-members {
flex-shrink: 0;
margin-left: 0.3em;
color: var(--fg_faded);
}
.list-result-context {
display: flex;
align-items: center;
flex-wrap: wrap;
margin-top: 2px;
color: var(--fg_faded);
a {
color: var(--fg_dark);
}
a.fullname {
color: var(--fg_color);
}
.list-facepile {
width: 20px;
height: 20px;
border-radius: 50%;
margin-right: 4px;
}
}
.list-result-description {
margin-top: 2px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
pointer-events: all;
}
}
.profile-tabs {
@include search-resize(820px, 5);
@include search-resize(715px, 4);

20
src/sass/timeline.scss
View file

@ -4,6 +4,26 @@
@include panel(100%, 600px);
}
.timeline-container.media-only {
max-width: none;
width: 100%;
padding: 0 10px;
box-sizing: border-box;
> .tab,
> .timeline-header {
max-width: 900px;
margin-left: auto;
margin-right: auto;
}
}
@media (max-width: 700px) {
.timeline-container.media-only {
padding: 0;
}
}
.timeline > div:not(:first-child) {
border-top: 1px solid var(--border_grey);
}

27
src/sass/tweet/_base.scss
View file

@ -87,7 +87,6 @@
margin-top: 6px;
margin-bottom: 0px;
color: var(--grey);
pointer-events: all;
}
.tweet-avatar {
@ -118,32 +117,6 @@
}
}
.tweet-embed {
display: flex;
flex-direction: column;
justify-content: center;
height: 100%;
background-color: var(--bg_panel);
.tweet-content {
font-size: 18px;
}
.tweet-body {
display: flex;
flex-direction: column;
max-height: calc(100vh - 0.75em * 2);
}
.card-image img {
height: auto;
}
.avatar {
position: absolute;
}
}
.attribution {
display: flex;
pointer-events: all;

164
src/sass/tweet/embed.scss
View file

@ -1,17 +1,159 @@
@import "_variables";
@import "_mixins";
.embed-video {
.gallery-video {
width: 100%;
height: 100%;
position: absolute;
background-color: black;
top: 0%;
left: 0%;
}
// Embed page: transparent background, no scrollbars
html:has(body > .embed-wrapper),
html:has(body > .embed-video) {
background: transparent;
overflow: hidden;
.gallery-video > .attachment {
max-height: unset;
body {
background: transparent;
overflow: hidden;
}
}
// Tweet embed wrapper
.embed-wrapper {
box-sizing: border-box;
border: 1px solid var(--border_grey);
border-radius: 12px;
overflow: hidden;
.embed-footer {
display: block;
padding: 12px 16px;
border-top: 1px solid var(--border_grey);
background: var(--bg_panel);
color: var(--accent);
font-size: 14px;
font-weight: 500;
text-align: center;
text-decoration: none;
transition: background-color 0.15s;
&:hover {
background: var(--bg_hover);
}
}
}
// Tweet embed content
.tweet-embed {
position: relative;
background-color: var(--bg_panel);
transition: background-color 0.15s;
&:hover {
background-color: var(--bg_hover);
}
.timeline-item {
pointer-events: none;
background-color: transparent;
}
.tweet-link:hover {
background-color: transparent;
}
.tweet-content {
font-size: 18px;
}
.avatar:not(.mini) {
position: absolute;
}
// Cap media height in embeds
.still-image img,
.quote-media-container img,
.quote-media-container video {
max-height: 600px;
}
&.error-embed {
display: flex;
align-items: center;
justify-content: center;
min-height: 120px;
padding: 20px;
.error-panel {
margin: 0;
}
}
}
// Video-only embed
.embed-video {
position: relative;
min-height: 300px;
background-color: black;
border: 1px solid var(--border_grey);
.attachments {
margin: 0;
border-radius: 0;
max-height: 560px;
background-color: unset;
}
.card {
margin: 0;
}
.gallery-video {
width: 100%;
}
.gallery-video>.attachment {
max-height: 560px;
width: 100%;
}
video {
width: 100%;
height: auto;
max-height: 560px;
object-fit: contain;
}
.video-download {
display: none;
}
.video-overlay-link {
position: absolute;
top: 12px;
right: 12px;
padding: 6px 12px;
background: rgba(30, 30, 30, 0.75);
backdrop-filter: blur(4px);
color: #fff;
font-size: 13px;
font-weight: 700;
text-decoration: none;
border-radius: 9999px;
border: 1px solid transparent;
transition:
background 0.15s,
opacity 0.15s;
z-index: 10;
&:hover {
background: rgba(60, 60, 60, 0.9);
}
}
// Hide button while playing, show on hover or when paused
&.video-playing .video-overlay-link {
opacity: 0;
pointer-events: none;
}
&.video-playing:hover .video-overlay-link {
opacity: 1;
pointer-events: auto;
}
}

42
src/sass/tweet/thread.scss
View file

@ -19,6 +19,39 @@
margin-bottom: 10px;
}
.reply-sort {
display: flex;
align-items: center;
flex-wrap: wrap;
gap: 2px 14px;
margin-bottom: 10px;
padding: 8px 12px;
background-color: var(--bg_panel);
font-size: 14px;
}
.reply-sort-label {
color: var(--fg_faded);
margin-right: 2px;
}
.reply-sort-option {
color: var(--tab);
font-weight: bold;
text-decoration: none;
border-bottom: 0.1rem solid transparent;
&:hover {
color: var(--fg_color);
text-decoration: none;
}
&.active {
color: var(--tab_selected);
border-bottom-color: var(--tab_selected);
}
}
.main-tweet,
.replies,
.edit-history > div {
@ -152,3 +185,12 @@
}
}
}
.related-header {
padding: 8px 12px;
margin-top: 10px;
background-color: var(--bg_panel);
color: var(--fg_faded);
font-size: 14px;
border-bottom: 1px solid var(--border_grey);
}

6
src/tid.nim
View file

@ -16,14 +16,16 @@ var
proc getPair(): Future[TidPair] {.async.} =
if cachedPairs.len == 0 or int(epochTime()) - lastCached > ttlSec:
lastCached = int(epochTime())
let client = newAsyncHttpClient()
defer: client.close()
let resp = await client.get(pairsUrl)
if resp.status == $Http200:
cachedPairs = parseTidPairs(await resp.body)
lastCached = int(epochTime())
if cachedPairs.len == 0:
raise newException(ValueError, "Failed to fetch x-client-transaction-id pairs")
return sample(cachedPairs)

12
src/types.nim
View file

@ -174,7 +174,10 @@ type
variants*: seq[VideoVariant]
QueryKind* = enum
posts, replies, media, users, tweets, userList, followers, following
posts, replies, media, users, tweets, userList, followers, following, lists, top
RankingMode* = enum
Relevance, Recency, Likes
Query* = object
kind*: QueryKind
@ -356,6 +359,7 @@ type
content*: Tweets
hasMore*: bool
cursor*: string
related*: bool
Conversation* = ref object
tweet*: Tweet
@ -385,6 +389,12 @@ type
members*: int
banner*: string
ListSearchResult* = object
list*: List
owner*: User
followersContext*: string
facepiles*: seq[string]
CommunityRule* = object
name*: string
description*: string

61
src/views/embed.nim
View file

@ -1,25 +1,76 @@
# SPDX-License-Identifier: AGPL-3.0-only
import options
import karax/[karaxdsl, vdom]
from jester import Request
import ".."/[types, formatters]
import ".."/[types, formatters, prefs]
import general, tweet
const doctype = "<!DOCTYPE html>\n"
const
doctype = "<!DOCTYPE html>\n"
embedResizeJs = staticRead("../../public/js/embedResize.js")
proc renderVideoEmbed*(tweet: Tweet; cfg: Config; req: Request): string =
let
let
video = tweet.getVideos()[0]
thumb = video.thumb
vidUrl = getVideoEmbed(cfg, tweet.id)
prefs = Prefs(hlsPlayback: true, mp4Playback: true)
prefs = Prefs(hlsPlayback: true, mp4Playback: true, proxyVideos: defaultPrefs.proxyVideos)
tweetUrl = getLink(tweet)
let node = buildHtml(html(lang="en")):
renderHead(prefs, cfg, req, video=vidUrl, images=(@[thumb]))
base(target="_blank")
body:
tdiv(class="embed-video"):
renderVideo(video, prefs, "")
a(class="video-overlay-link", href=tweetUrl):
text "Watch on " & cfg.hostname
script:
verbatim embedResizeJs
result = doctype & $node
proc renderTweetEmbed*(tweet: Tweet; path: string; prefs: Prefs; cfg: Config; req: Request): string =
let node = buildHtml(html(lang="en")):
renderHead(prefs, cfg, req)
base(target="_blank")
body:
tdiv(class="embed-wrapper"):
tdiv(class="tweet-embed"):
a(class="tweet-link", href=getLink(tweet))
renderTweet(tweet, prefs, path, mainTweet=true)
a(class="embed-footer", href=getLink(tweet)):
text "Read more on " & cfg.hostname
script:
verbatim embedResizeJs
result = doctype & $node
proc renderErrorEmbed*(error: string; prefs: Prefs; cfg: Config; req: Request;
tweetId = ""; username = ""): string =
let link = if tweetId.len > 0:
if username.len > 0: "/" & username & "/status/" & tweetId
else: "/i/status/" & tweetId
else: "/"
let node = buildHtml(html(lang="en")):
renderHead(prefs, cfg, req)
base(target="_blank")
body:
tdiv(class="embed-wrapper"):
tdiv(class="tweet-embed error-embed"):
a(class="tweet-link", href=link)
tdiv(class="error-panel"):
span: text error
a(class="embed-footer", href=link):
text "Read more on " & cfg.hostname
script:
verbatim embedResizeJs
result = doctype & $node

12
src/views/general.nim
View file

@ -38,7 +38,7 @@ proc renderNavbar(cfg: Config; req: Request; rss, canonical: string): VNode =
proc renderHead*(prefs: Prefs; cfg: Config; req: Request; titleText=""; desc="";
video=""; images: seq[string] = @[]; banner=""; ogTitle="";
rss=""; alternate=""): VNode =
rss=""; alternate=""; oembed=""): VNode =
let theme = prefs.theme.toTheme
let ogType =
@ -50,7 +50,7 @@ proc renderHead*(prefs: Prefs; cfg: Config; req: Request; titleText=""; desc="";
let opensearchUrl = getUrlPrefix(cfg) & "/opensearch"
buildHtml(head):
link(rel="stylesheet", type="text/css", href="/css/style.css?v=45")
link(rel="stylesheet", type="text/css", href="/css/style.css?v=106")
link(rel="stylesheet", type="text/css", href="/css/fontello.css?v=7")
if theme.len > 0:
@ -70,6 +70,10 @@ proc renderHead*(prefs: Prefs; cfg: Config; req: Request; titleText=""; desc="";
if rss.len > 0:
link(rel="alternate", type="application/rss+xml", href=rss, title="RSS feed")
if oembed.len > 0:
let oembedTitle = if titleText.len > 0: titleText else: "oEmbed"
link(rel="alternate", type="application/json+oembed", href=oembed, title=oembedTitle)
if prefs.hlsPlayback:
script(src="/js/hls.min.js", `defer`="")
script(src="/js/hlsPlayback.js?v=1", `defer`="")
@ -124,7 +128,7 @@ proc renderHead*(prefs: Prefs; cfg: Config; req: Request; titleText=""; desc="";
proc renderMain*(body: VNode; req: Request; cfg: Config; prefs=defaultPrefs;
titleText=""; desc=""; ogTitle=""; rss=""; video="";
images: seq[string] = @[]; banner="";
twitterLink=""): string =
twitterLink=""; oembed=""): string =
let twitterLink =
if twitterLink.len > 0: twitterLink
@ -132,7 +136,7 @@ proc renderMain*(body: VNode; req: Request; cfg: Config; prefs=defaultPrefs;
let node = buildHtml(html(lang="en")):
renderHead(prefs, cfg, req, titleText, desc, video, images, banner, ogTitle,
rss, twitterLink)
rss, twitterLink, oembed)
let bodyClass = if prefs.stickyNav: "fixed-nav" else: ""
body(class=bodyClass):

7
src/views/oembed.nimf Normal file
View file

@ -0,0 +1,7 @@
#? stdtmpl(subsChar = '$', metaChar = '#')
## SPDX-License-Identifier: AGPL-3.0-only
#proc renderOembedIframe*(embedUrl: string; maxwidth = 550): string =
# result = ""
<iframe src="$embedUrl" style="width:100%;max-width:${maxwidth}px;height:250px;border:none" scrolling="no" loading="lazy" onload="let c=new MessageChannel;c.port1.onmessage=e=>this.style.height=e.data+'px';this.contentWindow.postMessage('','*',[c.port2])"></iframe>
# result = result.strip()
#end proc

2
src/views/profile.nim
View file

@ -115,7 +115,7 @@ proc renderProtected*(username: string): VNode =
proc renderProfile*(profile: var Profile; prefs: Prefs; path: string): VNode =
profile.tweets.query.fromUser = @[profile.user.username]
let
isGalleryView = profile.tweets.query.kind == media and
isGalleryView = profile.tweets.query.kind == QueryKind.media and
profile.tweets.query.view == "gallery"
viewClass = if isGalleryView: " media-only" else: ""

68
src/views/search.nim
View file

@ -40,28 +40,45 @@ proc renderProfileTabs*(query: Query; username: string): VNode =
li(class=query.getTabClass(tweets)):
a(href=(link & "/search")): text "Search"
proc renderMediaViewTabs*(query: Query; username: string): VNode =
proc mediaViewUrl(query: Query; view: string): string =
var q = query
q.view = view
"?" & genQueryUrl(q)
proc renderMediaViewTabs*(query: Query): VNode =
let currentView = if query.view.len > 0: query.view else: "timeline"
let base = "/" & username & "/media?view="
func cls(view: string): string =
if currentView == view: "tab-item active" else: "tab-item"
buildHtml(ul(class="tab media-view-tabs")):
li(class=cls("timeline")):
a(href=(base & "timeline")): text "Timeline"
a(href=query.mediaViewUrl("timeline")): text "Timeline"
li(class=cls("grid")):
a(href=(base & "grid")): text "Grid"
a(href=query.mediaViewUrl("grid")): text "Grid"
li(class=cls("gallery")):
a(href=(base & "gallery")): text "Gallery"
a(href=query.mediaViewUrl("gallery")): text "Gallery"
proc renderSearchTabs*(query: Query): VNode =
var q = query
# the media view mode only applies to the Media tab
q.view = ""
buildHtml(ul(class="tab")):
li(class=query.getTabClass(top)):
q.kind = top
a(href=("?" & genQueryUrl(q))): text "Top"
li(class=query.getTabClass(tweets)):
q.kind = tweets
a(href=("?" & genQueryUrl(q))): text "Tweets"
a(href=("?" & genQueryUrl(q))): text "Latest"
li(class=query.getTabClass(media)):
q.kind = media
q.view = query.view
a(href=("?" & genQueryUrl(q))): text "Media"
li(class=query.getTabClass(users)):
q.kind = users
q.view = ""
a(href=("?" & genQueryUrl(q))): text "Users"
li(class=query.getTabClass(lists)):
q.kind = lists
a(href=("?" & genQueryUrl(q))): text "Lists"
proc isPanelOpen(q: Query): bool =
q.fromUser.len == 0 and (q.filters.len > 0 or q.excludes.len > 0 or
@ -72,7 +89,7 @@ proc renderSearchPanel*(query: Query): VNode =
let action = if user.len > 0: &"/{user}/search" else: "/search"
buildHtml(form(`method`="get", action=action,
class="search-field", autocomplete="off")):
hiddenField("f", "tweets")
hiddenField("f", $query.kind)
genInput("q", "", query.text, "Enter search...", class="pref-inline")
button(`type`="submit"): icon "search"
@ -103,33 +120,52 @@ proc renderSearchPanel*(query: Query): VNode =
proc renderTweetSearch*(results: Timeline; prefs: Prefs; path: string;
pinned=none(Tweet)): VNode =
let query = results.query
buildHtml(tdiv(class="timeline-container")):
let containerClass =
if query.fromUser.len == 0 and query.kind == QueryKind.media and
query.view == "gallery": "timeline-container media-only"
else: "timeline-container"
buildHtml(tdiv(class=containerClass)):
if query.fromUser.len > 1:
tdiv(class="timeline-header"):
text query.fromUser.join(" | ")
if query.fromUser.len > 0:
if query.kind != media or query.view != "gallery":
if query.kind != QueryKind.media or query.view != "gallery":
renderProfileTabs(query, query.fromUser.join(","))
if query.kind == media and query.fromUser.len == 1:
renderMediaViewTabs(query, query.fromUser[0])
if query.kind == QueryKind.media and query.fromUser.len == 1:
renderMediaViewTabs(query)
if query.fromUser.len == 0 or query.kind == tweets:
if query.fromUser.len == 0 or query.kind == QueryKind.tweets:
tdiv(class="timeline-header"):
renderSearchPanel(query)
if query.fromUser.len == 0:
renderSearchTabs(query)
if query.kind == QueryKind.media:
renderMediaViewTabs(query)
renderTimelineTweets(results, prefs, path, pinned)
proc renderSearchForm(kind, placeholder, value: string): VNode =
buildHtml(form(`method`="get", action="/search",
class="search-field", autocomplete="off")):
hiddenField("f", kind)
genInput("q", "", value, placeholder, class="pref-inline")
button(`type`="submit"): icon "search"
proc renderUserSearch*(results: Result[User]; prefs: Prefs): VNode =
buildHtml(tdiv(class="timeline-container")):
tdiv(class="timeline-header"):
form(`method`="get", action="/search", class="search-field", autocomplete="off"):
hiddenField("f", "users")
genInput("q", "", results.query.text, "Enter username...", class="pref-inline")
button(`type`="submit"): icon "search"
renderSearchForm("users", "Enter username...", results.query.text)
renderSearchTabs(results.query)
renderTimelineUsers(results, prefs)
proc renderListSearch*(results: Result[ListSearchResult]; prefs: Prefs;
path: string): VNode =
buildHtml(tdiv(class="timeline-container")):
tdiv(class="timeline-header"):
renderSearchForm("lists", "Enter search...", results.query.text)
renderSearchTabs(results.query)
renderTimelineLists(results, prefs, path)

41
src/views/status.nim
View file

@ -1,4 +1,5 @@
# SPDX-License-Identifier: AGPL-3.0-only
import sequtils
import karax/[karaxdsl, vdom]
import ".."/[types, formatters]
@ -28,21 +29,46 @@ proc renderReplyThread(thread: Chain; prefs: Prefs; path: string): VNode =
if thread.hasMore:
renderMoreReplies(thread)
proc renderReplies*(replies: Result[Chain]; prefs: Prefs; path: string; tweet: Tweet = nil): VNode =
proc renderReplySort(sort: RankingMode): VNode =
buildHtml(tdiv(class="reply-sort")):
span(class="reply-sort-label"): text "Sort replies:"
for mode in RankingMode:
let
cls = if mode == sort: "reply-sort-option active"
else: "reply-sort-option"
label = case mode
of Relevance: "Relevant"
of Recency: "Recent"
of Likes: "Liked"
a(class=cls, href=("?sort=" & $mode & "#r")):
text label
proc renderReplies*(replies: Result[Chain]; prefs: Prefs; path: string;
tweet: Tweet = nil; sort = Relevance): VNode =
buildHtml(tdiv(class="replies", id="r")):
var hasReplies = false
var replyCount = 0
for thread in replies.content:
if thread.content.len == 0: continue
if thread.content.len == 0 or thread.related: continue
hasReplies = true
replyCount += thread.content.len
renderReplyThread(thread, prefs, path)
if hasReplies and replies.bottom.len > 0:
if tweet == nil or not replies.beginning or replyCount < tweet.stats.replies:
renderMore(Query(), replies.bottom, focus="#r")
let extra = if sort == Relevance: "" else: "sort=" & $sort & "&"
renderMore(Query(), replies.bottom, focus="#r", extra=extra)
proc renderConversation*(conv: Conversation; prefs: Prefs; path: string): VNode =
proc renderRelated(replies: Result[Chain]; prefs: Prefs; path: string): VNode =
buildHtml(tdiv(class="related-tweets")):
tdiv(class="related-header"):
text "Related tweets"
for thread in replies.content:
if thread.content.len == 0 or not thread.related: continue
renderReplyThread(thread, prefs, path)
proc renderConversation*(conv: Conversation; prefs: Prefs; path: string;
sort = Relevance): VNode =
let hasAfter = conv.after.content.len > 0
let threadId = conv.tweet.threadId
buildHtml(tdiv(class="conversation")):
@ -75,7 +101,12 @@ proc renderConversation*(conv: Conversation; prefs: Prefs; path: string): VNode
if not conv.replies.beginning:
renderNewer(Query(), getLink(conv.tweet), focus="#r")
if conv.replies.content.len > 0 or conv.replies.bottom.len > 0:
renderReplies(conv.replies, prefs, path, conv.tweet)
renderReplySort(sort)
renderReplies(conv.replies, prefs, path, conv.tweet, sort)
if not prefs.hideRelated:
if conv.replies.content.anyIt(it.related and it.content.len > 0):
renderRelated(conv.replies, prefs, path)
renderToTop(focus="#m")

84
src/views/timeline.nim
View file

@ -6,7 +6,7 @@ import ".."/[types, query, formatters]
import tweet, renderutils
proc timelineViewClass(query: Query): string =
if query.kind != media:
if query.kind != QueryKind.media:
return "timeline"
case query.view
@ -50,9 +50,9 @@ proc renderNewer*(query: Query; path: string; focus=""): VNode =
a(href=(p & url)):
text "Load newest"
proc renderMore*(query: Query; cursor: string; focus=""): VNode =
proc renderMore*(query: Query; cursor: string; focus=""; extra=""): VNode =
buildHtml(tdiv(class="show-more")):
a(href=(&"?{getQuery(query)}cursor={encodeUrl(cursor, usePlus=false)}{focus}")):
a(href=(&"?{extra}{getQuery(query)}cursor={encodeUrl(cursor, usePlus=false)}{focus}")):
text "Load more"
proc renderNoMore(): VNode =
@ -114,6 +114,84 @@ proc renderTimelineUsers*(results: Result[User]; prefs: Prefs; path=""): VNode =
else:
renderNoMore()
proc mentionUsername(word: string): string =
# "@user" -> "user" for well-formed mentions, "" otherwise
if word.len > 1 and word[0] == '@' and
word[1 .. ^1].allCharsInSet({'A'..'Z', 'a'..'z', '0'..'9', '_'}):
word[1 .. ^1]
else: ""
proc mentionedUser(s: string): string =
# last @mention in strings like "65 followers including @user"
let words = s.split(' ')
for i in countdown(words.high, 0):
result = mentionUsername(words[i])
if result.len > 0: return
proc renderMentionedText(s: string): VNode =
# linkify @mentions in plain API strings like "65 followers including @user"
let words = s.split(' ')
buildHtml(span):
for i in 0 ..< words.len:
if i > 0: text " "
let username = mentionUsername(words[i])
if username.len > 0:
a(href=("/" & username)): text words[i]
else:
text words[i]
proc renderListCard(r: ListSearchResult): VNode =
let listUrl = "/i/lists/" & r.list.id
buildHtml(tdiv(class="timeline-item list-result")):
a(class="tweet-link", href=listUrl)
a(class="list-result-banner", href=listUrl):
if r.list.banner.len > 0:
genImg(r.list.banner)
tdiv(class="list-result-body"):
tdiv(class="list-result-title fullname-and-username"):
a(class="list-name fullname", href=listUrl): text r.list.name
span(class="list-members"):
text &"· {insertSep($r.list.members, ',')} members"
tdiv(class="list-result-context"):
if r.followersContext.len > 0:
# the first facepile belongs to the "including @user" account
let mentioned = mentionedUser(r.followersContext)
for i in 0 ..< r.facepiles.len:
if i == 0 and mentioned.len > 0:
a(class="facepile-link", href=("/" & mentioned)):
genImg(r.facepiles[i], class="list-facepile")
else:
genImg(r.facepiles[i], class="list-facepile")
renderMentionedText(r.followersContext)
else:
if r.owner.username.len > 0:
a(class="facepile-link", href=("/" & r.owner.username)):
genImg(r.owner.getUserPic("_mini"), class="list-facepile")
else:
genImg(r.owner.getUserPic("_mini"), class="list-facepile")
linkUser(r.owner, class="fullname")
linkUser(r.owner, class="username")
if r.list.description.len > 0:
tdiv(class="list-result-description"):
text r.list.description
proc renderTimelineLists*(results: Result[ListSearchResult]; prefs: Prefs;
path=""): VNode =
buildHtml(tdiv(class="timeline")):
if not results.beginning:
renderNewer(results.query, path)
if results.content.len > 0:
for list in results.content:
renderListCard(list)
if results.bottom.len > 0:
renderMore(results.query, results.bottom)
renderToTop()
elif results.beginning:
renderNoneFound()
else:
renderNoMore()
proc filterThreads(threads: seq[Tweets]; prefs: Prefs): seq[Tweets] =
var retweets: seq[int64]
for thread in threads:

11
src/views/tweet.nim
View file

@ -5,7 +5,6 @@ from jester import Request
import renderutils
import ".."/[types, utils, formatters]
import general
const doctype = "<!DOCTYPE html>\n"
@ -464,13 +463,3 @@ proc renderTweet*(tweet: Tweet; prefs: Prefs; path: string; class=""; index=0;
if not prefs.hideTweetStats:
renderStats(tweet.stats)
proc renderTweetEmbed*(tweet: Tweet; path: string; prefs: Prefs; cfg: Config; req: Request): string =
let node = buildHtml(html(lang="en")):
renderHead(prefs, cfg, req)
body:
tdiv(class="tweet-embed"):
renderTweet(tweet, prefs, path, mainTweet=true)
result = doctype & $node