react-native-marcus 0.1.0

package/android/build.gradle

@@ -0,0 +1,220 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "com.facebook.react"
+// Kotlin Gradle Plugin is expected on the root buildscript classpath, which the
+// React Native community template provides. Not declaring a version here means
+// the library always compiles with the Kotlin version the app pins.
+apply plugin: "org.jetbrains.kotlin.android"
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Marcus_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Marcus_" + name]).toInteger()
+}
+
+def safeAppExtGet(prop, fallback) {
+  def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+  appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+def resolveReactNativeDirectory() {
+  def reactNativeLocation = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+  if (reactNativeLocation != null) {
+    return file(reactNativeLocation)
+  }
+
+  // Fallback to node resolver for custom directory structures like monorepos.
+  def reactNativePackage = file(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim())
+  if (reactNativePackage.exists()) {
+    return reactNativePackage.parentFile
+  }
+
+  throw new GradleException("[react-native-marcus] Unable to resolve react-native location in node_modules. Your app should define `REACT_NATIVE_NODE_MODULES_DIR` extension property in `app/build.gradle` with a path to react-native in node_modules.")
+}
+
+def getReactNativeMinorVersion() {
+  def reactNativeRootDir = resolveReactNativeDirectory()
+  def reactNativeProperties = new Properties()
+  file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactNativeProperties.load(it) }
+  def reactNativeVersion = reactNativeProperties.getProperty("VERSION_NAME")
+  return reactNativeVersion.split("\\.")[1].toInteger()
+}
+
+def REACT_NATIVE_MINOR_VERSION = getReactNativeMinorVersion()
+
+if (REACT_NATIVE_MINOR_VERSION < 81) {
+  throw new GradleException("[react-native-marcus] React Native 0.81 or newer is required, found 0.${REACT_NATIVE_MINOR_VERSION}.")
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "app.getbullet.marcus"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  // Without this the library compiles its native code with whatever NDK the
+  // Android Gradle Plugin defaults to, which is rarely the one the app pins and
+  // often isn't installed at all.
+  if (rootProject.ext.has("ndkVersion")) {
+    ndkVersion rootProject.ext.get("ndkVersion")
+  }
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    buildConfigField "int", "REACT_NATIVE_MINOR_VERSION", REACT_NATIVE_MINOR_VERSION.toString()
+
+    consumerProguardFiles "proguard-rules.pro"
+
+    externalNativeBuild {
+      cmake {
+        arguments "-DANDROID_STL=c++_shared",
+          "-DANDROID_TOOLCHAIN=clang",
+          "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
+          "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON",
+          "-DREACT_NATIVE_ROOT_DIR=${resolveReactNativeDirectory().path}"
+        abiFilters (*reactNativeArchitectures())
+      }
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  testOptions {
+    unitTests {
+      // Robolectric needs the merged resources and the real framework jar;
+      // without this it cannot inflate a Context.
+      includeAndroidResources = true
+      // Unstubbed framework calls return defaults rather than throwing. Only
+      // reached for the few statics Robolectric does not shadow.
+      returnDefaultValues = true
+    }
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  sourceSets {
+    // The shared fixture corpus, on the test classpath. The formatters take
+    // ranges rather than markdown, so `ranges.json` is what lets the native
+    // suites run with no JS runtime at all.
+    test {
+      resources.srcDirs += "${projectDir}/../src/__fixtures__"
+    }
+
+    main {
+      java.srcDirs += [
+        // This is needed to build Kotlin project with NewArch enabled
+        "${project.buildDir}/generated/source/codegen/java"
+      ]
+
+      // TextLayoutManager
+      if (REACT_NATIVE_MINOR_VERSION <= 85) {
+          java.srcDirs += "src/reactNativeVersionPatch/CustomMountingManager/81"
+      } else {
+          java.srcDirs += "src/reactNativeVersionPatch/CustomMountingManager/latest"
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path file('src/main/cpp/CMakeLists.txt')
+      version '3.22.1'
+    }
+  }
+
+  packagingOptions {
+    doNotStrip '**/**/*.so'
+    // 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 exclude patterns)
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libreactnativejni.so",
+      "**/libreactnative.so",
+      "**/libreact_nativemodule_core.so",
+      "**/libruntimeexecutor.so",
+      "**/libworklets.so",
+      "**/libreact_render*.so",
+      "**/librrc_root.so",
+    ]
+  }
+}
+
+kotlin {
+  compilerOptions {
+    // Must match compileOptions above; a mismatch fails the build with
+    // "Inconsistent JVM-target compatibility" rather than anything useful.
+    jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  implementation "com.facebook.react:react-android" // version substituted by RNGP
+  implementation "com.facebook.react:hermes-android" // version substituted by RNGP
+  implementation project(":react-native-worklets")
+
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.robolectric:robolectric:4.16"
+}

package/android/proguard-rules.pro

@@ -0,0 +1 @@
+-keep class app.getbullet.marcus.** { *; }

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="app.getbullet.marcus">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,41 @@
+project("marcus")
+
+cmake_minimum_required(VERSION 3.13)
+
+set(CMAKE_VERBOSE_MAKEFILE on)
+set(CMAKE_CXX_STANDARD 20)
+
+include("${REACT_NATIVE_ROOT_DIR}/ReactAndroid/cmake-utils/folly-flags.cmake")
+add_compile_options(${folly_FLAGS})
+
+add_compile_options(-fvisibility=hidden -fexceptions -frtti)
+
+string(APPEND CMAKE_CXX_FLAGS " -DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}")
+
+set(CPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../../cpp")
+
+file(GLOB ANDROID_SRC CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+file(GLOB CPP_SRC CONFIGURE_DEPENDS "${CPP_DIR}/*.cpp")
+
+add_library(${CMAKE_PROJECT_NAME} SHARED ${ANDROID_SRC} ${CPP_SRC})
+
+target_include_directories(
+  ${CMAKE_PROJECT_NAME}
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CPP_DIR}
+    "${REACT_NATIVE_ROOT_DIR}/ReactCommon/jsiexecutor"
+    "${REACT_NATIVE_ROOT_DIR}/ReactCommon"
+)
+
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(react-native-worklets REQUIRED CONFIG)
+
+target_link_libraries(
+  ${CMAKE_PROJECT_NAME}
+  fbjni::fbjni
+  ReactAndroid::jsi
+  ReactAndroid::reactnative
+  react-native-worklets::worklets
+)

package/android/src/main/cpp/MarkdownParser.cpp

@@ -0,0 +1,49 @@
+#include "MarkdownParser.h"
+#include "MarkdownWorkletParser.h"
+
+#include <fbjni/fbjni.h>
+
+using namespace facebook;
+
+namespace bulletpoint {
+namespace marcus {
+jni::local_ref<JMarkdownParseResult>
+JMarkdownParser::nativeParse(jni::alias_ref<JMarkdownParser> jThis, jni::alias_ref<jni::JString> text, const int parserId) {
+  // Read the UTF-16 length from the same jstring rather than taking it as a
+  // parameter, so the length and the text can never disagree. The worklet
+  // reports offsets in UTF-16 units (they are JS string indices); validating
+  // them against the UTF-8 byte count would let out-of-bounds ranges through
+  // for any non-ASCII text.
+  const auto lengthUtf16 = static_cast<size_t>(
+    jni::Environment::current()->GetStringLength(text.get())
+  );
+
+  const auto result = parseMarkdown(text->toStdString(), lengthUtf16, parserId);
+
+  auto ranges = jni::JArrayClass<JMarkdownRange::javaobject>::newArray(
+    result.ranges.size()
+  );
+  for (size_t i = 0; i < result.ranges.size(); i++) {
+    const auto &range = result.ranges[i];
+    // Scoped so each local ref is released as we go, instead of accumulating
+    // one per range in the frame.
+    const auto jRange = JMarkdownRange::create(range.type, range.start, range.length, range.depth);
+    ranges->setElement(i, jRange.get());
+  }
+
+  auto schemaError = result.schemaError.empty()
+                       ? jni::local_ref<jni::JString>(nullptr)
+                       : jni::make_jstring(result.schemaError);
+
+  return JMarkdownParseResult::create(ranges, std::move(schemaError));
+}
+
+void
+JMarkdownParser::registerNatives() {
+  javaClassStatic()->registerNatives(
+    {makeNativeMethod("nativeParse", JMarkdownParser::nativeParse)}
+  );
+}
+
+} // namespace marcus
+} // namespace bulletpoint

package/android/src/main/cpp/MarkdownParser.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+#include <string>
+
+using namespace facebook;
+
+namespace bulletpoint {
+namespace marcus {
+
+struct JMarkdownRange : jni::JavaClass<JMarkdownRange> {
+  static constexpr auto kJavaDescriptor =
+    "Lapp/getbullet/marcus/MarkdownRange;";
+
+  // fbjni keeps newInstance protected, so the factory has to live inside the
+  // class.
+  static jni::local_ref<JMarkdownRange>
+  create(const std::string &type, int start, int length, int depth) {
+    return newInstance(jni::make_jstring(type), start, length, depth);
+  }
+};
+
+struct JMarkdownParseResult : jni::JavaClass<JMarkdownParseResult> {
+  static constexpr auto kJavaDescriptor =
+    "Lapp/getbullet/marcus/MarkdownParseResult;";
+
+  static jni::local_ref<JMarkdownParseResult>
+  create(jni::alias_ref<jni::JArrayClass<JMarkdownRange::javaobject>> ranges, jni::local_ref<jni::JString> schemaError) {
+    return newInstance(ranges, schemaError);
+  }
+};
+
+// A plain JavaClass, not a HybridClass: the Kotlin side holds no HybridData and
+// nothing ever constructs a C++ peer, so the hybrid machinery would only be
+// decoration.
+struct JMarkdownParser : jni::JavaClass<JMarkdownParser> {
+  static constexpr auto kJavaDescriptor =
+    "Lapp/getbullet/marcus/MarkdownParser;";
+
+  static jni::local_ref<JMarkdownParseResult>
+  nativeParse(jni::alias_ref<JMarkdownParser> jThis, jni::alias_ref<jni::JString> text, const int parserId);
+
+  static void
+  registerNatives();
+};
+
+} // namespace marcus
+} // namespace bulletpoint

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

@@ -0,0 +1,17 @@
+#include <fbjni/fbjni.h>
+
+#include "MarkdownParser.h"
+#include "RuntimeDecorator.h"
+
+JNIEXPORT jint JNICALL
+JNI_OnLoad(JavaVM *vm, void *reserved) {
+  return facebook::jni::initialize(
+    vm, [] { bulletpoint::marcus::JMarkdownParser::registerNatives(); }
+  );
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_app_getbullet_marcus_MarcusModule_injectJSIBindings(JNIEnv *env, jobject thiz, jlong jsiRuntime) {
+  jsi::Runtime &rt = *reinterpret_cast<jsi::Runtime *>(jsiRuntime);
+  bulletpoint::marcus::injectJSIBindings(rt);
+}

package/android/src/main/java/app/getbullet/marcus/MarcusModule.kt

@@ -0,0 +1,28 @@
+package app.getbullet.marcus
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.soloader.SoLoader
+
+class MarcusModule(reactContext: ReactApplicationContext) :
+  NativeMarcusModuleSpec(reactContext) {
+
+  override fun install(): Boolean {
+    val contextHolder = requireNotNull(reactApplicationContext.javaScriptContextHolder) {
+      "[react-native-marcus] JavaScriptContextHolder is null"
+    }
+    injectJSIBindings(contextHolder.get())
+    return true
+  }
+
+  // OnLoad.cpp hand-writes this symbol as
+  // Java_app_getbullet_marcus_MarcusModule_injectJSIBindings, so the package,
+  // class and method names are frozen. It must also stay an instance method: the native
+  // signature takes `jobject thiz`, which a @JvmStatic version would not supply.
+  private external fun injectJSIBindings(jsiRuntime: Long)
+
+  companion object {
+    init {
+      SoLoader.loadLibrary("marcus")
+    }
+  }
+}

package/android/src/main/java/app/getbullet/marcus/MarcusPackage.kt

@@ -0,0 +1,31 @@
+package app.getbullet.marcus
+
+import com.facebook.react.BaseReactPackage
+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
+
+class MarcusPackage : BaseReactPackage() {
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext
+  ): List<ViewManager<in Nothing, in Nothing>> = listOf(MarcusTextInputDecoratorViewManager())
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+    mapOf(
+      NativeMarcusModuleSpec.NAME to ReactModuleInfo(
+        NativeMarcusModuleSpec.NAME,
+        MarcusModule::class.java.name,
+        false, // canOverrideExistingModule
+        false, // needsEagerInit
+        false, // isCxxModule
+        true // isTurboModule
+      )
+    )
+  }
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == NativeMarcusModuleSpec.NAME) MarcusModule(reactContext) else null
+}

package/android/src/main/java/app/getbullet/marcus/MarcusTextInputDecoratorView.kt

@@ -0,0 +1,63 @@
+package app.getbullet.marcus
+
+import android.content.Context
+import android.text.SpannableStringBuilder
+import android.text.TextWatcher
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.views.textinput.ReactEditText
+import com.facebook.react.views.view.ReactViewGroup
+
+class MarcusTextInputDecoratorView(context: Context) : ReactViewGroup(context) {
+
+  private var markdownUtils: MarkdownUtils? = null
+  private var reactEditText: ReactEditText? = null
+  private var textWatcher: TextWatcher? = null
+
+  var markdownStyle: MarkdownStyle? = null
+    set(value) {
+      field = value
+      markdownUtils?.markdownStyle = value
+      applyNewStyles()
+    }
+
+  var parserId: Int = 0
+    set(value) {
+      field = value
+      markdownUtils?.parserId = value
+      applyNewStyles()
+    }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+
+    val child = getChildAt(0)
+    if (child is ReactEditText) {
+      val utils = MarkdownUtils(context as ReactContext, child.paint)
+      utils.markdownStyle = markdownStyle
+      utils.parserId = parserId
+      markdownUtils = utils
+      reactEditText = child
+      textWatcher = MarkdownTextWatcher(utils).also { child.addTextChangedListener(it) }
+      applyNewStyles()
+    }
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    reactEditText?.let { editText ->
+      textWatcher?.let { editText.removeTextChangedListener(it) }
+      reactEditText = null
+      textWatcher = null
+      markdownUtils = null
+    }
+  }
+
+  fun applyNewStyles() {
+    val editText = reactEditText ?: return
+    val utils = markdownUtils ?: return
+    val editable = editText.text
+    if (editable is SpannableStringBuilder) {
+      utils.applyMarkdownFormatting(editable)
+    }
+  }
+}

package/android/src/main/java/app/getbullet/marcus/MarcusTextInputDecoratorViewManager.kt

@@ -0,0 +1,32 @@
+package app.getbullet.marcus
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+@ReactModule(name = MarcusTextInputDecoratorViewManager.NAME)
+class MarcusTextInputDecoratorViewManager : MarcusTextInputDecoratorViewManagerSpec() {
+
+  override fun getName(): String = NAME
+
+  public override fun createViewInstance(context: ThemedReactContext): MarcusTextInputDecoratorView =
+    MarcusTextInputDecoratorView(context)
+
+  // The generated interface declares this parameter @Nullable, so the override
+  // has to accept null even though the prop always arrives set.
+  @ReactProp(name = "markdownStyle")
+  override fun setMarkdownStyle(view: MarcusTextInputDecoratorView, value: ReadableMap?) {
+    val map = requireNotNull(value) { "[react-native-marcus] markdownStyle prop is required" }
+    view.markdownStyle = MarkdownStyle(map, view.context)
+  }
+
+  @ReactProp(name = "parserId")
+  override fun setParserId(view: MarcusTextInputDecoratorView, parserId: Int) {
+    view.parserId = parserId
+  }
+
+  companion object {
+    const val NAME = "MarcusTextInputDecoratorView"
+  }
+}

package/android/src/main/java/app/getbullet/marcus/MarcusTextInputDecoratorViewManagerSpec.kt

@@ -0,0 +1,21 @@
+package app.getbullet.marcus
+
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.MarcusTextInputDecoratorViewManagerDelegate
+import com.facebook.react.viewmanagers.MarcusTextInputDecoratorViewManagerInterface
+
+// Not generic over the view type, unlike the Java this replaces. The generated
+// delegate's second type parameter is a Java intersection type
+// (`BaseViewManager<T, ...> & MarcusTextInputDecoratorViewManagerInterface<T>`),
+// which Kotlin has no syntax for. Naming the one concrete view type lets the
+// compiler infer it from `this` instead.
+abstract class MarcusTextInputDecoratorViewManagerSpec :
+  ViewGroupManager<MarcusTextInputDecoratorView>(),
+  MarcusTextInputDecoratorViewManagerInterface<MarcusTextInputDecoratorView> {
+
+  private val delegate: ViewManagerDelegate<MarcusTextInputDecoratorView> =
+    MarcusTextInputDecoratorViewManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<MarcusTextInputDecoratorView> = delegate
+}