react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/cpp/highlight/vendor/generated/generated_registry.cpp

@@ -0,0 +1,59 @@
+// Generated by vendor/gen-registry.mjs. Do not edit.
+
+#include "HighlightGrammars.hpp"
+#include "generated_queries.h"
+
+#include <cstring>
+
+extern "C" {
+const TSLanguage *tree_sitter_json(void);
+const TSLanguage *tree_sitter_html(void);
+const TSLanguage *tree_sitter_css(void);
+const TSLanguage *tree_sitter_markdown(void);
+const TSLanguage *tree_sitter_yaml(void);
+const TSLanguage *tree_sitter_go(void);
+const TSLanguage *tree_sitter_java(void);
+const TSLanguage *tree_sitter_javascript(void);
+const TSLanguage *tree_sitter_python(void);
+const TSLanguage *tree_sitter_c(void);
+const TSLanguage *tree_sitter_rust(void);
+const TSLanguage *tree_sitter_bash(void);
+const TSLanguage *tree_sitter_typescript(void);
+const TSLanguage *tree_sitter_tsx(void);
+}
+
+namespace Markdown {
+namespace {
+
+constexpr GrammarEntry kGrammars[] = {
+    {"json", tree_sitter_json, kHighlightsQuery_json},
+    {"html", tree_sitter_html, kHighlightsQuery_html},
+    {"css", tree_sitter_css, kHighlightsQuery_css},
+    {"markdown", tree_sitter_markdown, kHighlightsQuery_markdown},
+    {"yaml", tree_sitter_yaml, kHighlightsQuery_yaml},
+    {"go", tree_sitter_go, kHighlightsQuery_go},
+    {"java", tree_sitter_java, kHighlightsQuery_java},
+    {"javascript", tree_sitter_javascript, kHighlightsQuery_javascript},
+    {"python", tree_sitter_python, kHighlightsQuery_python},
+    {"c", tree_sitter_c, kHighlightsQuery_c},
+    {"rust", tree_sitter_rust, kHighlightsQuery_rust},
+    {"bash", tree_sitter_bash, kHighlightsQuery_bash},
+    {"typescript", tree_sitter_typescript, kHighlightsQuery_typescript},
+    {"tsx", tree_sitter_tsx, kHighlightsQuery_tsx},
+};
+
+} // namespace
+
+const GrammarEntry *findGrammar(const char *canonicalId) {
+  if (canonicalId == nullptr) {
+    return nullptr;
+  }
+  for (const GrammarEntry &entry : kGrammars) {
+    if (std::strcmp(entry.canonicalId, canonicalId) == 0) {
+      return &entry;
+    }
+  }
+  return nullptr;
+}
+
+} // namespace Markdown

package/cpp/parser/MD4CParser.cpp

@@ -19,6 +19,7 @@ public:
   static const std::string ATTR_LANGUAGE;
   static const std::string ATTR_IS_TASK;
   static const std::string ATTR_TASK_CHECKED;
+  static const std::string ATTR_START;
 
   void reset(size_t estimatedDepth) {
     root = std::make_shared<MarkdownASTNode>(NodeType::Document);
@@ -114,7 +115,14 @@ public:
       }
 
       case MD_BLOCK_OL: {
-        impl->pushNode(std::make_shared<MarkdownASTNode>(NodeType::OrderedList));
+        auto node = std::make_shared<MarkdownASTNode>(NodeType::OrderedList);
+        if (detail) {
+          auto *ol = static_cast<MD_BLOCK_OL_DETAIL *>(detail);
+          if (ol->start != 1) {
+            node->setAttribute(ATTR_START, std::to_string(ol->start));
+          }
+        }
+        impl->pushNode(node);
         break;
       }
 
@@ -346,10 +354,13 @@ public:
       return 0;
     auto *impl = static_cast<Impl *>(userdata);
 
-    // Handle soft/hard line breaks
-    if (type == MD_TEXT_SOFTBR || type == MD_TEXT_BR) {
-      auto brNode = std::make_shared<MarkdownASTNode>(NodeType::LineBreak);
-      impl->addInlineNode(brNode);
+    if (type == MD_TEXT_SOFTBR) {
+      impl->addInlineNode(std::make_shared<MarkdownASTNode>(NodeType::SoftBreak));
+      return 0;
+    }
+
+    if (type == MD_TEXT_BR) {
+      impl->addInlineNode(std::make_shared<MarkdownASTNode>(NodeType::LineBreak));
       return 0;
     }
 
@@ -364,63 +375,89 @@ public:
 
 namespace {
 
+using NodeList = std::vector<std::shared_ptr<MarkdownASTNode>>;
+
 bool isDisplayMathNode(const MarkdownASTNode &node) {
   return node.type == NodeType::LatexMathDisplay;
 }
 
 bool isSeparatorNode(const MarkdownASTNode &node) {
-  return node.type == NodeType::LineBreak ||
+  return node.type == NodeType::LineBreak || node.type == NodeType::SoftBreak ||
          (node.type == NodeType::Text && node.content.find_first_not_of(" \t\n\r") == std::string::npos);
 }
 
-// md4c treats $$...$$ as an inline span, so when display math appears on a line
-// directly after text (no blank line), md4c merges them into a single Paragraph.
-// This function finds the trailing run of LatexMathDisplay nodes (possibly
-// interspersed with LineBreak / whitespace separators) at the end of a paragraph's
-// children. Returns the index where the trailing run starts, or children.size()
-// if there is nothing to promote.
-size_t findTrailingDisplayMathRun(const std::vector<std::shared_ptr<MarkdownASTNode>> &children) {
-  size_t trailingRunStart = children.size();
-  bool hasDisplayMath = false;
-
-  for (size_t j = children.size(); j > 0; --j) {
-    auto &node = children[j - 1];
-    if (isDisplayMathNode(*node)) {
-      trailingRunStart = j - 1;
-      hasDisplayMath = true;
-    } else if (isSeparatorNode(*node) && hasDisplayMath) {
-      trailingRunStart = j - 1;
-    } else {
+// A display-math node is "isolated" — i.e. block-level — when at least one of its
+// neighbours is a boundary: the paragraph edge, or a separator (LineBreak / blank
+// text). Display math flanked by real text on BOTH sides (e.g. `a $$x$$ b`) is
+// genuinely inline and is left in place.
+bool isIsolatedDisplayMath(const std::vector<std::shared_ptr<MarkdownASTNode>> &children, size_t i) {
+  if (!isDisplayMathNode(*children[i]))
+    return false;
+  bool leftBoundary = (i == 0) || isSeparatorNode(*children[i - 1]);
+  bool rightBoundary = (i + 1 >= children.size()) || isSeparatorNode(*children[i + 1]);
+  return leftBoundary || rightBoundary;
+}
+
+// md4c parses $$...$$ as an inline span, so display math always lands nested inside a
+// Paragraph — even when it sits on its own line, and even in the middle of a paragraph
+// (text on lines before and after it, with no blank separator).
+//
+// This rebuilds such a paragraph into a sequence of top-level siblings so the rendering
+// layer sees isolated display math as a block: each run of inline content becomes its own
+// Paragraph, and each isolated display-math node becomes a bare LatexMathDisplay sibling.
+// Separators bordering a promoted node are dropped. Returns an empty vector when the
+// paragraph has no promotable display math, signalling the caller to leave it untouched.
+//
+// This subsumes the earlier trailing-only behaviour: pure (`$$x$$`), trailing
+// (`text\n$$x$$`) and leading (`$$x$$\ntext`) are all just special cases of the general
+// interior split.
+std::vector<std::shared_ptr<MarkdownASTNode>>
+splitParagraphAroundDisplayMath(const std::vector<std::shared_ptr<MarkdownASTNode>> &children) {
+  bool anyPromotion = false;
+  for (size_t i = 0; i < children.size(); ++i) {
+    if (isIsolatedDisplayMath(children, i)) {
+      anyPromotion = true;
       break;
     }
   }
+  if (!anyPromotion)
+    return {};
 
-  return hasDisplayMath ? trailingRunStart : children.size();
-}
-
-// Collect only the LatexMathDisplay nodes from a range, skipping separators.
-std::vector<std::shared_ptr<MarkdownASTNode>>
-collectDisplayMathNodes(const std::vector<std::shared_ptr<MarkdownASTNode>> &children, size_t from) {
   std::vector<std::shared_ptr<MarkdownASTNode>> result;
-  for (size_t j = from; j < children.size(); ++j) {
-    if (isDisplayMathNode(*children[j]))
-      result.push_back(children[j]);
+  std::vector<std::shared_ptr<MarkdownASTNode>> inlineRun;
+
+  auto flushInlineRun = [&]() {
+    // Trim separators left dangling against the promoted math on either side.
+    size_t start = 0;
+    size_t end = inlineRun.size();
+    while (start < end && isSeparatorNode(*inlineRun[start]))
+      ++start;
+    while (end > start && isSeparatorNode(*inlineRun[end - 1]))
+      --end;
+    if (start < end) {
+      auto paragraph = std::make_shared<MarkdownASTNode>(NodeType::Paragraph);
+      paragraph->children.assign(inlineRun.begin() + static_cast<NodeList::difference_type>(start),
+                                 inlineRun.begin() + static_cast<NodeList::difference_type>(end));
+      result.push_back(std::move(paragraph));
+    }
+    inlineRun.clear();
+  };
+
+  for (size_t i = 0; i < children.size(); ++i) {
+    if (isIsolatedDisplayMath(children, i)) {
+      flushInlineRun();
+      result.push_back(children[i]);
+    } else {
+      inlineRun.push_back(children[i]);
+    }
   }
+  flushInlineRun();
+
   return result;
 }
 
-// md4c wraps $$...$$ (display math) as inline spans inside a Paragraph. When they
-// appear on consecutive lines without a blank separator, md4c merges them — along
-// with any preceding text — into a single Paragraph with LineBreak nodes between them.
-//
-// This post-processing step walks the document's top-level children and promotes
-// trailing LatexMathDisplay nodes out of their parent Paragraph so that the
-// rendering layer sees them as top-level block elements.
-//
-// Two cases:
-//  (a) Pure: every child is display math or a separator → replace paragraph entirely.
-//  (b) Mixed: leading text followed by display math → keep text in the paragraph,
-//      splice the display math nodes as siblings after it.
+// Walk the document's top-level children and promote isolated display math out of its
+// parent Paragraph so the rendering layer sees it as a top-level block element.
 void promoteDisplayMathFromParagraphs(MarkdownASTNode &root) {
   auto &children = root.children;
 
@@ -431,31 +468,101 @@ void promoteDisplayMathFromParagraphs(MarkdownASTNode &root) {
       continue;
     }
 
-    auto &paragraphChildren = paragraph->children;
-    size_t trailingRunStart = findTrailingDisplayMathRun(paragraphChildren);
-
-    if (trailingRunStart >= paragraphChildren.size()) {
+    auto replacement = splitParagraphAroundDisplayMath(paragraph->children);
+    if (replacement.empty()) {
       ++i;
       continue;
     }
 
-    auto promoted = collectDisplayMathNodes(paragraphChildren, trailingRunStart);
+    auto position = children.erase(children.begin() + static_cast<NodeList::difference_type>(i));
+    children.insert(position, replacement.begin(), replacement.end());
+    i += replacement.size();
+  }
+}
+
+bool isBlockNode(const MarkdownASTNode &node) {
+  switch (node.type) {
+    case NodeType::Document:
+    case NodeType::Paragraph:
+    case NodeType::Heading:
+    case NodeType::Blockquote:
+    case NodeType::UnorderedList:
+    case NodeType::OrderedList:
+    case NodeType::ListItem:
+    case NodeType::CodeBlock:
+    case NodeType::ThematicBreak:
+    case NodeType::LatexMathDisplay:
+    case NodeType::Table:
+    case NodeType::TableHead:
+    case NodeType::TableBody:
+    case NodeType::TableRow:
+    case NodeType::TableHeaderCell:
+    case NodeType::TableCell:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// md4c omits Paragraph wrappers around the inline content of tight list items.
+// Wrap each run of consecutive inline children of a ListItem in a synthetic
+// Paragraph (marked "tight") so renderers only ever see block children.
+void wrapListItemInlineRuns(MarkdownASTNode &node) {
+  for (auto &child : node.children) {
+    wrapListItemInlineRuns(*child);
+  }
+
+  if (node.type != NodeType::ListItem)
+    return;
 
-    if (trailingRunStart == 0) {
-      auto position = children.erase(children.begin() + static_cast<ptrdiff_t>(i));
-      children.insert(position, promoted.begin(), promoted.end());
-      i += promoted.size();
+  bool hasInlineChild = false;
+  for (auto &child : node.children) {
+    if (!isBlockNode(*child)) {
+      hasInlineChild = true;
+      break;
+    }
+  }
+  if (!hasInlineChild)
+    return;
+
+  std::vector<std::shared_ptr<MarkdownASTNode>> newChildren;
+  newChildren.reserve(node.children.size());
+  std::vector<std::shared_ptr<MarkdownASTNode>> run;
+
+  auto flushRun = [&]() {
+    if (run.empty())
+      return;
+    bool hasContent = false;
+    for (auto &n : run) {
+      if (!isSeparatorNode(*n)) {
+        hasContent = true;
+        break;
+      }
+    }
+    if (hasContent) {
+      auto paragraph = std::make_shared<MarkdownASTNode>(NodeType::Paragraph);
+      paragraph->setAttribute("tight", "true");
+      paragraph->children = std::move(run);
+      newChildren.push_back(std::move(paragraph));
     } else {
-      paragraphChildren.erase(paragraphChildren.begin() + static_cast<ptrdiff_t>(trailingRunStart),
-                              paragraphChildren.end());
-      while (!paragraphChildren.empty() && isSeparatorNode(*paragraphChildren.back())) {
-        paragraphChildren.pop_back();
+      // Whitespace-only run between blocks — keep as-is, a paragraph would add spacing.
+      for (auto &n : run) {
+        newChildren.push_back(std::move(n));
       }
-      auto position = children.begin() + static_cast<ptrdiff_t>(i) + 1;
-      children.insert(position, promoted.begin(), promoted.end());
-      i += 1 + promoted.size();
+    }
+    run.clear();
+  };
+
+  for (auto &child : node.children) {
+    if (isBlockNode(*child)) {
+      flushRun();
+      newChildren.push_back(std::move(child));
+    } else {
+      run.push_back(std::move(child));
     }
   }
+  flushRun();
+  node.children = std::move(newChildren);
 }
 
 } // anonymous namespace
@@ -501,6 +608,9 @@ std::shared_ptr<MarkdownASTNode> MD4CParser::parse(const std::string &markdown,
   if (md4cFlags.highlight) {
     flags |= MD_FLAG_HIGHLIGHT;
   }
+  if (md4cFlags.hardSoftBreaks) {
+    flags |= MD_FLAG_HARD_SOFT_BREAKS;
+  }
 
   // Configure MD4C parser with callbacks
   MD_PARSER parser = {
@@ -522,6 +632,7 @@ std::shared_ptr<MarkdownASTNode> MD4CParser::parse(const std::string &markdown,
 
   if (impl_->root) {
     promoteDisplayMathFromParagraphs(*impl_->root);
+    wrapListItemInlineRuns(*impl_->root);
   }
 
   return impl_->root ? impl_->root : std::make_shared<MarkdownASTNode>(NodeType::Document);
@@ -535,5 +646,6 @@ const std::string MD4CParser::Impl::ATTR_FENCE_CHAR = "fenceChar";
 const std::string MD4CParser::Impl::ATTR_LANGUAGE = "language";
 const std::string MD4CParser::Impl::ATTR_IS_TASK = "isTask";
 const std::string MD4CParser::Impl::ATTR_TASK_CHECKED = "taskChecked";
+const std::string MD4CParser::Impl::ATTR_START = "start";
 
 } // namespace Markdown

package/cpp/parser/MD4CParser.hpp

@@ -13,6 +13,7 @@ struct Md4cFlags {
     bool subscript = false;
     bool highlight = false;
     bool permissiveAutolinks = true;
+    bool hardSoftBreaks = false;
 };
 
 class MD4CParser {

package/cpp/parser/MarkdownASTNode.hpp

@@ -37,7 +37,8 @@ enum class NodeType {
     Spoiler,
     Superscript,
     Subscript,
-    Highlight
+    Highlight,
+    SoftBreak
 };
 
 struct MarkdownASTNode {

package/cpp/wasm/ASTSerializer.cpp

@@ -18,6 +18,8 @@ static const char *nodeTypeToString(NodeType type) {
       return "Heading";
     case NodeType::LineBreak:
       return "LineBreak";
+    case NodeType::SoftBreak:
+      return "SoftBreak";
     case NodeType::Strong:
       return "Strong";
     case NodeType::Emphasis:

package/cpp/wasm/build.sh

@@ -51,6 +51,7 @@ emcc \
   -s INITIAL_MEMORY=16MB \
   -s MAXIMUM_MEMORY=512MB \
   -s ALLOW_MEMORY_GROWTH=1 \
+  -s GROWABLE_ARRAYBUFFERS=0 \
   -o "$OUT_DIR/md4c.js"
 
 rm "$OUT_DIR/md4c.o"

package/cpp/wasm/md4c_wasm.cpp

@@ -18,10 +18,11 @@ extern "C" {
  * @param superscript 1 → enable ^superscript^ spans; 0 → disable.
  * @param subscript  1 → enable ~subscript~ spans; 0 → disable.
  * @param highlight  1 → enable ==highlight== spans; 0 → disable.
+ * @param hardSoftBreaks 1 → treat soft breaks as hard breaks; 0 → collapse to space.
  * @return           Null-terminated UTF-8 JSON string, valid until the next call.
  */
 const char *parseMarkdown(const char *markdown, int underline, int latexMath, int superscript, int subscript,
-                          int highlight) {
+                          int highlight, int hardSoftBreaks) {
   if (!markdown) {
     g_resultBuffer = "{\"type\":\"Document\"}";
     return g_resultBuffer.c_str();
@@ -33,6 +34,7 @@ const char *parseMarkdown(const char *markdown, int underline, int latexMath, in
   flags.superscript = (superscript != 0);
   flags.subscript = (subscript != 0);
   flags.highlight = (highlight != 0);
+  flags.hardSoftBreaks = (hardSoftBreaks != 0);
 
   Markdown::MD4CParser parser;
   auto root = parser.parse(std::string(markdown), flags);

package/docs/ACCESSIBILITY.md

@@ -1,6 +1,6 @@
 # Accessibility
 
-`react-native-enriched-markdown` provides comprehensive accessibility support for screen readers on both iOS and Android platforms.
+`react-native-enriched-markdown-scaffold` provides comprehensive accessibility support for screen readers on both iOS and Android platforms.
 
 ## Overview
 
@@ -15,7 +15,7 @@ Plain text paragraphs without inline links or images are announced as a single V
 All strings spoken by the screen reader (list announcements, blockquote suffix, table rows, math equation prefix, and iOS rotor names) can be overridden via the optional `accessibilityLabels` prop on `EnrichedMarkdownText`. The defaults are English; consumers wire in their own i18n pipeline.
 
 ```tsx
-import { EnrichedMarkdownText } from 'react-native-enriched-markdown';
+import { EnrichedMarkdownText } from 'react-native-enriched-markdown-scaffold';
 
 <EnrichedMarkdownText
   markdown={markdown}
@@ -164,9 +164,21 @@ Tables expose one focusable element per row (header included), labeled with the
 
 Each math block exposes a single focusable element labeled `"Math: <latex>"`. The library does **not** convert LaTeX to natural language — the screen reader reads the raw LaTeX source. If you need spoken math, plug in a LaTeX→speech library on the consumer side and translate the labels accordingly.
 
+## Text input (`EnrichedMarkdownTextInput`)
+
+The editor's accessibility model is intentionally simpler than the renderer's. The input is built on a custom TextKit stack, so its inner `UITextView` is not surfaced to VoiceOver directly — instead the component is presented as a **single accessibility element** that reads its whole content as one paragraph.
+
+**iOS (VoiceOver):**
+- The field is one element whose spoken value is the full plain text (delimiters stripped). When the field is empty, the placeholder is announced instead.
+- `accessibilityLabel` / `accessibilityHint` set on the component are forwarded and announced.
+- Double-tapping activates the field: it becomes first responder and the keyboard opens for editing.
+
+**Android (TalkBack):** the input is a native `EditText`, announced and edited as a standard editable text field.
+
 ## Known Limitations
 
 - **Inline formatting** (bold / italic / underline / strikethrough / inline code / spoiler) is not split into separate accessibility elements — the entire paragraph is read as one element, exactly as the surrounding text. Screen readers don't apply visual emphasis to bold/italic by default.
 - **macOS** screen-reader support is still pending — `MarkdownAccessibilityElementBuilder.m` ships a no-op stub for macOS. Tracked as a TODO; iOS implementation can serve as a reference.
 - **Android** has no rotor concept — `accessibilityLabels.rotor.*` is silently ignored on that platform.
 - **iOS** blockquote backgrounds may break at link boundaries instead of spanning the full line. Visual only; doesn't affect accessibility.
+- **Text input** (`EnrichedMarkdownTextInput`, iOS) is exposed as a single VoiceOver element reading its full plain text as one paragraph. It is **not** announced with the native "text field" role, has no in-field cursor navigation or per-character echo (editing happens via the keyboard after a double-tap activation), and its spoken value refreshes on re-focus rather than live. Exposing the inner `UITextView` for these would be unreliable under the custom TextKit stack (duplicate/flaky announcements). Inline formatting and headings are read as plain text.