react-native-enriched-html 0.0.0 → 1.1.0-nightly-20260617-3dfd09072

package/ios/inputAttributesManager/InputAttributesManager.h

@@ -0,0 +1,18 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@class EnrichedTextInputView;
+
+@interface InputAttributesManager : NSObject
+@property(nonatomic, weak) EnrichedTextInputView *input;
+- (instancetype)initWithInput:(EnrichedTextInputView *)input;
+- (void)addDirtyRange:(NSRange)range;
+- (NSArray *)getDirtyRanges;
+- (void)shiftDirtyRangesWithEditedRange:(NSRange)editedRange
+                         changeInLength:(NSInteger)delta;
+- (void)didRemoveTypingAttribute:(NSString *)key;
+- (void)clearRemovedTypingAttributes;
+- (void)manageTypingAttributesWithOnlySelection:(BOOL)onlySelectionChanged;
+- (void)handleDirtyRangesStyling;
+- (NSSet<NSString *> *)customAttributesKeys;
+@end

package/ios/inputAttributesManager/InputAttributesManager.mm

@@ -0,0 +1,222 @@
+#import "InputAttributesManager.h"
+#import "AlignmentUtils.h"
+#import "AttributeEntry.h"
+#import "EnrichedTextInputView.h"
+#import "ParagraphAttributesUtils.h"
+#import "RangeUtils.h"
+#import "StyleHeaders.h"
+#import "ZeroWidthSpaceUtils.h"
+
+@implementation InputAttributesManager {
+  NSMutableArray<NSValue *> *_dirtyRanges;
+  NSSet *_customAttributesKeys;
+  NSMutableSet *_removedTypingAttributes;
+}
+
+- (instancetype)initWithInput:(EnrichedTextInputView *)input {
+  self = [super init];
+  _input = input;
+  _dirtyRanges = [[NSMutableArray alloc] init];
+  _removedTypingAttributes = [[NSMutableSet alloc] init];
+
+  // setup customAttributes
+  NSMutableSet *_customAttrsSet = [[NSMutableSet alloc] init];
+  for (StyleBase *style in _input->stylesDict.allValues) {
+    [_customAttrsSet addObject:[style getKey]];
+  }
+  _customAttributesKeys = _customAttrsSet;
+
+  return self;
+}
+- (NSSet<NSString *> *)customAttributesKeys {
+  return _customAttributesKeys;
+}
+
+- (void)addDirtyRange:(NSRange)range {
+  [_dirtyRanges addObject:[NSValue valueWithRange:range]];
+  _dirtyRanges = [[RangeUtils connectAndDedupeRanges:_dirtyRanges] mutableCopy];
+}
+
+- (NSArray *)getDirtyRanges {
+  return _dirtyRanges;
+}
+
+- (void)shiftDirtyRangesWithEditedRange:(NSRange)editedRange
+                         changeInLength:(NSInteger)delta {
+  if (delta == 0) {
+    return;
+  }
+  NSArray *shiftedRanges = [RangeUtils shiftRanges:_dirtyRanges
+                                   withEditedRange:editedRange
+                                    changeInLength:delta];
+  _dirtyRanges =
+      [[RangeUtils connectAndDedupeRanges:shiftedRanges] mutableCopy];
+}
+
+- (void)didRemoveTypingAttribute:(NSString *)key {
+  [_removedTypingAttributes addObject:key];
+}
+
+- (void)clearRemovedTypingAttributes {
+  [_removedTypingAttributes removeAllObjects];
+}
+
+- (void)handleDirtyRangesStyling {
+  // Filter out 0 length ranges for styling.
+  NSPredicate *predicate = [NSPredicate
+      predicateWithBlock:^BOOL(NSValue *evaluatedObject, NSDictionary *_) {
+        return [evaluatedObject rangeValue].length > 0;
+      }];
+  [_dirtyRanges filterUsingPredicate:predicate];
+
+  for (NSValue *rangeObj in _dirtyRanges) {
+    NSRange dirtyRange = [rangeObj rangeValue];
+
+    // dirty range can sometimes be wrong because of apple doing some changes
+    // behind the scenes
+    if (dirtyRange.location + dirtyRange.length >
+        _input->textView.textStorage.string.length)
+      continue;
+
+    // firstly, get all styles' occurences in that dirty range
+    NSMutableDictionary *presentStyles = [[NSMutableDictionary alloc] init];
+    for (StyleBase *style in _input->stylesDict.allValues) {
+      // the dict has keys of StyleType NSNumber and values of an array of all
+      // occurences
+      presentStyles[@([[style class] getType])] = [style all:dirtyRange];
+    }
+
+    // now reset the attributes to default ones
+    [_input->textView.textStorage setAttributes:_input->defaultTypingAttributes
+                                          range:dirtyRange];
+
+    // Restore ZWS layout metadata that is stored in regular attributes and was
+    // overwritten by the default-attributes reset above.
+    [ZeroWidthSpaceUtils applyKernForZeroWidthSpacesInRange:dirtyRange
+                                                       host:_input];
+
+    // Sort style types so paragraph styles come first. Their broad visual
+    // attributes (e.g. foreground color, font) are laid down before inline
+    // styles override them on their specific sub-ranges.
+    NSArray *sortedStyleTypes = [presentStyles.allKeys
+        sortedArrayUsingComparator:^NSComparisonResult(NSNumber *a,
+                                                       NSNumber *b) {
+          BOOL aPara = [_input->stylesDict[a] isParagraph];
+          BOOL bPara = [_input->stylesDict[b] isParagraph];
+          if (aPara == bPara)
+            return NSOrderedSame;
+          return aPara ? NSOrderedAscending : NSOrderedDescending;
+        }];
+
+    // re-apply meta-attributes and apply visual styling following the saved
+    // occurences.
+    for (NSNumber *styleType in sortedStyleTypes) {
+      StyleBase *style = _input->stylesDict[styleType];
+      if (style == nullptr)
+        continue;
+
+      for (StylePair *stylePair in presentStyles[styleType]) {
+        NSRange occurenceRange = [stylePair.rangeValue rangeValue];
+        [style reapplyFromStylePair:stylePair];
+        [style applyStyling:occurenceRange];
+      }
+    }
+  }
+  // do the typing attributes management, with no selection
+  [self manageTypingAttributesWithOnlySelection:NO];
+
+  [_dirtyRanges removeAllObjects];
+}
+
+- (void)manageTypingAttributesWithOnlySelection:(BOOL)onlySelectionChanged {
+  EnrichedInputTextView *textView = _input->textView;
+  NSRange selectedRange = textView.selectedRange;
+
+  // Typing attributes get reset (except alignment) when only selection changed
+  // to an empty line (or empty line with newline).
+  if (onlySelectionChanged) {
+    NSRange paragraphRange =
+        [textView.textStorage.string paragraphRangeForRange:selectedRange];
+    // User changed selection to an empty line (or empty line with a newline).
+    if (paragraphRange.length == 0 ||
+        (paragraphRange.length == 1 &&
+         [[NSCharacterSet newlineCharacterSet]
+             characterIsMember:[textView.textStorage.string
+                                   characterAtIndex:paragraphRange
+                                                        .location]])) {
+      NSParagraphStyle *currentTypingStyle =
+          textView.typingAttributes[NSParagraphStyleAttributeName];
+      NSTextAlignment savedAlignment = currentTypingStyle
+                                           ? currentTypingStyle.alignment
+                                           : NSTextAlignmentNatural;
+
+      [ParagraphAttributesUtils resetTypingAttributes:_input
+                                  preservingAlignment:savedAlignment];
+      return;
+    }
+  }
+
+  // General typing attributes management.
+
+  // Firstly, we make sure only default + custom + paragraph typing attribtues
+  // are left.
+  NSMutableDictionary *newAttrs = [_input->defaultTypingAttributes mutableCopy];
+
+  for (NSString *key in _input->textView.typingAttributes.allKeys) {
+    if ([_customAttributesKeys containsObject:key]) {
+      if ([key isEqualToString:NSParagraphStyleAttributeName]) {
+        // NSParagraphStyle for paragraph styles -> only keep the textLists
+        // property
+        NSParagraphStyle *pStyle =
+            (NSParagraphStyle *)_input->textView
+                .typingAttributes[NSParagraphStyleAttributeName];
+        if (pStyle != nullptr && pStyle.textLists.count >= 1) {
+          NSMutableParagraphStyle *newPStyle =
+              [[NSMutableParagraphStyle alloc] init];
+          newPStyle.textLists = pStyle.textLists;
+          newAttrs[NSParagraphStyleAttributeName] = newPStyle;
+        }
+      } else {
+        // Inline styles -> keep the key/value as a whole
+        newAttrs[key] = _input->textView.typingAttributes[key];
+      }
+    }
+  }
+
+  // Then, we add typingAttributes from present inline styles.
+  // We check for the previous character to naturally extend typing attributes.
+  // getEntryIfPresent properly returns nullptr for styles that we don't want to
+  // extend this way. Attributes from _removedTypingAttributes aren't added
+  // because they were just removed.
+  for (StyleBase *style in _input->stylesDict.allValues) {
+    if ([style isParagraph])
+      continue;
+    if ([_removedTypingAttributes containsObject:[style getKey]])
+      continue;
+
+    AttributeEntry *entry = nullptr;
+
+    if (selectedRange.location > 0) {
+      entry =
+          [style getEntryIfPresent:NSMakeRange(selectedRange.location - 1, 1)];
+    }
+
+    if (entry == nullptr)
+      continue;
+
+    newAttrs[entry.key] = entry.value;
+  }
+
+  // Apply active styles to typing attributes only for styles that require it so
+  // the cursor correctly reflects the current formatting state (e.g. heading
+  // size).
+  for (StyleBase *style in _input->stylesDict.allValues) {
+    if ([style appliesStylingToTyping] && [style detect:selectedRange]) {
+      [style applyStylingToTypingAttrs:newAttrs];
+    }
+  }
+
+  textView.typingAttributes = newAttrs;
+}
+
+@end

package/ios/inputHtmlParser/InputHtmlParser.h

@@ -0,0 +1,10 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface InputHtmlParser : NSObject
+- (instancetype _Nonnull)initWithInput:(id _Nonnull)input;
+- (void)replaceWholeFromHtml:(NSString *_Nonnull)html;
+- (void)replaceFromHtml:(NSString *_Nonnull)html range:(NSRange)range;
+- (void)insertFromHtml:(NSString *_Nonnull)html location:(NSInteger)location;
+- (NSString *_Nullable)initiallyProcessHtml:(NSString *_Nonnull)html;
+@end

package/ios/inputHtmlParser/InputHtmlParser.mm

@@ -0,0 +1,225 @@
+#import "InputHtmlParser.h"
+#import "AlignmentEntry.h"
+#import "EnrichedTextInputView.h"
+#import "HtmlParser.h"
+#import "StringExtension.h"
+#import "StyleHeaders.h"
+#import "StyleUtils.h"
+#import "TextInsertionUtils.h"
+#import <React/RCTLog.h>
+
+@implementation InputHtmlParser {
+  EnrichedTextInputView __weak *_input;
+}
+
+- (instancetype)initWithInput:(id)input {
+  self = [super init];
+  _input = (EnrichedTextInputView *)input;
+  return self;
+}
+
+- (void)replaceWholeFromHtml:(NSString *_Nonnull)html {
+  // reset the text first and reset typing attributes
+  _input->textView.text = @"";
+  _input->textView.typingAttributes = _input->defaultTypingAttributes;
+
+  @try {
+    NSArray *processingResult = [HtmlParser getTextAndStylesFromHtml:html];
+    NSString *plainText = (NSString *)processingResult[0];
+    NSArray *stylesInfo = (NSArray *)processingResult[1];
+    NSArray *alignments = (NSArray *)processingResult[2];
+
+    // set new text
+    _input->textView.text = plainText;
+
+    // re-apply the styles
+    [self applyProcessedStyles:stylesInfo
+           offsetFromBeginning:0
+               plainTextLength:plainText.length];
+    [self applyProcessedAlignments:alignments offset:0];
+    [_input anyTextMayHaveBeenModified];
+  } @catch (NSException *exception) {
+    RCTLogWarn(@"[EnrichedTextInput]: Failed to parse HTML: (%@), falling back "
+               @"to raw input.",
+               exception.reason);
+
+    // set new text
+    _input->textView.text = html;
+  }
+}
+
+- (void)replaceFromHtml:(NSString *_Nonnull)html range:(NSRange)range {
+  @try {
+    NSArray *processingResult = [HtmlParser getTextAndStylesFromHtml:html];
+    NSString *plainText = (NSString *)processingResult[0];
+    NSArray *stylesInfo = (NSArray *)processingResult[1];
+    NSArray *alignments = (NSArray *)processingResult[2];
+
+    // we can use ready replace util
+    [TextInsertionUtils replaceText:plainText
+                                 at:range
+               additionalAttributes:nil
+                               host:_input
+                      withSelection:YES];
+
+    [self applyProcessedStyles:stylesInfo
+           offsetFromBeginning:range.location
+               plainTextLength:plainText.length];
+    [self applyProcessedAlignments:alignments offset:range.location];
+    [_input anyTextMayHaveBeenModified];
+  } @catch (NSException *exception) {
+    RCTLogWarn(@"[EnrichedTextInput]: Failed to parse HTML: (%@), falling back "
+               @"to raw input.",
+               exception.reason);
+    [TextInsertionUtils replaceText:html
+                                 at:range
+               additionalAttributes:nil
+                               host:_input
+                      withSelection:YES];
+  }
+}
+
+- (void)insertFromHtml:(NSString *_Nonnull)html location:(NSInteger)location {
+  @try {
+    NSArray *processingResult = [HtmlParser getTextAndStylesFromHtml:html];
+    NSString *plainText = (NSString *)processingResult[0];
+    NSArray *stylesInfo = (NSArray *)processingResult[1];
+    NSArray *alignments = (NSArray *)processingResult[2];
+
+    // same here, insertion utils got our back
+    [TextInsertionUtils insertText:plainText
+                                at:location
+              additionalAttributes:nil
+                              host:_input
+                     withSelection:YES];
+
+    [self applyProcessedStyles:stylesInfo
+           offsetFromBeginning:location
+               plainTextLength:plainText.length];
+    [self applyProcessedAlignments:alignments offset:location];
+    [_input anyTextMayHaveBeenModified];
+  } @catch (NSException *exception) {
+    RCTLogWarn(@"[EnrichedTextInput]: Failed to parse HTML: (%@), falling back "
+               @"to raw input.",
+               exception.reason);
+    [TextInsertionUtils insertText:html
+                                at:location
+              additionalAttributes:nil
+                              host:_input
+                     withSelection:YES];
+  }
+}
+
+- (void)applyProcessedStyles:(NSArray *)processedStyles
+         offsetFromBeginning:(NSInteger)offset
+             plainTextLength:(NSUInteger)plainTextLength {
+  // 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;
+
+  for (NSArray *arr in processedStyles) {
+    // unwrap all info from processed style
+    NSNumber *styleType = (NSNumber *)arr[0];
+    StylePair *stylePair = (StylePair *)arr[1];
+    StyleBase *baseStyle = _input->stylesDict[styleType];
+    NSRange parsedRange = [stylePair.rangeValue rangeValue];
+    NSUInteger textLengthBeforeStyleApplied =
+        _input->textView.textStorage.string.length;
+    // range must be taking zeroWidthSpaceOffset and offest 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(offset + zeroWidthSpaceOffset + parsedRange.location,
+                    parsedRange.length);
+
+    // of course any changes here need to take blocks and conflicts into
+    // consideration
+    if ([StyleUtils handleStyleBlocksAndConflicts:[[baseStyle class] getType]
+                                            range:styleRange
+                                          forHost:_input]) {
+      BOOL shouldAddTypingAttr =
+          styleRange.location + styleRange.length ==
+          plainTextLength + offset + zeroWidthSpaceOffset;
+
+      if ([styleType isEqualToNumber:@([LinkStyle getType])]) {
+        LinkData *linkData = (LinkData *)stylePair.styleValue;
+        [((LinkStyle *)baseStyle) addLink:linkData
+                                    range:styleRange
+                            withSelection:NO];
+      } else if ([styleType isEqualToNumber:@([MentionStyle getType])]) {
+        MentionParams *params = (MentionParams *)stylePair.styleValue;
+        [((MentionStyle *)baseStyle) addMentionAtRange:styleRange
+                                                params:params];
+      } else if ([styleType isEqualToNumber:@([ImageStyle getType])]) {
+        ImageData *imgData = (ImageData *)stylePair.styleValue;
+        [((ImageStyle *)baseStyle) addImageAtRange:styleRange
+                                         imageData:imgData
+                                     withSelection:NO
+                                    withDirtyRange:YES];
+      } else if ([styleType isEqualToNumber:@([CheckboxListStyle getType])]) {
+        NSDictionary *checkboxStates = (NSDictionary *)stylePair.styleValue;
+        CheckboxListStyle *cbLStyle = (CheckboxListStyle *)baseStyle;
+
+        // First apply the checkbox list style to the entire range with
+        // unchecked value
+        [cbLStyle addWithChecked:NO
+                           range:styleRange
+                      withTyping:shouldAddTypingAttr
+                  withDirtyRange:YES];
+
+        if (checkboxStates && checkboxStates.count > 0) {
+          // Then toggle checked checkboxes
+          for (NSNumber *key in checkboxStates) {
+            NSUInteger checkboxPosition =
+                offset + zeroWidthSpaceOffset + [key unsignedIntegerValue];
+            BOOL isChecked = [checkboxStates[key] boolValue];
+            if (isChecked) {
+              [cbLStyle toggleCheckedAt:checkboxPosition withDirtyRange:YES];
+            }
+          }
+        }
+      } else {
+        [baseStyle add:styleRange
+                withTyping:shouldAddTypingAttr
+            withDirtyRange:YES];
+      }
+    }
+
+    NSInteger delta = (NSInteger)_input->textView.textStorage.string.length -
+                      (NSInteger)textLengthBeforeStyleApplied;
+    // Image shifts are already handled by _precedingImageCount during tag
+    // finalization.
+    if (delta != 0 && ![styleType isEqualToNumber:@([ImageStyle getType])]) {
+      zeroWidthSpaceOffset += delta;
+    }
+  }
+}
+
+- (void)applyProcessedAlignments:(NSArray<AlignmentEntry *> *)alignments
+                          offset:(NSInteger)offset {
+  AlignmentStyle *alignmentStyle =
+      _input.stylesDict[@([AlignmentStyle getType])];
+
+  if (alignmentStyle == nil) {
+    return;
+  }
+
+  for (AlignmentEntry *entry in alignments) {
+    // Offset the range (e.g. if inserting into the middle of text)
+    NSRange finalRange =
+        NSMakeRange(offset + entry.range.location, entry.range.length);
+
+    [alignmentStyle addAlignment:entry.alignment
+                           range:finalRange
+                      withTyping:NO
+                  withDirtyRange:NO];
+  }
+}
+
+- (NSString *_Nullable)initiallyProcessHtml:(NSString *_Nonnull)html {
+  return [HtmlParser initiallyProcessHtml:html
+                        useHtmlNormalizer:_input->useHtmlNormalizer];
+}
+
+@end

package/ios/interfaces/AlignmentEntry.h

@@ -0,0 +1,9 @@
+#pragma once
+#import <UIkit/UIKit.h>
+
+@interface AlignmentEntry : NSObject
+
+@property(nonatomic, assign) NSRange range;
+@property(nonatomic, assign) NSTextAlignment alignment;
+
+@end

package/ios/interfaces/AlignmentEntry.mm

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

package/ios/interfaces/AttributeEntry.h

@@ -0,0 +1,9 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface AttributeEntry : NSObject
+
+@property NSString *key;
+@property id value;
+
+@end

package/ios/interfaces/AttributeEntry.mm

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

package/ios/interfaces/BaseStyleProtocol.h

@@ -0,0 +1,17 @@
+#pragma once
+#import "StylePair.h"
+#import "StyleTypeEnum.h"
+
+@protocol BaseStyleProtocol <NSObject>
++ (StyleType)getStyleType;
++ (BOOL)isParagraphStyle;
+- (instancetype _Nonnull)initWithHost:(id _Nonnull)host;
+- (void)applyStyle:(NSRange)range;
+- (void)addAttributes:(NSRange)range withTypingAttr:(BOOL)withTypingAttr;
+- (void)removeAttributes:(NSRange)range;
+- (void)addTypingAttributes;
+- (void)removeTypingAttributes;
+- (BOOL)detectStyle:(NSRange)range;
+- (BOOL)anyOccurence:(NSRange)range;
+- (NSArray<StylePair *> *_Nullable)findAllOccurences:(NSRange)range;
+@end

package/ios/interfaces/EnrichedTextStyleHeaders.h

@@ -0,0 +1,62 @@
+#pragma once
+#import "StyleHeaders.h"
+
+@interface EnrichedTextBoldStyle : BoldStyle
+@end
+
+@interface EnrichedTextItalicStyle : ItalicStyle
+@end
+
+@interface EnrichedTextUnderlineStyle : UnderlineStyle
+@end
+
+@interface EnrichedTextStrikethroughStyle : StrikethroughStyle
+@end
+
+@interface EnrichedTextInlineCodeStyle : InlineCodeStyle
+@end
+
+@interface EnrichedTextH1Style : H1Style
+@end
+
+@interface EnrichedTextH2Style : H2Style
+@end
+
+@interface EnrichedTextH3Style : H3Style
+@end
+
+@interface EnrichedTextH4Style : H4Style
+@end
+
+@interface EnrichedTextH5Style : H5Style
+@end
+
+@interface EnrichedTextH6Style : H6Style
+@end
+
+@interface EnrichedTextBlockQuoteStyle : BlockQuoteStyle
+@end
+
+@interface EnrichedTextCodeBlockStyle : CodeBlockStyle
+@end
+
+@interface EnrichedTextUnorderedListStyle : UnorderedListStyle
+@end
+
+@interface EnrichedTextOrderedListStyle : OrderedListStyle
+@end
+
+@interface EnrichedTextLinkStyle : LinkStyle
+@end
+
+@interface EnrichedTextMentionStyle : MentionStyle
+@end
+
+@interface EnrichedTextImageStyle : ImageStyle
+@end
+
+@interface EnrichedTextCheckboxListStyle : CheckboxListStyle
+@end
+
+@interface EnrichedTextAlignmentStyle : AlignmentStyle
+@end

package/ios/interfaces/EnrichedViewHost.h

@@ -0,0 +1,26 @@
+#pragma once
+#import "EnrichedConfig.h"
+#import "InputAttributesManager.h"
+#import "StyleTypeEnum.h"
+#import <UIKit/UIKit.h>
+
+@protocol EnrichedViewHost <NSObject>
+@required
+@property(nonatomic, readonly) UITextView *_Nonnull textView;
+@property(nonatomic, readonly) EnrichedConfig *_Nonnull config;
+@property(nonatomic, readonly)
+    NSDictionary<NSNumber *, id> *_Nonnull stylesDict;
+@property(nonatomic, readonly, nullable)
+    NSMutableDictionary<NSNumber *, NSArray<NSNumber *> *> *conflictingStyles;
+@property(nonatomic, readonly, nullable)
+    NSMutableDictionary<NSNumber *, NSArray<NSNumber *> *> *blockingStyles;
+@property(nonatomic, readonly, nullable)
+    NSMutableDictionary<NSAttributedStringKey, id> *defaultTypingAttributes;
+@property(nonatomic) BOOL blockEmitting;
+@optional
+@property(nonatomic, readonly, nullable)
+    InputAttributesManager *attributesManager;
+- (void)emitOnLinkDetectedEvent:(id _Nonnull)linkData range:(NSRange)range;
+- (void)emitOnMentionEvent:(NSString *_Nonnull)indicator
+                      text:(NSString *_Nullable)text;
+@end

package/ios/interfaces/ImageAttachment.h

@@ -0,0 +1,11 @@
+#import "ImageData.h"
+#import "MediaAttachment.h"
+
+@interface ImageAttachment : MediaAttachment
+
+@property(nonatomic, strong) ImageData *imageData;
+@property(nonatomic, strong) UIImage *storedAnimatedImage;
+
+- (instancetype)initWithImageData:(ImageData *)data;
+
+@end