Use NSTextStorageDelegate instead of method swizzling

apple/MarkdownBackedTextInputDelegate.h

@@ -0,0 +1,12 @@
+#import <React/RCTBackedTextInputDelegate.h>
+#import <React/RCTUITextView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MarkdownBackedTextInputDelegate : NSObject <RCTBackedTextInputDelegate>
+
+- (instancetype)initWithTextView:(RCTUITextView *)textView;
+
+@end
+
+NS_ASSUME_NONNULL_END

apple/MarkdownBackedTextInputDelegate.mm

@@ -0,0 +1,75 @@
+#import "MarkdownBackedTextInputDelegate.h"
+
+@implementation MarkdownBackedTextInputDelegate {
+  __weak RCTUITextView *_textView;
+  id<RCTBackedTextInputDelegate> _originalTextInputDelegate;
+}
+
+- (instancetype)initWithTextView:(RCTUITextView *)textView
+{
+  if (self = [super init]) {
+    _textView = textView;
+    _originalTextInputDelegate = _textView.textInputDelegate;
+    _textView.textInputDelegate = self;
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  // Restore original text input delegate
+  _textView.textInputDelegate = _originalTextInputDelegate;
+}
+
+- (void)textInputDidChange
+{
+  // After adding a newline at the end of the blockquote, the typing attributes in the new line
+  // still contain NSParagraphStyle with non-zero firstLineHeadIndent and headIntent.
+  // This causes the cursor to be shifted to the right instead of being located at the beginning of the line.
+  // Also, if the previous line of the text ends with a link, there will be underline blinks visible while typing.
+  // The following code resets typing attributes with default text attributes to fix both problems at once.
+  _textView.typingAttributes = _textView.defaultTextAttributes;
+
+  // Delegate the call to the original text input delegate
+  [_originalTextInputDelegate textInputDidChange];
+}
+
+// Delegate all remaining calls to the original text input delegate
+
+- (void)textInputDidBeginEditing {
+  [_originalTextInputDelegate textInputDidBeginEditing];
+}
+
+- (void)textInputDidChangeSelection {
+  [_originalTextInputDelegate textInputDidChangeSelection];
+}
+
+- (void)textInputDidEndEditing {
+  [_originalTextInputDelegate textInputDidEndEditing];
+}
+
+- (void)textInputDidReturn {
+  [_originalTextInputDelegate textInputDidReturn];
+}
+
+- (BOOL)textInputShouldBeginEditing {
+  return [_originalTextInputDelegate textInputShouldBeginEditing];
+}
+
+- (nonnull NSString *)textInputShouldChangeText:(nonnull NSString *)text inRange:(NSRange)range {
+  return [_originalTextInputDelegate textInputShouldChangeText:text inRange:range];
+}
+
+- (BOOL)textInputShouldEndEditing {
+  return [_originalTextInputDelegate textInputShouldEndEditing];
+}
+
+- (BOOL)textInputShouldReturn {
+  return [_originalTextInputDelegate textInputShouldReturn];
+}
+
+- (BOOL)textInputShouldSubmitOnReturn {
+  return [_originalTextInputDelegate textInputShouldSubmitOnReturn];
+}
+
+@end

apple/MarkdownCommitHook.mm

@@ -197,8 +197,8 @@
             }
 
             // apply markdown
-            auto newString = [usedUtils parseMarkdown:nsAttributedString
-                            withDefaultTextAttributes:defaultNSTextAttributes];
+            NSMutableAttributedString *newString = [nsAttributedString mutableCopy];
+            [usedUtils applyMarkdownFormatting:newString withDefaultTextAttributes:defaultNSTextAttributes];
 
             // create a clone of the old TextInputState and update the
             // attributed string box to point to the string with markdown
@@ -246,8 +246,8 @@
                     stateData.attributedStringBox);
 
             // apply markdown
-            auto newString = [usedUtils parseMarkdown:nsAttributedString
-                            withDefaultTextAttributes:defaultNSTextAttributes];
+            NSMutableAttributedString *newString = [nsAttributedString mutableCopy];
+            [usedUtils applyMarkdownFormatting:newString withDefaultTextAttributes:defaultNSTextAttributes];
 
             // create a clone of the old TextInputState and update the
             // attributed string box to point to the string with markdown

apple/MarkdownFormatter.h

@@ -8,10 +8,10 @@ const NSAttributedStringKey RCTLiveMarkdownBlockquoteDepthAttributeName = @"RCTL
 
 @interface MarkdownFormatter : NSObject
 
-- (nonnull NSAttributedString *)format:(nonnull NSString *)text
-             withDefaultTextAttributes:(nonnull NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes
-                    withMarkdownRanges:(nonnull NSArray<MarkdownRange *> *)markdownRanges
-                     withMarkdownStyle:(nonnull RCTMarkdownStyle *)markdownStyle;
+- (void)formatAttributedString:(nonnull NSMutableAttributedString *)attributedString
+     withDefaultTextAttributes:(nonnull NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes
+            withMarkdownRanges:(nonnull NSArray<MarkdownRange *> *)markdownRanges
+             withMarkdownStyle:(nonnull RCTMarkdownStyle *)markdownStyle;
 
 NS_ASSUME_NONNULL_END
 

apple/MarkdownFormatter.mm

@@ -3,21 +3,22 @@
 
 @implementation MarkdownFormatter
 
-- (nonnull NSAttributedString *)format:(nonnull NSString *)text
-             withDefaultTextAttributes:(nonnull NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes
-                    withMarkdownRanges:(nonnull NSArray<MarkdownRange *> *)markdownRanges
-                     withMarkdownStyle:(nonnull RCTMarkdownStyle *)markdownStyle
+- (void)formatAttributedString:(nonnull NSMutableAttributedString *)attributedString
+     withDefaultTextAttributes:(nonnull NSDictionary<NSAttributedStringKey, id> *)defaultTextAttributes
+            withMarkdownRanges:(nonnull NSArray<MarkdownRange *> *)markdownRanges
+             withMarkdownStyle:(nonnull RCTMarkdownStyle *)markdownStyle
 {
-  NSMutableAttributedString *attributedString = [[NSMutableAttributedString alloc] initWithString:text attributes:defaultTextAttributes];
+  NSRange fullRange = NSMakeRange(0, attributedString.length);
 
   [attributedString beginEditing];
 
-  // If the attributed string ends with underlined text, blurring the single-line input imprints the underline style across the whole string.
-  // It looks like a bug in iOS, as there is no underline style to be found in the attributed string, especially after formatting.
-  // This is a workaround that applies the NSUnderlineStyleNone to the string before iterating over ranges which resolves this problem.
-  [attributedString addAttribute:NSUnderlineStyleAttributeName
-                           value:[NSNumber numberWithInteger:NSUnderlineStyleNone]
-                           range:NSMakeRange(0, attributedString.length)];
+  // We cannot simply call `[attributedString setAttributes:@{} range:fullRange];`
+  // because it makes spellcheck disappear immediately and also makes cursor lag behind while typing fast.
+
+  [attributedString removeAttribute:NSParagraphStyleAttributeName range:fullRange];
+  [attributedString removeAttribute:RCTLiveMarkdownBlockquoteDepthAttributeName range:fullRange];
+
+  [attributedString addAttributes:defaultTextAttributes range:fullRange];
 
   for (MarkdownRange *markdownRange in markdownRanges) {
     [self applyRangeToAttributedString:attributedString
@@ -29,9 +30,25 @@ - (nonnull NSAttributedString *)format:(nonnull NSString *)text
 
   RCTApplyBaselineOffset(attributedString);
 
-  [attributedString endEditing];
+  /*
+  Calling `[attributedString addAttributes:defaultTextAttributes range:fullRange]` breaks the font for emojis.
+  Before, NSFont attribute is ".SFUI-Regular" and NSOriginalFont attribute is ".AppleColorEmoji".
+  After the call, both are set to ".SFUI-Regular" which makes emoji invisible and zero-width.
+  Calling `fixAttributesInRange:` fixes this problem.
+  */
+  [attributedString fixAttributesInRange:fullRange];
+
+  /*
+  When updating MarkdownTextInput's `style` property without changing `markdownStyle`,
+  React Native calls `[RCTTextInputComponentView _setAttributedString:]` which skips update if strings are equal.
+  See https://github.com/facebook/react-native/blob/287e20033207df5e59d199a347b7ae2b4cd7a59e/packages/react-native/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputComponentView.mm#L680-L684
+  The attributed strings are compared using `[RCTTextInputComponentView _textOf:equals:]` which compares only raw strings
+  if NSOriginalFont attribute is present. So we purposefully remove this attribute to force update.
+  See https://github.com/facebook/react-native/blob/287e20033207df5e59d199a347b7ae2b4cd7a59e/packages/react-native/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputComponentView.mm#L751-L784
+  */
+  [attributedString removeAttribute:@"NSOriginalFont" range:fullRange];
 
-  return attributedString;
+  [attributedString endEditing];
 }
 
 - (void)applyRangeToAttributedString:(NSMutableAttributedString *)attributedString

apple/MarkdownParser.mm

@@ -32,7 +32,7 @@ @implementation MarkdownParser {
       output = markdownRuntime->runGuarded(markdownWorklet, input);
     } catch (const jsi::JSError &error) {
       // Skip formatting, runGuarded will show the error in LogBox
-      _prevText = text;
+      _prevText = [NSString stringWithString:text];
       _prevParserId = parserId;
       _prevMarkdownRanges = @[];
       return _prevMarkdownRanges;
@@ -58,13 +58,13 @@ @implementation MarkdownParser {
       }
     } catch (const jsi::JSError &error) {
       RCTLogWarn(@"[react-native-live-markdown] Incorrect schema of worklet parser output: %s", error.getMessage().c_str());
-      _prevText = text;
+      _prevText = [NSString stringWithString:text];
       _prevParserId = parserId;
       _prevMarkdownRanges = @[];
       return _prevMarkdownRanges;
     }
 
-    _prevText = text;
+    _prevText = [NSString stringWithString:text];
     _prevParserId = parserId;
     _prevMarkdownRanges = markdownRanges;
     return _prevMarkdownRanges;

apple/MarkdownTextFieldObserver.h

@@ -0,0 +1,17 @@
+#import <UIKit/UIKit.h>
+#import <React/RCTUITextField.h>
+#import <RNLiveMarkdown/RCTMarkdownUtils.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MarkdownTextFieldObserver : NSObject
+
+- (instancetype)initWithTextField:(nonnull RCTUITextField *)textField markdownUtils:(nonnull RCTMarkdownUtils *)markdownUtils;
+
+- (void)textFieldDidChange:(UITextField *)textField;
+
+- (void)textFieldDidEndEditing:(UITextField *)textField;
+
+@end
+
+NS_ASSUME_NONNULL_END

apple/MarkdownTextFieldObserver.mm

@@ -0,0 +1,73 @@
+#import <RNLiveMarkdown/MarkdownTextFieldObserver.h>
+#import "react_native_assert.h"
+
+@implementation MarkdownTextFieldObserver {
+  RCTUITextField *_textField;
+  RCTMarkdownUtils *_markdownUtils;
+  BOOL _active;
+}
+
+- (instancetype)initWithTextField:(nonnull RCTUITextField *)textField markdownUtils:(nonnull RCTMarkdownUtils *)markdownUtils
+{
+  if ((self = [super init])) {
+    react_native_assert(textField != nil);
+    react_native_assert(markdownUtils != nil);
+
+    _textField = textField;
+    _markdownUtils = markdownUtils;
+    _active = YES;
+  }
+  return self;
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context
+{
+  if (_active && ([keyPath isEqualToString:@"text"] || [keyPath isEqualToString:@"attributedText"])) {
+    [self applyMarkdownFormatting];
+  }
+}
+
+- (void)textFieldDidChange:(__unused UITextField *)textField
+{
+  [self applyMarkdownFormatting];
+}
+
+- (void)textFieldDidEndEditing:(__unused UITextField *)textField
+{
+  // In order to prevent iOS from applying underline to the whole text if text ends with a link on blur,
+  // we need to update `defaultTextAttributes` which at this point doesn't contain NSUnderline attribute yet.
+  // It seems like the setter performs deep comparision, so we differentiate the new value using a counter,
+  // otherwise this trick would work only once.
+  static NSAttributedStringKey RCTLiveMarkdownForceUpdateAttributeName = @"RCTLiveMarkdownForceUpdate";
+  static NSUInteger counter = 0;
+  NSMutableDictionary *defaultTextAttributes = [_textField.defaultTextAttributes mutableCopy];
+  defaultTextAttributes[RCTLiveMarkdownForceUpdateAttributeName] = @(counter++);
+  _textField.defaultTextAttributes = defaultTextAttributes;
+  [self applyMarkdownFormatting];
+}
+
+- (void)applyMarkdownFormatting
+{
+  react_native_assert(_textField.defaultTextAttributes != nil);
+
+  if (_textField.markedTextRange != nil) {
+    return; // skip formatting during multi-stage input to avoid breaking internal state
+  }
+
+  NSMutableAttributedString *attributedText = [_textField.attributedText mutableCopy];
+  [_markdownUtils applyMarkdownFormatting:attributedText withDefaultTextAttributes:_textField.defaultTextAttributes];
+
+  UITextRange *textRange = _textField.selectedTextRange;
+
+  _active = NO; // prevent recursion
+  _textField.attributedText = attributedText;
+  _active = YES;
+
+  // Restore cursor position
+  [_textField setSelectedTextRange:textRange notifyDelegate:NO];
+
+  // Eliminate underline blinks while typing if previous text ends with a link
+  _textField.typingAttributes = _textField.defaultTextAttributes;
+}
+
+@end