react-native-enriched-markdown 0.1.0 → 0.2.0

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,35 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, MarkdownNodeType) {
+  MarkdownNodeTypeDocument,
+  MarkdownNodeTypeParagraph,
+  MarkdownNodeTypeText,
+  MarkdownNodeTypeLink,
+  MarkdownNodeTypeHeading,
+  MarkdownNodeTypeLineBreak,
+  MarkdownNodeTypeStrong,
+  MarkdownNodeTypeEmphasis,
+  MarkdownNodeTypeStrikethrough,
+  MarkdownNodeTypeUnderline,
+  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,17 @@
+#import "MarkdownASTNode.h"
+#import <Foundation/Foundation.h>
+
+@interface Md4cFlags : NSObject <NSCopying>
+
+@property (nonatomic, assign) BOOL underline;
+
++ (instancetype)defaultFlags;
+
+@end
+
+@interface MarkdownParser : NSObject
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown;
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown flags:(Md4cFlags *)flags;
+
+@end

package/ios/parser/MarkdownParser.mm

@@ -0,0 +1,42 @@
+#import "MarkdownParser.h"
+#import "MarkdownASTNode.h"
+
+extern MarkdownASTNode *parseMarkdownWithCppParser(NSString *markdown, Md4cFlags *flags);
+
+@implementation Md4cFlags
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _underline = NO;
+  }
+  return self;
+}
+
++ (instancetype)defaultFlags
+{
+  return [[Md4cFlags alloc] init];
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+  Md4cFlags *copy = [[Md4cFlags allocWithZone:zone] init];
+  copy.underline = self.underline;
+  return copy;
+}
+
+@end
+
+@implementation MarkdownParser
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown
+{
+  return [self parseMarkdown:markdown flags:[Md4cFlags defaultFlags]];
+}
+
+- (MarkdownASTNode *)parseMarkdown:(NSString *)markdown flags:(Md4cFlags *)flags
+{
+  return parseMarkdownWithCppParser(markdown, flags);
+}
+
+@end

package/ios/parser/MarkdownParserBridge.mm

@@ -0,0 +1,120 @@
+#include "MD4CParser.hpp"
+#import "MarkdownASTNode.h"
+#include "MarkdownASTNode.hpp"
+#import "MarkdownParser.h"
+
+// 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::Strikethrough:
+      objcType = MarkdownNodeTypeStrikethrough;
+      break;
+    case Markdown::NodeType::Underline:
+      objcType = MarkdownNodeTypeUnderline;
+      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, Md4cFlags *flags)
+{
+  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);
+
+  // Convert Objective-C flags to C++ flags
+  Markdown::Md4cFlags cppFlags;
+  cppFlags.underline = flags.underline;
+
+  Markdown::MD4CParser parser;
+  auto cppAST = parser.parse(cppMarkdown, cppFlags);
+
+  // Convert C++ AST to Objective-C AST
+  return convertCppASTToObjC(cppAST);
+}

package/ios/renderer/AttributedRenderer.h

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