[Threads V2] Preliminary integration of unspecced V2 APIs (#8443)

* WIP

* Sorting working

* Rough handling of hidden/muted

* Better muted/hidden sorting and handling

* Clarify some naming

* Fix parents

* Handle first reply under highlighted/composer

* WIP RaW

* WIP optimistic

* Optimistic WIP

* Little cleanup, inserting dupes

* Re-org

* Add in new optimistic insert logic

* Update types

* Sorta working linear view optimistic state

* Simple working version, no pref for OP

* Working optimistic reply insertions, preference for OP

* Ensure deletes are coming through

* WIP scroll handling

* WIP scroll tweaks

* Clean up scrolling

* Clean up onPostSuccess

* Add annotations

* Fix highlighted post calc

* WIP kill me

* Update APIs

* Nvm don't kill me

* Fix optimistic insert

* Handle read more cases in tree view

* Basically working read more

* Handle linear view

* Reorg

* More reorg

* Split up thread post components

* New reply tree layout

* Fix up traversal metadata

* Tighten some spacing

* Use indent ya idiot

* Some linear mode cleanup

* Fix lines on read more items

* Vibe coding to success

* Almost there with read mores

* Update APIs

* Bump sdk

* Update import

* Checkpoint new traversal

* Checkpoint cleanup

* Checkpoint, need to fix blocked posts

* Checkpoint: think we're good, needs more cleanup

* Clean it up

* Two passes only

* Set to default params, update comment

* Fix render bug on native

* Checkpoint parent rendering, can opt for slower handling here

* Clean up parent handling, reply handling

* Fix read more extra space

* Fix read more in linear view

* Fix hidden reply handling, seen count, before/after calc

* Update naming

* Rename Slice to ThreadItem

* Add basic post and anchor skeletons

* Refactor client-side hidden

* WIP hidden fetching

* Update types

* Clean up query a bit

* Scrolling still broken

* Ok maybe fix scrolling

* Checkpoint move state into meta query

* Don't load remote hidden items unless needed

* skeleton view

* Reset hidden items when params change

* Split up traversal and avoid multiple passes

* Clean up

* Checkpoint: handling exhausted replies

* Clean up traversal functions further

* Clean up pagination

* Limit optimistic reply depth

* Handle optimistic insert in hidden replies

* Share root query key for easier cache extraction

* Make blurred posts not look like ass

* Fix double deleted item

* Make optimistic deleted state not look like crap in tree view

* Fix parents traversal 4 real

* Rename tree post

* Make optimistic deletions of linear posts not look bad

* Rename linear post components

* Handle tombstone views

* Rename read more component

* Add moreParents handling

* Align interaction states of read more

* Fix read more on FF

* Tree view skeleton

* Reply composer skele

* Remove hack for showing more replies

* Checkpoint: sort change scrolling fixed

* Checkpoint: learned new things, reset to base

* Feature gate

* Rename

* Replace show more

* Update settings screen

* Update pkg and endpoint

* Remove console

* Eureka

* Cleanup last commit

* No tests atm

* Remove scroll provider

* Clean up callbacks, better error state

* Remove todo

* Remove todo

* Remove todos

* Format

* Ok I think scrolling is solid

* Add back mobile compose input

* Ok need to compute headerHeight every time

* Update comments

* Ok button up web too

* Threads v2 tweaks (#8467)

* fix error screen collapsing

* use personx icon for blocked posts

* Remove height/width

* Revert unused Header change

* Clarify code

* Relate consts to theme values

* Remove debug code

* Typo

* Fix debounce of threads prefs

* Update metadata comments, dev mode

* Missed a spot

* Clean up todo

* Fix up no-unauthenticated posts

* Truncate parents if no-unauth

* Update getBranch docs

* Remove debug code

* Expand fetching in some cases

* Clear scroll need for root post to fix jump bug

* Fix reply composer skeleton state

* Remove uneeded initialized value

* Add profile shadow cache

* Some metrics

* prettier tweak

* eslint ignore

* Fix optimistic insertion

* Typo

* Rename, comment

* Remove wait

* Counter naming

* Replies seen counter for moderated sub-trees

* Remove borders on skeleton

* Align tombstone with optimistic deletion state

* Fix optimistic deletion for thread

* Add tree view icon

* Rename

* Cleanup

* Update settings copy

* Header menu open metric

* Bump package

* Better reply prompt (#8474)

* restyle reply prompt

* hide bottom bar border for cleaner look

* use new border hiding hook in DMs

* create `transparentifyColor` function

* adjust padding

* fix padding in immersive lpayer

* Apply suggestions from code review

Co-authored-by: surfdude29 <149612116+surfdude29@users.noreply.github.com>

* Integrate post-source

(cherry picked from commit fe053e9b38395a4fcb30a4367bc800f64ea84fe9)

---------

Co-authored-by: Samuel Newman <mozzius@protonmail.com>
Co-authored-by: surfdude29 <149612116+surfdude29@users.noreply.github.com>

1 files changed, 179 insertions, 0 deletions

diff --git a/src/state/queries/preferences/useThreadPreferences.ts b/src/state/queries/preferences/useThreadPreferences.ts
new file mode 100644
index 000000000..dc3122a72
--- /dev/null
+++ b/src/state/queries/preferences/useThreadPreferences.ts
@@ -0,0 +1,179 @@
+import {useCallback, useMemo, useRef, useState} from 'react'
+import {type AppBskyUnspeccedGetPostThreadV2} from '@atproto/api'
+import debounce from 'lodash.debounce'
+
+import {OnceKey, useCallOnce} from '#/lib/hooks/useCallOnce'
+import {logger} from '#/logger'
+import {
+  usePreferencesQuery,
+  useSetThreadViewPreferencesMutation,
+} from '#/state/queries/preferences'
+import {type ThreadViewPreferences} from '#/state/queries/preferences/types'
+import {type Literal} from '#/types/utils'
+
+export type ThreadSortOption = Literal<
+  AppBskyUnspeccedGetPostThreadV2.QueryParams['sort'],
+  string
+>
+export type ThreadViewOption = 'linear' | 'tree'
+export type ThreadPreferences = {
+  isLoaded: boolean
+  isSaving: boolean
+  sort: ThreadSortOption
+  setSort: (sort: string) => void
+  view: ThreadViewOption
+  setView: (view: ThreadViewOption) => void
+  prioritizeFollowedUsers: boolean
+  setPrioritizeFollowedUsers: (prioritize: boolean) => void
+}
+
+export function useThreadPreferences({
+  save,
+}: {save?: boolean} = {}): ThreadPreferences {
+  const {data: preferences} = usePreferencesQuery()
+  const serverPrefs = preferences?.threadViewPrefs
+  const once = useCallOnce(OnceKey.PreferencesThread)
+
+  /*
+   * Create local state representations of server state
+   */
+  const [sort, setSort] = useState(normalizeSort(serverPrefs?.sort || 'top'))
+  const [view, setView] = useState(
+    normalizeView({
+      treeViewEnabled: !!serverPrefs?.lab_treeViewEnabled,
+    }),
+  )
+  const [prioritizeFollowedUsers, setPrioritizeFollowedUsers] = useState(
+    !!serverPrefs?.prioritizeFollowedUsers,
+  )
+
+  /**
+   * If we get a server update, update local state
+   */
+  const [prevServerPrefs, setPrevServerPrefs] = useState(serverPrefs)
+  const isLoaded = !!prevServerPrefs
+  if (serverPrefs && prevServerPrefs !== serverPrefs) {
+    setPrevServerPrefs(serverPrefs)
+
+    /*
+     * Update
+     */
+    setSort(normalizeSort(serverPrefs.sort))
+    setPrioritizeFollowedUsers(serverPrefs.prioritizeFollowedUsers)
+    setView(
+      normalizeView({
+        treeViewEnabled: !!serverPrefs.lab_treeViewEnabled,
+      }),
+    )
+
+    once(() => {
+      logger.metric('thread:preferences:load', {
+        sort: serverPrefs.sort,
+        view: serverPrefs.lab_treeViewEnabled ? 'tree' : 'linear',
+        prioritizeFollowedUsers: serverPrefs.prioritizeFollowedUsers,
+      })
+    })
+  }
+
+  const userUpdatedPrefs = useRef(false)
+  const [isSaving, setIsSaving] = useState(false)
+  const {mutateAsync} = useSetThreadViewPreferencesMutation()
+  const savePrefs = useMemo(() => {
+    return debounce(async (prefs: ThreadViewPreferences) => {
+      try {
+        setIsSaving(true)
+        await mutateAsync(prefs)
+        logger.metric('thread:preferences:update', {
+          sort: prefs.sort,
+          view: prefs.lab_treeViewEnabled ? 'tree' : 'linear',
+          prioritizeFollowedUsers: prefs.prioritizeFollowedUsers,
+        })
+      } catch (e) {
+        logger.error('useThreadPreferences failed to save', {
+          safeMessage: e,
+        })
+      } finally {
+        setIsSaving(false)
+      }
+    }, 4e3)
+  }, [mutateAsync])
+
+  if (save && userUpdatedPrefs.current) {
+    savePrefs({
+      sort,
+      prioritizeFollowedUsers,
+      lab_treeViewEnabled: view === 'tree',
+    })
+    userUpdatedPrefs.current = false
+  }
+
+  const setSortWrapped = useCallback(
+    (next: string) => {
+      userUpdatedPrefs.current = true
+      setSort(normalizeSort(next))
+    },
+    [setSort],
+  )
+  const setViewWrapped = useCallback(
+    (next: ThreadViewOption) => {
+      userUpdatedPrefs.current = true
+      setView(next)
+    },
+    [setView],
+  )
+  const setPrioritizeFollowedUsersWrapped = useCallback(
+    (next: boolean) => {
+      userUpdatedPrefs.current = true
+      setPrioritizeFollowedUsers(next)
+    },
+    [setPrioritizeFollowedUsers],
+  )
+
+  return useMemo(
+    () => ({
+      isLoaded,
+      isSaving,
+      sort,
+      setSort: setSortWrapped,
+      view,
+      setView: setViewWrapped,
+      prioritizeFollowedUsers,
+      setPrioritizeFollowedUsers: setPrioritizeFollowedUsersWrapped,
+    }),
+    [
+      isLoaded,
+      isSaving,
+      sort,
+      setSortWrapped,
+      view,
+      setViewWrapped,
+      prioritizeFollowedUsers,
+      setPrioritizeFollowedUsersWrapped,
+    ],
+  )
+}
+
+/**
+ * Migrates user thread preferences from the old sort values to V2
+ */
+export function normalizeSort(sort: string): ThreadSortOption {
+  switch (sort) {
+    case 'oldest':
+      return 'oldest'
+    case 'newest':
+      return 'newest'
+    default:
+      return 'top'
+  }
+}
+
+/**
+ * Transforms existing treeViewEnabled preference into a ThreadViewOption
+ */
+export function normalizeView({
+  treeViewEnabled,
+}: {
+  treeViewEnabled: boolean
+}): ThreadViewOption {
+  return treeViewEnabled ? 'tree' : 'linear'
+}