@atproto/bsky 0.0.152 → 0.0.154

package/src/views/index.ts

@@ -76,6 +76,7 @@ import {
 } from '../util/uris'
 import {
   ThreadHiddenAnchorPostNode,
+  ThreadHiddenItemValuePost,
   ThreadHiddenPostNode,
   ThreadItemValueBlocked,
   ThreadItemValueNoUnauthenticated,
@@ -130,11 +131,15 @@ export class Views {
   public imgUriBuilder: ImageUriBuilder = this.opts.imgUriBuilder
   public videoUriBuilder: VideoUriBuilder = this.opts.videoUriBuilder
   public indexedAtEpoch: Date | undefined = this.opts.indexedAtEpoch
+  private threadTagsBumpDown: readonly string[] = this.opts.threadTagsBumpDown
+  private threadTagsHide: readonly string[] = this.opts.threadTagsHide
   constructor(
     private opts: {
       imgUriBuilder: ImageUriBuilder
       videoUriBuilder: VideoUriBuilder
       indexedAtEpoch: Date | undefined
+      threadTagsBumpDown: readonly string[]
+      threadTagsHide: readonly string[]
     },
   ) {}
 
@@ -1248,6 +1253,7 @@ export class Views {
                 below,
                 depth: 1,
                 branchingFactor,
+                prioritizeFollowedUsers,
               },
               state,
             )
@@ -1263,19 +1269,21 @@ export class Views {
           repliesAllowance: Infinity, // While we don't have pagination.
           uri: anchorUri,
         }),
+        tags: post.tags,
         hasOPLike: !!state.threadContexts?.get(postView.uri)?.like,
         parent,
         replies,
       }
     }
 
-    const thread = sortTrimFlattenThreadTree<ThreadItem>(anchorTree, {
+    const thread = sortTrimFlattenThreadTree(anchorTree, {
       opDid,
       branchingFactor,
       sort,
       prioritizeFollowedUsers,
       viewer: state.ctx?.viewer ?? null,
-      fetchedAt: Date.now(),
+      threadTagsBumpDown: this.threadTagsBumpDown,
+      threadTagsHide: this.threadTagsHide,
     })
 
     return {
@@ -1392,6 +1400,7 @@ export class Views {
           postView,
           uri,
         }),
+        tags: post.tags,
         hasOPLike: !!state.threadContexts?.get(postView.uri)?.like,
         parent,
         replies: undefined,
@@ -1410,6 +1419,7 @@ export class Views {
       below,
       depth,
       branchingFactor,
+      prioritizeFollowedUsers,
     }: {
       parentUri: string
       isOPThread: boolean
@@ -1419,6 +1429,7 @@ export class Views {
       below: number
       depth: number
       branchingFactor: number
+      prioritizeFollowedUsers: boolean
     },
     state: HydrationState,
   ): { replies: ThreadTreeVisible[] | undefined; hasHiddenReplies: boolean } {
@@ -1430,23 +1441,22 @@ export class Views {
     const childrenUris = childrenByParentUri[parentUri] ?? []
     let hasHiddenReplies = false
     const replies = mapDefined(childrenUris, (uri) => {
-      const replyInclusion = this.checkThreadV2ReplyInclusion(
+      const replyInclusion = this.checkThreadV2ReplyInclusion({
         uri,
         rootUri,
         state,
-      )
+      })
       if (!replyInclusion) {
         return undefined
       }
-      const { authorDid, postView } = replyInclusion
+      const { authorDid, post, postView } = replyInclusion
 
       // Hidden.
-      const { hiddenByThreadgate, mutedByViewer } = this.isHiddenThreadPost(
-        { rootUri, uri },
+      const { isHidden } = this.isHiddenThreadPost(
+        { post, postView, prioritizeFollowedUsers, rootUri, uri },
         state,
       )
-      // Is hidden reply.
-      if (hiddenByThreadgate || mutedByViewer) {
+      if (isHidden) {
         // Only care about anchor replies
         if (depth === 1) {
           hasHiddenReplies = true
@@ -1466,6 +1476,7 @@ export class Views {
           below,
           depth: depth + 1,
           branchingFactor,
+          prioritizeFollowedUsers,
         },
         state,
       )
@@ -1482,6 +1493,7 @@ export class Views {
           repliesAllowance,
           uri,
         }),
+        tags: post.tags,
         hasOPLike: !!state.threadContexts?.get(postView.uri)?.like,
         parent: undefined,
         replies: nestedReplies,
@@ -1520,11 +1532,13 @@ export class Views {
       uri,
       depth,
       value: {
-        $type: 'app.bsky.unspecced.getPostThreadV2#threadItemPost',
+        $type: 'app.bsky.unspecced.defs#threadItemPost',
         post: postView,
         moreParents: moreParents ?? false,
         moreReplies,
         opThread: isOPThread,
+        hiddenByThreadgate: false, // Hidden posts are handled by threadHiddenV2
+        mutedByViewer: false, // Hidden posts are handled by threadHiddenV2
       },
     }
   }
@@ -1540,7 +1554,7 @@ export class Views {
       uri,
       depth,
       value: {
-        $type: 'app.bsky.unspecced.getPostThreadV2#threadItemNoUnauthenticated',
+        $type: 'app.bsky.unspecced.defs#threadItemNoUnauthenticated',
       },
     }
   }
@@ -1556,7 +1570,7 @@ export class Views {
       uri,
       depth,
       value: {
-        $type: 'app.bsky.unspecced.getPostThreadV2#threadItemNotFound',
+        $type: 'app.bsky.unspecced.defs#threadItemNotFound',
       },
     }
   }
@@ -1576,7 +1590,7 @@ export class Views {
       uri,
       depth,
       value: {
-        $type: 'app.bsky.unspecced.getPostThreadV2#threadItemBlocked',
+        $type: 'app.bsky.unspecced.defs#threadItemBlocked',
         author: {
           did: authorDid,
           viewer: this.blockedProfileViewer(authorDid, state),
@@ -1591,9 +1605,11 @@ export class Views {
     {
       below,
       branchingFactor,
+      prioritizeFollowedUsers,
     }: {
       below: number
       branchingFactor: number
+      prioritizeFollowedUsers: boolean
     },
   ): ThreadHiddenItem[] {
     const { anchor: anchorUri, uris } = skeleton
@@ -1628,6 +1644,7 @@ export class Views {
           childrenByParentUri,
           below,
           depth: 1,
+          prioritizeFollowedUsers,
         },
         state,
       ),
@@ -1638,7 +1655,8 @@ export class Views {
       branchingFactor,
       prioritizeFollowedUsers: false,
       viewer: state.ctx?.viewer ?? null,
-      fetchedAt: Date.now(),
+      threadTagsBumpDown: this.threadTagsBumpDown,
+      threadTagsHide: this.threadTagsHide,
     })
   }
 
@@ -1649,12 +1667,14 @@ export class Views {
       childrenByParentUri,
       below,
       depth,
+      prioritizeFollowedUsers,
     }: {
       parentUri: string
       rootUri: string
       childrenByParentUri: Record<string, string[]>
       below: number
       depth: number
+      prioritizeFollowedUsers: boolean
     },
     state: HydrationState,
   ): ThreadHiddenPostNode[] | undefined {
@@ -1665,23 +1685,23 @@ export class Views {
 
     const childrenUris = childrenByParentUri[parentUri] ?? []
     return mapDefined(childrenUris, (uri) => {
-      const replyInclusion = this.checkThreadV2ReplyInclusion(
+      const replyInclusion = this.checkThreadV2ReplyInclusion({
         uri,
         rootUri,
         state,
-      )
+      })
       if (!replyInclusion) {
         return undefined
       }
-      const { postView } = replyInclusion
+      const { post, postView } = replyInclusion
 
       // Hidden.
-      const { hiddenByThreadgate, mutedByViewer } = this.isHiddenThreadPost(
-        { rootUri, uri },
-        state,
-      )
-      // Is hidden reply.
-      if (hiddenByThreadgate || mutedByViewer) {
+      const { isHidden, hiddenByThreadgate, mutedByViewer } =
+        this.isHiddenThreadPost(
+          { post, postView, rootUri, prioritizeFollowedUsers, uri },
+          state,
+        )
+      if (isHidden) {
         // Only show hidden anchor replies, not all hidden.
         if (depth > 1) {
           return undefined
@@ -1699,23 +1719,23 @@ export class Views {
           childrenByParentUri,
           below,
           depth: depth + 1,
+          prioritizeFollowedUsers,
         },
         state,
       )
 
-      const item = this.threadHiddenV2ItemPost(
-        {
-          depth,
-          postView,
-          rootUri,
-          uri,
-        },
-        state,
-      )
+      const item = this.threadHiddenV2ItemPost({
+        depth,
+        hiddenByThreadgate,
+        mutedByViewer,
+        postView,
+        uri,
+      })
 
       const tree: ThreadHiddenPostNode = {
         type: 'hiddenPost',
         item: item,
+        tags: post.tags,
         replies,
       }
 
@@ -1739,42 +1759,47 @@ export class Views {
     }
   }
 
-  private threadHiddenV2ItemPost(
-    {
-      depth,
-      postView,
-      rootUri,
-      uri,
-    }: {
-      depth: number
-      postView: PostView
-      rootUri: string
-      uri: string
-    },
-    state: HydrationState,
-  ): ThreadHiddenPostNode['item'] {
-    const { hiddenByThreadgate, mutedByViewer } = this.isHiddenThreadPost(
-      { rootUri, uri },
-      state,
-    )
-
+  private threadHiddenV2ItemPost({
+    depth,
+    hiddenByThreadgate,
+    mutedByViewer,
+    postView,
+    uri,
+  }: {
+    depth: number
+    hiddenByThreadgate: boolean
+    mutedByViewer: boolean
+    postView: PostView
+    uri: string
+  }): ThreadHiddenItemValuePost {
     const base = this.threadHiddenV2ItemPostAnchor({ depth, uri })
     return {
       ...base,
       value: {
-        $type: 'app.bsky.unspecced.getPostThreadHiddenV2#threadHiddenItemPost',
+        $type: 'app.bsky.unspecced.defs#threadItemPost',
         post: postView,
         hiddenByThreadgate,
         mutedByViewer,
+        moreParents: false, // Hidden replies don't have parents.
+        moreReplies: 0, // Hidden replies don't have replies hydrated.
+        opThread: false, // Hidden replies don't contain OP threads.
       },
     }
   }
 
-  private checkThreadV2ReplyInclusion(
-    uri: string,
-    rootUri: string,
-    state: HydrationState,
-  ): { authorDid: string; postView: PostView } | null {
+  private checkThreadV2ReplyInclusion({
+    uri,
+    rootUri,
+    state,
+  }: {
+    uri: string
+    rootUri: string
+    state: HydrationState
+  }): {
+    authorDid: string
+    post: Post
+    postView: PostView
+  } | null {
     // Not found.
     const post = state.posts?.get(uri)
     if (post?.violatesThreadGate) {
@@ -1806,24 +1831,41 @@ export class Views {
       return null
     }
 
-    return { authorDid, postView }
+    return { authorDid, post, postView }
   }
 
   private isHiddenThreadPost(
     {
+      post,
+      postView,
+      prioritizeFollowedUsers,
       rootUri,
       uri,
     }: {
+      post: Post
+      postView: PostView
+      prioritizeFollowedUsers: boolean
       rootUri: string
       uri: string
     },
     state: HydrationState,
   ): {
+    isHidden: boolean
+    hiddenByTag: boolean
     hiddenByThreadgate: boolean
     mutedByViewer: boolean
   } {
+    const opDid = creatorFromUri(rootUri)
     const authorDid = creatorFromUri(uri)
 
+    const showBecauseFollowing =
+      prioritizeFollowedUsers && !!postView.author.viewer?.following
+    const hiddenByTag =
+      authorDid !== opDid &&
+      authorDid !== state.ctx?.viewer &&
+      !showBecauseFollowing &&
+      this.threadTagsHide.some((t) => post.tags.has(t))
+
     const hiddenByThreadgate =
       state.ctx?.viewer !== authorDid &&
       this.replyIsHiddenByThreadgate(uri, rootUri, state)
@@ -1831,6 +1873,8 @@ export class Views {
     const mutedByViewer = this.viewerMuteExists(authorDid, state)
 
     return {
+      isHidden: hiddenByTag || hiddenByThreadgate || mutedByViewer,
+      hiddenByTag,
       hiddenByThreadgate,
       mutedByViewer,
     }

package/src/views/threads-v2.ts

@@ -2,17 +2,15 @@ import { asPredicate } from '@atproto/api'
 import { HydrateCtx } from '../hydration/hydrator'
 import { validateRecord as validatePostRecord } from '../lexicon/types/app/bsky/feed/post'
 import {
-  ThreadHiddenItem,
-  ThreadHiddenItemPost,
-  isThreadHiddenItemPost,
-} from '../lexicon/types/app/bsky/unspecced/getPostThreadHiddenV2'
-import {
-  QueryParams as GetPostThreadV2QueryParams,
-  ThreadItem,
   ThreadItemBlocked,
   ThreadItemNoUnauthenticated,
   ThreadItemNotFound,
   ThreadItemPost,
+} from '../lexicon/types/app/bsky/unspecced/defs'
+import { ThreadHiddenItem } from '../lexicon/types/app/bsky/unspecced/getPostThreadHiddenV2'
+import {
+  QueryParams as GetPostThreadV2QueryParams,
+  ThreadItem,
 } from '../lexicon/types/app/bsky/unspecced/getPostThreadV2'
 import { $Typed } from '../lexicon/util'
 
@@ -59,6 +57,7 @@ type ThreadNotFoundNode = {
 type ThreadPostNode = {
   type: 'post'
   item: ThreadItemValuePost
+  tags: Set<string>
   hasOPLike: boolean
   parent: ThreadTree | undefined
   replies: ThreadTree[] | undefined
@@ -72,7 +71,7 @@ type ThreadHiddenItemValue<T extends ThreadHiddenItem['value']> = Omit<
 }
 
 export type ThreadHiddenItemValuePost = ThreadHiddenItemValue<
-  $Typed<ThreadHiddenItemPost>
+  $Typed<ThreadItemPost>
 >
 
 // This is an intermediary type that doesn't map to the views.
@@ -87,6 +86,7 @@ export type ThreadHiddenAnchorPostNode = {
 export type ThreadHiddenPostNode = {
   type: 'hiddenPost'
   item: ThreadHiddenItemValuePost
+  tags: Set<string>
   replies: ThreadHiddenPostNode[] | undefined
 }
 
@@ -107,21 +107,23 @@ export type ThreadTreeHidden = ThreadHiddenAnchorPostNode | ThreadHiddenPostNode
 export type ThreadTree = ThreadTreeVisible | ThreadTreeHidden
 
 /** This function mutates the tree parameter. */
-export function sortTrimFlattenThreadTree<
-  TItem extends ThreadItem | ThreadHiddenItem,
->(anchorTree: ThreadTree, options: SortTrimFlattenOptions): TItem[] {
+export function sortTrimFlattenThreadTree(
+  anchorTree: ThreadTree,
+  options: SortTrimFlattenOptions,
+) {
   const sortedAnchorTree = sortTrimThreadTree(anchorTree, options)
 
-  return flattenTree<TItem>(sortedAnchorTree)
+  return flattenTree(sortedAnchorTree)
 }
 
 type SortTrimFlattenOptions = {
   branchingFactor: GetPostThreadV2QueryParams['branchingFactor']
-  fetchedAt: number
   opDid: string
   prioritizeFollowedUsers: boolean
   sort?: GetPostThreadV2QueryParams['sort']
   viewer: HydrateCtx['viewer']
+  threadTagsBumpDown: readonly string[]
+  threadTagsHide: readonly string[]
 }
 
 const isPostRecord = asPredicate(validatePostRecord)
@@ -136,15 +138,6 @@ function sortTrimThreadTree(
   }
   const node: ThreadNodeWithReplies = n
 
-  const {
-    branchingFactor,
-    fetchedAt,
-    opDid,
-    prioritizeFollowedUsers,
-    sort,
-    viewer,
-  } = opts
-
   if (node.replies) {
     node.replies.sort((an: ThreadTree, bn: ThreadTree) => {
       if (!isPostNode(an)) {
@@ -168,19 +161,10 @@ function sortTrimThreadTree(
 
     // Trimming: after sorting, apply branching factor to all levels of replies except the anchor direct replies.
     if (node.item.depth !== 0) {
-      node.replies = node.replies.slice(0, branchingFactor)
+      node.replies = node.replies.slice(0, opts.branchingFactor)
     }
 
-    node.replies.forEach((reply) =>
-      sortTrimThreadTree(reply, {
-        branchingFactor,
-        fetchedAt,
-        opDid,
-        prioritizeFollowedUsers,
-        sort,
-        viewer,
-      }),
-    )
+    node.replies.forEach((reply) => sortTrimThreadTree(reply, opts))
   }
 
   return node
@@ -191,19 +175,30 @@ function applyBumping(
   bNode: ThreadMaybeHiddenPostNode,
   opts: SortTrimFlattenOptions,
 ): number | null {
-  const a = aNode.item.value
-  const b = bNode.item.value
-  const { opDid, prioritizeFollowedUsers, viewer } = opts
+  if (!isPostNode(aNode)) {
+    return null
+  }
+  if (!isPostNode(bNode)) {
+    return null
+  }
+
+  const {
+    opDid,
+    prioritizeFollowedUsers,
+    viewer,
+    threadTagsBumpDown,
+    threadTagsHide,
+  } = opts
 
   type BumpDirection = 'up' | 'down'
-  type BumpPredicateFn = (i: ThreadItemPost | ThreadHiddenItemPost) => boolean
+  type BumpPredicateFn = (i: ThreadMaybeHiddenPostNode) => boolean
 
   const maybeBump = (
     bump: BumpDirection,
     predicateFn: BumpPredicateFn,
   ): number | null => {
-    const aPredicate = predicateFn(a)
-    const bPredicate = predicateFn(b)
+    const aPredicate = predicateFn(aNode)
+    const bPredicate = predicateFn(bNode)
     if (aPredicate && bPredicate) {
       return applySorting(aNode, bNode, opts)
     } else if (aPredicate) {
@@ -218,21 +213,56 @@ function applyBumping(
   // Bumps-up applied first make the item appear higher in the list than later bumps-up.
   // Bumps-down applied first make the item appear lower in the list than later bumps-down.
   const bumps: [BumpDirection, BumpPredicateFn][] = [
+    /*
+      General bumps.
+    */
     // OP replies.
-    ['up', (i) => i.post.author.did === opDid],
+    ['up', (i) => i.item.value.post.author.did === opDid],
     // Viewer replies.
-    ['up', (i) => i.post.author.did === viewer],
-    // Muted account by the viewer.
-    ['down', (i) => isThreadHiddenItemPost(i) && i.mutedByViewer],
-    // Hidden by threadgate.
-    ['down', (i) => isThreadHiddenItemPost(i) && i.hiddenByThreadgate],
+    ['up', (i) => i.item.value.post.author.did === viewer],
+
+    /*
+      Bumps within visible replies.
+    */
+    // Followers posts.
+    [
+      'up',
+      (i) =>
+        i.type === 'post' &&
+        prioritizeFollowedUsers &&
+        !!i.item.value.post.author.viewer?.following,
+    ],
+    // Bump-down tags.
+    [
+      'down',
+      (i) => i.type === 'post' && threadTagsBumpDown.some((t) => i.tags.has(t)),
+    ],
     // Pushpin-only.
     [
       'down',
-      (i) => isPostRecord(i.post.record) && i.post.record.text.trim() === '📌',
+      (i) =>
+        i.type === 'post' &&
+        isPostRecord(i.item.value.post.record) &&
+        i.item.value.post.record.text.trim() === '📌',
     ],
-    // Followers posts.
-    ['up', (i) => prioritizeFollowedUsers && !!i.post.author.viewer?.following],
+
+    /*
+      Bumps within hidden replies.
+      This determines the order of hidden replies:
+        1. hidden by threadgate.
+        2. hidden by tags.
+        3. muted by viewer.
+    */
+    // Muted account by the viewer.
+    ['down', (i) => i.type === 'hiddenPost' && i.item.value.mutedByViewer],
+    // Hidden by tags.
+    [
+      'down',
+      (i) =>
+        i.type === 'hiddenPost' && threadTagsHide.some((t) => i.tags.has(t)),
+    ],
+    // Hidden by threadgate.
+    ['down', (i) => i.type === 'hiddenPost' && i.item.value.hiddenByThreadgate],
   ]
 
   for (const [bump, predicateFn] of bumps) {
@@ -279,13 +309,11 @@ function topSortValue(likeCount: number, hasOPLike: boolean): number {
   return Math.log(3 + likeCount) * (hasOPLike ? 1.45 : 1.0)
 }
 
-function flattenTree<TItem extends ThreadItem | ThreadHiddenItem>(
-  tree: ThreadTree,
-): TItem[] {
+function flattenTree(tree: ThreadTree) {
   return [
     // All parents above.
     ...Array.from(
-      flattenInDirection<TItem>({
+      flattenInDirection({
         tree,
         direction: 'up',
       }),
@@ -293,11 +321,11 @@ function flattenTree<TItem extends ThreadItem | ThreadHiddenItem>(
 
     // The anchor.
     // In the case of hidden replies, the anchor item itself is undefined.
-    ...(tree.item.value ? ([tree.item] as TItem[]) : []),
+    ...(tree.item.value ? [tree.item] : []),
 
     // All replies below.
     ...Array.from(
-      flattenInDirection<TItem>({
+      flattenInDirection({
         tree,
         direction: 'down',
       }),
@@ -305,18 +333,18 @@ function flattenTree<TItem extends ThreadItem | ThreadHiddenItem>(
   ]
 }
 
-function* flattenInDirection<TItem extends ThreadItem | ThreadHiddenItem>({
+function* flattenInDirection({
   tree,
   direction,
 }: {
   tree: ThreadTree
   direction: 'up' | 'down'
-}): Generator<TItem, void> {
+}) {
   if (tree.type === 'noUnauthenticated') {
     if (direction === 'up') {
       if (tree.parent) {
         // Unfold all parents above.
-        yield* flattenTree<TItem>(tree.parent)
+        yield* flattenTree(tree.parent)
       }
     }
   }
@@ -325,13 +353,13 @@ function* flattenInDirection<TItem extends ThreadItem | ThreadHiddenItem>({
     if (direction === 'up') {
       if (tree.parent) {
         // Unfold all parents above.
-        yield* flattenTree<TItem>(tree.parent)
+        yield* flattenTree(tree.parent)
       }
     } else {
       // Unfold all replies below.
       if (tree.replies?.length) {
         for (const reply of tree.replies) {
-          yield* flattenTree<TItem>(reply)
+          yield* flattenTree(reply)
         }
       }
     }
@@ -343,7 +371,7 @@ function* flattenInDirection<TItem extends ThreadItem | ThreadHiddenItem>({
       // Unfold all replies below.
       if (tree.replies?.length) {
         for (const reply of tree.replies) {
-          yield* flattenTree<TItem>(reply)
+          yield* flattenTree(reply)
         }
       }
     }