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

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)
-}