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

package/ios/input/ENRMInputStyledRange.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, ENRMInputStyleType) {
+  ENRMInputStyleTypeStrong,
+  ENRMInputStyleTypeEmphasis,
+  ENRMInputStyleTypeUnderline,
+  ENRMInputStyleTypeStrikethrough,
+  ENRMInputStyleTypeLink,
+  ENRMInputStyleTypeSpoiler,
+};
+
+@interface ENRMInputStyledRange : NSObject
+
+@property (nonatomic, assign) ENRMInputStyleType type;
+@property (nonatomic, assign) NSRange contentRange;
+@property (nonatomic, strong) NSArray<NSValue *> *syntaxRanges;
+@property (nonatomic, assign) NSRange fullRange;
+@property (nonatomic, strong, nullable) NSString *url;
+
+/// YES if both delimiters are present in the original text (before remend completion).
+@property (nonatomic, assign) BOOL isComplete;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMInputStyledRange.mm

@@ -0,0 +1,4 @@
+#import "ENRMInputStyledRange.h"
+
+@implementation ENRMInputStyledRange
+@end

package/ios/input/ENRMInputTextView.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#import "ENRMUIKit.h"
+
+@class EnrichedMarkdownTextInput;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMInputTextView : ENRMPlatformTextView
+@property (nonatomic, weak, nullable) EnrichedMarkdownTextInput *markdownTextInput;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMInputTextView.mm

@@ -0,0 +1,175 @@
+#import "ENRMInputTextView.h"
+#import "EnrichedMarkdownTextInput.h"
+#if TARGET_OS_OSX
+#import "EnrichedMarkdownTextInput+Internal.h"
+#endif
+
+static NSString *const kENRMMarkdownPasteboardType = @"com.swmansion.enriched-markdown.markdown";
+
+#if !TARGET_OS_OSX
+
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+
+@implementation ENRMInputTextView
+
+- (void)copy:(id)sender
+{
+  NSRange selection = self.selectedRange;
+  if (selection.length == 0) {
+    return;
+  }
+
+  NSString *plainText = [self.text substringWithRange:selection];
+  NSString *markdown = [self.markdownTextInput markdownForSelectedRange];
+
+  UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+  NSMutableDictionary *items = [NSMutableDictionary dictionary];
+  items[UTTypePlainText.identifier] = plainText;
+  if (markdown.length > 0) {
+    items[kENRMMarkdownPasteboardType] = markdown;
+  }
+  pasteboard.items = @[ items ];
+}
+
+- (void)cut:(id)sender
+{
+  [self copy:sender];
+  [self.markdownTextInput replaceSelectedTextWith:@"" formattingRanges:@[]];
+}
+
+- (void)paste:(id)sender
+{
+  UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+
+  NSString *markdown = nil;
+  id markdownValue = [pasteboard valueForPasteboardType:kENRMMarkdownPasteboardType];
+  if ([markdownValue isKindOfClass:[NSString class]]) {
+    markdown = markdownValue;
+  } else if ([markdownValue isKindOfClass:[NSData class]]) {
+    markdown = [[NSString alloc] initWithData:markdownValue encoding:NSUTF8StringEncoding];
+  }
+
+  if (markdown.length > 0 && self.markdownTextInput != nil) {
+    [self.markdownTextInput pasteMarkdown:markdown];
+    return;
+  }
+
+  NSString *plainText = pasteboard.string;
+  if (plainText.length > 0) {
+    [self replaceRange:self.selectedTextRange withText:plainText];
+  }
+}
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
+{
+  if (action == @selector(paste:)) {
+    UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+    if (pasteboard.hasStrings || [pasteboard containsPasteboardTypes:@[ kENRMMarkdownPasteboardType ]]) {
+      return YES;
+    }
+  }
+  return [super canPerformAction:action withSender:sender];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  if (self.markdownTextInput != nil) {
+    [self.markdownTextInput scheduleRelayoutIfNeeded];
+  }
+}
+
+@end
+
+#else // TARGET_OS_OSX
+
+@implementation ENRMInputTextView
+
+- (void)copy:(id)sender
+{
+  NSRange selection = self.selectedRange;
+  if (selection.length == 0) {
+    return;
+  }
+
+  NSString *plainText = [self.string substringWithRange:selection];
+  NSString *markdown = [self.markdownTextInput markdownForSelectedRange];
+
+  NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+  [pasteboard clearContents];
+  NSMutableArray *types = [NSMutableArray arrayWithObject:NSPasteboardTypeString];
+  if (markdown.length > 0) {
+    [types addObject:kENRMMarkdownPasteboardType];
+  }
+  [pasteboard declareTypes:types owner:nil];
+  [pasteboard setString:plainText forType:NSPasteboardTypeString];
+  if (markdown.length > 0) {
+    [pasteboard setString:markdown forType:kENRMMarkdownPasteboardType];
+  }
+}
+
+- (void)cut:(id)sender
+{
+  [self copy:sender];
+  [self.markdownTextInput replaceSelectedTextWith:@"" formattingRanges:@[]];
+}
+
+- (void)paste:(id)sender
+{
+  NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+
+  NSString *markdown = [pasteboard stringForType:kENRMMarkdownPasteboardType];
+  if (markdown.length > 0 && self.markdownTextInput != nil) {
+    [self.markdownTextInput pasteMarkdown:markdown];
+    return;
+  }
+
+  NSString *plainText = [pasteboard stringForType:NSPasteboardTypeString];
+  if (plainText.length > 0) {
+    [self insertText:plainText replacementRange:self.selectedRange];
+  }
+}
+
+- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
+{
+  if (menuItem.action == @selector(paste:)) {
+    NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
+    return ([pasteboard stringForType:NSPasteboardTypeString] != nil ||
+            [pasteboard stringForType:kENRMMarkdownPasteboardType] != nil);
+  }
+  return [super validateMenuItem:menuItem];
+}
+
+- (BOOL)acceptsFirstResponder
+{
+  return self.isEditable;
+}
+
+- (void)mouseDown:(NSEvent *)event
+{
+  if (self.window != nil) {
+    [self.window makeFirstResponder:self];
+  }
+  [super mouseDown:event];
+}
+
+- (NSMenu *)menuForEvent:(NSEvent *)event
+{
+  NSMenu *menu = [super menuForEvent:event];
+  if (self.markdownTextInput != nil) {
+    return [self.markdownTextInput enrichedMenuForEvent:event defaultMenu:menu textView:self];
+  }
+  return menu;
+}
+
+- (void)layout
+{
+  [super layout];
+  if (self.markdownTextInput != nil) {
+    [self.markdownTextInput scheduleRelayoutIfNeeded];
+  }
+}
+
+@end
+
+#endif

package/ios/input/ENRMLinkRegexConfig.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMLinkRegexConfig : NSObject
+
+@property (nonatomic, copy, readonly) NSString *pattern;
+@property (nonatomic, assign, readonly) BOOL caseInsensitive;
+@property (nonatomic, assign, readonly) BOOL dotAll;
+@property (nonatomic, assign, readonly) BOOL isDisabled;
+@property (nonatomic, assign, readonly) BOOL isDefault;
+@property (nonatomic, strong, readonly, nullable) NSRegularExpression *parsedRegex;
+
+- (instancetype)initWithPattern:(NSString *)pattern
+                caseInsensitive:(BOOL)caseInsensitive
+                         dotAll:(BOOL)dotAll
+                     isDisabled:(BOOL)isDisabled
+                      isDefault:(BOOL)isDefault;
+
+- (BOOL)isEqualToConfig:(ENRMLinkRegexConfig *)other;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMLinkRegexConfig.mm

@@ -0,0 +1,60 @@
+#import "ENRMLinkRegexConfig.h"
+
+#import <React/RCTLog.h>
+
+@implementation ENRMLinkRegexConfig
+
+- (instancetype)initWithPattern:(NSString *)pattern
+                caseInsensitive:(BOOL)caseInsensitive
+                         dotAll:(BOOL)dotAll
+                     isDisabled:(BOOL)isDisabled
+                      isDefault:(BOOL)isDefault
+{
+  self = [super init];
+  if (!self) {
+    return nil;
+  }
+
+  _pattern = [pattern copy];
+  _caseInsensitive = caseInsensitive;
+  _dotAll = dotAll;
+  _isDisabled = isDisabled;
+  _isDefault = isDefault;
+  _parsedRegex = nil;
+
+  if (!_isDefault && !_isDisabled && _pattern.length > 0) {
+    NSRegularExpressionOptions options = 0;
+    if (_caseInsensitive) {
+      options |= NSRegularExpressionCaseInsensitive;
+    }
+    if (_dotAll) {
+      options |= NSRegularExpressionDotMatchesLineSeparators;
+    }
+
+    NSError *error = nil;
+    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:_pattern
+                                                                           options:options
+                                                                             error:&error];
+    if (error) {
+      RCTLogWarn(
+          @"[EnrichedMarkdownTextInput]: Couldn't parse the user-defined link regex '%@', "
+           "falling back to default regex.",
+          _pattern);
+    } else {
+      _parsedRegex = regex;
+    }
+  }
+
+  return self;
+}
+
+- (BOOL)isEqualToConfig:(ENRMLinkRegexConfig *)other
+{
+  if (other == nil) {
+    return NO;
+  }
+  return [_pattern isEqualToString:other.pattern] && _caseInsensitive == other.caseInsensitive &&
+         _dotAll == other.dotAll && _isDefault == other.isDefault && _isDisabled == other.isDisabled;
+}
+
+@end

package/ios/input/ENRMMarkdownSerializer.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#import "ENRMFormattingRange.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMMarkdownSerializer : NSObject
+
++ (NSString *)serializePlainText:(NSString *)text ranges:(NSArray<ENRMFormattingRange *> *)ranges;
+
+/// Serializes an attributed string, expanding any `ENRMMathInlineAttachment`
+/// at U+FFFC positions back into `$latex$` or `$$latex$$` markdown. The
+/// `ranges` are formatting ranges over `attr.string` positions; they are
+/// shifted internally to account for the expansion.
++ (NSString *)serializeAttributedString:(NSAttributedString *)attr ranges:(NSArray<ENRMFormattingRange *> *)ranges;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMMarkdownSerializer.mm

@@ -0,0 +1,283 @@
+#import "ENRMMarkdownSerializer.h"
+
+#import "ENRMFeatureFlags.h"
+#if ENRICHED_MARKDOWN_MATH
+#import "ENRMMathInlineAttachment.h"
+#endif
+
+static NSString *openingDelimiterForType(ENRMInputStyleType type)
+{
+  switch (type) {
+    case ENRMInputStyleTypeStrong:
+      return @"**";
+    case ENRMInputStyleTypeEmphasis:
+      return @"*";
+    case ENRMInputStyleTypeUnderline:
+      return @"_";
+    case ENRMInputStyleTypeStrikethrough:
+      return @"~~";
+    case ENRMInputStyleTypeLink:
+      return @"[";
+    case ENRMInputStyleTypeSpoiler:
+      return @"||";
+    default:
+      return @"";
+  }
+}
+
+static NSString *closingDelimiterForType(ENRMInputStyleType type, NSString *url)
+{
+  switch (type) {
+    case ENRMInputStyleTypeStrong:
+      return @"**";
+    case ENRMInputStyleTypeEmphasis:
+      return @"*";
+    case ENRMInputStyleTypeUnderline:
+      return @"_";
+    case ENRMInputStyleTypeStrikethrough:
+      return @"~~";
+    case ENRMInputStyleTypeLink:
+      return [NSString stringWithFormat:@"](%@)", url ?: @""];
+    case ENRMInputStyleTypeSpoiler:
+      return @"||";
+    default:
+      return @"";
+  }
+}
+
+/// Lower value = outermost wrapper. Font styles wrap around structural styles (link).
+static int nestingPriorityForType(ENRMInputStyleType type)
+{
+  switch (type) {
+    case ENRMInputStyleTypeEmphasis:
+      return 0;
+    case ENRMInputStyleTypeStrong:
+      return 1;
+    case ENRMInputStyleTypeUnderline:
+      return 2;
+    case ENRMInputStyleTypeStrikethrough:
+      return 3;
+    case ENRMInputStyleTypeSpoiler:
+      return 4;
+    case ENRMInputStyleTypeLink:
+      return 5;
+    default:
+      return 99;
+  }
+}
+
+typedef struct {
+  NSUInteger position;
+  BOOL isOpening;
+  ENRMInputStyleType type;
+  NSString *__unsafe_unretained url;
+} BoundaryEvent;
+
+static int compareBoundaryEvents(const void *first, const void *second)
+{
+  const BoundaryEvent *eventA = (const BoundaryEvent *)first;
+  const BoundaryEvent *eventB = (const BoundaryEvent *)second;
+
+  if (eventA->position != eventB->position) {
+    return eventA->position < eventB->position ? -1 : 1;
+  }
+  // Closing events before opening events at the same position
+  if (eventA->isOpening != eventB->isOpening) {
+    return eventA->isOpening ? 1 : -1;
+  }
+  // Among openings: outer first (lower priority emitted first)
+  // Among closings: inner first (higher priority emitted first) — LIFO order
+  int priorityA = nestingPriorityForType(eventA->type);
+  int priorityB = nestingPriorityForType(eventB->type);
+  if (eventA->isOpening) {
+    return priorityA - priorityB;
+  } else {
+    return priorityB - priorityA;
+  }
+}
+
+static NSCharacterSet *whitespaceSet(void)
+{
+  static NSCharacterSet *set;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{ set = [NSCharacterSet whitespaceCharacterSet]; });
+  return set;
+}
+
+/// Split formatting ranges at paragraph breaks (\n\n) so each segment gets
+/// its own delimiters — CommonMark delimiters can't span paragraphs.
+/// NOTE: This only handles inline styles (bold, italic, etc.). Block-level
+/// elements (lists, blockquotes, headings) are prefix-based and will need
+/// a separate serialization path.
+static NSArray<ENRMFormattingRange *> *splitRangesAtParagraphBreaks(NSArray<ENRMFormattingRange *> *ranges,
+                                                                    NSString *text)
+{
+  NSMutableArray<ENRMFormattingRange *> *result = [NSMutableArray arrayWithCapacity:ranges.count];
+
+  NSUInteger textLength = text.length;
+
+  for (ENRMFormattingRange *formattingRange in ranges) {
+    NSUInteger rangeStart = MIN(formattingRange.range.location, textLength);
+    NSUInteger rangeEnd = MIN(NSMaxRange(formattingRange.range), textLength);
+
+    NSUInteger segStart = rangeStart;
+    while (segStart < rangeEnd) {
+      NSUInteger segEnd = segStart;
+      while (segEnd < rangeEnd) {
+        if (segEnd + 1 < rangeEnd && [text characterAtIndex:segEnd] == '\n' &&
+            [text characterAtIndex:segEnd + 1] == '\n') {
+          break;
+        }
+        segEnd++;
+      }
+
+      if (segEnd > segStart) {
+        [result addObject:[ENRMFormattingRange rangeWithType:formattingRange.type
+                                                       range:NSMakeRange(segStart, segEnd - segStart)
+                                                         url:formattingRange.url]];
+      }
+
+      segStart = (segEnd < rangeEnd && segEnd + 1 < rangeEnd && [text characterAtIndex:segEnd] == '\n' &&
+                  [text characterAtIndex:segEnd + 1] == '\n')
+                     ? segEnd + 2
+                     : segEnd;
+    }
+  }
+
+  return result;
+}
+
+@implementation ENRMMarkdownSerializer
+
++ (NSString *)serializePlainText:(NSString *)text ranges:(NSArray<ENRMFormattingRange *> *)ranges
+{
+  if (ranges.count == 0) {
+    return text;
+  }
+
+  NSArray<ENRMFormattingRange *> *splitRanges = splitRangesAtParagraphBreaks(ranges, text);
+
+  NSUInteger textLength = text.length;
+  NSUInteger eventCount = splitRanges.count * 2;
+
+  BoundaryEvent *events = (BoundaryEvent *)malloc(sizeof(BoundaryEvent) * eventCount);
+  if (!events)
+    return text;
+
+  NSCharacterSet *ws = whitespaceSet();
+  NSUInteger eventIndex = 0;
+  for (ENRMFormattingRange *formattingRange in splitRanges) {
+    NSUInteger start = MIN(formattingRange.range.location, textLength);
+    NSUInteger end = MIN(NSMaxRange(formattingRange.range), textLength);
+
+    while (start < end && [ws characterIsMember:[text characterAtIndex:start]]) {
+      start++;
+    }
+    while (end > start && [ws characterIsMember:[text characterAtIndex:end - 1]]) {
+      end--;
+    }
+
+    if (start >= end) {
+      continue;
+    }
+
+    events[eventIndex++] = (BoundaryEvent){
+        .position = start,
+        .isOpening = YES,
+        .type = formattingRange.type,
+        .url = formattingRange.url,
+    };
+    events[eventIndex++] = (BoundaryEvent){
+        .position = end,
+        .isOpening = NO,
+        .type = formattingRange.type,
+        .url = formattingRange.url,
+    };
+  }
+
+  qsort(events, eventIndex, sizeof(BoundaryEvent), compareBoundaryEvents);
+
+  NSMutableString *markdown = [NSMutableString stringWithCapacity:textLength + eventCount * 4];
+  NSUInteger lastPosition = 0;
+
+  for (NSUInteger currentEvent = 0; currentEvent < eventIndex; currentEvent++) {
+    BoundaryEvent event = events[currentEvent];
+    NSUInteger position = MIN(event.position, textLength);
+
+    if (position > lastPosition) {
+      [markdown appendString:[text substringWithRange:NSMakeRange(lastPosition, position - lastPosition)]];
+      lastPosition = position;
+    }
+
+    if (event.isOpening) {
+      [markdown appendString:openingDelimiterForType(event.type)];
+    } else {
+      [markdown appendString:closingDelimiterForType(event.type, event.url)];
+    }
+  }
+
+  if (lastPosition < textLength) {
+    [markdown appendString:[text substringFromIndex:lastPosition]];
+  }
+
+  free(events);
+  return markdown;
+}
+
++ (NSString *)serializeAttributedString:(NSAttributedString *)attr ranges:(NSArray<ENRMFormattingRange *> *)ranges
+{
+  if (attr.length == 0) {
+    return [self serializePlainText:@"" ranges:ranges];
+  }
+
+  NSString *plain = attr.string;
+  NSUInteger length = plain.length;
+
+  // Build expanded text where each math `` becomes its `$latex$` / `$$latex$$`
+  // markdown and build a position map from original indices to expanded indices.
+  NSMutableString *expanded = [NSMutableString stringWithCapacity:length];
+  NSMutableData *mapData = [NSMutableData dataWithLength:(length + 1) * sizeof(NSUInteger)];
+  NSUInteger *posMap = (NSUInteger *)mapData.mutableBytes;
+  NSUInteger expandedPos = 0;
+  for (NSUInteger i = 0; i < length; i++) {
+    posMap[i] = expandedPos;
+    unichar c = [plain characterAtIndex:i];
+    if (c == (unichar)0xFFFC) {
+#if ENRICHED_MARKDOWN_MATH
+      id value = [attr attribute:NSAttachmentAttributeName atIndex:i effectiveRange:NULL];
+      if ([value isKindOfClass:[ENRMMathInlineAttachment class]]) {
+        ENRMMathInlineAttachment *att = value;
+        NSString *delim = att.displayMode ? @"$$" : @"$";
+        [expanded appendString:delim];
+        if (att.latex.length > 0) {
+          [expanded appendString:att.latex];
+        }
+        [expanded appendString:delim];
+        expandedPos += delim.length * 2 + att.latex.length;
+        continue;
+      }
+#endif
+      // Unknown attachment — skip the placeholder char so it doesn't leak.
+      continue;
+    }
+    [expanded appendFormat:@"%C", c];
+    expandedPos += 1;
+  }
+  posMap[length] = expandedPos;
+
+  NSMutableArray<ENRMFormattingRange *> *shifted = [NSMutableArray arrayWithCapacity:ranges.count];
+  for (ENRMFormattingRange *fr in ranges) {
+    NSUInteger start = fr.range.location;
+    NSUInteger end = NSMaxRange(fr.range);
+    if (start > length)
+      start = length;
+    if (end > length)
+      end = length;
+    NSRange shiftedRange = NSMakeRange(posMap[start], posMap[end] - posMap[start]);
+    [shifted addObject:[ENRMFormattingRange rangeWithType:fr.type range:shiftedRange url:fr.url]];
+  }
+
+  return [self serializePlainText:expanded ranges:shifted];
+}
+
+@end

package/ios/input/ENRMTextDetector.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#import "ENRMWordsUtils.h"
+#import <Foundation/Foundation.h>
+
+@class ENRMFormattingRange;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Protocol for pluggable text detectors that run after each text edit.
+/// Each detector scans affected words, can refresh its own visual styling
+/// after the formatter resets base attributes, and contributes transient
+/// formatting ranges for markdown serialization.
+@protocol ENRMTextDetector <NSObject>
+
+/// Process a single word at the given range after a text edit.
+/// Called once per affected word in the modification range.
+- (void)processWord:(ENRMWordResult *)wordResult;
+
+/// Re-apply any visual styling owned by this detector.
+/// Called after the formatter resets base text attributes.
+- (void)refreshStyling;
+
+/// Return transient formatting ranges that should be merged
+/// with the FormattingStore ranges during markdown serialization.
+- (NSArray<ENRMFormattingRange *> *)transientFormattingRanges;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMWordsUtils.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMWordResult : NSObject
+
+@property (nonatomic, copy, readonly) NSString *word;
+@property (nonatomic, assign, readonly) NSRange range;
+
++ (instancetype)resultWithWord:(NSString *)word range:(NSRange)range;
+
+@end
+
+@interface ENRMWordsUtils : NSObject
+
+/// Returns the start index of the non-whitespace token that ends at [position].
+/// If [position] is directly after whitespace or at the start of text, returns [position].
++ (NSUInteger)tokenStartInText:(NSString *)text beforePosition:(NSUInteger)position;
+
+/// Expands the modification range to word boundaries, then splits into
+/// individual ENRMWordResult objects.
++ (NSArray<ENRMWordResult *> *)getAffectedWordsFromText:(NSString *)text modificationRange:(NSRange)range;
+
+@end
+
+NS_ASSUME_NONNULL_END