Enhancements to live comments

components/comment.js

@@ -97,7 +97,7 @@ export function CommentFlat ({ item, rank, siblingComments, ...props }) {
 }
 
 export default function Comment ({
-  item, children, replyOpen, includeParent, topLevel,
+  item, children, replyOpen, includeParent, topLevel, rootLastCommentAt,
   rootText, noComments, noReply, truncate, depth, pin, setDisableRetry, disableRetry
 }) {
   const [edit, setEdit] = useState()
@@ -141,12 +141,20 @@ export default function Comment ({
   }, [item.id, cache, router.query.commentId])
 
   useEffect(() => {
+    if (me?.id === item.user?.id) return
+    const itemCreatedAt = new Date(item.createdAt).getTime()
+
     if (router.query.commentsViewedAt &&
-        me?.id !== item.user?.id &&
-        new Date(item.createdAt).getTime() > router.query.commentsViewedAt) {
+        !item.injected &&
+        itemCreatedAt > router.query.commentsViewedAt) {
       ref.current.classList.add('outline-new-comment')
+    // newly injected comments have to use a different class to outline every new comment
+    } else if (rootLastCommentAt &&
+              item.injected &&
+              itemCreatedAt > new Date(rootLastCommentAt).getTime()) {
+      ref.current.classList.add('outline-new-injected-comment')
     }
-  }, [item.id])
+  }, [item.id, rootLastCommentAt])
 
   const bottomedOut = depth === COMMENT_DEPTH_LIMIT || (item.comments?.comments.length === 0 && item.nDirectComments > 0)
   // Don't show OP badge when anon user comments on anon user posts
@@ -261,19 +269,17 @@ export default function Comment ({
                 : !noReply &&
                   <Reply depth={depth + 1} item={item} replyOpen={replyOpen} onCancelQuote={cancelQuote} onQuoteReply={quoteReply} quote={quote}>
                     {root.bounty && !bountyPaid && <PayBounty item={item} />}
-                    {item.newComments?.length > 0 && (
-                      <div className='ms-auto'>
-                        <ShowNewComments item={item} depth={depth} />
-                      </div>
-                    )}
+                    <div className='ms-auto'>
+                      <ShowNewComments item={item} depth={depth} />
+                    </div>
                   </Reply>}
               {children}
               <div className={styles.comments}>
                 {!noComments && item.comments?.comments
                   ? (
                     <>
                       {item.comments.comments.map((item) => (
-                        <Comment depth={depth + 1} key={item.id} item={item} />
+                        <Comment depth={depth + 1} key={item.id} item={item} rootLastCommentAt={rootLastCommentAt} />
                       ))}
                       {item.comments.comments.length < item.nDirectComments && <ViewAllReplies id={item.id} nhas={item.ncomments} />}
                     </>

components/comment.module.css

@@ -147,15 +147,33 @@
 
 @keyframes pulse {
     0% {
-        background-color: #FADA5E;
+        background-color: #80d3ff;
         opacity: 0.7;
     }
     50% {
-        background-color: #F6911D;
+        background-color: #007cbe;
         opacity: 1;
     }
     100% {
-        background-color: #FADA5E;
+        background-color: #80d3ff;
         opacity: 0.7;
     }
-}
+}
+
+.floatingComments {
+    position: fixed;
+    top: 72px;
+    left: 50%;
+    transform: translateX(-50%);
+    z-index: 1050;
+    animation: slideDown 0.3s ease-out;
+}
+
+@keyframes slideDown {
+    0% {
+        transform: translateX(-50%) translateY(-100px);
+    }
+    100% {
+        transform: translateX(-50%) translateY(0);
+    }
+}

components/comments.js

@@ -76,7 +76,7 @@ export default function Comments ({
 
   return (
     <>
-      <ShowNewComments item={item} sort={router.query.sort} />
+      <ShowNewComments topLevel item={item} sort={router.query.sort} />
       {comments?.length > 0
         ? <CommentsHeader
             commentSats={commentSats} parentCreatedAt={parentCreatedAt}
@@ -95,11 +95,11 @@ export default function Comments ({
         : null}
       {pins.map(item => (
         <Fragment key={item.id}>
-          <Comment depth={1} item={item} {...props} pin />
+          <Comment depth={1} item={item} rootLastCommentAt={lastCommentAt} {...props} pin />
         </Fragment>
       ))}
       {comments.filter(({ position }) => !position).map(item => (
-        <Comment depth={1} key={item.id} item={item} {...props} />
+        <Comment depth={1} key={item.id} item={item} rootLastCommentAt={lastCommentAt} {...props} />
       ))}
       {ncomments > FULL_COMMENTS_THRESHOLD &&
         <MoreFooter

components/show-new-comments.js

@@ -1,8 +1,10 @@
-import { useCallback } from 'react'
+import { useCallback, useRef } from 'react'
 import { useApolloClient } from '@apollo/client'
 import styles from './comment.module.css'
 import { COMMENT_DEPTH_LIMIT } from '../lib/constants'
 import { commentsViewedAfterComment } from '../lib/new-comments'
+import classNames from 'classnames'
+import useVisibility from './use-visibility'
 import {
   itemUpdateQuery,
   commentUpdateFragment,
@@ -18,118 +20,180 @@ function dedupeNewComments (newComments, comments = []) {
   return newComments.filter(id => !existingIds.has(id))
 }
 
+// of an array of new comments, count each new comment + all their existing comments
+function countNComments (newComments) {
+  let totalNComments = newComments.length
+  for (const comment of newComments) {
+    totalNComments += comment.ncomments || 0
+  }
+  return totalNComments
+}
+
 // prepares and creates a new comments fragment for injection into the cache
 // returns a function that can be used to update an item's comments field
-function prepareComments ({ client, newComments }) {
-  return (data) => {
-    // count total comments being injected: each new comment + all their existing nested comments
-    let totalNComments = newComments.length
-    for (const comment of newComments) {
-      // add all nested comments (subtree) under this newly injected comment to the total
-      totalNComments += (comment.ncomments || 0)
-    }
+function prepareComments (data, client, newComments) {
+  const totalNComments = countNComments(newComments)
+
+  const itemHierarchy = data.path.split('.')
+  const ancestors = itemHierarchy.slice(0, -1)
+  const rootId = itemHierarchy[0]
+
+  // update all ancestors, but not the item itself
+  updateAncestorsCommentCount(client.cache, ancestors, totalNComments)
+
+  // update commentsViewedAt with the most recent fresh new comment
+  // quirk: this is not the most recent comment, it's the most recent comment in the newComments array
+  //        as such, the next visit will not outline other new comments that are older than this one.
+  const latestCommentCreatedAt = getLatestCommentCreatedAt(newComments, data.createdAt)
+  commentsViewedAfterComment(rootId, latestCommentCreatedAt, totalNComments)
+
+  // an item can either have a comments.comments field, or not
+  const payload = data.comments
+    ? {
+        ...data,
+        ncomments: data.ncomments + totalNComments,
+        newComments: [],
+        comments: {
+          ...data.comments,
+          comments: newComments.concat(data.comments.comments)
+        }
+      }
+    // when the fragment doesn't have a comments field, we just update stats fields
+    : {
+        ...data,
+        ncomments: data.ncomments + totalNComments,
+        newComments: []
+      }
 
-    // update all ancestors, but not the item itself
-    const ancestors = data.path.split('.').slice(0, -1)
-    updateAncestorsCommentCount(client.cache, ancestors, totalNComments)
-
-    // update commentsViewedAt with the most recent fresh new comment
-    // quirk: this is not the most recent comment, it's the most recent comment in the newComments array
-    //        as such, the next visit will not outline other new comments that are older than this one.
-    const latestCommentCreatedAt = getLatestCommentCreatedAt(newComments, data.createdAt)
-    const rootId = data.path.split('.')[0]
-    commentsViewedAfterComment(rootId, latestCommentCreatedAt, totalNComments)
-
-    // return the updated item with the new comments injected
-    return {
-      ...data,
-      comments: { ...data.comments, comments: [...newComments, ...(data.comments?.comments || [])] },
-      ncomments: data.ncomments + totalNComments,
-      newComments: []
-    }
-  }
+  return payload
 }
 
 // traverses all new comments and their children
-// at each level, we can execute a callback giving the new comments and the item
-function traverseNewComments (client, item, onLevel, currentDepth = 1) {
-  if (currentDepth > COMMENT_DEPTH_LIMIT) return
+// if we're showing all new comments of a thread, we also consider their existing children
+function traverseNewComments (client, item, onLevel, threadComment = false, currentDepth = 1) {
+  // if we're at the depth limit, stop traversing, we've reached the bottom of the visible thread
+  if (currentDepth >= COMMENT_DEPTH_LIMIT) return
 
   if (item.newComments && item.newComments.length > 0) {
     const dedupedNewComments = dedupeNewComments(item.newComments, item.comments?.comments)
 
     // being newComments an array of comment ids, we can get their latest version from the cache
     // ensuring that we don't miss any new comments
     const freshNewComments = dedupedNewComments.map(id => {
-      return readCommentsFragment(client, id)
+      // mark all new comments as injected, so we can outline them
+      return { ...readCommentsFragment(client, id), injected: true }
     }).filter(Boolean)
 
-    // passing currentDepth allows children of top level comments
-    // to be updated by the commentUpdateFragment
-    onLevel(freshNewComments, item, currentDepth)
+    // at each level, we can execute a callback passing the current item's new comments, depth and ID
+    onLevel(freshNewComments, currentDepth, item.id)
 
     for (const newComment of freshNewComments) {
-      traverseNewComments(client, newComment, onLevel, currentDepth + 1)
+      traverseNewComments(client, newComment, onLevel, threadComment, currentDepth + 1)
+    }
+  }
+
+  // if we're showing all new comments of a thread
+  // we consider every child comment recursively
+  if (threadComment && item.comments?.comments) {
+    for (const child of item.comments.comments) {
+      traverseNewComments(client, child, onLevel, threadComment, currentDepth + 1)
     }
   }
 }
 
-// recursively processes and displays all new comments and its children
+// recursively processes and displays all new comments
 // handles comment injection at each level, respecting depth limits
-function injectNewComments (client, item, currentDepth, sort) {
-  traverseNewComments(client, item, (newComments, item, depth) => {
+function injectNewComments (client, item, currentDepth, sort, threadComment = false) {
+  traverseNewComments(client, item, (newComments, depth, itemId) => {
     if (newComments.length > 0) {
-      const payload = prepareComments({ client, newComments })
-
-      // used to determine if by iterating through the new comments
-      // we are injecting topLevels (depth 0) or not
+      // traverseNewComments also passes the depth of the current item
+      // used to determine if in an array of new comments, we are injecting topLevels (depth 0) or not
       if (depth === 0) {
-        itemUpdateQuery(client, item.id, sort, payload)
+        itemUpdateQuery(client, itemId, sort, (data) => prepareComments(data, client, newComments))
       } else {
-        commentUpdateFragment(client, item.id, payload)
+        commentUpdateFragment(client, itemId, (data) => prepareComments(data, client, newComments))
       }
     }
-  }, currentDepth)
+  }, threadComment, currentDepth)
 }
 
-// counts all new comments for an item and its children
-function countAllNewComments (client, item, currentDepth = 1) {
-  let totalNComments = 0
+// counts all new comments of an item
+function countAllNewComments (client, item, thread = false, currentDepth = 1) {
+  let newCommentsCount = 0
+  let threadChildren = false
+
+  // count by traversing the comment structure
+  traverseNewComments(client, item, (newComments, depth) => {
+    newCommentsCount += countNComments(newComments)
 
-  // count by traversing all new comments and their children
-  traverseNewComments(client, item, (newComments) => {
-    totalNComments += newComments.length
-    for (const newComment of newComments) {
-      totalNComments += newComment.ncomments || 0
+    // if we reached a depth greater than 1, the thread's children have new comments
+    if (depth > 1 && newComments.length > 0) {
+      threadChildren = true
     }
-  }, currentDepth)
+  }, thread, currentDepth)
 
-  return totalNComments
+  return { newCommentsCount, threadChildren }
+}
+
+function FloatingComments ({ buttonRef, showNewComments, text }) {
+  // show the floating comments button only when we're past the main top level button
+  const isButtonVisible = useVisibility(buttonRef, { pastElement: true })
+
+  if (isButtonVisible) return null
+
+  return (
+    <span
+      className={classNames(styles.floatingComments, 'btn btn-sm btn-info')}
+      onClick={() => {
+        // show new comments as we scroll up
+        showNewComments()
+        buttonRef.current?.scrollIntoView({ behavior: 'smooth' })
+      }}
+    >
+      {text}
+    </span>
+  )
 }
 
 // ShowNewComments is a component that dedupes, refreshes and injects newComments into the comments field
-export function ShowNewComments ({ item, sort, depth = 0 }) {
+export function ShowNewComments ({ topLevel, item, sort, depth = 0 }) {
   const client = useApolloClient()
+  const ref = useRef(null)
+
+  // a thread is a top-level comment
+  const thread = item.path?.split('.').length === 2
 
   // recurse through all new comments and their children
-  const newCommentsCount = item.newComments?.length > 0 ? countAllNewComments(client, item, depth) : 0
+  // if the item is a thread, we consider every existing child comment
+  const { newCommentsCount, threadChildren } = countAllNewComments(client, item, thread, depth)
+
+  // only if the item is a thread and its children have new comments, we show "show all new comments"
+  const threadComment = thread && threadChildren
 
   const showNewComments = useCallback(() => {
-    // a top level comment doesn't have depth, we pass 0 to signify this
-    // other comments are injected from their depth
-    injectNewComments(client, item, depth, sort)
+    // a top level comment doesn't pass depth, we pass its default value of 0 to signify this
+    // child comments are injected from the depth they're at
+    injectNewComments(client, item, depth, sort, threadComment)
   }, [client, sort, item, depth])
 
+  const text = !threadComment
+    ? `${newCommentsCount} new comment${newCommentsCount > 1 ? 's' : ''}`
+    : 'show all new comments'
+
   return (
-    <span
-      onClick={showNewComments}
-      className='fw-bold d-flex align-items-center gap-2 px-3 pointer'
-      style={{ visibility: newCommentsCount > 0 ? 'visible' : 'hidden' }}
-    >
-      {newCommentsCount > 1
-        ? `${newCommentsCount} new comments`
-        : 'show new comment'}
-      <div className={styles.newCommentDot} />
-    </span>
+    <>
+      <span
+        ref={ref}
+        onClick={showNewComments}
+        className='fw-bold d-flex align-items-center gap-2 px-3 pointer'
+        style={{ visibility: newCommentsCount > 0 ? 'visible' : 'hidden' }}
+      >
+        {text}
+        <div className={styles.newCommentDot} />
+      </span>
+      {topLevel && newCommentsCount > 0 && (
+        <FloatingComments buttonRef={ref} showNewComments={showNewComments} text={text} />
+      )}
+    </>
   )
 }