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

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_direct_message_eligibility.ts

@@ -1,40 +0,0 @@
-import { useQuery } from '@tanstack/react-query'
-import { ApiResource, MemberResource } from '../types'
-import { useApiClient } from './use_api_client'
-
-export interface DirectMessageEligibility {
-  canDirectMessage: boolean
-  directMessagesDisabled: boolean
-}
-
-export function useDirectMessageEligibility({
-  groupId,
-  personId,
-  enabled = true,
-}: {
-  groupId: string
-  personId: number
-  enabled?: boolean
-}) {
-  const apiClient = useApiClient()
-  const url = `/me/groups/${groupId}/members/${personId}`
-
-  const { data, isLoading, isError } = useQuery({
-    queryKey: ['chat', url, 'direct_message_eligibility'],
-    queryFn: () =>
-      apiClient.chat.get({
-        url,
-        data: { fields: { Member: ['can_direct_message', 'direct_messages_disabled'] } },
-      }) as Promise<ApiResource<MemberResource>>,
-    enabled,
-    retry: false,
-  })
-
-  const member = data?.data
-  const eligibility: DirectMessageEligibility | undefined = member && {
-    canDirectMessage: member.canDirectMessage ?? false,
-    directMessagesDisabled: member.directMessagesDisabled ?? false,
-  }
-
-  return { eligibility, isLoading, isError }
-}

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

package/src/hooks/use_fetch_newer_on_foreground.ts

@@ -1,25 +0,0 @@
-import { useEffect, useRef } from 'react'
-import { useAppState } from './use_app_state'
-
-type Options = {
-  fetchNewer: (newestMessageId: string) => Promise<void>
-  newestMessageId?: string
-  enabled: boolean
-}
-
-export const useFetchNewerOnForeground = ({ fetchNewer, newestMessageId, enabled }: Options) => {
-  const appState = useAppState()
-  const wasInBackground = useRef(false)
-
-  useEffect(() => {
-    if (appState !== 'active') {
-      wasInBackground.current = true
-      return
-    }
-    const returnedToForeground = wasInBackground.current
-    wasInBackground.current = false
-    if (!returnedToForeground || !enabled || !newestMessageId) return
-
-    fetchNewer(newestMessageId).catch(() => {})
-  }, [appState, enabled, fetchNewer, newestMessageId])
-}

package/src/hooks/use_held_back_messages.ts

@@ -1,33 +0,0 @@
-import { useCallback, useEffect, useRef } from 'react'
-
-type Options = {
-  fetchNewer: (newestMessageId: string) => Promise<void>
-  newestMessageId?: string
-  readingHistory: boolean
-  caughtUp: boolean
-}
-
-export const useHeldBackMessages = ({
-  fetchNewer,
-  newestMessageId,
-  readingHistory,
-  caughtUp,
-}: Options) => {
-  const heldBackSince = useRef<string | null>(null)
-
-  const onSkippedNewMessage = useCallback(() => {
-    heldBackSince.current ??= newestMessageId ?? null
-  }, [newestMessageId])
-
-  useEffect(() => {
-    const since = heldBackSince.current
-    if (readingHistory || !caughtUp || !since) return
-
-    heldBackSince.current = null
-    fetchNewer(since).catch(() => {
-      heldBackSince.current ??= since
-    })
-  }, [caughtUp, fetchNewer, readingHistory])
-
-  return { onSkippedNewMessage }
-}

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

@@ -1,37 +0,0 @@
-import { QueryClient } from '@tanstack/react-query'
-import { getMessagesQueryKey } from '../../request/get_messages'
-import { findMessageInCaches } from '../find_message_in_caches'
-
-const page = (ids: string[]) => ({
-  data: ids.map(id => ({ id, type: 'Message' })),
-  links: {},
-  meta: { count: ids.length, totalCount: ids.length },
-})
-
-const seed = (queryClient: QueryClient, key: unknown[], ids: string[]) =>
-  queryClient.setQueryData(key, { pages: [page(ids)], pageParams: [{}] })
-
-describe('findMessageInCaches', () => {
-  const queryClient = new QueryClient()
-
-  beforeEach(() => {
-    queryClient.clear()
-    seed(queryClient, getMessagesQueryKey({ conversation_id: 1 }), ['01C', '01B'])
-    seed(queryClient, getMessagesQueryKey({ conversation_id: 1, anchor: '01A' }), ['01A', '00Z'])
-    seed(queryClient, getMessagesQueryKey({ conversation_id: 1, reply_root_id: '01B' }), ['01R'])
-    seed(queryClient, getMessagesQueryKey({ conversation_id: 2 }), ['02A'])
-  })
-
-  it('finds a message in the live cache', () => {
-    expect(findMessageInCaches(queryClient, 1, '01B')?.id).toBe('01B')
-  })
-
-  it('finds a message that only the anchored cache holds', () => {
-    expect(findMessageInCaches(queryClient, 1, '00Z')?.id).toBe('00Z')
-  })
-
-  it('ignores reply threads and other conversations', () => {
-    expect(findMessageInCaches(queryClient, 1, '01R')).toBeUndefined()
-    expect(findMessageInCaches(queryClient, 1, '02A')).toBeUndefined()
-  })
-})

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

@@ -1,23 +0,0 @@
-import { QueryClient } from '@tanstack/react-query'
-import { getMessagesQueryKey } from '../../request/get_messages'
-import { invalidateRefetchableQueries } from '../invalidate_refetchable_queries'
-
-describe('invalidateRefetchableQueries', () => {
-  const queryClient = new QueryClient()
-  const live = getMessagesQueryKey({ conversation_id: 1 })
-  const anchored = getMessagesQueryKey({ conversation_id: 1, anchor: '01A' })
-  const other = ['/me/conversations']
-
-  beforeEach(() => {
-    queryClient.clear()
-    for (const key of [live, anchored, other]) queryClient.setQueryData(key, { pages: [], pageParams: [] })
-  })
-
-  it('invalidates everything except anchored message windows', async () => {
-    await invalidateRefetchableQueries(queryClient)
-
-    expect(queryClient.getQueryState(live)?.isInvalidated).toBe(true)
-    expect(queryClient.getQueryState(other)?.isInvalidated).toBe(true)
-    expect(queryClient.getQueryState(anchored)?.isInvalidated).toBe(false)
-  })
-})

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

@@ -1,34 +0,0 @@
-import { prependNewerPage } from '../prepend_newer_page'
-
-const page = (ids: string[], next?: { idGt: string }) => ({
-  data: ids.map(id => ({ id, type: 'Message' })),
-  links: {},
-  meta: { count: ids.length, totalCount: ids.length, next },
-})
-
-describe('prependNewerPage', () => {
-  const cached = { pages: [page(['01C', '01B']), page(['01A'])], pageParams: [{}, { offset: 1 }] }
-
-  it('merges the new rows into the first page and leaves the page params alone', () => {
-    const result = prependNewerPage(cached, [page(['01C', '01D', '01E'])])
-
-    expect(result?.pages).toHaveLength(2)
-    expect(result?.pages[0].data.map(m => m.id)).toEqual(['01D', '01E', '01C', '01B'])
-    expect(result?.pageParams).toEqual(cached.pageParams)
-  })
-
-  it('merges every fetched batch, newest last', () => {
-    const result = prependNewerPage(cached, [page(['01D', '01E']), page(['01F'])])
-
-    expect(result?.pages[0].data.map(m => m.id)).toEqual(['01D', '01E', '01F', '01C', '01B'])
-  })
-
-  it('returns the same data when nothing new came back', () => {
-    expect(prependNewerPage(cached, [page(['01C'])])).toBe(cached)
-    expect(prependNewerPage(cached, [])).toBe(cached)
-  })
-
-  it('does nothing without cached data', () => {
-    expect(prependNewerPage(undefined, [page(['01D'])])).toBeUndefined()
-  })
-})

package/src/utils/cache/find_message_in_caches.ts

@@ -1,20 +0,0 @@
-import { InfiniteData, QueryClient } from '@tanstack/react-query'
-import { ApiCollection, MessageResource } from '../../types'
-import { getMessagesRequestArgs } from '../request/get_messages'
-
-type QueryData = InfiniteData<ApiCollection<MessageResource>>
-
-export const findMessageInCaches = (
-  queryClient: QueryClient,
-  conversation_id: number,
-  message_id: string
-): MessageResource | undefined => {
-  const { url } = getMessagesRequestArgs({ conversation_id })
-
-  for (const [, data] of queryClient.getQueriesData<QueryData>({ queryKey: [url] })) {
-    const found = data?.pages.flatMap(page => page.data).find(message => message.id === message_id)
-    if (found) return found
-  }
-
-  return undefined
-}

package/src/utils/cache/invalidate_refetchable_queries.ts

@@ -1,9 +0,0 @@
-import { Query, QueryClient } from '@tanstack/react-query'
-
-const isAnchoredMessagesWindow = (query: Query) => {
-  const [, params] = query.queryKey as [unknown, { where?: { id_around?: string } } | undefined]
-  return !!params?.where?.id_around
-}
-
-export const invalidateRefetchableQueries = (queryClient: QueryClient) =>
-  queryClient.invalidateQueries({ predicate: query => !isAnchoredMessagesWindow(query) })

package/src/utils/cache/prepend_newer_page.ts

@@ -1,19 +0,0 @@
-import { InfiniteData } from '@tanstack/react-query'
-import { ApiCollection, ResourceObject } from '../../types'
-import { RequestData } from '../client'
-
-type PagesData<T extends ResourceObject> = InfiniteData<ApiCollection<T>, Partial<RequestData>>
-
-export function prependNewerPage<T extends ResourceObject>(
-  data: PagesData<T> | undefined,
-  pages: ApiCollection<T>[]
-): PagesData<T> | undefined {
-  if (!data || data.pages.length === 0) return data
-
-  const knownIds = new Set(data.pages.flatMap(page => page.data.map(record => record.id)))
-  const fresh = pages.flatMap(page => page.data).filter(record => !knownIds.has(record.id))
-  if (fresh.length === 0) return data
-
-  const [first, ...rest] = data.pages
-  return { ...data, pages: [{ ...first, data: [...fresh, ...first.data] }, ...rest] }
-}

package/src/utils/gated_message_cache.ts

@@ -1,19 +0,0 @@
-import type { MessagesCache } from '../hooks/use_conversation_messages_jolt_events'
-
-export const gatedMessageCache = ({
-  queryKey,
-  acceptNewMessages,
-  onSkippedNewMessage,
-}: {
-  queryKey: unknown[]
-  acceptNewMessages: boolean
-  onSkippedNewMessage?: () => void
-}): MessagesCache => ({
-  queryKey,
-  canUpdate: event => {
-    if (event !== 'message.created' || acceptNewMessages) return true
-
-    onSkippedNewMessage?.()
-    return false
-  },
-})

package/src/utils/ulid.ts

@@ -1,11 +0,0 @@
-export const ULID_CHARS = '0123456789ABCDEFGHJKMNPQRSTVWXYZ' // Crockford's Base32
-
-const TIME_LENGTH = 10
-
-export function decodeUlidTime(ulid: string): number {
-  return ulid
-    .slice(0, TIME_LENGTH)
-    .toUpperCase()
-    .split('')
-    .reduce((time, char) => time * 32 + ULID_CHARS.indexOf(char), 0)
-}