react-native-enriched 0.2.0 → 0.3.0

package/android/generated/jni/react/renderer/components/RNEnrichedTextInputViewSpec/EventEmitters.h

@@ -33,7 +33,136 @@ class EnrichedTextInputViewEventEmitter : public ViewEventEmitter {
       std::string value;
     };
 
+  struct OnChangeStateBold {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateItalic {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateUnderline {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateStrikeThrough {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateInlineCode {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateH1 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateH2 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateH3 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateH4 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateH5 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateH6 {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateCodeBlock {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateBlockQuote {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateOrderedList {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateUnorderedList {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateLink {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateImage {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
+  struct OnChangeStateMention {
+      bool isActive;
+    bool isConflicting;
+    bool isBlocking;
+    };
+
   struct OnChangeState {
+      OnChangeStateBold bold;
+    OnChangeStateItalic italic;
+    OnChangeStateUnderline underline;
+    OnChangeStateStrikeThrough strikeThrough;
+    OnChangeStateInlineCode inlineCode;
+    OnChangeStateH1 h1;
+    OnChangeStateH2 h2;
+    OnChangeStateH3 h3;
+    OnChangeStateH4 h4;
+    OnChangeStateH5 h5;
+    OnChangeStateH6 h6;
+    OnChangeStateCodeBlock codeBlock;
+    OnChangeStateBlockQuote blockQuote;
+    OnChangeStateOrderedList orderedList;
+    OnChangeStateUnorderedList unorderedList;
+    OnChangeStateLink link;
+    OnChangeStateImage image;
+    OnChangeStateMention mention;
+    };
+
+  struct OnChangeStateDeprecated {
       bool isBold;
     bool isItalic;
     bool isUnderline;
@@ -42,6 +171,9 @@ class EnrichedTextInputViewEventEmitter : public ViewEventEmitter {
     bool isH1;
     bool isH2;
     bool isH3;
+    bool isH4;
+    bool isH5;
+    bool isH6;
     bool isCodeBlock;
     bool isBlockQuote;
     bool isOrderedList;
@@ -74,6 +206,15 @@ class EnrichedTextInputViewEventEmitter : public ViewEventEmitter {
     int end;
     std::string text;
     };
+
+  struct OnRequestHtmlResult {
+      int requestId;
+    folly::dynamic html;
+    };
+
+  struct OnInputKeyPress {
+      std::string key;
+    };
   void onInputFocus(OnInputFocus value) const;
 
   void onInputBlur(OnInputBlur value) const;
@@ -84,6 +225,8 @@ class EnrichedTextInputViewEventEmitter : public ViewEventEmitter {
 
   void onChangeState(OnChangeState value) const;
 
+  void onChangeStateDeprecated(OnChangeStateDeprecated value) const;
+
   void onLinkDetected(OnLinkDetected value) const;
 
   void onMentionDetected(OnMentionDetected value) const;
@@ -91,5 +234,9 @@ class EnrichedTextInputViewEventEmitter : public ViewEventEmitter {
   void onMention(OnMention value) const;
 
   void onChangeSelection(OnChangeSelection value) const;
+
+  void onRequestHtmlResult(OnRequestHtmlResult value) const;
+
+  void onInputKeyPress(OnInputKeyPress value) const;
 };
 } // namespace facebook::react

package/android/generated/jni/react/renderer/components/RNEnrichedTextInputViewSpec/Props.cpp

@@ -31,12 +31,14 @@ EnrichedTextInputViewProps::EnrichedTextInputViewProps(
     autoCapitalize(convertRawProp(context, rawProps, "autoCapitalize", sourceProps.autoCapitalize, {})),
     htmlStyle(convertRawProp(context, rawProps, "htmlStyle", sourceProps.htmlStyle, {})),
     scrollEnabled(convertRawProp(context, rawProps, "scrollEnabled", sourceProps.scrollEnabled, {false})),
+    linkRegex(convertRawProp(context, rawProps, "linkRegex", sourceProps.linkRegex, {})),
     color(convertRawProp(context, rawProps, "color", sourceProps.color, {})),
     fontSize(convertRawProp(context, rawProps, "fontSize", sourceProps.fontSize, {0.0})),
     fontFamily(convertRawProp(context, rawProps, "fontFamily", sourceProps.fontFamily, {})),
     fontWeight(convertRawProp(context, rawProps, "fontWeight", sourceProps.fontWeight, {})),
     fontStyle(convertRawProp(context, rawProps, "fontStyle", sourceProps.fontStyle, {})),
     isOnChangeHtmlSet(convertRawProp(context, rawProps, "isOnChangeHtmlSet", sourceProps.isOnChangeHtmlSet, {false})),
+    isOnChangeTextSet(convertRawProp(context, rawProps, "isOnChangeTextSet", sourceProps.isOnChangeTextSet, {false})),
     androidExperimentalSynchronousEvents(convertRawProp(context, rawProps, "androidExperimentalSynchronousEvents", sourceProps.androidExperimentalSynchronousEvents, {false})) {}
     
 #ifdef RN_SERIALIZABLE_STATE
@@ -99,6 +101,10 @@ folly::dynamic EnrichedTextInputViewProps::getDiffProps(
     result["scrollEnabled"] = scrollEnabled;
   }
     
+  if (linkRegex != oldProps->linkRegex) {
+    result["linkRegex"] = toDynamic(linkRegex);
+  }
+    
   if (color != oldProps->color) {
     result["color"] = *color;
   }
@@ -123,6 +129,10 @@ folly::dynamic EnrichedTextInputViewProps::getDiffProps(
     result["isOnChangeHtmlSet"] = isOnChangeHtmlSet;
   }
     
+  if (isOnChangeTextSet != oldProps->isOnChangeTextSet) {
+    result["isOnChangeTextSet"] = isOnChangeTextSet;
+  }
+    
   if (androidExperimentalSynchronousEvents != oldProps->androidExperimentalSynchronousEvents) {
     result["androidExperimentalSynchronousEvents"] = androidExperimentalSynchronousEvents;
   }

package/android/generated/jni/react/renderer/components/RNEnrichedTextInputViewSpec/Props.h

@@ -135,6 +135,123 @@ static inline folly::dynamic toDynamic(const EnrichedTextInputViewHtmlStyleH3Str
 }
 #endif
 
+struct EnrichedTextInputViewHtmlStyleH4Struct {
+  Float fontSize{0.0};
+  bool bold{false};
+
+#ifdef RN_SERIALIZABLE_STATE
+  bool operator==(const EnrichedTextInputViewHtmlStyleH4Struct&) const = default;
+
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    result["fontSize"] = fontSize;
+    result["bold"] = bold;
+    return result;
+  }
+#endif
+};
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, EnrichedTextInputViewHtmlStyleH4Struct &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  auto tmp_fontSize = map.find("fontSize");
+  if (tmp_fontSize != map.end()) {
+    fromRawValue(context, tmp_fontSize->second, result.fontSize);
+  }
+  auto tmp_bold = map.find("bold");
+  if (tmp_bold != map.end()) {
+    fromRawValue(context, tmp_bold->second, result.bold);
+  }
+}
+
+static inline std::string toString(const EnrichedTextInputViewHtmlStyleH4Struct &value) {
+  return "[Object EnrichedTextInputViewHtmlStyleH4Struct]";
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const EnrichedTextInputViewHtmlStyleH4Struct &value) {
+  return value.toDynamic();
+}
+#endif
+
+struct EnrichedTextInputViewHtmlStyleH5Struct {
+  Float fontSize{0.0};
+  bool bold{false};
+
+#ifdef RN_SERIALIZABLE_STATE
+  bool operator==(const EnrichedTextInputViewHtmlStyleH5Struct&) const = default;
+
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    result["fontSize"] = fontSize;
+    result["bold"] = bold;
+    return result;
+  }
+#endif
+};
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, EnrichedTextInputViewHtmlStyleH5Struct &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  auto tmp_fontSize = map.find("fontSize");
+  if (tmp_fontSize != map.end()) {
+    fromRawValue(context, tmp_fontSize->second, result.fontSize);
+  }
+  auto tmp_bold = map.find("bold");
+  if (tmp_bold != map.end()) {
+    fromRawValue(context, tmp_bold->second, result.bold);
+  }
+}
+
+static inline std::string toString(const EnrichedTextInputViewHtmlStyleH5Struct &value) {
+  return "[Object EnrichedTextInputViewHtmlStyleH5Struct]";
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const EnrichedTextInputViewHtmlStyleH5Struct &value) {
+  return value.toDynamic();
+}
+#endif
+
+struct EnrichedTextInputViewHtmlStyleH6Struct {
+  Float fontSize{0.0};
+  bool bold{false};
+
+#ifdef RN_SERIALIZABLE_STATE
+  bool operator==(const EnrichedTextInputViewHtmlStyleH6Struct&) const = default;
+
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    result["fontSize"] = fontSize;
+    result["bold"] = bold;
+    return result;
+  }
+#endif
+};
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, EnrichedTextInputViewHtmlStyleH6Struct &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  auto tmp_fontSize = map.find("fontSize");
+  if (tmp_fontSize != map.end()) {
+    fromRawValue(context, tmp_fontSize->second, result.fontSize);
+  }
+  auto tmp_bold = map.find("bold");
+  if (tmp_bold != map.end()) {
+    fromRawValue(context, tmp_bold->second, result.bold);
+  }
+}
+
+static inline std::string toString(const EnrichedTextInputViewHtmlStyleH6Struct &value) {
+  return "[Object EnrichedTextInputViewHtmlStyleH6Struct]";
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const EnrichedTextInputViewHtmlStyleH6Struct &value) {
+  return value.toDynamic();
+}
+#endif
+
 struct EnrichedTextInputViewHtmlStyleBlockquoteStruct {
   SharedColor borderColor{};
   Float borderWidth{0.0};
@@ -415,6 +532,9 @@ struct EnrichedTextInputViewHtmlStyleStruct {
   EnrichedTextInputViewHtmlStyleH1Struct h1{};
   EnrichedTextInputViewHtmlStyleH2Struct h2{};
   EnrichedTextInputViewHtmlStyleH3Struct h3{};
+  EnrichedTextInputViewHtmlStyleH4Struct h4{};
+  EnrichedTextInputViewHtmlStyleH5Struct h5{};
+  EnrichedTextInputViewHtmlStyleH6Struct h6{};
   EnrichedTextInputViewHtmlStyleBlockquoteStruct blockquote{};
   EnrichedTextInputViewHtmlStyleCodeblockStruct codeblock{};
   EnrichedTextInputViewHtmlStyleCodeStruct code{};
@@ -431,6 +551,9 @@ struct EnrichedTextInputViewHtmlStyleStruct {
     result["h1"] = ::facebook::react::toDynamic(h1);
     result["h2"] = ::facebook::react::toDynamic(h2);
     result["h3"] = ::facebook::react::toDynamic(h3);
+    result["h4"] = ::facebook::react::toDynamic(h4);
+    result["h5"] = ::facebook::react::toDynamic(h5);
+    result["h6"] = ::facebook::react::toDynamic(h6);
     result["blockquote"] = ::facebook::react::toDynamic(blockquote);
     result["codeblock"] = ::facebook::react::toDynamic(codeblock);
     result["code"] = ::facebook::react::toDynamic(code);
@@ -458,6 +581,18 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_h3 != map.end()) {
     fromRawValue(context, tmp_h3->second, result.h3);
   }
+  auto tmp_h4 = map.find("h4");
+  if (tmp_h4 != map.end()) {
+    fromRawValue(context, tmp_h4->second, result.h4);
+  }
+  auto tmp_h5 = map.find("h5");
+  if (tmp_h5 != map.end()) {
+    fromRawValue(context, tmp_h5->second, result.h5);
+  }
+  auto tmp_h6 = map.find("h6");
+  if (tmp_h6 != map.end()) {
+    fromRawValue(context, tmp_h6->second, result.h6);
+  }
   auto tmp_blockquote = map.find("blockquote");
   if (tmp_blockquote != map.end()) {
     fromRawValue(context, tmp_blockquote->second, result.blockquote);
@@ -497,6 +632,63 @@ static inline folly::dynamic toDynamic(const EnrichedTextInputViewHtmlStyleStruc
   return value.toDynamic();
 }
 #endif
+
+struct EnrichedTextInputViewLinkRegexStruct {
+  std::string pattern{};
+  bool caseInsensitive{false};
+  bool dotAll{false};
+  bool isDisabled{false};
+  bool isDefault{false};
+
+#ifdef RN_SERIALIZABLE_STATE
+  bool operator==(const EnrichedTextInputViewLinkRegexStruct&) const = default;
+
+  folly::dynamic toDynamic() const {
+    folly::dynamic result = folly::dynamic::object();
+    result["pattern"] = pattern;
+    result["caseInsensitive"] = caseInsensitive;
+    result["dotAll"] = dotAll;
+    result["isDisabled"] = isDisabled;
+    result["isDefault"] = isDefault;
+    return result;
+  }
+#endif
+};
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, EnrichedTextInputViewLinkRegexStruct &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  auto tmp_pattern = map.find("pattern");
+  if (tmp_pattern != map.end()) {
+    fromRawValue(context, tmp_pattern->second, result.pattern);
+  }
+  auto tmp_caseInsensitive = map.find("caseInsensitive");
+  if (tmp_caseInsensitive != map.end()) {
+    fromRawValue(context, tmp_caseInsensitive->second, result.caseInsensitive);
+  }
+  auto tmp_dotAll = map.find("dotAll");
+  if (tmp_dotAll != map.end()) {
+    fromRawValue(context, tmp_dotAll->second, result.dotAll);
+  }
+  auto tmp_isDisabled = map.find("isDisabled");
+  if (tmp_isDisabled != map.end()) {
+    fromRawValue(context, tmp_isDisabled->second, result.isDisabled);
+  }
+  auto tmp_isDefault = map.find("isDefault");
+  if (tmp_isDefault != map.end()) {
+    fromRawValue(context, tmp_isDefault->second, result.isDefault);
+  }
+}
+
+static inline std::string toString(const EnrichedTextInputViewLinkRegexStruct &value) {
+  return "[Object EnrichedTextInputViewLinkRegexStruct]";
+}
+
+#ifdef RN_SERIALIZABLE_STATE
+static inline folly::dynamic toDynamic(const EnrichedTextInputViewLinkRegexStruct &value) {
+  return value.toDynamic();
+}
+#endif
 class EnrichedTextInputViewProps final : public ViewProps {
  public:
   EnrichedTextInputViewProps() = default;
@@ -515,12 +707,14 @@ class EnrichedTextInputViewProps final : public ViewProps {
   std::string autoCapitalize{};
   EnrichedTextInputViewHtmlStyleStruct htmlStyle{};
   bool scrollEnabled{false};
+  EnrichedTextInputViewLinkRegexStruct linkRegex{};
   SharedColor color{};
   Float fontSize{0.0};
   std::string fontFamily{};
   std::string fontWeight{};
   std::string fontStyle{};
   bool isOnChangeHtmlSet{false};
+  bool isOnChangeTextSet{false};
   bool androidExperimentalSynchronousEvents{false};
 
   #ifdef RN_SERIALIZABLE_STATE

package/android/lint.gradle

@@ -0,0 +1,70 @@
+apply plugin: "org.jlleitschuh.gradle.ktlint"
+apply plugin: 'com.diffplug.spotless'
+
+ktlint {
+	version = "1.8.0"
+	verbose = true
+	outputToConsole = true
+	coloredOutput = true
+	android = true
+	enableExperimentalRules = true
+
+	reporters {
+		reporter "plain"
+		reporter "checkstyle"
+		reporter "html"
+	}
+
+	filter {
+		exclude("**/generated/**")
+		exclude("**/build/**")
+		exclude("**/node_modules/**")
+
+		include("src/**/*.kt")
+		include("src/**/*.kts")
+	}
+}
+
+spotless {
+	kotlin {
+		target 'src/**/*.kt', 'src/**/*.kts'
+		ktlint("1.8.0")
+		trimTrailingWhitespace()
+		endWithNewline()
+		lineEndings 'UNIX'
+		targetExclude '**/generated/**', '**/build/**', '**/node_modules/**'
+	}
+
+	java {
+		target 'src/**/*.java'
+		googleJavaFormat("1.23.0")
+		removeUnusedImports()
+		trimTrailingWhitespace()
+		endWithNewline()
+		leadingTabsToSpaces(2)
+		lineEndings 'UNIX'
+		targetExclude '**/generated/**', '**/build/**', '**/node_modules/**'
+	}
+
+	groovyGradle {
+		target '*.gradle', 'gradle/*.gradle'
+		greclipse()
+		trimTrailingWhitespace()
+		endWithNewline()
+	}
+}
+
+tasks.register('lintFormat') {
+	group = "formatting"
+	description = "Auto-fix all code formatting issues"
+	dependsOn 'ktlintFormat', 'spotlessApply'
+}
+
+tasks.register('lintVerify') {
+	group = "verification"
+	description = "Verify code is properly formatted"
+	dependsOn 'ktlintCheck', 'spotlessCheck'
+	doLast {
+		println "✓ All code formatting checks passed!"
+	}
+}

package/android/src/main/java/com/swmansion/enriched/EnrichedTextInputConnectionWrapper.kt

@@ -0,0 +1,140 @@
+package com.swmansion.enriched
+
+import android.view.KeyEvent
+import android.view.inputmethod.InputConnection
+import android.view.inputmethod.InputConnectionWrapper
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.events.OnInputKeyPressEvent
+
+// This class is based on the implementation from Facebook React Native to provide 'onKeyPress' API on android.
+// Original source:
+// https://github.com/facebook/react-native/blob/v0.83.1/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactEditTextInputConnectionWrapper.kt
+class EnrichedTextInputConnectionWrapper(
+  target: InputConnection,
+  private val reactContext: ReactContext,
+  private val editText: EnrichedTextInputView,
+  private val experimentalSynchronousEvents: Boolean,
+) : InputConnectionWrapper(target, false) {
+  private var isBatchEdit = false
+  private var key: String? = null
+
+  override fun beginBatchEdit(): Boolean {
+    isBatchEdit = true
+    return super.beginBatchEdit()
+  }
+
+  override fun endBatchEdit(): Boolean {
+    isBatchEdit = false
+    key?.let { k ->
+      dispatchKeyEvent(k)
+      key = null
+    }
+    return super.endBatchEdit()
+  }
+
+  override fun setComposingText(
+    text: CharSequence,
+    newCursorPosition: Int,
+  ): Boolean {
+    val previousSelectionStart = editText.selectionStart
+    val previousSelectionEnd = editText.selectionEnd
+
+    val consumed = super.setComposingText(text, newCursorPosition)
+
+    val currentSelectionStart = editText.selectionStart
+    val noPreviousSelection = previousSelectionStart == previousSelectionEnd
+    val cursorDidNotMove = currentSelectionStart == previousSelectionStart
+    val cursorMovedBackwardsOrAtBeginningOfInput =
+      currentSelectionStart < previousSelectionStart || currentSelectionStart <= 0
+
+    val inputKey =
+      if (
+        cursorMovedBackwardsOrAtBeginningOfInput || (!noPreviousSelection && cursorDidNotMove)
+      ) {
+        BACKSPACE_KEY_VALUE
+      } else {
+        editText.text?.get(currentSelectionStart - 1).toString()
+      }
+
+    dispatchKeyEventOrEnqueue(inputKey)
+    return consumed
+  }
+
+  override fun commitText(
+    text: CharSequence,
+    newCursorPosition: Int,
+  ): Boolean {
+    var inputKey = text.toString()
+    // Assume not a keyPress if length > 1 (or 2 if unicode)
+    if (inputKey.length <= 2) {
+      if (inputKey.isEmpty()) {
+        inputKey = BACKSPACE_KEY_VALUE
+      }
+      dispatchKeyEventOrEnqueue(inputKey)
+    }
+    return super.commitText(text, newCursorPosition)
+  }
+
+  override fun deleteSurroundingText(
+    beforeLength: Int,
+    afterLength: Int,
+  ): Boolean {
+    dispatchKeyEvent(BACKSPACE_KEY_VALUE)
+    return super.deleteSurroundingText(beforeLength, afterLength)
+  }
+
+  // Called by SwiftKey when cursor at beginning of input when there is a delete
+  // or when enter is pressed anywhere in the text. Whereas stock Android Keyboard calls
+  // [InputConnection.deleteSurroundingText] & [InputConnection.commitText]
+  // in each case, respectively.
+  override fun sendKeyEvent(event: KeyEvent): Boolean {
+    if (event.action == KeyEvent.ACTION_DOWN) {
+      val isNumberKey = event.unicodeChar in 48..57
+      when (event.keyCode) {
+        KeyEvent.KEYCODE_DEL -> {
+          dispatchKeyEvent(BACKSPACE_KEY_VALUE)
+        }
+
+        KeyEvent.KEYCODE_ENTER -> {
+          dispatchKeyEvent(ENTER_KEY_VALUE)
+        }
+
+        else -> {
+          if (isNumberKey) {
+            dispatchKeyEvent(event.number.toString())
+          }
+        }
+      }
+    }
+    return super.sendKeyEvent(event)
+  }
+
+  private fun dispatchKeyEventOrEnqueue(inputKey: String) {
+    if (isBatchEdit) {
+      key = inputKey
+    } else {
+      dispatchKeyEvent(inputKey)
+    }
+  }
+
+  private fun dispatchKeyEvent(inputKey: String) {
+    val resolvedKey = if (inputKey == NEWLINE_RAW_VALUE) ENTER_KEY_VALUE else inputKey
+    val surfaceId = UIManagerHelper.getSurfaceId(editText)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, editText.id)
+    eventDispatcher?.dispatchEvent(
+      OnInputKeyPressEvent(
+        surfaceId = surfaceId,
+        viewId = editText.id,
+        key = resolvedKey,
+        experimentalSynchronousEvents = experimentalSynchronousEvents,
+      ),
+    )
+  }
+
+  companion object {
+    const val NEWLINE_RAW_VALUE: String = "\n"
+    const val BACKSPACE_KEY_VALUE: String = "Backspace"
+    const val ENTER_KEY_VALUE: String = "Enter"
+  }
+}