@expensify/react-native-live-markdown 0.1.44 → 0.1.46

package/RNLiveMarkdown.podspec

@@ -19,4 +19,17 @@ Pod::Spec.new do |s|
   s.resources = "parser/react-native-live-markdown-parser.js"
 
   install_modules_dependencies(s)
+
+  if ENV['USE_FRAMEWORKS'] && ENV['RCT_NEW_ARCH_ENABLED']
+    add_dependency(s, "React-Fabric", :additional_framework_paths => [
+      "react/renderer/textlayoutmanager/platform/ios",
+      "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

@@ -53,6 +53,9 @@ 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"
@@ -112,6 +115,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}
+)