react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/cpp/wasm/ASTSerializer.cpp

@@ -0,0 +1,158 @@
+#include "ASTSerializer.hpp"
+#include <cassert>
+#include <cstdio>
+
+namespace Markdown {
+
+static const char *nodeTypeToString(NodeType type) {
+  switch (type) {
+    case NodeType::Document:
+      return "Document";
+    case NodeType::Paragraph:
+      return "Paragraph";
+    case NodeType::Text:
+      return "Text";
+    case NodeType::Link:
+      return "Link";
+    case NodeType::Heading:
+      return "Heading";
+    case NodeType::LineBreak:
+      return "LineBreak";
+    case NodeType::Strong:
+      return "Strong";
+    case NodeType::Emphasis:
+      return "Emphasis";
+    case NodeType::Strikethrough:
+      return "Strikethrough";
+    case NodeType::Underline:
+      return "Underline";
+    case NodeType::Code:
+      return "Code";
+    case NodeType::Image:
+      return "Image";
+    case NodeType::Blockquote:
+      return "Blockquote";
+    case NodeType::UnorderedList:
+      return "UnorderedList";
+    case NodeType::OrderedList:
+      return "OrderedList";
+    case NodeType::ListItem:
+      return "ListItem";
+    case NodeType::CodeBlock:
+      return "CodeBlock";
+    case NodeType::ThematicBreak:
+      return "ThematicBreak";
+    case NodeType::Table:
+      return "Table";
+    case NodeType::TableHead:
+      return "TableHead";
+    case NodeType::TableBody:
+      return "TableBody";
+    case NodeType::TableRow:
+      return "TableRow";
+    case NodeType::TableHeaderCell:
+      return "TableHeaderCell";
+    case NodeType::TableCell:
+      return "TableCell";
+    case NodeType::LatexMathInline:
+      return "LatexMathInline";
+    case NodeType::LatexMathDisplay:
+      return "LatexMathDisplay";
+    case NodeType::Spoiler:
+      return "Spoiler";
+    case NodeType::Superscript:
+      return "Superscript";
+    case NodeType::Subscript:
+      return "Subscript";
+    case NodeType::Highlight:
+      return "Highlight";
+    default:
+      assert(false && "unhandled NodeType in nodeTypeToString");
+      return "";
+  }
+}
+
+void ASTSerializer::appendEscaped(const std::string &str, std::string &out) {
+  out += '"';
+  for (unsigned char c : str) {
+    switch (c) {
+      case '"':
+        out += "\\\"";
+        break;
+      case '\\':
+        out += "\\\\";
+        break;
+      case '\n':
+        out += "\\n";
+        break;
+      case '\r':
+        out += "\\r";
+        break;
+      case '\t':
+        out += "\\t";
+        break;
+      case '\b':
+        out += "\\b";
+        break;
+      case '\f':
+        out += "\\f";
+        break;
+      default:
+        if (c < 0x20) {
+          char buf[7];
+          std::snprintf(buf, sizeof(buf), "\\u%04x", c);
+          out += buf;
+        } else {
+          out += static_cast<char>(c);
+        }
+        break;
+    }
+  }
+  out += '"';
+}
+
+void ASTSerializer::serializeNode(const MarkdownASTNode &node, std::string &out) {
+  out += "{\"type\":\"";
+  out += nodeTypeToString(node.type);
+  out += '"';
+
+  if (!node.content.empty()) {
+    out += ",\"content\":";
+    appendEscaped(node.content, out);
+  }
+
+  if (!node.attributes.empty()) {
+    out += ",\"attributes\":{";
+    bool first = true;
+    for (const auto &kv : node.attributes) {
+      if (!first)
+        out += ',';
+      first = false;
+      appendEscaped(kv.first, out);
+      out += ':';
+      appendEscaped(kv.second, out);
+    }
+    out += '}';
+  }
+
+  if (!node.children.empty()) {
+    out += ",\"children\":[";
+    for (size_t i = 0; i < node.children.size(); ++i) {
+      if (i > 0)
+        out += ',';
+      serializeNode(*node.children[i], out);
+    }
+    out += ']';
+  }
+
+  out += '}';
+}
+
+std::string ASTSerializer::serialize(const MarkdownASTNode &node) {
+  std::string out;
+  out.reserve(1024);
+  serializeNode(node, out);
+  return out;
+}
+
+} // namespace Markdown

package/cpp/wasm/ASTSerializer.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../parser/MarkdownASTNode.hpp"
+#include <string>
+
+namespace Markdown {
+
+class ASTSerializer {
+public:
+  static std::string serialize(const MarkdownASTNode &node);
+
+private:
+  static void serializeNode(const MarkdownASTNode &node, std::string &out);
+  static void appendEscaped(const std::string &str, std::string &out);
+};
+
+} // namespace Markdown

package/cpp/wasm/build.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# Compile md4c + the WASM wrapper to a single self-contained JS file.
+#
+# Prerequisites:
+#   brew install emscripten    # macOS
+#   # or follow https://emscripten.org/docs/getting_started/downloads.html
+#
+# Usage:
+#   bash cpp/wasm/build.sh
+#
+# Output:
+#   src/web/wasm/md4c.js   — Emscripten glue with WASM binary inlined as base64
+#                            (SINGLE_FILE=1 means no separate .wasm file is needed)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PACKAGE_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+OUT_DIR="$PACKAGE_ROOT/src/web/wasm"
+
+mkdir -p "$OUT_DIR"
+
+echo "Building md4c WASM…"
+
+# Compile the C file separately (no -std=c++17)
+emcc \
+  -I "$PACKAGE_ROOT/cpp" \
+  -O2 \
+  -c "$PACKAGE_ROOT/cpp/md4c/md4c.c" \
+  -o "$OUT_DIR/md4c.o"
+
+# Compile C++ sources and link everything together
+emcc \
+  "$SCRIPT_DIR/md4c_wasm.cpp" \
+  "$SCRIPT_DIR/ASTSerializer.cpp" \
+  "$PACKAGE_ROOT/cpp/parser/MD4CParser.cpp" \
+  "$OUT_DIR/md4c.o" \
+  -I "$PACKAGE_ROOT/cpp" \
+  -I "$SCRIPT_DIR" \
+  -O2 \
+  -std=c++17 \
+  -Wswitch \
+  -s WASM=1 \
+  -s SINGLE_FILE=1 \
+  -s EXPORTED_FUNCTIONS='["_parseMarkdown"]' \
+  -s EXPORTED_RUNTIME_METHODS='["ccall","cwrap","UTF8ToString"]' \
+  -s ENVIRONMENT='web' \
+  -s MODULARIZE=1 \
+  -s EXPORT_NAME='createMd4cModule' \
+  -s STACK_SIZE=8MB \
+  -s INITIAL_MEMORY=16MB \
+  -s MAXIMUM_MEMORY=512MB \
+  -s ALLOW_MEMORY_GROWTH=1 \
+  -o "$OUT_DIR/md4c.js"
+
+rm "$OUT_DIR/md4c.o"
+
+echo "Done → $OUT_DIR/md4c.js"

package/cpp/wasm/md4c_wasm.cpp

@@ -0,0 +1,43 @@
+#include "../parser/MD4CParser.hpp"
+#include "ASTSerializer.hpp"
+#include <string>
+
+// Static buffer for the JSON result.
+// Safe for single-threaded WASM execution — the caller must consume (copy)
+// the returned string before calling parseMarkdown again.
+static std::string g_resultBuffer;
+
+extern "C" {
+
+/**
+ * Parse a markdown string and return its AST as a JSON string.
+ *
+ * @param markdown   Null-terminated UTF-8 markdown input.
+ * @param underline  1 → enable __ underline extension; 0 → __ means emphasis.
+ * @param latexMath  1 → enable $…$ / $$…$$ LaTeX math spans; 0 → disable.
+ * @param superscript 1 → enable ^superscript^ spans; 0 → disable.
+ * @param subscript  1 → enable ~subscript~ spans; 0 → disable.
+ * @param highlight  1 → enable ==highlight== spans; 0 → disable.
+ * @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) {
+  if (!markdown) {
+    g_resultBuffer = "{\"type\":\"Document\"}";
+    return g_resultBuffer.c_str();
+  }
+
+  Markdown::Md4cFlags flags;
+  flags.underline = (underline != 0);
+  flags.latexMath = (latexMath != 0);
+  flags.superscript = (superscript != 0);
+  flags.subscript = (subscript != 0);
+  flags.highlight = (highlight != 0);
+
+  Markdown::MD4CParser parser;
+  auto root = parser.parse(std::string(markdown), flags);
+  g_resultBuffer = Markdown::ASTSerializer::serialize(*root);
+  return g_resultBuffer.c_str();
+}
+
+} // extern "C"

package/ios/EnrichedMarkdown.h

@@ -0,0 +1,20 @@
+#import "ENRMUIKit.h"
+#import "StyleConfig.h"
+#import <React/RCTViewComponentView.h>
+
+#ifndef EnrichedMarkdownNativeComponent_h
+#define EnrichedMarkdownNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface EnrichedMarkdown : RCTViewComponentView
+@property (nonatomic, strong) StyleConfig *config;
+- (CGSize)measureSize:(CGFloat)maxWidth;
+- (void)renderMarkdownSynchronously:(NSString *)markdownString;
+- (BOOL)hasRenderedMarkdown:(NSString *)markdown;
+- (BOOL)hasRenderedWithStyleFingerprint:(size_t)fingerprint;
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif