react-native-jet-markdown 0.2.0-beta.7

package/cpp/react/JetMarkdownShadowNode.cpp

@@ -0,0 +1,100 @@
+#include "JetMarkdownShadowNode.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "JetMarkdownMeasurer.h"
+
+namespace facebook::react {
+
+namespace {
+
+void appendJsonEscaped(std::string& out, const std::string& value) {
+  for (char c : value) {
+    switch (c) {
+      case '"': out += "\\\""; break;
+      case '\\': out += "\\\\"; break;
+      case '\n': out += "\\n"; break;
+      case '\t': out += "\\t"; break;
+      case '\r': out += "\\r"; break;
+      default:
+        if (static_cast<unsigned char>(c) < 0x20) {
+          char buffer[8];
+          snprintf(buffer, sizeof(buffer), "\\u%04x", c);
+          out += buffer;
+        } else {
+          out += c;
+        }
+        break;
+    }
+  }
+}
+
+} // namespace
+
+Size JetMarkdownShadowNode::measureContent(
+    const LayoutContext& layoutContext,
+    const LayoutConstraints& layoutConstraints) const {
+  const auto& props = getConcreteProps();
+  const auto& state = getStateData();
+
+  // {"url":[w,h],...} — state sizes first, the images prop wins.
+  std::string imagesJson = "{";
+  bool first = true;
+  auto appendEntry = [&](const std::string& url, double width, double height) {
+    if (!first) {
+      imagesJson += ',';
+    }
+    first = false;
+    imagesJson += '"';
+    appendJsonEscaped(imagesJson, url);
+    imagesJson += "\":[";
+    imagesJson += std::to_string(width);
+    imagesJson += ',';
+    imagesJson += std::to_string(height);
+    imagesJson += ']';
+  };
+  for (const auto& [url, size] : state.imageSizes) {
+    bool inProps = false;
+    for (const auto& image : props.images) {
+      if (image.url == url) {
+        inProps = true;
+        break;
+      }
+    }
+    if (!inProps) {
+      appendEntry(url, size.width, size.height);
+    }
+  }
+  for (const auto& image : props.images) {
+    appendEntry(image.url, image.width, image.height);
+  }
+  imagesJson += '}';
+
+  // Under an unconstrained parent the max width is +inf; measuring against
+  // it would produce nonsense (one endless line). Fall back to the
+  // viewport-ish minimum and let Yoga assign the real frame.
+  float maxWidth = layoutConstraints.maximumSize.width;
+  if (!std::isfinite(maxWidth)) {
+    maxWidth = std::max(static_cast<float>(layoutConstraints.minimumSize.width), 0.0f);
+  }
+  // The host views compute the same multiplier (RN's iOS category table /
+  // Android configuration.fontScale) so measured and rendered heights
+  // agree.
+  float fontScale = 1.0f;
+  if (props.allowFontScaling && layoutContext.fontSizeMultiplier > 0) {
+    fontScale = static_cast<float>(layoutContext.fontSizeMultiplier);
+  }
+  const float height = jetmarkdown::JetMarkdownMeasurer::shared().measure(
+      props.markdown, props.stylesJson, imagesJson, maxWidth, fontScale);
+
+  Size size;
+  size.width = maxWidth;
+  size.height = std::clamp(
+      static_cast<Float>(height),
+      layoutConstraints.minimumSize.height,
+      layoutConstraints.maximumSize.height);
+  return size;
+}
+
+} // namespace facebook::react

package/cpp/react/JetMarkdownShadowNode.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <react/renderer/components/JetMarkdownViewSpec/EventEmitters.h>
+#include <react/renderer/components/JetMarkdownViewSpec/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+
+#include "JetMarkdownState.h"
+
+namespace facebook::react {
+
+// Defined in the codegen-generated ShadowNodes.cpp.
+extern const char JetMarkdownViewComponentName[];
+
+// Custom shadow node: sizes the component to its markdown content via the
+// platform measurer, replacing the codegen default (which cannot measure).
+class JetMarkdownShadowNode final : public ConcreteViewShadowNode<
+                                         JetMarkdownViewComponentName,
+                                         JetMarkdownViewProps,
+                                         JetMarkdownViewEventEmitter,
+                                         JetMarkdownState> {
+ public:
+  JetMarkdownShadowNode(
+      const ShadowNodeFragment& fragment,
+      const ShadowNodeFamily::Shared& family,
+      ShadowNodeTraits traits)
+      : ConcreteViewShadowNode(fragment, family, traits) {}
+
+  JetMarkdownShadowNode(
+      const ShadowNode& sourceShadowNode,
+      const ShadowNodeFragment& fragment)
+      : ConcreteViewShadowNode(sourceShadowNode, fragment) {
+    // State carries image sizes, which affect measureContent; Yoga must
+    // re-measure when a new state arrives.
+    if (fragment.state != nullptr) {
+      dirtyLayout();
+    }
+  }
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  Size measureContent(
+      const LayoutContext& layoutContext,
+      const LayoutConstraints& layoutConstraints) const override;
+};
+
+} // namespace facebook::react

package/cpp/react/JetMarkdownState.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+#ifdef RN_SERIALIZABLE_STATE
+#include <folly/dynamic.h>
+#endif
+
+namespace facebook::react {
+
+// Shadow-node state: intrinsic sizes of images discovered after loading.
+// The host view publishes sizes here; measureContent reads them so the view
+// grows once an un-presized image arrives.
+class JetMarkdownState final {
+ public:
+  struct ImageSize {
+    double width = 0;
+    double height = 0;
+  };
+
+  JetMarkdownState() = default;
+  explicit JetMarkdownState(std::map<std::string, ImageSize> imageSizes)
+      : imageSizes(std::move(imageSizes)) {}
+
+#ifdef RN_SERIALIZABLE_STATE
+  JetMarkdownState(const JetMarkdownState& previousState, folly::dynamic data) {
+    imageSizes = previousState.imageSizes;
+    const auto& sizes = data["imageSizes"];
+    if (sizes.isObject()) {
+      for (const auto& entry : sizes.items()) {
+        imageSizes[entry.first.getString()] = ImageSize{
+            entry.second["width"].getDouble(),
+            entry.second["height"].getDouble(),
+        };
+      }
+    }
+  }
+
+  folly::dynamic getDynamic() const {
+    folly::dynamic sizes = folly::dynamic::object();
+    for (const auto& [url, size] : imageSizes) {
+      sizes[url] = folly::dynamic::object("width", size.width)("height", size.height);
+    }
+    return folly::dynamic::object("imageSizes", std::move(sizes));
+  }
+#endif
+
+  std::map<std::string, ImageSize> imageSizes;
+};
+
+} // namespace facebook::react

package/cpp/react/override/react/renderer/components/JetMarkdownViewSpec/ComponentDescriptors.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// Shadows the codegen-generated ComponentDescriptors.h (this directory is
+// first on the include path) so autolinking and the iOS component view
+// register a descriptor over the custom measurable shadow node instead of
+// the codegen default.
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+#include "../../../../../JetMarkdownEditorShadowNode.h"
+#include "../../../../../JetMarkdownShadowNode.h"
+
+namespace facebook::react {
+
+using JetMarkdownViewComponentDescriptor =
+    ConcreteComponentDescriptor<JetMarkdownShadowNode>;
+
+using JetMarkdownEditorComponentDescriptor =
+    ConcreteComponentDescriptor<JetMarkdownEditorShadowNode>;
+
+} // namespace facebook::react