react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/ios/input/ENRMInputBlockType.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Block-level (paragraph-scoped) element types. A block covers whole lines,
+/// unlike inline styles (ENRMInputStyleType) which cover character ranges.
+///
+/// Paragraph is the default: every line is a paragraph until a block handler
+/// claims it. Concrete block types (headings, list items, etc.) are appended
+/// here as their handlers are added — each new case must have a matching
+/// id<ENRMBlockHandler> registered in ENRMInputFormatter.
+typedef NS_ENUM(NSInteger, ENRMInputBlockType) {
+  ENRMInputBlockTypeParagraph = 0,
+  ENRMInputBlockTypeHeading1 = 1,
+  ENRMInputBlockTypeHeading2 = 2,
+  ENRMInputBlockTypeHeading3 = 3,
+  ENRMInputBlockTypeHeading4 = 4,
+  ENRMInputBlockTypeHeading5 = 5,
+  ENRMInputBlockTypeHeading6 = 6,
+  ENRMInputBlockTypeUnorderedListItem = 7,
+  ENRMInputBlockTypeOrderedListItem = 8,
+};
+
+/// Whether the type is a list item (nesting depth rides in the range's level).
+static inline BOOL ENRMBlockTypeIsListItem(ENRMInputBlockType type)
+{
+  return type == ENRMInputBlockTypeUnorderedListItem || type == ENRMInputBlockTypeOrderedListItem;
+}
+
+/// Maximum bullet-list nesting depth (0-based). Depth is carried as the block's
+/// level payload (ENRMBlockRange.level), clamped into [0, kENRMMaxListDepth].
+static const NSInteger kENRMMaxListDepth = 5;
+
+/// Bullet-list layout metrics (points). Shared by the list block handler (which
+/// reserves the head-indent column via the paragraph style) and the layout
+/// manager (which draws the marker glyph into that column). Text for a list item
+/// at depth d starts at (d + 1) * kENRMListIndentPerDepth from the leading edge;
+/// the marker is centered kENRMListBulletGap before the text.
+static const CGFloat kENRMListIndentPerDepth = 18.0;
+static const CGFloat kENRMListBulletGap = 9.0;
+
+/// Maps a heading level (1-6) to its ENRMInputBlockType. Levels outside 1-6 are
+/// clamped into range. The contiguous Heading1..Heading6 enum values make this a
+/// simple offset from the Heading1 base.
+static inline ENRMInputBlockType ENRMBlockTypeForHeadingLevel(NSInteger level)
+{
+  if (level < 1) {
+    level = 1;
+  } else if (level > 6) {
+    level = 6;
+  }
+  return (ENRMInputBlockType)(ENRMInputBlockTypeHeading1 + (level - 1));
+}
+
+/// The heading level (1-6) for a heading block type, or 0 if the type is not a
+/// heading. Inverse of ENRMBlockTypeForHeadingLevel.
+static inline NSInteger ENRMHeadingLevelForBlockType(ENRMInputBlockType type)
+{
+  if (type >= ENRMInputBlockTypeHeading1 && type <= ENRMInputBlockTypeHeading6) {
+    return (NSInteger)(type - ENRMInputBlockTypeHeading1) + 1;
+  }
+  return 0;
+}
+
+/// Whether an emptied line of this type keeps a zero-length anchor (an emptied
+/// heading stays a heading, an emptied bullet keeps its marker) instead of
+/// reverting to a plain paragraph.
+static inline BOOL ENRMBlockTypePersistsWhenEmpty(ENRMInputBlockType type)
+{
+  return (type >= ENRMInputBlockTypeHeading1 && type <= ENRMInputBlockTypeHeading6) || ENRMBlockTypeIsListItem(type);
+}
+
+/// NSAttributedString attribute carrying the ENRMInputBlockType (boxed NSNumber)
+/// of the paragraph a character belongs to. Set by ENRMInputFormatter on the
+/// paragraphs a block claims; the next block pass uses it to find and strip the
+/// previous pass's styling before re-applying.
+extern NSAttributedStringKey const ENRMBlockTypeAttributeName;
+
+/// NSAttributedString attribute carrying the block's integer payload (boxed
+/// NSNumber) — e.g. heading level or list depth. See ENRMBlockRange.level.
+/// Applied and stripped alongside ENRMBlockTypeAttributeName.
+extern NSAttributedStringKey const ENRMBlockLevelAttributeName;
+
+/// NSAttributedString attribute carrying an ordered item's 1-based ordinal
+/// (boxed NSNumber) so the layout manager can draw its number. Applied and
+/// stripped alongside ENRMBlockTypeAttributeName.
+extern NSAttributedStringKey const ENRMBlockOrdinalAttributeName;
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMInputBlockType.mm

@@ -0,0 +1,5 @@
+#import "ENRMInputBlockType.h"
+
+NSAttributedStringKey const ENRMBlockTypeAttributeName = @"ENRMBlockType";
+NSAttributedStringKey const ENRMBlockLevelAttributeName = @"ENRMBlockLevel";
+NSAttributedStringKey const ENRMBlockOrdinalAttributeName = @"ENRMBlockOrdinal";

package/ios/input/ENRMInputDecorationDrawer.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Draws decorations (markers, borders, backgrounds) for the input layout manager.
+@protocol ENRMInputDecorationDrawer <NSObject>
+
+- (void)drawDecorationsForGlyphRange:(NSRange)glyphRange
+                       layoutManager:(NSLayoutManager *)layoutManager
+                             atPoint:(CGPoint)origin;
+
+- (void)drawEmptyEditorDecorationsWithInset:(UIEdgeInsets)inset layoutManager:(NSLayoutManager *)layoutManager;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMInputEventEmitter.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#import "ENRMInputStyleStateBuilder.h"
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+#ifdef __cplusplus
+#import <ReactNativeEnrichedMarkdown/EventEmitters.h>
+#import <memory>
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol ENRMInputEventEmitterDataSource <ENRMInputStyleStateDataSource>
+
+#ifdef __cplusplus
+- (std::shared_ptr<facebook::react::EnrichedMarkdownTextInputEventEmitter const>)fabricEventEmitter;
+#endif
+
+- (NSString *)plainText;
+- (NSString *)currentMarkdown;
+- (CGRect)computeCaretRect;
+
+@end
+
+@interface ENRMInputEventEmitter : NSObject
+
+@property (nonatomic, assign) BOOL emitMarkdown;
+
+- (instancetype)initWithDataSource:(id<ENRMInputEventEmitterDataSource>)dataSource;
+
+- (void)emitOnChangeText;
+- (void)emitOnKeyPress:(NSString *)text;
+- (void)emitOnChangeMarkdown;
+- (void)emitOnChangeSelection;
+- (void)emitOnChangeState;
+- (void)emitFormattingChanged;
+- (void)emitCaretRectChangeIfNeeded;
+- (void)invalidateCachedState;
+- (void)emitContextMenuItemPress:(NSString *)itemText;
+- (void)emitOnFocus;
+- (void)emitOnBlur;
+- (void)emitOnLinkDetectedWithText:(NSString *)text url:(NSString *)url range:(NSRange)range;
+- (void)emitOnStartMention:(NSString *)indicator;
+- (void)emitOnChangeMentionWithIndicator:(NSString *)indicator text:(NSString *)text;
+- (void)emitOnEndMention:(NSString *)indicator;
+/// `rect` is the chip's glyph rect in the host view's coordinates, in points —
+/// JS positions its formula editor against it.
+- (void)emitOnMathPressWithLatex:(NSString *)latex range:(NSRange)range displayMode:(BOOL)displayMode rect:(CGRect)rect;
+- (void)emitOnPasteWithText:(NSString *)text markdown:(NSString *)markdown;
+- (void)requestMarkdown:(NSInteger)requestId;
+- (void)requestCaretRect:(NSInteger)requestId;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMInputEventEmitter.mm

@@ -0,0 +1,308 @@
+#import "ENRMInputEventEmitter.h"
+
+using namespace facebook::react;
+
+static EnrichedMarkdownTextInputEventEmitter::OnChangeState ENRMFabricChangeState(ENRMInputStyleSnapshot s)
+{
+  return {
+      .bold = {.isActive = s.bold},
+      .italic = {.isActive = s.italic},
+      .underline = {.isActive = s.underline},
+      .strikethrough = {.isActive = s.strikethrough},
+      .spoiler = {.isActive = s.spoiler},
+      .link = {.isActive = s.link},
+      .heading = {.isActive = s.headingLevel > 0, .level = static_cast<int>(s.headingLevel)},
+      .unorderedList = {.isActive = s.unorderedList, .depth = static_cast<int>(s.unorderedList ? s.listDepth : 0)},
+      .orderedList = {.isActive = s.orderedList, .depth = static_cast<int>(s.orderedList ? s.listDepth : 0)},
+  };
+}
+
+static EnrichedMarkdownTextInputEventEmitter::OnContextMenuItemPressStyleState
+ENRMFabricContextMenuStyleState(ENRMInputStyleSnapshot s)
+{
+  return {
+      .bold = {.isActive = s.bold},
+      .italic = {.isActive = s.italic},
+      .underline = {.isActive = s.underline},
+      .strikethrough = {.isActive = s.strikethrough},
+      .spoiler = {.isActive = s.spoiler},
+      .link = {.isActive = s.link},
+      .heading = {.isActive = s.headingLevel > 0, .level = static_cast<int>(s.headingLevel)},
+      .unorderedList = {.isActive = s.unorderedList, .depth = static_cast<int>(s.unorderedList ? s.listDepth : 0)},
+      .orderedList = {.isActive = s.orderedList, .depth = static_cast<int>(s.orderedList ? s.listDepth : 0)},
+  };
+}
+
+#define ENRM_GUARD_EMITTER(name)                                                                                       \
+  auto name = [self emitter];                                                                                          \
+  if (name == nullptr) {                                                                                               \
+    return;                                                                                                            \
+  }
+
+@implementation ENRMInputEventEmitter {
+  __weak id<ENRMInputEventEmitterDataSource> _dataSource;
+
+  struct {
+    BOOL bold, italic, underline, strikethrough, spoiler, link, initialized;
+    NSInteger headingLevel;
+    BOOL unorderedList;
+    NSInteger unorderedListDepth;
+    BOOL orderedList;
+    NSInteger orderedListDepth;
+  } _prevState;
+
+  std::optional<CGRect> _prevCaretRect;
+}
+
+- (instancetype)initWithDataSource:(id<ENRMInputEventEmitterDataSource>)dataSource
+{
+  self = [super init];
+  if (self) {
+    _dataSource = dataSource;
+  }
+  return self;
+}
+
+#pragma mark - Private
+
+- (std::shared_ptr<EnrichedMarkdownTextInputEventEmitter const>)emitter
+{
+  return [_dataSource fabricEventEmitter];
+}
+
+#pragma mark - Simple emitters
+
+- (void)emitOnChangeText
+{
+  ENRM_GUARD_EMITTER(emitter);
+  NSString *plainText = [_dataSource plainText];
+  emitter->onChangeText({.value = std::string([plainText UTF8String] ?: "")});
+}
+
+/// Maps the replacement text of a pending edit to RN TextInput's
+/// `onKeyPress` key names: empty text means deletion ("Backspace"), and
+/// leading \n, \t and ESC map to "Enter", "Tab" and "Escape".
+- (void)emitOnKeyPress:(NSString *)text
+{
+  ENRM_GUARD_EMITTER(emitter);
+  NSString *key;
+  if (text.length == 0) {
+    key = @"Backspace";
+  } else {
+    switch ([text characterAtIndex:0]) {
+      case '\n':
+        key = @"Enter";
+        break;
+      case '\t':
+        key = @"Tab";
+        break;
+      case 0x1B:
+        key = @"Escape";
+        break;
+      default:
+        key = text;
+        break;
+    }
+  }
+  emitter->onInputKeyPress({.key = std::string([key UTF8String] ?: "")});
+}
+
+- (void)emitOnChangeMarkdown
+{
+  ENRM_GUARD_EMITTER(emitter);
+  NSString *markdown = [_dataSource currentMarkdown];
+  emitter->onChangeMarkdown({.value = std::string([markdown UTF8String] ?: "")});
+}
+
+- (void)emitOnChangeSelection
+{
+  ENRM_GUARD_EMITTER(emitter);
+  NSRange selection = [_dataSource selectedRange];
+  emitter->onChangeSelection({
+      .start = static_cast<int>(selection.location),
+      .end = static_cast<int>(NSMaxRange(selection)),
+  });
+}
+
+- (void)emitOnFocus
+{
+  ENRM_GUARD_EMITTER(emitter);
+  emitter->onInputFocus({});
+}
+
+- (void)emitOnBlur
+{
+  ENRM_GUARD_EMITTER(emitter);
+  emitter->onInputBlur({});
+}
+
+- (void)emitOnLinkDetectedWithText:(NSString *)text url:(NSString *)url range:(NSRange)range
+{
+  ENRM_GUARD_EMITTER(emitter);
+  emitter->onLinkDetected({
+      .text = std::string([text UTF8String] ?: ""),
+      .url = std::string([url UTF8String] ?: ""),
+      .start = static_cast<int>(range.location),
+      .end = static_cast<int>(range.location + range.length),
+  });
+}
+
+- (void)emitOnMathPressWithLatex:(NSString *)latex range:(NSRange)range displayMode:(BOOL)displayMode rect:(CGRect)rect
+{
+  ENRM_GUARD_EMITTER(emitter);
+  emitter->onMathPress({
+      .latex = std::string([latex UTF8String] ?: ""),
+      .start = static_cast<int>(range.location),
+      .end = static_cast<int>(NSMaxRange(range)),
+      .displayMode = displayMode ? true : false,
+      .x = rect.origin.x,
+      .y = rect.origin.y,
+      .width = rect.size.width,
+      .height = rect.size.height,
+  });
+}
+
+- (void)emitOnPasteWithText:(NSString *)text markdown:(NSString *)markdown
+{
+  ENRM_GUARD_EMITTER(emitter);
+  emitter->onPaste({
+      .text = std::string([text UTF8String] ?: ""),
+      .markdown = std::string([markdown UTF8String] ?: ""),
+  });
+}
+
+- (void)emitOnStartMention:(NSString *)indicator
+{
+  ENRM_GUARD_EMITTER(emitter);
+  emitter->onStartMention({.indicator = std::string([indicator UTF8String] ?: "")});
+}
+
+- (void)emitOnChangeMentionWithIndicator:(NSString *)indicator text:(NSString *)text
+{
+  ENRM_GUARD_EMITTER(emitter);
+  emitter->onChangeMention({
+      .indicator = std::string([indicator UTF8String] ?: ""),
+      .text = std::string([text UTF8String] ?: ""),
+  });
+}
+
+- (void)emitOnEndMention:(NSString *)indicator
+{
+  ENRM_GUARD_EMITTER(emitter);
+  emitter->onEndMention({.indicator = std::string([indicator UTF8String] ?: "")});
+}
+
+#pragma mark - Stateful emitters
+
+- (void)emitOnChangeState
+{
+  ENRM_GUARD_EMITTER(emitter);
+
+  ENRMInputStyleSnapshot snapshot = [ENRMInputStyleStateBuilder snapshotAtCurrentCursor:_dataSource];
+
+  if (_prevState.initialized && _prevState.bold == snapshot.bold && _prevState.italic == snapshot.italic &&
+      _prevState.underline == snapshot.underline && _prevState.strikethrough == snapshot.strikethrough &&
+      _prevState.spoiler == snapshot.spoiler && _prevState.link == snapshot.link &&
+      _prevState.headingLevel == snapshot.headingLevel && _prevState.unorderedList == snapshot.unorderedList &&
+      _prevState.unorderedListDepth == snapshot.listDepth && _prevState.orderedList == snapshot.orderedList &&
+      _prevState.orderedListDepth == snapshot.listDepth) {
+    return;
+  }
+
+  _prevState.bold = snapshot.bold;
+  _prevState.italic = snapshot.italic;
+  _prevState.underline = snapshot.underline;
+  _prevState.strikethrough = snapshot.strikethrough;
+  _prevState.spoiler = snapshot.spoiler;
+  _prevState.link = snapshot.link;
+  _prevState.headingLevel = snapshot.headingLevel;
+  _prevState.unorderedList = snapshot.unorderedList;
+  _prevState.unorderedListDepth = snapshot.listDepth;
+  _prevState.orderedList = snapshot.orderedList;
+  _prevState.orderedListDepth = snapshot.listDepth;
+  _prevState.initialized = YES;
+
+  emitter->onChangeState(ENRMFabricChangeState(snapshot));
+}
+
+- (void)emitCaretRectChangeIfNeeded
+{
+  ENRM_GUARD_EMITTER(emitter);
+
+  CGRect caretRect = [_dataSource computeCaretRect];
+
+  if (_prevCaretRect.has_value() && CGRectEqualToRect(_prevCaretRect.value(), caretRect)) {
+    return;
+  }
+
+  _prevCaretRect = caretRect;
+
+  emitter->onCaretRectChange({
+      .x = caretRect.origin.x,
+      .y = caretRect.origin.y,
+      .width = caretRect.size.width,
+      .height = caretRect.size.height,
+  });
+}
+
+- (void)invalidateCachedState
+{
+  _prevState.initialized = NO;
+  _prevCaretRect.reset();
+}
+
+- (void)emitContextMenuItemPress:(NSString *)itemText
+{
+  ENRM_GUARD_EMITTER(eventEmitter);
+
+  NSRange selectedRange = [_dataSource selectedRange];
+  NSString *selectedText = selectedRange.length > 0 ? [[_dataSource plainText] substringWithRange:selectedRange] : @"";
+
+  ENRMInputStyleSnapshot snapshot = [ENRMInputStyleStateBuilder snapshotForRange:selectedRange dataSource:_dataSource];
+
+  eventEmitter->onContextMenuItemPress({
+      .itemText = std::string(itemText.UTF8String),
+      .selectedText = std::string(selectedText.UTF8String),
+      .selectionStart = static_cast<int>(selectedRange.location),
+      .selectionEnd = static_cast<int>(NSMaxRange(selectedRange)),
+      .styleState = ENRMFabricContextMenuStyleState(snapshot),
+  });
+}
+
+#pragma mark - Compound helpers
+
+- (void)emitFormattingChanged
+{
+  [self emitOnChangeState];
+  if (_emitMarkdown) {
+    [self emitOnChangeMarkdown];
+  }
+}
+
+#pragma mark - Request-response
+
+- (void)requestMarkdown:(NSInteger)requestId
+{
+  ENRM_GUARD_EMITTER(emitter);
+  NSString *markdown = [_dataSource currentMarkdown];
+  emitter->onRequestMarkdownResult({
+      .requestId = static_cast<int>(requestId),
+      .markdown = std::string([markdown UTF8String] ?: ""),
+  });
+}
+
+- (void)requestCaretRect:(NSInteger)requestId
+{
+  ENRM_GUARD_EMITTER(emitter);
+
+  CGRect caretRect = [_dataSource computeCaretRect];
+  emitter->onRequestCaretRectResult({
+      .requestId = static_cast<int>(requestId),
+      .x = caretRect.origin.x,
+      .y = caretRect.origin.y,
+      .width = caretRect.size.width,
+      .height = caretRect.size.height,
+  });
+}
+
+@end

package/ios/input/ENRMInputFormatter.h

@@ -1,88 +1,48 @@
 #pragma once
 
+#import "ENRMBlockRange.h"
 #import "ENRMFormattingRange.h"
-#import "ENRMUIKit.h"
+#import "ENRMInputFormatterStyle.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
 @protocol ENRMStyleHandler;
-
-@interface ENRMInputLinkVariantStyle : NSObject
-
-@property (nonatomic, copy) NSString *pattern;
-@property (nonatomic, strong) RCTUIColor *color;
-@property (nonatomic, assign) BOOL underline;
-@property (nonatomic, strong, nullable) RCTUIColor *backgroundColor;
-@property (nonatomic, strong, nullable) NSRegularExpression *regex;
-
-@end
-
-@interface ENRMInputFormatterStyle : NSObject <NSCopying>
-
-/// Base text properties
-@property (nonatomic, strong) UIFont *baseFont;
-@property (nonatomic, strong) RCTUIColor *baseTextColor;
-
-/// Bold — color override (nil = inherit baseTextColor)
-@property (nonatomic, strong, nullable) RCTUIColor *boldColor;
-
-/// Italic — color override (nil = inherit baseTextColor)
-@property (nonatomic, strong, nullable) RCTUIColor *italicColor;
-
-/// Link
-@property (nonatomic, strong, nullable) RCTUIColor *linkColor;
-@property (nonatomic, assign) BOOL linkUnderline;
-@property (nonatomic, strong, nullable) RCTUIColor *linkBackgroundColor;
-@property (nonatomic, copy) NSArray<ENRMInputLinkVariantStyle *> *linkVariants;
-
-/// Spoiler
-@property (nonatomic, strong, nullable) RCTUIColor *spoilerColor;
-@property (nonatomic, strong, nullable) RCTUIColor *spoilerBackgroundColor;
-
-/// Math (inline `$...$`)
-@property (nonatomic, strong, nullable) RCTUIColor *mathColor;
-@property (nonatomic, assign) CGFloat mathFontSize;
-@property (nonatomic, strong, nullable) RCTUIColor *mathBackgroundColor;
-@property (nonatomic, strong, nullable) RCTUIColor *mathBorderColor;
-@property (nonatomic, assign) CGFloat mathBorderWidth;
-@property (nonatomic, assign) CGFloat mathBorderRadius;
-@property (nonatomic, assign) CGFloat mathPaddingHorizontal;
-@property (nonatomic, assign) CGFloat mathPaddingVertical;
-@property (nonatomic, strong, nullable) RCTUIColor *mathSelectedBackgroundColor;
-@property (nonatomic, strong, nullable) RCTUIColor *mathSelectedBorderColor;
-/// Raw `fontWeight` string; narrowed at the draw site (see ENRMMathFontWeight.h).
-@property (nonatomic, copy, nullable) NSString *mathFontWeight;
-
-/// Math block (`$$...$$`)
-@property (nonatomic, strong, nullable) RCTUIColor *mathBlockColor;
-@property (nonatomic, assign) CGFloat mathBlockFontSize;
-@property (nonatomic, strong, nullable) RCTUIColor *mathBlockBackgroundColor;
-@property (nonatomic, strong, nullable) RCTUIColor *mathBlockBorderColor;
-@property (nonatomic, assign) CGFloat mathBlockBorderWidth;
-@property (nonatomic, assign) CGFloat mathBlockBorderRadius;
-@property (nonatomic, assign) CGFloat mathBlockPaddingHorizontal;
-@property (nonatomic, assign) CGFloat mathBlockPaddingVertical;
-@property (nonatomic, strong, nullable) RCTUIColor *mathBlockSelectedBackgroundColor;
-@property (nonatomic, strong, nullable) RCTUIColor *mathBlockSelectedBorderColor;
-@property (nonatomic, assign) CGFloat mathBlockMarginTop;
-@property (nonatomic, assign) CGFloat mathBlockMarginBottom;
-@property (nonatomic, assign) NSTextAlignment mathBlockAlignment;
-/// Raw `fontWeight` string; narrowed at the draw site (see ENRMMathFontWeight.h).
-@property (nonatomic, copy, nullable) NSString *mathBlockFontWeight;
-
-- (UIFont *)fontForTraits:(UIFontDescriptorSymbolicTraits)traits;
-- (void)invalidateFontCache;
-
-@end
+@protocol ENRMBlockHandler;
 
 @interface ENRMInputFormatter : NSObject
 
 - (nullable id<ENRMStyleHandler>)handlerForStyleType:(ENRMInputStyleType)type;
+- (nullable id<ENRMBlockHandler>)handlerForBlockType:(ENRMInputBlockType)type;
 
 - (void)applyFormattingRanges:(NSArray<ENRMFormattingRange *> *)ranges
                    toTextView:(ENRMPlatformTextView *)textView
                         style:(ENRMInputFormatterStyle *)style;
 
+/// Same as above, but resets and re-applies attributes only within `scope`
+/// (ranges straddling the boundary are clipped — attributes outside the scope
+/// are already consistent because they move with the text on edits). Pass the
+/// full text range for a wholesale re-apply (import / style change).
+- (void)applyFormattingRanges:(NSArray<ENRMFormattingRange *> *)ranges
+                   toTextView:(ENRMPlatformTextView *)textView
+                        style:(ENRMInputFormatterStyle *)style
+                scopedToRange:(NSRange)scope;
+
+/// Applies paragraph-level attributes for each block range via its handler,
+/// after first stripping the attributes applied on the previous pass (so
+/// removed blocks don't leave stale paragraph styling behind). With no
+/// handlers registered (PR1) this is a no-op.
+- (void)applyBlockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
+              toTextView:(ENRMPlatformTextView *)textView
+                   style:(ENRMInputFormatterStyle *)style;
+
+/// Same as above, scoped: strips markers only within `scope` and re-applies
+/// only the block ranges intersecting it. `scope` must cover whole lines
+/// (blocks are line-scoped) — pass a line-expanded edit window.
+- (void)applyBlockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
+              toTextView:(ENRMPlatformTextView *)textView
+                   style:(ENRMInputFormatterStyle *)style
+           scopedToRange:(NSRange)scope;
+
 @end
 
 NS_ASSUME_NONNULL_END