@expensify/react-native-live-markdown 0.1.45 → 0.1.47

package/RNLiveMarkdown.podspec

@@ -14,7 +14,7 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => "11.0" }
   s.source       = { :git => "https://github.com/expensify/react-native-live-markdown.git", :tag => "#{s.version}" }
 
-  s.source_files = "ios/**/*.{h,m,mm,cpp}"
+  s.source_files = "ios/**/*.{h,m,mm}"
 
   s.resources = "parser/react-native-live-markdown-parser.js"
 
@@ -26,4 +26,10 @@ Pod::Spec.new do |s|
       "react/renderer/components/textinput/iostextinput",
     ])
   end
+
+  s.subspec "common" do |ss|
+    ss.source_files         = "cpp/**/*.{cpp,h}"
+    ss.header_dir           = "RNLiveMarkdown"
+    ss.pod_target_xcconfig  = { "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/cpp\"" }
+  end
 end

package/android/build.gradle

@@ -9,6 +9,11 @@ buildscript {
   }
 }
 
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
 def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
@@ -53,9 +58,13 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    
+    consumerProguardFiles "proguard-rules.pro"
+    
     externalNativeBuild {
       cmake {
         arguments "-DANDROID_STL=c++_shared", "-DANDROID_TOOLCHAIN=clang"
+        abiFilters (*reactNativeArchitectures())
       }
     }
   }
@@ -112,6 +121,15 @@ android {
       "**/libreactnativejni.so",
     ]
   }
+
+  packagingOptions {
+    // For some reason gradle only complains about the duplicated version of librrc_root and libreact_render libraries
+    // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
+    // only the ones that make the build fail (ideally we should only include libreanimated but we
+    // are only allowed to specify exlude patterns)
+    exclude "**/libreact_render*.so"
+    exclude "**/librrc_root.so"
+  }
 }
 
 repositories {

package/android/proguard-rules.pro

@@ -0,0 +1 @@
+-keep class com.expensify.livemarkdown.** { *; }

package/android/src/main/java/com/expensify/livemarkdown/CustomFabricUIManager.java

@@ -0,0 +1,47 @@
+package com.expensify.livemarkdown;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.fabric.FabricUIManager;
+import com.facebook.react.fabric.mounting.MountingManager;
+import com.facebook.react.uimanager.ViewManagerRegistry;
+import com.facebook.react.uimanager.events.BatchEventDispatchedListener;
+
+import java.lang.reflect.Field;
+
+public class CustomFabricUIManager {
+
+  public static FabricUIManager create(FabricUIManager source, ReadableMap markdownProps) {
+    Class<? extends FabricUIManager> uiManagerClass = source.getClass();
+
+    try {
+      Field mountingManagerField = uiManagerClass.getDeclaredField("mMountingManager");
+      mountingManagerField.setAccessible(true);
+
+      ReactApplicationContext reactContext = readPrivateField(source, "mReactApplicationContext");
+      ViewManagerRegistry viewManagerRegistry = readPrivateField(source, "mViewManagerRegistry");
+      BatchEventDispatchedListener batchEventDispatchedListener = readPrivateField(source, "mBatchEventDispatchedListener");
+      MountingManager.MountItemExecutor mountItemExecutor = readPrivateField(source, "mMountItemExecutor");
+
+      FabricUIManager customFabricUIManager = new FabricUIManager(reactContext, viewManagerRegistry, batchEventDispatchedListener);
+
+      mountingManagerField.set(customFabricUIManager, new CustomMountingManager(viewManagerRegistry, mountItemExecutor, reactContext, markdownProps));
+
+      return customFabricUIManager;
+    } catch (NoSuchFieldException | IllegalAccessException e) {
+      throw new RuntimeException("[LiveMarkdown] Cannot read data from FabricUIManager");
+    }
+  }
+
+  private static <T> T readPrivateField(Object obj, String name) throws NoSuchFieldException, IllegalAccessException {
+    Class<?> clazz = obj.getClass();
+
+    Field field = clazz.getDeclaredField(name);
+    field.setAccessible(true);
+    T value = (T) field.get(obj);
+
+    return value;
+  }
+}

package/android/src/main/java/com/expensify/livemarkdown/CustomMountingManager.java

@@ -0,0 +1,248 @@
+package com.expensify.livemarkdown;
+
+import static com.facebook.react.views.text.TextAttributeProps.UNSET;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.text.BoringLayout;
+import android.text.Layout;
+import android.text.Spannable;
+import android.text.SpannableStringBuilder;
+import android.text.TextPaint;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.mapbuffer.MapBuffer;
+import com.facebook.react.fabric.mounting.MountingManager;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.ViewManagerRegistry;
+import com.facebook.react.views.text.TextAttributeProps;
+import com.facebook.react.views.text.TextInlineViewPlaceholderSpan;
+import com.facebook.react.views.text.TextLayoutManagerMapBuffer;
+import com.facebook.yoga.YogaMeasureMode;
+import com.facebook.yoga.YogaMeasureOutput;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class CustomMountingManager extends MountingManager {
+  private static final boolean DEFAULT_INCLUDE_FONT_PADDING = true;
+  private static final TextPaint sTextPaintInstance = new TextPaint(TextPaint.ANTI_ALIAS_FLAG);
+
+  private MarkdownUtils markdownUtils;
+
+  public CustomMountingManager(
+      @NonNull ViewManagerRegistry viewManagerRegistry,
+      @NonNull MountItemExecutor mountItemExecutor,
+      @NonNull Context context,
+      @NonNull ReadableMap decoratorProps) {
+    super(viewManagerRegistry, mountItemExecutor);
+
+    AssetManager assetManager = context.getAssets();
+    MarkdownUtils.maybeInitializeRuntime(assetManager);
+    
+    this.markdownUtils = new MarkdownUtils(assetManager);
+    this.markdownUtils.setMarkdownStyle(new MarkdownStyle(decoratorProps, context));
+  }
+
+  @Override
+  public long measureMapBuffer(
+      @NonNull ReactContext context,
+      @NonNull String componentName,
+      @NonNull MapBuffer attributedString,
+      @NonNull MapBuffer paragraphAttributes,
+      @Nullable MapBuffer state,
+      float width,
+      @NonNull YogaMeasureMode widthYogaMeasureMode,
+      float height,
+      @NonNull YogaMeasureMode heightYogaMeasureMode,
+      @Nullable float[] attachmentsPositions) {
+
+    Spannable text =
+      TextLayoutManagerMapBuffer.getOrCreateSpannableForText(context, attributedString, null);
+
+    if (text == null) {
+      return 0;
+    }
+
+    int textBreakStrategy =
+      TextAttributeProps.getTextBreakStrategy(
+        paragraphAttributes.getString(TextLayoutManagerMapBuffer.PA_KEY_TEXT_BREAK_STRATEGY));
+    boolean includeFontPadding =
+      paragraphAttributes.contains(TextLayoutManagerMapBuffer.PA_KEY_INCLUDE_FONT_PADDING)
+        ? paragraphAttributes.getBoolean(TextLayoutManagerMapBuffer.PA_KEY_INCLUDE_FONT_PADDING)
+        : DEFAULT_INCLUDE_FONT_PADDING;
+    int hyphenationFrequency =
+      TextAttributeProps.getHyphenationFrequency(
+        paragraphAttributes.getString(TextLayoutManagerMapBuffer.PA_KEY_HYPHENATION_FREQUENCY));
+
+    // StaticLayout returns wrong metrics for the last line if it's empty, add something to the
+    // last line so it's measured correctly
+    if (text.toString().endsWith("\n")) {
+      SpannableStringBuilder sb = new SpannableStringBuilder(text);
+      sb.append("I");
+
+      text = sb;
+    }
+
+    markdownUtils.applyMarkdownFormatting((SpannableStringBuilder)text);
+
+    BoringLayout.Metrics boring = BoringLayout.isBoring(text, sTextPaintInstance);
+
+    Class<TextLayoutManagerMapBuffer> mapBufferClass = TextLayoutManagerMapBuffer.class;
+    try {
+      Method createLayoutMethod = mapBufferClass.getDeclaredMethod("createLayout", Spannable.class, BoringLayout.Metrics.class, float.class, YogaMeasureMode.class, boolean.class, int.class, int.class);
+      createLayoutMethod.setAccessible(true);
+
+      Layout layout = (Layout)createLayoutMethod.invoke(
+        null,
+        text,
+        boring,
+        width,
+        widthYogaMeasureMode,
+        includeFontPadding,
+        textBreakStrategy,
+        hyphenationFrequency);
+
+      int maximumNumberOfLines =
+        paragraphAttributes.contains(TextLayoutManagerMapBuffer.PA_KEY_MAX_NUMBER_OF_LINES)
+          ? paragraphAttributes.getInt(TextLayoutManagerMapBuffer.PA_KEY_MAX_NUMBER_OF_LINES)
+          : UNSET;
+
+      int calculatedLineCount =
+        maximumNumberOfLines == UNSET || maximumNumberOfLines == 0
+          ? layout.getLineCount()
+          : Math.min(maximumNumberOfLines, layout.getLineCount());
+
+      // Instead of using `layout.getWidth()` (which may yield a significantly larger width for
+      // text that is wrapping), compute width using the longest line.
+      float calculatedWidth = 0;
+      if (widthYogaMeasureMode == YogaMeasureMode.EXACTLY) {
+        calculatedWidth = width;
+      } else {
+        for (int lineIndex = 0; lineIndex < calculatedLineCount; lineIndex++) {
+          boolean endsWithNewLine =
+            text.length() > 0 && text.charAt(layout.getLineEnd(lineIndex) - 1) == '\n';
+          float lineWidth =
+            endsWithNewLine ? layout.getLineMax(lineIndex) : layout.getLineWidth(lineIndex);
+          if (lineWidth > calculatedWidth) {
+            calculatedWidth = lineWidth;
+          }
+        }
+        if (widthYogaMeasureMode == YogaMeasureMode.AT_MOST && calculatedWidth > width) {
+          calculatedWidth = width;
+        }
+      }
+
+      // Android 11+ introduces changes in text width calculation which leads to cases
+      // where the container is measured smaller than text. Math.ceil prevents it
+      // See T136756103 for investigation
+      if (android.os.Build.VERSION.SDK_INT > android.os.Build.VERSION_CODES.Q) {
+        calculatedWidth = (float) Math.ceil(calculatedWidth);
+      }
+
+      float calculatedHeight = height;
+      if (heightYogaMeasureMode != YogaMeasureMode.EXACTLY) {
+        calculatedHeight = layout.getLineBottom(calculatedLineCount - 1);
+        if (heightYogaMeasureMode == YogaMeasureMode.AT_MOST && calculatedHeight > height) {
+          calculatedHeight = height;
+        }
+      }
+
+      // Calculate the positions of the attachments (views) that will be rendered inside the
+      // Spanned Text. The following logic is only executed when a text contains views inside.
+      // This follows a similar logic than used in pre-fabric (see ReactTextView.onLayout method).
+      int attachmentIndex = 0;
+      int lastAttachmentFoundInSpan;
+      for (int i = 0; i < text.length(); i = lastAttachmentFoundInSpan) {
+        lastAttachmentFoundInSpan =
+          text.nextSpanTransition(i, text.length(), TextInlineViewPlaceholderSpan.class);
+        TextInlineViewPlaceholderSpan[] placeholders =
+          text.getSpans(i, lastAttachmentFoundInSpan, TextInlineViewPlaceholderSpan.class);
+        for (TextInlineViewPlaceholderSpan placeholder : placeholders) {
+          int start = text.getSpanStart(placeholder);
+          int line = layout.getLineForOffset(start);
+          boolean isLineTruncated = layout.getEllipsisCount(line) > 0;
+          // This truncation check works well on recent versions of Android (tested on 5.1.1 and
+          // 6.0.1) but not on Android 4.4.4. The reason is that getEllipsisCount is buggy on
+          // Android 4.4.4. Specifically, it incorrectly returns 0 if an inline view is the
+          // first thing to be truncated.
+          if (!(isLineTruncated && start >= layout.getLineStart(line) + layout.getEllipsisStart(line))
+            || start >= layout.getLineEnd(line)) {
+            float placeholderWidth = placeholder.getWidth();
+            float placeholderHeight = placeholder.getHeight();
+            // Calculate if the direction of the placeholder character is Right-To-Left.
+            boolean isRtlChar = layout.isRtlCharAt(start);
+            boolean isRtlParagraph = layout.getParagraphDirection(line) == Layout.DIR_RIGHT_TO_LEFT;
+            float placeholderLeftPosition;
+            // There's a bug on Samsung devices where calling getPrimaryHorizontal on
+            // the last offset in the layout will result in an endless loop. Work around
+            // this bug by avoiding getPrimaryHorizontal in that case.
+            if (start == text.length() - 1) {
+              boolean endsWithNewLine =
+                text.length() > 0 && text.charAt(layout.getLineEnd(line) - 1) == '\n';
+              float lineWidth = endsWithNewLine ? layout.getLineMax(line) : layout.getLineWidth(line);
+              placeholderLeftPosition =
+                isRtlParagraph
+                  // Equivalent to `layout.getLineLeft(line)` but `getLineLeft` returns
+                  // incorrect
+                  // values when the paragraph is RTL and `setSingleLine(true)`.
+                  ? calculatedWidth - lineWidth
+                  : layout.getLineRight(line) - placeholderWidth;
+            } else {
+              // The direction of the paragraph may not be exactly the direction the string is
+              // heading
+              // in at the
+              // position of the placeholder. So, if the direction of the character is the same
+              // as the
+              // paragraph
+              // use primary, secondary otherwise.
+              boolean characterAndParagraphDirectionMatch = isRtlParagraph == isRtlChar;
+              placeholderLeftPosition =
+                characterAndParagraphDirectionMatch
+                  ? layout.getPrimaryHorizontal(start)
+                  : layout.getSecondaryHorizontal(start);
+              if (isRtlParagraph) {
+                // Adjust `placeholderLeftPosition` to work around an Android bug.
+                // The bug is when the paragraph is RTL and `setSingleLine(true)`, some layout
+                // methods such as `getPrimaryHorizontal`, `getSecondaryHorizontal`, and
+                // `getLineRight` return incorrect values. Their return values seem to be off
+                // by the same number of pixels so subtracting these values cancels out the
+                // error.
+                //
+                // The result is equivalent to bugless versions of
+                // `getPrimaryHorizontal`/`getSecondaryHorizontal`.
+                placeholderLeftPosition =
+                  calculatedWidth - (layout.getLineRight(line) - placeholderLeftPosition);
+              }
+              if (isRtlChar) {
+                placeholderLeftPosition -= placeholderWidth;
+              }
+            }
+            // Vertically align the inline view to the baseline of the line of text.
+            float placeholderTopPosition = layout.getLineBaseline(line) - placeholderHeight;
+            int attachmentPosition = attachmentIndex * 2;
+
+            // The attachment array returns the positions of each of the attachments as
+            attachmentsPositions[attachmentPosition] =
+              PixelUtil.toDIPFromPixel(placeholderTopPosition);
+            attachmentsPositions[attachmentPosition + 1] =
+              PixelUtil.toDIPFromPixel(placeholderLeftPosition);
+            attachmentIndex++;
+          }
+        }
+      }
+
+      float widthInSP = PixelUtil.toDIPFromPixel(calculatedWidth);
+      float heightInSP = PixelUtil.toDIPFromPixel(calculatedHeight);
+
+      return YogaMeasureOutput.make(widthInSP, heightInSP);
+    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}

package/android/src/main/java/com/expensify/livemarkdown/LiveMarkdownModule.java

@@ -0,0 +1,27 @@
+package com.expensify.livemarkdown;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.fabric.FabricUIManager;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.common.UIManagerType;
+
+public class LiveMarkdownModule extends NativeLiveMarkdownModuleSpec {
+  private NativeProxy mNativeProxy;
+  public LiveMarkdownModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+
+    this.mNativeProxy = new NativeProxy();
+  }
+
+  @Override
+  public boolean install() {
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      FabricUIManager uiManager =
+        (FabricUIManager) UIManagerHelper.getUIManager(getReactApplicationContext(), UIManagerType.FABRIC);
+      mNativeProxy.createCommitHook(uiManager);
+    }
+
+    return true;
+  }
+}

package/android/src/main/java/com/expensify/livemarkdown/LiveMarkdownPackage.java

@@ -1,15 +1,22 @@
 package com.expensify.livemarkdown;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.facebook.react.ReactPackage;
+import com.facebook.react.TurboReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.uimanager.ViewManager;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
-public class LiveMarkdownPackage implements ReactPackage {
+public class LiveMarkdownPackage extends TurboReactPackage {
   @Override
   public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
     List<ViewManager> viewManagers = new ArrayList<>();
@@ -18,7 +25,27 @@ public class LiveMarkdownPackage implements ReactPackage {
   }
 
   @Override
-  public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-    return Collections.emptyList();
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return new ReactModuleInfoProvider() {
+      @Override
+      public Map<String, ReactModuleInfo> getReactModuleInfos() {
+        return Map.of(LiveMarkdownModule.NAME, new ReactModuleInfo(
+          LiveMarkdownModule.NAME,
+          LiveMarkdownModule.class.getName(),
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          false, // isCxxModule
+          true // isTurboModule
+        ));
+      }
+    };
+  }
+  @Nullable
+  @Override
+  public NativeModule getModule(@NonNull String s, @NonNull ReactApplicationContext reactApplicationContext) {
+    if (s.equals(LiveMarkdownModule.NAME)) {
+      return new LiveMarkdownModule(reactApplicationContext);
+    }
+    return null;
   }
 }

package/android/src/main/java/com/expensify/livemarkdown/MarkdownFontFamilySpan.java

@@ -8,6 +8,7 @@ import android.text.style.MetricAffectingSpan;
 
 import androidx.annotation.NonNull;
 
+import com.facebook.react.common.assets.ReactFontManager.TypefaceStyle;
 import com.facebook.react.views.text.ReactFontManager;
 
 public class MarkdownFontFamilySpan extends MetricAffectingSpan implements MarkdownSpan {
@@ -31,7 +32,12 @@ public class MarkdownFontFamilySpan extends MetricAffectingSpan implements Markd
   }
 
   private void apply(@NonNull TextPaint textPaint) {
-    int style = textPaint.getTypeface().getStyle();
+    int style = TypefaceStyle.NORMAL;
+    if (textPaint.getTypeface() != null) {
+      style = textPaint.getTypeface().getStyle();
+    } else {
+      style = TypefaceStyle.NORMAL;
+    }
     Typeface typeface = ReactFontManager.getInstance().getTypeface(mFontFamily, style, mAssetManager);
     textPaint.setTypeface(typeface);
     textPaint.setFlags(textPaint.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);

package/android/src/main/java/com/expensify/livemarkdown/MarkdownFontSizeSpan.java

@@ -2,8 +2,10 @@ package com.expensify.livemarkdown;
 
 import android.text.style.AbsoluteSizeSpan;
 
+import com.facebook.react.uimanager.PixelUtil;
+
 public class MarkdownFontSizeSpan extends AbsoluteSizeSpan implements MarkdownSpan {
   public MarkdownFontSizeSpan(float fontSize) {
-    super((int) fontSize, true);
+    super((int) PixelUtil.toPixelFromDIP(fontSize), false);
   }
 }

package/android/src/main/java/com/expensify/livemarkdown/MarkdownUtils.java

@@ -29,9 +29,7 @@ public class MarkdownUtils {
 
   private static boolean IS_RUNTIME_INITIALIZED = false;
 
-  @ThreadConfined(UI)
-  public static void maybeInitializeRuntime(AssetManager assetManager) {
-    UiThreadUtil.assertOnUiThread();
+  public static synchronized void maybeInitializeRuntime(AssetManager assetManager) {
     if (IS_RUNTIME_INITIALIZED) {
       return;
     }
@@ -50,9 +48,7 @@ public class MarkdownUtils {
 
   private static native void nativeInitializeRuntime(String code);
 
-  @ThreadConfined(UI)
-  private static String parseMarkdown(String input) {
-    UiThreadUtil.assertOnUiThread();
+  private synchronized static String parseMarkdown(String input) {
     return nativeParseMarkdown(input);
   }
 

package/android/src/main/new_arch/CMakeLists.txt

@@ -0,0 +1,82 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+set(LIB_LITERAL RNLiveMarkdownSpec)
+set(LIB_TARGET_NAME react_codegen_${LIB_LITERAL})
+
+set(LIB_ANDROID_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
+set(LIB_CPP_DIR ${LIB_ANDROID_DIR}/../cpp)
+set(LIB_CUSTOM_SOURCES_DIR ${LIB_CPP_DIR}/react/renderer/components/${LIB_LITERAL})
+set(LIB_ANDROID_GENERATED_JNI_DIR ${LIB_ANDROID_DIR}/build/generated/source/codegen/jni)
+set(LIB_ANDROID_GENERATED_COMPONENTS_DIR ${LIB_ANDROID_GENERATED_JNI_DIR}/react/renderer/components/${LIB_LITERAL})
+
+file(GLOB LIB_MODULE_SRCS CONFIGURE_DEPENDS *.cpp)
+file(GLOB LIB_CUSTOM_SRCS CONFIGURE_DEPENDS ${LIB_CUSTOM_SOURCES_DIR}/*.cpp)
+file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp)
+
+set(RN_DIR ${LIB_ANDROID_DIR}/../example/node_modules/react-native)
+
+add_library(
+  ${LIB_TARGET_NAME}
+  SHARED 
+  ${LIB_MODULE_SRCS}
+  ${LIB_CUSTOM_SRCS}
+  ${LIB_CODEGEN_SRCS}
+)
+
+target_include_directories(
+  ${LIB_TARGET_NAME}
+  PUBLIC
+  .
+  ${LIB_ANDROID_GENERATED_JNI_DIR}
+  ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
+  ${LIB_CPP_DIR}
+)
+
+find_package(ReactAndroid REQUIRED CONFIG)
+
+target_link_libraries(
+  ${LIB_TARGET_NAME}
+  ReactAndroid::rrc_text
+  ReactAndroid::rrc_textinput
+  ReactAndroid::react_render_textlayoutmanager
+  ReactAndroid::react_render_imagemanager
+  fabricjni
+  fbjni
+  folly_runtime
+  glog
+  jsi
+  react_codegen_rncore
+  react_debug
+  react_nativemodule_core
+  react_render_core
+  react_render_debug
+  react_render_graphics
+  react_render_mapbuffer
+  ReactAndroid::react_render_uimanager
+  ReactAndroid::react_render_scheduler
+  react_utils
+  runtimeexecutor
+  rrc_view
+  turbomodulejsijni
+  yoga
+  android
+  log
+)
+
+target_compile_options(
+  ${LIB_TARGET_NAME}
+  PRIVATE
+  -DLOG_TAG=\"ReactNative\"
+  -fexceptions
+  -frtti
+  -Wall
+  -std=c++20
+)
+
+target_include_directories(
+ ${CMAKE_PROJECT_NAME}
+ PUBLIC
+ ${CMAKE_CURRENT_SOURCE_DIR}
+)

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

@@ -0,0 +1,173 @@
+#include <react/fabric/Binding.h>
+#include <react/jni/ReadableNativeMap.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/scheduler/Scheduler.h>
+
+#include "MarkdownCommitHook.h"
+#include "react/renderer/components/RNLiveMarkdownSpec/MarkdownShadowFamilyRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace livemarkdown {
+
+MarkdownCommitHook::MarkdownCommitHook(
+    jni::global_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager)
+    : fabricUIManager_(fabricUIManager),
+      uiManager_(
+          fabricUIManager->getBinding()->getScheduler()->getUIManager()) {
+  uiManager_->registerCommitHook(*this);
+}
+
+MarkdownCommitHook::~MarkdownCommitHook() noexcept {
+  uiManager_->unregisterCommitHook(*this);
+}
+
+RootShadowNode::Unshared MarkdownCommitHook::shadowTreeWillCommit(
+    ShadowTree const &, RootShadowNode::Shared const &,
+    RootShadowNode::Unshared const &newRootShadowNode) noexcept {
+  auto rootNode = newRootShadowNode->ShadowNode::clone(ShadowNodeFragment{});
+
+  // A preface to why we do the weird thing below:
+  // On the new architecture there are two ways of measuring text on Android: by
+  // passing a cache key, or by passing a measured text with attributes by a map
+  // buffer. We could implement both, but that would increase the complexity of
+  // the code and duplication between here and RN core, so we implement
+  // measurement for map buffers since it's the independent one, and force RN to
+  // use this path every time. It shouldn't have a negative performance impact,
+  // since there is a cpp cache layer anyway.
+  //
+  // AndroidTextInputShadowNode is closed pretty tightly, but there's a one
+  // place where we can insert ourselves (well, there are two but we really
+  // shouldn't mess with vtable). The path to measurement looks like this:
+  // AndroidTextInputShadowNode::measureContent ->
+  // TextLayoutManager::measureAndroidComponentMapBuffer
+  //  -> (jni) -> FabricUIManager::measureMapBuffer ->
+  //  MountingManager::measureMapBuffer
+  // We cannot modify the shadow node directly, but we can replace its
+  // TextLayoutManager. Literally every method it has is linked statically so we
+  // cannot override anything, but we can replace its ContextContainer where a
+  // jni reference to the FabricUIManager is stored. Now `measureMapBuffer` is
+  // private in the ui manager, but the only thing it does is calling
+  // `measureMapBuffer` on MountingManager where it's public. At this point the
+  // path forward is clear: we make a custom MountingManager that will perform
+  // our measurement, then create a custom FabricUIManager which will direct
+  // measurement to our MountingManager. Then we only need to create the
+  // ContextContainer with our FabricUIManager, create the TextLayoutManager
+  // with the newly created ContextContainer and replace the pointer to
+  // TextLayoutManager inside the AndroidTextInputShadowNode.
+
+  // In order to properly apply markdown formatting to the text input, we need
+  // to update the TextInputShadowNode's state to reset the cache key and update
+  // its TextLayoutManager reference, but we only have access to the
+  // ShadowNodeFamilies of the decorator components. We also know that a
+  // markdown decorator is always preceded with the TextInput to decorate, so we
+  // need to take the sibling.
+  std::vector<MarkdownTextInputDecoratorPair> nodesToUpdate;
+  MarkdownShadowFamilyRegistry::runForEveryFamily([&rootNode, &nodesToUpdate](
+                                                      ShadowNodeFamily::Shared
+                                                          family) {
+    // get the path from the root to the node from the decorator family
+    const auto ancestors = family->getAncestors(*rootNode);
+
+    if (!ancestors.empty()) {
+      auto &parentNode = ancestors.back().first.get();
+      auto index = ancestors.back().second;
+
+      // this is node represented by one of the registered families and since we
+      // only register markdown decorator shadow families, static casting should
+      // be safe here
+      const auto &decoratorNode =
+          std::static_pointer_cast<const MarkdownTextInputDecoratorShadowNode>(
+              parentNode.getChildren().at(index));
+      // text input always precedes the decorator component
+      const auto &previousSibling = parentNode.getChildren().at(index - 1);
+
+      if (const auto &textInputNode =
+              std::dynamic_pointer_cast<const AndroidTextInputShadowNode>(
+                  previousSibling)) {
+        // store the pair of text input and decorator to update in the next step
+        // we need both, decorator to get markdown style and text input to
+        // update it
+        nodesToUpdate.push_back({
+            textInputNode,
+            decoratorNode,
+        });
+      }
+    }
+  });
+
+  for (const auto &nodes : nodesToUpdate) {
+    const auto &textInputState =
+        *std::static_pointer_cast<const ConcreteState<AndroidTextInputState>>(
+            nodes.textInput->getState());
+    const auto &stateData = textInputState.getData();
+
+    rootNode = rootNode->cloneTree(
+        nodes.textInput->getFamily(),
+        [this, &stateData, &textInputState, &nodes](ShadowNode const &node) {
+          auto newStateData =
+              std::make_shared<AndroidTextInputState>(stateData);
+          // force measurement of a map buffer
+          newStateData->cachedAttributedStringId = 0;
+
+          // clone the text input with the new state
+          auto newNode = node.clone({
+              .state =
+                  std::make_shared<const ConcreteState<AndroidTextInputState>>(
+                      newStateData, textInputState),
+          });
+
+          const auto currentDecoratorProps =
+              nodes.decorator->getProps()->rawProps["markdownStyle"];
+
+          // if it's the first time we encounter this particular input or the
+          // markdown styles have changed (in which case we need to reset the
+          // cpp cache, to which we don't have a direct access), create a new
+          // instance of TextLayoutManager that will be performing measurement
+          // for this particular input
+          if (!textLayoutManagers_.contains(nodes.textInput->getTag()) ||
+              previousDecoratorProps_[nodes.textInput->getTag()] !=
+                  currentDecoratorProps) {
+            static auto customUIManagerClass = jni::findClassStatic(
+                "com/expensify/livemarkdown/CustomFabricUIManager");
+            static auto createCustomUIManager =
+                customUIManagerClass
+                    ->getStaticMethod<JFabricUIManager::javaobject(
+                        JFabricUIManager::javaobject, ReadableMap::javaobject)>(
+                        "create");
+
+            auto const decoratorPropsRNM =
+                ReadableNativeMap::newObjectCxxArgs(currentDecoratorProps);
+            auto const decoratorPropsRM =
+                jni::make_local(reinterpret_cast<ReadableMap::javaobject>(
+                    decoratorPropsRNM.get()));
+
+            const auto customUIManager = jni::make_global(createCustomUIManager(
+                customUIManagerClass, fabricUIManager_.get(),
+                decoratorPropsRM.get()));
+            const ContextContainer::Shared contextContainer =
+                std::make_shared<ContextContainer const>();
+            contextContainer->insert("FabricUIManager", customUIManager);
+            textLayoutManagers_[nodes.textInput->getTag()] =
+                std::make_shared<TextLayoutManager>(contextContainer);
+            previousDecoratorProps_[nodes.textInput->getTag()] =
+                currentDecoratorProps;
+          }
+
+          // we need to replace the TextLayoutManager every time to make sure
+          // the correct measurement code is run
+          auto newTextInputShadowNode =
+              std::static_pointer_cast<AndroidTextInputShadowNode>(newNode);
+          newTextInputShadowNode->setTextLayoutManager(
+              textLayoutManagers_[nodes.textInput->getTag()]);
+
+          return newNode;
+        });
+  }
+
+  return std::static_pointer_cast<RootShadowNode>(rootNode);
+}
+
+} // namespace livemarkdown

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

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/JFabricUIManager.h>
+
+#include <react/renderer/components/androidtextinput/AndroidTextInputShadowNode.h>
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+
+#include <memory>
+#include <unordered_map>
+
+#include "react/renderer/components/RNLiveMarkdownSpec/MarkdownTextInputDecoratorShadowNode.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace livemarkdown {
+
+struct MarkdownTextInputDecoratorPair {
+  const std::shared_ptr<const AndroidTextInputShadowNode> textInput;
+  const std::shared_ptr<const MarkdownTextInputDecoratorShadowNode> decorator;
+};
+
+class MarkdownCommitHook : public UIManagerCommitHook {
+public:
+  MarkdownCommitHook(
+      jni::global_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager);
+
+  ~MarkdownCommitHook() noexcept override;
+
+  void commitHookWasRegistered(UIManager const &) noexcept override {}
+
+  void commitHookWasUnregistered(UIManager const &) noexcept override {}
+
+  RootShadowNode::Unshared shadowTreeWillCommit(
+      ShadowTree const &shadowTree,
+      RootShadowNode::Shared const &oldRootShadowNode,
+      RootShadowNode::Unshared const &newRootShadowNode) noexcept override;
+
+private:
+  const jni::global_ref<facebook::react::JFabricUIManager::javaobject>
+      fabricUIManager_;
+  const std::shared_ptr<UIManager> uiManager_;
+  std::unordered_map<facebook::react::Tag, SharedTextLayoutManager>
+      textLayoutManagers_;
+  std::unordered_map<facebook::react::Tag, folly::dynamic>
+      previousDecoratorProps_;
+};
+
+} // namespace livemarkdown

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

@@ -0,0 +1,38 @@
+#include <fbjni/fbjni.h>
+#include <react/fabric/Binding.h>
+#include <react/renderer/scheduler/Scheduler.h>
+
+#include <string>
+
+#include "NativeProxy.h"
+
+namespace livemarkdown {
+
+using namespace facebook;
+using namespace react;
+
+NativeProxy::NativeProxy(jni::alias_ref<NativeProxy::javaobject> jThis)
+    : javaPart_(jni::make_global(jThis)) {}
+
+NativeProxy::~NativeProxy() {}
+
+void NativeProxy::registerNatives() {
+  registerHybrid(
+      {makeNativeMethod("initHybrid", NativeProxy::initHybrid),
+       makeNativeMethod("createCommitHook", NativeProxy::createCommitHook)});
+}
+
+void NativeProxy::createCommitHook(
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager) {
+  const auto &globalUIManager = jni::make_global(fabricUIManager);
+
+  this->commitHook_ = std::make_shared<MarkdownCommitHook>(globalUIManager);
+}
+
+jni::local_ref<NativeProxy::jhybriddata>
+NativeProxy::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+} // namespace livemarkdown

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

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/JFabricUIManager.h>
+
+#include <string>
+
+#include "MarkdownCommitHook.h"
+
+namespace livemarkdown {
+
+using namespace facebook;
+using namespace facebook::jni;
+
+class NativeProxy : public jni::HybridClass<NativeProxy> {
+public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/expensify/livemarkdown/NativeProxy;";
+  static jni::local_ref<jhybriddata>
+  initHybrid(jni::alias_ref<jhybridobject> jThis);
+  static void registerNatives();
+
+  ~NativeProxy();
+
+private:
+  friend HybridBase;
+  jni::global_ref<NativeProxy::javaobject> javaPart_;
+  std::shared_ptr<MarkdownCommitHook> commitHook_;
+
+  explicit NativeProxy(jni::alias_ref<NativeProxy::javaobject> jThis);
+
+  void
+  createCommitHook(jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+                       fabricUIManager);
+};
+
+} // namespace livemarkdown

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

@@ -0,0 +1,8 @@
+#include <fbjni/fbjni.h>
+
+#include "NativeProxy.h"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(
+      vm, [] { livemarkdown::NativeProxy::registerNatives(); });
+}

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

@@ -0,0 +1,44 @@
+
+/**
+ * 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.
+ *
+ * @generated by codegen project: GenerateModuleJniCpp.js
+ */
+
+#include "RNLiveMarkdownSpec.h"
+
+namespace facebook {
+namespace react {
+
+static facebook::jsi::Value
+__hostFunction_NativeLiveMarkdownModuleSpecJSI_install(
+    facebook::jsi::Runtime &rt, TurboModule &turboModule,
+    const facebook::jsi::Value *args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule)
+      .invokeJavaMethod(rt, BooleanKind, "install", "()Z", args, count,
+                        cachedMethodId);
+}
+
+NativeLiveMarkdownModuleSpecJSI::NativeLiveMarkdownModuleSpecJSI(
+    const JavaTurboModule::InitParams &params)
+    : JavaTurboModule(params) {
+  methodMap_["install"] =
+      MethodMetadata{0, __hostFunction_NativeLiveMarkdownModuleSpecJSI_install};
+}
+
+std::shared_ptr<TurboModule>
+RNLiveMarkdownSpec_ModuleProvider(const std::string &moduleName,
+                                  const JavaTurboModule::InitParams &params) {
+  if (moduleName == "LiveMarkdownModule") {
+    return std::make_shared<NativeLiveMarkdownModuleSpecJSI>(params);
+  }
+  return nullptr;
+}
+
+} // namespace react
+} // namespace facebook

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

@@ -0,0 +1,37 @@
+
+/**
+ * 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.
+ *
+ * @generated by codegen project: GenerateModuleJniH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+#include <react/renderer/components/RNLiveMarkdownSpec/MarkdownTextInputDecoratorViewComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+/**
+ * JNI C++ class for module 'NativeLiveMarkdownModule'
+ */
+class JSI_EXPORT NativeLiveMarkdownModuleSpecJSI : public JavaTurboModule {
+public:
+  NativeLiveMarkdownModuleSpecJSI(const JavaTurboModule::InitParams &params);
+};
+
+JSI_EXPORT
+std::shared_ptr<TurboModule>
+RNLiveMarkdownSpec_ModuleProvider(const std::string &moduleName,
+                                  const JavaTurboModule::InitParams &params);
+
+} // namespace react
+} // namespace facebook

package/android/src/newarch/NativeProxy.java

@@ -0,0 +1,24 @@
+package com.expensify.livemarkdown;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.fabric.FabricUIManager;
+import com.facebook.soloader.SoLoader;
+
+public class NativeProxy {
+  static {
+    SoLoader.loadLibrary("react_codegen_RNLiveMarkdownSpec");
+  }
+  
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private final HybridData mHybridData;
+
+  public NativeProxy() {
+    mHybridData = initHybrid();
+  }
+
+  private native HybridData initHybrid();
+
+  public native void createCommitHook(FabricUIManager fabricUIManager);
+}

package/android/src/oldarch/NativeLiveMarkdownModuleSpec.java

@@ -0,0 +1,37 @@
+
+/**
+ * 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.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.expensify.livemarkdown;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeLiveMarkdownModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "LiveMarkdownModule";
+
+  public NativeLiveMarkdownModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean install();
+}

package/android/src/oldarch/NativeProxy.java

@@ -0,0 +1,9 @@
+package com.expensify.livemarkdown;
+
+import com.facebook.react.bridge.UIManager;
+
+public class NativeProxy {
+  public void createCommitHook(UIManager uiManager) {
+    // no-op on the old arch
+  }
+}

package/{ios → cpp/react/renderer/components/RNLiveMarkdownSpec}/MarkdownShadowFamilyRegistry.cpp

@@ -1,4 +1,4 @@
-#ifdef RCT_NEW_ARCH_ENABLED
+#if defined(RCT_NEW_ARCH_ENABLED) || defined(ANDROID)
 
 #include "MarkdownShadowFamilyRegistry.h"
 

package/{ios → cpp/react/renderer/components/RNLiveMarkdownSpec}/MarkdownShadowFamilyRegistry.h

@@ -1,7 +1,7 @@
 #pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
+#if defined(RCT_NEW_ARCH_ENABLED) || defined(ANDROID)
 
-#include <react/renderer/components/iostextinput/TextInputShadowNode.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
 
 #include <mutex>
 #include <set>

package/{ios → cpp/react/renderer/components/RNLiveMarkdownSpec}/MarkdownTextInputDecoratorShadowNode.cpp

@@ -1,4 +1,4 @@
-#ifdef RCT_NEW_ARCH_ENABLED
+#if defined(RCT_NEW_ARCH_ENABLED) || defined(ANDROID)
 
 #include <react/renderer/core/LayoutContext.h>
 

package/{ios → cpp/react/renderer/components/RNLiveMarkdownSpec}/MarkdownTextInputDecoratorShadowNode.h

@@ -1,12 +1,11 @@
 #pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
+#if defined(RCT_NEW_ARCH_ENABLED) || defined(ANDROID)
 
 #include "MarkdownShadowFamilyRegistry.h"
 #include "MarkdownTextInputDecoratorState.h"
 #include <jsi/jsi.h>
 #include <react/renderer/components/RNLiveMarkdownSpec/EventEmitters.h>
 #include <react/renderer/components/RNLiveMarkdownSpec/Props.h>
-#include <react/renderer/components/iostextinput/TextInputShadowNode.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 
 namespace facebook {

package/{ios → cpp/react/renderer/components/RNLiveMarkdownSpec}/MarkdownTextInputDecoratorState.h

@@ -14,7 +14,20 @@ public:
       const ShadowNodeFamily::Shared textInputFamily_)
       : decoratorFamily(textInputFamily_){};
 
+#ifdef ANDROID
+  MarkdownTextInputDecoratorState(
+      MarkdownTextInputDecoratorState const &previousState, folly::dynamic data)
+      : decoratorFamily(previousState.decoratorFamily){};
+#endif
+
   const ShadowNodeFamily::Shared decoratorFamily;
+
+#ifdef ANDROID
+  folly::dynamic getDynamic() const {
+    return folly::dynamic::object("decoratorFamily", "pointer should be here?");
+  }
+  MapBuffer getMapBuffer() const { return MapBufferBuilder::EMPTY(); };
+#endif
 };
 
 } // namespace react

package/{ios/MarkdownTextInputDecoratorComponentDescriptor.h → cpp/react/renderer/components/RNLiveMarkdownSpec/MarkdownTextInputDecoratorViewComponentDescriptor.h}

@@ -7,7 +7,7 @@
 namespace facebook {
 namespace react {
 
-class MarkdownTextInputDecoratorComponentDescriptor final
+class MarkdownTextInputDecoratorViewComponentDescriptor final
     : public ConcreteComponentDescriptor<MarkdownTextInputDecoratorShadowNode> {
 public:
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;

package/ios/MarkdownTextInputDecoratorComponentView.mm

@@ -6,7 +6,7 @@
 #import <RNLiveMarkdown/MarkdownTextInputDecoratorView.h>
 #import <RNLiveMarkdown/RCTMarkdownStyle.h>
 
-#import "MarkdownTextInputDecoratorComponentDescriptor.h"
+#import <RNLiveMarkdown/MarkdownTextInputDecoratorViewComponentDescriptor.h>
 #import "MarkdownShadowFamilyRegistry.h"
 #import "RCTFabricComponentsPlugins.h"
 
@@ -19,7 +19,7 @@ using namespace facebook::react;
 
 + (ComponentDescriptorProvider)componentDescriptorProvider
 {
-  return concreteComponentDescriptorProvider<MarkdownTextInputDecoratorComponentDescriptor>();
+  return concreteComponentDescriptorProvider<MarkdownTextInputDecoratorViewComponentDescriptor>();
 }
 
 - (instancetype)initWithFrame:(CGRect)frame

package/lib/commonjs/MarkdownTextInputDecoratorViewNativeComponent.js

@@ -6,5 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _codegenNativeComponent = _interopRequireDefault(require("react-native/Libraries/Utilities/codegenNativeComponent"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-var _default = exports.default = (0, _codegenNativeComponent.default)('MarkdownTextInputDecoratorView');
+var _default = exports.default = (0, _codegenNativeComponent.default)('MarkdownTextInputDecoratorView', {
+  interfaceOnly: true
+});
 //# sourceMappingURL=MarkdownTextInputDecoratorViewNativeComponent.js.map

package/lib/commonjs/MarkdownTextInputDecoratorViewNativeComponent.js.map

@@ -1 +1 @@
-{"version":3,"names":["_codegenNativeComponent","_interopRequireDefault","require","obj","__esModule","default","_default","exports","codegenNativeComponent"],"sourceRoot":"../../src","sources":["MarkdownTextInputDecoratorViewNativeComponent.ts"],"mappings":";;;;;;AAGA,IAAAA,uBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA6F,SAAAD,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GA+C9E,IAAAG,+BAAsB,EAAc,gCAAgC,CAAC"}
+{"version":3,"names":["_codegenNativeComponent","_interopRequireDefault","require","obj","__esModule","default","_default","exports","codegenNativeComponent","interfaceOnly"],"sourceRoot":"../../src","sources":["MarkdownTextInputDecoratorViewNativeComponent.ts"],"mappings":";;;;;;AAGA,IAAAA,uBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA6F,SAAAD,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GA+C9E,IAAAG,+BAAsB,EAAc,gCAAgC,EAAE;EACnFC,aAAa,EAAE;AACjB,CAAC,CAAC"}

package/lib/module/MarkdownTextInputDecoratorViewNativeComponent.js

@@ -1,3 +1,5 @@
 import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
-export default codegenNativeComponent('MarkdownTextInputDecoratorView');
+export default codegenNativeComponent('MarkdownTextInputDecoratorView', {
+  interfaceOnly: true
+});
 //# sourceMappingURL=MarkdownTextInputDecoratorViewNativeComponent.js.map

package/lib/module/MarkdownTextInputDecoratorViewNativeComponent.js.map

@@ -1 +1 @@
-{"version":3,"names":["codegenNativeComponent"],"sourceRoot":"../../src","sources":["MarkdownTextInputDecoratorViewNativeComponent.ts"],"mappings":"AAGA,OAAOA,sBAAsB,MAAM,yDAAyD;AA+C5F,eAAeA,sBAAsB,CAAc,gCAAgC,CAAC"}
+{"version":3,"names":["codegenNativeComponent","interfaceOnly"],"sourceRoot":"../../src","sources":["MarkdownTextInputDecoratorViewNativeComponent.ts"],"mappings":"AAGA,OAAOA,sBAAsB,MAAM,yDAAyD;AA+C5F,eAAeA,sBAAsB,CAAc,gCAAgC,EAAE;EACnFC,aAAa,EAAE;AACjB,CAAC,CAAC"}

package/lib/typescript/src/MarkdownTextInputDecoratorViewNativeComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownTextInputDecoratorViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/MarkdownTextInputDecoratorViewNativeComponent.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAC,UAAU,EAAE,SAAS,EAAC,MAAM,cAAc,CAAC;AAExD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,2CAA2C,CAAC;AAGrE,UAAU,aAAa;IACrB,MAAM,EAAE;QACN,KAAK,EAAE,UAAU,CAAC;KACnB,CAAC;IACF,KAAK,EAAE;QACL,QAAQ,EAAE,KAAK,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACJ,KAAK,EAAE,UAAU,CAAC;KACnB,CAAC;IACF,EAAE,EAAE;QACF,QAAQ,EAAE,KAAK,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACV,WAAW,EAAE,UAAU,CAAC;QACxB,WAAW,EAAE,KAAK,CAAC;QACnB,UAAU,EAAE,KAAK,CAAC;QAClB,WAAW,EAAE,KAAK,CAAC;KACpB,CAAC;IACF,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;IACF,GAAG,EAAE;QACH,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;CACH;AAED,UAAU,WAAY,SAAQ,SAAS;IACrC,aAAa,EAAE,aAAa,CAAC;CAC9B;;AAED,wBAAqF;AAErF,YAAY,EAAC,aAAa,EAAC,CAAC"}
+{"version":3,"file":"MarkdownTextInputDecoratorViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/MarkdownTextInputDecoratorViewNativeComponent.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAC,UAAU,EAAE,SAAS,EAAC,MAAM,cAAc,CAAC;AAExD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,2CAA2C,CAAC;AAGrE,UAAU,aAAa;IACrB,MAAM,EAAE;QACN,KAAK,EAAE,UAAU,CAAC;KACnB,CAAC;IACF,KAAK,EAAE;QACL,QAAQ,EAAE,KAAK,CAAC;KACjB,CAAC;IACF,IAAI,EAAE;QACJ,KAAK,EAAE,UAAU,CAAC;KACnB,CAAC;IACF,EAAE,EAAE;QACF,QAAQ,EAAE,KAAK,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACV,WAAW,EAAE,UAAU,CAAC;QACxB,WAAW,EAAE,KAAK,CAAC;QACnB,UAAU,EAAE,KAAK,CAAC;QAClB,WAAW,EAAE,KAAK,CAAC;KACpB,CAAC;IACF,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;IACF,GAAG,EAAE;QACH,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,UAAU,CAAC;QAClB,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;CACH;AAED,UAAU,WAAY,SAAQ,SAAS;IACrC,aAAa,EAAE,aAAa,CAAC;CAC9B;;AAED,wBAEG;AAEH,YAAY,EAAC,aAAa,EAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expensify/react-native-live-markdown",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "description": "Drop-in replacement for React Native's TextInput component with Markdown formatting.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -15,6 +15,7 @@
     "ios",
     "cpp",
     "*.podspec",
+    "react-native.config.js",
     "!ios/build",
     "!android/build",
     "!android/gradle",

package/react-native.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        componentDescriptors: [
+          "MarkdownTextInputDecoratorViewComponentDescriptor",
+        ],
+        cmakeListsPath: "../android/src/main/new_arch/CMakeLists.txt"
+      },
+    },
+  },
+}

package/src/MarkdownTextInputDecoratorViewNativeComponent.ts

@@ -48,6 +48,8 @@ interface NativeProps extends ViewProps {
   markdownStyle: MarkdownStyle;
 }
 
-export default codegenNativeComponent<NativeProps>('MarkdownTextInputDecoratorView');
+export default codegenNativeComponent<NativeProps>('MarkdownTextInputDecoratorView', {
+  interfaceOnly: true,
+});
 
 export type {MarkdownStyle};