react-native-enriched 0.1.6 → 0.2.1

package/android/src/main/java/com/swmansion/enriched/styles/ParagraphStyles.kt

@@ -3,13 +3,85 @@ package com.swmansion.enriched.styles
 import android.text.Editable
 import android.text.Spannable
 import android.text.SpannableStringBuilder
+import android.util.Log
 import com.swmansion.enriched.EnrichedTextInputView
 import com.swmansion.enriched.spans.EnrichedSpans
+import com.swmansion.enriched.spans.interfaces.EnrichedSpan
 import com.swmansion.enriched.utils.getParagraphBounds
 import com.swmansion.enriched.utils.getSafeSpanBoundaries
 
 class ParagraphStyles(private val view: EnrichedTextInputView) {
+  private fun <T>getPreviousParagraphSpan(spannable: Spannable, paragraphStart: Int, type: Class<T>): T? {
+    if (paragraphStart <= 0) return null
+
+    val (previousParagraphStart, previousParagraphEnd) = spannable.getParagraphBounds(paragraphStart - 1)
+    val spans = spannable.getSpans(previousParagraphStart, previousParagraphEnd, type)
+
+    // A paragraph implies a single cohesive style. having multiple spans of the
+    // same type (e.g., two codeblock spans) in one paragraph is an invalid state in current library logic
+    if (spans.size > 1) {
+      Log.w("ParagraphStyles", "getPreviousParagraphSpan(): Found more than one span in the paragraph!")
+    }
+
+    if (spans.isNotEmpty()) {
+      return spans.first()
+    }
+
+    return null
+  }
+
+  private fun <T>getNextParagraphSpan(spannable: Spannable, paragraphEnd: Int, type: Class<T>): T? {
+    if (paragraphEnd >= spannable.length - 1) return null
+
+    val (nextParagraphStart, nextParagraphEnd) = spannable.getParagraphBounds(paragraphEnd + 1)
+
+    val spans = spannable.getSpans(nextParagraphStart, nextParagraphEnd, type)
+
+    // A paragraph implies a single cohesive style. having multiple spans of the
+    // same type (e.g., two codeblock spans) in one paragraph is an invalid state in current library logic
+    if (spans.size > 1) {
+      Log.w("ParagraphStyles", "getNextParagraphSpan(): Found more than one span in the paragraph!")
+    }
+
+    if (spans.isNotEmpty()) {
+      return spans.first()
+    }
+
+    return null
+  }
+
+  /**
+   * Applies a continuous span to the specified range.
+   * If the new range touches existing continuous spans, they are coalesced into a single span
+   */
+  private fun <T>setContinuousSpan(spannable: Spannable, start: Int, end: Int, type: Class<T>) {
+    val span = type.getDeclaredConstructor(HtmlStyle::class.java).newInstance(view.htmlStyle)
+    val previousSpan = getPreviousParagraphSpan(spannable, start, type)
+    val nextSpan = getNextParagraphSpan(spannable, end, type)
+    var newStart = start
+    var newEnd = end
+
+    if (previousSpan != null) {
+      newStart = spannable.getSpanStart(previousSpan)
+      spannable.removeSpan(previousSpan)
+    }
+
+    if (nextSpan != null && start != end) {
+      newEnd = spannable.getSpanEnd(nextSpan)
+      spannable.removeSpan(nextSpan)
+    }
+
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(newStart, newEnd)
+    spannable.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+  }
+
+
   private fun <T>setSpan(spannable: Spannable, type: Class<T>, start: Int, end: Int) {
+    if (EnrichedSpans.isTypeContinuous(type)) {
+      setContinuousSpan(spannable, start, end, type)
+      return
+    }
+
     val span = type.getDeclaredConstructor(HtmlStyle::class.java).newInstance(view.htmlStyle)
     val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
     spannable.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
@@ -94,14 +166,116 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     return spans.isNotEmpty()
   }
 
+  private fun <T>mergeAdjacentStyleSpans(s: Editable, endCursorPosition: Int, type: Class<T>) {
+    val (start, end) = s.getParagraphBounds(endCursorPosition)
+    val currParagraphSpans = s.getSpans(start, end, type)
+
+    if (currParagraphSpans.isEmpty()) {
+      return
+    }
+
+    val currSpan = currParagraphSpans[0]
+    val nextSpan = getNextParagraphSpan(s, end, type)
+
+    if (nextSpan == null) {
+      return
+    }
+
+    val newStart = s.getSpanStart(currSpan)
+    val newEnd = s.getSpanEnd(nextSpan)
+
+    s.removeSpan(nextSpan)
+    s.removeSpan(currSpan)
+
+    val (safeStart, safeEnd) = s.getSafeSpanBoundaries(newStart, newEnd)
+    val span = type.getDeclaredConstructor(HtmlStyle::class.java).newInstance(view.htmlStyle)
+
+    s.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+  }
+
+  private fun handleConflictsDuringNewlineDeletion(s: Editable, style: String, paragraphStart: Int, paragraphEnd: Int): Boolean {
+    val spanState = view.spanState ?: return false
+    val mergingConfig = EnrichedSpans.getMergingConfigForStyle(style, view.htmlStyle) ?: return false
+    var isConflicting = false
+    val stylesToCheck = mergingConfig.blockingStyles + mergingConfig.conflictingStyles
+
+    for (styleToCheck in stylesToCheck) {
+      val conflictingType = EnrichedSpans.allSpans[styleToCheck]?.clazz ?: continue
+
+      val spans = s.getSpans(paragraphStart, paragraphEnd, conflictingType)
+      if (spans.isEmpty()) {
+        continue
+      }
+      isConflicting = true
+
+      val isParagraphStyle = EnrichedSpans.paragraphSpans[styleToCheck] != null
+      if (!isParagraphStyle) {
+        continue
+      }
+
+      for (span in spans) {
+        extendStyleOnWholeParagraph(s, span as EnrichedSpan, conflictingType, paragraphEnd)
+      }
+    }
+
+    if (isConflicting) {
+      val styleStart =  spanState.getStart(style) ?: return false
+      spanState.setStart(style, null)
+      removeStyle(style, styleStart, paragraphEnd)
+      return true
+    }
+
+    return false
+  }
+
+
+  private fun deleteConflictingAndBlockingStyles(s: Editable, style: String, paragraphStart: Int, paragraphEnd: Int) {
+    val mergingConfig = EnrichedSpans.getMergingConfigForStyle(style, view.htmlStyle) ?: return
+    val stylesToCheck = mergingConfig.blockingStyles + mergingConfig.conflictingStyles
+
+    for (styleToCheck in stylesToCheck) {
+      val conflictingType = EnrichedSpans.allSpans[styleToCheck]?.clazz ?: continue
+
+      val spans = s.getSpans(paragraphStart, paragraphEnd, conflictingType)
+      for (span in spans) {
+        s.removeSpan(span)
+      }
+    }
+  }
+
+  private fun <T>extendStyleOnWholeParagraph(s: Editable, span: EnrichedSpan, type: Class<T>, paragraphEnd: Int) {
+    val currStyleStart = s.getSpanStart(span)
+    s.removeSpan(span)
+    val (safeStart, safeEnd) = s.getSafeSpanBoundaries(currStyleStart, paragraphEnd)
+    setSpan(s, type, safeStart, safeEnd)
+  }
+
   fun afterTextChanged(s: Editable, endPosition: Int, previousTextLength: Int) {
     var endCursorPosition = endPosition
     val isBackspace = s.length < previousTextLength
     val isNewLine = endCursorPosition == 0 || endCursorPosition > 0 && s[endCursorPosition - 1] == '\n'
+    val spanState = view.spanState ?: return
 
     for ((style, config) in EnrichedSpans.paragraphSpans) {
-      val spanState = view.spanState ?: continue
-      val styleStart = spanState.getStart(style) ?: continue
+      val styleStart = spanState.getStart(style)
+
+      if (styleStart == null) {
+        if (isBackspace) {
+          val (start, end) = s.getParagraphBounds(endCursorPosition)
+          val spans = s.getSpans(start, end, config.clazz)
+
+          for (span in spans) {
+            // handle conflicts when entering paragraph with some paragraph style applied
+            deleteConflictingAndBlockingStyles(s, style, start, end)
+            extendStyleOnWholeParagraph(s, span as EnrichedSpan, config.clazz, end)
+          }
+        }
+
+        if (config.isContinuous) {
+          mergeAdjacentStyleSpans(s, endCursorPosition, config.clazz)
+        }
+        continue
+      }
 
       if (isNewLine) {
         if (!config.isContinuous) {
@@ -111,7 +285,7 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
 
         if (isBackspace) {
           endCursorPosition -= 1
-          view.spanState.setStart(style, null)
+          spanState.setStart(style, null)
         } else {
           s.insert(endCursorPosition, "\u200B")
           endCursorPosition += 1
@@ -119,6 +293,15 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
       }
 
       var (start, end) = s.getParagraphBounds(styleStart, endCursorPosition)
+
+      // handle conflicts when deleting newline from paragraph style (going back to previous line)
+      if (isBackspace && styleStart != start) {
+        val isConflicting = handleConflictsDuringNewlineDeletion(s, style, start, end)
+        if (isConflicting) {
+          continue
+        }
+      }
+
       val isNotEndLineSpan = isSpanEnabledInNextLine(s, end, config.clazz)
       val spans = s.getSpans(start, end, config.clazz)
 
@@ -154,8 +337,8 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
 
     if (start == end) {
       spannable.insert(start, "\u200B")
-      view.spanState?.setStart(name, start + 1)
       setAndMergeSpans(spannable, type, start, end + 1)
+      view.selection.validateStyles()
 
       return
     }
@@ -170,8 +353,8 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
       currentStart = currentEnd + 1
     }
 
-    view.spanState?.setStart(name, start)
     setAndMergeSpans(spannable, type, start, currentEnd)
+    view.selection.validateStyles()
   }
 
   fun getStyleRange(): Pair<Int, Int> {

package/android/src/main/java/com/swmansion/enriched/styles/ParametrizedStyles.kt

@@ -1,6 +1,5 @@
 package com.swmansion.enriched.styles
 
-import android.net.Uri
 import android.text.Editable
 import android.text.Spannable
 import android.text.SpannableStringBuilder
@@ -11,7 +10,6 @@ import com.swmansion.enriched.spans.EnrichedLinkSpan
 import com.swmansion.enriched.spans.EnrichedMentionSpan
 import com.swmansion.enriched.spans.EnrichedSpans
 import com.swmansion.enriched.utils.getSafeSpanBoundaries
-import java.io.File
 
 class ParametrizedStyles(private val view: EnrichedTextInputView) {
   private var mentionStart: Int? = null
@@ -85,7 +83,7 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     }
   }
 
-  private fun getWordAtIndex(s: Editable, index: Int): Triple<String, Int, Int>? {
+  private fun getWordAtIndex(s: CharSequence, index: Int): TextRange? {
     if (index < 0 ) return null
 
     var start = index
@@ -101,7 +99,7 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
 
     val result = s.subSequence(start, end).toString()
 
-    return Triple(result, start, end)
+    return TextRange(result, start, end)
   }
 
   private fun canLinkBeApplied(): Boolean {
@@ -120,7 +118,7 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     return true
   }
 
-  private fun afterTextChangedLinks(result: Triple<String, Int, Int>) {
+  private fun afterTextChangedLinks(result: TextRange) {
     // Do not detect link if it's applied manually
     if (isSettingLinkSpan || !canLinkBeApplied()) return
 
@@ -141,55 +139,80 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     }
   }
 
-  private fun afterTextChangedMentions(result: Triple<String, Int, Int>) {
+  private fun afterTextChangedMentions(currentWord: TextRange) {
     val mentionHandler = view.mentionHandler ?: return
     val spannable = view.text as Spannable
-    val (word, start, end) = result
 
     val indicatorsPattern = mentionIndicators.joinToString("|") { Regex.escape(it) }
     val mentionIndicatorRegex = Regex("^($indicatorsPattern)")
     val mentionRegex= Regex("^($indicatorsPattern)\\w*")
 
-    val spans = spannable.getSpans(start, end, EnrichedMentionSpan::class.java)
+    val spans = spannable.getSpans(currentWord.start, currentWord.end, EnrichedMentionSpan::class.java)
     for (span in spans) {
       spannable.removeSpan(span)
     }
 
-    if (mentionRegex.matches(word)) {
-      val indicator = mentionIndicatorRegex.find(word)?.value ?: ""
-      val text = word.replaceFirst(indicator, "")
+    var indicator: String
+    var finalStart: Int
+    val finalEnd = currentWord.end
+
+    // No mention in the current word, check previous one
+    if (!mentionRegex.matches(currentWord.text)) {
+      val previousWord = getWordAtIndex(spannable, currentWord.start - 1)
 
-      // Means we are starting mention
-      if (text.isEmpty()) {
-        mentionStart = start
+      // No previous word -> no mention to be detected
+      if (previousWord == null) {
+        mentionHandler.endMention()
+        return
       }
 
-      mentionHandler.onMention(indicator, text)
+      // Previous word is not a mention -> end mention
+      if (!mentionRegex.matches(previousWord.text)) {
+        mentionHandler.endMention()
+        return
+      }
+
+      // Previous word is a mention -> use it
+      finalStart = previousWord.start
+      indicator = mentionIndicatorRegex.find(previousWord.text)?.value ?: ""
     } else {
-      mentionHandler.endMention()
+      // Current word is a mention -> use it
+      finalStart = currentWord.start
+      indicator = mentionIndicatorRegex.find(currentWord.text)?.value ?: ""
+    }
+
+    // Extract text without indicator
+    val text = spannable.subSequence(finalStart, finalEnd).toString().replaceFirst(indicator, "")
+
+    // Means we are starting mention
+    if (text.isEmpty()) {
+      mentionStart = finalStart
     }
+
+    mentionHandler.onMention(indicator, text)
   }
 
-  fun setImageSpan(src: String) {
+  fun setImageSpan(src: String, width: Float, height: Float) {
     if (view.selection == null) return
-
     val spannable = view.text as SpannableStringBuilder
-    var (start, end) = view.selection.getInlineSelection()
-    val spans = spannable.getSpans(start, end, EnrichedImageSpan::class.java)
+    val (start, originalEnd) = view.selection.getInlineSelection()
 
-    for (s in spans) {
-      spannable.removeSpan(s)
-    }
-
-    if (start == end) {
+    if (start == originalEnd) {
       spannable.insert(start, "\uFFFC")
-      end++
+    } else {
+      val spans = spannable.getSpans(start, originalEnd, EnrichedImageSpan::class.java)
+      for (s in spans) {
+        spannable.removeSpan(s)
+      }
+
+      spannable.replace(start, originalEnd, "\uFFFC")
     }
 
-    val uri = Uri.fromFile(File(src))
-    val span = EnrichedImageSpan(view.context, uri, view.htmlStyle)
-    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
-    spannable.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    val (imageStart, imageEnd) = spannable.getSafeSpanBoundaries(start, start + 1)
+    val span = EnrichedImageSpan.createEnrichedImageSpan(src, width.toInt(), height.toInt())
+    span.observeAsyncDrawableLoaded(view.text)
+
+    spannable.setSpan(span, imageStart, imageEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
   }
 
   fun startMention(indicator: String) {
@@ -245,4 +268,8 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     val spannable = view.text as Spannable
     return removeSpansForRange(spannable, start, end, config.clazz)
   }
+
+  companion object {
+    data class TextRange(val text: String, val start: Int, val end: Int)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/utils/AsyncDrawable.kt

@@ -0,0 +1,91 @@
+package com.swmansion.enriched.utils
+
+import android.annotation.SuppressLint
+import android.content.res.Resources
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.PixelFormat
+import android.graphics.drawable.Drawable
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.core.content.res.ResourcesCompat
+import androidx.core.graphics.drawable.DrawableCompat
+import java.net.URL
+import java.util.concurrent.Executors
+import androidx.core.graphics.drawable.toDrawable
+import com.swmansion.enriched.R
+
+class AsyncDrawable (
+  private val url: String,
+) : Drawable() {
+  private var internalDrawable: Drawable = Color.TRANSPARENT.toDrawable()
+  private val mainHandler = Handler(Looper.getMainLooper())
+  private val executor = Executors.newSingleThreadExecutor()
+  var isLoaded = false
+
+  init {
+    internalDrawable.bounds = bounds
+
+    load()
+  }
+
+  private fun load() {
+    executor.execute {
+      try {
+        isLoaded = false
+        val inputStream = URL(url).openStream()
+        val bitmap = BitmapFactory.decodeStream(inputStream)
+
+        // Switch to Main Thread to update UI
+        mainHandler.post {
+          if (bitmap != null) {
+            val d = bitmap.toDrawable(Resources.getSystem())
+
+            d.bounds = bounds
+            internalDrawable = d
+          } else {
+            loadPlaceholderImage()
+          }
+        }
+      } catch (e: Exception) {
+        Log.e("AsyncDrawable", "Failed to load: $url", e)
+
+        loadPlaceholderImage()
+      } finally {
+        isLoaded = true
+        onLoaded?.invoke()
+      }
+    }
+  }
+
+  private fun loadPlaceholderImage() {
+    internalDrawable = ResourceManager.getDrawableResource(R.drawable.broken_image)
+  }
+
+  override fun draw(canvas: Canvas) {
+    internalDrawable.draw(canvas)
+  }
+
+  override fun setAlpha(alpha: Int) {
+    internalDrawable.alpha = alpha
+  }
+
+  override fun setColorFilter(colorFilter: ColorFilter?) {
+    internalDrawable.colorFilter = colorFilter
+  }
+
+  @Deprecated("Deprecated in Java")
+  override fun getOpacity(): Int {
+    return PixelFormat.TRANSLUCENT
+  }
+
+  override fun setBounds(left: Int, top: Int, right: Int, bottom: Int) {
+    super.setBounds(left, top, right, bottom)
+    internalDrawable.setBounds(left, top, right, bottom)
+  }
+
+  var onLoaded: (() -> Unit)? = null
+}

package/android/src/main/java/com/swmansion/enriched/utils/EnrichedParser.java

@@ -105,6 +105,14 @@ public class EnrichedParser {
     String normalizedBlockQuote = normalizedCodeBlock.replaceAll("</blockquote>\\n<br>", "</blockquote>");
     return "<html>\n" + normalizedBlockQuote + "</html>";
   }
+
+  public static String toHtmlWithDefault(CharSequence text) {
+    if (text instanceof Spanned) {
+      return toHtml((Spanned) text);
+    }
+    return "<html>\n<p></p>\n</html>";
+  }
+
   /**
    * Returns an HTML escaped representation of the given plain text.
    */
@@ -275,7 +283,16 @@ public class EnrichedParser {
         if (style[j] instanceof EnrichedImageSpan) {
           out.append("<img src=\"");
           out.append(((EnrichedImageSpan) style[j]).getSource());
-          out.append("\">");
+          out.append("\"");
+
+          out.append(" width=\"");
+          out.append(((EnrichedImageSpan) style[j]).getWidth());
+          out.append("\"");
+
+          out.append(" height=\"");
+          out.append(((EnrichedImageSpan) style[j]).getHeight());
+
+          out.append("\"/>");
           // Don't output the placeholder character underlying the image.
           i = next;
         }
@@ -412,7 +429,6 @@ class HtmlToSpannedConverter implements ContentHandler {
   }
 
   private void handleStartTag(String tag, Attributes attributes) {
-    isEmptyTag = false;
     if (tag.equalsIgnoreCase("br")) {
       // We don't need to handle this. TagSoup will ensure that there's a </br> for each <br>
       // so we can safely emit the linebreaks when we handle the close tag.
@@ -454,7 +470,7 @@ class HtmlToSpannedConverter implements ContentHandler {
     } else if (tag.equalsIgnoreCase("h3")) {
       startHeading(mSpannableStringBuilder, 3);
     } else if (tag.equalsIgnoreCase("img")) {
-      startImg(mSpannableStringBuilder, attributes, mImageGetter, mStyle);
+      startImg(mSpannableStringBuilder, attributes, mImageGetter);
     } else if (tag.equalsIgnoreCase("code")) {
       start(mSpannableStringBuilder, new Code());
     } else if (tag.equalsIgnoreCase("mention")) {
@@ -679,20 +695,15 @@ class HtmlToSpannedConverter implements ContentHandler {
     }
   }
 
-  private static void startImg(Editable text, Attributes attributes, EnrichedParser.ImageGetter img, HtmlStyle style) {
+  private static void startImg(Editable text, Attributes attributes, EnrichedParser.ImageGetter img) {
     String src = attributes.getValue("", "src");
-    Drawable d = null;
-    if (img != null) {
-      d = img.getDrawable(src);
-    }
-
-    if (d == null) {
-      return;
-    }
+    String width = attributes.getValue("", "width");
+    String height = attributes.getValue("", "height");
 
     int len = text.length();
+    EnrichedImageSpan span = EnrichedImageSpan.Companion.createEnrichedImageSpan(src, Integer.parseInt(width), Integer.parseInt(height));
     text.append("");
-    text.setSpan(new EnrichedImageSpan(d, src, style), len, text.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+    text.setSpan(span, len, text.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   private static void startA(Editable text, Attributes attributes) {

package/android/src/main/java/com/swmansion/enriched/utils/ResourceManager.kt

@@ -0,0 +1,26 @@
+package com.swmansion.enriched.utils
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.Resources
+import android.graphics.drawable.Drawable
+import androidx.core.content.res.ResourcesCompat
+import androidx.core.graphics.drawable.DrawableCompat
+
+object ResourceManager {
+  private var appContext: Context? = null
+
+  fun init(context: Context) {
+    this.appContext = context.applicationContext
+  }
+
+  @SuppressLint("UseCompatLoadingForDrawables")
+  fun getDrawableResource(id: Int): Drawable {
+    val context = appContext ?: throw IllegalStateException("ResourceManager not initialized! Call init() first.")
+
+    val image = ResourcesCompat.getDrawable(context.resources, id, null)
+    val finalImage = image ?: Resources.getSystem().getDrawable(android.R.drawable.ic_menu_report_image)
+
+    return DrawableCompat.wrap(finalImage)
+  }
+}

package/android/src/main/java/com/swmansion/enriched/watchers/EnrichedSpanWatcher.kt

@@ -52,6 +52,9 @@ class EnrichedSpanWatcher(private val view: EnrichedTextInputView) : SpanWatcher
   }
 
   fun emitEvent(s: Spannable, what: Any?) {
+    // Do not parse spannable and emit event if onChangeHtml is not provided
+    if (!view.shouldEmitHtml) return
+
     // Emit event only if we change one of ours spans
     if (what != null && what !is EnrichedSpan) return
 

package/android/src/main/new_arch/RNEnrichedTextInputViewSpec.cpp

@@ -1,9 +1,10 @@
 
 /**
- * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ * This code was generated by
+ * [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
  *
- * Do not edit this file as changes may cause incorrect behavior and will be lost
- * once the code is regenerated.
+ * Do not edit this file as changes may cause incorrect behavior and will be
+ * lost once the code is regenerated.
  *
  * @generated by codegen project: GenerateModuleJniCpp.js
  */
@@ -12,9 +13,8 @@
 
 namespace facebook::react {
 
-
-
-std::shared_ptr<TurboModule> RNEnrichedTextInputViewSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+std::shared_ptr<TurboModule> RNEnrichedTextInputViewSpec_ModuleProvider(
+    const std::string &moduleName, const JavaTurboModule::InitParams &params) {
 
   return nullptr;
 }

package/android/src/main/new_arch/RNEnrichedTextInputViewSpec.h

@@ -1,9 +1,10 @@
 
 /**
- * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ * This code was generated by
+ * [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
  *
- * Do not edit this file as changes may cause incorrect behavior and will be lost
- * once the code is regenerated.
+ * Do not edit this file as changes may cause incorrect behavior and will be
+ * lost once the code is regenerated.
  *
  * @generated by codegen project: GenerateModuleJniH.js
  */
@@ -18,9 +19,8 @@
 
 namespace facebook::react {
 
-
-
 JSI_EXPORT
-std::shared_ptr<TurboModule> RNEnrichedTextInputViewSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params);
+std::shared_ptr<TurboModule> RNEnrichedTextInputViewSpec_ModuleProvider(
+    const std::string &moduleName, const JavaTurboModule::InitParams &params);
 
 } // namespace facebook::react