@planningcenter/chat-react-native 4.2.1-qa-staging.5 → 4.3.0-rc.0

package/build/utils/gated_message_cache.js

@@ -1,13 +0,0 @@
-export const gatedMessageCache = ({
-  queryKey,
-  acceptNewMessages,
-  onSkippedNewMessage
-}) => ({
-  queryKey,
-  canUpdate: event => {
-    if (event !== 'message.created' || acceptNewMessages) return true;
-    onSkippedNewMessage?.();
-    return false;
-  }
-});
-//# sourceMappingURL=gated_message_cache.js.map

package/build/utils/gated_message_cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gated_message_cache.js","names":["gatedMessageCache","queryKey","acceptNewMessages","onSkippedNewMessage","canUpdate","event"],"sources":["../../src/utils/gated_message_cache.ts"],"sourcesContent":["import type { MessagesCache } from '../hooks/use_conversation_messages_jolt_events'\n\nexport const gatedMessageCache = ({\n  queryKey,\n  acceptNewMessages,\n  onSkippedNewMessage,\n}: {\n  queryKey: unknown[]\n  acceptNewMessages: boolean\n  onSkippedNewMessage?: () => void\n}): MessagesCache => ({\n  queryKey,\n  canUpdate: event => {\n    if (event !== 'message.created' || acceptNewMessages) return true\n\n    onSkippedNewMessage?.()\n    return false\n  },\n})\n"],"mappings":"AAEA,OAAO,MAAMA,iBAAiB,GAAGA,CAAC;EAChCC,QAAQ;EACRC,iBAAiB;EACjBC;AAKF,CAAC,MAAqB;EACpBF,QAAQ;EACRG,SAAS,EAAEC,KAAK,IAAI;IAClB,IAAIA,KAAK,KAAK,iBAAiB,IAAIH,iBAAiB,EAAE,OAAO,IAAI;IAEjEC,mBAAmB,GAAG,CAAC;IACvB,OAAO,KAAK;EACd;AACF,CAAC,CAAC","ignoreList":[]}

package/build/utils/ulid.d.ts

@@ -1,3 +0,0 @@
-export declare const ULID_CHARS = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-export declare function decodeUlidTime(ulid: string): number;
-//# sourceMappingURL=ulid.d.ts.map

package/build/utils/ulid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ulid.d.ts","sourceRoot":"","sources":["../../src/utils/ulid.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,qCAAqC,CAAA;AAI5D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMnD"}

package/build/utils/ulid.js

@@ -1,7 +0,0 @@
-export const ULID_CHARS = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'; // Crockford's Base32
-
-const TIME_LENGTH = 10;
-export function decodeUlidTime(ulid) {
-  return ulid.slice(0, TIME_LENGTH).toUpperCase().split('').reduce((time, char) => time * 32 + ULID_CHARS.indexOf(char), 0);
-}
-//# sourceMappingURL=ulid.js.map

package/build/utils/ulid.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ulid.js","names":["ULID_CHARS","TIME_LENGTH","decodeUlidTime","ulid","slice","toUpperCase","split","reduce","time","char","indexOf"],"sources":["../../src/utils/ulid.ts"],"sourcesContent":["export const ULID_CHARS = '0123456789ABCDEFGHJKMNPQRSTVWXYZ' // Crockford's Base32\n\nconst TIME_LENGTH = 10\n\nexport function decodeUlidTime(ulid: string): number {\n  return ulid\n    .slice(0, TIME_LENGTH)\n    .toUpperCase()\n    .split('')\n    .reduce((time, char) => time * 32 + ULID_CHARS.indexOf(char), 0)\n}\n"],"mappings":"AAAA,OAAO,MAAMA,UAAU,GAAG,kCAAkC,EAAC;;AAE7D,MAAMC,WAAW,GAAG,EAAE;AAEtB,OAAO,SAASC,cAAcA,CAACC,IAAY,EAAU;EACnD,OAAOA,IAAI,CACRC,KAAK,CAAC,CAAC,EAAEH,WAAW,CAAC,CACrBI,WAAW,CAAC,CAAC,CACbC,KAAK,CAAC,EAAE,CAAC,CACTC,MAAM,CAAC,CAACC,IAAI,EAAEC,IAAI,KAAKD,IAAI,GAAG,EAAE,GAAGR,UAAU,CAACU,OAAO,CAACD,IAAI,CAAC,EAAE,CAAC,CAAC;AACpE","ignoreList":[]}

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

@@ -1,22 +0,0 @@
-import { anchoredRetry } from '../../hooks/use_conversation_messages'
-import { FailedResponse } from '../../types/api_primitives'
-import { ResponseError } from '../../utils/response_error'
-
-const responseError = (status: number) =>
-  new ResponseError({ status, statusText: 'nope' } as unknown as FailedResponse)
-
-describe('anchoredRetry', () => {
-  it('gives up straight away on a missing anchor', () => {
-    expect(anchoredRetry(0, responseError(404))).toBe(false)
-  })
-
-  it('does not hammer a rate limit', () => {
-    expect(anchoredRetry(0, responseError(429))).toBe(false)
-  })
-
-  it('retries other failures a few times', () => {
-    expect(anchoredRetry(0, responseError(500))).toBe(true)
-    expect(anchoredRetry(2, new Error('network'))).toBe(true)
-    expect(anchoredRetry(3, responseError(500))).toBe(false)
-  })
-})

package/src/__tests__/hooks/use_conversation_messages_jolt_events.test.ts

@@ -1,33 +0,0 @@
-import { queryKeysForEvent } from '../../hooks/use_conversation_messages_jolt_events'
-
-const cache = { queryKey: ['shown'] }
-const gated = { queryKey: ['shown'], canUpdate: (e: string) => e !== 'message.created' }
-const topLevel = { sort_key: '01M', reply_root_id: null }
-const replyInThread = { sort_key: '01R', reply_root_id: '01ROOT' }
-const replyElsewhere = { sort_key: '01S', reply_root_id: '01OTHER' }
-const theRoot = { sort_key: '01ROOT', reply_root_id: '01ROOT' }
-
-describe('queryKeysForEvent', () => {
-  it('writes every message event to the conversation view', () => {
-    const view = { replyRootId: null, cache }
-
-    expect(queryKeysForEvent('message.created', view, topLevel)).toEqual([['shown']])
-    expect(queryKeysForEvent('message.created', view, replyInThread)).toEqual([['shown']])
-  })
-
-  it('writes only this thread and its root to a reply view', () => {
-    const view = { replyRootId: '01ROOT', cache }
-
-    expect(queryKeysForEvent('message.created', view, replyInThread)).toEqual([['shown']])
-    expect(queryKeysForEvent('message.updated', view, theRoot)).toEqual([['shown']])
-    expect(queryKeysForEvent('message.created', view, topLevel)).toEqual([])
-    expect(queryKeysForEvent('message.created', view, replyElsewhere)).toEqual([])
-  })
-
-  it('honors the gate on the shown cache', () => {
-    const view = { replyRootId: null, cache: gated }
-
-    expect(queryKeysForEvent('message.created', view, topLevel)).toEqual([])
-    expect(queryKeysForEvent('reaction', view, topLevel)).toEqual([['shown']])
-  })
-})

package/src/__tests__/screens/conversation_new/components/services_form.test.tsx

@@ -1,91 +0,0 @@
-import { DefaultTheme, ThemeProvider } from '@react-navigation/native'
-import { render } from '@testing-library/react-native'
-import React from 'react'
-import { SafeAreaProvider } from 'react-native-safe-area-context'
-import { useFindOrCreateServicesConversation } from '../../../../hooks/services/use_find_or_create_services_conversation'
-import { useTeamMembersForNewConversation } from '../../../../hooks/services/use_team_members_for_new_conversation'
-import { ServicesForm } from '../../../../screens/conversation_new/components/services_form'
-
-jest.mock('react-native-reanimated', () => ({
-  ...jest.requireActual('react-native-reanimated/mock'),
-  LayoutAnimationConfig: ({ children }: { children: React.ReactNode }) => children,
-}))
-jest.mock('@react-navigation/native', () => ({
-  ...jest.requireActual('@react-navigation/native'),
-  useNavigation: () => ({ navigate: jest.fn(), dispatch: jest.fn(), getParent: () => undefined }),
-}))
-jest.mock('../../../../hooks/use_api_client', () => ({ useApiClient: () => ({}) }))
-jest.mock('../../../../hooks/use_upload_client', () => ({ useUploadClient: () => ({}) }))
-jest.mock('../../../../hooks/use_features', () => ({
-  ...jest.requireActual('../../../../hooks/use_features'),
-  useFeatures: () => ({ features: [], featureEnabled: () => false }),
-}))
-jest.mock('../../../../hooks/use_conversation_validate', () => ({
-  useConversationValidate: () => ({ warnings: [], validationPending: false }),
-}))
-jest.mock('../../../../hooks/services/use_services_chat_conversation_payload', () => ({
-  useServicesChatConversationPayload: () => ({ payload: undefined, isLoading: false }),
-}))
-jest.mock('../../../../hooks/services/use_services_team', () => ({
-  useServicesTeams: () => [],
-}))
-jest.mock('../../../../hooks/services/use_team_plans', () => ({
-  useTeamPlans: () => ({
-    planOptions: [],
-    isFetching: false,
-    isError: false,
-    findPlan: () => undefined,
-  }),
-}))
-jest.mock('../../../../hooks/services/use_team_members_for_new_conversation', () => ({
-  useTeamMembersForNewConversation: jest.fn(() => ({ members: [], isError: false })),
-}))
-jest.mock('../../../../hooks/services/use_find_or_create_services_conversation', () => ({
-  useFindOrCreateServicesConversation: jest.fn(() => ({
-    mutate: jest.fn(),
-    isPending: false,
-    selectionHasConversation: false,
-    isLoadingConversationCheck: false,
-  })),
-}))
-
-const mockedFindOrCreate = jest.mocked(useFindOrCreateServicesConversation)
-const mockedTeamMembers = jest.mocked(useTeamMembersForNewConversation)
-
-const latestArgs = <T extends jest.Mock>(mock: T) => mock.mock.calls.at(-1)?.[0]
-
-const safeAreaMetrics = {
-  frame: { x: 0, y: 0, width: 390, height: 844 },
-  insets: { top: 0, right: 0, bottom: 0, left: 0 },
-}
-
-const renderForm = (props: { initialPlanId?: number } = {}) =>
-  render(
-    <SafeAreaProvider initialMetrics={safeAreaMetrics}>
-      <ThemeProvider value={DefaultTheme}>
-        <ServicesForm initialTeamIds={[1, 2]} {...props} />
-      </ThemeProvider>
-    </SafeAreaProvider>
-  )
-
-describe('ServicesForm', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('filters by plan when opened from a plan', () => {
-    const { getByRole } = renderForm({ initialPlanId: 42 })
-
-    expect(getByRole('switch').props.value).toBe(true)
-    expect(latestArgs(mockedFindOrCreate)).toMatchObject({ teamIds: [1, 2], planId: 42 })
-    expect(latestArgs(mockedTeamMembers)).toMatchObject({ teamIds: [1, 2], planId: 42 })
-  })
-
-  it('does not filter by plan when opened without a plan', () => {
-    const { getByRole } = renderForm()
-
-    expect(getByRole('switch').props.value).toBe(false)
-    expect(latestArgs(mockedFindOrCreate)).toMatchObject({ teamIds: [1, 2], planId: undefined })
-    expect(latestArgs(mockedTeamMembers)).toMatchObject({ teamIds: [1, 2], planId: undefined })
-  })
-})

package/src/__tests__/utils/gated_message_cache.test.ts

@@ -1,26 +0,0 @@
-import { gatedMessageCache } from '../../utils/gated_message_cache'
-
-describe('gatedMessageCache', () => {
-  const queryKey = ['messages']
-
-  it('keeps new messages out while they are not accepted and reports the skip', () => {
-    const onSkippedNewMessage = jest.fn()
-    const cache = gatedMessageCache({ queryKey, acceptNewMessages: false, onSkippedNewMessage })
-
-    expect(cache.queryKey).toBe(queryKey)
-    expect(cache.canUpdate?.('message.created')).toBe(false)
-    expect(onSkippedNewMessage).toHaveBeenCalledTimes(1)
-    expect(cache.canUpdate?.('message.updated')).toBe(true)
-    expect(cache.canUpdate?.('message.destroyed')).toBe(true)
-    expect(cache.canUpdate?.('reaction')).toBe(true)
-    expect(onSkippedNewMessage).toHaveBeenCalledTimes(1)
-  })
-
-  it('lets new messages in once they are accepted', () => {
-    const onSkippedNewMessage = jest.fn()
-    const cache = gatedMessageCache({ queryKey, acceptNewMessages: true, onSkippedNewMessage })
-
-    expect(cache.canUpdate?.('message.created')).toBe(true)
-    expect(onSkippedNewMessage).not.toHaveBeenCalled()
-  })
-})

package/src/__tests__/utils/request/get_messages.test.ts

@@ -1,24 +0,0 @@
-import { getMessagesQueryKey, getMessagesRequestArgs } from '../../../utils/request/get_messages'
-
-describe('getMessagesRequestArgs', () => {
-  it('requests the newest page by default', () => {
-    const { data } = getMessagesRequestArgs({ conversation_id: 1 })
-
-    expect(data).not.toHaveProperty('where')
-    expect(data).not.toHaveProperty('order')
-  })
-
-  it('opens around the anchor when one is given', () => {
-    const { data } = getMessagesRequestArgs({ conversation_id: 1, anchor: '01ANCHOR' })
-
-    expect(data).toMatchObject({ where: { id_around: '01ANCHOR' } })
-    expect(data).not.toHaveProperty('order')
-  })
-
-  it('keeps anchored and live queries in separate cache entries', () => {
-    const live = getMessagesQueryKey({ conversation_id: 1 })
-    const anchored = getMessagesQueryKey({ conversation_id: 1, anchor: '01ANCHOR' })
-
-    expect(anchored).not.toEqual(live)
-  })
-})

package/src/__tests__/utils/ulid.test.ts

@@ -1,15 +0,0 @@
-import { generatePlaceholderUlid } from '../../utils/generate_placeholder_ulid'
-import { decodeUlidTime } from '../../utils/ulid'
-
-describe('decodeUlidTime', () => {
-  it('decodes the spec example', () => {
-    expect(decodeUlidTime('01ARYZ6S41TSV4RRFFQ69G5FAV')).toBe(1469918176385)
-  })
-
-  it('round-trips a placeholder ulid', () => {
-    const now = Date.now()
-    jest.spyOn(Date, 'now').mockReturnValue(now)
-
-    expect(decodeUlidTime(generatePlaceholderUlid())).toBe(now)
-  })
-})

package/src/components/conversation/__tests__/anchor_not_found_boundary.test.tsx

@@ -1,51 +0,0 @@
-import { render, screen } from '@testing-library/react-native'
-import React from 'react'
-import { Text } from 'react-native'
-import { FailedResponse } from '../../../types/api_primitives'
-import { ResponseError } from '../../../utils/response_error'
-import { AnchorNotFoundBoundary } from '../anchor_not_found_boundary'
-
-const responseError = (status: number) =>
-  new ResponseError({ status, statusText: 'nope' } as unknown as FailedResponse)
-
-function Thrower({ error }: { error: Error | null }) {
-  if (error) throw error
-  return <Text>content</Text>
-}
-
-describe('AnchorNotFoundBoundary', () => {
-  beforeEach(() => jest.spyOn(console, 'error').mockImplementation(() => {}))
-
-  it('reports a missing anchor and renders nothing while the parent drops it', () => {
-    const onAnchorNotFound = jest.fn()
-
-    render(
-      <AnchorNotFoundBoundary onAnchorNotFound={onAnchorNotFound}>
-        <Thrower error={responseError(404)} />
-      </AnchorNotFoundBoundary>
-    )
-
-    expect(onAnchorNotFound).toHaveBeenCalledTimes(1)
-    expect(screen.queryByText('content')).toBeNull()
-  })
-
-  it('lets every other error through untouched', () => {
-    const onAnchorNotFound = jest.fn()
-
-    expect(() =>
-      render(
-        <AnchorNotFoundBoundary onAnchorNotFound={onAnchorNotFound}>
-          <Thrower error={responseError(403)} />
-        </AnchorNotFoundBoundary>
-      )
-    ).toThrow()
-    expect(() =>
-      render(
-        <AnchorNotFoundBoundary onAnchorNotFound={onAnchorNotFound}>
-          <Thrower error={new Error('render blew up')} />
-        </AnchorNotFoundBoundary>
-      )
-    ).toThrow('render blew up')
-    expect(onAnchorNotFound).not.toHaveBeenCalled()
-  })
-})

package/src/components/conversation/anchor_not_found_boundary.tsx

@@ -1,21 +0,0 @@
-import React, { PropsWithChildren } from 'react'
-import { ResponseError } from '../../utils/response_error'
-
-type Props = PropsWithChildren<{ onAnchorNotFound: () => void }>
-
-export class AnchorNotFoundBoundary extends React.Component<Props, { recovering: boolean }> {
-  state = { recovering: false }
-
-  static getDerivedStateFromError(error: Error) {
-    if (error instanceof ResponseError && error.status === 404) return { recovering: true }
-    throw error
-  }
-
-  componentDidCatch() {
-    this.props.onAnchorNotFound()
-  }
-
-  render() {
-    return this.state.recovering ? null : this.props.children
-  }
-}

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

@@ -1,95 +0,0 @@
-import { InfiniteData, QueryClientProvider } from '@tanstack/react-query'
-import { act, renderHook } from '@testing-library/react-native'
-import React from 'react'
-import { buildTestQueryClient } from '../../__utils__/query_client'
-import type { ApiCollection, MessageResource } from '../../types'
-import { getMessagesQueryKey } from '../../utils/request/get_messages'
-import { ApiClient, useApiClient } from '../use_api_client'
-import { useFetchNewerMessages } from '../use_fetch_newer_messages'
-
-jest.mock('../use_api_client')
-
-type QueryData = InfiniteData<ApiCollection<MessageResource>>
-
-const page = (ids: string[], next?: { idGt: string }) => ({
-  data: ids.map(id => ({ id, type: 'Message' }) as unknown as MessageResource),
-  links: {},
-  meta: { count: ids.length, totalCount: ids.length, next },
-})
-
-const queryKey = getMessagesQueryKey({ conversation_id: 1 })
-let queryClient = buildTestQueryClient()
-const get = jest.fn()
-
-const wrapper = ({ children }: { children: React.ReactNode }) => (
-  <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-)
-
-const cachedIds = () =>
-  queryClient.getQueryData<QueryData>(queryKey)?.pages.flatMap(p => p.data.map(m => m.id))
-
-beforeEach(() => {
-  queryClient = buildTestQueryClient()
-  queryClient.setQueryData<QueryData>(queryKey, {
-    pages: [page(['01C', '01B']), page(['01A'])],
-    pageParams: [{}, { where: { id_lt: '01B' } }],
-  })
-  get.mockReset()
-  ;(useApiClient as jest.MockedFunction<typeof useApiClient>).mockReturnValue({
-    chat: { get },
-  } as unknown as ApiClient)
-})
-
-describe('useFetchNewerMessages', () => {
-  it('follows meta.next until everything newer is in the cache', async () => {
-    get
-      .mockResolvedValueOnce(page(['01D', '01E'], { idGt: '01E' }))
-      .mockResolvedValueOnce(page(['01F']))
-    const { result } = renderHook(() => useFetchNewerMessages({ conversation_id: 1, queryKey }), {
-      wrapper,
-    })
-
-    await act(() => result.current('01C'))
-
-    expect(get).toHaveBeenCalledTimes(2)
-    expect(get.mock.calls[1][0].data.where).toEqual({ id_gt: '01E' })
-    expect(cachedIds()).toEqual(['01D', '01E', '01F', '01C', '01B', '01A'])
-  })
-
-  it('rejects when the request fails so the caller can try again later', async () => {
-    get.mockRejectedValueOnce(new Error('offline'))
-    const { result } = renderHook(() => useFetchNewerMessages({ conversation_id: 1, queryKey }), {
-      wrapper,
-    })
-
-    await expect(act(() => result.current('01C'))).rejects.toThrow('offline')
-    expect(cachedIds()).toEqual(['01C', '01B', '01A'])
-  })
-
-  it('hands off instead of refetching when more is left than it will walk', async () => {
-    for (let i = 0; i < 5; i++) get.mockResolvedValueOnce(page([`01D${i}`], { idGt: `01D${i}` }))
-    const onTooFarBehind = jest.fn()
-    const invalidate = jest.spyOn(queryClient, 'invalidateQueries')
-    const { result } = renderHook(
-      () => useFetchNewerMessages({ conversation_id: 1, queryKey, onTooFarBehind }),
-      { wrapper }
-    )
-
-    await act(() => result.current('01C'))
-
-    expect(onTooFarBehind).toHaveBeenCalledTimes(1)
-    expect(invalidate).not.toHaveBeenCalled()
-  })
-
-  it('refetches the live cache when more is left and nobody takes over', async () => {
-    for (let i = 0; i < 5; i++) get.mockResolvedValueOnce(page([`01D${i}`], { idGt: `01D${i}` }))
-    const invalidate = jest.spyOn(queryClient, 'invalidateQueries')
-    const { result } = renderHook(() => useFetchNewerMessages({ conversation_id: 1, queryKey }), {
-      wrapper,
-    })
-
-    await act(() => result.current('01C'))
-
-    expect(invalidate).toHaveBeenCalledWith({ queryKey })
-  })
-})

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

@@ -1,60 +0,0 @@
-import { act, renderHook } from '@testing-library/react-native'
-import { useHeldBackMessages } from '../use_held_back_messages'
-
-type Props = { newestMessageId?: string; readingHistory: boolean; caughtUp: boolean }
-
-const setup = (fetchNewer: jest.Mock, initial: Props) =>
-  renderHook((props: Props) => useHeldBackMessages({ fetchNewer, ...props }), {
-    initialProps: initial,
-  })
-
-describe('useHeldBackMessages', () => {
-  it('catches up from where the first skip happened, not from the newest message', async () => {
-    const fetchNewer = jest.fn().mockResolvedValue(undefined)
-    const { result, rerender } = setup(fetchNewer, {
-      newestMessageId: 'A',
-      readingHistory: true,
-      caughtUp: true,
-    })
-
-    act(() => result.current.onSkippedNewMessage())
-    rerender({ newestMessageId: 'B', readingHistory: true, caughtUp: true })
-    await act(async () => rerender({ newestMessageId: 'B', readingHistory: false, caughtUp: true }))
-
-    expect(fetchNewer).toHaveBeenCalledTimes(1)
-    expect(fetchNewer).toHaveBeenCalledWith('A')
-  })
-
-  it('keeps the cursor when the catch-up fails and tries again next time', async () => {
-    const fetchNewer = jest
-      .fn()
-      .mockRejectedValueOnce(new Error('offline'))
-      .mockResolvedValue(undefined)
-    const { result, rerender } = setup(fetchNewer, {
-      newestMessageId: 'A',
-      readingHistory: true,
-      caughtUp: true,
-    })
-
-    act(() => result.current.onSkippedNewMessage())
-    await act(async () => rerender({ newestMessageId: 'A', readingHistory: false, caughtUp: true }))
-    rerender({ newestMessageId: 'C', readingHistory: true, caughtUp: true })
-    await act(async () => rerender({ newestMessageId: 'C', readingHistory: false, caughtUp: true }))
-
-    expect(fetchNewer).toHaveBeenCalledTimes(2)
-    expect(fetchNewer).toHaveBeenLastCalledWith('A')
-  })
-
-  it('does nothing when nothing was held back', async () => {
-    const fetchNewer = jest.fn()
-    const { rerender } = setup(fetchNewer, {
-      newestMessageId: 'A',
-      readingHistory: true,
-      caughtUp: true,
-    })
-
-    await act(async () => rerender({ newestMessageId: 'A', readingHistory: false, caughtUp: true }))
-
-    expect(fetchNewer).not.toHaveBeenCalled()
-  })
-})

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

@@ -1,73 +0,0 @@
-import { InfiniteData, QueryClientProvider } from '@tanstack/react-query'
-import { act, renderHook } from '@testing-library/react-native'
-import React from 'react'
-import { buildTestQueryClient } from '../../__utils__/query_client'
-import { ConversationContextProvider } from '../../contexts/conversation_context'
-import type { ApiCollection, MessageResource } from '../../types'
-import { getMessagesQueryKey } from '../../utils/request/get_messages'
-import { ApiClient, useApiClient } from '../use_api_client'
-import { useMessageReactionToggle } from '../use_message_reaction_toggle'
-
-jest.mock('../use_api_client')
-
-type QueryData = InfiniteData<ApiCollection<MessageResource>>
-
-const message = { id: '01M', type: 'Message', reactionCounts: [] } as unknown as MessageResource
-const liveKey = getMessagesQueryKey({ conversation_id: 1 })
-const anchoredKey = getMessagesQueryKey({ conversation_id: 1, anchor: '01A' })
-const seed = (): QueryData => ({
-  pages: [{ data: [message], links: {}, meta: { count: 1, totalCount: 1 } }],
-  pageParams: [{}],
-})
-
-const heartsIn = (queryClient: ReturnType<typeof buildTestQueryClient>, key: unknown[]) =>
-  queryClient
-    .getQueryData<QueryData>(key)
-    ?.pages[0].data[0].reactionCounts.map(r => `${r.value}:${r.count}`)
-
-describe('useMessageReactionToggle', () => {
-  beforeEach(() => {
-    ;(useApiClient as jest.MockedFunction<typeof useApiClient>).mockReturnValue({
-      chat: { post: jest.fn(() => new Promise(() => {})) },
-    } as unknown as ApiClient)
-  })
-
-  it('applies the optimistic reaction to the cache the screen is showing', async () => {
-    const queryClient = buildTestQueryClient({ defaultOptions: { queries: { gcTime: Infinity } } })
-    queryClient.setQueryData<QueryData>(anchoredKey, seed())
-    const wrapper = ({ children }: { children: React.ReactNode }) => (
-      <QueryClientProvider client={queryClient}>
-        <ConversationContextProvider
-          conversationId={1}
-          currentPageReplyRootId={null}
-          messagesQueryKey={anchoredKey}
-        >
-          {children}
-        </ConversationContextProvider>
-      </QueryClientProvider>
-    )
-    const { result } = renderHook(() => useMessageReactionToggle({ conversation_id: 1, message }), {
-      wrapper,
-    })
-
-    await act(async () => result.current.handleReactionToggle({ value: 'heart', mine: false }))
-
-    expect(heartsIn(queryClient, anchoredKey)).toEqual(['heart:1'])
-    expect(queryClient.getQueryData(liveKey)).toBeUndefined()
-  })
-
-  it('falls back to the live cache when no screen key is provided', async () => {
-    const queryClient = buildTestQueryClient({ defaultOptions: { queries: { gcTime: Infinity } } })
-    queryClient.setQueryData<QueryData>(liveKey, seed())
-    const wrapper = ({ children }: { children: React.ReactNode }) => (
-      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-    )
-    const { result } = renderHook(() => useMessageReactionToggle({ conversation_id: 1, message }), {
-      wrapper,
-    })
-
-    await act(async () => result.current.handleReactionToggle({ value: 'heart', mine: false }))
-
-    expect(heartsIn(queryClient, liveKey)).toEqual(['heart:1'])
-  })
-})

package/src/hooks/use_conversation_message_lookup.ts

@@ -1,29 +0,0 @@
-import { useQueryClient } from '@tanstack/react-query'
-import { useCallback, useSyncExternalStore } from 'react'
-import { findMessageInCaches } from '../utils/cache/find_message_in_caches'
-import { useConversationMessage } from './use_conversation_message'
-
-type Options = {
-  conversation_id: number
-  message_id: string
-}
-
-export const useConversationMessageLookup = ({ conversation_id, message_id }: Options) => {
-  const queryClient = useQueryClient()
-  const subscribe = useCallback(
-    (onChange: () => void) => queryClient.getQueryCache().subscribe(onChange),
-    [queryClient]
-  )
-  const getSnapshot = useCallback(
-    () => findMessageInCaches(queryClient, conversation_id, message_id),
-    [conversation_id, message_id, queryClient]
-  )
-  const cached = useSyncExternalStore(subscribe, getSnapshot)
-  const fetched = useConversationMessage({
-    conversation_id,
-    messageId: message_id,
-    enabled: !cached,
-  })
-
-  return cached ?? fetched.message
-}

package/src/hooks/use_fetch_newer_messages.ts

@@ -1,52 +0,0 @@
-import { useQueryClient } from '@tanstack/react-query'
-import { useCallback } from 'react'
-import { ApiCollection, MessageResource } from '../types'
-import { prependNewerPage } from '../utils/cache/prepend_newer_page'
-import { getMessagesRequestArgs } from '../utils/request/get_messages'
-import { useApiClient } from './use_api_client'
-
-const MAX_PAGES = 5
-
-type Options = {
-  conversation_id: number
-  reply_root_id?: string | null
-  queryKey: unknown[]
-  onTooFarBehind?: () => void
-}
-
-export const useFetchNewerMessages = ({
-  conversation_id,
-  reply_root_id,
-  queryKey,
-  onTooFarBehind,
-}: Options) => {
-  const queryClient = useQueryClient()
-  const apiClient = useApiClient()
-
-  return useCallback(
-    async (newestMessageId: string) => {
-      const { url, data } = getMessagesRequestArgs({ conversation_id, reply_root_id })
-      const pages: ApiCollection<MessageResource>[] = []
-      let cursor: string | undefined = newestMessageId
-
-      while (cursor && pages.length < MAX_PAGES) {
-        const page: ApiCollection<MessageResource> = await apiClient.chat.get({
-          url,
-          data: { ...data, where: { id_gt: cursor }, order: 'asc' },
-        })
-        pages.push(page)
-        cursor = page.meta?.next?.idGt
-      }
-
-      queryClient.setQueryData<Parameters<typeof prependNewerPage<MessageResource>>[0]>(
-        queryKey,
-        prev => prependNewerPage(prev, pages)
-      )
-      const moreThanWeFetched = !!cursor
-      if (!moreThanWeFetched) return
-      if (onTooFarBehind) onTooFarBehind()
-      else await queryClient.invalidateQueries({ queryKey })
-    },
-    [apiClient, conversation_id, onTooFarBehind, queryClient, queryKey, reply_root_id]
-  )
-}