@planningcenter/chat-react-native 3.38.0-rc.10 → 3.38.0-rc.11

package/build/utils/unread_divider_helpers.js

@@ -1,13 +0,0 @@
-export function dividerExitedTowardNewer({ changed, viewableItems, dividerKey, initialMessageId, }) {
-    const dividerExited = changed.some(c => c.key === dividerKey && !c.isViewable);
-    if (!dividerExited)
-        return false;
-    const visibleMessageIds = viewableItems
-        .filter(v => v.item?.type === 'Message')
-        .map(v => v.item?.id)
-        .filter((id) => !!id);
-    if (visibleMessageIds.length === 0)
-        return false;
-    return visibleMessageIds.every(id => id.localeCompare(initialMessageId) > 0);
-}
-//# sourceMappingURL=unread_divider_helpers.js.map

package/build/utils/unread_divider_helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unread_divider_helpers.js","sourceRoot":"","sources":["../../src/utils/unread_divider_helpers.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,wBAAwB,CAAC,EACvC,OAAO,EACP,aAAa,EACb,UAAU,EACV,gBAAgB,GAMjB;IACC,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,UAAU,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAA;IAC9E,IAAI,CAAC,aAAa;QAAE,OAAO,KAAK,CAAA;IAEhC,MAAM,iBAAiB,GAAG,aAAa;SACpC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,SAAS,CAAC;SACvC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,EAAE,EAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;IACrC,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IAEhD,OAAO,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,aAAa,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAA;AAC9E,CAAC","sourcesContent":["type ViewableChangeEntry = { key: string; isViewable: boolean }\ntype ViewableItem = { item: { id?: string; type?: string } }\n\nexport function dividerExitedTowardNewer({\n  changed,\n  viewableItems,\n  dividerKey,\n  initialMessageId,\n}: {\n  changed: ViewableChangeEntry[]\n  viewableItems: ViewableItem[]\n  dividerKey: string\n  initialMessageId: string\n}): boolean {\n  const dividerExited = changed.some(c => c.key === dividerKey && !c.isViewable)\n  if (!dividerExited) return false\n\n  const visibleMessageIds = viewableItems\n    .filter(v => v.item?.type === 'Message')\n    .map(v => v.item?.id)\n    .filter((id): id is string => !!id)\n  if (visibleMessageIds.length === 0) return false\n\n  return visibleMessageIds.every(id => id.localeCompare(initialMessageId) > 0)\n}\n"]}

package/src/__tests__/hooks/use_conversation_messages.test.tsx

@@ -1,109 +0,0 @@
-import { QueryClientProvider } from '@tanstack/react-query'
-import { act, renderHook } from '@testing-library/react-native'
-import React, { Suspense } from 'react'
-import { buildTestQueryClient } from '../../__utils__/query_client'
-import { ConversationContextProvider } from '../../contexts/conversation_context'
-import * as useApiClientModule from '../../hooks/use_api_client'
-import { useConversationMessages } from '../../hooks/use_conversation_messages'
-import { ApiCollection, MessageResource } from '../../types'
-
-const mockMessage = (id: string): MessageResource =>
-  ({
-    id,
-    type: 'Message',
-    text: `msg ${id}`,
-    attachments: [],
-    deletedAt: null,
-    replyRootId: null,
-  }) as MessageResource
-
-const apiResponse = (data: MessageResource[]): ApiCollection<MessageResource> => ({
-  data,
-  links: {},
-  meta: { count: data.length, totalCount: data.length, next: {} },
-})
-
-const createWrapper = (initialMessageId: string | null) => {
-  const queryClient = buildTestQueryClient()
-
-  return ({ children }: { children: React.ReactNode }) => (
-    <QueryClientProvider client={queryClient}>
-      <Suspense fallback={null}>
-        <ConversationContextProvider
-          conversationId={123}
-          currentPageReplyRootId={null}
-          initialMessageId={initialMessageId}
-          initialMessageIdIsAnchor={!!initialMessageId}
-        >
-          {children}
-        </ConversationContextProvider>
-      </Suspense>
-    </QueryClientProvider>
-  )
-}
-
-const flushPromises = async () => {
-  await act(async () => {
-    await Promise.resolve()
-    await Promise.resolve()
-    await Promise.resolve()
-    await Promise.resolve()
-  })
-}
-
-const mockApiClient = (get: jest.Mock) => {
-  jest.spyOn(useApiClientModule, 'useApiClient').mockReturnValue({
-    chat: { get },
-  } as unknown as ReturnType<typeof useApiClientModule.useApiClient>)
-}
-
-describe('useConversationMessages', () => {
-  afterEach(() => {
-    jest.restoreAllMocks()
-  })
-
-  it('fires two parallel seed requests with id_gte/asc and id_lt/desc when anchored', async () => {
-    const get = jest.fn(({ data }: { data: { where?: Record<string, string> } }) => {
-      if (data.where?.id_gte === '01B') {
-        return Promise.resolve(apiResponse([mockMessage('01C'), mockMessage('01B')]))
-      }
-      if (data.where?.id_lt === '01B') {
-        return Promise.resolve(apiResponse([mockMessage('01A')]))
-      }
-      return Promise.resolve(apiResponse([]))
-    })
-    mockApiClient(get)
-
-    renderHook(() => useConversationMessages({ conversation_id: 123 }), {
-      wrapper: createWrapper('01B'),
-    })
-    await flushPromises()
-
-    expect(get).toHaveBeenCalledTimes(2)
-    const requested = get.mock.calls.map(
-      ([req]: [{ data: { where?: Record<string, string>; order?: string } }]) => ({
-        where: req.data.where,
-        order: req.data.order,
-      })
-    )
-    expect(requested).toEqual(
-      expect.arrayContaining([
-        { where: { id_gte: '01B' }, order: 'asc' },
-        { where: { id_lt: '01B' }, order: 'desc' },
-      ])
-    )
-  })
-
-  it('fires one fetch with no cursor when not anchored', async () => {
-    const get = jest.fn(() => Promise.resolve(apiResponse([mockMessage('01A')])))
-    mockApiClient(get)
-
-    renderHook(() => useConversationMessages({ conversation_id: 123 }), {
-      wrapper: createWrapper(null),
-    })
-    await flushPromises()
-
-    expect(get).toHaveBeenCalledTimes(1)
-    expect(get.mock.calls[0][0].data.where).toBeUndefined()
-  })
-})

package/src/__tests__/hooks/use_mark_latest_message_read.test.tsx

@@ -1,154 +0,0 @@
-import { QueryClientProvider } from '@tanstack/react-query'
-import { renderHook } from '@testing-library/react-native'
-import React, { useEffect } from 'react'
-import { buildTestQueryClient } from '../../__utils__/query_client'
-import {
-  ConversationContextProvider,
-  useConversationContext,
-} from '../../contexts/conversation_context'
-import * as appStateModule from '../../hooks/use_app_state'
-import * as conversationsActionsModule from '../../hooks/use_conversations_actions'
-import * as featuresModule from '../../hooks/use_features'
-import { useMarkLatestMessageRead } from '../../hooks/use_mark_latest_message_read'
-import { ConversationResource } from '../../types'
-
-const conversation = {
-  id: 1,
-  type: 'Conversation',
-  unreadCount: 3,
-  unreadReactionCount: 0,
-  conversationMembership: { lastReadMessageSortKey: '01A' },
-} as unknown as ConversationResource
-
-interface WrapperProps {
-  replyRootId?: string | null
-  initialMessageIdIsAnchor?: boolean
-  atEndOfMessageHistory?: boolean
-}
-
-const createWrapper = ({
-  replyRootId = null,
-  initialMessageIdIsAnchor = false,
-  atEndOfMessageHistory = !initialMessageIdIsAnchor,
-}: WrapperProps = {}) => {
-  const queryClient = buildTestQueryClient()
-  const Wrapper = ({ children }: { children: React.ReactNode }) => (
-    <QueryClientProvider client={queryClient}>
-      <ConversationContextProvider
-        conversationId={1}
-        currentPageReplyRootId={replyRootId}
-        initialMessageId={initialMessageIdIsAnchor ? '01A' : null}
-        initialMessageIdIsAnchor={initialMessageIdIsAnchor}
-      >
-        <AtEndPrimer atEndOfMessageHistory={atEndOfMessageHistory}>{children}</AtEndPrimer>
-      </ConversationContextProvider>
-    </QueryClientProvider>
-  )
-  return Wrapper
-}
-
-const AtEndPrimer = ({
-  atEndOfMessageHistory,
-  children,
-}: {
-  atEndOfMessageHistory: boolean
-  children: React.ReactNode
-}) => {
-  const { setAtEndOfMessageHistory } = useConversationContext()
-  useEffect(() => {
-    setAtEndOfMessageHistory(atEndOfMessageHistory)
-  }, [atEndOfMessageHistory, setAtEndOfMessageHistory])
-  return <>{children}</>
-}
-
-const mockFeatures = (enabled: boolean) => {
-  jest.spyOn(featuresModule, 'useFeatures').mockReturnValue({
-    features: [],
-    featureEnabled: () => enabled,
-  })
-}
-
-const mockMarkRead = () => {
-  const markRead = jest.fn()
-  jest.spyOn(conversationsActionsModule, 'useConversationsMarkRead').mockReturnValue({
-    markRead,
-    read: false,
-  } as unknown as ReturnType<typeof conversationsActionsModule.useConversationsMarkRead>)
-  return markRead
-}
-
-const mockAppState = (state: string = 'active') => {
-  jest.spyOn(appStateModule, 'useAppState').mockReturnValue(state)
-}
-
-describe('useMarkLatestMessageRead', () => {
-  afterEach(() => {
-    jest.restoreAllMocks()
-  })
-
-  it('fires markRead when JTU is off (backward compat preserved)', () => {
-    mockAppState()
-    mockFeatures(false)
-    const markRead = mockMarkRead()
-
-    renderHook(() => useMarkLatestMessageRead({ conversation }), {
-      wrapper: createWrapper(),
-    })
-
-    expect(markRead).toHaveBeenCalledWith(true)
-  })
-
-  it('does NOT fire markRead when in a reply view (parity fix, ships flag-off)', () => {
-    mockAppState()
-    mockFeatures(false)
-    const markRead = mockMarkRead()
-
-    renderHook(() => useMarkLatestMessageRead({ conversation }), {
-      wrapper: createWrapper({ replyRootId: 'root-1' }),
-    })
-
-    expect(markRead).not.toHaveBeenCalled()
-  })
-
-  it('does NOT fire markRead when JTU is active and user is not at end of history', () => {
-    mockAppState()
-    mockFeatures(true)
-    const markRead = mockMarkRead()
-
-    renderHook(() => useMarkLatestMessageRead({ conversation }), {
-      wrapper: createWrapper({
-        initialMessageIdIsAnchor: true,
-        atEndOfMessageHistory: false,
-      }),
-    })
-
-    expect(markRead).not.toHaveBeenCalled()
-  })
-
-  it('fires markRead when JTU is active and user reaches end of history', () => {
-    mockAppState()
-    mockFeatures(true)
-    const markRead = mockMarkRead()
-
-    renderHook(() => useMarkLatestMessageRead({ conversation }), {
-      wrapper: createWrapper({
-        initialMessageIdIsAnchor: true,
-        atEndOfMessageHistory: true,
-      }),
-    })
-
-    expect(markRead).toHaveBeenCalledWith(true)
-  })
-
-  it('does NOT fire when app state is not active', () => {
-    mockAppState('background')
-    mockFeatures(false)
-    const markRead = mockMarkRead()
-
-    renderHook(() => useMarkLatestMessageRead({ conversation }), {
-      wrapper: createWrapper(),
-    })
-
-    expect(markRead).not.toHaveBeenCalled()
-  })
-})

package/src/__tests__/utils/cache/messages_cache.test.ts

@@ -1,54 +0,0 @@
-import { buildTestQueryClient } from '../../../__utils__/query_client'
-import { hasUnloadedNewerPages } from '../../../utils/cache/messages_cache'
-
-const queryKey = ['messages-test']
-
-const buildClient = (data: unknown) => {
-  const client = buildTestQueryClient()
-  client.setQueryData(queryKey, data)
-  return client
-}
-
-describe('hasUnloadedNewerPages', () => {
-  it('returns false when the query has no cached data', () => {
-    const client = buildTestQueryClient()
-    expect(hasUnloadedNewerPages(client, queryKey)).toBe(false)
-  })
-
-  it('returns false when pages[0] has no next.idGt cursor', () => {
-    const client = buildClient({
-      pageParams: [{}],
-      pages: [{ data: [], links: {}, meta: { count: 0, totalCount: 0 } }],
-    })
-    expect(hasUnloadedNewerPages(client, queryKey)).toBe(false)
-  })
-
-  it('returns false when next exists but idGt is absent', () => {
-    const client = buildClient({
-      pageParams: [{}],
-      pages: [{ data: [], links: {}, meta: { count: 0, totalCount: 0, next: { idLt: '01A' } } }],
-    })
-    expect(hasUnloadedNewerPages(client, queryKey)).toBe(false)
-  })
-
-  it('returns true when pages[0].meta.next.idGt is set', () => {
-    const client = buildClient({
-      pageParams: [{}],
-      pages: [
-        { data: [], links: {}, meta: { count: 0, totalCount: 0, next: { idGt: '01KQSTAY' } } },
-      ],
-    })
-    expect(hasUnloadedNewerPages(client, queryKey)).toBe(true)
-  })
-
-  it('inspects only the first page (the newest side after sort)', () => {
-    const client = buildClient({
-      pageParams: [{}, {}],
-      pages: [
-        { data: [], links: {}, meta: { count: 0, totalCount: 0 } },
-        { data: [], links: {}, meta: { count: 0, totalCount: 0, next: { idGt: '01KQSTAY' } } },
-      ],
-    })
-    expect(hasUnloadedNewerPages(client, queryKey)).toBe(false)
-  })
-})

package/src/components/conversation/unread_divider.tsx

@@ -1,90 +0,0 @@
-import { StyleSheet, View } from 'react-native'
-import Animated, { FadeIn, FadeOut } from 'react-native-reanimated'
-import Svg, { Defs, Path, Pattern, Rect } from 'react-native-svg'
-import { useConversationContext } from '../../contexts/conversation_context'
-import { useTheme } from '../../hooks'
-import { CONVERSATION_MESSAGE_LIST_PADDING_HORIZONTAL } from '../../utils/styles'
-import { Text } from '../display'
-
-interface UnreadDividerProps {
-  scrolledPast?: boolean
-}
-
-const WAVE_WIDTH = 16
-const WAVE_HEIGHT = 8
-const FADE_DURATION = 750
-
-export function UnreadDivider({ scrolledPast = false }: UnreadDividerProps) {
-  const styles = useStyles()
-  const { atEndOfMessageHistory } = useConversationContext()
-
-  if (scrolledPast || atEndOfMessageHistory) return null
-
-  return (
-    <Animated.View
-      entering={FadeIn.duration(FADE_DURATION)}
-      exiting={FadeOut.duration(FADE_DURATION)}
-      style={styles.container}
-      accessibilityRole="header"
-      accessibilityLabel="Unread messages start here"
-    >
-      <SquigglyLine />
-      <Text variant="footnote" style={styles.label}>
-        New
-      </Text>
-      <SquigglyLine />
-    </Animated.View>
-  )
-}
-
-function SquigglyLine() {
-  const { colors } = useTheme()
-  return (
-    <View style={squigglyStyle.container}>
-      <Svg width="100%" height={WAVE_HEIGHT}>
-        <Defs>
-          <Pattern
-            id="wave"
-            x="0"
-            y="0"
-            width={WAVE_WIDTH}
-            height={WAVE_HEIGHT}
-            patternUnits="userSpaceOnUse"
-          >
-            <Path
-              d="M 0 4 Q 4 0 8 4 T 16 4"
-              stroke={colors.interaction}
-              strokeWidth={1.5}
-              fill="none"
-            />
-          </Pattern>
-        </Defs>
-        <Rect x="0" y="0" width="100%" height={WAVE_HEIGHT} fill="url(#wave)" />
-      </Svg>
-    </View>
-  )
-}
-
-const squigglyStyle = StyleSheet.create({
-  container: {
-    flex: 1,
-    height: WAVE_HEIGHT,
-  },
-})
-
-const useStyles = () => {
-  const { colors } = useTheme()
-  return StyleSheet.create({
-    container: {
-      alignItems: 'center',
-      flexDirection: 'row',
-      paddingHorizontal: CONVERSATION_MESSAGE_LIST_PADDING_HORIZONTAL,
-      paddingVertical: 8,
-      gap: 8,
-    },
-    label: {
-      color: colors.interaction,
-      fontWeight: '600',
-    },
-  })
-}

package/src/hooks/use_flat_list_viewability.ts

@@ -1,50 +0,0 @@
-import { useCallback, useEffect, useRef } from 'react'
-import type { ViewToken } from 'react-native'
-import type { ViewabilityObserver } from '../utils/message_viewability'
-
-interface UseFlatListViewabilityArgs<Item> {
-  observers: ViewabilityObserver<Item>[]
-  itemVisiblePercentThreshold?: number
-}
-
-export function useFlatListViewability<Item>({
-  observers,
-  itemVisiblePercentThreshold = 50,
-}: UseFlatListViewabilityArgs<Item>) {
-  const userHasScrolledRef = useRef(false)
-  const observersRef = useRef(observers)
-
-  useEffect(() => {
-    observersRef.current = observers
-  })
-
-  const onScrollBeginDrag = useCallback(() => {
-    userHasScrolledRef.current = true
-  }, [])
-
-  const viewabilityConfigCallbackPairs = useRef([
-    {
-      viewabilityConfig: { itemVisiblePercentThreshold },
-      onViewableItemsChanged: ({
-        viewableItems,
-        changed,
-      }: {
-        viewableItems: ViewToken[]
-        changed: ViewToken[]
-      }) => {
-        const event = {
-          viewableItems: viewableItems.map(toEntry<Item>),
-          changed: changed.map(toEntry<Item>),
-          userHasScrolled: userHasScrolledRef.current,
-        }
-        for (const observer of observersRef.current) observer(event)
-      },
-    },
-  ]).current
-
-  return { viewabilityConfigCallbackPairs, onScrollBeginDrag }
-}
-
-function toEntry<Item>(token: ViewToken) {
-  return { key: token.key, isViewable: !!token.isViewable, item: token.item as Item }
-}

package/src/hooks/use_jump_to_bottom_action.ts

@@ -1,75 +0,0 @@
-import { useQueryClient } from '@tanstack/react-query'
-import { RefObject, useCallback, useEffect, useRef, useState } from 'react'
-import type { FlatList } from 'react-native'
-import { useConversationContext } from '../contexts/conversation_context'
-import { ApiCollection, MessageResource } from '../types'
-import { Haptic } from '../utils/native_adapters'
-import { getMessagesQueryKey, getMessagesRequestArgs } from '../utils/request/get_messages'
-import { useApiClient } from './use_api_client'
-import { useJumpToUnreadGates } from './use_jump_to_unread_gates'
-
-const LATEST_PAGE_SIZE = 25
-
-export function useJumpToBottomAction({ listRef }: { listRef: RefObject<FlatList | null> }) {
-  const { jumpToUnreadEnabled } = useJumpToUnreadGates()
-  const { conversationId, currentPageReplyRootId, initialMessageId, setInitialMessageId } =
-    useConversationContext()
-  const queryClient = useQueryClient()
-  const apiClient = useApiClient()
-  const [isJumpingToBottom, setIsJumpingToBottom] = useState(false)
-
-  const mountedRef = useRef(true)
-  useEffect(
-    () => () => {
-      mountedRef.current = false
-    },
-    []
-  )
-
-  const handleJumpToBottom = useCallback(() => {
-    Haptic.impactLight()
-    listRef.current?.scrollToOffset({ offset: 0, animated: true })
-
-    if (!jumpToUnreadEnabled || !initialMessageId) return
-
-    const queryKey = getMessagesQueryKey({
-      conversation_id: conversationId,
-      reply_root_id: currentPageReplyRootId,
-    })
-    const args = getMessagesRequestArgs({
-      conversation_id: conversationId,
-      reply_root_id: currentPageReplyRootId,
-    })
-
-    setIsJumpingToBottom(true)
-
-    queryClient
-      .cancelQueries({ queryKey })
-      .then(() =>
-        apiClient.chat.get<ApiCollection<MessageResource>>({
-          url: args.url,
-          data: { ...args.data, perPage: LATEST_PAGE_SIZE },
-        })
-      )
-      .then(latest => {
-        if (!mountedRef.current) return
-        queryClient.setQueryData(queryKey, { pages: [latest], pageParams: [{}] })
-        setInitialMessageId(null)
-        listRef.current?.scrollToOffset({ offset: 0, animated: false })
-      })
-      .finally(() => {
-        if (mountedRef.current) setIsJumpingToBottom(false)
-      })
-  }, [
-    jumpToUnreadEnabled,
-    initialMessageId,
-    setInitialMessageId,
-    queryClient,
-    apiClient,
-    conversationId,
-    currentPageReplyRootId,
-    listRef,
-  ])
-
-  return { handleJumpToBottom, isJumpingToBottom }
-}

package/src/hooks/use_jump_to_unread_anchor.ts

@@ -1,68 +0,0 @@
-import { RefObject, useCallback, useEffect, useRef } from 'react'
-import type { FlatList } from 'react-native'
-import { useConversationContext } from '../contexts/conversation_context'
-import { useJumpToUnreadGates } from './use_jump_to_unread_gates'
-
-interface UseJumpToUnreadAnchorArgs<T> {
-  listRef: RefObject<FlatList<T> | null>
-  items: T[]
-}
-
-interface ScrollToIndexFailInfo {
-  index: number
-  highestMeasuredFrameIndex: number
-  averageItemLength: number
-}
-
-export function useJumpToUnreadAnchor<T extends { id?: string | number }>({
-  listRef,
-  items,
-}: UseJumpToUnreadAnchorArgs<T>) {
-  const { jumpToUnreadActive } = useJumpToUnreadGates()
-  const { initialMessageId } = useConversationContext()
-  const hasAnchoredRef = useRef(false)
-  const userTouchedRef = useRef(false)
-  const retryTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-
-  useEffect(() => {
-    return () => {
-      if (retryTimerRef.current) clearTimeout(retryTimerRef.current)
-      retryTimerRef.current = null
-    }
-  }, [])
-
-  const onScrollBeginDrag = useCallback(() => {
-    userTouchedRef.current = true
-    if (retryTimerRef.current) {
-      clearTimeout(retryTimerRef.current)
-      retryTimerRef.current = null
-    }
-  }, [])
-
-  const onContentSizeChange = useCallback(() => {
-    if (hasAnchoredRef.current) return
-    if (!jumpToUnreadActive || !initialMessageId) return
-    if (userTouchedRef.current) return
-    const index = items.findIndex(item => String(item.id ?? '') === initialMessageId)
-    if (index < 0) return
-    hasAnchoredRef.current = true
-    listRef.current?.scrollToIndex({ index, viewPosition: 0.25, animated: false })
-  }, [jumpToUnreadActive, initialMessageId, items, listRef])
-
-  const onScrollToIndexFailed = useCallback(
-    (info: ScrollToIndexFailInfo) => {
-      if (userTouchedRef.current) return
-      const offset = info.averageItemLength * info.index
-      listRef.current?.scrollToOffset({ offset, animated: false })
-      if (retryTimerRef.current) clearTimeout(retryTimerRef.current)
-      retryTimerRef.current = setTimeout(() => {
-        retryTimerRef.current = null
-        if (userTouchedRef.current) return
-        listRef.current?.scrollToIndex({ index: info.index, viewPosition: 0.25, animated: false })
-      }, 50)
-    },
-    [listRef]
-  )
-
-  return { onScrollBeginDrag, onContentSizeChange, onScrollToIndexFailed }
-}

package/src/hooks/use_jump_to_unread_gates.ts

@@ -1,10 +0,0 @@
-import { useConversationContext } from '../contexts/conversation_context'
-import { availableFeatures, useFeatures } from './use_features'
-
-export function useJumpToUnreadGates() {
-  const { featureEnabled } = useFeatures()
-  const { initialMessageIdIsAnchor } = useConversationContext()
-  const jumpToUnreadEnabled = featureEnabled(availableFeatures.jump_to_unread)
-  const jumpToUnreadActive = jumpToUnreadEnabled && initialMessageIdIsAnchor
-  return { jumpToUnreadEnabled, jumpToUnreadActive }
-}