react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.10

package/ios/utils/ENRMChipDrawing.m

@@ -0,0 +1,83 @@
+#import "ENRMChipDrawing.h"
+
+static UIBezierPath *chipFillPath(CGRect rect, CGFloat r, BOOL isFirst, 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(r, r)];
+#else
+  // NSBezierPath doesn't support per-corner rounding — use uniform corner radius
+  return UIBezierPathWithRoundedRect(rect, (isFirst || isLast) ? r : 0);
+#endif
+}
+
+static UIBezierPath *chipOpenBorderPath(CGRect rect, CGFloat r, CGFloat borderWidth, BOOL isFirst, BOOL isLast)
+{
+  UIBezierPath *path = [UIBezierPath bezierPath];
+  CGFloat inset = borderWidth / 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;
+}
+
+void ENRMDrawChipFragment(CGRect rect, RCTUIColor *backgroundColor, RCTUIColor *borderColor, CGFloat borderWidth,
+                          CGFloat cornerRadius, BOOL isFirst, BOOL isLast, BOOL strokeInset)
+{
+  if (CGRectIsEmpty(rect))
+    return;
+
+  CGFloat r = MIN(MAX(cornerRadius, 0), MIN(rect.size.width, rect.size.height) / 2.0);
+
+  if (backgroundColor) {
+    [backgroundColor setFill];
+    [chipFillPath(rect, r, isFirst, isLast) fill];
+  }
+
+  if (!borderColor || borderWidth <= 0)
+    return;
+
+  [borderColor setStroke];
+  UIBezierPath *strokePath;
+  if (isFirst && isLast) {
+    if (strokeInset) {
+      CGFloat inset = borderWidth / 2.0;
+      strokePath = chipFillPath(CGRectInset(rect, inset, inset), MAX(r - inset, 0), YES, YES);
+    } else {
+      strokePath = chipFillPath(rect, r, YES, YES);
+    }
+  } else {
+    strokePath = chipOpenBorderPath(rect, r, borderWidth, isFirst, isLast);
+  }
+  strokePath.lineWidth = borderWidth;
+  BezierPathSetRoundStyle(strokePath);
+  [strokePath stroke];
+}

package/ios/utils/ENRMCodeBlockContent.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+@class MarkdownASTNode;
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Shared code block node semantics, used by both markdown flavors so the
+/// meaning of a CodeBlock AST node (its text, language, fence) is defined in
+/// one place. Language display names come from the shared C++ core
+/// (cpp/highlight/CodeBlockLanguages.hpp) so all platforms label fences
+/// identically.
+
+NSString *ENRMCodeBlockExtractCode(MarkdownASTNode *node);
+NSString *_Nullable ENRMCodeBlockLanguage(MarkdownASTNode *node);
+NSString *ENRMCodeBlockFenceChar(MarkdownASTNode *node);
+NSString *ENRMCodeBlockFencedMarkdown(NSString *code, NSString *_Nullable language, NSString *fenceChar);
+NSString *ENRMCodeBlockDisplayLanguageName(NSString *_Nullable language);
+
+/// Applies the flavor-independent code block text attributes (code font,
+/// color, line height, forced-LTR left-aligned paragraph) to the range.
+/// Callers layer their container-specific paragraph adjustments on top (the
+/// commonmark span flavor adds padding indents; the github block view has
+/// none).
+void ENRMApplyCodeBlockTextAttributes(NSMutableAttributedString *string, NSRange range, StyleConfig *config);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMCodeBlockContent.mm

@@ -0,0 +1,79 @@
+#import "ENRMCodeBlockContent.h"
+#include "CodeBlockLanguages.hpp"
+#import "ENRMUIKit.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "StyleConfig.h"
+
+static void ENRMAppendNodeContent(MarkdownASTNode *node, NSMutableString *output)
+{
+  if (node.content.length > 0) {
+    [output appendString:node.content];
+  }
+  for (MarkdownASTNode *child in node.children) {
+    ENRMAppendNodeContent(child, output);
+  }
+}
+
+NSString *ENRMCodeBlockExtractCode(MarkdownASTNode *node)
+{
+  NSMutableString *code = [NSMutableString string];
+  ENRMAppendNodeContent(node, code);
+  NSUInteger end = code.length;
+  while (end > 0 && [code characterAtIndex:end - 1] == '\n') {
+    end--;
+  }
+  return [code substringToIndex:end];
+}
+
+NSString *ENRMCodeBlockLanguage(MarkdownASTNode *node)
+{
+  NSString *language = node.attributes[@"language"];
+  return language.length > 0 ? language : nil;
+}
+
+NSString *ENRMCodeBlockFenceChar(MarkdownASTNode *node)
+{
+  NSString *fenceChar = node.attributes[@"fenceChar"];
+  return fenceChar.length > 0 ? fenceChar : @"`";
+}
+
+NSString *ENRMCodeBlockFencedMarkdown(NSString *code, NSString *language, NSString *fenceChar)
+{
+  NSString *fence = [@"" stringByPaddingToLength:3 withString:fenceChar startingAtIndex:0];
+  return [NSString stringWithFormat:@"%@%@\n%@\n%@", fence, language ?: @"", code, fence];
+}
+
+NSString *ENRMCodeBlockDisplayLanguageName(NSString *language)
+{
+  if (language.length == 0) {
+    return @"";
+  }
+  std::string display = Markdown::displayNameForLanguage(language.UTF8String ?: "");
+  return [NSString stringWithUTF8String:display.c_str()] ?: language;
+}
+
+void ENRMApplyCodeBlockTextAttributes(NSMutableAttributedString *string, NSRange range, StyleConfig *config)
+{
+  if (range.length == 0) {
+    return;
+  }
+
+  UIFont *font = [config codeBlockFont];
+  RCTUIColor *color = [config codeBlockColor];
+  if (color) {
+    [string addAttributes:@{NSFontAttributeName : font, NSForegroundColorAttributeName : color} range:range];
+  } else {
+    [string addAttribute:NSFontAttributeName value:font range:range];
+  }
+
+  CGFloat lineHeight = [config codeBlockLineHeight];
+  if (lineHeight > 0) {
+    applyLineHeight(string, range, lineHeight);
+  }
+
+  NSMutableParagraphStyle *paragraphStyle = [getOrCreateParagraphStyle(string, range.location) mutableCopy];
+  paragraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+  paragraphStyle.alignment = NSTextAlignmentLeft;
+  [string addAttribute:NSParagraphStyleAttributeName value:paragraphStyle range:range];
+}

package/ios/utils/ENRMCodeBlockHighlighter.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Platform adapter over the shared C++ syntax highlighting seam
+/// (cpp/highlight/CodeBlockHighlighter.hpp).
+///
+/// Applies token colors as foreground-color attributes onto a mutable copy of
+/// the plain styled code, so highlighting can never change text metrics and
+/// the block height measured from the plain string stays valid. Token colors
+/// come from the config's resolved per-token palette. Returns nil when
+/// highlighting is unavailable (module compiled out, unknown language, parse
+/// failure); callers keep the plain attributed code.
+NSAttributedString *_Nullable ENRMHighlightedAttributedCode(NSAttributedString *plainCode, NSString *code,
+                                                            NSString *_Nullable language, StyleConfig *config);
+
+/// Applies token foreground colors from the config's palette onto `output`
+/// within `range` (range.location is where the code begins in output). Used by
+/// the commonmark flavor, which renders code inline instead of as a container.
+/// Returns whether any color was applied. No-op when highlighting is
+/// unavailable, so callers keep the plain rendering.
+BOOL ENRMApplyHighlightTokens(NSMutableAttributedString *output, NSRange range, NSString *code,
+                              NSString *_Nullable language, StyleConfig *config);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMCodeBlockHighlighter.mm

@@ -0,0 +1,51 @@
+#import "ENRMCodeBlockHighlighter.h"
+#include "CodeBlockHighlighter.hpp"
+#import "ENRMUIKit.h"
+#import "StyleConfig.h"
+
+BOOL ENRMApplyHighlightTokens(NSMutableAttributedString *output, NSRange range, NSString *code,
+                              NSString *_Nullable language, StyleConfig *config)
+{
+  if (code.length == 0) {
+    return NO;
+  }
+
+  std::vector<Markdown::HighlightToken> tokens;
+  try {
+    tokens = Markdown::highlightCode(code.UTF8String ?: "", language.UTF8String ?: "");
+  } catch (...) {
+    return NO;
+  }
+  if (tokens.empty()) {
+    return NO;
+  }
+
+  NSUInteger cap = MIN(NSMaxRange(range), output.length);
+  BOOL applied = NO;
+  for (const auto &token : tokens) {
+    RCTUIColor *color = [config codeBlockSyntaxColorForToken:(NSInteger)token.type];
+    if (!color || token.end <= token.start) {
+      continue;
+    }
+    NSUInteger start = range.location + token.start;
+    NSUInteger end = range.location + token.end;
+    if (end > cap) {
+      continue;
+    }
+    [output addAttribute:NSForegroundColorAttributeName value:color range:NSMakeRange(start, end - start)];
+    applied = YES;
+  }
+  return applied;
+}
+
+NSAttributedString *ENRMHighlightedAttributedCode(NSAttributedString *plainCode, NSString *code,
+                                                  NSString *_Nullable language, StyleConfig *config)
+{
+  if (code.length == 0) {
+    return nil;
+  }
+
+  NSMutableAttributedString *highlighted = [plainCode mutableCopy];
+  BOOL applied = ENRMApplyHighlightTokens(highlighted, NSMakeRange(0, highlighted.length), code, language, config);
+  return applied ? highlighted : nil;
+}

package/ios/utils/ENRMFeatureFlags.h

@@ -10,3 +10,10 @@
 #if !defined(ENRICHED_MARKDOWN_MATH)
 #define ENRICHED_MARKDOWN_MATH 0
 #endif
+
+// Code-block syntax highlighting is defined purely by the podspec (no external
+// framework to auto-detect, unlike RaTeX). Default off when the podspec did not
+// enable it; the C++ seam then degrades to no tokens.
+#if !defined(ENRICHED_MARKDOWN_CODE_HIGHLIGHT)
+#define ENRICHED_MARKDOWN_CODE_HIGHLIGHT 0
+#endif

package/ios/utils/ENRMImageDownloader.h

@@ -5,11 +5,21 @@ NS_ASSUME_NONNULL_BEGIN
 
 typedef void (^ENRMImageDownloadCompletion)(RCTUIImage *_Nullable image);
 
+/**
+ * Cache identity for a remote image request. Returns the URL itself when no
+ * headers are set; otherwise appends a SHA-256 digest of the sorted header
+ * pairs, so the same URL fetched with different headers is cached and
+ * deduplicated separately without embedding header values in the key.
+ */
+NSString *ENRMImageCacheKey(NSString *url, NSDictionary<NSString *, NSString *> *_Nullable headers);
+
 @interface ENRMImageDownloader : NSObject
 
 + (instancetype)shared;
 
-- (void)downloadURL:(NSString *)url completion:(ENRMImageDownloadCompletion)completion;
+- (void)downloadURL:(NSString *)url
+            headers:(nullable NSDictionary<NSString *, NSString *> *)headers
+         completion:(ENRMImageDownloadCompletion)completion;
 
 @end
 

package/ios/utils/ENRMImageDownloader.m

@@ -1,5 +1,7 @@
 #import "ENRMImageDownloader.h"
 #import "ENRMImageAttachment.h"
+#import "ENRMLocalImageLoader.h"
+#import <CommonCrypto/CommonDigest.h>
 #include <TargetConditionals.h>
 
 static const NSUInteger kDiskCacheMemoryCapacity = 10 * 1024 * 1024;
@@ -13,6 +15,27 @@ static inline NSUInteger ENRMImageByteCost(RCTUIImage *image)
   return CGImageGetBytesPerRow(cgImage) * CGImageGetHeight(cgImage);
 }
 
+NSString *ENRMImageCacheKey(NSString *url, NSDictionary<NSString *, NSString *> *headers)
+{
+  if (headers.count == 0) {
+    return url;
+  }
+  NSArray<NSString *> *names = [headers.allKeys sortedArrayUsingSelector:@selector(compare:)];
+  NSMutableArray<NSString *> *pairs = [NSMutableArray arrayWithCapacity:names.count];
+  for (NSString *name in names) {
+    [pairs addObject:[NSString stringWithFormat:@"%@:%@", name, headers[name]]];
+  }
+  NSString *joined = [pairs componentsJoinedByString:@"\n"];
+  NSData *data = [joined dataUsingEncoding:NSUTF8StringEncoding];
+  unsigned char digest[CC_SHA256_DIGEST_LENGTH];
+  CC_SHA256(data.bytes, (CC_LONG)data.length, digest);
+  NSMutableString *hash = [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
+  for (int i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
+    [hash appendFormat:@"%02x", digest[i]];
+  }
+  return [NSString stringWithFormat:@"%@|%@", url, hash];
+}
+
 @implementation ENRMImageDownloader {
   NSURLSession *_session;
   NSMutableDictionary<NSString *, NSMutableArray<ENRMImageDownloadCompletion> *> *_inFlightRequests;
@@ -43,56 +66,77 @@ static inline NSUInteger ENRMImageByteCost(RCTUIImage *image)
   return self;
 }
 
-- (void)downloadURL:(NSString *)url completion:(ENRMImageDownloadCompletion)completion
+- (void)downloadURL:(NSString *)url
+            headers:(NSDictionary<NSString *, NSString *> *)headers
+         completion:(ENRMImageDownloadCompletion)completion
 {
   if (url.length == 0) {
     completion(nil);
     return;
   }
 
-  RCTUIImage *cached = [[ENRMImageAttachment originalImageCache] objectForKey:url];
+  BOOL isLocal = ENRMIsLocalImageURL(url);
+  NSString *cacheKey = isLocal ? url : ENRMImageCacheKey(url, headers);
+
+  RCTUIImage *cached = [[ENRMImageAttachment originalImageCache] objectForKey:cacheKey];
   if (cached) {
     completion(cached);
     return;
   }
 
+  if (isLocal) {
+    RCTUIImage *local = ENRMLoadLocalImage(url);
+    if (local) {
+      [[ENRMImageAttachment originalImageCache] setObject:local forKey:cacheKey cost:ENRMImageByteCost(local)];
+    }
+    completion(local);
+    return;
+  }
+
   @synchronized(_inFlightRequests) {
-    NSMutableArray *existing = _inFlightRequests[url];
+    NSMutableArray *existing = _inFlightRequests[cacheKey];
     if (existing) {
       [existing addObject:completion];
       return;
     }
-    _inFlightRequests[url] = [NSMutableArray arrayWithObject:completion];
+    _inFlightRequests[cacheKey] = [NSMutableArray arrayWithObject:completion];
   }
 
   NSURL *nsURL = [NSURL URLWithString:url];
   if (!nsURL) {
-    [self dispatchCallbacksForURL:url image:nil];
+    [self dispatchCallbacksForKey:cacheKey image:nil];
     return;
   }
 
-  [[_session dataTaskWithURL:nsURL
-           completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:nsURL];
+  [headers enumerateKeysAndObjectsUsingBlock:^(NSString *name, NSString *value, BOOL *stop) {
+    [request setValue:value forHTTPHeaderField:name];
+  }];
+
+  [[_session dataTaskWithRequest:request
+               completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
 #if !TARGET_OS_OSX
-             RCTUIImage *image = (data && !error) ? [RCTUIImage imageWithData:data] : nil;
+                 RCTUIImage *image = (data && !error) ? [RCTUIImage imageWithData:data] : nil;
 #else
         RCTUIImage *image = (data && !error) ? [[RCTUIImage alloc] initWithData:data] : nil;
 #endif
 
-             if (image) {
-               [[ENRMImageAttachment originalImageCache] setObject:image forKey:url cost:ENRMImageByteCost(image)];
-             }
+                 if (image) {
+                   [[ENRMImageAttachment originalImageCache] setObject:image
+                                                                forKey:cacheKey
+                                                                  cost:ENRMImageByteCost(image)];
+                 }
 
-             [self dispatchCallbacksForURL:url image:image];
-           }] resume];
+                 [self dispatchCallbacksForKey:cacheKey image:image];
+               }] resume];
 }
 
-- (void)dispatchCallbacksForURL:(NSString *)url image:(RCTUIImage *_Nullable)image
+- (void)dispatchCallbacksForKey:(NSString *)cacheKey image:(RCTUIImage *_Nullable)image
 {
   NSArray<ENRMImageDownloadCompletion> *callbacks;
   @synchronized(_inFlightRequests) {
-    callbacks = [_inFlightRequests[url] copy];
-    [_inFlightRequests removeObjectForKey:url];
+    callbacks = [_inFlightRequests[cacheKey] copy];
+    [_inFlightRequests removeObjectForKey:cacheKey];
   }
 
   if (!callbacks)

package/ios/utils/ENRMLinkChip.h

@@ -0,0 +1,70 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Marks a link range that carries chip styling. The value is one
+/// `ENRMLinkChip` instance per link: instances compare by identity, so two
+/// adjacent links never coalesce into one attribute run (one chip).
+extern NSString *const ENRMLinkChipAttributeName;
+
+/// Marks the spacer characters `LinkRenderer` inserts at both outer edges of a
+/// link to reserve `paddingHorizontal` in the line. Spacers are layout-only:
+/// every text exit point (copy, markdown/HTML export, decoration text) strips
+/// them by this attribute — never by character, since U+00A0 can be content.
+extern NSString *const ENRMLinkSpacerAttributeName;
+
+@interface ENRMLinkChip : NSObject
+@property (nonatomic, strong, nullable) RCTUIColor *backgroundColor;
+@property (nonatomic, strong, nullable) RCTUIColor *borderColor;
+@property (nonatomic, assign) CGFloat borderWidth;
+@property (nonatomic, assign) CGFloat borderRadius;
+@property (nonatomic, assign) CGFloat paddingHorizontal;
+@property (nonatomic, assign) CGFloat paddingVertical;
+/// YES when the chip paints something (a background or a visible border).
+@property (nonatomic, readonly) BOOL isVisible;
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// A spacer character (U+00A0) whose advance is exactly `width`.
+///
+/// U+00A0 is line-break class GL: a break is allowed before it after a space
+/// but never after it, and never before it after a non-space — so a leading
+/// spacer always travels with the link's first glyph and a trailing one with
+/// its last glyph (no orphaned padding at a wrap). It uses a 1pt system font
+/// so its own advance and line-height contribution are negligible whatever
+/// the link font (a custom font may lack U+00A0), and NSKern makes up the rest.
+NSAttributedString *ENRMLinkSpacerString(NSDictionary<NSAttributedStringKey, id> *baseAttributes, CGFloat width);
+
+/// `string` without link spacers (returns `string` itself when it has none).
+NSAttributedString *ENRMAttributedStringByRemovingLinkSpacers(NSAttributedString *string);
+
+/// Plain text of `range` without link spacers.
+NSString *ENRMPlainTextByRemovingLinkSpacers(NSAttributedString *string, NSRange range);
+
+/// Falls back to a plain `NSBackgroundColorAttributeName` for every chip
+/// background, for text drawn without `TextViewLayoutManager` (table cells,
+/// RTF export). Radius, border and vertical padding are not represented.
+void ENRMApplyLinkChipBackgroundsAsTextBackground(NSMutableAttributedString *string);
+
+/// Enumerates the chip rect of every laid-out line fragment of the link at
+/// `charRange`, in text-container coordinates. The rect spans the glyphs
+/// (spacers included, so it already covers `paddingHorizontal`) horizontally
+/// and the link font's ascender..descender ± `paddingVertical` vertically.
+void ENRMEnumerateLinkChipFragments(NSLayoutManager *layoutManager, NSTextContainer *textContainer, NSRange charRange,
+                                    ENRMLinkChip *_Nullable chip,
+                                    void (^block)(CGRect rect, BOOL isFirst, BOOL isLast));
+
+/// Draws the visible link chips intersecting `glyphsToShow`. Called from the
+/// layout manager's background pass, before glyphs are drawn.
+void ENRMDrawLinkChipsForGlyphRange(NSLayoutManager *layoutManager, NSTextContainer *textContainer,
+                                    NSRange glyphsToShow, CGPoint origin);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END