react-native-controlled-mentions: A TypeScript repository from dabakovich

react-native-controlled-mentions

Pretty simple and fully controlled mention input. It can:

Gracefully render formatted mentions directly in RN TextInput component
Support for different mention types (@user mentions, #hashtags, etc)
Use value/onChange as in usual TextInput props
Completely typed (written on TypeScript)
No need for native libraries

In addition, you can add custom styling for a regex pattern (like URLs) using the optimized recursive function for parsing the value.

Demo

Try it on Expo Snack: https://snack.expo.io/@dabakovich/mentionsapp

Getting started

Install the library using either Yarn:

yarn add react-native-controlled-mentions

or npm:

npm install --save react-native-controlled-mentions

Usage

Import the MentionInput component:

import { MentionInput } from 'react-native-controlled-mentions'

Replace your TextInput by MentionInput component and add the partTypes property where you can define what mention or pattern types you want to support. It takes an array of PartType objects.

<MentionInput
  value={value}
  onChange={setValue}

  partTypes={[
    {
      trigger: '@', // Should be a single character like '@' or '#'
      renderSuggestions,
      textStyle: {fontWeight: 'bold', color: 'blue'}, // The mention style in the input
    },
  ]}
/>

Define your renderSuggestions functional component that receive MentionSuggestionsProps:

const suggestions = [
  {id: '1', name: 'David Tabaka'},
  {id: '2', name: 'Mary'},
  {id: '3', name: 'Tony'},
  {id: '4', name: 'Mike'},
  {id: '5', name: 'Grey'},
];

const renderSuggestions: FC<MentionSuggestionsProps> = ({keyword, onSuggestionPress}) => {
  if (keyword == null) {
    return null;
  }

  return (
    <View>
      {suggestions
        .filter(one => one.name.toLocaleLowerCase().includes(keyword.toLocaleLowerCase()))
        .map(one => (
          <Pressable
            key={one.id}
            onPress={() => onSuggestionPress(one)}

            style={{padding: 12}}
          >
            <Text>{one.name}</Text>
          </Pressable>
        ))
      }
    </View>
  );
};

You're done!

The whole example is in the /example folder.

API

`MentionInput` component props

Property name	Description	Type	Required	Default
`value`	The same as in `TextInput`	string	true
`onChange`	The same as in `TextInput`	(value: string) => void	true
`partTypes`	Declare what part types you want to support (mentions, hashtags, urls)	PartType[]	false	[]
`inputRef`	Reference to the `TextInput` component inside `MentionInput`	Ref<TextInput>	false
`containerStyle`	Style to the `MentionInput`'s root component	StyleProp<TextStyle>	false
...textInputProps	Other text input props	TextInputProps	false

`PartType` type

MentionPartType | PatternPartType

`MentionPartType` type props

Property name	Description	Type	Required	Default
`trigger`	Character that will trigger current mention type	string	true
`renderSuggestions`	Renderer for mention suggestions component	(props: MentionSuggestionsProps) => ReactNode	false
`allowedSpacesCount`	How much spaces are allowed for mention keyword	number	false	1
`isInsertSpaceAfterMention`	Should we add a space after selected mentions if the mention is at the end of row	boolean	false	false
`isBottomMentionSuggestionsRender`	Should we render either at the top or bottom of the input	boolean	false
`textStyle`	Text style for mentions in `TextInput`	StyleProp<TextStyle>	false
`getPlainString`	Function for generating custom mention text in text input	(mention: MentionData) => string	false

`PatternPartType` type props

Property name	Description	Type	Required	Default
`pattern`	RegExp for parsing a pattern, should include global flag	RegExp	true
`textStyle`	Text style for pattern in `TextInput`	StyleProp<TextStyle>	false

`MentionSuggestionsProps` type props

keyword: string | undefined

Keyword that will provide string between trigger character (e.g. '@') and cursor.

If the cursor is not tracking any mention typing the keyword will be undefined.

Examples where @name is just plain text yet, not mention and | is cursor position:

'|abc @name dfg' - keyword is undefined
'abc @| dfg' - keyword is ''
'abc @name| dfg' - keyword is 'name'
'abc @na|me dfg' - keyword is 'na'
'abc @|name dfg' - keyword is against ''
'abc @name |dfg' - keyword is against undefined

onSuggestionPress: (suggestion: Suggestion) => void

You should call that callback when user selects any suggestion.

`Suggestion` type props

id: string

Unique id for each suggestion.

name: string

Name that will be shown in MentionInput when user will select the suggestion.

`MentionData` type props

For example, we have that mention value @[David Tabaka](123). Then after parsing that string by mentionRegEx we will get next properties:

original: string

The whole mention value string - @[David Tabaka](123)

trigger: string

The extracted trigger - @

name: string

The extracted name - David Tabaka

id: string

The extracted id - 123

`mentionRegEx`

/(?<original>(?<trigger>.)\[(?<name>([^[]*))]\((?<id>([\d\w-]*))\))/gi;

Parsing `MentionInput`'s value

You can import RegEx that is using in the component and then extract all your mentions from MentionInput's value using your own logic.

import { mentionRegEx } from 'react-native-controlled-mentions';

Or you can use replaceMentionValues helper to replace all mentions from MentionInput's input using your replacer function that receives MentionData type and returns string.

import { replaceMentionValues } from 'react-native-controlled-mentions';

const value = 'Hello @[David Tabaka](5)! How are you?';

console.log(replaceMentionValues(value, ({id}) => `@${id}`)); // Hello @5! How are you?
console.log(replaceMentionValues(value, ({name}) => `@${name}`)); // Hello @David Tabaka! How are you?

Rendering `MentionInput`'s value

If you want to parse and render your value somewhere else you can use parseValue tool which gives you array of parts and then use your own part renderer to resolve this issue.

Here is an example:

import {
  Part,
  PartType,
  parseValue,
  isMentionPartType,
} from 'react-native-controlled-mentions';

/**
 * Part renderer
 * 
 * @param part
 * @param index
 */
const renderPart = (
  part: Part,
  index: number,
) => {
  // Just plain text
  if (!part.partType) {
    return <Text key={index}>{part.text}</Text>;
  }

  // Mention type part
  if (isMentionPartType(part.partType)) {
    return (
      <Text
        key={`${index}-${part.data?.trigger}`}
        style={part.partType.textStyle}
        onPress={() => console.log('Pressed', part.data)}
      >
        {part.text}
      </Text>
    );
  }

  // Other styled part types
  return (
    <Text
      key={`${index}-pattern`}
      style={part.partType.textStyle}
    >
      {part.text}
    </Text>
  );
};

/**
 * Value renderer. Parsing value to parts array and then mapping the array using 'renderPart'
 * 
 * @param value - value from MentionInput
 * @param partTypes - the part types array that you providing to MentionInput
 */
const renderValue: FC = (
  value: string,
  partTypes: PartType[],
) => {
  const {parts} = parseValue(value, partTypes);

  return <Text>{parts.map(renderPart)}</Text>;
};

To Do

~~Add support for different text formatting (e.g. URLs)~~
~~Add more customizations~~ DONE
~~Add ability to handle few mention types ("#", "@" etc)~~ DONE

Known issues

Mention name regex accepts white spaces (e.g. {name: ' ', value: 1})
~~Keyboard auto-correction not working if suggested word has the same length~~ FIXED
~~Text becomes transparent when setting custom font size in TextInput~~ FIXED

dabakovich/react-native-controlled-mentions