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

package/ios/input/InputStylePropsUtils.h

@@ -0,0 +1,261 @@
+#pragma once
+
+#import "ENRMInputFormatter.h"
+#import "ENRMUIKit.h"
+#import "FontUtils.h"
+#import <React/RCTConversions.h>
+
+#if !TARGET_OS_OSX
+static inline UITextAutocapitalizationType ENRMAutocapitalizationTypeFromString(NSString *value)
+{
+  if ([value isEqualToString:@"none"])
+    return UITextAutocapitalizationTypeNone;
+  if ([value isEqualToString:@"words"])
+    return UITextAutocapitalizationTypeWords;
+  if ([value isEqualToString:@"characters"])
+    return UITextAutocapitalizationTypeAllCharacters;
+  return UITextAutocapitalizationTypeSentences;
+}
+#endif
+
+template <typename InputProps>
+BOOL applyInputStyleProps(ENRMInputFormatterStyle *style, const InputProps &newProps, const InputProps &oldProps)
+{
+  BOOL changed = NO;
+
+  if (newProps.fontSize != oldProps.fontSize) {
+    CGFloat fontSize = newProps.fontSize > 0 ? newProps.fontSize : 16.0;
+    style.baseFont = [style.baseFont fontWithSize:fontSize];
+    changed = YES;
+  }
+
+  if (newProps.fontWeight != oldProps.fontWeight) {
+    CGFloat fontSize = style.baseFont.pointSize;
+    if (!newProps.fontWeight.empty()) {
+      NSString *weightString = [NSString stringWithUTF8String:newProps.fontWeight.c_str()];
+      UIFontWeight weight = ENRMFontWeightFromString(weightString);
+      style.baseFont = [UIFont systemFontOfSize:fontSize weight:weight];
+    } else {
+      style.baseFont = [UIFont systemFontOfSize:fontSize];
+    }
+    changed = YES;
+  }
+
+  if (newProps.fontFamily != oldProps.fontFamily) {
+    if (!newProps.fontFamily.empty()) {
+      NSString *familyName = [NSString stringWithUTF8String:newProps.fontFamily.c_str()];
+      UIFont *customFont = [UIFont fontWithName:familyName size:style.baseFont.pointSize];
+      if (customFont) {
+        style.baseFont = customFont;
+      }
+    } else {
+      style.baseFont = [UIFont systemFontOfSize:style.baseFont.pointSize];
+    }
+    changed = YES;
+  }
+
+  if (newProps.color != oldProps.color) {
+    if (isColorMeaningful(newProps.color)) {
+      style.baseTextColor = RCTUIColorFromSharedColor(newProps.color);
+    } else {
+      style.baseTextColor = [RCTUIColor labelColor];
+    }
+    changed = YES;
+  }
+
+  if (newProps.markdownStyle.strong.color != oldProps.markdownStyle.strong.color) {
+    if (isColorMeaningful(newProps.markdownStyle.strong.color)) {
+      style.boldColor = RCTUIColorFromSharedColor(newProps.markdownStyle.strong.color);
+    } else {
+      style.boldColor = nil;
+    }
+    changed = YES;
+  }
+
+  if (newProps.markdownStyle.em.color != oldProps.markdownStyle.em.color) {
+    if (isColorMeaningful(newProps.markdownStyle.em.color)) {
+      style.italicColor = RCTUIColorFromSharedColor(newProps.markdownStyle.em.color);
+    } else {
+      style.italicColor = nil;
+    }
+    changed = YES;
+  }
+
+  if (newProps.markdownStyle.link.color != oldProps.markdownStyle.link.color) {
+    style.linkColor = RCTUIColorFromSharedColor(newProps.markdownStyle.link.color);
+    changed = YES;
+  }
+
+  if (newProps.markdownStyle.link.underline != oldProps.markdownStyle.link.underline) {
+    style.linkUnderline = newProps.markdownStyle.link.underline;
+    changed = YES;
+  }
+
+  if (newProps.markdownStyle.link.backgroundColor != oldProps.markdownStyle.link.backgroundColor) {
+    RCTUIColor *backgroundColor = RCTUIColorFromSharedColor(newProps.markdownStyle.link.backgroundColor);
+    style.linkBackgroundColor = CGColorGetAlpha(backgroundColor.CGColor) > 0 ? backgroundColor : nil;
+    changed = YES;
+  }
+
+  {
+    BOOL linkVariantsChanged = newProps.markdownStyle.linkVariants.size() != oldProps.markdownStyle.linkVariants.size();
+    if (!linkVariantsChanged) {
+      for (size_t i = 0; i < newProps.markdownStyle.linkVariants.size(); i++) {
+        const auto &newVariant = newProps.markdownStyle.linkVariants[i];
+        const auto &oldVariant = oldProps.markdownStyle.linkVariants[i];
+        if (newVariant.pattern != oldVariant.pattern || newVariant.color != oldVariant.color ||
+            newVariant.underline != oldVariant.underline || newVariant.backgroundColor != oldVariant.backgroundColor) {
+          linkVariantsChanged = YES;
+          break;
+        }
+      }
+    }
+
+    if (linkVariantsChanged) {
+      NSMutableArray<ENRMInputLinkVariantStyle *> *variants = [NSMutableArray array];
+      for (const auto &entry : newProps.markdownStyle.linkVariants) {
+        ENRMInputLinkVariantStyle *variant = [[ENRMInputLinkVariantStyle alloc] init];
+        variant.pattern = [[NSString alloc] initWithUTF8String:entry.pattern.c_str()];
+        variant.color = RCTUIColorFromSharedColor(entry.color);
+        variant.underline = entry.underline;
+        RCTUIColor *backgroundColor = RCTUIColorFromSharedColor(entry.backgroundColor);
+        variant.backgroundColor = CGColorGetAlpha(backgroundColor.CGColor) > 0 ? backgroundColor : nil;
+        variant.regex = [NSRegularExpression regularExpressionWithPattern:variant.pattern options:0 error:nil];
+        if (variant.regex != nil) {
+          [variants addObject:variant];
+        }
+      }
+      style.linkVariants = variants;
+      changed = YES;
+    }
+  }
+
+  if (newProps.markdownStyle.spoiler.color != oldProps.markdownStyle.spoiler.color) {
+    style.spoilerColor = RCTUIColorFromSharedColor(newProps.markdownStyle.spoiler.color);
+    changed = YES;
+  }
+
+  if (newProps.markdownStyle.spoiler.backgroundColor != oldProps.markdownStyle.spoiler.backgroundColor) {
+    style.spoilerBackgroundColor = RCTUIColorFromSharedColor(newProps.markdownStyle.spoiler.backgroundColor);
+    changed = YES;
+  }
+
+  // Math (inline `$...$`)
+  if (newProps.markdownStyle.math.color != oldProps.markdownStyle.math.color) {
+    style.mathColor = isColorMeaningful(newProps.markdownStyle.math.color)
+                          ? RCTUIColorFromSharedColor(newProps.markdownStyle.math.color)
+                          : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.fontSize != oldProps.markdownStyle.math.fontSize) {
+    style.mathFontSize = newProps.markdownStyle.math.fontSize > 0 ? newProps.markdownStyle.math.fontSize : 16.0;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.backgroundColor != oldProps.markdownStyle.math.backgroundColor) {
+    RCTUIColor *bg = RCTUIColorFromSharedColor(newProps.markdownStyle.math.backgroundColor);
+    style.mathBackgroundColor = (bg && CGColorGetAlpha(bg.CGColor) > 0) ? bg : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.borderColor != oldProps.markdownStyle.math.borderColor) {
+    RCTUIColor *bc = RCTUIColorFromSharedColor(newProps.markdownStyle.math.borderColor);
+    style.mathBorderColor = (bc && CGColorGetAlpha(bc.CGColor) > 0) ? bc : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.borderWidth != oldProps.markdownStyle.math.borderWidth) {
+    style.mathBorderWidth = newProps.markdownStyle.math.borderWidth;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.borderRadius != oldProps.markdownStyle.math.borderRadius) {
+    style.mathBorderRadius = newProps.markdownStyle.math.borderRadius;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.paddingHorizontal != oldProps.markdownStyle.math.paddingHorizontal) {
+    style.mathPaddingHorizontal = newProps.markdownStyle.math.paddingHorizontal;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.paddingVertical != oldProps.markdownStyle.math.paddingVertical) {
+    style.mathPaddingVertical = newProps.markdownStyle.math.paddingVertical;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.selectedBackgroundColor != oldProps.markdownStyle.math.selectedBackgroundColor) {
+    RCTUIColor *sbg = RCTUIColorFromSharedColor(newProps.markdownStyle.math.selectedBackgroundColor);
+    style.mathSelectedBackgroundColor = (sbg && CGColorGetAlpha(sbg.CGColor) > 0) ? sbg : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.math.selectedBorderColor != oldProps.markdownStyle.math.selectedBorderColor) {
+    RCTUIColor *sbc = RCTUIColorFromSharedColor(newProps.markdownStyle.math.selectedBorderColor);
+    style.mathSelectedBorderColor = (sbc && CGColorGetAlpha(sbc.CGColor) > 0) ? sbc : nil;
+    changed = YES;
+  }
+
+  // Math block (`$$...$$`)
+  if (newProps.markdownStyle.mathBlock.color != oldProps.markdownStyle.mathBlock.color) {
+    style.mathBlockColor = isColorMeaningful(newProps.markdownStyle.mathBlock.color)
+                               ? RCTUIColorFromSharedColor(newProps.markdownStyle.mathBlock.color)
+                               : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.fontSize != oldProps.markdownStyle.mathBlock.fontSize) {
+    style.mathBlockFontSize =
+        newProps.markdownStyle.mathBlock.fontSize > 0 ? newProps.markdownStyle.mathBlock.fontSize : 20.0;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.backgroundColor != oldProps.markdownStyle.mathBlock.backgroundColor) {
+    RCTUIColor *bg = RCTUIColorFromSharedColor(newProps.markdownStyle.mathBlock.backgroundColor);
+    style.mathBlockBackgroundColor = (bg && CGColorGetAlpha(bg.CGColor) > 0) ? bg : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.borderColor != oldProps.markdownStyle.mathBlock.borderColor) {
+    RCTUIColor *bc = RCTUIColorFromSharedColor(newProps.markdownStyle.mathBlock.borderColor);
+    style.mathBlockBorderColor = (bc && CGColorGetAlpha(bc.CGColor) > 0) ? bc : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.borderWidth != oldProps.markdownStyle.mathBlock.borderWidth) {
+    style.mathBlockBorderWidth = newProps.markdownStyle.mathBlock.borderWidth;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.borderRadius != oldProps.markdownStyle.mathBlock.borderRadius) {
+    style.mathBlockBorderRadius = newProps.markdownStyle.mathBlock.borderRadius;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.paddingHorizontal != oldProps.markdownStyle.mathBlock.paddingHorizontal) {
+    style.mathBlockPaddingHorizontal = newProps.markdownStyle.mathBlock.paddingHorizontal;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.paddingVertical != oldProps.markdownStyle.mathBlock.paddingVertical) {
+    style.mathBlockPaddingVertical = newProps.markdownStyle.mathBlock.paddingVertical;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.selectedBackgroundColor !=
+      oldProps.markdownStyle.mathBlock.selectedBackgroundColor) {
+    RCTUIColor *sbg = RCTUIColorFromSharedColor(newProps.markdownStyle.mathBlock.selectedBackgroundColor);
+    style.mathBlockSelectedBackgroundColor = (sbg && CGColorGetAlpha(sbg.CGColor) > 0) ? sbg : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.selectedBorderColor != oldProps.markdownStyle.mathBlock.selectedBorderColor) {
+    RCTUIColor *sbc = RCTUIColorFromSharedColor(newProps.markdownStyle.mathBlock.selectedBorderColor);
+    style.mathBlockSelectedBorderColor = (sbc && CGColorGetAlpha(sbc.CGColor) > 0) ? sbc : nil;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.marginTop != oldProps.markdownStyle.mathBlock.marginTop) {
+    style.mathBlockMarginTop = newProps.markdownStyle.mathBlock.marginTop;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.marginBottom != oldProps.markdownStyle.mathBlock.marginBottom) {
+    style.mathBlockMarginBottom = newProps.markdownStyle.mathBlock.marginBottom;
+    changed = YES;
+  }
+  if (newProps.markdownStyle.mathBlock.alignment != oldProps.markdownStyle.mathBlock.alignment) {
+    NSString *align = [NSString stringWithUTF8String:newProps.markdownStyle.mathBlock.alignment.c_str()];
+    if ([align isEqualToString:@"left"]) {
+      style.mathBlockAlignment = NSTextAlignmentLeft;
+    } else if ([align isEqualToString:@"right"]) {
+      style.mathBlockAlignment = NSTextAlignmentRight;
+    } else {
+      style.mathBlockAlignment = NSTextAlignmentCenter;
+    }
+    changed = YES;
+  }
+
+  return changed;
+}

package/ios/input/internals/EnrichedMarkdownTextInputComponentDescriptor.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "EnrichedMarkdownTextInputShadowNode.h"
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class EnrichedMarkdownTextInputComponentDescriptor final
+    : public ConcreteComponentDescriptor<EnrichedMarkdownTextInputShadowNode> {
+public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(dynamic_cast<EnrichedMarkdownTextInputShadowNode *>(&shadowNode));
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

package/ios/input/internals/EnrichedMarkdownTextInputShadowNode.h

@@ -0,0 +1,40 @@
+#pragma once
+#include "EnrichedMarkdownTextInputState.h"
+#include <ReactNativeEnrichedMarkdown/EventEmitters.h>
+#include <ReactNativeEnrichedMarkdown/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char EnrichedMarkdownTextInputComponentName[];
+
+class EnrichedMarkdownTextInputShadowNode
+    : public ConcreteViewShadowNode<EnrichedMarkdownTextInputComponentName, EnrichedMarkdownTextInputProps,
+                                    EnrichedMarkdownTextInputEventEmitter, EnrichedMarkdownTextInputState> {
+public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  EnrichedMarkdownTextInputShadowNode(const ShadowNodeFragment &fragment, const ShadowNodeFamily::Shared &family,
+                                      ShadowNodeTraits traits);
+
+  EnrichedMarkdownTextInputShadowNode(const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment);
+
+  void dirtyLayoutIfNeeded();
+
+  Size measureContent(const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints) const override;
+
+  static ShadowNodeTraits BaseTraits()
+  {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+private:
+  int localHeightRecalculationCounter_{0};
+  id setupMockInputView_(CGFloat width) const;
+};
+
+} // namespace facebook::react

package/ios/input/internals/EnrichedMarkdownTextInputShadowNode.mm

@@ -0,0 +1,83 @@
+#import "EnrichedMarkdownTextInputShadowNode.h"
+#import "EnrichedMarkdownTextInput.h"
+#import <react/utils/ManagedObjectWrapper.h>
+#import <yoga/Yoga.h>
+
+namespace facebook::react {
+
+extern const char EnrichedMarkdownTextInputComponentName[] = "EnrichedMarkdownTextInput";
+
+EnrichedMarkdownTextInputShadowNode::EnrichedMarkdownTextInputShadowNode(const ShadowNodeFragment &fragment,
+                                                                         const ShadowNodeFamily::Shared &family,
+                                                                         ShadowNodeTraits traits)
+    : ConcreteViewShadowNode(fragment, family, traits)
+{
+}
+
+EnrichedMarkdownTextInputShadowNode::EnrichedMarkdownTextInputShadowNode(const ShadowNode &sourceShadowNode,
+                                                                         const ShadowNodeFragment &fragment)
+    : ConcreteViewShadowNode(sourceShadowNode, fragment)
+{
+  dirtyLayoutIfNeeded();
+}
+
+void EnrichedMarkdownTextInputShadowNode::dirtyLayoutIfNeeded()
+{
+  const auto state = this->getStateData();
+  const int receivedCounter = state.getHeightRecalculationCounter();
+
+  if (receivedCounter > localHeightRecalculationCounter_) {
+    localHeightRecalculationCounter_ = receivedCounter;
+    YGNodeMarkDirty(&yogaNode_);
+  }
+}
+
+id EnrichedMarkdownTextInputShadowNode::setupMockInputView_(CGFloat width) const
+{
+  EnrichedMarkdownTextInput *mockView =
+      [[EnrichedMarkdownTextInput alloc] initWithFrame:CGRectMake(20000, 20000, width, 1000)];
+
+  mockView.blockEmitting = YES;
+
+  const auto props = this->getProps();
+  [mockView updateProps:props oldProps:nullptr];
+
+  return mockView;
+}
+
+Size EnrichedMarkdownTextInputShadowNode::measureContent(const LayoutContext &layoutContext,
+                                                         const LayoutConstraints &layoutConstraints) const
+{
+  CGFloat maxWidth = layoutConstraints.maximumSize.width;
+
+  RCTInternalGenericWeakWrapper *weakWrapper =
+      (RCTInternalGenericWeakWrapper *)unwrapManagedObject(getStateData().getComponentViewRef());
+  EnrichedMarkdownTextInput *view = weakWrapper ? (EnrichedMarkdownTextInput *)weakWrapper.object : nil;
+
+  __block CGSize size;
+
+  void (^measureBlock)(void) = ^{
+    if (view) {
+      size = [view measureSize:maxWidth];
+    } else {
+      EnrichedMarkdownTextInput *mockView = setupMockInputView_(maxWidth);
+      size = [mockView measureSize:maxWidth];
+    }
+  };
+
+  if ([NSThread isMainThread]) {
+    measureBlock();
+  } else {
+    dispatch_sync(dispatch_get_main_queue(), measureBlock);
+  }
+
+  Float clampedWidth = std::max((Float)size.width, layoutConstraints.minimumSize.width);
+  clampedWidth = std::min(clampedWidth, layoutConstraints.maximumSize.width);
+  Float clampedHeight = std::max((Float)size.height, layoutConstraints.minimumSize.height);
+  if (std::isfinite(layoutConstraints.maximumSize.height)) {
+    clampedHeight = std::min(clampedHeight, layoutConstraints.maximumSize.height);
+  }
+  return {clampedWidth, clampedHeight};
+}
+
+} // namespace facebook::react

package/ios/input/internals/EnrichedMarkdownTextInputState.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <memory>
+
+namespace facebook::react {
+
+class EnrichedMarkdownTextInputState {
+public:
+  EnrichedMarkdownTextInputState() = default;
+  EnrichedMarkdownTextInputState(int counter, std::shared_ptr<void> ref) : counter_(counter), viewRef_(ref) {}
+
+  int getHeightRecalculationCounter() const {
+    return counter_;
+  }
+  std::shared_ptr<void> getComponentViewRef() const {
+    return viewRef_;
+  }
+
+private:
+  int counter_{0};
+  std::shared_ptr<void> viewRef_{nullptr};
+};
+
+} // namespace facebook::react

package/ios/input/styles/ENRMBoldStyleHandler.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#import "ENRMStyleHandler.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMBoldStyleHandler : NSObject <ENRMStyleHandler>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/styles/ENRMBoldStyleHandler.mm

@@ -0,0 +1,29 @@
+#import "ENRMBoldStyleHandler.h"
+
+@implementation ENRMBoldStyleHandler
+
+- (ENRMInputStyleType)styleType
+{
+  return ENRMInputStyleTypeStrong;
+}
+
+- (ENRMStyleMergingConfig *)mergingConfig
+{
+  return [ENRMStyleMergingConfig emptyConfig];
+}
+
+- (UIFontDescriptorSymbolicTraits)fontTraits
+{
+  return UIFontDescriptorTraitBold;
+}
+
+- (void)applyNonFontAttributesToTextStorage:(NSTextStorage *)storage
+                                      range:(NSRange)range
+                            formattingRange:(ENRMFormattingRange *)formattingRange
+                                      style:(ENRMInputFormatterStyle *)style
+{
+  RCTUIColor *color = style.boldColor ?: style.baseTextColor;
+  [storage addAttribute:NSForegroundColorAttributeName value:color range:range];
+}
+
+@end

package/ios/input/styles/ENRMItalicStyleHandler.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#import "ENRMStyleHandler.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMItalicStyleHandler : NSObject <ENRMStyleHandler>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/styles/ENRMItalicStyleHandler.mm

@@ -0,0 +1,29 @@
+#import "ENRMItalicStyleHandler.h"
+
+@implementation ENRMItalicStyleHandler
+
+- (ENRMInputStyleType)styleType
+{
+  return ENRMInputStyleTypeEmphasis;
+}
+
+- (ENRMStyleMergingConfig *)mergingConfig
+{
+  return [ENRMStyleMergingConfig emptyConfig];
+}
+
+- (UIFontDescriptorSymbolicTraits)fontTraits
+{
+  return UIFontDescriptorTraitItalic;
+}
+
+- (void)applyNonFontAttributesToTextStorage:(NSTextStorage *)storage
+                                      range:(NSRange)range
+                            formattingRange:(ENRMFormattingRange *)formattingRange
+                                      style:(ENRMInputFormatterStyle *)style
+{
+  RCTUIColor *color = style.italicColor ?: style.baseTextColor;
+  [storage addAttribute:NSForegroundColorAttributeName value:color range:range];
+}
+
+@end

package/ios/input/styles/ENRMLinkStyleHandler.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#import "ENRMStyleHandler.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMLinkStyleHandler : NSObject <ENRMStyleHandler>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/styles/ENRMLinkStyleHandler.mm

@@ -0,0 +1,52 @@
+#import "ENRMLinkStyleHandler.h"
+
+static ENRMInputLinkVariantStyle *ENRMResolveInputLinkVariant(ENRMInputFormatterStyle *style, NSString *url)
+{
+  NSRange urlRange = NSMakeRange(0, url.length);
+  for (ENRMInputLinkVariantStyle *variant in style.linkVariants) {
+    if ([variant.regex firstMatchInString:url options:0 range:urlRange] != nil) {
+      return variant;
+    }
+  }
+  return nil;
+}
+
+@implementation ENRMLinkStyleHandler
+
+- (ENRMInputStyleType)styleType
+{
+  return ENRMInputStyleTypeLink;
+}
+
+- (ENRMStyleMergingConfig *)mergingConfig
+{
+  return [ENRMStyleMergingConfig emptyConfig];
+}
+
+- (UIFontDescriptorSymbolicTraits)fontTraits
+{
+  return 0;
+}
+
+- (void)applyNonFontAttributesToTextStorage:(NSTextStorage *)storage
+                                      range:(NSRange)range
+                            formattingRange:(ENRMFormattingRange *)formattingRange
+                                      style:(ENRMInputFormatterStyle *)style
+{
+  ENRMInputLinkVariantStyle *variant = ENRMResolveInputLinkVariant(style, formattingRange.url);
+  RCTUIColor *linkColor = variant.color ?: style.linkColor;
+  BOOL linkUnderline = variant ? variant.underline : style.linkUnderline;
+  RCTUIColor *backgroundColor = variant ? variant.backgroundColor : style.linkBackgroundColor;
+
+  if (linkColor != nil) {
+    [storage addAttribute:NSForegroundColorAttributeName value:linkColor range:range];
+  }
+  if (linkUnderline) {
+    [storage addAttribute:NSUnderlineStyleAttributeName value:@(NSUnderlineStyleSingle) range:range];
+  }
+  if (backgroundColor != nil) {
+    [storage addAttribute:NSBackgroundColorAttributeName value:backgroundColor range:range];
+  }
+}
+
+@end

package/ios/input/styles/ENRMSpoilerStyleHandler.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#import "ENRMStyleHandler.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMSpoilerStyleHandler : NSObject <ENRMStyleHandler>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/styles/ENRMSpoilerStyleHandler.mm

@@ -0,0 +1,33 @@
+#import "ENRMSpoilerStyleHandler.h"
+
+@implementation ENRMSpoilerStyleHandler
+
+- (ENRMInputStyleType)styleType
+{
+  return ENRMInputStyleTypeSpoiler;
+}
+
+- (ENRMStyleMergingConfig *)mergingConfig
+{
+  return [ENRMStyleMergingConfig emptyConfig];
+}
+
+- (UIFontDescriptorSymbolicTraits)fontTraits
+{
+  return 0;
+}
+
+- (void)applyNonFontAttributesToTextStorage:(NSTextStorage *)storage
+                                      range:(NSRange)range
+                            formattingRange:(ENRMFormattingRange *)formattingRange
+                                      style:(ENRMInputFormatterStyle *)style
+{
+  if (style.spoilerColor) {
+    [storage addAttribute:NSForegroundColorAttributeName value:style.spoilerColor range:range];
+  }
+  if (style.spoilerBackgroundColor) {
+    [storage addAttribute:NSBackgroundColorAttributeName value:style.spoilerBackgroundColor range:range];
+  }
+}
+
+@end

package/ios/input/styles/ENRMStrikethroughStyleHandler.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#import "ENRMStyleHandler.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMStrikethroughStyleHandler : NSObject <ENRMStyleHandler>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/styles/ENRMStrikethroughStyleHandler.mm

@@ -0,0 +1,28 @@
+#import "ENRMStrikethroughStyleHandler.h"
+
+@implementation ENRMStrikethroughStyleHandler
+
+- (ENRMInputStyleType)styleType
+{
+  return ENRMInputStyleTypeStrikethrough;
+}
+
+- (ENRMStyleMergingConfig *)mergingConfig
+{
+  return [ENRMStyleMergingConfig emptyConfig];
+}
+
+- (UIFontDescriptorSymbolicTraits)fontTraits
+{
+  return 0;
+}
+
+- (void)applyNonFontAttributesToTextStorage:(NSTextStorage *)storage
+                                      range:(NSRange)range
+                            formattingRange:(ENRMFormattingRange *)formattingRange
+                                      style:(ENRMInputFormatterStyle *)style
+{
+  [storage addAttribute:NSStrikethroughStyleAttributeName value:@(NSUnderlineStyleSingle) range:range];
+}
+
+@end