@fendent/react-native-enriched 0.5.2-fork.1

package/ios/utils/WordsUtils.mm

@@ -0,0 +1,98 @@
+#import "WordsUtils.h"
+
+@implementation WordsUtils
+
++ (NSArray<NSDictionary *> *)getAffectedWordsFromText:(NSString *)text
+                                    modificationRange:(NSRange)range {
+  if (text.length == 0) {
+    return [[NSArray alloc] init];
+  }
+
+  NSInteger leftIt = range.location - 1;
+  leftIt = MIN(leftIt, NSInteger(text.length - 1));
+  if (leftIt > 0) {
+    while (leftIt >= 0) {
+      unichar charAtIndex = [text characterAtIndex:leftIt];
+      if ([[NSCharacterSet whitespaceAndNewlineCharacterSet]
+              characterIsMember:charAtIndex]) {
+        leftIt += 1;
+        break;
+      }
+      leftIt -= 1;
+    }
+  }
+  leftIt = MAX(0, leftIt);
+  leftIt = MIN(NSInteger(text.length - 1), leftIt);
+
+  NSInteger rightIt = range.location + range.length;
+  if (rightIt < text.length - 1) {
+    while (rightIt <= text.length - 1) {
+      unichar charAtIndex = [text characterAtIndex:rightIt];
+      if ([[NSCharacterSet whitespaceAndNewlineCharacterSet]
+              characterIsMember:charAtIndex]) {
+        rightIt -= 1;
+        break;
+      }
+      rightIt += 1;
+    }
+  }
+  rightIt = MIN(NSInteger(text.length - 1), rightIt);
+
+  if (leftIt > rightIt) {
+    return [[NSArray alloc] init];
+  }
+
+  NSMutableArray<NSDictionary *> *separatedWords =
+      [[NSMutableArray<NSDictionary *> alloc] init];
+  NSMutableString *currentWord = [[NSMutableString alloc] init];
+  NSInteger currentRangeStart = leftIt;
+  NSInteger currentIdx = leftIt;
+
+  while (currentIdx <= rightIt) {
+    unichar charAtIndex = [text characterAtIndex:currentIdx];
+    if ([[NSCharacterSet whitespaceAndNewlineCharacterSet]
+            characterIsMember:charAtIndex]) {
+      if (currentWord.length > 0) {
+        [separatedWords addObject:@{
+          @"word" : [currentWord copy],
+          @"range" : [NSValue
+              valueWithRange:NSMakeRange(currentRangeStart, currentWord.length)]
+        }];
+        [currentWord setString:@""];
+      }
+      currentRangeStart = currentIdx + 1;
+    } else {
+      [currentWord appendFormat:@"%C", charAtIndex];
+    }
+    currentIdx += 1;
+  }
+
+  if (currentWord.length > 0) {
+    [separatedWords addObject:@{
+      @"word" : [currentWord copy],
+      @"range" :
+          [NSValue valueWithRange:NSMakeRange(currentRangeStart,
+                                              rightIt - currentRangeStart + 1)]
+    }];
+  }
+
+  return separatedWords;
+}
+
++ (NSDictionary *)getCurrentWord:(NSString *)text range:(NSRange)range {
+  // we just get current word at the cursor
+  if (range.length > 0) {
+    return nullptr;
+  }
+
+  NSArray<NSDictionary *> *words = [WordsUtils getAffectedWordsFromText:text
+                                                      modificationRange:range];
+  if (words != nullptr && [words count] == 1 &&
+      [words firstObject] != nullptr) {
+    return [words firstObject];
+  }
+
+  return nullptr;
+}
+
+@end

package/ios/utils/ZeroWidthSpaceUtils.h

@@ -0,0 +1,9 @@
+#import <UIKit/UIKit.h>
+#pragma once
+
+@interface ZeroWidthSpaceUtils : NSObject
++ (void)handleZeroWidthSpacesInInput:(id)input;
++ (BOOL)handleBackspaceInRange:(NSRange)range
+               replacementText:(NSString *)text
+                         input:(id)input;
+@end

package/ios/utils/ZeroWidthSpaceUtils.mm

@@ -0,0 +1,270 @@
+#import "ZeroWidthSpaceUtils.h"
+#import "EnrichedTextInputView.h"
+#import "StyleHeaders.h"
+#import "TextInsertionUtils.h"
+#import "UIView+React.h"
+
+@implementation ZeroWidthSpaceUtils
++ (void)handleZeroWidthSpacesInInput:(id)input {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
+  if (typedInput == nullptr) {
+    return;
+  }
+
+  [self removeSpacesIfNeededinInput:typedInput];
+  [self addSpacesIfNeededinInput:typedInput];
+}
+
++ (void)removeSpacesIfNeededinInput:(EnrichedTextInputView *)input {
+  NSMutableArray *indexesToBeRemoved = [[NSMutableArray alloc] init];
+  NSRange preRemoveSelection = input->textView.selectedRange;
+
+  for (int i = 0; i < input->textView.textStorage.string.length; i++) {
+    unichar character = [input->textView.textStorage.string characterAtIndex:i];
+    if (character == 0x200B) {
+      NSRange characterRange = NSMakeRange(i, 1);
+
+      NSRange paragraphRange = [input->textView.textStorage.string
+          paragraphRangeForRange:characterRange];
+      // having paragraph longer than 1 character means someone most likely
+      // added something and we probably can remove the space
+      BOOL removeSpace = paragraphRange.length > 1;
+      // exception; 2 characters paragraph with zero width space + newline
+      // here, we still need zero width space to keep the empty list items
+      if (paragraphRange.length == 2 && paragraphRange.location == i &&
+          [[NSCharacterSet newlineCharacterSet]
+              characterIsMember:[input->textView.textStorage.string
+                                    characterAtIndex:i + 1]]) {
+        removeSpace = NO;
+      }
+
+      if (removeSpace) {
+        [indexesToBeRemoved addObject:@(characterRange.location)];
+        continue;
+      }
+
+      // zero width spaces with no needsZWS style on them get removed
+      if (![self anyZWSStylePresentInRange:characterRange input:input]) {
+        [indexesToBeRemoved addObject:@(characterRange.location)];
+      }
+    }
+  }
+
+  // do the removing
+  NSInteger offset = 0;
+  NSInteger postRemoveLocationOffset = 0;
+  NSInteger postRemoveLengthOffset = 0;
+  for (NSNumber *index in indexesToBeRemoved) {
+    NSRange replaceRange = NSMakeRange([index integerValue] + offset, 1);
+    [TextInsertionUtils replaceText:@""
+                                 at:replaceRange
+               additionalAttributes:nullptr
+                              input:input
+                      withSelection:NO];
+    offset -= 1;
+    if ([index integerValue] < preRemoveSelection.location) {
+      postRemoveLocationOffset -= 1;
+    }
+    if ([index integerValue] >= preRemoveSelection.location &&
+        [index integerValue] < NSMaxRange(preRemoveSelection)) {
+      postRemoveLengthOffset -= 1;
+    }
+  }
+
+  // fix the selection if needed
+  if ([input->textView isFirstResponder]) {
+    input->textView.selectedRange =
+        NSMakeRange(preRemoveSelection.location + postRemoveLocationOffset,
+                    preRemoveSelection.length + postRemoveLengthOffset);
+  }
+}
+
+// Collects active inline (non-paragraph) meta-attributes from the style
+// dictionary so that ZWS characters carry the same meta-attributes that are
+// currently active in the typing attributes. Only within the currently selected
+// range!
++ (NSDictionary *)inlineMetaAttributesForInput:(EnrichedTextInputView *)input {
+  NSMutableDictionary *metaAttrs = [NSMutableDictionary new];
+  for (NSNumber *type in input->stylesDict) {
+    StyleBase *style = input->stylesDict[type];
+    if (![style isParagraph]) {
+      AttributeEntry *entry =
+          [style getEntryIfPresent:input->textView.selectedRange];
+      if (entry) {
+        metaAttrs[entry.key] = entry.value;
+      }
+    }
+  }
+  return metaAttrs.count > 0 ? metaAttrs : nullptr;
+}
+
++ (void)addSpacesIfNeededinInput:(EnrichedTextInputView *)input {
+  NSMutableArray *indexesToBeInserted = [[NSMutableArray alloc] init];
+  NSRange preAddSelection = input->textView.selectedRange;
+
+  for (NSUInteger i = 0; i < input->textView.textStorage.string.length; i++) {
+    unichar character = [input->textView.textStorage.string characterAtIndex:i];
+
+    if ([[NSCharacterSet newlineCharacterSet] characterIsMember:character]) {
+      NSRange characterRange = NSMakeRange(i, 1);
+      NSRange paragraphRange = [input->textView.textStorage.string
+          paragraphRangeForRange:characterRange];
+
+      if (paragraphRange.length == 1) {
+        if ([self anyZWSStylePresentInRange:characterRange input:input]) {
+          // we have an empty list or quote item with no space: add it!
+          [indexesToBeInserted addObject:@(paragraphRange.location)];
+        }
+      }
+    }
+  }
+
+  NSDictionary *metaAttrs = [self inlineMetaAttributesForInput:input];
+
+  // do the replacing
+  NSInteger offset = 0;
+  NSInteger postAddLocationOffset = 0;
+  NSInteger postAddLengthOffset = 0;
+  for (NSNumber *index in indexesToBeInserted) {
+    NSRange replaceRange = NSMakeRange([index integerValue] + offset, 1);
+    [TextInsertionUtils replaceText:@"\u200B\n"
+                                 at:replaceRange
+               additionalAttributes:metaAttrs
+                              input:input
+                      withSelection:NO];
+    offset += 1;
+    if ([index integerValue] < preAddSelection.location) {
+      postAddLocationOffset += 1;
+    }
+    if ([index integerValue] >= preAddSelection.location &&
+        [index integerValue] < NSMaxRange(preAddSelection)) {
+      postAddLengthOffset += 1;
+    }
+  }
+
+  // additional check for last index of the input
+  NSRange lastRange = NSMakeRange(input->textView.textStorage.string.length, 0);
+  NSRange lastParagraphRange =
+      [input->textView.textStorage.string paragraphRangeForRange:lastRange];
+  if (lastParagraphRange.length == 0 &&
+      [self anyZWSStylePresentInRange:lastRange input:input]) {
+    [TextInsertionUtils insertText:@"\u200B"
+                                at:lastRange.location
+              additionalAttributes:metaAttrs
+                             input:input
+                     withSelection:NO];
+  }
+
+  // fix the selection if needed
+  if ([input->textView isFirstResponder]) {
+    input->textView.selectedRange =
+        NSMakeRange(preAddSelection.location + postAddLocationOffset,
+                    preAddSelection.length + postAddLengthOffset);
+  }
+}
+
++ (BOOL)handleBackspaceInRange:(NSRange)range
+               replacementText:(NSString *)text
+                         input:(id)input {
+  if (![text isEqualToString:@""]) {
+    return NO;
+  }
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
+  if (typedInput == nullptr) {
+    return NO;
+  }
+
+  // Backspace at the very beginning of the input ({0, 0}).
+  // Nothing to delete, but if the first paragraph has a needsZWS style,
+  // remove it.
+  if (range.length == 0 && range.location == 0) {
+    NSRange firstParagraphRange = [typedInput->textView.textStorage.string
+        paragraphRangeForRange:NSMakeRange(0, 0)];
+    if ([self removeZWSStyleInRange:firstParagraphRange input:typedInput]) {
+      return YES;
+    }
+    return NO;
+  }
+
+  if (range.length != 1) {
+    return NO;
+  }
+
+  unichar character =
+      [typedInput->textView.textStorage.string characterAtIndex:range.location];
+  // zero-width space got backspaced
+  if (character == 0x200B) {
+    // in such case: remove the whole line without the endline if there is one
+
+    NSRange paragraphRange =
+        [typedInput->textView.textStorage.string paragraphRangeForRange:range];
+    NSRange removalRange = paragraphRange;
+    // if whole paragraph gets removed then 0 length for style removal
+    NSRange styleRemovalRange = NSMakeRange(paragraphRange.location, 0);
+
+    if ([[NSCharacterSet newlineCharacterSet]
+            characterIsMember:[typedInput->textView.textStorage.string
+                                  characterAtIndex:NSMaxRange(paragraphRange) -
+                                                   1]]) {
+      // if endline is there, don't remove it
+      removalRange =
+          NSMakeRange(paragraphRange.location, paragraphRange.length - 1);
+      // if endline is left then 1 length for style removal
+      styleRemovalRange = NSMakeRange(paragraphRange.location, 1);
+    }
+
+    // remove the ZWS (keep the newline if present)
+    [TextInsertionUtils replaceText:@""
+                                 at:removalRange
+               additionalAttributes:nullptr
+                              input:typedInput
+                      withSelection:YES];
+
+    // and then remove associated styling
+    [self removeZWSStyleInRange:styleRemovalRange input:typedInput];
+
+    return YES;
+  }
+
+  // Backspace at the start of a paragraph that has a ZWS-needing style.
+  // The character being deleted is the newline at the end of the previous
+  // paragraph. Instead of letting iOS merge the two lines, just remove the
+  // style from the current paragraph.
+  if ([[NSCharacterSet newlineCharacterSet] characterIsMember:character]) {
+    NSUInteger nextParaStart = NSMaxRange(range);
+    if (nextParaStart < typedInput->textView.textStorage.string.length) {
+      NSRange nextParagraphRange = [typedInput->textView.textStorage.string
+          paragraphRangeForRange:NSMakeRange(nextParaStart, 0)];
+      if ([self removeZWSStyleInRange:nextParagraphRange input:typedInput]) {
+        return YES;
+      }
+    }
+  }
+
+  return NO;
+}
+
++ (BOOL)anyZWSStylePresentInRange:(NSRange)range
+                            input:(EnrichedTextInputView *)input {
+  for (NSNumber *type in input->stylesDict) {
+    StyleBase *style = input->stylesDict[type];
+    if ([style needsZWS] && [style detect:range]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
++ (BOOL)removeZWSStyleInRange:(NSRange)range
+                        input:(EnrichedTextInputView *)input {
+  for (NSNumber *type in input->stylesDict) {
+    StyleBase *style = input->stylesDict[type];
+    if ([style needsZWS] && [style detect:range]) {
+      [style remove:range withDirtyRange:YES];
+      return YES;
+    }
+  }
+  return NO;
+}
+
+@end

package/lib/module/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { EnrichedTextInput } from "./native/EnrichedTextInput.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EnrichedTextInput"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,iBAAiB,QAAQ,+BAA4B","ignoreList":[]}

package/lib/module/native/EnrichedTextInput.js

@@ -0,0 +1,304 @@
+"use strict";
+
+import { useEffect, useImperativeHandle, useMemo, useRef } from 'react';
+import { useCallback } from 'react';
+import EnrichedTextInputNativeComponent, { Commands } from '../spec/EnrichedTextInputNativeComponent';
+import { normalizeHtmlStyle } from "../utils/normalizeHtmlStyle.js";
+import { toNativeRegexConfig } from "../utils/regexParser.js";
+import { nullthrows } from "../utils/nullthrows.js";
+import { ENRICHED_TEXT_INPUT_DEFAULT_PROPS } from "../utils/EnrichedTextInputDefaultProps.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const warnMentionIndicators = indicator => {
+  console.warn(`Looks like you are trying to set a "${indicator}" but it's not in the mentionIndicators prop`);
+};
+export const EnrichedTextInput = ({
+  ref,
+  autoFocus,
+  editable = ENRICHED_TEXT_INPUT_DEFAULT_PROPS.editable,
+  mentionIndicators = ENRICHED_TEXT_INPUT_DEFAULT_PROPS.mentionIndicators.slice(),
+  defaultValue,
+  placeholder,
+  placeholderTextColor,
+  cursorColor,
+  selectionColor,
+  style,
+  autoCapitalize = ENRICHED_TEXT_INPUT_DEFAULT_PROPS.autoCapitalize,
+  htmlStyle = ENRICHED_TEXT_INPUT_DEFAULT_PROPS.htmlStyle,
+  linkRegex: _linkRegex,
+  onFocus,
+  onBlur,
+  onChangeText,
+  onChangeHtml,
+  onChangeState,
+  onLinkDetected,
+  onMentionDetected,
+  onStartMention,
+  onChangeMention,
+  onEndMention,
+  onChangeSelection,
+  onKeyPress,
+  onSubmitEditing,
+  returnKeyType,
+  returnKeyLabel,
+  submitBehavior,
+  contextMenuItems,
+  androidExperimentalSynchronousEvents = ENRICHED_TEXT_INPUT_DEFAULT_PROPS.androidExperimentalSynchronousEvents,
+  useHtmlNormalizer = ENRICHED_TEXT_INPUT_DEFAULT_PROPS.useHtmlNormalizer,
+  scrollEnabled = ENRICHED_TEXT_INPUT_DEFAULT_PROPS.scrollEnabled,
+  ...rest
+}) => {
+  const nativeRef = useRef(null);
+  const nextHtmlRequestId = useRef(1);
+  const pendingHtmlRequests = useRef(new Map());
+
+  // Store onPress callbacks in a ref so native only receives serializable data
+  const contextMenuCallbacksRef = useRef(new Map());
+  useEffect(() => {
+    const callbacksMap = new Map();
+    if (contextMenuItems) {
+      for (const item of contextMenuItems) {
+        callbacksMap.set(item.text, item.onPress);
+      }
+    }
+    contextMenuCallbacksRef.current = callbacksMap;
+  }, [contextMenuItems]);
+  const nativeContextMenuItems = useMemo(() => contextMenuItems?.filter(item => item.visible !== false).map(item => ({
+    text: item.text
+  })), [contextMenuItems]);
+  const handleContextMenuItemPress = useCallback(e => {
+    const {
+      itemText,
+      selectedText,
+      selectionStart,
+      selectionEnd,
+      styleState
+    } = e.nativeEvent;
+    const callback = contextMenuCallbacksRef.current.get(itemText);
+    callback?.({
+      text: selectedText,
+      selection: {
+        start: selectionStart,
+        end: selectionEnd
+      },
+      styleState
+    });
+  }, []);
+  useEffect(() => {
+    const pendingRequests = pendingHtmlRequests.current;
+    return () => {
+      pendingRequests.forEach(({
+        reject
+      }) => {
+        reject(new Error('Component unmounted'));
+      });
+      pendingRequests.clear();
+    };
+  }, []);
+  const normalizedHtmlStyle = useMemo(() => normalizeHtmlStyle(htmlStyle, mentionIndicators), [htmlStyle, mentionIndicators]);
+  const linkRegex = useMemo(() => toNativeRegexConfig(_linkRegex), [_linkRegex]);
+  useImperativeHandle(ref, () => ({
+    measureInWindow: callback => {
+      nullthrows(nativeRef.current).measureInWindow(callback);
+    },
+    measure: callback => {
+      nullthrows(nativeRef.current).measure(callback);
+    },
+    measureLayout: (relativeToNativeComponentRef, onSuccess, onFail) => {
+      nullthrows(nativeRef.current).measureLayout(relativeToNativeComponentRef, onSuccess, onFail);
+    },
+    setNativeProps: nativeProps => {
+      nullthrows(nativeRef.current).setNativeProps(nativeProps);
+    },
+    focus: () => {
+      Commands.focus(nullthrows(nativeRef.current));
+    },
+    blur: () => {
+      Commands.blur(nullthrows(nativeRef.current));
+    },
+    setValue: value => {
+      Commands.setValue(nullthrows(nativeRef.current), value);
+    },
+    insertText: (text, start, end) => {
+      const s = start ?? -1;
+      const e = end ?? s;
+      Commands.insertText(nullthrows(nativeRef.current), text, s, e);
+    },
+    getHTML: () => {
+      return new Promise((resolve, reject) => {
+        const requestId = nextHtmlRequestId.current++;
+        pendingHtmlRequests.current.set(requestId, {
+          resolve,
+          reject
+        });
+        Commands.requestHTML(nullthrows(nativeRef.current), requestId);
+      });
+    },
+    toggleBold: () => {
+      Commands.toggleBold(nullthrows(nativeRef.current));
+    },
+    toggleItalic: () => {
+      Commands.toggleItalic(nullthrows(nativeRef.current));
+    },
+    toggleUnderline: () => {
+      Commands.toggleUnderline(nullthrows(nativeRef.current));
+    },
+    toggleStrikeThrough: () => {
+      Commands.toggleStrikeThrough(nullthrows(nativeRef.current));
+    },
+    toggleInlineCode: () => {
+      Commands.toggleInlineCode(nullthrows(nativeRef.current));
+    },
+    toggleH1: () => {
+      Commands.toggleH1(nullthrows(nativeRef.current));
+    },
+    toggleH2: () => {
+      Commands.toggleH2(nullthrows(nativeRef.current));
+    },
+    toggleH3: () => {
+      Commands.toggleH3(nullthrows(nativeRef.current));
+    },
+    toggleH4: () => {
+      Commands.toggleH4(nullthrows(nativeRef.current));
+    },
+    toggleH5: () => {
+      Commands.toggleH5(nullthrows(nativeRef.current));
+    },
+    toggleH6: () => {
+      Commands.toggleH6(nullthrows(nativeRef.current));
+    },
+    toggleCodeBlock: () => {
+      Commands.toggleCodeBlock(nullthrows(nativeRef.current));
+    },
+    toggleBlockQuote: () => {
+      Commands.toggleBlockQuote(nullthrows(nativeRef.current));
+    },
+    toggleOrderedList: () => {
+      Commands.toggleOrderedList(nullthrows(nativeRef.current));
+    },
+    toggleUnorderedList: () => {
+      Commands.toggleUnorderedList(nullthrows(nativeRef.current));
+    },
+    toggleCheckboxList: checked => {
+      Commands.toggleCheckboxList(nullthrows(nativeRef.current), checked);
+    },
+    setLink: (start, end, text, url) => {
+      Commands.addLink(nullthrows(nativeRef.current), start, end, text, url);
+    },
+    removeLink: (start, end) => {
+      Commands.removeLink(nullthrows(nativeRef.current), start, end);
+    },
+    setImage: (uri, width, height) => {
+      Commands.addImage(nullthrows(nativeRef.current), uri, width, height);
+    },
+    setMention: (indicator, text, attributes) => {
+      // Codegen does not support objects as Commands parameters, so we stringify attributes
+      const parsedAttributes = JSON.stringify(attributes ?? {});
+      Commands.addMention(nullthrows(nativeRef.current), indicator, text, parsedAttributes);
+    },
+    startMention: indicator => {
+      if (!mentionIndicators?.includes(indicator)) {
+        warnMentionIndicators(indicator);
+      }
+      Commands.startMention(nullthrows(nativeRef.current), indicator);
+    },
+    setSelection: (start, end) => {
+      Commands.setSelection(nullthrows(nativeRef.current), start, end);
+    }
+  }));
+  const handleMentionEvent = e => {
+    const mentionText = e.nativeEvent.text;
+    const mentionIndicator = e.nativeEvent.indicator;
+    if (typeof mentionText === 'string') {
+      if (mentionText === '') {
+        onStartMention?.(mentionIndicator);
+      } else {
+        onChangeMention?.({
+          indicator: mentionIndicator,
+          text: mentionText
+        });
+      }
+    } else if (mentionText === null) {
+      onEndMention?.(mentionIndicator);
+    }
+  };
+  const handleLinkDetected = e => {
+    const {
+      text,
+      url,
+      start,
+      end
+    } = e.nativeEvent;
+    onLinkDetected?.({
+      text,
+      url,
+      start,
+      end
+    });
+  };
+  const handleMentionDetected = e => {
+    const {
+      text,
+      indicator,
+      payload
+    } = e.nativeEvent;
+    const attributes = JSON.parse(payload);
+    onMentionDetected?.({
+      text,
+      indicator,
+      attributes
+    });
+  };
+  const handleRequestHtmlResult = e => {
+    const {
+      requestId,
+      html
+    } = e.nativeEvent;
+    const pending = pendingHtmlRequests.current.get(requestId);
+    if (!pending) return;
+    if (html === null || typeof html !== 'string') {
+      pending.reject(new Error('Failed to parse HTML'));
+    } else {
+      pending.resolve(html);
+    }
+    pendingHtmlRequests.current.delete(requestId);
+  };
+  return /*#__PURE__*/_jsx(EnrichedTextInputNativeComponent, {
+    ref: nativeRef,
+    mentionIndicators: mentionIndicators,
+    editable: editable,
+    autoFocus: autoFocus,
+    defaultValue: defaultValue,
+    placeholder: placeholder,
+    placeholderTextColor: placeholderTextColor,
+    cursorColor: cursorColor,
+    selectionColor: selectionColor,
+    style: style,
+    autoCapitalize: autoCapitalize,
+    htmlStyle: normalizedHtmlStyle,
+    linkRegex: linkRegex,
+    onInputFocus: onFocus,
+    onInputBlur: onBlur,
+    onChangeText: onChangeText,
+    onChangeHtml: onChangeHtml,
+    isOnChangeHtmlSet: onChangeHtml !== undefined,
+    isOnChangeTextSet: onChangeText !== undefined,
+    onChangeState: onChangeState,
+    onLinkDetected: handleLinkDetected,
+    onMentionDetected: handleMentionDetected,
+    onMention: handleMentionEvent,
+    onChangeSelection: onChangeSelection,
+    onRequestHtmlResult: handleRequestHtmlResult,
+    onInputKeyPress: onKeyPress,
+    contextMenuItems: nativeContextMenuItems,
+    onContextMenuItemPress: handleContextMenuItemPress,
+    onSubmitEditing: onSubmitEditing,
+    returnKeyType: returnKeyType,
+    returnKeyLabel: returnKeyLabel,
+    submitBehavior: submitBehavior,
+    androidExperimentalSynchronousEvents: androidExperimentalSynchronousEvents,
+    useHtmlNormalizer: useHtmlNormalizer,
+    scrollEnabled: scrollEnabled,
+    ...rest
+  });
+};
+//# sourceMappingURL=EnrichedTextInput.js.map