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

package/ios/utils/ParagraphStyleUtils.m

@@ -0,0 +1,349 @@
+#import "ParagraphStyleUtils.h"
+#import "LastElementUtils.h"
+#import <React/RCTI18nUtil.h>
+
+NSAttributedString *kNewlineAttributedString;
+static NSParagraphStyle *kBlockSpacerTemplate;
+
+NSLineBreakStrategy ENRMResolveLineBreakStrategy(NSString *strategy)
+{
+  if ([strategy isEqualToString:@"standard"]) {
+    return NSLineBreakStrategyStandard;
+  } else if ([strategy isEqualToString:@"hangul-word"]) {
+    return NSLineBreakStrategyHangulWordPriority;
+  } else if ([strategy isEqualToString:@"push-out"]) {
+    return NSLineBreakStrategyPushOut;
+  }
+  return NSLineBreakStrategyNone;
+}
+
+__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];
+}
+
+ENRMWritingDirectionMode ENRMResolveWritingDirectionMode(NSString *value)
+{
+  if ([value isEqualToString:@"ltr"]) {
+    return ENRMWritingDirectionModeLTR;
+  }
+  if ([value isEqualToString:@"rtl"]) {
+    return ENRMWritingDirectionModeRTL;
+  }
+  if ([value isEqualToString:@"auto"]) {
+    return ENRMWritingDirectionModeAuto;
+  }
+  return ENRMWritingDirectionModeFirstStrong;
+}
+
+static BOOL ENRMIsStrongRTLChar(unichar c)
+{
+  return (c >= 0x0590 && c <= 0x08FF) || (c >= 0xFB1D && c <= 0xFDFF) || (c >= 0xFE70 && c <= 0xFEFF);
+}
+
+NSWritingDirection ENRMFirstStrongDirection(NSString *text)
+{
+  NSCharacterSet *letters = [NSCharacterSet letterCharacterSet];
+  NSUInteger length = text.length;
+  for (NSUInteger i = 0; i < length; i++) {
+    unichar c = [text characterAtIndex:i];
+    if (![letters characterIsMember:c]) {
+      continue;
+    }
+    return ENRMIsStrongRTLChar(c) ? NSWritingDirectionRightToLeft : NSWritingDirectionLeftToRight;
+  }
+  return NSWritingDirectionNatural;
+}
+
+BOOL ENRMParagraphIsRTL(NSParagraphStyle *style)
+{
+  if (style && style.baseWritingDirection != NSWritingDirectionNatural) {
+    return style.baseWritingDirection == NSWritingDirectionRightToLeft;
+  }
+  return [[RCTI18nUtil sharedInstance] isRTL];
+}
+
+void ENRMApplyWritingDirectionMode(NSMutableAttributedString *output, ENRMWritingDirectionMode mode,
+                                   NSWritingDirection layoutDirection)
+{
+  switch (mode) {
+    case ENRMWritingDirectionModeAuto:
+      ENRMApplyWritingDirectionToParagraphStyles(output, NSWritingDirectionNatural);
+      break;
+    case ENRMWritingDirectionModeLTR:
+      ENRMApplyWritingDirectionToParagraphStyles(output, NSWritingDirectionLeftToRight);
+      break;
+    case ENRMWritingDirectionModeRTL:
+      ENRMApplyWritingDirectionToParagraphStyles(output, NSWritingDirectionRightToLeft);
+      break;
+    case ENRMWritingDirectionModeFirstStrong:
+      ENRMApplyFirstStrongParagraphDirections(output, layoutDirection);
+      break;
+  }
+}
+
+void ENRMApplyFirstStrongParagraphDirections(NSMutableAttributedString *output, NSWritingDirection fallback)
+{
+  if (output.length == 0) {
+    return;
+  }
+  NSString *string = output.string;
+  NSUInteger length = string.length;
+  NSUInteger position = 0;
+  while (position < length) {
+    NSRange paragraphRange = [string paragraphRangeForRange:NSMakeRange(position, 0)];
+    if (NSMaxRange(paragraphRange) <= position) {
+      break;
+    }
+    position = NSMaxRange(paragraphRange);
+
+    NSNumber *isCodeBlock = [output attribute:CodeBlockAttributeName
+                                      atIndex:paragraphRange.location
+                               effectiveRange:nil];
+    if (isCodeBlock.boolValue) {
+      continue;
+    }
+
+    NSWritingDirection direction = ENRMFirstStrongDirection([string substringWithRange:paragraphRange]);
+    if (direction == NSWritingDirectionNatural) {
+      direction = fallback;
+    }
+    if (direction == NSWritingDirectionNatural) {
+      continue;
+    }
+
+    [output enumerateAttribute:NSParagraphStyleAttributeName
+                       inRange:paragraphRange
+                       options:0
+                    usingBlock:^(NSParagraphStyle *style, NSRange range, BOOL *stop) {
+                      if (style != nil && style.baseWritingDirection == direction) {
+                        return;
+                      }
+                      NSMutableParagraphStyle *updated =
+                          style ? [style mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+                      updated.baseWritingDirection = direction;
+                      [output addAttribute:NSParagraphStyleAttributeName value:updated range:range];
+                    }];
+  }
+}
+
+void ENRMApplyWritingDirectionToParagraphStyles(NSMutableAttributedString *output, NSWritingDirection writingDirection)
+{
+  if (output.length == 0) {
+    return;
+  }
+  [output enumerateAttribute:NSParagraphStyleAttributeName
+                     inRange:NSMakeRange(0, output.length)
+                     options:0
+                  usingBlock:^(NSParagraphStyle *style, NSRange range, BOOL *stop) {
+                    if (!style) {
+                      return;
+                    }
+                    NSNumber *isCodeBlock = [output attribute:CodeBlockAttributeName
+                                                      atIndex:range.location
+                                               effectiveRange:nil];
+                    if (isCodeBlock.boolValue) {
+                      return;
+                    }
+                    NSMutableParagraphStyle *mutable = [style mutableCopy];
+                    mutable.baseWritingDirection = writingDirection;
+                    [output addAttribute:NSParagraphStyleAttributeName value:mutable range:range];
+                  }];
+}
+
+NSMutableParagraphStyle *getOrCreateParagraphStyle(NSMutableAttributedString *output, NSUInteger index)
+{
+  NSParagraphStyle *existing = [output attribute:NSParagraphStyleAttributeName atIndex:index effectiveRange:NULL];
+  NSMutableParagraphStyle *style = existing ? [existing mutableCopy] : [[NSMutableParagraphStyle alloc] init];
+  return style;
+}
+
+void applyParagraphSpacingAfter(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];
+}
+
+NSUInteger applyParagraphSpacingBefore(NSMutableAttributedString *output, NSRange range, CGFloat marginTop)
+{
+  if (marginTop <= 0 || range.location == 0)
+    return 0;
+
+  NSUInteger prevIdx = range.location - 1;
+  if ([output.string characterAtIndex:prevIdx] != '\n')
+    return 0;
+
+  NSParagraphStyle *prevStyle = [output attribute:NSParagraphStyleAttributeName atIndex:prevIdx effectiveRange:NULL];
+
+  CGFloat prevMarginBottom = prevStyle.paragraphSpacing;
+  if (prevMarginBottom >= marginTop)
+    return 0;
+
+  CGFloat extraGap = marginTop - prevMarginBottom;
+
+  NSMutableParagraphStyle *spacerStyle = [kBlockSpacerTemplate mutableCopy];
+  spacerStyle.paragraphSpacing = MAX(0, extraGap - 1.0);
+
+  NSDictionary *attrs = @{NSParagraphStyleAttributeName : spacerStyle};
+  NSAttributedString *spacer = [[NSAttributedString alloc] initWithString:@"\n" attributes:attrs];
+
+  [output insertAttributedString:spacer atIndex:range.location];
+  return 1;
+}
+
+NSUInteger applyBlockSpacingBefore(NSMutableAttributedString *output, NSUInteger insertionPoint, CGFloat marginTop)
+{
+  if (marginTop <= 0) {
+    return 0;
+  }
+
+  CGFloat spacing = marginTop;
+
+  // At index 0 the spacer \n produces a 1pt line fragment (minimumLineHeight=1)
+  // on top of paragraphSpacing. Subtract it so the total equals the desired margin.
+  // For non-zero positions the 1pt is intentional inter-block spacing.
+  if (insertionPoint == 0) {
+    spacing = MAX(0, marginTop - 1.0);
+  }
+
+  NSMutableParagraphStyle *spacerStyle = [kBlockSpacerTemplate mutableCopy];
+  spacerStyle.paragraphSpacing = spacing;
+
+  NSAttributedString *spacer =
+      [[NSAttributedString alloc] initWithString:@"\n" attributes:@{NSParagraphStyleAttributeName : spacerStyle}];
+
+  [output insertAttributedString:spacer atIndex:insertionPoint];
+  return 1;
+}
+
+void applyBlockSpacingAfter(NSMutableAttributedString *output, CGFloat marginBottom)
+{
+  if (marginBottom <= 0) {
+    return;
+  }
+
+  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];
+}
+
+// TODO: Extend baseline offset to every block that calls applyLineHeight (headings, blockquotes,
+// code blocks, list items). Keep per-block range scoping — not a whole-document pass like RN Text,
+// since blocks can use different line heights. Optionally consolidate into a single post-pass in
+// AttributedRenderer; evaluate RN's per-line mode (enableIOSTextBaselineOffsetPerLine) if needed.
+void applyBaselineOffset(NSMutableAttributedString *output, NSRange range)
+{
+  if (range.length == 0) {
+    return;
+  }
+
+  __block CGFloat maximumLineHeight = 0;
+  [output enumerateAttribute:NSParagraphStyleAttributeName
+                     inRange:range
+                     options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                  usingBlock:^(NSParagraphStyle *paragraphStyle, __unused NSRange subrange, __unused BOOL *stop) {
+                    if (!paragraphStyle) {
+                      return;
+                    }
+                    maximumLineHeight = MAX(paragraphStyle.maximumLineHeight, maximumLineHeight);
+                  }];
+
+  if (maximumLineHeight <= 0) {
+    return;
+  }
+
+  __block CGFloat maximumFontLineHeight = 0;
+  [output enumerateAttribute:NSFontAttributeName
+                     inRange:range
+                     options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                  usingBlock:^(UIFont *font, __unused NSRange subrange, __unused BOOL *stop) {
+                    if (!font) {
+                      return;
+                    }
+                    maximumFontLineHeight = MAX(font.lineHeight, maximumFontLineHeight);
+                  }];
+
+  if (maximumFontLineHeight <= 0 || maximumLineHeight < maximumFontLineHeight) {
+    return;
+  }
+
+  CGFloat baseLineOffset = (maximumLineHeight - maximumFontLineHeight) / 2.0;
+
+  [output enumerateAttribute:NSBaselineOffsetAttributeName
+                     inRange:range
+                     options:0
+                  usingBlock:^(NSNumber *existingOffset, NSRange subrange, BOOL *stop) {
+                    if (existingOffset != nil) {
+                      return;
+                    }
+                    [output addAttribute:NSBaselineOffsetAttributeName value:@(baseLineOffset) range:subrange];
+                  }];
+}
+
+void applyTextAlignment(NSMutableAttributedString *output, NSRange range, NSTextAlignment textAlign)
+{
+  NSMutableParagraphStyle *style = getOrCreateParagraphStyle(output, range.location);
+  style.alignment = textAlign;
+  [output addAttribute:NSParagraphStyleAttributeName value:style range:range];
+}
+
+void ENRMApplyLineBreakStrategyToParagraphStyles(NSMutableAttributedString *output,
+                                                 NSLineBreakStrategy lineBreakStrategy)
+{
+  if (output.length == 0) {
+    return;
+  }
+  [output enumerateAttribute:NSParagraphStyleAttributeName
+                     inRange:NSMakeRange(0, output.length)
+                     options:0
+                  usingBlock:^(NSParagraphStyle *value, NSRange range, BOOL *stop) {
+                    if (!value) {
+                      return;
+                    }
+                    NSMutableParagraphStyle *mutable = [value mutableCopy];
+                    mutable.lineBreakStrategy = lineBreakStrategy;
+                    [output addAttribute:NSParagraphStyleAttributeName value:mutable range:range];
+                  }];
+}
+
+NSTextAlignment textAlignmentFromString(NSString *textAlign)
+{
+  if ([textAlign isEqualToString:@"left"]) {
+    return NSTextAlignmentLeft;
+  } else if ([textAlign isEqualToString:@"center"]) {
+    return NSTextAlignmentCenter;
+  } else if ([textAlign isEqualToString:@"right"]) {
+    return NSTextAlignmentRight;
+  } else if ([textAlign isEqualToString:@"justify"]) {
+    return NSTextAlignmentJustified;
+  }
+  return NSTextAlignmentNatural;
+}

package/ios/utils/PasteboardUtils.h

@@ -0,0 +1,48 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+@class StyleConfig;
+
+static NSString *const kUTIPlainText = @"public.utf8-plain-text";
+static NSString *const kUTIHTML = @"public.html";
+static NSString *const kUTIMarkdown = @"net.daringfireball.markdown";
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Copies a plain string to the platform pasteboard.
+ */
+void copyStringToPasteboard(NSString *string);
+
+/// Copies a { UTI → NSString | NSData } dictionary to the platform pasteboard.
+void copyItemsToPasteboard(NSDictionary<NSString *, id> *items);
+
+/**
+ * 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 ENRMImageAttachments in the given range.
+ */
+NSArray<NSString *> *imageURLsInRange(NSAttributedString *attributedText, NSRange range);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/PasteboardUtils.m

@@ -0,0 +1,162 @@
+#import "PasteboardUtils.h"
+#import "ENRMImageAttachment.h"
+#import "HTMLGenerator.h"
+#import "MarkdownExtractor.h"
+#import "RTFExportUtils.h"
+#import "StyleConfig.h"
+#include <TargetConditionals.h>
+#if !TARGET_OS_OSX
+#import <UIKit/UIPasteboard.h>
+#endif
+
+static NSString *const kUTIRTFD = @"com.apple.rtfd";
+static NSString *const kUTIFlatRTFD = @"com.apple.flat-rtfd";
+static NSString *const kUTIRTF = @"public.rtf";
+
+#pragma mark - Private Helpers
+
+static void addRTFData(NSMutableDictionary *items, NSAttributedString *attributedString, NSRange range,
+                       NSString *documentType, NSString *uti)
+{
+  NSError *error = nil;
+  NSData *data = [attributedString dataFromRange:range
+                              documentAttributes:@{NSDocumentTypeDocumentAttribute : documentType}
+                                           error:&error];
+  if (data && !error) {
+    items[uti] = data;
+  }
+}
+
+static void addRTFDData(NSMutableDictionary *items, NSAttributedString *attributedString, NSRange range)
+{
+  NSError *error = nil;
+  NSFileWrapper *wrapper =
+      [attributedString fileWrapperFromRange:range
+                          documentAttributes:@{NSDocumentTypeDocumentAttribute : NSRTFDTextDocumentType}
+                                       error:&error];
+  if (wrapper && !error) {
+    NSData *data = [wrapper serializedRepresentation];
+    if (data) {
+      items[kUTIFlatRTFD] = data;
+    }
+  }
+}
+
+static void addHTMLData(NSMutableDictionary *items, NSAttributedString *attributedString, StyleConfig *styleConfig)
+{
+  NSString *html = generateHTML(attributedString, styleConfig);
+  if (html) {
+    NSData *data = [html dataUsingEncoding:NSUTF8StringEncoding];
+    if (data) {
+      items[kUTIHTML] = data;
+    }
+  }
+}
+
+#pragma mark - Public API
+
+void copyStringToPasteboard(NSString *string)
+{
+#if !TARGET_OS_OSX
+  [[UIPasteboard generalPasteboard] setString:string];
+#else
+  NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+  [pasteboard clearContents];
+  [pasteboard setString:string forType:kUTIPlainText];
+#endif
+}
+
+void copyItemsToPasteboard(NSDictionary<NSString *, id> *items)
+{
+#if !TARGET_OS_OSX
+  [[UIPasteboard generalPasteboard] setItems:@[ items ]];
+#else
+  NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+  [pasteboard clearContents];
+  for (NSString *type in items) {
+    id value = items[type];
+    if ([value isKindOfClass:[NSString class]]) {
+      [pasteboard setString:value forType:type];
+    } else if ([value isKindOfClass:[NSData class]]) {
+      [pasteboard setData:value forType:type];
+    }
+  }
+#endif
+}
+
+void copyAttributedStringToPasteboard(NSAttributedString *attributedString, NSString *_Nullable markdown,
+                                      StyleConfig *_Nullable styleConfig)
+{
+  if (!attributedString || attributedString.length == 0)
+    return;
+
+  NSMutableDictionary *items = [NSMutableDictionary dictionary];
+
+  items[kUTIPlainText] = attributedString.string;
+
+  if (markdown.length > 0) {
+    items[kUTIMarkdown] = markdown;
+  }
+
+  if (styleConfig) {
+    addHTMLData(items, attributedString, styleConfig);
+  }
+
+  // RTF export requires preprocessing (backgrounds, markers, normalized spacing)
+  NSAttributedString *rtfPrepared = prepareAttributedStringForRTFExport(attributedString, styleConfig);
+  NSRange rtfRange = NSMakeRange(0, rtfPrepared.length);
+
+  addRTFDData(items, rtfPrepared, rtfRange);
+  addRTFData(items, rtfPrepared, rtfRange, NSRTFTextDocumentType, kUTIRTF);
+
+  copyItemsToPasteboard(items);
+}
+
+#pragma mark - Content Extraction
+
+NSString *_Nullable markdownForRange(NSAttributedString *attributedText, NSRange range,
+                                     NSString *_Nullable cachedMarkdown)
+{
+  if (!cachedMarkdown || range.length == 0)
+    return nil;
+
+  if (!attributedText || range.location >= attributedText.length)
+    return nil;
+
+  range.length = MIN(range.length, attributedText.length - range.location);
+
+  // Full selection: use cached markdown directly
+  BOOL isFullSelection = (range.location == 0 && range.length >= attributedText.length - 1);
+  if (isFullSelection) {
+    return cachedMarkdown;
+  }
+
+  // Partial selection: reverse-engineer from attributes
+  return extractMarkdownFromAttributedString(attributedText, range);
+}
+
+NSArray<NSString *> *imageURLsInRange(NSAttributedString *attributedText, NSRange range)
+{
+  if (!attributedText || range.location == NSNotFound || range.length == 0 || range.location >= attributedText.length) {
+    return @[];
+  }
+
+  range.length = MIN(range.length, attributedText.length - range.location);
+
+  NSMutableArray<NSString *> *urls = [NSMutableArray array];
+
+  [attributedText enumerateAttribute:NSAttachmentAttributeName
+                             inRange:range
+                             options:0
+                          usingBlock:^(id value, NSRange r, BOOL *stop) {
+                            if (![value isKindOfClass:[ENRMImageAttachment class]])
+                              return;
+
+                            NSString *url = ((ENRMImageAttachment *)value).imageURL;
+                            if ([url hasPrefix:@"http://"] || [url hasPrefix:@"https://"]) {
+                              [urls addObject:url];
+                            }
+                          }];
+
+  return urls;
+}

package/ios/utils/RTFExportUtils.h

@@ -0,0 +1,24 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Prepares NSAttributedString for RTF/RTFD export by adding backgrounds,
+ * inserting text markers (>, •, 1.), and normalizing paragraph styles.
+ */
+NSAttributedString *prepareAttributedStringForRTFExport(NSAttributedString *attributedString,
+                                                        StyleConfig *_Nullable styleConfig);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END