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

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/cpp/react/renderer/components/RNLiveMarkdownSpec/MarkdownShadowFamilyRegistry.cpp

@@ -0,0 +1,58 @@
+#if defined(RCT_NEW_ARCH_ENABLED) || defined(ANDROID)
+
+#include "MarkdownShadowFamilyRegistry.h"
+
+std::set<facebook::react::ShadowNodeFamily::Shared>
+    MarkdownShadowFamilyRegistry::familiesToUpdate_;
+std::set<facebook::react::Tag> MarkdownShadowFamilyRegistry::forcedUpdates_;
+std::mutex MarkdownShadowFamilyRegistry::mutex_;
+
+void MarkdownShadowFamilyRegistry::registerFamilyForUpdates(
+    facebook::react::ShadowNodeFamily::Shared family) {
+  auto lock =
+      std::unique_lock<std::mutex>(MarkdownShadowFamilyRegistry::mutex_);
+  MarkdownShadowFamilyRegistry::familiesToUpdate_.insert(family);
+}
+
+void MarkdownShadowFamilyRegistry::unregisterFamilyForUpdates(
+    facebook::react::ShadowNodeFamily::Shared family) {
+  auto lock =
+      std::unique_lock<std::mutex>(MarkdownShadowFamilyRegistry::mutex_);
+  MarkdownShadowFamilyRegistry::familiesToUpdate_.erase(family);
+}
+
+void MarkdownShadowFamilyRegistry::reset() {
+  auto lock =
+      std::unique_lock<std::mutex>(MarkdownShadowFamilyRegistry::mutex_);
+  MarkdownShadowFamilyRegistry::familiesToUpdate_.clear();
+  MarkdownShadowFamilyRegistry::forcedUpdates_.clear();
+}
+
+void MarkdownShadowFamilyRegistry::runForEveryFamily(
+    std::function<void(facebook::react::ShadowNodeFamily::Shared)> fun) {
+  auto lock =
+      std::unique_lock<std::mutex>(MarkdownShadowFamilyRegistry::mutex_);
+  for (auto &family : MarkdownShadowFamilyRegistry::familiesToUpdate_) {
+    fun(family);
+  }
+}
+
+void MarkdownShadowFamilyRegistry::forceNextStateUpdate(
+    facebook::react::Tag tag) {
+  auto lock =
+      std::unique_lock<std::mutex>(MarkdownShadowFamilyRegistry::mutex_);
+  forcedUpdates_.insert(tag);
+}
+
+bool MarkdownShadowFamilyRegistry::shouldForceUpdate(facebook::react::Tag tag) {
+  auto lock =
+      std::unique_lock<std::mutex>(MarkdownShadowFamilyRegistry::mutex_);
+  bool force = forcedUpdates_.contains(tag);
+  if (force) {
+    forcedUpdates_.erase(tag);
+    return true;
+  }
+  return false;
+}
+
+#endif

package/cpp/react/renderer/components/RNLiveMarkdownSpec/MarkdownShadowFamilyRegistry.h

@@ -0,0 +1,35 @@
+#pragma once
+#if defined(RCT_NEW_ARCH_ENABLED) || defined(ANDROID)
+
+#include <react/renderer/core/ShadowNodeFamily.h>
+
+#include <mutex>
+#include <set>
+
+// A registry to store pointers to the ShadowNodeFamilies of markdown
+// decorators. The only place we can _legally_ access the family of shadow node
+// is in the constructor and we need it inside commit hook. To achieve it, we
+// use this simple registry where families are registered when nodes are created
+// and cleaned up when native view is removed from window or when a turbomodule
+// is deallocated.
+
+class MarkdownShadowFamilyRegistry {
+public:
+  static void
+  registerFamilyForUpdates(facebook::react::ShadowNodeFamily::Shared family);
+  static void
+  unregisterFamilyForUpdates(facebook::react::ShadowNodeFamily::Shared family);
+  static void reset();
+  static void runForEveryFamily(
+      std::function<void(facebook::react::ShadowNodeFamily::Shared family)>
+          fun);
+  static void forceNextStateUpdate(facebook::react::Tag tag);
+  static bool shouldForceUpdate(facebook::react::Tag tag);
+
+private:
+  static std::set<facebook::react::ShadowNodeFamily::Shared> familiesToUpdate_;
+  static std::set<facebook::react::Tag> forcedUpdates_;
+  static std::mutex mutex_;
+};
+
+#endif

package/cpp/react/renderer/components/RNLiveMarkdownSpec/MarkdownTextInputDecoratorShadowNode.cpp

@@ -0,0 +1,38 @@
+#if defined(RCT_NEW_ARCH_ENABLED) || defined(ANDROID)
+
+#include <react/renderer/core/LayoutContext.h>
+
+#include "MarkdownShadowFamilyRegistry.h"
+#include "MarkdownTextInputDecoratorShadowNode.h"
+
+namespace facebook {
+namespace react {
+
+extern const char MarkdownTextInputDecoratorViewComponentName[] =
+    "MarkdownTextInputDecoratorView";
+
+const ShadowNodeFragment::Value
+MarkdownTextInputDecoratorShadowNode::updateFragmentState(
+    ShadowNodeFragment const &fragment,
+    ShadowNodeFamily::Shared const &family) {
+  const auto newStateData =
+      std::make_shared<MarkdownTextInputDecoratorState>(family);
+
+  MarkdownShadowFamilyRegistry::registerFamilyForUpdates(family);
+
+  // we pass the pointer to the ShadowNodeFamily in the initial state, so it's
+  // propagated on every clone we need it to clear the reference in the registry
+  // when the view is removed from window it cannot be done in the destructor,
+  // as multiple shadow nodes for the same family may be created
+  return ShadowNodeFragment::Value({
+      .props = fragment.props,
+      .children = fragment.children,
+      .state =
+          std::make_shared<const ConcreteState>(newStateData, *fragment.state),
+  });
+}
+
+} // namespace react
+} // namespace facebook
+
+#endif

package/cpp/react/renderer/components/RNLiveMarkdownSpec/MarkdownTextInputDecoratorShadowNode.h

@@ -0,0 +1,48 @@
+#pragma once
+#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/view/ConcreteViewShadowNode.h>
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT extern const char MarkdownTextInputDecoratorViewComponentName[];
+
+class JSI_EXPORT MarkdownTextInputDecoratorShadowNode final
+    : public ConcreteViewShadowNode<MarkdownTextInputDecoratorViewComponentName,
+                                    MarkdownTextInputDecoratorViewProps,
+                                    MarkdownTextInputDecoratorViewEventEmitter,
+                                    MarkdownTextInputDecoratorState> {
+public:
+  MarkdownTextInputDecoratorShadowNode(ShadowNodeFragment const &fragment,
+                                       ShadowNodeFamily::Shared const &family,
+                                       ShadowNodeTraits traits)
+      : ConcreteViewShadowNode(static_cast<ShadowNodeFragment>(
+                                   updateFragmentState(fragment, family)),
+                               family, traits) {}
+
+  MarkdownTextInputDecoratorShadowNode(ShadowNode const &sourceShadowNode,
+                                       ShadowNodeFragment const &fragment)
+      : ConcreteViewShadowNode(sourceShadowNode, fragment) {
+    // if the props changed, we need to update the shadow node state to reflect
+    // potential style changes
+    if (fragment.props != ShadowNodeFragment::propsPlaceholder()) {
+      MarkdownShadowFamilyRegistry::forceNextStateUpdate(this->getTag());
+    }
+  }
+
+private:
+  static const ShadowNodeFragment::Value
+  updateFragmentState(ShadowNodeFragment const &fragment,
+                      ShadowNodeFamily::Shared const &family);
+};
+
+} // namespace react
+} // namespace facebook
+
+#endif