react-native-enriched-markdown 0.1.0 → 0.1.1

package/ios/generated/EnrichedMarkdownTextSpec/RCTComponentViewHelpers.h

@@ -0,0 +1,20 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GenerateComponentHObjCpp.js
+*/
+
+#import <Foundation/Foundation.h>
+#import <React/RCTDefines.h>
+#import <React/RCTLog.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RCTEnrichedMarkdownTextViewProtocol <NSObject>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/generated/EnrichedMarkdownTextSpec/ShadowNodes.cpp

@@ -0,0 +1,17 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeCpp.js
+ */
+
+#include "ShadowNodes.h"
+
+namespace facebook::react {
+
+extern const char EnrichedMarkdownTextComponentName[] = "EnrichedMarkdownText";
+
+} // namespace facebook::react

package/ios/generated/EnrichedMarkdownTextSpec/ShadowNodes.h

@@ -0,0 +1,32 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeH.js
+ */
+
+#pragma once
+
+#include "EventEmitters.h"
+#include "Props.h"
+#include "States.h"
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char EnrichedMarkdownTextComponentName[];
+
+/*
+ * `ShadowNode` for <EnrichedMarkdownText> component.
+ */
+using EnrichedMarkdownTextShadowNode = ConcreteViewShadowNode<
+    EnrichedMarkdownTextComponentName,
+    EnrichedMarkdownTextProps,
+    EnrichedMarkdownTextEventEmitter,
+    EnrichedMarkdownTextState>;
+
+} // namespace facebook::react

package/ios/generated/EnrichedMarkdownTextSpec/States.cpp

@@ -0,0 +1,16 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateCpp.js
+ */
+#include "States.h"
+
+namespace facebook::react {
+
+
+
+} // namespace facebook::react

package/ios/generated/EnrichedMarkdownTextSpec/States.h

@@ -0,0 +1,20 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateH.js
+ */
+#pragma once
+
+#include <react/renderer/core/StateData.h>
+#ifdef RN_SERIALIZABLE_STATE
+#include <folly/dynamic.h>
+#endif
+
+namespace facebook::react {
+
+using EnrichedMarkdownTextState = StateData;
+
+} // namespace facebook::react

package/ios/internals/EnrichedMarkdownTextComponentDescriptor.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "EnrichedMarkdownTextShadowNode.h"
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class EnrichedMarkdownTextComponentDescriptor final
+    : public ConcreteComponentDescriptor<EnrichedMarkdownTextShadowNode> {
+public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(dynamic_cast<EnrichedMarkdownTextShadowNode *>(&shadowNode));
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

package/ios/internals/EnrichedMarkdownTextShadowNode.h

@@ -0,0 +1,43 @@
+#pragma once
+#include <ReactNativeEnrichedMarkdown/EnrichedMarkdownTextState.h>
+#include <ReactNativeEnrichedMarkdown/EventEmitters.h>
+#include <ReactNativeEnrichedMarkdown/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char EnrichedMarkdownTextComponentName[];
+
+/// ShadowNode implementing measureContent for automatic height calculation.
+class EnrichedMarkdownTextShadowNode
+    : public ConcreteViewShadowNode<EnrichedMarkdownTextComponentName, EnrichedMarkdownTextProps,
+                                    EnrichedMarkdownTextEventEmitter, EnrichedMarkdownTextState> {
+public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  EnrichedMarkdownTextShadowNode(const ShadowNodeFragment &fragment, const ShadowNodeFamily::Shared &family,
+                                 ShadowNodeTraits traits);
+
+  EnrichedMarkdownTextShadowNode(const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment);
+
+  void dirtyLayoutIfNeeded();
+
+  Size measureContent(const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints) const override;
+
+  static ShadowNodeTraits BaseTraits()
+  {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+private:
+  int localHeightRecalculationCounter_{0};
+
+  // Creates mock view off-screen for initial measurement when real view doesn't exist
+  id setupMockEnrichedMarkdownText_(CGFloat width) const;
+};
+
+} // namespace facebook::react

package/ios/internals/EnrichedMarkdownTextShadowNode.mm

@@ -0,0 +1,85 @@
+#import "EnrichedMarkdownTextShadowNode.h"
+#import "EnrichedMarkdownText.h"
+#import <react/utils/ManagedObjectWrapper.h>
+#import <yoga/Yoga.h>
+
+namespace facebook::react {
+
+extern const char EnrichedMarkdownTextComponentName[] = "EnrichedMarkdownText";
+
+EnrichedMarkdownTextShadowNode::EnrichedMarkdownTextShadowNode(const ShadowNodeFragment &fragment,
+                                                               const ShadowNodeFamily::Shared &family,
+                                                               ShadowNodeTraits traits)
+    : ConcreteViewShadowNode(fragment, family, traits)
+{
+}
+
+EnrichedMarkdownTextShadowNode::EnrichedMarkdownTextShadowNode(const ShadowNode &sourceShadowNode,
+                                                               const ShadowNodeFragment &fragment)
+    : ConcreteViewShadowNode(sourceShadowNode, fragment)
+{
+  dirtyLayoutIfNeeded();
+}
+
+void EnrichedMarkdownTextShadowNode::dirtyLayoutIfNeeded()
+{
+  const auto state = this->getStateData();
+  const int receivedCounter = state.getHeightRecalculationCounter();
+
+  if (receivedCounter > localHeightRecalculationCounter_) {
+    localHeightRecalculationCounter_ = receivedCounter;
+    YGNodeMarkDirty(&yogaNode_);
+  }
+}
+
+/// Creates a mock view off-screen to measure content when real view isn't ready yet.
+id EnrichedMarkdownTextShadowNode::setupMockEnrichedMarkdownText_(CGFloat width) const
+{
+  EnrichedMarkdownText *mockView = [[EnrichedMarkdownText alloc] initWithFrame:CGRectMake(20000, 20000, width, 1000)];
+
+  const auto props = this->getProps();
+  [mockView updateProps:props oldProps:nullptr];
+
+  // Render markdown synchronously for accurate measurement
+  const auto &typedProps = *std::static_pointer_cast<const EnrichedMarkdownTextProps>(props);
+  if (!typedProps.markdown.empty()) {
+    NSString *markdown = [NSString stringWithUTF8String:typedProps.markdown.c_str()];
+    [mockView renderMarkdownSynchronously:markdown];
+  }
+
+  return mockView;
+}
+
+Size EnrichedMarkdownTextShadowNode::measureContent(const LayoutContext &layoutContext,
+                                                    const LayoutConstraints &layoutConstraints) const
+{
+  CGFloat maxWidth = layoutConstraints.maximumSize.width;
+  CGFloat maxHeight = layoutConstraints.maximumSize.height;
+
+  RCTInternalGenericWeakWrapper *weakWrapper =
+      (RCTInternalGenericWeakWrapper *)unwrapManagedObject(getStateData().getComponentViewRef());
+  EnrichedMarkdownText *view = weakWrapper ? (EnrichedMarkdownText *)weakWrapper.object : nil;
+
+  __block CGSize size;
+
+  // Measure on main thread (required for UIKit)
+  void (^measureBlock)(void) = ^{
+    if (view) {
+      size = [view measureSize:maxWidth];
+    } else {
+      // No view yet - create mock view for accurate initial measurement
+      EnrichedMarkdownText *mockView = setupMockEnrichedMarkdownText_(maxWidth);
+      size = [mockView measureSize:maxWidth];
+    }
+  };
+
+  if ([NSThread isMainThread]) {
+    measureBlock();
+  } else {
+    dispatch_sync(dispatch_get_main_queue(), measureBlock);
+  }
+
+  return {size.width, MIN(size.height, maxHeight)};
+}
+
+} // namespace facebook::react

package/ios/internals/EnrichedMarkdownTextState.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <memory>
+
+namespace facebook::react {
+
+/// Counter triggers layout recalculation, viewRef allows shadow node to access view for measurement.
+class EnrichedMarkdownTextState {
+public:
+  EnrichedMarkdownTextState() = default;
+  EnrichedMarkdownTextState(int counter, std::shared_ptr<void> ref) : counter_(counter), viewRef_(ref) {}
+
+  int getHeightRecalculationCounter() const {
+    return counter_;
+  }
+  std::shared_ptr<void> getComponentViewRef() const {
+    return viewRef_;
+  }
+
+private:
+  int counter_{0};
+  std::shared_ptr<void> viewRef_{nullptr};
+};
+
+} // namespace facebook::react

package/ios/parser/MarkdownASTNode.h

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, MarkdownNodeType) {
+  MarkdownNodeTypeDocument,
+  MarkdownNodeTypeParagraph,
+  MarkdownNodeTypeText,
+  MarkdownNodeTypeLink,
+  MarkdownNodeTypeHeading,
+  MarkdownNodeTypeLineBreak,
+  MarkdownNodeTypeStrong,
+  MarkdownNodeTypeEmphasis,
+  MarkdownNodeTypeCode,
+  MarkdownNodeTypeImage,
+  MarkdownNodeTypeBlockquote,
+  MarkdownNodeTypeUnorderedList,
+  MarkdownNodeTypeOrderedList,
+  MarkdownNodeTypeListItem,
+  MarkdownNodeTypeCodeBlock,
+  MarkdownNodeTypeThematicBreak
+};
+
+@interface MarkdownASTNode : NSObject
+
+@property (nonatomic, assign) MarkdownNodeType type;
+@property (nonatomic, strong) NSString *content;
+@property (nonatomic, strong) NSMutableDictionary *attributes;
+@property (nonatomic, strong) NSMutableArray<MarkdownASTNode *> *children;
+
+- (instancetype)initWithType:(MarkdownNodeType)type;
+- (void)addChild:(MarkdownASTNode *)child;
+- (void)setAttribute:(NSString *)key value:(NSString *)value;
+
+@end

package/ios/parser/MarkdownASTNode.m

@@ -0,0 +1,32 @@
+#import "MarkdownASTNode.h"
+
+@implementation MarkdownASTNode
+
+- (instancetype)initWithType:(MarkdownNodeType)type
+{
+  if (self = [super init]) {
+    _type = type;
+    _content = nil;
+    _attributes = [[NSMutableDictionary alloc] init];
+    _children = [[NSMutableArray alloc] init];
+  }
+  return self;
+}
+
+- (void)addChild:(MarkdownASTNode *)child
+{
+  [_children addObject:child];
+}
+
+- (void)setAttribute:(NSString *)key value:(NSString *)value
+{
+  _attributes[key] = value;
+}
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"MarkdownASTNode(type=%ld, content=%@, children=%lu)", (long)_type, _content,
+                                    (unsigned long)_children.count];
+}
+
+@end

package/ios/parser/MarkdownParser.h

@@ -0,0 +1,8 @@
+#import "MarkdownASTNode.h"
+#import <Foundation/Foundation.h>
+
+@interface MarkdownParser : NSObject
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown;
+
+@end

package/ios/parser/MarkdownParser.mm

@@ -0,0 +1,13 @@
+#import "MarkdownParser.h"
+#import "MarkdownASTNode.h"
+
+extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown);
+
+@implementation MarkdownParser
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown
+{
+  return parseMarkdownWithCppParser(markdown);
+}
+
+@end

package/ios/parser/MarkdownParserBridge.mm

@@ -0,0 +1,110 @@
+#include "MD4CParser.hpp"
+#import "MarkdownASTNode.h"
+#include "MarkdownASTNode.hpp"
+
+// Convert C++ AST node to Objective-C AST node
+static MarkdownASTNode *convertCppASTToObjC(std::shared_ptr<Markdown::MarkdownASTNode> cppNode)
+{
+  if (!cppNode) {
+    return [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
+  }
+
+  // Convert C++ NodeType enum to Objective-C MarkdownNodeType
+  MarkdownNodeType objcType;
+  switch (cppNode->type) {
+    case Markdown::NodeType::Document:
+      objcType = MarkdownNodeTypeDocument;
+      break;
+    case Markdown::NodeType::Paragraph:
+      objcType = MarkdownNodeTypeParagraph;
+      break;
+    case Markdown::NodeType::Text:
+      objcType = MarkdownNodeTypeText;
+      break;
+    case Markdown::NodeType::Link:
+      objcType = MarkdownNodeTypeLink;
+      break;
+    case Markdown::NodeType::Heading:
+      objcType = MarkdownNodeTypeHeading;
+      break;
+    case Markdown::NodeType::LineBreak:
+      objcType = MarkdownNodeTypeLineBreak;
+      break;
+    case Markdown::NodeType::Strong:
+      objcType = MarkdownNodeTypeStrong;
+      break;
+    case Markdown::NodeType::Emphasis:
+      objcType = MarkdownNodeTypeEmphasis;
+      break;
+    case Markdown::NodeType::Code:
+      objcType = MarkdownNodeTypeCode;
+      break;
+    case Markdown::NodeType::Image:
+      objcType = MarkdownNodeTypeImage;
+      break;
+    case Markdown::NodeType::Blockquote:
+      objcType = MarkdownNodeTypeBlockquote;
+      break;
+    case Markdown::NodeType::UnorderedList:
+      objcType = MarkdownNodeTypeUnorderedList;
+      break;
+    case Markdown::NodeType::OrderedList:
+      objcType = MarkdownNodeTypeOrderedList;
+      break;
+    case Markdown::NodeType::ListItem:
+      objcType = MarkdownNodeTypeListItem;
+      break;
+    case Markdown::NodeType::CodeBlock:
+      objcType = MarkdownNodeTypeCodeBlock;
+      break;
+    case Markdown::NodeType::ThematicBreak:
+      objcType = MarkdownNodeTypeThematicBreak;
+      break;
+  }
+
+  MarkdownASTNode *objcNode = [[MarkdownASTNode alloc] initWithType:objcType];
+
+  // Convert content
+  if (!cppNode->content.empty()) {
+    objcNode.content = [NSString stringWithUTF8String:cppNode->content.c_str()];
+  }
+
+  // Convert attributes
+  for (const auto &[key, value] : cppNode->attributes) {
+    NSString *objcKey = [NSString stringWithUTF8String:key.c_str()];
+    NSString *objcValue = [NSString stringWithUTF8String:value.c_str()];
+    [objcNode setAttribute:objcKey value:objcValue];
+  }
+
+  // Convert children recursively
+  for (const auto &child : cppNode->children) {
+    MarkdownASTNode *objcChild = convertCppASTToObjC(child);
+    [objcNode addChild:objcChild];
+  }
+
+  return objcNode;
+}
+
+// Public function to parse markdown using C++ parser and convert to Objective-C AST
+MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown)
+{
+  if (markdown.length == 0) {
+    return [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
+  }
+
+  // Convert NSString to std::string
+  const char *utf8String = [markdown UTF8String];
+  if (!utf8String) {
+    NSLog(@"MarkdownParserBridge: Failed to convert markdown to UTF-8");
+    return [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
+  }
+
+  std::string cppMarkdown(utf8String);
+
+  // Parse using C++ parser
+  Markdown::MD4CParser parser;
+  auto cppAST = parser.parse(cppMarkdown);
+
+  // Convert C++ AST to Objective-C AST
+  return convertCppASTToObjC(cppAST);
+}

package/ios/renderer/AttributedRenderer.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+
+@class MarkdownASTNode;
+@class RenderContext;
+
+@interface AttributedRenderer : NSObject
+- (instancetype)initWithConfig:(id)config;
+- (NSMutableAttributedString *)renderRoot:(MarkdownASTNode *)root context:(RenderContext *)context;
+@end

package/ios/renderer/AttributedRenderer.m

@@ -0,0 +1,119 @@
+#import "AttributedRenderer.h"
+#import "CodeBlockBackground.h"
+#import "LastElementUtils.h"
+#import "MarkdownASTNode.h"
+#import "NodeRenderer.h"
+#import "RenderContext.h"
+#import "RendererFactory.h"
+#import "StyleConfig.h"
+
+@implementation AttributedRenderer {
+  StyleConfig *_config;
+  RendererFactory *_rendererFactory;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  self = [super init];
+  if (self) {
+    _config = config;
+    _rendererFactory = [[RendererFactory alloc] initWithConfig:config];
+  }
+  return self;
+}
+
+/**
+ * Entry point for rendering a Markdown AST.
+ * Sets the baseline global style and initiates the recursive traversal.
+ */
+- (NSMutableAttributedString *)renderRoot:(MarkdownASTNode *)root context:(RenderContext *)context
+{
+  if (!root)
+    return [[NSMutableAttributedString alloc] init];
+
+  // 1. Establish the global baseline style.
+  // This ensures that leaf nodes (like Text) have valid attributes if they appear at the root.
+  [context setBlockStyle:BlockTypeParagraph font:_config.paragraphFont color:_config.paragraphColor headingLevel:0];
+
+  NSMutableAttributedString *output = [[NSMutableAttributedString alloc] init];
+
+  // 2. Iterate through root children.
+  // We skip the 'Root' node itself as it is a container, not a renderable element.
+  for (MarkdownASTNode *node in root.children) {
+    [self renderNodeRecursive:node into:output context:context];
+  }
+
+  // 3. Remove trailing paragraph spacing from last block element
+  [self removeTrailingSpacing:output];
+
+  // 4. Cleanup global state to prevent side effects in subsequent renders.
+  [context clearBlockStyle];
+
+  return output;
+}
+
+/// Removes trailing margin spacing while preserving code block padding
+- (void)removeTrailingSpacing:(NSMutableAttributedString *)output
+{
+  if (output.length == 0)
+    return;
+
+  NSRange lastContent = [output.string rangeOfCharacterFromSet:[[NSCharacterSet newlineCharacterSet] invertedSet]
+                                                       options:NSBackwardsSearch];
+  if (lastContent.location == NSNotFound)
+    return;
+
+  if (isLastElementCodeBlock(output)) {
+    // Code block: preserve bottom padding, only trim external margin
+    NSRange codeBlockRange;
+    [output attribute:CodeBlockAttributeName atIndex:lastContent.location effectiveRange:&codeBlockRange];
+    NSUInteger codeBlockEnd = NSMaxRange(codeBlockRange);
+    if (codeBlockEnd < output.length) {
+      [output deleteCharactersInRange:NSMakeRange(codeBlockEnd, output.length - codeBlockEnd)];
+    }
+  } else {
+    // Other elements: trim trailing newlines and zero all spacing
+    [output deleteCharactersInRange:NSMakeRange(NSMaxRange(lastContent), output.length - NSMaxRange(lastContent))];
+
+    NSRange range;
+    NSParagraphStyle *style = [output attribute:NSParagraphStyleAttributeName
+                                        atIndex:lastContent.location
+                                 effectiveRange:&range];
+    if (style) {
+      NSMutableParagraphStyle *fixed = [style mutableCopy];
+      fixed.paragraphSpacing = 0;
+      fixed.paragraphSpacingBefore = 0;
+      // For images: zero line spacing to eliminate baseline gaps
+      if (isLastElementImage(output)) {
+        fixed.lineSpacing = 0;
+      }
+      [output addAttribute:NSParagraphStyleAttributeName value:fixed range:range];
+    }
+  }
+}
+
+/**
+ * Orchestrates the recursive traversal of the AST.
+ * If a specialized renderer exists for a node type, it takes full control.
+ */
+- (void)renderNodeRecursive:(MarkdownASTNode *)node
+                       into:(NSMutableAttributedString *)out
+                    context:(RenderContext *)context
+{
+  if (!node)
+    return;
+
+  id<NodeRenderer> renderer = [_rendererFactory rendererForNodeType:node.type];
+
+  if (renderer) {
+    // Specialized renderers (e.g., Strong, Link, Heading) handle their own sub-trees.
+    [renderer renderNode:node into:out context:context];
+  } else {
+    // Fallback: Default to deep-first traversal for unhandled container nodes.
+    for (MarkdownASTNode *child in node.children) {
+      [self renderNodeRecursive:child into:out context:context];
+    }
+  }
+}
+
+@end

package/ios/renderer/BlockquoteRenderer.h

@@ -0,0 +1,7 @@
+#import "MarkdownASTNode.h"
+#import "NodeRenderer.h"
+#import "RenderContext.h"
+
+@interface BlockquoteRenderer : NSObject <NodeRenderer>
+- (instancetype)initWithRendererFactory:(id)rendererFactory config:(id)config;
+@end