@atproto/bsky 0.0.150 → 0.0.152

package/dist/views/index.js

@@ -11,6 +11,7 @@ const threadgate_1 = require("../lexicon/types/app/bsky/feed/threadgate");
 const service_1 = require("../lexicon/types/app/bsky/labeler/service");
 const defs_2 = require("../lexicon/types/com/atproto/label/defs");
 const uris_1 = require("../util/uris");
+const threads_v2_1 = require("./threads-v2");
 const types_1 = require("./types");
 const util_1 = require("./util");
 const notificationDeletedRecord = {
@@ -67,6 +68,10 @@ class Views {
             return true;
         return false;
     }
+    noUnauthenticatedPost(state, post) {
+        const isNoUnauthenticated = post.author.labels?.some((l) => l.val === '!no-unauthenticated');
+        return !state.ctx?.viewer && !!isNoUnauthenticated;
+    }
     viewerBlockExists(did, state) {
         const viewer = state.profileViewers?.get(did);
         if (!viewer)
@@ -649,7 +654,7 @@ class Views {
                 return;
             if (repost.record.subject.uri !== item.post.uri)
                 return;
-            reason = this.reasonRepost((0, uris_1.uriToDid)(item.repost.uri), repost, state);
+            reason = this.reasonRepost(item.repost.uri, repost, state);
             if (!reason)
                 return;
         }
@@ -728,13 +733,16 @@ class Views {
             notFound: true,
         };
     }
-    reasonRepost(creatorDid, repost, state) {
+    reasonRepost(uri, repost, state) {
+        const creatorDid = (0, uris_1.uriToDid)(uri);
         const creator = this.profileBasic(creatorDid, state);
         if (!creator)
             return;
         return {
             $type: 'app.bsky.feed.defs#reasonRepost',
             by: creator,
+            uri,
+            cid: repost.cid,
             indexedAt: this.indexedAt(repost).toISOString(),
         };
     }
@@ -848,6 +856,464 @@ class Views {
             };
         });
     }
+    // Threads V2
+    // ------------
+    threadV2(skeleton, state, { above, below, branchingFactor, prioritizeFollowedUsers, sort, }) {
+        const { anchor: anchorUri, uris } = skeleton;
+        // Not found.
+        const postView = this.post(anchorUri, state);
+        const post = state.posts?.get(anchorUri);
+        if (!post || !postView) {
+            return {
+                hasHiddenReplies: false,
+                thread: [
+                    this.threadV2ItemNotFound({
+                        uri: anchorUri,
+                        depth: 0,
+                    }),
+                ],
+            };
+        }
+        // Blocked (only 1p for anchor).
+        if (this.viewerBlockExists(postView.author.did, state)) {
+            return {
+                hasHiddenReplies: false,
+                thread: [
+                    this.threadV2ItemBlocked({
+                        uri: anchorUri,
+                        depth: 0,
+                        authorDid: postView.author.did,
+                        state,
+                    }),
+                ],
+            };
+        }
+        const childrenByParentUri = this.groupThreadChildrenByParent(anchorUri, uris, state);
+        const rootUri = getRootUri(anchorUri, post);
+        const opDid = (0, uris_1.uriToDid)(rootUri);
+        const authorDid = postView.author.did;
+        const isOPPost = authorDid === opDid;
+        const anchorViolatesThreadGate = post.violatesThreadGate;
+        // Builds the parent tree, and whether it is a contiguous OP thread.
+        const parentTree = !anchorViolatesThreadGate
+            ? this.threadV2Parent({
+                childUri: anchorUri,
+                opDid,
+                rootUri,
+                above,
+                depth: -1,
+            }, state)
+            : undefined;
+        const { tree: parent, isOPThread: isOPThreadFromRootToParent } = parentTree ?? { tree: undefined, isOPThread: false };
+        const isOPThread = parent
+            ? isOPThreadFromRootToParent && isOPPost
+            : isOPPost;
+        const anchorDepth = 0; // The depth of the anchor post is always 0.
+        let anchorTree;
+        let hasHiddenReplies = false;
+        if (this.noUnauthenticatedPost(state, postView)) {
+            anchorTree = {
+                type: 'noUnauthenticated',
+                item: this.threadV2ItemNoUnauthenticated({
+                    uri: anchorUri,
+                    depth: anchorDepth,
+                }),
+                parent,
+            };
+        }
+        else {
+            const { replies, hasHiddenReplies: hasHiddenRepliesShadow } = !anchorViolatesThreadGate
+                ? this.threadV2Replies({
+                    parentUri: anchorUri,
+                    isOPThread,
+                    opDid,
+                    rootUri,
+                    childrenByParentUri,
+                    below,
+                    depth: 1,
+                    branchingFactor,
+                }, state)
+                : { replies: undefined, hasHiddenReplies: false };
+            hasHiddenReplies = hasHiddenRepliesShadow;
+            anchorTree = {
+                type: 'post',
+                item: this.threadV2ItemPost({
+                    depth: anchorDepth,
+                    isOPThread,
+                    postView,
+                    repliesAllowance: Infinity, // While we don't have pagination.
+                    uri: anchorUri,
+                }),
+                hasOPLike: !!state.threadContexts?.get(postView.uri)?.like,
+                parent,
+                replies,
+            };
+        }
+        const thread = (0, threads_v2_1.sortTrimFlattenThreadTree)(anchorTree, {
+            opDid,
+            branchingFactor,
+            sort,
+            prioritizeFollowedUsers,
+            viewer: state.ctx?.viewer ?? null,
+            fetchedAt: Date.now(),
+        });
+        return {
+            hasHiddenReplies,
+            thread,
+        };
+    }
+    threadV2Parent({ childUri, opDid, rootUri, above, depth, }, state) {
+        // Reached the `above` limit.
+        if (Math.abs(depth) > above) {
+            return undefined;
+        }
+        // Not found.
+        const uri = state.posts?.get(childUri)?.record.reply?.parent.uri;
+        if (!uri) {
+            return undefined;
+        }
+        const postView = this.post(uri, state);
+        const post = state.posts?.get(uri);
+        if (!post || !postView) {
+            return {
+                tree: {
+                    type: 'notFound',
+                    item: this.threadV2ItemNotFound({ uri, depth }),
+                },
+                isOPThread: false,
+            };
+        }
+        if (rootUri !== getRootUri(uri, post)) {
+            // Outside thread boundary.
+            return undefined;
+        }
+        // Blocked (1p and 3p for parent).
+        const authorDid = postView.author.did;
+        const has1pBlock = this.viewerBlockExists(authorDid, state);
+        const has3pBlock = !state.ctx?.include3pBlocks && state.postBlocks?.get(childUri)?.parent;
+        if (has1pBlock || has3pBlock) {
+            return {
+                tree: {
+                    type: 'blocked',
+                    item: this.threadV2ItemBlocked({
+                        uri,
+                        depth,
+                        authorDid,
+                        state,
+                    }),
+                },
+                isOPThread: false,
+            };
+        }
+        // Recurse up.
+        const parentTree = this.threadV2Parent({
+            childUri: uri,
+            opDid,
+            rootUri,
+            above,
+            depth: depth - 1,
+        }, state);
+        const { tree: parent, isOPThread: isOPThreadFromRootToParent } = parentTree ?? { tree: undefined, isOPThread: false };
+        const isOPPost = authorDid === opDid;
+        const isOPThread = parent
+            ? isOPThreadFromRootToParent && isOPPost
+            : isOPPost;
+        if (this.noUnauthenticatedPost(state, postView)) {
+            return {
+                tree: {
+                    type: 'noUnauthenticated',
+                    item: this.threadV2ItemNoUnauthenticated({
+                        uri,
+                        depth,
+                    }),
+                    parent,
+                },
+                isOPThread,
+            };
+        }
+        const parentUri = post.record.reply?.parent.uri;
+        const hasMoreParents = !!parentUri && !parent;
+        return {
+            tree: {
+                type: 'post',
+                item: this.threadV2ItemPost({
+                    depth,
+                    isOPThread,
+                    moreParents: hasMoreParents,
+                    postView,
+                    uri,
+                }),
+                hasOPLike: !!state.threadContexts?.get(postView.uri)?.like,
+                parent,
+                replies: undefined,
+            },
+            isOPThread,
+        };
+    }
+    threadV2Replies({ parentUri, isOPThread: isOPThreadFromRootToParent, opDid, rootUri, childrenByParentUri, below, depth, branchingFactor, }, state) {
+        // Reached the `below` limit.
+        if (depth > below) {
+            return { replies: undefined, hasHiddenReplies: false };
+        }
+        const childrenUris = childrenByParentUri[parentUri] ?? [];
+        let hasHiddenReplies = false;
+        const replies = (0, common_1.mapDefined)(childrenUris, (uri) => {
+            const replyInclusion = this.checkThreadV2ReplyInclusion(uri, rootUri, state);
+            if (!replyInclusion) {
+                return undefined;
+            }
+            const { authorDid, postView } = replyInclusion;
+            // Hidden.
+            const { hiddenByThreadgate, mutedByViewer } = this.isHiddenThreadPost({ rootUri, uri }, state);
+            // Is hidden reply.
+            if (hiddenByThreadgate || mutedByViewer) {
+                // Only care about anchor replies
+                if (depth === 1) {
+                    hasHiddenReplies = true;
+                }
+                return undefined;
+            }
+            // Recurse down.
+            const isOPThread = isOPThreadFromRootToParent && authorDid === opDid;
+            const { replies: nestedReplies } = this.threadV2Replies({
+                parentUri: uri,
+                isOPThread,
+                opDid,
+                rootUri,
+                childrenByParentUri,
+                below,
+                depth: depth + 1,
+                branchingFactor,
+            }, state);
+            const reachedDepth = depth === below;
+            const repliesAllowance = reachedDepth ? 0 : branchingFactor;
+            const tree = {
+                type: 'post',
+                item: this.threadV2ItemPost({
+                    depth,
+                    isOPThread,
+                    postView,
+                    repliesAllowance,
+                    uri,
+                }),
+                hasOPLike: !!state.threadContexts?.get(postView.uri)?.like,
+                parent: undefined,
+                replies: nestedReplies,
+            };
+            return tree;
+        });
+        return {
+            replies,
+            hasHiddenReplies,
+        };
+    }
+    threadV2ItemPost({ depth, isOPThread, moreParents, postView, repliesAllowance, uri, }) {
+        const moreReplies = repliesAllowance === undefined
+            ? 0
+            : Math.max((postView.replyCount ?? 0) - repliesAllowance, 0);
+        return {
+            uri,
+            depth,
+            value: {
+                $type: 'app.bsky.unspecced.getPostThreadV2#threadItemPost',
+                post: postView,
+                moreParents: moreParents ?? false,
+                moreReplies,
+                opThread: isOPThread,
+            },
+        };
+    }
+    threadV2ItemNoUnauthenticated({ uri, depth, }) {
+        return {
+            uri,
+            depth,
+            value: {
+                $type: 'app.bsky.unspecced.getPostThreadV2#threadItemNoUnauthenticated',
+            },
+        };
+    }
+    threadV2ItemNotFound({ uri, depth, }) {
+        return {
+            uri,
+            depth,
+            value: {
+                $type: 'app.bsky.unspecced.getPostThreadV2#threadItemNotFound',
+            },
+        };
+    }
+    threadV2ItemBlocked({ uri, depth, authorDid, state, }) {
+        return {
+            uri,
+            depth,
+            value: {
+                $type: 'app.bsky.unspecced.getPostThreadV2#threadItemBlocked',
+                author: {
+                    did: authorDid,
+                    viewer: this.blockedProfileViewer(authorDid, state),
+                },
+            },
+        };
+    }
+    threadHiddenV2(skeleton, state, { below, branchingFactor, }) {
+        const { anchor: anchorUri, uris } = skeleton;
+        // Not found.
+        const postView = this.post(anchorUri, state);
+        const post = state.posts?.get(anchorUri);
+        if (!post || !postView) {
+            return [];
+        }
+        // Blocked (only 1p for anchor).
+        if (this.viewerBlockExists(postView.author.did, state)) {
+            return [];
+        }
+        const childrenByParentUri = this.groupThreadChildrenByParent(anchorUri, uris, state);
+        const rootUri = getRootUri(anchorUri, post);
+        const opDid = (0, uris_1.uriToDid)(rootUri);
+        const anchorTree = {
+            type: 'hiddenAnchor',
+            item: this.threadHiddenV2ItemPostAnchor({ depth: 0, uri: anchorUri }),
+            replies: this.threadHiddenV2Replies({
+                parentUri: anchorUri,
+                rootUri,
+                childrenByParentUri,
+                below,
+                depth: 1,
+            }, state),
+        };
+        return (0, threads_v2_1.sortTrimFlattenThreadTree)(anchorTree, {
+            opDid,
+            branchingFactor,
+            prioritizeFollowedUsers: false,
+            viewer: state.ctx?.viewer ?? null,
+            fetchedAt: Date.now(),
+        });
+    }
+    threadHiddenV2Replies({ parentUri, rootUri, childrenByParentUri, below, depth, }, state) {
+        // Reached the `below` limit.
+        if (depth > below) {
+            return undefined;
+        }
+        const childrenUris = childrenByParentUri[parentUri] ?? [];
+        return (0, common_1.mapDefined)(childrenUris, (uri) => {
+            const replyInclusion = this.checkThreadV2ReplyInclusion(uri, rootUri, state);
+            if (!replyInclusion) {
+                return undefined;
+            }
+            const { postView } = replyInclusion;
+            // Hidden.
+            const { hiddenByThreadgate, mutedByViewer } = this.isHiddenThreadPost({ rootUri, uri }, state);
+            // Is hidden reply.
+            if (hiddenByThreadgate || mutedByViewer) {
+                // Only show hidden anchor replies, not all hidden.
+                if (depth > 1) {
+                    return undefined;
+                }
+            }
+            else if (depth === 1) {
+                // Don't include non-hidden anchor replies.
+                return undefined;
+            }
+            // Recurse down.
+            const replies = this.threadHiddenV2Replies({
+                parentUri: uri,
+                rootUri,
+                childrenByParentUri,
+                below,
+                depth: depth + 1,
+            }, state);
+            const item = this.threadHiddenV2ItemPost({
+                depth,
+                postView,
+                rootUri,
+                uri,
+            }, state);
+            const tree = {
+                type: 'hiddenPost',
+                item: item,
+                replies,
+            };
+            return tree;
+        });
+    }
+    threadHiddenV2ItemPostAnchor({ depth, uri, }) {
+        return {
+            uri,
+            depth,
+            // In hidden replies, the anchor value is undefined, so it doesn't include the anchor in the result.
+            // This is helpful so we can use the same internal structure for hidden and non-hidden, while omitting anchor for hidden.
+            value: undefined,
+        };
+    }
+    threadHiddenV2ItemPost({ depth, postView, rootUri, uri, }, state) {
+        const { hiddenByThreadgate, mutedByViewer } = this.isHiddenThreadPost({ rootUri, uri }, state);
+        const base = this.threadHiddenV2ItemPostAnchor({ depth, uri });
+        return {
+            ...base,
+            value: {
+                $type: 'app.bsky.unspecced.getPostThreadHiddenV2#threadHiddenItemPost',
+                post: postView,
+                hiddenByThreadgate,
+                mutedByViewer,
+            },
+        };
+    }
+    checkThreadV2ReplyInclusion(uri, rootUri, state) {
+        // Not found.
+        const post = state.posts?.get(uri);
+        if (post?.violatesThreadGate) {
+            return null;
+        }
+        const postView = this.post(uri, state);
+        if (!post || !postView) {
+            return null;
+        }
+        const authorDid = postView.author.did;
+        if (rootUri !== getRootUri(uri, post)) {
+            // outside thread boundary
+            return null;
+        }
+        // Blocked (1p and 3p for replies).
+        const has1pBlock = this.viewerBlockExists(authorDid, state);
+        const has3pBlock = !state.ctx?.include3pBlocks && state.postBlocks?.get(uri)?.parent;
+        if (has1pBlock || has3pBlock) {
+            return null;
+        }
+        if (!this.viewerSeesNeedsReview({ uri, did: authorDid }, state)) {
+            return null;
+        }
+        // No unauthenticated.
+        if (this.noUnauthenticatedPost(state, postView)) {
+            return null;
+        }
+        return { authorDid, postView };
+    }
+    isHiddenThreadPost({ rootUri, uri, }, state) {
+        const authorDid = (0, uris_1.uriToDid)(uri);
+        const hiddenByThreadgate = state.ctx?.viewer !== authorDid &&
+            this.replyIsHiddenByThreadgate(uri, rootUri, state);
+        const mutedByViewer = this.viewerMuteExists(authorDid, state);
+        return {
+            hiddenByThreadgate,
+            mutedByViewer,
+        };
+    }
+    groupThreadChildrenByParent(anchorUri, uris, state) {
+        // Groups children of each parent.
+        const includedPosts = new Set([anchorUri]);
+        const childrenByParentUri = {};
+        uris.forEach((uri) => {
+            const post = state.posts?.get(uri);
+            const parentUri = post?.record.reply?.parent.uri;
+            if (!parentUri)
+                return;
+            if (includedPosts.has(uri))
+                return;
+            includedPosts.add(uri);
+            childrenByParentUri[parentUri] ?? (childrenByParentUri[parentUri] = []);
+            childrenByParentUri[parentUri].push(uri);
+        });
+        return childrenByParentUri;
+    }
     // Embeds
     // ------------
     embed(postUri, embed, state, depth) {