react-native-enriched-html 0.0.0 → 1.0.0

package/ios/textHtmlParser/TextHtmlParser.mm

@@ -0,0 +1,181 @@
+#import "TextHtmlParser.h"
+#import "AlignmentEntry.h"
+#import "EnrichedTextView.h"
+#import "HtmlParser.h"
+#import "LinkData.h"
+#import "MentionParams.h"
+#import "StyleHeaders.h"
+#import "StyleUtils.h"
+#import "ZeroWidthSpaceUtils.h"
+#import <React/RCTLog.h>
+
+@implementation TextHtmlParser
+
+- (instancetype)initWithView:(EnrichedTextView *)view {
+  self = [super init];
+  _view = view;
+  return self;
+}
+
+- (void)replaceWholeFromHtml:(NSString *_Nonnull)html {
+  @try {
+    NSString *normalized =
+        [HtmlParser initiallyProcessHtml:html
+                       useHtmlNormalizer:_view->useHtmlNormalizer];
+    if (normalized == nil) {
+      [_view->textView.textStorage
+          setAttributedString:[[NSAttributedString alloc]
+                                  initWithString:html
+                                      attributes:_view->
+                                                 defaultTypingAttributes]];
+      return;
+    }
+
+    NSArray *result = [HtmlParser getTextAndStylesFromHtml:normalized];
+    NSString *plainText = result[0];
+    NSArray *processedStyles = result[1];
+    NSArray *alignments = result[2];
+
+    NSMutableAttributedString *body = [[NSMutableAttributedString alloc]
+        initWithString:plainText
+            attributes:_view->defaultTypingAttributes];
+    [_view->textView.textStorage setAttributedString:body];
+    [self applyProcessedStyles:processedStyles];
+    [self applyProcessedAlignments:alignments];
+  } @catch (NSException *exception) {
+    RCTLogWarn(@"[EnrichedTextView]: Failed to parse HTML: (%@), falling back "
+               @"to raw input.",
+               exception.reason);
+    [_view->textView.textStorage
+        setAttributedString:[[NSAttributedString alloc]
+                                initWithString:html
+                                    attributes:_view->defaultTypingAttributes]];
+  }
+}
+
+- (void)applyProcessedStyles:(NSArray *_Nonnull)processedStyles {
+  // Some paragraph styles (codeblock, blockquote, etc.) insert \u200B
+  // into empty lines, mutating NSTextStorage length. We need to
+  // shift subsequent ranges by this offset.
+  NSInteger zeroWidthSpaceOffset = 0;
+
+  // Inline styles collected during the first pass so their applyStyling: can
+  // be re-run after all paragraph styles have applied their visual attributes.
+  // Each entry is @[style, adjustedRange].
+  NSMutableArray *pendingInlineApply = [NSMutableArray array];
+
+  // Paragraph styles call applyStyling: immediately; inline styles
+  // defer it so that paragraph visual attributes are already in
+  // place when inline styles override them.
+  for (NSArray *arr in processedStyles) {
+    NSNumber *styleType = (NSNumber *)arr[0];
+    StylePair *stylePair = (StylePair *)arr[1];
+    StyleBase *style = _view->stylesDict[styleType];
+    if (style == nullptr)
+      continue;
+
+    NSRange parsedRange = [stylePair.rangeValue rangeValue];
+    NSUInteger textLengthBeforeStyleApplied =
+        _view->textView.textStorage.string.length;
+
+    // Range must be taking zeroWidthSpaceOffset into consideration
+    // because processed styles ranges are relative to only the new text while
+    // we need absolute ranges relative to the whole existing text
+    NSRange styleRange = NSMakeRange(
+        zeroWidthSpaceOffset + parsedRange.location, parsedRange.length);
+
+    if (![StyleUtils handleStyleBlocksAndConflicts:[[style class] getType]
+                                             range:styleRange
+                                           forHost:_view]) {
+      continue;
+    }
+
+    if ([styleType isEqualToNumber:@([LinkStyle getType])]) {
+      LinkData *linkData = (LinkData *)stylePair.styleValue;
+      [((LinkStyle *)style) applyLinkMetaWithData:linkData range:styleRange];
+    } else if ([styleType isEqualToNumber:@([MentionStyle getType])]) {
+      MentionParams *params = (MentionParams *)stylePair.styleValue;
+      [((MentionStyle *)style) applyMentionMeta:params range:styleRange];
+    } else if ([styleType isEqualToNumber:@([ImageStyle getType])]) {
+      ImageData *imgData = (ImageData *)stylePair.styleValue;
+      [((ImageStyle *)style) addImageAtRange:styleRange
+                                   imageData:imgData
+                               withSelection:NO
+                              withDirtyRange:NO];
+    } else if ([styleType isEqualToNumber:@([CheckboxListStyle getType])]) {
+      NSDictionary *checkboxStates = (NSDictionary *)stylePair.styleValue;
+      CheckboxListStyle *cbStyle = (CheckboxListStyle *)style;
+
+      [cbStyle addWithChecked:NO
+                        range:styleRange
+                   withTyping:NO
+               withDirtyRange:NO];
+
+      if (checkboxStates && checkboxStates.count > 0) {
+        for (NSNumber *key in checkboxStates) {
+          NSUInteger checkboxPosition =
+              zeroWidthSpaceOffset + [key unsignedIntegerValue];
+          BOOL isChecked = [checkboxStates[key] boolValue];
+
+          if (isChecked) {
+            [cbStyle toggleCheckedAt:checkboxPosition withDirtyRange:NO];
+          }
+        }
+      }
+    } else {
+      [style add:styleRange withTyping:NO withDirtyRange:NO];
+    }
+
+    [ZeroWidthSpaceUtils addSpacesIfNeededInHost:_view inRange:styleRange];
+
+    NSInteger delta = _view->textView.textStorage.string.length -
+                      textLengthBeforeStyleApplied;
+
+    // Use an adjusted range so that applyStyling covers any ZWS characters that
+    // were just inserted by addSpacesIfNeededInHost:inRange:. Without this, a
+    // style applied to an empty range {0,0} would call applyStyling on {0,0}
+    // even after a ZWS was inserted.
+    NSRange adjustedStyleRange = NSMakeRange(
+        styleRange.location, styleRange.length + (NSUInteger)MAX(0LL, delta));
+
+    if ([style isParagraph]) {
+      [style applyStyling:adjustedStyleRange];
+    } else {
+      [pendingInlineApply
+          addObject:@[ style, [NSValue valueWithRange:adjustedStyleRange] ]];
+    }
+
+    // Image shifts are already handled by _precedingImageCount during tag
+    // finalization.
+    if (delta != 0 && ![styleType isEqualToNumber:@([ImageStyle getType])]) {
+      zeroWidthSpaceOffset += delta;
+    }
+  }
+
+  // Apply visual styling for inline styles
+  for (NSArray *entry in pendingInlineApply) {
+    StyleBase *style = entry[0];
+    NSRange adjustedStyleRange = [((NSValue *)entry[1]) rangeValue];
+    [style applyStyling:adjustedStyleRange];
+  }
+}
+
+- (void)applyProcessedAlignments:(NSArray<AlignmentEntry *> *)alignments {
+  AlignmentStyle *alignmentStyle =
+      _view.stylesDict[@([AlignmentStyle getType])];
+
+  if (alignmentStyle == nil) {
+    return;
+  }
+
+  for (AlignmentEntry *entry in alignments) {
+    NSRange finalRange = NSMakeRange(entry.range.location, entry.range.length);
+    [alignmentStyle addAlignment:entry.alignment
+                           range:finalRange
+                      withTyping:NO
+                  withDirtyRange:NO];
+    [alignmentStyle applyStyling:finalRange];
+  }
+}
+
+@end

package/ios/utils/AlignmentUtils.h

@@ -0,0 +1,20 @@
+#import "AlignmentEntry.h"
+#import "EnrichedTextInputView.h"
+#import "StyleHeaders.h"
+#import <UIKit/UIKit.h>
+
+@interface AlignmentUtils : NSObject
+
++ (NSString *)alignmentToString:(NSTextAlignment)alignmentl;
+
++ (NSTextAlignment)stringToAlignment:(NSString *)alignmentString;
+
++ (NSString *)alignmentToMarker:(NSTextAlignment)alignment;
+
++ (NSTextAlignment)markerToAlignment:(NSString *)marker;
+
++ (NSString *)cssValueForAlignment:(NSTextAlignment)alignment;
+
++ (NSTextAlignment)alignmentFromStyleParams:(NSString *)params;
+
+@end

package/ios/utils/AlignmentUtils.mm

@@ -0,0 +1,111 @@
+#import "AlignmentUtils.h"
+#import "RangeUtils.h"
+#import "StyleHeaders.h"
+
+@implementation AlignmentUtils
+
++ (NSString *)alignmentToString:(NSTextAlignment)alignment {
+  switch (alignment) {
+  case NSTextAlignmentLeft:
+    return @"left";
+  case NSTextAlignmentCenter:
+    return @"center";
+  case NSTextAlignmentRight:
+    return @"right";
+  case NSTextAlignmentJustified:
+    return @"justify";
+  case NSTextAlignmentNatural:
+  default:
+    return @"auto";
+  }
+}
+
++ (NSTextAlignment)stringToAlignment:(NSString *)alignmentString {
+  NSString *normalized = [alignmentString lowercaseString];
+
+  if ([normalized isEqualToString:@"left"]) {
+    return NSTextAlignmentLeft;
+  }
+  if ([normalized isEqualToString:@"center"]) {
+    return NSTextAlignmentCenter;
+  }
+  if ([normalized isEqualToString:@"right"]) {
+    return NSTextAlignmentRight;
+  }
+  if ([normalized isEqualToString:@"justify"]) {
+    return NSTextAlignmentJustified;
+  }
+
+  return NSTextAlignmentNatural;
+}
+
++ (NSTextAlignment)markerToAlignment:(NSString *)marker {
+  if ([marker isEqualToString:@"EnrichedAlignmentLeft"]) {
+    return NSTextAlignmentLeft;
+  } else if ([marker isEqualToString:@"EnrichedAlignmentCenter"]) {
+    return NSTextAlignmentCenter;
+  } else if ([marker isEqualToString:@"EnrichedAlignmentRight"]) {
+    return NSTextAlignmentRight;
+  } else if ([marker isEqualToString:@"EnrichedAlignmentJustified"]) {
+    return NSTextAlignmentJustified;
+  }
+  return NSTextAlignmentNatural;
+}
+
++ (NSString *)alignmentToMarker:(NSTextAlignment)alignment {
+  if (alignment == NSTextAlignmentLeft) {
+    return @"EnrichedAlignmentLeft";
+  } else if (alignment == NSTextAlignmentCenter) {
+    return @"EnrichedAlignmentCenter";
+  } else if (alignment == NSTextAlignmentRight) {
+    return @"EnrichedAlignmentRight";
+  } else if (alignment == NSTextAlignmentJustified) {
+    return @"EnrichedAlignmentJustified";
+  }
+
+  return @"EnrichedAlignmentNatural";
+}
+
++ (NSString *)cssValueForAlignment:(NSTextAlignment)alignment {
+  switch (alignment) {
+  case NSTextAlignmentLeft:
+    return @"left";
+  case NSTextAlignmentCenter:
+    return @"center";
+  case NSTextAlignmentRight:
+    return @"right";
+  case NSTextAlignmentJustified:
+    return @"justify";
+  default:
+    return nil;
+  }
+}
+
++ (NSTextAlignment)alignmentFromStyleParams:(NSString *)params {
+  if (!params)
+    return NSTextAlignmentNatural;
+
+  NSString *pattern = @"text-align\\s*:\\s*(left|center|right|justify)";
+
+  NSRegularExpression *regex = [NSRegularExpression
+      regularExpressionWithPattern:pattern
+                           options:NSRegularExpressionCaseInsensitive
+                             error:nil];
+
+  NSTextCheckingResult *match =
+      [regex firstMatchInString:params
+                        options:0
+                          range:NSMakeRange(0, params.length)];
+
+  if (match) {
+    // rangeAtIndex:1 corresponds to the capture group
+    // (left|center|right|justify)
+    NSString *value =
+        [[params substringWithRange:[match rangeAtIndex:1]] lowercaseString];
+    return [AlignmentUtils stringToAlignment:value];
+  }
+
+  return NSTextAlignmentNatural;
+}
+
+@end

package/ios/utils/AttachmentLayoutUtils.h

@@ -0,0 +1,24 @@
+#pragma once
+#import "EnrichedConfig.h"
+#import "ImageAttachment.h"
+#import <UIKit/UIKit.h>
+
+@interface AttachmentLayoutUtils : NSObject
+
++ (void)handleAttachmentUpdate:(MediaAttachment *)attachment
+                      textView:(UITextView *)textView
+                 onLayoutBlock:(dispatch_block_t)layoutBlock;
+
++ (NSMutableDictionary<NSValue *, UIImageView *> *)
+    layoutAttachmentsInTextView:(UITextView *)textView
+                         config:(EnrichedConfig *)config
+                  existingViews:
+                      (NSMutableDictionary<NSValue *, UIImageView *> *)
+                          attachmentViews;
+
++ (CGRect)frameForAttachment:(ImageAttachment *)attachment
+                     atRange:(NSRange)range
+                    textView:(UITextView *)textView
+                      config:(EnrichedConfig *)config;
+
+@end

package/ios/utils/AttachmentLayoutUtils.mm

@@ -0,0 +1,144 @@
+#import "AttachmentLayoutUtils.h"
+
+@implementation AttachmentLayoutUtils
+
++ (void)handleAttachmentUpdate:(MediaAttachment *)attachment
+                      textView:(UITextView *)textView
+                 onLayoutBlock:(dispatch_block_t)layoutBlock {
+  NSTextStorage *storage = textView.textStorage;
+  NSRange fullRange = NSMakeRange(0, storage.length);
+
+  __block NSRange foundRange = NSMakeRange(NSNotFound, 0);
+
+  [storage enumerateAttribute:NSAttachmentAttributeName
+                      inRange:fullRange
+                      options:0
+                   usingBlock:^(id value, NSRange range, BOOL *stop) {
+                     if (value == attachment) {
+                       foundRange = range;
+                       *stop = YES;
+                     }
+                   }];
+
+  if (foundRange.location == NSNotFound) {
+    return;
+  }
+
+  [storage edited:NSTextStorageEditedAttributes
+               range:foundRange
+      changeInLength:0];
+
+  dispatch_async(dispatch_get_main_queue(), layoutBlock);
+}
+
++ (NSMutableDictionary<NSValue *, UIImageView *> *)
+    layoutAttachmentsInTextView:(UITextView *)textView
+                         config:(EnrichedConfig *)config
+                  existingViews:
+                      (NSMutableDictionary<NSValue *, UIImageView *> *)
+                          attachmentViews {
+  NSTextStorage *storage = textView.textStorage;
+  NSMutableDictionary<NSValue *, UIImageView *> *activeAttachmentViews =
+      [NSMutableDictionary dictionary];
+
+  if (storage.length > 0) {
+    // Iterate over the entire text to find ImageAttachments
+    [storage enumerateAttribute:NSAttachmentAttributeName
+                        inRange:NSMakeRange(0, storage.length)
+                        options:0
+                     usingBlock:^(id value, NSRange range, BOOL *stop) {
+                       if ([value isKindOfClass:[ImageAttachment class]]) {
+                         ImageAttachment *attachment = (ImageAttachment *)value;
+
+                         CGRect rect = [self frameForAttachment:attachment
+                                                        atRange:range
+                                                       textView:textView
+                                                         config:config];
+
+                         // Get or Create the UIImageView for this specific
+                         // attachment key
+                         NSValue *key =
+                             [NSValue valueWithNonretainedObject:attachment];
+                         UIImageView *imgView = attachmentViews[key];
+
+                         if (!imgView) {
+                           // It doesn't exist yet, create it
+                           imgView = [[UIImageView alloc] initWithFrame:rect];
+                           imgView.contentMode =
+                               UIViewContentModeScaleAspectFit;
+                           imgView.tintColor = [UIColor labelColor];
+
+                           // Add it directly to the TextView
+                           [textView addSubview:imgView];
+                         }
+
+                         // Update position (in case text moved/scrolled)
+                         if (!CGRectEqualToRect(imgView.frame, rect)) {
+                           imgView.frame = rect;
+                         }
+                         UIImage *targetImage =
+                             attachment.storedAnimatedImage ?: attachment.image;
+
+                         // Only set if different to avoid resetting the
+                         // animation loop
+                         if (imgView.image != targetImage) {
+                           imgView.image = targetImage;
+                         }
+
+                         // Ensure it is visible on top
+                         imgView.hidden = NO;
+                         [textView bringSubviewToFront:imgView];
+
+                         activeAttachmentViews[key] = imgView;
+                         // Remove from the old map so we know it has been
+                         // claimed
+                         [attachmentViews removeObjectForKey:key];
+                       }
+                     }];
+  }
+
+  // Everything remaining in attachmentViews is dead or off-screen
+  for (UIImageView *danglingView in attachmentViews.allValues) {
+    [danglingView removeFromSuperview];
+  }
+
+  return activeAttachmentViews;
+}
+
++ (CGRect)frameForAttachment:(ImageAttachment *)attachment
+                     atRange:(NSRange)range
+                    textView:(UITextView *)textView
+                      config:(EnrichedConfig *)config {
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  NSTextContainer *textContainer = textView.textContainer;
+  NSTextStorage *storage = textView.textStorage;
+
+  NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:range
+                                             actualCharacterRange:NULL];
+  CGRect glyphRect = [layoutManager boundingRectForGlyphRange:glyphRange
+                                              inTextContainer:textContainer];
+
+  CGRect lineRect =
+      [layoutManager lineFragmentRectForGlyphAtIndex:glyphRange.location
+                                      effectiveRange:NULL];
+  CGSize attachmentSize = attachment.bounds.size;
+
+  UIFont *font = [storage attribute:NSFontAttributeName
+                            atIndex:range.location
+                     effectiveRange:NULL];
+  if (!font) {
+    font = [config primaryFont];
+  }
+
+  // Calculate (Baseline Alignment)
+  CGFloat targetY =
+      CGRectGetMaxY(lineRect) + font.descender - attachmentSize.height;
+  CGRect rect =
+      CGRectMake(glyphRect.origin.x + textView.textContainerInset.left,
+                 targetY + textView.textContainerInset.top,
+                 attachmentSize.width, attachmentSize.height);
+
+  return CGRectIntegral(rect);
+}
+
+@end

package/ios/utils/CheckboxHitTestUtils.h

@@ -0,0 +1,10 @@
+#import <UIKit/UIKit.h>
+
+@class EnrichedTextInputView;
+
+@interface CheckboxHitTestUtils : NSObject
+
++ (NSInteger)hitTestCheckboxAtPoint:(CGPoint)pt
+                            inInput:(EnrichedTextInputView *)input;
+
+@end

package/ios/utils/CheckboxHitTestUtils.mm

@@ -0,0 +1,122 @@
+#import "CheckboxHitTestUtils.h"
+#import "EnrichedConfig.h"
+#import "EnrichedTextInputView.h"
+#import "StyleHeaders.h"
+
+static const CGFloat kCheckboxHitSlopLeft = 8.0;
+static const CGFloat kCheckboxHitSlopVertical = 6.0;
+
+@implementation CheckboxHitTestUtils
+
+// MARK: - Coordinate helpers
+
++ (CGPoint)containerPointFromViewPoint:(CGPoint)point
+                              textView:(UITextView *)textView {
+  return CGPointMake(point.x - textView.textContainerInset.left,
+                     point.y - textView.textContainerInset.top);
+}
+
+// MARK: - Glyph lookup
+
++ (NSUInteger)glyphIndexAtContainerPoint:(CGPoint)point
+                                textView:(UITextView *)textView {
+  return [textView.layoutManager glyphIndexForPoint:point
+                                    inTextContainer:textView.textContainer
+                     fractionOfDistanceThroughGlyph:nil];
+}
+
+// MARK: - Checkbox detection
+
++ (BOOL)isCheckboxGlyph:(NSUInteger)glyphIndex
+                inInput:(EnrichedTextInputView *)input {
+  UITextView *textView = input->textView;
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  NSTextStorage *storage = textView.textStorage;
+
+  NSUInteger charIndex =
+      [layoutManager characterIndexForGlyphAtIndex:glyphIndex];
+
+  if (charIndex >= storage.length) {
+    return NO;
+  }
+
+  CheckboxListStyle *checkboxListStyle =
+      (CheckboxListStyle *)input->stylesDict[@([CheckboxListStyle getType])];
+
+  if (!checkboxListStyle) {
+    return NO;
+  }
+
+  return [checkboxListStyle detect:NSMakeRange(charIndex, 0)];
+}
+
+// MARK: - Checkbox rect
+
++ (CGRect)checkboxRectForGlyphIndex:(NSUInteger)glyphIndex
+                            inInput:(EnrichedTextInputView *)input {
+  UITextView *textView = input->textView;
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  EnrichedConfig *config = input->config;
+
+  if (!config) {
+    return CGRectNull;
+  }
+
+  CGRect lineRect = [layoutManager lineFragmentRectForGlyphAtIndex:glyphIndex
+                                                    effectiveRange:nil];
+
+  CGFloat originX = lineRect.origin.x + config.checkboxListMarginLeft;
+
+  CGFloat originY = lineRect.origin.y +
+                    (lineRect.size.height - config.checkboxListBoxSize) / 2.0;
+
+  return CGRectMake(originX, originY, config.checkboxListBoxSize,
+                    config.checkboxListBoxSize);
+}
+
+// MARK: - Hit rect
+
++ (CGRect)expandedHitRectFromCheckboxRect:(CGRect)rect {
+  if (CGRectIsNull(rect))
+    return rect;
+
+  return CGRectInset(rect, -kCheckboxHitSlopLeft, -kCheckboxHitSlopVertical);
+}
+
+// MARK: - Public API
+
++ (NSInteger)hitTestCheckboxAtPoint:(CGPoint)point
+                            inInput:(EnrichedTextInputView *)input {
+  UITextView *textView = input->textView;
+
+  CGPoint containerPoint = [self containerPointFromViewPoint:point
+                                                    textView:textView];
+
+  NSUInteger glyphIndex = [self glyphIndexAtContainerPoint:containerPoint
+                                                  textView:textView];
+
+  if (glyphIndex == NSNotFound) {
+    return -1;
+  }
+
+  if (![self isCheckboxGlyph:glyphIndex inInput:input]) {
+    return -1;
+  }
+
+  CGRect checkboxRect = [self checkboxRectForGlyphIndex:glyphIndex
+                                                inInput:input];
+
+  if (CGRectIsNull(checkboxRect)) {
+    return -1;
+  }
+
+  CGRect hitRect = [self expandedHitRectFromCheckboxRect:checkboxRect];
+
+  if (!CGRectContainsPoint(hitRect, containerPoint)) {
+    return -1;
+  }
+
+  return [textView.layoutManager characterIndexForGlyphAtIndex:glyphIndex];
+}
+
+@end

package/ios/utils/DotReplacementUtils.h

@@ -0,0 +1,10 @@
+#import <UIKit/UIKit.h>
+#pragma once
+
+@interface DotReplacementUtils : NSObject
++ (void)handleDotReplacement:(id)input
+                 textStorage:(NSTextStorage *)textStorage
+                  editedMask:(NSTextStorageEditActions)editedMask
+                 editedRange:(NSRange)editedRange
+                       delta:(NSInteger)delta;
+@end

package/ios/utils/DotReplacementUtils.mm

@@ -0,0 +1,68 @@
+#import "DotReplacementUtils.h"
+#import "EnrichedTextInputView.h"
+
+@implementation DotReplacementUtils
+
+// This is a fix for iOS replacing a space with a dot when two spaces are
+// quickly inputted That operation doesn't properly extend our custom attributes
+// and we do it here manually
++ (void)handleDotReplacement:(id)input
+                 textStorage:(NSTextStorage *)textStorage
+                  editedMask:(NSTextStorageEditActions)editedMask
+                 editedRange:(NSRange)editedRange
+                       delta:(NSInteger)delta {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)input;
+  if (typedInput == nullptr) {
+    return;
+  }
+
+  // Conditions for the dot attributes fix:
+  // - character edition was done
+  // - it edited one character
+  // - new character is a dot
+  // - delta=0, meaning a replacement was done
+  // - there is something before the edited range to get attributes from
+  if ((editedMask & NSTextStorageEditedCharacters) != 0 &&
+      editedRange.length == 1 &&
+      [[textStorage.string substringWithRange:editedRange]
+          isEqualToString:@"."] &&
+      delta == 0 && editedRange.location > 0) {
+    // If all of the above are true, we are sure some dot replacement has been
+    // done So we manually need to apply the preceeding attribtues to the dot
+    NSDictionary *prevAttrs =
+        [textStorage attributesAtIndex:editedRange.location - 1
+                        effectiveRange:nullptr];
+    [textStorage addAttributes:prevAttrs range:editedRange];
+    typedInput->dotReplacementRange = [NSValue valueWithRange:editedRange];
+    return;
+  }
+
+  // Space after the dot added by iOS comes in a separate, second callback.
+  // Checking its conditions:
+  // - dotReplacementRange defined
+  // - dotReplacementRange was exactly before the new edited range
+  // - character edition was done
+  // - it edited one character
+  // - edited character is a space
+  // - delta=1, meaning addition was done
+  if (typedInput->dotReplacementRange != nullptr &&
+      [typedInput->dotReplacementRange rangeValue].location + 1 ==
+          editedRange.location &&
+      (editedMask & NSTextStorageEditedCharacters) != 0 &&
+      editedRange.length == 1 &&
+      [[textStorage.string substringWithRange:editedRange]
+          isEqualToString:@" "] &&
+      delta == 1) {
+    // If all of the above are true, we are now sure it was the iOS dot
+    // replacement Only then do we also fix attribtues of the space added
+    // afterwards
+    NSDictionary *prevAttrs =
+        [textStorage attributesAtIndex:editedRange.location - 1
+                        effectiveRange:nullptr];
+    [textStorage addAttributes:prevAttrs range:editedRange];
+  }
+  // always reset the replacement range after any processing
+  typedInput->dotReplacementRange = nullptr;
+}
+
+@end