137 lines
3.1 KiB
TypeScript
137 lines
3.1 KiB
TypeScript
import {RootStoreModel} from 'state/index'
|
|
import {
|
|
AppBskyFeedDefs,
|
|
AppBskyFeedGetAuthorFeed as GetAuthorFeed,
|
|
} from '@atproto/api'
|
|
type ReasonRepost = AppBskyFeedDefs.ReasonRepost
|
|
|
|
async function getMultipleAuthorsPosts(
|
|
rootStore: RootStoreModel,
|
|
authors: string[],
|
|
cursor: string | undefined = undefined,
|
|
limit: number = 10,
|
|
) {
|
|
const responses = await Promise.all(
|
|
authors.map((actor, index) =>
|
|
rootStore.agent
|
|
.getAuthorFeed({
|
|
actor,
|
|
limit,
|
|
cursor: cursor ? cursor.split(',')[index] : undefined,
|
|
})
|
|
.catch(_err => ({success: false, headers: {}, data: {feed: []}})),
|
|
),
|
|
)
|
|
return responses
|
|
}
|
|
|
|
function mergePosts(
|
|
responses: GetAuthorFeed.Response[],
|
|
{repostsOnly, bestOfOnly}: {repostsOnly?: boolean; bestOfOnly?: boolean},
|
|
) {
|
|
let posts: AppBskyFeedDefs.FeedViewPost[] = []
|
|
|
|
if (bestOfOnly) {
|
|
for (const res of responses) {
|
|
if (res.success) {
|
|
// filter the feed down to the post with the most likes
|
|
res.data.feed = res.data.feed.reduce(
|
|
(acc: AppBskyFeedDefs.FeedViewPost[], v) => {
|
|
if (
|
|
!acc?.[0] &&
|
|
!v.reason &&
|
|
!v.reply &&
|
|
isRecentEnough(v.post.indexedAt)
|
|
) {
|
|
return [v]
|
|
}
|
|
if (
|
|
acc &&
|
|
!v.reason &&
|
|
!v.reply &&
|
|
(v.post.likeCount || 0) > (acc[0]?.post.likeCount || 0) &&
|
|
isRecentEnough(v.post.indexedAt)
|
|
) {
|
|
return [v]
|
|
}
|
|
return acc
|
|
},
|
|
[],
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
// merge into one array
|
|
for (const res of responses) {
|
|
if (res.success) {
|
|
posts = posts.concat(res.data.feed)
|
|
}
|
|
}
|
|
|
|
// filter down to reposts of other users
|
|
const uris = new Set()
|
|
posts = posts.filter(p => {
|
|
if (repostsOnly && !isARepostOfSomeoneElse(p)) {
|
|
return false
|
|
}
|
|
if (uris.has(p.post.uri)) {
|
|
return false
|
|
}
|
|
uris.add(p.post.uri)
|
|
return true
|
|
})
|
|
|
|
// sort by index time
|
|
posts.sort((a, b) => {
|
|
return (
|
|
Number(new Date(b.post.indexedAt)) - Number(new Date(a.post.indexedAt))
|
|
)
|
|
})
|
|
|
|
return posts
|
|
}
|
|
|
|
function isARepostOfSomeoneElse(post: AppBskyFeedDefs.FeedViewPost): boolean {
|
|
return (
|
|
post.reason?.$type === 'app.bsky.feed.defs#reasonRepost' &&
|
|
post.post.author.did !== (post.reason as ReasonRepost).by.did
|
|
)
|
|
}
|
|
|
|
function getCombinedCursors(responses: GetAuthorFeed.Response[]) {
|
|
let hasCursor = false
|
|
const cursors = responses.map(r => {
|
|
if (r.data.cursor) {
|
|
hasCursor = true
|
|
return r.data.cursor
|
|
}
|
|
return ''
|
|
})
|
|
if (!hasCursor) {
|
|
return undefined
|
|
}
|
|
const combinedCursors = cursors.join(',')
|
|
return combinedCursors
|
|
}
|
|
|
|
function isCombinedCursor(cursor: string) {
|
|
return cursor.includes(',')
|
|
}
|
|
|
|
const TWO_DAYS_AGO = Date.now() - 1e3 * 60 * 60 * 48
|
|
function isRecentEnough(date: string) {
|
|
try {
|
|
const d = Number(new Date(date))
|
|
return d > TWO_DAYS_AGO
|
|
} catch {
|
|
return false
|
|
}
|
|
}
|
|
|
|
export {
|
|
getMultipleAuthorsPosts,
|
|
mergePosts,
|
|
getCombinedCursors,
|
|
isCombinedCursor,
|
|
}
|