@planningcenter/chat-react-native 3.38.0-rc.9 → 3.38.1-rc.0

package/src/hooks/use_track_highest_seen_message.ts

@@ -1,43 +0,0 @@
-import { useCallback, useEffect, useMemo } from 'react'
-import { AppState } from 'react-native'
-import { useConversationContext } from '../contexts/conversation_context'
-import { makeHighestSeenTracker } from '../utils/highest_seen_tracker'
-import { useConversationsMarkReadUpTo } from './use_conversations_actions'
-import { useJumpToUnreadGates } from './use_jump_to_unread_gates'
-
-export function useTrackHighestSeenMessage() {
-  const { conversationId, currentPageReplyRootId } = useConversationContext()
-  const { jumpToUnreadActive } = useJumpToUnreadGates()
-  const enabled = jumpToUnreadActive && !currentPageReplyRootId
-  const { mutate: markReadUpTo } = useConversationsMarkReadUpTo({ conversationId })
-
-  const tracker = useMemo(
-    () => makeHighestSeenTracker(conversationId, ({ sortKey }) => markReadUpTo({ sortKey })),
-    [conversationId, markReadUpTo]
-  )
-
-  const onMessageSeen = useCallback(
-    (sortKey: string) => {
-      if (!enabled) return
-      tracker.onSeen(sortKey)
-    },
-    [enabled, tracker]
-  )
-
-  useEffect(() => {
-    if (!enabled) return
-    const sub = AppState.addEventListener('change', state => {
-      if (state !== 'active') tracker.flushNow()
-    })
-    return () => sub.remove()
-  }, [enabled, tracker])
-
-  useEffect(() => {
-    return () => {
-      tracker.flushNow()
-      tracker.cancel()
-    }
-  }, [tracker])
-
-  return { onMessageSeen }
-}

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

@@ -1,105 +0,0 @@
-import { ApiCollection, MessageResource } from '../../types'
-import {
-  anchoredSeedPageParams,
-  newerPageParam,
-  olderPageParam,
-  sortAndFilterMessages,
-} from '../conversation_messages'
-
-const message = (id: string, overrides: Partial<MessageResource> = {}): MessageResource =>
-  ({
-    id,
-    type: 'Message',
-    text: `msg ${id}`,
-    attachments: [],
-    deletedAt: null,
-    replyRootId: null,
-    ...overrides,
-  }) as MessageResource
-
-const page = (
-  data: MessageResource[],
-  next?: { idLt?: string; idGt?: string }
-): ApiCollection<MessageResource> => ({
-  data,
-  links: {},
-  meta: { count: data.length, totalCount: data.length, next },
-})
-
-describe('anchoredSeedPageParams', () => {
-  it('returns one ascending after-page and one descending before-page', () => {
-    expect(anchoredSeedPageParams('01ABC')).toEqual([
-      { where: { id_gte: '01ABC' }, order: 'asc' },
-      { where: { id_lt: '01ABC' }, order: 'desc' },
-    ])
-  })
-})
-
-describe('olderPageParam', () => {
-  it('returns id_lt cursor when meta.next.idLt is present', () => {
-    expect(olderPageParam(page([], { idLt: '01XYZ' }))).toEqual({
-      where: { id_lt: '01XYZ' },
-      order: 'desc',
-    })
-  })
-
-  it('returns undefined when meta.next.idLt is missing', () => {
-    expect(olderPageParam(page([], {}))).toBeUndefined()
-    expect(olderPageParam(page([], { idGt: '01XYZ' }))).toBeUndefined()
-  })
-})
-
-describe('newerPageParam', () => {
-  it('returns id_gt cursor when meta.next.idGt is present', () => {
-    expect(newerPageParam(page([], { idGt: '01XYZ' }))).toEqual({
-      where: { id_gt: '01XYZ' },
-      order: 'asc',
-    })
-  })
-
-  it('returns undefined when meta.next.idGt is missing', () => {
-    expect(newerPageParam(page([], {}))).toBeUndefined()
-    expect(newerPageParam(page([], { idLt: '01XYZ' }))).toBeUndefined()
-  })
-})
-
-describe('sortAndFilterMessages', () => {
-  it('flattens pages and sorts descending by id (newest first)', () => {
-    const pages = [page([message('01B'), message('01A')]), page([message('01D'), message('01C')])]
-
-    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01D', '01C', '01B', '01A'])
-  })
-
-  it('drops empty messages (no text, no attachments)', () => {
-    const pages = [page([message('01A'), message('01B', { text: '' })])]
-
-    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01A'])
-  })
-
-  it('drops deleted messages outside reply threads', () => {
-    const pages = [page([message('01A'), message('01B', { deletedAt: '2026-01-01T00:00:00Z' })])]
-
-    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01A'])
-  })
-
-  it('keeps deleted reply-thread messages so threads do not break', () => {
-    const pages = [
-      page([
-        message('01A'),
-        message('01B', { deletedAt: '2026-01-01T00:00:00Z', replyRootId: '01A' }),
-      ]),
-    ]
-
-    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01B', '01A'])
-  })
-
-  it('keeps messages with attachments even when text is empty', () => {
-    const pages = [
-      page([
-        message('01A', { text: '', attachments: [{ id: '1' }] as MessageResource['attachments'] }),
-      ]),
-    ]
-
-    expect(sortAndFilterMessages(pages).map(m => m.id)).toEqual(['01A'])
-  })
-})

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

@@ -1,82 +0,0 @@
-import { makeHighestSeenTracker } from '../highest_seen_tracker'
-
-describe('makeHighestSeenTracker', () => {
-  beforeEach(() => {
-    jest.useFakeTimers()
-  })
-
-  afterEach(() => {
-    jest.useRealTimers()
-  })
-
-  it('debounces and sends the highest sort key seen so far', () => {
-    const send = jest.fn()
-    const tracker = makeHighestSeenTracker(42, send, 2000)
-
-    tracker.onSeen('10')
-    tracker.onSeen('15')
-    tracker.onSeen('12')
-
-    expect(send).not.toHaveBeenCalled()
-    jest.advanceTimersByTime(2000)
-
-    expect(send).toHaveBeenCalledWith({ conversationId: 42, sortKey: '15' })
-    expect(send).toHaveBeenCalledTimes(1)
-  })
-
-  it('ignores sort keys that are not strictly greater than the current highest', () => {
-    const send = jest.fn()
-    const tracker = makeHighestSeenTracker(1, send, 1000)
-
-    tracker.onSeen('20')
-    tracker.onSeen('20')
-    tracker.onSeen('19')
-    jest.advanceTimersByTime(1000)
-
-    expect(send).toHaveBeenCalledTimes(1)
-    expect(send).toHaveBeenCalledWith({ conversationId: 1, sortKey: '20' })
-  })
-
-  it('does not re-send the same sort key on subsequent flushes', () => {
-    const send = jest.fn()
-    const tracker = makeHighestSeenTracker(1, send, 1000)
-
-    tracker.onSeen('5')
-    jest.advanceTimersByTime(1000)
-    tracker.flushNow()
-
-    expect(send).toHaveBeenCalledTimes(1)
-  })
-
-  it('flushNow fires immediately without waiting for the debounce', () => {
-    const send = jest.fn()
-    const tracker = makeHighestSeenTracker(1, send, 5000)
-
-    tracker.onSeen('3')
-    tracker.flushNow()
-
-    expect(send).toHaveBeenCalledWith({ conversationId: 1, sortKey: '3' })
-  })
-
-  it('cancel prevents a pending fire', () => {
-    const send = jest.fn()
-    const tracker = makeHighestSeenTracker(1, send, 1000)
-
-    tracker.onSeen('7')
-    tracker.cancel()
-    jest.advanceTimersByTime(1000)
-
-    expect(send).not.toHaveBeenCalled()
-  })
-
-  it('orders fixed-width sort keys via lexicographic comparison', () => {
-    const send = jest.fn()
-    const tracker = makeHighestSeenTracker(1, send, 100)
-
-    tracker.onSeen('09')
-    tracker.onSeen('10')
-    jest.advanceTimersByTime(100)
-
-    expect(send).toHaveBeenCalledWith({ conversationId: 1, sortKey: '10' })
-  })
-})

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

@@ -1,168 +0,0 @@
-import {
-  detectDividerExitTowardNewer,
-  reportViewableMessages,
-  type ViewabilityEvent,
-} from '../message_viewability'
-
-type Msg = { id: string; type: 'Message' }
-
-const event = (overrides: Partial<ViewabilityEvent<Msg>> = {}): ViewabilityEvent<Msg> => ({
-  viewableItems: [],
-  changed: [],
-  userHasScrolled: true,
-  ...overrides,
-})
-
-describe('reportViewableMessages', () => {
-  it('fires onMessageSeen for every viewable Message item by id', () => {
-    const onSeen = jest.fn()
-    const observer = reportViewableMessages<Msg>(onSeen)
-
-    observer(
-      event({
-        viewableItems: [
-          { key: '10', isViewable: true, item: { id: '10', type: 'Message' } },
-          { key: '11', isViewable: true, item: { id: '11', type: 'Message' } },
-        ],
-      })
-    )
-
-    expect(onSeen).toHaveBeenCalledTimes(2)
-    expect(onSeen).toHaveBeenNthCalledWith(1, '10')
-    expect(onSeen).toHaveBeenNthCalledWith(2, '11')
-  })
-
-  it('skips non-Message items (dividers, separators, shadows)', () => {
-    const onSeen = jest.fn()
-    const observer = reportViewableMessages<{ id?: string; type?: string }>(onSeen)
-
-    observer(
-      event({
-        viewableItems: [
-          { key: 'divider', isViewable: true, item: { id: 'divider', type: 'UnreadDivider' } },
-          {
-            key: 'day-divider-05',
-            isViewable: true,
-            item: { id: 'day-divider-05', type: 'DateSeparator' },
-          },
-          { key: '5', isViewable: true, item: { id: '5', type: 'Message' } },
-        ],
-      })
-    )
-
-    expect(onSeen).toHaveBeenCalledTimes(1)
-    expect(onSeen).toHaveBeenCalledWith('5')
-  })
-
-  it('does not fire before the user has scrolled', () => {
-    const onSeen = jest.fn()
-    const observer = reportViewableMessages<Msg>(onSeen)
-
-    observer(
-      event({
-        userHasScrolled: false,
-        viewableItems: [{ key: '10', isViewable: true, item: { id: '10', type: 'Message' } }],
-      })
-    )
-
-    expect(onSeen).not.toHaveBeenCalled()
-  })
-})
-
-describe('detectDividerExitTowardNewer', () => {
-  const baseArgs = { dividerKey: 'unread-divider', initialMessageId: '050' }
-
-  it('fires onExited when the divider leaves and only newer messages remain visible', () => {
-    const onExited = jest.fn()
-    const observer = detectDividerExitTowardNewer<{ id: string; type?: string }>({
-      ...baseArgs,
-      onExited,
-    })
-
-    observer(
-      event({
-        changed: [
-          {
-            key: 'unread-divider',
-            isViewable: false,
-            item: { id: 'unread-divider', type: 'UnreadDivider' },
-          },
-        ],
-        viewableItems: [
-          { key: '055', isViewable: true, item: { id: '055', type: 'Message' } },
-          { key: '056', isViewable: true, item: { id: '056', type: 'Message' } },
-        ],
-      })
-    )
-
-    expect(onExited).toHaveBeenCalledTimes(1)
-  })
-
-  it('does not fire when divider leaves toward older messages', () => {
-    const onExited = jest.fn()
-    const observer = detectDividerExitTowardNewer<{ id: string; type?: string }>({
-      ...baseArgs,
-      onExited,
-    })
-
-    observer(
-      event({
-        changed: [
-          {
-            key: 'unread-divider',
-            isViewable: false,
-            item: { id: 'unread-divider', type: 'UnreadDivider' },
-          },
-        ],
-        viewableItems: [
-          { key: '045', isViewable: true, item: { id: '045', type: 'Message' } },
-          { key: '048', isViewable: true, item: { id: '048', type: 'Message' } },
-        ],
-      })
-    )
-
-    expect(onExited).not.toHaveBeenCalled()
-  })
-
-  it('does not fire before the user has scrolled', () => {
-    const onExited = jest.fn()
-    const observer = detectDividerExitTowardNewer<{ id: string; type?: string }>({
-      ...baseArgs,
-      onExited,
-    })
-
-    observer(
-      event({
-        userHasScrolled: false,
-        changed: [
-          {
-            key: 'unread-divider',
-            isViewable: false,
-            item: { id: 'unread-divider', type: 'UnreadDivider' },
-          },
-        ],
-        viewableItems: [{ key: '055', isViewable: true, item: { id: '055', type: 'Message' } }],
-      })
-    )
-
-    expect(onExited).not.toHaveBeenCalled()
-  })
-
-  it('no-ops when initialMessageId is null (observer is always installed)', () => {
-    const onExited = jest.fn()
-    const observer = detectDividerExitTowardNewer<{ id: string; type?: string }>({
-      dividerKey: 'unread-divider',
-      initialMessageId: null,
-      onExited,
-    })
-
-    observer(
-      event({
-        changed: [{ key: 'unread-divider', isViewable: false, item: { id: 'unread-divider' } }],
-        viewableItems: [{ key: '055', isViewable: true, item: { id: '055' } }],
-      })
-    )
-
-    expect(onExited).not.toHaveBeenCalled()
-  })
-})

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

@@ -1,85 +0,0 @@
-import { dividerExitedTowardNewer } from '../unread_divider_helpers'
-
-const dividerKey = 'unread-divider'
-const initialMessageId = '050'
-const msg = (id: string) => ({ item: { id, type: 'Message' } })
-
-describe('dividerExitedTowardNewer', () => {
-  it('returns false while the divider is still viewable', () => {
-    const result = dividerExitedTowardNewer({
-      changed: [{ key: dividerKey, isViewable: true }],
-      viewableItems: [
-        msg('049'),
-        { item: { id: dividerKey, type: 'UnreadDivider' } },
-        msg('050'),
-        msg('051'),
-      ],
-      dividerKey,
-      initialMessageId,
-    })
-    expect(result).toBe(false)
-  })
-
-  it('returns true when divider exits and only newer messages are visible (scrolled toward newer)', () => {
-    const result = dividerExitedTowardNewer({
-      changed: [{ key: dividerKey, isViewable: false }],
-      viewableItems: [msg('055'), msg('056'), msg('057')],
-      dividerKey,
-      initialMessageId,
-    })
-    expect(result).toBe(true)
-  })
-
-  it('returns false when divider exits and only older messages are visible (scrolled toward older)', () => {
-    const result = dividerExitedTowardNewer({
-      changed: [{ key: dividerKey, isViewable: false }],
-      viewableItems: [msg('040'), msg('045'), msg('048')],
-      dividerKey,
-      initialMessageId,
-    })
-    expect(result).toBe(false)
-  })
-
-  it('returns false when divider exits but the visible window straddles the boundary', () => {
-    const result = dividerExitedTowardNewer({
-      changed: [{ key: dividerKey, isViewable: false }],
-      viewableItems: [msg('048'), msg('049'), msg('055')],
-      dividerKey,
-      initialMessageId,
-    })
-    expect(result).toBe(false)
-  })
-
-  it('returns false when the divider entry is not in the changed set', () => {
-    const result = dividerExitedTowardNewer({
-      changed: [{ key: '055', isViewable: true }],
-      viewableItems: [msg('055'), msg('056')],
-      dividerKey,
-      initialMessageId,
-    })
-    expect(result).toBe(false)
-  })
-
-  it('returns false when no message items are visible (only the divider was)', () => {
-    const result = dividerExitedTowardNewer({
-      changed: [{ key: dividerKey, isViewable: false }],
-      viewableItems: [],
-      dividerKey,
-      initialMessageId,
-    })
-    expect(result).toBe(false)
-  })
-
-  it('ignores non-Message items (date separators, reply shadows) when deciding direction', () => {
-    const result = dividerExitedTowardNewer({
-      changed: [{ key: dividerKey, isViewable: false }],
-      viewableItems: [
-        { item: { id: 'day-divider-200', type: 'DateSeparator' } },
-        { item: { id: '055-rootA', type: 'ReplyShadowMessage' } },
-      ],
-      dividerKey,
-      initialMessageId,
-    })
-    expect(result).toBe(false)
-  })
-})

package/src/utils/conversation_messages.ts

@@ -1,37 +0,0 @@
-import { ApiCollection, MessageResource } from '../types'
-import { RequestData } from './client'
-
-export type MessagesPageParam = Partial<RequestData> & {
-  order?: 'asc' | 'desc'
-}
-
-export const anchoredSeedPageParams = (anchor: string): MessagesPageParam[] => [
-  { where: { id_gte: anchor }, order: 'asc' },
-  { where: { id_lt: anchor }, order: 'desc' },
-]
-
-export const olderPageParam = (
-  page: ApiCollection<MessageResource>
-): MessagesPageParam | undefined => {
-  const idLt = page.meta?.next?.idLt
-  if (!idLt) return undefined
-  return { where: { id_lt: idLt }, order: 'desc' }
-}
-
-export const newerPageParam = (
-  page: ApiCollection<MessageResource>
-): MessagesPageParam | undefined => {
-  const idGt = page.meta?.next?.idGt
-  if (!idGt) return undefined
-  return { where: { id_gt: idGt }, order: 'asc' }
-}
-
-export const sortAndFilterMessages = (pages: ApiCollection<MessageResource>[]): MessageResource[] =>
-  pages
-    .flatMap(page => page.data)
-    .filter(
-      message =>
-        (!message.deletedAt || message.replyRootId) &&
-        (message.attachments?.length || message.text?.length)
-    )
-    .sort((a, b) => -a.id.localeCompare(b.id))

package/src/utils/highest_seen_tracker.ts

@@ -1,42 +0,0 @@
-export const FLUSH_DELAY_MS = 2000
-
-type SendFn = (args: { conversationId: number; sortKey: string }) => void
-
-export function makeHighestSeenTracker(
-  conversationId: number,
-  send: SendFn,
-  flushDelayMs: number = FLUSH_DELAY_MS
-) {
-  let highest: string | null = null
-  let lastSent: string | null = null
-  let timer: ReturnType<typeof setTimeout> | null = null
-
-  const fire = () => {
-    timer = null
-    if (!highest || highest === lastSent) return
-    lastSent = highest
-    send({ conversationId, sortKey: highest })
-  }
-
-  return {
-    onSeen(sortKey: string) {
-      if (highest && sortKey.localeCompare(highest) <= 0) return
-      highest = sortKey
-      if (timer) clearTimeout(timer)
-      timer = setTimeout(fire, flushDelayMs)
-    },
-    flushNow() {
-      if (timer) {
-        clearTimeout(timer)
-        timer = null
-      }
-      fire()
-    },
-    cancel() {
-      if (timer) {
-        clearTimeout(timer)
-        timer = null
-      }
-    },
-  }
-}

package/src/utils/message_viewability.ts

@@ -1,49 +0,0 @@
-import { dividerExitedTowardNewer } from './unread_divider_helpers'
-
-export interface ViewableEntry<Item> {
-  key: string
-  isViewable: boolean
-  item: Item
-}
-
-export interface ViewabilityEvent<Item> {
-  viewableItems: ViewableEntry<Item>[]
-  changed: ViewableEntry<Item>[]
-  userHasScrolled: boolean
-}
-
-export type ViewabilityObserver<Item> = (event: ViewabilityEvent<Item>) => void
-
-export function reportViewableMessages<Item extends { id?: string; type?: string }>(
-  onMessageSeen: (id: string) => void
-): ViewabilityObserver<Item> {
-  return ({ viewableItems, userHasScrolled }) => {
-    if (!userHasScrolled) return
-    for (const entry of viewableItems) {
-      if (entry.item?.type !== 'Message') continue
-      const id = entry.item?.id
-      if (typeof id === 'string') onMessageSeen(id)
-    }
-  }
-}
-
-export function detectDividerExitTowardNewer<Item extends { id?: string; type?: string }>({
-  dividerKey,
-  initialMessageId,
-  onExited,
-}: {
-  dividerKey: string
-  initialMessageId: string | null
-  onExited: () => void
-}): ViewabilityObserver<Item> {
-  return ({ viewableItems, changed, userHasScrolled }) => {
-    if (!userHasScrolled || !initialMessageId) return
-    const exited = dividerExitedTowardNewer({
-      changed,
-      viewableItems,
-      dividerKey,
-      initialMessageId,
-    })
-    if (exited) onExited()
-  }
-}

package/src/utils/unread_divider_helpers.ts

@@ -1,25 +0,0 @@
-type ViewableChangeEntry = { key: string; isViewable: boolean }
-type ViewableItem = { item: { id?: string; type?: string } }
-
-export function dividerExitedTowardNewer({
-  changed,
-  viewableItems,
-  dividerKey,
-  initialMessageId,
-}: {
-  changed: ViewableChangeEntry[]
-  viewableItems: ViewableItem[]
-  dividerKey: string
-  initialMessageId: string
-}): boolean {
-  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 is string => !!id)
-  if (visibleMessageIds.length === 0) return false
-
-  return visibleMessageIds.every(id => id.localeCompare(initialMessageId) > 0)
-}