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

package/android/src/main/java/com/jetmarkdown/views/BoxDrawing.kt

@@ -0,0 +1,50 @@
+package com.jetmarkdown.views
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.RectF
+import com.jetmarkdown.style.LayoutStyleSpec
+
+/** Shared background + per-side border painting for block containers. */
+object BoxDrawing {
+  private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+
+  fun draw(canvas: Canvas, style: LayoutStyleSpec, width: Float, height: Float) {
+    if (style.backgroundColor != null) {
+      paint.style = Paint.Style.FILL
+      paint.color = style.backgroundColor
+      canvas.drawRoundRect(
+        RectF(0f, 0f, width, height),
+        style.borderRadius,
+        style.borderRadius,
+        paint,
+      )
+    }
+    paint.style = Paint.Style.FILL
+    if (style.borderLeftWidth > 0 && style.borderLeftColor != null) {
+      paint.color = style.borderLeftColor
+      if (style.borderRadius > 0) {
+        canvas.drawRoundRect(
+          RectF(0f, 0f, style.borderLeftWidth, height),
+          style.borderRadius / 2,
+          style.borderRadius / 2,
+          paint,
+        )
+      } else {
+        canvas.drawRect(0f, 0f, style.borderLeftWidth, height, paint)
+      }
+    }
+    if (style.borderRightWidth > 0 && style.borderRightColor != null) {
+      paint.color = style.borderRightColor
+      canvas.drawRect(width - style.borderRightWidth, 0f, width, height, paint)
+    }
+    if (style.borderTopWidth > 0 && style.borderTopColor != null) {
+      paint.color = style.borderTopColor
+      canvas.drawRect(0f, 0f, width, style.borderTopWidth, paint)
+    }
+    if (style.borderBottomWidth > 0 && style.borderBottomColor != null) {
+      paint.color = style.borderBottomColor
+      canvas.drawRect(0f, height - style.borderBottomWidth, width, height, paint)
+    }
+  }
+}

package/android/src/main/java/com/jetmarkdown/views/MarkdownHost.kt

@@ -0,0 +1,12 @@
+package com.jetmarkdown.views
+
+/** Callbacks from block views up to the host component view. */
+interface MarkdownHost {
+  fun onImageIntrinsicSize(url: String, widthDp: Float, heightDp: Float)
+  fun isSpoilerRevealed(id: Int): Boolean
+  fun toggleSpoiler(id: Int)
+  fun onLinkPress(url: String)
+  fun onLinkLongPress(url: String)
+  /** Position and size describe the pressed image in screen coordinates, dp. */
+  fun onImagePress(url: String, xDp: Float, yDp: Float, widthDp: Float, heightDp: Float)
+}

package/android/src/main/java/com/jetmarkdown/views/MarkdownImageView.kt

@@ -0,0 +1,113 @@
+package com.jetmarkdown.views
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import android.widget.ImageView
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.DataSource
+import com.bumptech.glide.load.engine.GlideException
+import com.bumptech.glide.request.RequestListener
+import com.bumptech.glide.request.target.Target
+import com.jetmarkdown.render.Block
+
+/**
+ * One markdown image, loaded through Glide: animated GIF playback,
+ * downsampling, memory + disk caches, in-flight request sharing, and
+ * cancellation when the view is rebound. Background shows while loading
+ * (and stays for broken URLs); rounded corners clip both.
+ */
+@SuppressLint("AppCompatCustomView")
+class MarkdownImageView(context: Context) : ImageView(context) {
+  private var block: Block.Image? = null
+  private val clipPath = Path()
+
+  var host: MarkdownHost? = null
+
+  init {
+    scaleType = ScaleType.FIT_CENTER
+    setOnClickListener {
+      block?.let { image ->
+        val density = resources.displayMetrics.density
+        val location = IntArray(2)
+        getLocationOnScreen(location)
+        host?.onImagePress(
+          image.url,
+          location[0] / density,
+          location[1] / density,
+          width / density,
+          height / density,
+        )
+      }
+    }
+  }
+
+  fun bind(image: Block.Image) {
+    block = image
+    // Application context: requests outlive transient view detaches during
+    // list recycling and are replaced (cancelling the old one) on rebind.
+    Glide.with(context.applicationContext)
+      .load(image.url.ifEmpty { null })
+      .listener(object : RequestListener<Drawable> {
+        override fun onLoadFailed(
+          e: GlideException?,
+          model: Any?,
+          target: Target<Drawable>,
+          isFirstResource: Boolean,
+        ): Boolean = false
+
+        override fun onResourceReady(
+          resource: Drawable,
+          model: Any,
+          target: Target<Drawable>?,
+          dataSource: DataSource,
+          isFirstResource: Boolean,
+        ): Boolean {
+          if (block?.url == image.url) {
+            // Image pixels map 1:1 to dp (web semantics); reported for
+            // cache hits too so a fresh view still resizes un-presized
+            // images.
+            host?.onImageIntrinsicSize(
+              image.url,
+              resource.intrinsicWidth.toFloat(),
+              resource.intrinsicHeight.toFloat(),
+            )
+          }
+          return false
+        }
+      })
+      .into(this)
+    invalidate()
+  }
+
+  /**
+   * Discard hook (views are recreated wholesale on rebind): stops the
+   * in-flight request from delivering into a recycled host and frees GIF
+   * buffers early. Transient detaches during scrolling must NOT clear —
+   * this is only called when the parent drops the view for good.
+   */
+  fun unbind() {
+    host = null
+    block = null
+    Glide.with(context.applicationContext).clear(this)
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    val image = block ?: return
+    if (image.borderRadiusPx > 0) {
+      clipPath.reset()
+      clipPath.addRoundRect(
+        RectF(0f, 0f, width.toFloat(), height.toFloat()),
+        image.borderRadiusPx,
+        image.borderRadiusPx,
+        Path.Direction.CW,
+      )
+      canvas.clipPath(clipPath)
+    }
+    image.backgroundColor?.let { canvas.drawColor(it) }
+    super.onDraw(canvas)
+  }
+}

package/android/src/main/java/com/jetmarkdown/views/NestedHorizontalScrollView.kt

@@ -0,0 +1,87 @@
+package com.jetmarkdown.views
+
+import android.content.Context
+import android.view.MotionEvent
+import android.view.ViewConfiguration
+import android.widget.HorizontalScrollView
+import com.facebook.react.uimanager.events.NativeGestureUtil
+import kotlin.math.abs
+
+/**
+ * Horizontal scroller for code blocks and tables.
+ *
+ * Two problems to solve, both because this is not a React view:
+ * 1. Once a wrapping RN Pressable becomes the JS responder, Fabric's
+ *    JSResponderHandler makes that view intercept every non-UP event, which
+ *    cancels this scroller's stream (~40ms after DOWN). Guard against it by
+ *    disallowing ancestor interception while a touch may become a horizontal
+ *    drag, then hand the gesture back the moment it proves vertical so the
+ *    outer list still pans.
+ * 2. Nothing cancels the JS responder (the Pressable press) when this view
+ *    takes the drag — notify the React root like ReactHorizontalScrollView
+ *    does, so onPress does not fire after a scroll.
+ */
+class NestedHorizontalScrollView(context: Context) : HorizontalScrollView(context) {
+  private var downX = 0f
+  private var downY = 0f
+  private var notified = false
+  private var directionLocked = false
+
+  private fun hasOverflow(): Boolean =
+    canScrollHorizontally(1) || canScrollHorizontally(-1)
+
+  private fun onDown(ev: MotionEvent) {
+    downX = ev.x
+    downY = ev.y
+    notified = false
+    directionLocked = false
+    if (hasOverflow()) {
+      parent?.requestDisallowInterceptTouchEvent(true)
+    }
+  }
+
+  private fun onMove(ev: MotionEvent) {
+    if (directionLocked) {
+      return
+    }
+    val dx = abs(ev.x - downX)
+    val dy = abs(ev.y - downY)
+    val slop = ViewConfiguration.get(context).scaledTouchSlop
+    if (dx > slop || dy > slop) {
+      directionLocked = true
+      if (dy > dx) {
+        // Vertical drag: let the outer list intercept and pan.
+        parent?.requestDisallowInterceptTouchEvent(false)
+      } else {
+        notifyGestureStarted(ev)
+      }
+    }
+  }
+
+  override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+    if (ev.actionMasked == MotionEvent.ACTION_DOWN) {
+      onDown(ev)
+    }
+    if (super.onInterceptTouchEvent(ev)) {
+      notifyGestureStarted(ev)
+      return true
+    }
+    return false
+  }
+
+  override fun onTouchEvent(ev: MotionEvent): Boolean {
+    when (ev.actionMasked) {
+      MotionEvent.ACTION_MOVE -> onMove(ev)
+      MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL ->
+        parent?.requestDisallowInterceptTouchEvent(false)
+    }
+    return super.onTouchEvent(ev)
+  }
+
+  private fun notifyGestureStarted(ev: MotionEvent) {
+    if (!notified) {
+      notified = true
+      NativeGestureUtil.notifyNativeGestureStarted(this, ev)
+    }
+  }
+}

package/android/src/main/java/com/jetmarkdown/views/TableBlockView.kt

@@ -0,0 +1,139 @@
+package com.jetmarkdown.views
+
+import android.content.Context
+import android.graphics.Canvas
+import android.view.ViewGroup
+import com.jetmarkdown.render.Block
+import com.jetmarkdown.render.MeasuredBlock
+
+/**
+ * Table: paints the table box, hosts a grid in a horizontal scroller so
+ * wide tables keep readable column widths.
+ */
+class TableBlockView(context: Context) : ViewGroup(context) {
+  private var measured: MeasuredBlock? = null
+  private var block: Block.Table? = null
+  private val scroller = NestedHorizontalScrollView(context).apply {
+    isHorizontalScrollBarEnabled = false
+    overScrollMode = OVER_SCROLL_NEVER
+  }
+  private val grid = TableGridView(context)
+
+  init {
+    setWillNotDraw(false)
+    scroller.addView(grid)
+    addView(scroller)
+  }
+
+  fun bind(measuredBlock: MeasuredBlock, table: Block.Table, host: MarkdownHost? = null) {
+    measured = measuredBlock
+    block = table
+    grid.bind(measuredBlock, table, host)
+    invalidate()
+    requestLayout()
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    block?.let { BoxDrawing.draw(canvas, it.style, width.toFloat(), height.toFloat()) }
+  }
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    setMeasuredDimension(
+      MeasureSpec.getSize(widthMeasureSpec),
+      MeasureSpec.getSize(heightMeasureSpec),
+    )
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    val style = block?.style ?: return
+    val tree = measured ?: return
+    val left = (style.borderLeftWidth + style.paddingLeft).toInt()
+    val top = (style.borderTopWidth + style.paddingTop).toInt()
+    val right = (r - l) - (style.borderRightWidth + style.paddingRight).toInt()
+    val gridHeight = tree.rowHeights.sum().toInt()
+
+    scroller.measure(
+      MeasureSpec.makeMeasureSpec(right - left, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(gridHeight, MeasureSpec.EXACTLY),
+    )
+    scroller.layout(left, top, right, top + gridHeight)
+  }
+
+  override fun shouldDelayChildPressedState(): Boolean = false
+}
+
+/** The unclipped grid inside the scroller: row boxes + cell text. */
+class TableGridView(context: Context) : ViewGroup(context) {
+  private var measured: MeasuredBlock? = null
+  private var block: Block.Table? = null
+
+  init {
+    setWillNotDraw(false)
+  }
+
+  fun bind(measuredBlock: MeasuredBlock, table: Block.Table, host: MarkdownHost? = null) {
+    measured = measuredBlock
+    block = table
+    removeAllViews()
+    for (row in measuredBlock.cellLayouts) {
+      for (cell in row) {
+        addView(BlockTextView(context).apply {
+          this.host = host
+          setTextLayout(cell)
+        })
+      }
+    }
+    invalidate()
+    requestLayout()
+  }
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    val tree = measured
+    setMeasuredDimension(
+      tree?.contentWidthPx?.toInt() ?: 0,
+      tree?.rowHeights?.sum()?.toInt() ?: 0,
+    )
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    val table = block ?: return
+    val tree = measured ?: return
+    val width = tree.contentWidthPx
+    var y = 0f
+    tree.rowHeights.forEachIndexed { rowIndex, rowHeight ->
+      val isHeader = table.rows.getOrNull(rowIndex)?.isHeader == true
+      canvas.save()
+      canvas.translate(0f, y)
+      BoxDrawing.draw(canvas, table.rowStyle(isHeader), width, rowHeight)
+      canvas.restore()
+      y += rowHeight
+    }
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    val table = block ?: return
+    val tree = measured ?: return
+
+    var index = 0
+    var y = 0f
+    tree.cellLayouts.forEachIndexed { rowIndex, row ->
+      var x = 0f
+      val isHeader = table.rows.getOrNull(rowIndex)?.isHeader == true
+      row.forEachIndexed { column, cell ->
+        val child = getChildAt(index++) ?: return@forEachIndexed
+        val cellLeft = (x + table.padLeft(isHeader)).toInt()
+        val cellTop =
+          (y + table.padTop(isHeader) + table.rowStyle(isHeader).borderTopWidth).toInt()
+        child.measure(
+          MeasureSpec.makeMeasureSpec(cell.width, MeasureSpec.EXACTLY),
+          MeasureSpec.makeMeasureSpec(cell.height, MeasureSpec.EXACTLY),
+        )
+        child.layout(cellLeft, cellTop, cellLeft + cell.width, cellTop + cell.height)
+        x += tree.columnWidths[column]
+      }
+      y += tree.rowHeights[rowIndex]
+    }
+  }
+
+  override fun shouldDelayChildPressedState(): Boolean = false
+}

package/cpp/core/Ast.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace jetmarkdown {
+
+enum class NodeType : uint8_t {
+  Document = 0,
+  Heading = 1,
+  Paragraph = 2,
+  BlockQuote = 3,
+  CodeBlock = 4,
+  List = 5,
+  ListItem = 6,
+  Table = 7,
+  TableRow = 8,
+  TableCell = 9,
+  Image = 10,
+  ThematicBreak = 11,
+  Text = 12,
+  SoftBreak = 13,
+  HardBreak = 14,
+  Bold = 15,
+  Italic = 16,
+  Strikethrough = 17,
+  Link = 18,
+  InlineCode = 19,
+  Spoiler = 20,
+  Superscript = 21,
+  Subscript = 22,
+};
+
+enum class CellAlign : uint8_t {
+  Default = 0,
+  Left = 1,
+  Center = 2,
+  Right = 3,
+};
+
+// Node field usage by type:
+//   Text:       text = content
+//   Image:      text = alt text, url = source
+//   CodeBlock:  text = code content, url = info string (language)
+//   InlineCode: text = content
+//   Link:       url = destination, children = label
+//   Heading:    level = 1..6
+//   List:       ordered, startIndex
+//   TableRow:   level = 1 when header row
+//   TableCell:  level = CellAlign
+struct Node {
+  NodeType type = NodeType::Document;
+  std::string text;
+  std::string url;
+  uint8_t level = 0;
+  bool ordered = false;
+  // Text nodes born from character escapes/entities. The inline-extension
+  // scanner must not read delimiters out of them (the author explicitly
+  // de-fanged the characters), so they never merge with neighbours.
+  bool verbatim = false;
+  int32_t startIndex = 1;
+  std::vector<Node*> children;
+};
+
+// Owns every node of one parsed document; nodes are freed together.
+class AstArena {
+ public:
+  Node* alloc(NodeType type) {
+    nodes_.push_back(std::make_unique<Node>());
+    nodes_.back()->type = type;
+    return nodes_.back().get();
+  }
+
+ private:
+  std::vector<std::unique_ptr<Node>> nodes_;
+};
+
+struct MarkdownDocument {
+  AstArena arena;
+  Node* root = nullptr;
+};
+
+} // namespace jetmarkdown

package/cpp/core/AstJson.cpp

@@ -0,0 +1,129 @@
+#include "AstJson.h"
+
+#include <cstdio>
+
+namespace jetmarkdown {
+
+namespace {
+
+const char* typeName(NodeType type) {
+  switch (type) {
+    case NodeType::Document: return "document";
+    case NodeType::Heading: return "heading";
+    case NodeType::Paragraph: return "paragraph";
+    case NodeType::BlockQuote: return "blockQuote";
+    case NodeType::CodeBlock: return "codeBlock";
+    case NodeType::List: return "list";
+    case NodeType::ListItem: return "listItem";
+    case NodeType::Table: return "table";
+    case NodeType::TableRow: return "tableRow";
+    case NodeType::TableCell: return "tableCell";
+    case NodeType::Image: return "image";
+    case NodeType::ThematicBreak: return "thematicBreak";
+    case NodeType::Text: return "text";
+    case NodeType::SoftBreak: return "softBreak";
+    case NodeType::HardBreak: return "hardBreak";
+    case NodeType::Bold: return "bold";
+    case NodeType::Italic: return "italic";
+    case NodeType::Strikethrough: return "strikethrough";
+    case NodeType::Link: return "link";
+    case NodeType::InlineCode: return "inlineCode";
+    case NodeType::Spoiler: return "spoiler";
+    case NodeType::Superscript: return "superscript";
+    case NodeType::Subscript: return "subscript";
+  }
+  return "unknown";
+}
+
+void appendEscaped(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 buf[8];
+          std::snprintf(buf, sizeof(buf), "\\u%04x", c);
+          out += buf;
+        } else {
+          out += c;
+        }
+        break;
+    }
+  }
+}
+
+void write(std::string& out, const Node* node) {
+  out += "{\"type\":\"";
+  out += typeName(node->type);
+  out += '"';
+  if (!node->text.empty()) {
+    out += ",\"text\":\"";
+    appendEscaped(out, node->text);
+    out += '"';
+  }
+  if (!node->url.empty()) {
+    out += ",\"url\":\"";
+    appendEscaped(out, node->url);
+    out += '"';
+  }
+  if (node->level != 0) {
+    out += ",\"level\":";
+    out += std::to_string(node->level);
+  }
+  if (node->type == NodeType::List) {
+    out += ",\"ordered\":";
+    out += node->ordered ? "true" : "false";
+    if (node->ordered && node->startIndex != 1) {
+      out += ",\"start\":";
+      out += std::to_string(node->startIndex);
+    }
+  }
+  if (!node->children.empty()) {
+    out += ",\"children\":[";
+    bool first = true;
+    for (size_t i = 0; i < node->children.size(); i++) {
+      // Adjacent text nodes dump as one: verbatim (entity-born) nodes are a
+      // scanner-facing distinction, not a content one, and tests compare
+      // content.
+      if (node->children[i]->type == NodeType::Text) {
+        std::string merged = node->children[i]->text;
+        while (i + 1 < node->children.size() &&
+               node->children[i + 1]->type == NodeType::Text) {
+          merged += node->children[i + 1]->text;
+          i++;
+        }
+        if (!first) {
+          out += ',';
+        }
+        first = false;
+        out += "{\"type\":\"text\",\"text\":\"";
+        appendEscaped(out, merged);
+        out += "\"}";
+        continue;
+      }
+      if (!first) {
+        out += ',';
+      }
+      first = false;
+      write(out, node->children[i]);
+    }
+    out += ']';
+  }
+  out += '}';
+}
+
+} // namespace
+
+std::string astToJson(const Node* node) {
+  std::string out;
+  if (node != nullptr) {
+    write(out, node);
+  }
+  return out;
+}
+
+} // namespace jetmarkdown

package/cpp/core/AstJson.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+
+#include "Ast.h"
+
+namespace jetmarkdown {
+
+// Compact JSON rendering of the AST for golden tests and debugging.
+std::string astToJson(const Node* node);
+
+} // namespace jetmarkdown

package/cpp/core/AstSerializer.cpp

@@ -0,0 +1,40 @@
+#include "AstSerializer.h"
+
+namespace jetmarkdown {
+
+namespace {
+
+void writeU32(std::vector<uint8_t>& out, uint32_t value) {
+  out.push_back(static_cast<uint8_t>(value & 0xFF));
+  out.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
+  out.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
+  out.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
+}
+
+void writeNode(std::vector<uint8_t>& out, const Node* node) {
+  out.push_back(static_cast<uint8_t>(node->type));
+  out.push_back(node->level);
+  out.push_back(node->ordered ? 1 : 0);
+  writeU32(out, static_cast<uint32_t>(node->startIndex));
+  writeU32(out, static_cast<uint32_t>(node->text.size()));
+  out.insert(out.end(), node->text.begin(), node->text.end());
+  writeU32(out, static_cast<uint32_t>(node->url.size()));
+  out.insert(out.end(), node->url.begin(), node->url.end());
+  writeU32(out, static_cast<uint32_t>(node->children.size()));
+  for (const Node* child : node->children) {
+    writeNode(out, child);
+  }
+}
+
+} // namespace
+
+std::vector<uint8_t> serializeAst(const Node* root) {
+  std::vector<uint8_t> out;
+  if (root != nullptr) {
+    out.reserve(1024);
+    writeNode(out, root);
+  }
+  return out;
+}
+
+} // namespace jetmarkdown

package/cpp/core/AstSerializer.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "Ast.h"
+
+namespace jetmarkdown {
+
+// Flat little-endian pre-order encoding, decoded by AstDecoder.kt on Android.
+// Per node:
+//   u8  type
+//   u8  level
+//   u8  flags        (bit 0: ordered)
+//   i32 startIndex
+//   u32 textLen, textLen bytes (UTF-8)
+//   u32 urlLen,  urlLen bytes (UTF-8)
+//   u32 childCount, then children recursively
+std::vector<uint8_t> serializeAst(const Node* root);
+
+} // namespace jetmarkdown