react-native-enriched-markdown 0.1.0 → 0.1.1

package/ios/utils/LastElementUtils.h

@@ -0,0 +1,53 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+static NSString *const CodeBlockAttributeName = @"CodeBlock";
+
+/**
+ * Checks if the last element in the attributed string is a code block.
+ * Used to compensate for iOS text APIs not measuring/drawing trailing newlines with custom line heights.
+ */
+static inline BOOL isLastElementCodeBlock(NSAttributedString *text)
+{
+  if (text.length == 0)
+    return NO;
+
+  NSRange lastContent = [text.string rangeOfCharacterFromSet:[[NSCharacterSet newlineCharacterSet] invertedSet]
+                                                     options:NSBackwardsSearch];
+  if (lastContent.location == NSNotFound)
+    return NO;
+
+  NSNumber *isCodeBlock = [text attribute:CodeBlockAttributeName atIndex:lastContent.location effectiveRange:nil];
+  if (!isCodeBlock.boolValue)
+    return NO;
+
+  NSRange codeBlockRange;
+  [text attribute:CodeBlockAttributeName atIndex:lastContent.location effectiveRange:&codeBlockRange];
+  return NSMaxRange(codeBlockRange) == text.length;
+}
+
+/**
+ * Checks if the last element in the attributed string is an image attachment.
+ * Used to compensate for iOS text attachment baseline spacing issues.
+ */
+static inline BOOL isLastElementImage(NSAttributedString *text)
+{
+  if (text.length == 0)
+    return NO;
+
+  NSRange lastContent = [text.string rangeOfCharacterFromSet:[[NSCharacterSet newlineCharacterSet] invertedSet]
+                                                     options:NSBackwardsSearch];
+  if (lastContent.location == NSNotFound)
+    return NO;
+
+  unichar lastChar = [text.string characterAtIndex:lastContent.location];
+  if (lastChar != 0xFFFC)
+    return NO;
+
+  id attachment = [text attribute:NSAttachmentAttributeName atIndex:lastContent.location effectiveRange:nil];
+  return attachment != nil;
+}
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ListMarkerDrawer.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@class StyleConfig;
+
+@interface ListMarkerDrawer : NSObject
+
+- (instancetype)initWithConfig:(StyleConfig *)config;
+
+- (void)drawMarkersForGlyphRange:(NSRange)glyphsToShow
+                   layoutManager:(NSLayoutManager *)layoutManager
+                   textContainer:(NSTextContainer *)textContainer
+                         atPoint:(CGPoint)origin;
+
+@end

package/ios/utils/ListMarkerDrawer.m

@@ -0,0 +1,127 @@
+#import "ListMarkerDrawer.h"
+#import "ListItemRenderer.h"
+#import "RenderContext.h"
+#import "StyleConfig.h"
+
+// Reference external symbols defined in ListItemRenderer.m
+extern NSString *const ListDepthAttribute;
+extern NSString *const ListTypeAttribute;
+extern NSString *const ListItemNumberAttribute;
+
+@implementation ListMarkerDrawer {
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  if (self = [super init]) {
+    _config = config;
+  }
+  return self;
+}
+
+- (void)drawMarkersForGlyphRange:(NSRange)glyphsToShow
+                   layoutManager:(NSLayoutManager *)layoutManager
+                   textContainer:(NSTextContainer *)textContainer
+                         atPoint:(CGPoint)origin
+{
+  NSTextStorage *storage = layoutManager.textStorage;
+  if (!storage || storage.length == 0)
+    return;
+
+  // Cache gap and track paragraphs to prevent double-drawing on wrapped lines
+  CGFloat gap = [_config effectiveListGapWidth];
+  NSMutableSet *drawnParagraphs = [NSMutableSet set];
+
+  [layoutManager
+      enumerateLineFragmentsForGlyphRange:glyphsToShow
+                               usingBlock:^(CGRect rect, CGRect usedRect, NSTextContainer *container,
+                                            NSRange glyphRange, BOOL *stop) {
+                                 NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphRange
+                                                                               actualGlyphRange:NULL];
+                                 if (charRange.location == NSNotFound)
+                                   return;
+
+                                 // 1. Fetch all attributes at once for efficiency
+                                 NSDictionary *attrs = [storage attributesAtIndex:charRange.location
+                                                                   effectiveRange:NULL];
+                                 if (!attrs[ListDepthAttribute])
+                                   return;
+
+                                 // 2. Identify the start of the paragraph
+                                 NSRange paraRange = [storage.string paragraphRangeForRange:charRange];
+                                 if (charRange.location != paraRange.location ||
+                                     [drawnParagraphs containsObject:@(paraRange.location)])
+                                   return;
+                                 [drawnParagraphs addObject:@(paraRange.location)];
+
+                                 // 3. Calculate Layout Coordinates
+                                 CGPoint glyphLoc = [layoutManager locationForGlyphAtIndex:glyphRange.location];
+                                 CGFloat baselineY = origin.y + rect.origin.y + glyphLoc.y;
+                                 CGFloat textStartX = origin.x + usedRect.origin.x;
+
+                                 // 4. Draw marker based on type
+                                 if ([attrs[ListTypeAttribute] integerValue] == ListTypeUnordered) {
+                                   UIFont *font = attrs[NSFontAttributeName] ?: [self defaultFont];
+                                   [self drawBulletAtX:textStartX - gap centerY:baselineY - (font.xHeight / 2.0)];
+                                 } else {
+                                   [self drawOrderedMarkerAtX:textStartX - gap attrs:attrs baselineY:baselineY];
+                                 }
+                               }];
+}
+
+#pragma mark - Drawing Helpers
+
+- (void)drawBulletAtX:(CGFloat)x centerY:(CGFloat)y
+{
+  [self
+      executeDrawing:^(CGContextRef ctx) {
+        [[_config listStyleBulletColor] ?: [UIColor blackColor] setFill];
+        CGFloat size = [_config listStyleBulletSize];
+        CGContextFillEllipseInRect(ctx, CGRectMake(x - size / 2.0, y - size / 2.0, size, size));
+      }
+                 atX:x
+                   y:y];
+}
+
+- (void)drawOrderedMarkerAtX:(CGFloat)rightBoundaryX attrs:(NSDictionary *)attrs baselineY:(CGFloat)baselineY
+{
+  NSNumber *num = attrs[ListItemNumberAttribute];
+  if (!num)
+    return;
+
+  NSString *text = [NSString stringWithFormat:@"%ld.", (long)num.integerValue];
+  UIFont *font = [_config listMarkerFont] ?: [self defaultFont];
+
+  NSDictionary *mAttrs = @{
+    NSFontAttributeName : font,
+    NSForegroundColorAttributeName : [_config listStyleMarkerColor] ?: [UIColor blackColor]
+  };
+  CGSize size = [text sizeWithAttributes:mAttrs];
+
+  if ([self isValidX:rightBoundaryX - size.width y:baselineY]) {
+    [text drawAtPoint:CGPointMake(rightBoundaryX - size.width, baselineY - font.ascender) withAttributes:mAttrs];
+  }
+}
+
+- (void)executeDrawing:(void (^)(CGContextRef))block atX:(CGFloat)x y:(CGFloat)y
+{
+  CGContextRef ctx = UIGraphicsGetCurrentContext();
+  if (ctx && [self isValidX:x y:y]) {
+    CGContextSaveGState(ctx);
+    block(ctx);
+    CGContextRestoreGState(ctx);
+  }
+}
+
+- (UIFont *)defaultFont
+{
+  return [UIFont systemFontOfSize:[_config listStyleFontSize]];
+}
+
+- (BOOL)isValidX:(CGFloat)x y:(CGFloat)y
+{
+  return !isnan(x) && !isinf(x) && !isnan(y) && !isinf(y);
+}
+
+@end

package/ios/utils/MarkdownExtractor.h

@@ -0,0 +1,17 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Extracts markdown from an attributed string (best-effort reconstruction).
+NSString *_Nullable extractMarkdownFromAttributedString(NSAttributedString *attributedText, NSRange range);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/MarkdownExtractor.m

@@ -0,0 +1,295 @@
+#import "MarkdownExtractor.h"
+#import "BlockquoteBorder.h"
+#import "ImageAttachment.h"
+#import "LastElementUtils.h"
+#import "RuntimeKeys.h"
+#import "ThematicBreakAttachment.h"
+
+#pragma mark - Extraction Context
+
+typedef struct {
+  NSInteger blockquoteDepth; // -1 = not in blockquote
+  NSInteger listDepth;       // -1 = not in list
+  BOOL needsBlankLine;
+} ExtractionState;
+
+#pragma mark - Helper Functions
+
+static void ensureBlankLine(NSMutableString *result)
+{
+  if (result.length == 0)
+    return;
+  if ([result hasSuffix:@"\n\n"])
+    return;
+
+  [result appendString:[result hasSuffix:@"\n"] ? @"\n" : @"\n\n"];
+}
+
+static BOOL isAtLineStart(NSMutableString *result)
+{
+  return result.length == 0 || [result hasSuffix:@"\n"];
+}
+
+/// Depth 0 = "> ", Depth 1 = "> > ", etc.
+static NSString *buildBlockquotePrefix(NSInteger depth)
+{
+  NSMutableString *prefix = [NSMutableString string];
+  for (NSInteger i = 0; i <= depth; i++) {
+    [prefix appendString:@"> "];
+  }
+  return prefix;
+}
+
+static NSString *buildListPrefix(NSInteger depth, BOOL isOrdered, NSInteger itemNumber)
+{
+  NSString *indent = [@"" stringByPaddingToLength:(depth * 2) withString:@" " startingAtIndex:0];
+  NSString *marker = isOrdered ? [NSString stringWithFormat:@"%ld.", (long)itemNumber] : @"-";
+  return [NSString stringWithFormat:@"%@%@ ", indent, marker];
+}
+
+static NSString *buildHeadingPrefix(NSInteger level)
+{
+  return [NSString stringWithFormat:@"%@ ", [@"" stringByPaddingToLength:level withString:@"#" startingAtIndex:0]];
+}
+
+static void extractFontTraits(NSDictionary *attrs, BOOL *isBold, BOOL *isItalic, BOOL *isMonospace)
+{
+  UIFont *font = attrs[NSFontAttributeName];
+  *isBold = NO;
+  *isItalic = NO;
+  *isMonospace = NO;
+
+  if (font) {
+    UIFontDescriptorSymbolicTraits traits = font.fontDescriptor.symbolicTraits;
+    *isBold = (traits & UIFontDescriptorTraitBold) != 0;
+    *isItalic = (traits & UIFontDescriptorTraitItalic) != 0;
+    *isMonospace = (traits & UIFontDescriptorTraitMonoSpace) != 0;
+  }
+}
+
+static NSString *applyInlineFormatting(NSString *text, BOOL isBold, BOOL isItalic, BOOL isMonospace, NSString *linkURL)
+{
+  NSMutableString *result = [NSMutableString stringWithString:text];
+
+  // Innermost first
+  if (isMonospace && !linkURL) {
+    result = [NSMutableString stringWithFormat:@"`%@`", result];
+  }
+  if (isItalic) {
+    result = [NSMutableString stringWithFormat:@"*%@*", result];
+  }
+  if (isBold) {
+    result = [NSMutableString stringWithFormat:@"**%@**", result];
+  }
+  if (linkURL) {
+    result = [NSMutableString stringWithFormat:@"[%@](%@)", text, linkURL];
+  }
+
+  return result;
+}
+
+#pragma mark - Main Extraction Function
+
+NSString *_Nullable extractMarkdownFromAttributedString(NSAttributedString *attributedText, NSRange range)
+{
+  if (!attributedText || range.length == 0 || range.location >= attributedText.length) {
+    return nil;
+  }
+
+  range.length = MIN(range.length, attributedText.length - range.location);
+
+  NSMutableString *result = [NSMutableString string];
+
+  // Headings may span multiple attribute runs
+  __block NSString *currentHeadingType = nil;
+  __block NSMutableString *headingContent = nil;
+  __block ExtractionState state = {.blockquoteDepth = -1, .listDepth = -1, .needsBlankLine = NO};
+
+  void (^flushHeading)(void) = ^{
+    if (!currentHeadingType || headingContent.length == 0)
+      return;
+
+    ensureBlankLine(result);
+    NSInteger level = [[currentHeadingType substringFromIndex:8] integerValue];
+    [result appendFormat:@"%@%@\n", buildHeadingPrefix(level), headingContent];
+
+    currentHeadingType = nil;
+    headingContent = nil;
+    state.needsBlankLine = YES;
+  };
+
+  [attributedText
+      enumerateAttributesInRange:range
+                         options:0
+                      usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange attrRange, BOOL *stop) {
+                        NSString *text = [[attributedText attributedSubstringFromRange:attrRange] string];
+                        if (text.length == 0)
+                          return;
+
+                        // Images and Thematic Breaks
+                        NSTextAttachment *attachment = attrs[NSAttachmentAttributeName];
+                        if ([attachment isKindOfClass:[ImageAttachment class]]) {
+                          ImageAttachment *img = (ImageAttachment *)attachment;
+                          if (!img.imageURL)
+                            return;
+
+                          if (img.isInline) {
+                            [result appendFormat:@"![image](%@)", img.imageURL];
+                          } else {
+                            ensureBlankLine(result);
+                            [result appendFormat:@"![image](%@)\n", img.imageURL];
+                            state.needsBlankLine = YES;
+                            state.blockquoteDepth = -1;
+                            state.listDepth = -1;
+                          }
+                          return;
+                        }
+
+                        if ([attachment isKindOfClass:[ThematicBreakAttachment class]]) {
+                          ensureBlankLine(result);
+                          [result appendString:@"---\n"];
+                          state.needsBlankLine = YES;
+                          state.blockquoteDepth = -1;
+                          state.listDepth = -1;
+                          return;
+                        }
+
+                        if ([text isEqualToString:@"\uFFFC"])
+                          return;
+
+                        // Newlines
+                        if ([text isEqualToString:@"\n"] || [text isEqualToString:@"\n\n"]) {
+                          NSNumber *bqDepth = attrs[BlockquoteDepthAttributeName];
+                          NSNumber *listDepth = attrs[@"ListDepth"];
+                          BOOL inBlockquote = (bqDepth != nil);
+                          BOOL inList = (listDepth != nil);
+
+                          if (!inBlockquote && state.blockquoteDepth >= 0) {
+                            ensureBlankLine(result);
+                            state.blockquoteDepth = -1;
+                            return;
+                          }
+
+                          if (!inList && state.listDepth >= 0) {
+                            ensureBlankLine(result);
+                            state.listDepth = -1;
+                            return;
+                          }
+
+                          if (inBlockquote || inList) {
+                            if (![result hasSuffix:@"\n"]) {
+                              [result appendString:@"\n"];
+                            }
+                            return;
+                          }
+
+                          ensureBlankLine(result);
+                          return;
+                        }
+
+                        // Headings
+                        NSString *markdownType = attrs[MarkdownTypeAttributeName];
+
+                        if (markdownType && [markdownType hasPrefix:@"heading-"]) {
+                          if (![markdownType isEqualToString:currentHeadingType]) {
+                            flushHeading();
+                            currentHeadingType = markdownType;
+                            headingContent = [NSMutableString string];
+                          }
+                          [headingContent
+                              appendString:[text stringByTrimmingCharactersInSet:[NSCharacterSet newlineCharacterSet]]];
+                          return;
+                        } else if (currentHeadingType) {
+                          flushHeading();
+                        }
+
+                        // Code blocks
+                        NSNumber *isCodeBlock = attrs[CodeBlockAttributeName];
+                        if ([isCodeBlock boolValue]) {
+                          if (state.needsBlankLine) {
+                            ensureBlankLine(result);
+                            state.needsBlankLine = NO;
+                          }
+
+                          BOOL needsFence = (result.length == 0) || [result hasSuffix:@"\n\n"];
+                          if (needsFence) {
+                            [result appendString:@"```\n"];
+                          }
+
+                          [result appendString:text];
+
+                          if ([text hasSuffix:@"\n"]) {
+                            [result appendString:@"```\n"];
+                            state.needsBlankLine = YES;
+                          }
+                          return;
+                        }
+
+                        // Blockquotes
+                        NSNumber *bqDepthNum = attrs[BlockquoteDepthAttributeName];
+                        NSInteger currentBqDepth = bqDepthNum ? [bqDepthNum integerValue] : -1;
+                        NSString *blockquotePrefix = nil;
+
+                        if (currentBqDepth >= 0) {
+                          blockquotePrefix = buildBlockquotePrefix(currentBqDepth);
+                          state.blockquoteDepth = currentBqDepth;
+                        } else if (state.blockquoteDepth >= 0) {
+                          ensureBlankLine(result);
+                          state.blockquoteDepth = -1;
+                        }
+
+                        // Lists
+                        NSNumber *listDepthNum = attrs[@"ListDepth"];
+                        NSNumber *listTypeNum = attrs[@"ListType"];
+                        NSNumber *listItemNum = attrs[@"ListItemNumber"];
+                        NSInteger currentListDepth = listDepthNum ? [listDepthNum integerValue] : -1;
+
+                        if (currentListDepth >= 0) {
+                          state.listDepth = currentListDepth;
+                        } else if (state.listDepth >= 0) {
+                          ensureBlankLine(result);
+                          state.listDepth = -1;
+                        }
+
+                        // Inline formatting
+                        BOOL isBold, isItalic, isMonospace;
+                        extractFontTraits(attrs, &isBold, &isItalic, &isMonospace);
+
+                        NSString *linkURL = attrs[NSLinkAttributeName];
+                        NSString *segment = applyInlineFormatting(text, isBold, isItalic, isMonospace, linkURL);
+
+                        // Add block prefixes at line start
+                        if (isAtLineStart(result)) {
+                          NSMutableString *prefixedSegment = [NSMutableString string];
+
+                          if (listDepthNum && ![text hasPrefix:@"\n"]) {
+                            BOOL isOrdered = ([listTypeNum integerValue] == 1);
+                            NSInteger itemNumber = listItemNum ? [listItemNum integerValue] : 1;
+                            [prefixedSegment appendString:buildListPrefix(currentListDepth, isOrdered, itemNumber)];
+                          }
+
+                          if (blockquotePrefix) {
+                            [prefixedSegment insertString:blockquotePrefix atIndex:0];
+                          }
+
+                          [prefixedSegment appendString:segment];
+                          segment = prefixedSegment;
+                        }
+
+                        if (state.needsBlankLine && result.length > 0) {
+                          ensureBlankLine(result);
+                          state.needsBlankLine = NO;
+                        }
+
+                        [result appendString:segment];
+                      }];
+
+  // Flush remaining heading
+  if (currentHeadingType && headingContent.length > 0) {
+    ensureBlankLine(result);
+    NSInteger level = [[currentHeadingType substringFromIndex:8] integerValue];
+    [result appendFormat:@"%@%@\n", buildHeadingPrefix(level), headingContent];
+  }
+
+  return result.length > 0 ? result : nil;
+}

package/ios/utils/ParagraphStyleUtils.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+extern NSAttributedString *kNewlineAttributedString;
+
+NSMutableParagraphStyle *getOrCreateParagraphStyle(NSMutableAttributedString *output, NSUInteger index);
+void applyParagraphSpacing(NSMutableAttributedString *output, NSUInteger start, CGFloat marginBottom);
+void applyBlockSpacing(NSMutableAttributedString *output, CGFloat marginBottom);
+void applyLineHeight(NSMutableAttributedString *output, NSRange range, CGFloat lineHeight);
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ParagraphStyleUtils.m

@@ -0,0 +1,56 @@
+#import "ParagraphStyleUtils.h"
+
+NSAttributedString *kNewlineAttributedString;
+static NSParagraphStyle *kBlockSpacerTemplate;
+
+__attribute__((constructor)) static void initParagraphStyleUtils(void)
+{
+  kNewlineAttributedString = [[NSAttributedString alloc] initWithString:@"\n"];
+
+  NSMutableParagraphStyle *template = [[NSMutableParagraphStyle alloc] init];
+  template.minimumLineHeight = 1;
+  template.maximumLineHeight = 1;
+  kBlockSpacerTemplate = [template copy];
+}
+
+NSMutableParagraphStyle *getOrCreateParagraphStyle(NSMutableAttributedString *output, NSUInteger index)
+{
+  NSParagraphStyle *existing = [output attribute:NSParagraphStyleAttributeName atIndex:index effectiveRange:NULL];
+  return existing ? [existing mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+}
+
+void applyParagraphSpacing(NSMutableAttributedString *output, NSUInteger start, CGFloat marginBottom)
+{
+  [output appendAttributedString:kNewlineAttributedString];
+
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, start);
+  style.paragraphSpacing = marginBottom;
+
+  NSRange range = NSMakeRange(start, output.length - start);
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}
+
+void applyBlockSpacing(NSMutableAttributedString *output, CGFloat marginBottom)
+{
+  NSUInteger spacerLocation = output.length;
+  [output appendAttributedString:kNewlineAttributedString];
+
+  NSMutableParagraphStyle *spacerStyle = [kBlockSpacerTemplate mutableCopy];
+  spacerStyle.paragraphSpacing = marginBottom;
+
+  [output addAttribute:NSParagraphStyleAttributeName value:spacerStyle range:NSMakeRange(spacerLocation, 1)];
+}
+
+void applyLineHeight(NSMutableAttributedString *output, NSRange range, CGFloat lineHeight)
+{
+  if (lineHeight <= 0) {
+    return;
+  }
+
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, range.location);
+
+  style.minimumLineHeight = lineHeight;
+  style.maximumLineHeight = lineHeight;
+
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}

package/ios/utils/PasteboardUtils.h

@@ -0,0 +1,36 @@
+#pragma once
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Copies attributed string to pasteboard with multiple representations
+ * (plain text, Markdown, HTML, RTFD, RTF). Receiving apps pick the richest format they support.
+ */
+void copyAttributedStringToPasteboard(NSAttributedString *attributedString, NSString *_Nullable markdown,
+                                      StyleConfig *_Nullable styleConfig);
+
+/**
+ * Extracts markdown for the given range.
+ * Full selection returns cached markdown; partial selection reverse-engineers from attributes.
+ */
+NSString *_Nullable markdownForRange(NSAttributedString *attributedText, NSRange range,
+                                     NSString *_Nullable cachedMarkdown);
+
+/**
+ * Returns remote image URLs (http/https only) from ImageAttachments in the given range.
+ */
+NSArray<NSString *> *imageURLsInRange(NSAttributedString *attributedText, NSRange range);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END