react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/ios/input/ENRMInputRemend.mm

@@ -7,8 +7,8 @@ typedef struct {
 } ENRMDelimiterPair;
 
 static const ENRMDelimiterPair kDelimiterPairs[] = {
-    {@"**", @"**", YES}, {@"*", @"*", YES}, {@"_", @"_", YES}, {@"~~", @"~~", YES},
-    {@"||", @"||", YES}, {@"`", @"`", YES}, {@"[", @"]", NO},
+    {@"***", @"***", YES}, {@"**", @"**", YES}, {@"*", @"*", YES}, {@"_", @"_", YES},
+    {@"~~", @"~~", YES},   {@"||", @"||", YES}, {@"`", @"`", YES}, {@"[", @"]", NO},
 };
 static const NSUInteger kDelimiterPairCount = sizeof(kDelimiterPairs) / sizeof(kDelimiterPairs[0]);
 

package/ios/input/ENRMInputStyleStateBuilder.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#import "ENRMBlockRange.h"
+#import "ENRMInputStyledRange.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef struct {
+  BOOL bold;
+  BOOL italic;
+  BOOL underline;
+  BOOL strikethrough;
+  BOOL spoiler;
+  BOOL link;
+  NSInteger headingLevel;
+  BOOL unorderedList;
+  BOOL orderedList;
+  NSInteger listDepth;
+} ENRMInputStyleSnapshot;
+
+@protocol ENRMInputStyleStateDataSource <NSObject>
+
+- (NSRange)selectedRange;
+- (BOOL)isEffectiveStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position;
+- (BOOL)isStyleActive:(ENRMInputStyleType)type inRange:(NSRange)range;
+- (NSInteger)headingLevelForCursorParagraph;
+- (nullable ENRMBlockRange *)listBlockForCursorParagraph;
+
+@end
+
+@interface ENRMInputStyleStateBuilder : NSObject
+
++ (ENRMInputStyleSnapshot)snapshotAtCurrentCursor:(id<ENRMInputStyleStateDataSource>)dataSource;
+
++ (ENRMInputStyleSnapshot)snapshotForRange:(NSRange)range dataSource:(id<ENRMInputStyleStateDataSource>)dataSource;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMInputStyleStateBuilder.mm

@@ -0,0 +1,60 @@
+#import "ENRMInputStyleStateBuilder.h"
+
+@implementation ENRMInputStyleStateBuilder
+
++ (ENRMInputStyleSnapshot)snapshotAtCurrentCursor:(id<ENRMInputStyleStateDataSource>)dataSource
+{
+  NSUInteger cursor = [dataSource selectedRange].location;
+  ENRMInputStyleSnapshot snapshot = {};
+  if (cursor == NSNotFound) {
+    return snapshot;
+  }
+  snapshot.bold = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeStrong atPosition:cursor];
+  snapshot.italic = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeEmphasis atPosition:cursor];
+  snapshot.underline = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeUnderline atPosition:cursor];
+  snapshot.strikethrough = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeStrikethrough atPosition:cursor];
+  snapshot.spoiler = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeSpoiler atPosition:cursor];
+  snapshot.link = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeLink atPosition:cursor];
+  snapshot.headingLevel = [dataSource headingLevelForCursorParagraph];
+
+  ENRMBlockRange *listBlock = [dataSource listBlockForCursorParagraph];
+  snapshot.unorderedList = listBlock != nil && listBlock.type == ENRMInputBlockTypeUnorderedListItem;
+  snapshot.orderedList = listBlock != nil && listBlock.type == ENRMInputBlockTypeOrderedListItem;
+  snapshot.listDepth = listBlock != nil ? listBlock.level : 0;
+
+  return snapshot;
+}
+
++ (ENRMInputStyleSnapshot)snapshotForRange:(NSRange)range dataSource:(id<ENRMInputStyleStateDataSource>)dataSource
+{
+  ENRMInputStyleSnapshot snapshot = {};
+  if (range.location == NSNotFound) {
+    return snapshot;
+  }
+  if (range.length > 0) {
+    snapshot.bold = [dataSource isStyleActive:ENRMInputStyleTypeStrong inRange:range];
+    snapshot.italic = [dataSource isStyleActive:ENRMInputStyleTypeEmphasis inRange:range];
+    snapshot.underline = [dataSource isStyleActive:ENRMInputStyleTypeUnderline inRange:range];
+    snapshot.strikethrough = [dataSource isStyleActive:ENRMInputStyleTypeStrikethrough inRange:range];
+    snapshot.spoiler = [dataSource isStyleActive:ENRMInputStyleTypeSpoiler inRange:range];
+    snapshot.link = [dataSource isStyleActive:ENRMInputStyleTypeLink inRange:range];
+  } else {
+    snapshot.bold = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeStrong atPosition:range.location];
+    snapshot.italic = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeEmphasis atPosition:range.location];
+    snapshot.underline = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeUnderline atPosition:range.location];
+    snapshot.strikethrough = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeStrikethrough
+                                                     atPosition:range.location];
+    snapshot.spoiler = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeSpoiler atPosition:range.location];
+    snapshot.link = [dataSource isEffectiveStyleActive:ENRMInputStyleTypeLink atPosition:range.location];
+  }
+  snapshot.headingLevel = [dataSource headingLevelForCursorParagraph];
+
+  ENRMBlockRange *listBlock = [dataSource listBlockForCursorParagraph];
+  snapshot.unorderedList = listBlock != nil && listBlock.type == ENRMInputBlockTypeUnorderedListItem;
+  snapshot.orderedList = listBlock != nil && listBlock.type == ENRMInputBlockTypeOrderedListItem;
+  snapshot.listDepth = listBlock != nil ? listBlock.level : 0;
+
+  return snapshot;
+}
+
+@end

package/ios/input/ENRMInputTextView.mm

@@ -1,15 +1,19 @@
 #import "ENRMInputTextView.h"
+#import "ENRMInputLayoutManager.h"
+#import "EnrichedMarkdownTextInput+Internal.h"
 #import "EnrichedMarkdownTextInput.h"
 #import "PasteboardUtils.h"
 #if TARGET_OS_OSX
-#import "EnrichedMarkdownTextInput+Internal.h"
+#import <objc/message.h>
 #endif
 
 NSString *const kENRMMarkdownPasteboardType = @"com.swmansion.enriched-markdown.markdown";
 
 #if !TARGET_OS_OSX
 
-@implementation ENRMInputTextView
+@implementation ENRMInputTextView {
+  CGFloat _lastLayoutWidth;
+}
 
 - (void)copy:(id)sender
 {
@@ -46,13 +50,27 @@ NSString *const kENRMMarkdownPasteboardType = @"com.swmansion.enriched-markdown.
     markdown = [[NSString alloc] initWithData:markdownValue encoding:NSUTF8StringEncoding];
   }
 
+  NSString *plainText = pasteboard.string;
+
+  // Both flavors are read before anything is decided, then nothing is written:
+  // JS owns the paste from here and must call resolvePaste. Mutating the buffer
+  // first would mean a handler that dies mid-flight leaves the selection gone
+  // with no text to show for it — a no-op paste is the visible failure.
+  if (self.markdownTextInput.interceptPaste && (plainText.length > 0 || markdown.length > 0)) {
+    [self.markdownTextInput emitOnPasteWithText:(plainText ?: @"") markdown:(markdown ?: @"")];
+    return;
+  }
+
   if (markdown.length > 0 && self.markdownTextInput != nil) {
     [self.markdownTextInput pasteMarkdown:markdown];
     return;
   }
 
-  NSString *plainText = pasteboard.string;
-  if (plainText.length > 0) {
+  // External plain text is treated as markdown so pasted syntax ("- ", "#",
+  // "**") formats instead of landing literal; syntax-free text is unchanged.
+  if (plainText.length > 0 && self.markdownTextInput != nil) {
+    [self.markdownTextInput pasteMarkdown:plainText];
+  } else if (plainText.length > 0) {
     [self replaceRange:self.selectedTextRange withText:plainText];
   }
 }
@@ -71,16 +89,65 @@ NSString *const kENRMMarkdownPasteboardType = @"com.swmansion.enriched-markdown.
 - (void)layoutSubviews
 {
   [super layoutSubviews];
-  if (self.markdownTextInput != nil) {
+  CGFloat currentWidth = self.bounds.size.width;
+  if (self.markdownTextInput != nil && fabs(currentWidth - _lastLayoutWidth) > 0.5) {
+    _lastLayoutWidth = currentWidth;
     [self.markdownTextInput scheduleRelayoutIfNeeded];
   }
 }
 
+- (void)deleteBackward
+{
+  // Backspace at the very start of the document doesn't fire the text-change
+  // delegate (nothing precedes the caret), so removing/outdenting the first
+  // line's list marker has to be handled here.
+  if (self.markdownTextInput != nil && [self.markdownTextInput handleBackspaceAtDocumentStart]) {
+    return;
+  }
+  [super deleteBackward];
+}
+
+/// Hardware-keyboard Tab / Shift+Tab indent and outdent the current list item.
+/// UIKeyCommand only fires for an attached keyboard; on-screen Tab/Backspace go
+/// through the text-change delegate (see handleListKeyForReplacementRange:).
+- (NSArray<UIKeyCommand *> *)keyCommands
+{
+  return @[
+    [UIKeyCommand keyCommandWithInput:@"\t" modifierFlags:0 action:@selector(enrmIndentList:)],
+    [UIKeyCommand keyCommandWithInput:@"\t" modifierFlags:UIKeyModifierShift action:@selector(enrmOutdentList:)],
+  ];
+}
+
+- (void)enrmIndentList:(UIKeyCommand *)command
+{
+  [self.markdownTextInput indentList];
+}
+
+- (void)enrmOutdentList:(UIKeyCommand *)command
+{
+  [self.markdownTextInput outdentList];
+}
+
+- (void)drawRect:(CGRect)rect
+{
+  [super drawRect:rect];
+  // A wholly empty editor has no glyphs, so the layout manager's
+  // drawGlyphsForGlyphRange: never runs — draw decorations here instead.
+  if (self.text.length == 0) {
+    NSLayoutManager *layoutManager = self.layoutManager;
+    if ([layoutManager isKindOfClass:[ENRMInputLayoutManager class]]) {
+      [(ENRMInputLayoutManager *)layoutManager drawEmptyEditorDecorationsWithInset:self.textContainerInset];
+    }
+  }
+}
+
 @end
 
 #else // TARGET_OS_OSX
 
-@implementation ENRMInputTextView
+@implementation ENRMInputTextView {
+  CGFloat _lastLayoutWidth;
+}
 
 - (void)copy:(id)sender
 {
@@ -115,8 +182,12 @@ NSString *const kENRMMarkdownPasteboardType = @"com.swmansion.enriched-markdown.
     return;
   }
 
+  // External plain text is treated as markdown so pasted syntax ("- ", "#",
+  // "**") formats instead of landing literal; syntax-free text is unchanged.
   NSString *plainText = [pasteboard stringForType:NSPasteboardTypeString];
-  if (plainText.length > 0) {
+  if (plainText.length > 0 && self.markdownTextInput != nil) {
+    [self.markdownTextInput pasteMarkdown:plainText];
+  } else if (plainText.length > 0) {
     [self insertText:plainText replacementRange:self.selectedRange];
   }
 }
@@ -153,14 +224,38 @@ NSString *const kENRMMarkdownPasteboardType = @"com.swmansion.enriched-markdown.
   return menu;
 }
 
+- (void)setTypingAttributes:(NSDictionary *)typingAttributes
+{
+  // RCTUITextView's override discards the value and always resets to
+  // defaultTextAttributes.  We need the actual value (e.g. list paragraph
+  // indent) to reach NSTextView so the caret positions correctly.
+  struct objc_super superSuper = {self, [NSTextView class]};
+  ((void (*)(struct objc_super *, SEL, NSDictionary *))objc_msgSendSuper)(&superSuper, _cmd, typingAttributes);
+}
+
 - (void)layout
 {
   [super layout];
-  if (self.markdownTextInput != nil) {
+  CGFloat currentWidth = self.bounds.size.width;
+  if (self.markdownTextInput != nil && fabs(currentWidth - _lastLayoutWidth) > 0.5) {
+    _lastLayoutWidth = currentWidth;
     [self.markdownTextInput scheduleRelayoutIfNeeded];
   }
 }
 
+- (void)drawRect:(NSRect)rect
+{
+  [super drawRect:rect];
+  if (self.string.length == 0) {
+    NSLayoutManager *lm = self.layoutManager;
+    if ([lm isKindOfClass:[ENRMInputLayoutManager class]]) {
+      NSEdgeInsets insets = self.textContainerInsets;
+      insets.left += self.textContainer.lineFragmentPadding;
+      [(ENRMInputLayoutManager *)lm drawEmptyEditorDecorationsWithInset:insets];
+    }
+  }
+}
+
 @end
 
 #endif

package/ios/input/ENRMInputTypingAttributesController.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#import "ENRMBlockRange.h"
+#import "ENRMEditSession.h"
+#import "ENRMInputFormatterStyle.h"
+#import "ENRMInputStyledRange.h"
+#import "ENRMInputTextView.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol ENRMInputTypingAttributesDataSource <NSObject>
+
+- (NSRange)selectedRange;
+- (NSInteger)headingLevelForCursorParagraph;
+- (nullable ENRMBlockRange *)listBlockForCursorParagraph;
+- (BOOL)isStyleAdjacentBefore:(ENRMInputStyleType)type position:(NSUInteger)position;
+- (BOOL)isStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position;
+
+@end
+
+@interface ENRMInputTypingAttributesController : NSObject
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView
+                  formatterStyle:(ENRMInputFormatterStyle *)style
+                      dataSource:(id<ENRMInputTypingAttributesDataSource>)dataSource
+                     editSession:(ENRMEditSession *)editSession;
+
+- (BOOL)isEffectiveStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position;
+- (void)togglePendingStyle:(ENRMInputStyleType)type wasActive:(BOOL)wasActive hasSelection:(BOOL)hasSelection;
+- (void)clearPendingStyle:(ENRMInputStyleType)type;
+- (void)syncWithCursorBlock;
+- (void)syncWithPendingStyles;
+- (void)resetForSelectionChange;
+- (void)clearListParagraphStyle;
+
+@property (nonatomic, readonly) NSSet<NSNumber *> *pendingStyles;
+@property (nonatomic, readonly) NSSet<NSNumber *> *pendingStyleRemovals;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMInputTypingAttributesController.mm

@@ -0,0 +1,203 @@
+#import "ENRMInputTypingAttributesController.h"
+#import "ENRMInputBlockType.h"
+
+@implementation ENRMInputTypingAttributesController {
+  __weak ENRMPlatformTextView *_textView;
+  __weak id<ENRMInputTypingAttributesDataSource> _dataSource;
+  ENRMInputFormatterStyle *_formatterStyle;
+  ENRMEditSession *_editSession;
+
+  NSMutableSet<NSNumber *> *_pendingStyles;
+  NSMutableSet<NSNumber *> *_pendingStyleRemovals;
+}
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView
+                  formatterStyle:(ENRMInputFormatterStyle *)style
+                      dataSource:(id<ENRMInputTypingAttributesDataSource>)dataSource
+                     editSession:(ENRMEditSession *)editSession
+{
+  self = [super init];
+  if (self) {
+    _textView = textView;
+    _formatterStyle = style;
+    _dataSource = dataSource;
+    _editSession = editSession;
+    _pendingStyles = [NSMutableSet set];
+    _pendingStyleRemovals = [NSMutableSet set];
+  }
+  return self;
+}
+
+#pragma mark - Properties
+
+- (NSSet<NSNumber *> *)pendingStyles
+{
+  return [_pendingStyles copy];
+}
+
+- (NSSet<NSNumber *> *)pendingStyleRemovals
+{
+  return [_pendingStyleRemovals copy];
+}
+
+#pragma mark - Style queries
+
+- (BOOL)isEffectiveStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position
+{
+  BOOL inRange = [_dataSource isStyleActive:type atPosition:position];
+  NSNumber *key = @(type);
+  if ([_pendingStyleRemovals containsObject:key]) {
+    return NO;
+  }
+  if ([_pendingStyles containsObject:key]) {
+    return YES;
+  }
+  return inRange;
+}
+
+#pragma mark - Pending style mutations
+
+- (void)togglePendingStyle:(ENRMInputStyleType)type wasActive:(BOOL)wasActive hasSelection:(BOOL)hasSelection
+{
+  NSNumber *key = @(type);
+  if (hasSelection) {
+    [_pendingStyles removeObject:key];
+    [_pendingStyleRemovals removeObject:key];
+  } else {
+    if ([_pendingStyleRemovals containsObject:key]) {
+      [_pendingStyleRemovals removeObject:key];
+    } else if ([_pendingStyles containsObject:key]) {
+      [_pendingStyles removeObject:key];
+    } else if (wasActive) {
+      [_pendingStyleRemovals addObject:key];
+    } else {
+      [_pendingStyles addObject:key];
+    }
+  }
+}
+
+- (void)clearPendingStyle:(ENRMInputStyleType)type
+{
+  NSNumber *key = @(type);
+  [_pendingStyles removeObject:key];
+  [_pendingStyleRemovals removeObject:key];
+}
+
+#pragma mark - Typing attribute synchronization
+
+- (void)syncWithCursorBlock
+{
+  UIFontDescriptorSymbolicTraits traits = 0;
+  if ([_pendingStyles containsObject:@(ENRMInputStyleTypeStrong)]) {
+    traits |= UIFontDescriptorTraitBold;
+  }
+  if ([_pendingStyles containsObject:@(ENRMInputStyleTypeEmphasis)]) {
+    traits |= UIFontDescriptorTraitItalic;
+  }
+
+  NSInteger headingLevel = [_dataSource headingLevelForCursorParagraph];
+
+  UIFont *font;
+  if (headingLevel >= 1 && headingLevel <= 6) {
+    UIFont *headingFont = [_formatterStyle headingFontForLevel:headingLevel];
+    UIFontDescriptorSymbolicTraits merged = headingFont.fontDescriptor.symbolicTraits | traits;
+    UIFontDescriptor *descriptor = [headingFont.fontDescriptor fontDescriptorWithSymbolicTraits:merged];
+    font = descriptor ? [UIFont fontWithDescriptor:descriptor size:0] : headingFont;
+  } else {
+    font = [_formatterStyle fontForTraits:traits];
+  }
+
+  NSMutableDictionary *attrs = [_textView.typingAttributes mutableCopy];
+  attrs[NSFontAttributeName] = font;
+  RCTUIColor *headingColor = headingLevel >= 1 ? [_formatterStyle headingColorForLevel:headingLevel] : nil;
+  attrs[NSForegroundColorAttributeName] = headingColor ?: _formatterStyle.baseTextColor;
+
+  ENRMBlockRange *typingListBlock = [_dataSource listBlockForCursorParagraph];
+  if (typingListBlock != nil) {
+    NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
+    CGFloat indent = (typingListBlock.level + 1) * kENRMListIndentPerDepth;
+    paragraph.firstLineHeadIndent = indent;
+    paragraph.headIndent = indent;
+    paragraph.paragraphSpacingBefore = _formatterStyle.listItemSpacing;
+    attrs[NSParagraphStyleAttributeName] = paragraph;
+  } else {
+    [attrs removeObjectForKey:NSParagraphStyleAttributeName];
+  }
+
+  if (![attrs isEqualToDictionary:_textView.typingAttributes]) {
+    _textView.typingAttributes = attrs;
+  }
+}
+
+- (void)syncWithPendingStyles
+{
+  UIFontDescriptorSymbolicTraits traits = 0;
+  if ([_pendingStyles containsObject:@(ENRMInputStyleTypeStrong)]) {
+    traits |= UIFontDescriptorTraitBold;
+  }
+  if ([_pendingStyles containsObject:@(ENRMInputStyleTypeEmphasis)]) {
+    traits |= UIFontDescriptorTraitItalic;
+  }
+
+  NSMutableDictionary *attrs = [_textView.typingAttributes mutableCopy];
+  attrs[NSFontAttributeName] = [_formatterStyle fontForTraits:traits];
+  _textView.typingAttributes = attrs;
+}
+
+- (void)resetForSelectionChange
+{
+  if (_editSession.isPostEditGracePeriod) {
+    return;
+  }
+  [_pendingStyles removeAllObjects];
+  [_pendingStyleRemovals removeAllObjects];
+  [self rebuildFromContext];
+  if ([_dataSource selectedRange].length == 0) {
+    [self syncWithCursorBlock];
+  }
+}
+
+- (void)clearListParagraphStyle
+{
+  if (_textView.typingAttributes[NSParagraphStyleAttributeName] == nil) {
+    return;
+  }
+  NSMutableDictionary *attrs = [_textView.typingAttributes mutableCopy];
+  [attrs removeObjectForKey:NSParagraphStyleAttributeName];
+  _textView.typingAttributes = attrs;
+}
+
+#pragma mark - Private
+
+- (void)rebuildFromContext
+{
+  static const ENRMInputStyleType inlineStyles[] = {
+      ENRMInputStyleTypeStrong,        ENRMInputStyleTypeEmphasis, ENRMInputStyleTypeUnderline,
+      ENRMInputStyleTypeStrikethrough, ENRMInputStyleTypeSpoiler,
+  };
+
+  NSRange selection = [_dataSource selectedRange];
+
+  if (selection.length > 0) {
+    for (NSUInteger i = 0; i < sizeof(inlineStyles) / sizeof(inlineStyles[0]); i++) {
+      ENRMInputStyleType type = inlineStyles[i];
+      if ([_dataSource isStyleActive:type atPosition:selection.location]) {
+        [_pendingStyles addObject:@(type)];
+      }
+    }
+    return;
+  }
+
+  if (selection.location == 0) {
+    return;
+  }
+
+  for (NSUInteger i = 0; i < sizeof(inlineStyles) / sizeof(inlineStyles[0]); i++) {
+    ENRMInputStyleType type = inlineStyles[i];
+    if ([_dataSource isStyleAdjacentBefore:type position:selection.location]) {
+      [_pendingStyles addObject:@(type)];
+    }
+  }
+}
+
+@end

package/ios/input/ENRMLinkCoordinator.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#import "ENRMFormattingRange.h"
+#import "ENRMFormattingStore.h"
+#import <Foundation/Foundation.h>
+
+@class AutoLinkDetector;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol ENRMAutoLinkDetecting <NSObject>
+- (void)clearAutoLinkInRange:(NSRange)range;
+@end
+
+@interface ENRMLinkCoordinator : NSObject
+
+- (instancetype)initWithFormattingStore:(ENRMFormattingStore *)formattingStore
+                       autoLinkDetector:(id<ENRMAutoLinkDetecting>)autoLinkDetector;
+
+- (NSString *)sanitizeURL:(NSString *)url;
+- (nullable ENRMFormattingRange *)linkAtPosition:(NSUInteger)position;
+
+/// Sets a link on the selection range, or updates an existing link's URL at the cursor.
+/// Returns YES if a mutation occurred.
+- (BOOL)setLinkURL:(NSString *)url atCursor:(NSUInteger)cursor selection:(NSRange)selection;
+
+/// Adds a new link range (sanitizes the URL, clears auto-links).
+- (void)addLinkWithURL:(NSString *)url start:(NSUInteger)start end:(NSUInteger)end;
+
+/// Adds a link range with an already-sanitized URL (no auto-link clearing).
+- (void)addLinkDirectWithURL:(NSString *)url start:(NSUInteger)start end:(NSUInteger)end;
+
+/// Removes the link at the given position. Returns YES if a link was found and removed.
+- (BOOL)removeLinkAtPosition:(NSUInteger)position;
+
+/// Returns the link range containing `position - 1`, for atomic link deletion.
+- (nullable ENRMFormattingRange *)linkRangeForDeletionAtPosition:(NSUInteger)position;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMLinkCoordinator.mm

@@ -0,0 +1,89 @@
+#import "ENRMLinkCoordinator.h"
+
+@implementation ENRMLinkCoordinator {
+  ENRMFormattingStore *_formattingStore;
+  id<ENRMAutoLinkDetecting> _autoLinkDetector;
+}
+
+- (instancetype)initWithFormattingStore:(ENRMFormattingStore *)formattingStore
+                       autoLinkDetector:(id<ENRMAutoLinkDetecting>)autoLinkDetector
+{
+  if (self = [super init]) {
+    _formattingStore = formattingStore;
+    _autoLinkDetector = autoLinkDetector;
+  }
+  return self;
+}
+
+- (NSString *)sanitizeURL:(NSString *)url
+{
+  NSString *result = [url stringByReplacingOccurrencesOfString:@"(" withString:@"%28"];
+  return [result stringByReplacingOccurrencesOfString:@")" withString:@"%29"];
+}
+
+- (nullable ENRMFormattingRange *)linkAtPosition:(NSUInteger)position
+{
+  return [_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:position];
+}
+
+- (BOOL)setLinkURL:(NSString *)url atCursor:(NSUInteger)cursor selection:(NSRange)selection
+{
+  ENRMFormattingRange *activeLink = [_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:cursor];
+
+  if (activeLink != nil) {
+    activeLink.url = url;
+    [_autoLinkDetector clearAutoLinkInRange:activeLink.range];
+    return YES;
+  }
+
+  if (selection.length > 0) {
+    ENRMFormattingRange *linkRange = [ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink range:selection url:url];
+    [_formattingStore addRange:linkRange];
+    [_autoLinkDetector clearAutoLinkInRange:selection];
+    return YES;
+  }
+
+  return NO;
+}
+
+- (void)addLinkWithURL:(NSString *)url start:(NSUInteger)start end:(NSUInteger)end
+{
+  if (start >= end) {
+    return;
+  }
+  NSRange range = NSMakeRange(start, end - start);
+  [_autoLinkDetector clearAutoLinkInRange:range];
+  [_formattingStore addRange:[ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink
+                                                          range:range
+                                                            url:[self sanitizeURL:url]]];
+}
+
+- (void)addLinkDirectWithURL:(NSString *)url start:(NSUInteger)start end:(NSUInteger)end
+{
+  if (start >= end) {
+    return;
+  }
+  [_formattingStore addRange:[ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink
+                                                          range:NSMakeRange(start, end - start)
+                                                            url:url]];
+}
+
+- (BOOL)removeLinkAtPosition:(NSUInteger)position
+{
+  ENRMFormattingRange *activeLink = [_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:position];
+  if (activeLink == nil) {
+    return NO;
+  }
+  [_formattingStore removeRange:activeLink];
+  return YES;
+}
+
+- (nullable ENRMFormattingRange *)linkRangeForDeletionAtPosition:(NSUInteger)position
+{
+  if (position == 0) {
+    return nil;
+  }
+  return [_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:position - 1];
+}
+
+@end