@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.10

package/ios/utils/EditMenuUtils.m

@@ -0,0 +1,143 @@
+#import "EditMenuUtils.h"
+#import "PasteboardUtils.h"
+#import "StyleConfig.h"
+#include <TargetConditionals.h>
+
+#if !TARGET_OS_OSX
+
+static NSString *const kMenuIdentifierStandardEdit = @"com.apple.menu.standard-edit";
+static NSString *const kActionIdentifierCopy = @"com.swmansion.enriched.tiptap.copy";
+static NSString *const kActionIdentifierCopyTiptap = @"com.swmansion.enriched.tiptap.copyTiptap";
+static NSString *const kActionIdentifierCopyImageURL = @"com.swmansion.enriched.tiptap.copyImageURL";
+
+static UIAction *createCopyAction(NSAttributedString *selectedText, NSString *tiptap, StyleConfig *styleConfig,
+                                  NSString *copyLabel)
+{
+  return [UIAction actionWithTitle:copyLabel
+                             image:[RCTUIImage systemImageNamed:@"doc.on.doc"]
+                        identifier:kActionIdentifierCopy
+                           handler:^(__kindof UIAction *action) {
+                             copyAttributedStringToPasteboard(selectedText, tiptap, styleConfig);
+                           }];
+}
+
+static UIAction *_Nullable createCopyTiptapAction(NSString *tiptap, NSString *copyAsTiptapLabel)
+{
+  if (tiptap.length == 0)
+    return nil;
+
+  return [UIAction actionWithTitle:copyAsTiptapLabel
+                             image:[RCTUIImage systemImageNamed:@"doc.text"]
+                        identifier:kActionIdentifierCopyTiptap
+                           handler:^(__kindof UIAction *action) { copyStringToPasteboard(tiptap); }];
+}
+
+static UIAction *_Nullable createCopyImageURLAction(NSArray<NSString *> *imageURLs,
+                                                    ENRMSelectionMenuConfig selectionMenuConfig)
+{
+  if (imageURLs.count == 0)
+    return nil;
+
+  NSString *urlsToCopy = [imageURLs componentsJoinedByString:@"\n"];
+  NSString *title = ENRMResolveImageURLsTitle(selectionMenuConfig, imageURLs.count);
+
+  return [UIAction actionWithTitle:title
+                             image:[RCTUIImage systemImageNamed:@"link"]
+                        identifier:kActionIdentifierCopyImageURL
+                           handler:^(__kindof UIAction *action) { copyStringToPasteboard(urlsToCopy); }];
+}
+
+/// Rebuilds the standard-edit menu with the system Copy swapped for the enhanced
+/// copy action. All other system items are kept — dropping them would remove
+/// Select All, which on iOS 16+ is the only way to start a selection from the
+/// long-press menu of a non-editable text view.
+static UIMenu *createEnhancedStandardEditMenu(UIMenu *originalMenu, UIAction *copyAction)
+{
+  NSMutableArray<UIMenuElement *> *children = [NSMutableArray arrayWithCapacity:originalMenu.children.count];
+  BOOL replacedCopy = NO;
+
+  for (UIMenuElement *element in originalMenu.children) {
+    if (!replacedCopy && [element isKindOfClass:[UICommand class]] &&
+        ((UICommand *)element).action == @selector(copy:)) {
+      [children addObject:copyAction];
+      replacedCopy = YES;
+      continue;
+    }
+    [children addObject:element];
+  }
+
+  if (!replacedCopy) {
+    [children insertObject:copyAction atIndex:0];
+  }
+
+  return [UIMenu menuWithTitle:originalMenu.title
+                         image:originalMenu.image
+                    identifier:originalMenu.identifier
+                       options:originalMenu.options
+                      children:children];
+}
+
+static void addOptionalAction(NSMutableArray<UIMenuElement *> *array, UIAction *_Nullable action)
+{
+  if (action) {
+    [array addObject:action];
+  }
+}
+
+static void insertOptionalAction(NSMutableArray<UIMenuElement *> *array, UIAction *_Nullable action, NSUInteger index)
+{
+  if (action) {
+    [array insertObject:action atIndex:index];
+  }
+}
+
+// TODO: Remove API_AVAILABLE(ios(16.0)) guard when the minimum iOS deployment target in RN is bumped to 16.
+UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range, NSString *_Nullable cachedTiptap,
+                                  StyleConfig *styleConfig, NSArray<UIMenuElement *> *suggestedActions,
+                                  NSArray<UIAction *> *_Nullable customActions,
+                                  ENRMSelectionMenuConfig selectionMenuConfig) API_AVAILABLE(ios(16.0))
+{
+  NSAttributedString *selectedText = [attributedText attributedSubstringFromRange:range];
+  NSString *tiptap = tiptapForRange(attributedText, range, cachedTiptap);
+  NSArray<NSString *> *imageURLs = imageURLsInRange(attributedText, range);
+
+  UIAction *copyAction = createCopyAction(selectedText, tiptap, styleConfig, selectionMenuConfig.copyLabel);
+  UIAction *copyTiptapAction = selectionMenuConfig.copyAsTiptap
+                                     ? createCopyTiptapAction(tiptap, selectionMenuConfig.copyAsTiptapLabel)
+                                     : nil;
+  UIAction *copyImageURLAction =
+      selectionMenuConfig.copyImageURL ? createCopyImageURLAction(imageURLs, selectionMenuConfig) : nil;
+
+  NSMutableArray<UIMenuElement *> *result = [NSMutableArray array];
+  BOOL foundStandardEditMenu = NO;
+
+  for (UIMenuElement *element in suggestedActions) {
+    if ([element isKindOfClass:[UIMenu class]]) {
+      UIMenu *menu = (UIMenu *)element;
+
+      if ([menu.identifier isEqualToString:kMenuIdentifierStandardEdit]) {
+        // Replace standard Copy with our enhanced version
+        [result addObject:createEnhancedStandardEditMenu(menu, copyAction)];
+        addOptionalAction(result, copyTiptapAction);
+        addOptionalAction(result, copyImageURLAction);
+        foundStandardEditMenu = YES;
+        continue;
+      }
+    }
+    [result addObject:element];
+  }
+
+  if (!foundStandardEditMenu) {
+    [result insertObject:copyAction atIndex:0];
+    insertOptionalAction(result, copyTiptapAction, 1);
+    addOptionalAction(result, copyImageURLAction);
+  }
+
+  if (customActions.count > 0) {
+    return [UIMenu menuWithChildren:[customActions arrayByAddingObjectsFromArray:result]];
+  }
+
+  return [UIMenu menuWithChildren:result];
+}
+
+#endif

package/ios/utils/FactoidBackground.h

@@ -0,0 +1,20 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+extern NSString *const FactoidAttributeName;
+extern NSString *const FactoidIdAttributeName;
+extern NSString *const FactoidBackgroundColorAttributeName;
+extern NSString *const FactoidBorderColorAttributeName;
+
+@interface FactoidBackground : NSObject
+
+- (void)drawBackgroundsForGlyphRange:(NSRange)glyphsToShow
+                       layoutManager:(NSLayoutManager *)layoutManager
+                       textContainer:(NSTextContainer *)textContainer
+                             atPoint:(CGPoint)origin;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/FactoidBackground.m

@@ -0,0 +1,161 @@
+#import "FactoidBackground.h"
+
+NSString *const FactoidAttributeName = @"Factoid";
+NSString *const FactoidIdAttributeName = @"factoidId";
+NSString *const FactoidBackgroundColorAttributeName = @"FactoidBackgroundColor";
+NSString *const FactoidBorderColorAttributeName = @"FactoidBorderColor";
+
+static const CGFloat kFactoidCornerRadius = 4.0;
+static const CGFloat kFactoidBorderWidth = 1.0;
+
+@implementation FactoidBackground
+
+- (void)drawBackgroundsForGlyphRange:(NSRange)glyphsToShow
+                       layoutManager:(NSLayoutManager *)layoutManager
+                       textContainer:(NSTextContainer *)textContainer
+                             atPoint:(CGPoint)origin
+{
+  NSTextStorage *textStorage = layoutManager.textStorage;
+  if (!textStorage || textStorage.length == 0)
+    return;
+
+  NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphsToShow actualGlyphRange:NULL];
+  if (charRange.location == NSNotFound || charRange.length == 0)
+    return;
+
+  [textStorage enumerateAttribute:FactoidAttributeName
+                          inRange:NSMakeRange(0, textStorage.length)
+                          options:0
+                       usingBlock:^(id value, NSRange range, BOOL *stop) {
+                         if (!value || range.length == 0)
+                           return;
+                         if (NSIntersectionRange(range, charRange).length == 0)
+                           return;
+
+                         RCTUIColor *backgroundColor =
+                             [textStorage attribute:FactoidBackgroundColorAttributeName atIndex:range.location effectiveRange:NULL];
+                         RCTUIColor *borderColor =
+                             [textStorage attribute:FactoidBorderColorAttributeName atIndex:range.location effectiveRange:NULL];
+                         if (!backgroundColor && !borderColor)
+                           return;
+
+                         [self drawFactoidForRange:range
+                                     layoutManager:layoutManager
+                                     textContainer:textContainer
+                                           atPoint:origin
+                                   backgroundColor:backgroundColor
+                                       borderColor:borderColor];
+                       }];
+}
+
+- (void)drawFactoidForRange:(NSRange)range
+              layoutManager:(NSLayoutManager *)layoutManager
+              textContainer:(NSTextContainer *)textContainer
+                    atPoint:(CGPoint)origin
+            backgroundColor:(RCTUIColor *)backgroundColor
+                borderColor:(RCTUIColor *)borderColor
+{
+  NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:range actualCharacterRange:NULL];
+  if (glyphRange.location == NSNotFound || glyphRange.length == 0)
+    return;
+
+  [layoutManager
+      enumerateLineFragmentsForGlyphRange:glyphRange
+                               usingBlock:^(CGRect rect, CGRect usedRect, NSTextContainer *tc, NSRange lineRange,
+                                            BOOL *stop) {
+                                 (void)usedRect;
+                                 (void)tc;
+                                 (void)stop;
+                                 NSRange intersect = NSIntersectionRange(lineRange, glyphRange);
+                                 if (intersect.length == 0)
+                                   return;
+
+                                 BOOL isFirst = (intersect.location == glyphRange.location);
+                                 BOOL isLast = (NSMaxRange(intersect) == NSMaxRange(glyphRange));
+                                 CGRect textRect = [layoutManager boundingRectForGlyphRange:intersect inTextContainer:textContainer];
+                                 // Full line height, but only as wide as the glyphs. A wrapped factoid stops at
+                                 // the last glyph instead of running out to the line edge.
+                                 CGRect finalRect = CGRectMake(textRect.origin.x + origin.x, rect.origin.y + origin.y,
+                                                               textRect.size.width, rect.size.height);
+                                 [self drawBackgroundAndBorders:finalRect
+                                                backgroundColor:backgroundColor
+                                                    borderColor:borderColor
+                                                        isFirst:isFirst
+                                                         isLast:isLast];
+                               }];
+}
+
+- (void)drawBackgroundAndBorders:(CGRect)rect
+                 backgroundColor:(RCTUIColor *)backgroundColor
+                     borderColor:(RCTUIColor *)borderColor
+                         isFirst:(BOOL)isFirst
+                          isLast:(BOOL)isLast
+{
+  UIBezierPath *path = [self pathForRect:rect isFirst:isFirst isLast:isLast];
+  if (backgroundColor) {
+    [backgroundColor setFill];
+    [path fill];
+  }
+  if (!borderColor)
+    return;
+
+  [borderColor setStroke];
+  UIBezierPath *strokePath = (isFirst && isLast) ? path : [self openBorderPathForRect:rect isFirst:isFirst isLast:isLast];
+  strokePath.lineWidth = kFactoidBorderWidth;
+  BezierPathSetRoundStyle(strokePath);
+  [strokePath stroke];
+}
+
+- (UIBezierPath *)pathForRect:(CGRect)rect isFirst:(BOOL)isFirst isLast:(BOOL)isLast
+{
+#if !TARGET_OS_OSX
+  UIRectCorner corners = 0;
+  if (isFirst)
+    corners |= (UIRectCornerTopLeft | UIRectCornerBottomLeft);
+  if (isLast)
+    corners |= (UIRectCornerTopRight | UIRectCornerBottomRight);
+
+  return [UIBezierPath bezierPathWithRoundedRect:rect
+                               byRoundingCorners:corners
+                                     cornerRadii:CGSizeMake(kFactoidCornerRadius, kFactoidCornerRadius)];
+#else
+  CGFloat cornerRadius = (isFirst || isLast) ? kFactoidCornerRadius : 0;
+  return UIBezierPathWithRoundedRect(rect, cornerRadius);
+#endif
+}
+
+- (UIBezierPath *)openBorderPathForRect:(CGRect)rect isFirst:(BOOL)isFirst isLast:(BOOL)isLast
+{
+  UIBezierPath *path = [UIBezierPath bezierPath];
+  CGFloat r = kFactoidCornerRadius;
+  CGFloat inset = kFactoidBorderWidth / 2.0;
+  CGRect insetRect = CGRectInset(rect, inset, inset);
+
+  if (isFirst) {
+    [path moveToPoint:CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y)];
+    BezierPathAddLine(path, CGPointMake(insetRect.origin.x + r, insetRect.origin.y));
+    BezierPathAddQuadCurve(path, CGPointMake(insetRect.origin.x, insetRect.origin.y + r),
+                           CGPointMake(insetRect.origin.x, insetRect.origin.y));
+    BezierPathAddLine(path, CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect) - r));
+    BezierPathAddQuadCurve(path, CGPointMake(insetRect.origin.x + r, CGRectGetMaxY(insetRect)),
+                           CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect)));
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect)));
+  } else if (isLast) {
+    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(insetRect) - r, insetRect.origin.y));
+    BezierPathAddQuadCurve(path, CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y + r),
+                           CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y));
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect) - r));
+    BezierPathAddQuadCurve(path, CGPointMake(CGRectGetMaxX(insetRect) - r, CGRectGetMaxY(insetRect)),
+                           CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect)));
+    BezierPathAddLine(path, CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect)));
+  } else {
+    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y));
+    [path moveToPoint:CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect))];
+    BezierPathAddLine(path, CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect)));
+  }
+  return path;
+}
+
+@end

package/ios/utils/FontScaleObserver.h

@@ -0,0 +1,10 @@
+#import "ENRMUIKit.h"
+
+@interface FontScaleObserver : NSObject
+
+@property (nonatomic, assign) BOOL allowFontScaling;
+@property (nonatomic, readonly) CGFloat effectiveFontScale;
+
+@property (nonatomic, copy, nullable) void (^onChange)(void);
+
+@end

package/ios/utils/FontScaleObserver.m

@@ -0,0 +1,55 @@
+#import "FontScaleObserver.h"
+#import <React/RCTUtils.h>
+#include <TargetConditionals.h>
+
+@implementation FontScaleObserver {
+  CGFloat _currentFontScale;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _allowFontScaling = YES;
+    _currentFontScale = RCTFontSizeMultiplier();
+
+#if !TARGET_OS_OSX
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(contentSizeCategoryDidChange:)
+                                                 name:UIContentSizeCategoryDidChangeNotification
+                                               object:nil];
+#endif
+    // TODO: Observe macOS system font size changes. UIContentSizeCategoryDidChangeNotification
+    // is iOS-only; macOS has no direct equivalent. Possible approaches: KVO on
+    // NSApplication.effectiveAppearance or polling NSFont.systemFontSize.
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+#if !TARGET_OS_OSX
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:UIContentSizeCategoryDidChangeNotification object:nil];
+#endif
+}
+
+- (CGFloat)effectiveFontScale
+{
+  return _allowFontScaling ? _currentFontScale : 1.0;
+}
+
+- (void)contentSizeCategoryDidChange:(NSNotification *)notification
+{
+  if (!_allowFontScaling) {
+    return;
+  }
+
+  CGFloat newFontScale = RCTFontSizeMultiplier();
+  if (_currentFontScale != newFontScale) {
+    _currentFontScale = newFontScale;
+    if (self.onChange) {
+      self.onChange();
+    }
+  }
+}
+
+@end

package/ios/utils/FontUtils.h

@@ -0,0 +1,31 @@
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+@class BlockStyle;
+@class RenderContext;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Returns a cached UIFont from BlockStyle properties via RenderContext. */
+extern UIFont *cachedFontFromBlockStyle(BlockStyle *blockStyle, RenderContext *context);
+
+/** Returns the font scale multiplier, capped by maxFontSizeMultiplier.
+ *  Uses React Native's RCTFontSizeMultiplier() internally.
+ *  @param maxFontSizeMultiplier Values >= 1.0 cap the result, < 1.0 means no cap. */
+extern CGFloat RCTFontSizeMultiplierWithMax(CGFloat maxFontSizeMultiplier);
+
+/** Converts a CSS-style font weight string to a UIFontWeight constant.
+ *  Mirrors React Native's RCTFont table: "100"/"ultralight" through
+ *  "900"/"black", plus the "normal"/"regular"/"bold"/etc. aliases.
+ *  Returns UIFontWeightRegular for unrecognised or nil input. */
+extern UIFontWeight ENRMFontWeightFromString(NSString *_Nullable weightString);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/FontUtils.m

@@ -0,0 +1,63 @@
+#import "FontUtils.h"
+#import "RenderContext.h"
+#import <React/RCTUtils.h>
+
+UIFont *cachedFontFromBlockStyle(BlockStyle *blockStyle, RenderContext *context)
+{
+  if (!blockStyle) {
+    return nil;
+  }
+  if (blockStyle.cachedFont) {
+    return blockStyle.cachedFont;
+  }
+  return [context cachedFontForSize:blockStyle.fontSize family:blockStyle.fontFamily weight:blockStyle.fontWeight];
+}
+
+CGFloat RCTFontSizeMultiplierWithMax(CGFloat maxFontSizeMultiplier)
+{
+  CGFloat multiplier = RCTFontSizeMultiplier();
+
+  // Apply maxFontSizeMultiplier cap if >= 1.0
+  // Values < 1.0 (including 0 and NaN) mean no cap is applied
+  if (!isnan(maxFontSizeMultiplier) && maxFontSizeMultiplier >= 1.0) {
+    return fmin(maxFontSizeMultiplier, multiplier);
+  }
+
+  return multiplier;
+}
+
+UIFontWeight ENRMFontWeightFromString(NSString *weightString)
+{
+  if (weightString.length == 0) {
+    return UIFontWeightRegular;
+  }
+  if ([weightString isEqualToString:@"ultralight"] || [weightString isEqualToString:@"100"]) {
+    return UIFontWeightUltraLight;
+  }
+  if ([weightString isEqualToString:@"thin"] || [weightString isEqualToString:@"200"]) {
+    return UIFontWeightThin;
+  }
+  if ([weightString isEqualToString:@"light"] || [weightString isEqualToString:@"300"]) {
+    return UIFontWeightLight;
+  }
+  if ([weightString isEqualToString:@"normal"] || [weightString isEqualToString:@"regular"] ||
+      [weightString isEqualToString:@"400"]) {
+    return UIFontWeightRegular;
+  }
+  if ([weightString isEqualToString:@"medium"] || [weightString isEqualToString:@"500"]) {
+    return UIFontWeightMedium;
+  }
+  if ([weightString isEqualToString:@"semibold"] || [weightString isEqualToString:@"600"]) {
+    return UIFontWeightSemibold;
+  }
+  if ([weightString isEqualToString:@"bold"] || [weightString isEqualToString:@"700"]) {
+    return UIFontWeightBold;
+  }
+  if ([weightString isEqualToString:@"heavy"] || [weightString isEqualToString:@"800"]) {
+    return UIFontWeightHeavy;
+  }
+  if ([weightString isEqualToString:@"black"] || [weightString isEqualToString:@"900"]) {
+    return UIFontWeightBlack;
+  }
+  return UIFontWeightRegular;
+}

package/ios/utils/HTMLGenerator.h

@@ -0,0 +1,25 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Generates semantic HTML with inline styles (email-client compatible).
+/// Document direction is read from the first paragraph style of `attributedString`.
+NSString *_Nullable generateHTML(NSAttributedString *attributedString, StyleConfig *styleConfig);
+
+/// Generates an HTML `<table>` with inline styles from rows of cell dictionaries.
+/// Table direction is read from the first paragraph style of the first non-empty cell.
+NSString *_Nullable generateTableHTML(NSArray<NSArray<NSDictionary *> *> *rows, StyleConfig *styleConfig);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END