@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.9

package/android/src/main/jni/react/renderer/components/RichTextSpec/TiptapTextMeasurementManager.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <react/renderer/components/RichTextSpec/Props.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook::react {
+
+class TiptapTextMeasurementManager {
+public:
+  TiptapTextMeasurementManager(const std::shared_ptr<const ContextContainer> &contextContainer)
+      : contextContainer_(contextContainer) {}
+
+  Size measure(SurfaceId surfaceId, int viewTag, const EnrichedTiptapTextProps &props,
+               LayoutConstraints layoutConstraints) const;
+
+private:
+  const std::shared_ptr<const ContextContainer> contextContainer_;
+};
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/RichTextSpec/TiptapTextShadowNode.cpp

@@ -0,0 +1,38 @@
+#include "TiptapTextShadowNode.h"
+
+#include <react/renderer/core/LayoutContext.h>
+
+namespace facebook::react {
+
+extern const char TiptapTextComponentName[] = "EnrichedTiptapText";
+
+void TiptapTextShadowNode::setMeasurementsManager(
+    const std::shared_ptr<TiptapTextMeasurementManager> &measurementsManager) {
+  ensureUnsealed();
+  measurementsManager_ = measurementsManager;
+}
+
+void TiptapTextShadowNode::dirtyLayoutIfNeeded() {
+  const auto state = this->getStateData();
+  const auto counter = state.getForceHeightRecalculationCounter();
+
+  if (forceHeightRecalculationCounter_ != counter) {
+    forceHeightRecalculationCounter_ = counter;
+    dirtyLayout();
+  }
+}
+
+// Only new props change the rendered tiptap. When a parent is cloned, React Native's adoptYogaChild
+// re-clones its children without new props, and dirtying those clones re-measures every settled message
+// whenever the list above grows.
+bool TiptapTextShadowNode::shouldNewRevisionDirtyMeasurement(const ShadowNode & /*sourceShadowNode*/,
+                                                               const ShadowNodeFragment &fragment) const {
+  return fragment.props != nullptr;
+}
+
+Size TiptapTextShadowNode::measureContent(const LayoutContext &layoutContext,
+                                            const LayoutConstraints &layoutConstraints) const {
+  return measurementsManager_->measure(getSurfaceId(), getTag(), getConcreteProps(), layoutConstraints);
+}
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/RichTextSpec/TiptapTextShadowNode.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "TiptapTextMeasurementManager.h"
+#include "TiptapTextState.h"
+
+#include <react/renderer/components/RichTextSpec/EventEmitters.h>
+#include <react/renderer/components/RichTextSpec/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char TiptapTextComponentName[];
+
+/*
+ * `ShadowNode` for <EnrichedTiptapText> component.
+ */
+class TiptapTextShadowNode final
+    : public ConcreteViewShadowNode<TiptapTextComponentName, EnrichedTiptapTextProps,
+                                    EnrichedTiptapTextEventEmitter, TiptapTextState> {
+public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  TiptapTextShadowNode(ShadowNode const &sourceShadowNode, ShadowNodeFragment const &fragment)
+      : ConcreteViewShadowNode(sourceShadowNode, fragment) {
+    forceHeightRecalculationCounter_ =
+        static_cast<const TiptapTextShadowNode &>(sourceShadowNode).forceHeightRecalculationCounter_;
+    dirtyLayoutIfNeeded();
+  }
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  // Associates a shared `TiptapTextMeasurementManager` with the node.
+  void setMeasurementsManager(const std::shared_ptr<TiptapTextMeasurementManager> &measurementsManager);
+
+  void dirtyLayoutIfNeeded();
+
+  Size measureContent(const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints) const override;
+
+protected:
+  bool shouldNewRevisionDirtyMeasurement(const ShadowNode &sourceShadowNode,
+                                         const ShadowNodeFragment &fragment) const override;
+
+private:
+  int forceHeightRecalculationCounter_{0};
+  std::shared_ptr<TiptapTextMeasurementManager> measurementsManager_;
+};
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/RichTextSpec/TiptapTextState.cpp

@@ -0,0 +1,9 @@
+#include "TiptapTextState.h"
+
+namespace facebook::react {
+
+int TiptapTextState::getForceHeightRecalculationCounter() const {
+  return forceHeightRecalculationCounter_;
+}
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/RichTextSpec/TiptapTextState.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <folly/dynamic.h>
+
+namespace facebook::react {
+
+class TiptapTextState {
+public:
+  TiptapTextState() : forceHeightRecalculationCounter_(0) {}
+
+  TiptapTextState(TiptapTextState const &previousState, folly::dynamic data)
+      : forceHeightRecalculationCounter_((int)data["forceHeightRecalculationCounter"].getInt()) {}
+
+  folly::dynamic getDynamic() const {
+    return {};
+  }
+
+  int getForceHeightRecalculationCounter() const;
+
+private:
+  const int forceHeightRecalculationCounter_{};
+};
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/RichTextSpec/conversions.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <folly/dynamic.h>
+#include <react/renderer/components/RichTextSpec/Props.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook::react {
+
+#ifdef RN_SERIALIZABLE_STATE
+inline folly::dynamic toDynamic(const EnrichedTiptapTextProps &props) {
+  folly::dynamic serializedProps = folly::dynamic::object();
+  serializedProps["document"] = props.document;
+  serializedProps["tiptapStyle"] = toDynamic(props.tiptapStyle);
+  serializedProps["md4cFlags"] = toDynamic(props.md4cFlags);
+  serializedProps["allowFontScaling"] = props.allowFontScaling;
+  serializedProps["maxFontSizeMultiplier"] = props.maxFontSizeMultiplier;
+  serializedProps["allowTrailingMargin"] = props.allowTrailingMargin;
+  serializedProps["streamingAnimation"] = props.streamingAnimation;
+  serializedProps["numberOfLines"] = props.numberOfLines;
+  serializedProps["ellipsizeMode"] = props.ellipsizeMode;
+
+  folly::dynamic imageRequestHeaders = folly::dynamic::array();
+  for (const auto &header : props.imageRequestHeaders) {
+    imageRequestHeaders.push_back(toDynamic(header));
+  }
+  serializedProps["imageRequestHeaders"] = std::move(imageRequestHeaders);
+
+  folly::dynamic linkPillContent = folly::dynamic::array();
+  for (const auto &content : props.linkPillContent) {
+    linkPillContent.push_back(toDynamic(content));
+  }
+  serializedProps["linkPillContent"] = std::move(linkPillContent);
+
+  serializedProps["linkRecognition"] = toDynamic(props.linkRecognition);
+
+  return serializedProps;
+}
+#endif
+
+} // namespace facebook::react

package/cpp/parser/TiptapASTNode.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace Tiptap {
+
+enum class NodeType {
+  Document,
+  Paragraph,
+  Text,
+  Link,
+  Heading,
+  LineBreak,
+  Strong,
+  Emphasis,
+  Strikethrough,
+  Underline,
+  Code,
+  Image,
+  Blockquote,
+  UnorderedList,
+  OrderedList,
+  ListItem,
+  CodeBlock,
+  ThematicBreak,
+  Table,
+  TableHead,
+  TableBody,
+  TableRow,
+  TableHeaderCell,
+  TableCell,
+  LatexMathInline,
+  LatexMathDisplay,
+  Spoiler,
+  Superscript,
+  Subscript,
+  Highlight,
+  SoftBreak,
+  BlankLine,
+  Admonition,
+  Video,
+  Factoid,
+  Mention
+};
+
+struct TiptapASTNode {
+  NodeType type;
+  std::string content;
+  std::unordered_map<std::string, std::string> attributes;
+  std::vector<std::shared_ptr<TiptapASTNode>> children;
+
+  explicit TiptapASTNode(NodeType t) : type(t) {}
+
+  void addChild(std::shared_ptr<TiptapASTNode> child) {
+    if (child) {
+      children.push_back(std::move(child));
+    }
+  }
+
+  void setAttribute(const std::string &key, const std::string &value) {
+    attributes[key] = value;
+  }
+};
+
+} // namespace Tiptap

package/cpp/parser/TiptapParser.cpp

@@ -0,0 +1,233 @@
+#include "TiptapParser.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <string>
+
+namespace Tiptap {
+namespace {
+
+using json = nlohmann::json;
+
+std::shared_ptr<TiptapASTNode> makeNode(NodeType type) {
+  return std::make_shared<TiptapASTNode>(type);
+}
+
+std::shared_ptr<TiptapASTNode> parseNode(const json &node);
+
+bool isObject(const json &value) {
+  return value.is_object();
+}
+
+std::string textOf(const json &node) {
+  if (!node.contains("text") || !node["text"].is_string()) {
+    return "";
+  }
+  return node["text"].get<std::string>();
+}
+
+const json *markOfType(const json &node, const char *typeA, const char *typeB = nullptr) {
+  if (!node.contains("marks") || !node["marks"].is_array()) {
+    return nullptr;
+  }
+  const json *found = nullptr;
+  for (const auto &mark : node["marks"]) {
+    if (!mark.is_object() || !mark.contains("type") || !mark["type"].is_string()) {
+      continue;
+    }
+    const auto &type = mark["type"].get_ref<const std::string &>();
+    if (type == typeA || (typeB != nullptr && type == typeB)) {
+      found = &mark;
+    }
+  }
+  return found;
+}
+
+std::shared_ptr<TiptapASTNode> wrap(NodeType type, std::shared_ptr<TiptapASTNode> child) {
+  auto node = makeNode(type);
+  node->addChild(std::move(child));
+  return node;
+}
+
+// Marks are flat on a Tiptap text node. Nest them in a fixed order so the
+// renderers see the same shape tiptap used to produce: code inside bold
+// inside italic inside strike inside underline inside highlight inside link.
+std::shared_ptr<TiptapASTNode> parseText(const json &node) {
+  auto text = makeNode(NodeType::Text);
+  text->content = textOf(node);
+  std::shared_ptr<TiptapASTNode> current = text;
+
+  if (markOfType(node, "code") != nullptr) {
+    current = wrap(NodeType::Code, std::move(current));
+  }
+  if (markOfType(node, "bold", "strong") != nullptr) {
+    current = wrap(NodeType::Strong, std::move(current));
+  }
+  if (markOfType(node, "italic", "em") != nullptr) {
+    current = wrap(NodeType::Emphasis, std::move(current));
+  }
+  if (markOfType(node, "strike", "strikethrough") != nullptr) {
+    current = wrap(NodeType::Strikethrough, std::move(current));
+  }
+  if (markOfType(node, "underline") != nullptr) {
+    current = wrap(NodeType::Underline, std::move(current));
+  }
+  if (markOfType(node, "highlight") != nullptr) {
+    current = wrap(NodeType::Highlight, std::move(current));
+  }
+  if (const json *link = markOfType(node, "link")) {
+    auto linked = makeNode(NodeType::Link);
+    if (link->contains("attrs") && (*link)["attrs"].is_object()) {
+      const auto &attrs = (*link)["attrs"];
+      if (attrs.contains("href") && attrs["href"].is_string()) {
+        linked->setAttribute("url", attrs["href"].get<std::string>());
+      }
+    }
+    linked->addChild(std::move(current));
+    current = std::move(linked);
+  }
+  return current;
+}
+
+void addChildren(TiptapASTNode &parent, const json &node) {
+  if (!node.contains("content") || !node["content"].is_array()) {
+    return;
+  }
+  for (const auto &child : node["content"]) {
+    if (auto parsed = parseNode(child)) {
+      parent.addChild(std::move(parsed));
+    }
+  }
+}
+
+int intAttr(const json &node, const char *key, int fallback) {
+  if (!node.contains("attrs") || !node["attrs"].is_object()) {
+    return fallback;
+  }
+  const auto &attrs = node["attrs"];
+  if (!attrs.contains(key)) {
+    return fallback;
+  }
+  const auto &value = attrs[key];
+  if (value.is_number_integer()) {
+    return value.get<int>();
+  }
+  if (value.is_number()) {
+    return static_cast<int>(value.get<double>());
+  }
+  return fallback;
+}
+
+void copyAttributes(TiptapASTNode &target, const json &node) {
+  if (!node.contains("attrs") || !node["attrs"].is_object()) {
+    return;
+  }
+  for (auto it = node["attrs"].begin(); it != node["attrs"].end(); ++it) {
+    const auto &value = it.value();
+    if (value.is_string()) {
+      target.setAttribute(it.key(), value.get<std::string>());
+    } else if (value.is_number_integer()) {
+      target.setAttribute(it.key(), std::to_string(value.get<long long>()));
+    } else if (value.is_boolean()) {
+      target.setAttribute(it.key(), value.get<bool>() ? "true" : "false");
+    }
+  }
+}
+
+std::string stringAttr(const json &node, const char *key) {
+  if (!node.contains("attrs") || !node["attrs"].is_object()) {
+    return "";
+  }
+  const auto &attrs = node["attrs"];
+  if (!attrs.contains(key) || !attrs[key].is_string()) {
+    return "";
+  }
+  return attrs[key].get<std::string>();
+}
+
+std::shared_ptr<TiptapASTNode> parseNode(const json &node) {
+  if (!isObject(node) || !node.contains("type") || !node["type"].is_string()) {
+    return nullptr;
+  }
+  const auto &type = node["type"].get_ref<const std::string &>();
+
+  if (type == "text") {
+    return parseText(node);
+  }
+  if (type == "hardBreak") {
+    return makeNode(NodeType::LineBreak);
+  }
+
+  std::shared_ptr<TiptapASTNode> parsed;
+  if (type == "doc") {
+    parsed = makeNode(NodeType::Document);
+  } else if (type == "paragraph") {
+    parsed = makeNode(NodeType::Paragraph);
+  } else if (type == "heading") {
+    parsed = makeNode(NodeType::Heading);
+    int level = intAttr(node, "level", 1);
+    if (level < 1) {
+      level = 1;
+    }
+    parsed->setAttribute("level", std::to_string(level));
+  } else if (type == "bulletList") {
+    parsed = makeNode(NodeType::UnorderedList);
+  } else if (type == "orderedList") {
+    parsed = makeNode(NodeType::OrderedList);
+    int start = intAttr(node, "start", 1);
+    if (start != 1) {
+      parsed->setAttribute("start", std::to_string(start));
+    }
+  } else if (type == "listItem") {
+    parsed = makeNode(NodeType::ListItem);
+  } else if (type == "blockquote") {
+    parsed = makeNode(NodeType::Blockquote);
+  } else if (type == "codeBlock") {
+    parsed = makeNode(NodeType::CodeBlock);
+    std::string language = stringAttr(node, "language");
+    if (!language.empty()) {
+      parsed->setAttribute("language", language);
+    }
+  } else if (type == "horizontalRule") {
+    parsed = makeNode(NodeType::ThematicBreak);
+  } else if (type == "factoid") {
+    // Inline node whose children are themselves inline (text, marks, links).
+    parsed = makeNode(NodeType::Factoid);
+    copyAttributes(*parsed, node);
+  } else if (type == "mention") {
+    // Atom. The visible text is "@" plus label, or id when label is blank.
+    parsed = makeNode(NodeType::Mention);
+    copyAttributes(*parsed, node);
+    return parsed;
+  } else {
+    // Tables, images, task lists, and anything else are skipped with their children.
+    return nullptr;
+  }
+
+  addChildren(*parsed, node);
+  return parsed;
+}
+
+} // namespace
+
+std::shared_ptr<TiptapASTNode> parseTiptapDocument(const std::string &jsonText) {
+  if (jsonText.empty()) {
+    return makeNode(NodeType::Document);
+  }
+  json parsed = json::parse(jsonText, nullptr, false);
+  if (parsed.is_discarded() || !parsed.is_object()) {
+    return makeNode(NodeType::Document);
+  }
+  auto root = parseNode(parsed);
+  if (!root) {
+    return makeNode(NodeType::Document);
+  }
+  if (root->type != NodeType::Document) {
+    auto document = makeNode(NodeType::Document);
+    document->addChild(std::move(root));
+    return document;
+  }
+  return root;
+}
+
+} // namespace Tiptap

package/cpp/parser/TiptapParser.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "TiptapASTNode.hpp"
+#include <memory>
+#include <string>
+
+namespace Tiptap {
+
+// Parses a Tiptap document JSON string into the display AST.
+// Unknown nodes and marks are skipped. Invalid JSON yields an empty document.
+std::shared_ptr<TiptapASTNode> parseTiptapDocument(const std::string &json);
+
+} // namespace Tiptap