react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/ios/generated/ReactCodegen/EnrichedMarkdownTextSpec/RCTComponentViewHelpers.h

@@ -27,8 +27,14 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)toggleUnderline;
 - (void)toggleStrikethrough;
 - (void)toggleSpoiler;
+- (void)toggleHeading:(NSInteger)level;
+- (void)toggleUnorderedList;
+- (void)toggleOrderedList;
+- (void)indentList;
+- (void)outdentList;
 - (void)setLink:(NSString *)url;
 - (void)insertLink:(NSString *)text url:(NSString *)url;
+- (void)insertText:(NSString *)text;
 - (void)insertMention:(NSString *)displayText url:(NSString *)url;
 - (void)startMention:(NSString *)indicator;
 - (void)removeLink;
@@ -36,6 +42,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)updateMath:(NSInteger)start latex:(NSString *)latex displayMode:(BOOL)displayMode;
 - (void)removeMath:(NSInteger)start;
 - (void)copyToClipboard;
+- (void)resolvePaste:(NSString *)text markdown:(NSString *)markdown;
 - (void)requestMarkdown:(NSInteger)requestId;
 - (void)requestCaretRect:(NSInteger)requestId;
 @end
@@ -191,6 +198,82 @@ if ([commandName isEqualToString:@"toggleSpoiler"]) {
   return;
 }
 
+if ([commandName isEqualToString:@"toggleHeading"]) {
+#if RCT_DEBUG
+  if ([args count] != 1) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownTextInput", commandName, (int)[args count], 1);
+    return;
+  }
+#endif
+
+  NSObject *arg0 = args[0];
+#if RCT_DEBUG
+  if (!RCTValidateTypeOfViewCommandArgument(arg0, [NSNumber class], @"number", @"EnrichedMarkdownTextInput", commandName, @"1st")) {
+    return;
+  }
+#endif
+  NSInteger level = [(NSNumber *)arg0 intValue];
+
+  [componentView toggleHeading:level];
+  return;
+}
+
+if ([commandName isEqualToString:@"toggleUnorderedList"]) {
+#if RCT_DEBUG
+  if ([args count] != 0) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownTextInput", commandName, (int)[args count], 0);
+    return;
+  }
+#endif
+
+  
+
+  [componentView toggleUnorderedList];
+  return;
+}
+
+if ([commandName isEqualToString:@"toggleOrderedList"]) {
+#if RCT_DEBUG
+  if ([args count] != 0) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownTextInput", commandName, (int)[args count], 0);
+    return;
+  }
+#endif
+
+  
+
+  [componentView toggleOrderedList];
+  return;
+}
+
+if ([commandName isEqualToString:@"indentList"]) {
+#if RCT_DEBUG
+  if ([args count] != 0) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownTextInput", commandName, (int)[args count], 0);
+    return;
+  }
+#endif
+
+  
+
+  [componentView indentList];
+  return;
+}
+
+if ([commandName isEqualToString:@"outdentList"]) {
+#if RCT_DEBUG
+  if ([args count] != 0) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownTextInput", commandName, (int)[args count], 0);
+    return;
+  }
+#endif
+
+  
+
+  [componentView outdentList];
+  return;
+}
+
 if ([commandName isEqualToString:@"setLink"]) {
 #if RCT_DEBUG
   if ([args count] != 1) {
@@ -239,6 +322,26 @@ NSObject *arg1 = args[1];
   return;
 }
 
+if ([commandName isEqualToString:@"insertText"]) {
+#if RCT_DEBUG
+  if ([args count] != 1) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownTextInput", commandName, (int)[args count], 1);
+    return;
+  }
+#endif
+
+  NSObject *arg0 = args[0];
+#if RCT_DEBUG
+  if (!RCTValidateTypeOfViewCommandArgument(arg0, [NSString class], @"string", @"EnrichedMarkdownTextInput", commandName, @"1st")) {
+    return;
+  }
+#endif
+  NSString * text = (NSString *)arg0;
+
+  [componentView insertText:text];
+  return;
+}
+
 if ([commandName isEqualToString:@"insertMention"]) {
 #if RCT_DEBUG
   if ([args count] != 2) {
@@ -399,6 +502,34 @@ if ([commandName isEqualToString:@"copyToClipboard"]) {
   return;
 }
 
+if ([commandName isEqualToString:@"resolvePaste"]) {
+#if RCT_DEBUG
+  if ([args count] != 2) {
+    RCTLogError(@"%@ command %@ received %d arguments, expected %d.", @"EnrichedMarkdownTextInput", commandName, (int)[args count], 2);
+    return;
+  }
+#endif
+
+  NSObject *arg0 = args[0];
+#if RCT_DEBUG
+  if (!RCTValidateTypeOfViewCommandArgument(arg0, [NSString class], @"string", @"EnrichedMarkdownTextInput", commandName, @"1st")) {
+    return;
+  }
+#endif
+  NSString * text = (NSString *)arg0;
+
+NSObject *arg1 = args[1];
+#if RCT_DEBUG
+  if (!RCTValidateTypeOfViewCommandArgument(arg1, [NSString class], @"string", @"EnrichedMarkdownTextInput", commandName, @"2nd")) {
+    return;
+  }
+#endif
+  NSString * markdown = (NSString *)arg1;
+
+  [componentView resolvePaste:text markdown:markdown];
+  return;
+}
+
 if ([commandName isEqualToString:@"requestMarkdown"]) {
 #if RCT_DEBUG
   if ([args count] != 1) {

package/ios/input/ENRMAutoLinkDetector.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #import "ENRMFormattingStore.h"
+#import "ENRMLinkCoordinator.h"
 #import "ENRMLinkRegexConfig.h"
 #import "ENRMTextDetector.h"
 #import <Foundation/Foundation.h>
@@ -11,7 +12,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 typedef void (^ENRMAutoLinkCallback)(NSString *text, NSString *url, NSRange range);
 
-@interface ENRMAutoLinkDetector : NSObject <ENRMTextDetector>
+@interface ENRMAutoLinkDetector : NSObject <ENRMTextDetector, ENRMAutoLinkDetecting>
 
 - (instancetype)initWithTextStorage:(NSTextStorage *)textStorage
                     formattingStore:(ENRMFormattingStore *)store

package/ios/input/ENRMAutoLinkDetector.mm

@@ -34,9 +34,19 @@ static NSAttributedStringKey const ENRMAutomaticLinkAttributeName = @"ENRMAutoma
 
 - (void)processWord:(ENRMWordResult *)wordResult
 {
-  NSString *detectedUrl = [self detectNewLinkAtRange:wordResult.range inText:wordResult.word];
+  NSRange matchedRange = NSMakeRange(NSNotFound, 0);
+  NSString *detectedUrl = [self detectNewLinkAtRange:wordResult.range
+                                              inText:wordResult.word
+                                        matchedRange:&matchedRange];
   if (detectedUrl != nil && _onLinkDetected != nil) {
-    _onLinkDetected(wordResult.word, detectedUrl, wordResult.range);
+    // Emit the actual linked slice, not the whole whitespace token — surrounding
+    // punctuation is not part of the link.
+    BOOL hasSlice = matchedRange.location != NSNotFound;
+    NSString *matchedText = hasSlice ? [wordResult.word substringWithRange:matchedRange] : wordResult.word;
+    NSRange absoluteRange = hasSlice
+                                ? NSMakeRange(wordResult.range.location + matchedRange.location, matchedRange.length)
+                                : wordResult.range;
+    _onLinkDetected(matchedText, detectedUrl, absoluteRange);
   }
 }
 
@@ -92,8 +102,14 @@ static NSAttributedStringKey const ENRMAutomaticLinkAttributeName = @"ENRMAutoma
 
 #pragma mark - Link matching
 
-- (nullable NSString *)detectNewLinkAtRange:(NSRange)wordRange inText:(NSString *)word
+- (nullable NSString *)detectNewLinkAtRange:(NSRange)wordRange
+                                     inText:(NSString *)word
+                               matchedRange:(NSRange *)outMatchedRange
 {
+  if (outMatchedRange != NULL) {
+    *outMatchedRange = NSMakeRange(NSNotFound, 0);
+  }
+
   if (_regexConfig != nil && _regexConfig.isDisabled) {
     return nil;
   }
@@ -107,61 +123,83 @@ static NSAttributedStringKey const ENRMAutomaticLinkAttributeName = @"ENRMAutoma
     return nil;
   }
 
+  // Tokens carrying markdown link syntax (e.g. "[label](url)") belong to the
+  // parser, not the auto-linker. Auto-linking them re-wraps the destination and
+  // yields a corrupted URL like "https://[label](url)" on serialize.
+  if ([word hasPrefix:@"["] || [word rangeOfString:@"]("].location != NSNotFound) {
+    [self clearAutoLinkInRange:wordRange];
+    return nil;
+  }
+
+  NSRange localMatch = NSMakeRange(NSNotFound, 0);
+  NSString *matchedUrl = [self tryMatchWord:word matchedRange:&localMatch];
+
+  if (matchedUrl == nil || localMatch.location == NSNotFound) {
+    [self clearAutoLinkInRange:wordRange];
+    return nil;
+  }
+
+  NSRange matchRange = NSMakeRange(wordRange.location + localMatch.location, localMatch.length);
+
+  // A manual link overlapping the matched slice takes precedence — test the
+  // whole slice, not just its first character.
   ENRMFormattingStore *store = _formattingStore;
-  if (store != nil) {
-    ENRMFormattingRange *manualLink = [store rangeOfType:ENRMInputStyleTypeLink containingPosition:wordRange.location];
-    if (manualLink != nil) {
-      return nil;
-    }
-  }
-
-  NSString *matchedUrl = [self tryMatchWord:word];
-
-  if (matchedUrl != nil) {
-    NSRange effectiveRange;
-    id existing = [textStorage attribute:ENRMAutomaticLinkAttributeName
-                                 atIndex:wordRange.location
-                          effectiveRange:&effectiveRange];
-    BOOL alreadyApplied = [matchedUrl isEqual:existing] && NSEqualRanges(effectiveRange, wordRange);
-
-    if (!alreadyApplied) {
-      [textStorage beginEditing];
-      [textStorage addAttribute:ENRMAutomaticLinkAttributeName value:matchedUrl range:wordRange];
-      [self applyVisualStylingToRange:wordRange];
-      [textStorage endEditing];
-    }
-  } else {
-    id existing = [textStorage attribute:ENRMAutomaticLinkAttributeName atIndex:wordRange.location effectiveRange:nil];
-    if (existing != nil) {
-      [textStorage beginEditing];
-      [textStorage removeAttribute:ENRMAutomaticLinkAttributeName range:wordRange];
-      [textStorage endEditing];
-    }
+  if (store != nil && [store isStyleActive:ENRMInputStyleTypeLink inRange:matchRange]) {
+    [self clearAutoLinkInRange:wordRange];
+    return nil;
   }
 
+  NSRange effectiveRange;
+  id existing = [textStorage attribute:ENRMAutomaticLinkAttributeName
+                               atIndex:matchRange.location
+                        effectiveRange:&effectiveRange];
+  BOOL alreadyApplied = [matchedUrl isEqual:existing] && NSEqualRanges(effectiveRange, matchRange);
+
+  if (!alreadyApplied) {
+    [textStorage beginEditing];
+    [textStorage removeAttribute:ENRMAutomaticLinkAttributeName range:wordRange];
+    [textStorage addAttribute:ENRMAutomaticLinkAttributeName value:matchedUrl range:matchRange];
+    [self applyVisualStylingToRange:matchRange];
+    [textStorage endEditing];
+  }
+
+  if (outMatchedRange != NULL) {
+    *outMatchedRange = localMatch;
+  }
   return matchedUrl;
 }
 
-- (nullable NSString *)tryMatchWord:(NSString *)word
+- (nullable NSString *)tryMatchWord:(NSString *)word matchedRange:(NSRange *)outRange
 {
+  if (outRange != NULL) {
+    *outRange = NSMakeRange(NSNotFound, 0);
+  }
+
   if (word.length == 0) {
     return nil;
   }
 
-  NSRange matchRange = NSMakeRange(0, word.length);
+  NSRange fullRange = NSMakeRange(0, word.length);
 
-  if (_regexConfig != nil && !_regexConfig.isDefault && _regexConfig.parsedRegex != nil) {
-    if ([_regexConfig.parsedRegex numberOfMatchesInString:word options:0 range:matchRange]) {
-      return [ENRMAutoLinkDetector normalizeUrl:word];
-    }
+  // A custom regex describes the whole-token contract, so keep whole-word
+  // semantics for it. The default detector extracts just the matched URL slice
+  // so surrounding punctuation isn't swallowed into the link.
+  BOOL customExact = _regexConfig != nil && !_regexConfig.isDefault && _regexConfig.parsedRegex != nil;
+  NSRegularExpression *regex = customExact ? _regexConfig.parsedRegex : [ENRMAutoLinkDetector defaultRegex];
+  if (regex == nil) {
     return nil;
   }
 
-  if ([[ENRMAutoLinkDetector defaultRegex] numberOfMatchesInString:word options:0 range:matchRange]) {
-    return [ENRMAutoLinkDetector normalizeUrl:word];
+  NSTextCheckingResult *match = [regex firstMatchInString:word options:0 range:fullRange];
+  if (match == nil || match.range.location == NSNotFound) {
+    return nil;
   }
 
-  return nil;
+  NSRange matchRange = customExact ? fullRange : match.range;
+  if (outRange != NULL) {
+    *outRange = matchRange;
+  }
+  return [ENRMAutoLinkDetector normalizeUrl:[word substringWithRange:matchRange]];
 }
 
 + (NSString *)normalizeUrl:(NSString *)url

package/ios/input/ENRMBlockEditCoordinator.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#import "ENRMInputBlockType.h"
+#import <Foundation/Foundation.h>
+
+@class ENRMBlockStore;
+@class ENRMBlockRange;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Result of a depth-change operation.
+typedef NS_ENUM(NSInteger, ENRMDepthChangeResult) {
+  ENRMDepthChangeResultChanged,
+  ENRMDepthChangeResultStartedList,
+  ENRMDepthChangeResultExitedList,
+  ENRMDepthChangeResultNoOp,
+};
+
+/// Encapsulates block-editing operations: toggling block types, adjusting list
+/// depth, and querying the block at a given position. The view delegates here
+/// and applies UI-level consequences (formatting, anchor sync, typing
+/// attributes) based on the returned result.
+///
+/// All mutating methods normalize stores to line bounds before returning, so the
+/// caller can re-stamp block spans immediately.
+@interface ENRMBlockEditCoordinator : NSObject
+
+- (instancetype)initWithBlockStore:(ENRMBlockStore *)blockStore;
+
+// ── Queries ──────────────────────────────────────────────────────────
+
+/// The block owning the paragraph at `position`, or nil.
+- (nullable ENRMBlockRange *)blockAtPosition:(NSUInteger)position inText:(NSString *)text;
+
+/// The list-item block at `position`, or nil if the paragraph is not a list item.
+- (nullable ENRMBlockRange *)listBlockAtPosition:(NSUInteger)position inText:(NSString *)text;
+
+/// Heading level (1-6) at `position`, or 0 for non-heading paragraphs.
+- (NSInteger)headingLevelAtPosition:(NSUInteger)position inText:(NSString *)text;
+
+/// Whether the paragraph at `position` is a list item of `type`, and its depth.
+- (BOOL)listStateOfType:(ENRMInputBlockType)type
+             atPosition:(NSUInteger)position
+                 inText:(NSString *)text
+                  depth:(nullable NSInteger *)outDepth;
+
+// ── Mutations ────────────────────────────────────────────────────────
+
+/// Toggles `type` at `level` on the paragraphs the selection touches.
+/// Returns YES when the block was already active (i.e. it was turned off).
+- (BOOL)toggleBlockType:(ENRMInputBlockType)type
+                  level:(NSInteger)level
+         selectionRange:(NSRange)selection
+                 inText:(NSString *)text;
+
+/// Toggles a list of `type` on the selection.
+/// Returns YES when the list was turned off.
+- (BOOL)toggleListType:(ENRMInputBlockType)type
+        cursorPosition:(NSUInteger)cursorPos
+        selectionRange:(NSRange)selection
+                inText:(NSString *)text;
+
+/// Adjusts list depth by `delta` on the selected lines.
+- (ENRMDepthChangeResult)changeDepthBy:(NSInteger)delta
+                        cursorPosition:(NSUInteger)cursorPos
+                        selectionRange:(NSRange)selection
+                                inText:(NSString *)text;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMBlockEditCoordinator.mm

@@ -0,0 +1,195 @@
+#import "ENRMBlockEditCoordinator.h"
+#import "ENRMBlockRange.h"
+#import "ENRMBlockStore.h"
+
+@implementation ENRMBlockEditCoordinator {
+  ENRMBlockStore *_blockStore;
+}
+
+- (instancetype)initWithBlockStore:(ENRMBlockStore *)blockStore
+{
+  self = [super init];
+  if (self) {
+    _blockStore = blockStore;
+  }
+  return self;
+}
+
+// ── Queries ──────────────────────────────────────────────────────────
+
+- (nullable ENRMBlockRange *)blockAtPosition:(NSUInteger)position inText:(NSString *)text
+{
+  if (position > text.length) {
+    return nil;
+  }
+  NSRange paragraph = [text paragraphRangeForRange:NSMakeRange(position, 0)];
+  return [_blockStore blockStartingAtLocation:paragraph.location];
+}
+
+- (nullable ENRMBlockRange *)listBlockAtPosition:(NSUInteger)position inText:(NSString *)text
+{
+  ENRMBlockRange *block = [self blockAtPosition:position inText:text];
+  return (block != nil && ENRMBlockTypeIsListItem(block.type)) ? block : nil;
+}
+
+- (NSInteger)headingLevelAtPosition:(NSUInteger)position inText:(NSString *)text
+{
+  ENRMBlockRange *block = [self blockAtPosition:position inText:text];
+  return block != nil ? ENRMHeadingLevelForBlockType(block.type) : 0;
+}
+
+- (BOOL)listStateOfType:(ENRMInputBlockType)type
+             atPosition:(NSUInteger)position
+                 inText:(NSString *)text
+                  depth:(nullable NSInteger *)outDepth
+{
+  ENRMBlockRange *block = [self listBlockAtPosition:position inText:text];
+  BOOL match = block != nil && block.type == type;
+  if (outDepth) {
+    *outDepth = match ? block.level : 0;
+  }
+  return match;
+}
+
+// ── Mutations ────────────────────────────────────────────────────────
+
+- (BOOL)toggleBlockType:(ENRMInputBlockType)type
+                  level:(NSInteger)level
+         selectionRange:(NSRange)selection
+                 inText:(NSString *)text
+{
+  NSRange paragraphRange = [text paragraphRangeForRange:selection];
+
+  ENRMBlockRange *current = [_blockStore blockStartingAtLocation:paragraphRange.location];
+  BOOL alreadyActive = current != nil && current.type == type;
+
+  if (alreadyActive) {
+    [_blockStore removeBlockInParagraphRange:paragraphRange inText:text];
+  } else if (paragraphRange.length == 0) {
+    NSInteger resolvedLevel = level;
+    if (ENRMBlockTypeIsListItem(type) && current != nil && ENRMBlockTypeIsListItem(current.type)) {
+      resolvedLevel = current.level;
+    }
+    [_blockStore setBlockType:type level:resolvedLevel forParagraphRange:paragraphRange inText:text];
+  } else {
+    [text
+        enumerateSubstringsInRange:paragraphRange
+                           options:NSStringEnumerationByParagraphs | NSStringEnumerationSubstringNotRequired
+                        usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange, BOOL *stop) {
+                          NSInteger paragraphLevel = level;
+                          if (ENRMBlockTypeIsListItem(type)) {
+                            ENRMBlockRange *existing = [self listBlockAtPosition:substringRange.location inText:text];
+                            if (existing != nil) {
+                              paragraphLevel = existing.level;
+                            }
+                          }
+                          [self->_blockStore setBlockType:type
+                                                    level:paragraphLevel
+                                        forParagraphRange:substringRange
+                                                   inText:text];
+                        }];
+  }
+
+  [_blockStore normalizeToLineBoundsInText:text];
+  return alreadyActive;
+}
+
+- (BOOL)toggleListType:(ENRMInputBlockType)type
+        cursorPosition:(NSUInteger)cursorPos
+        selectionRange:(NSRange)selection
+                inText:(NSString *)text
+{
+  ENRMBlockRange *cursorBlock = [self listBlockAtPosition:cursorPos inText:text];
+  BOOL turningOff = cursorBlock != nil && cursorBlock.type == type;
+  NSRange paragraphRange = [text paragraphRangeForRange:selection];
+
+  if (turningOff) {
+    if (paragraphRange.length == 0) {
+      [_blockStore removeBlockInParagraphRange:paragraphRange inText:text];
+    } else {
+      [text enumerateSubstringsInRange:paragraphRange
+                               options:NSStringEnumerationByParagraphs | NSStringEnumerationSubstringNotRequired
+                            usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange,
+                                         BOOL *stop) {
+                              [self->_blockStore removeBlockInParagraphRange:substringRange inText:text];
+                            }];
+    }
+  } else {
+    if (paragraphRange.length == 0) {
+      NSInteger existingLevel = 0;
+      ENRMBlockRange *existing = [self listBlockAtPosition:paragraphRange.location inText:text];
+      if (existing != nil) {
+        existingLevel = existing.level;
+      }
+      [_blockStore setBlockType:type level:existingLevel forParagraphRange:paragraphRange inText:text];
+    } else {
+      [text enumerateSubstringsInRange:paragraphRange
+                               options:NSStringEnumerationByParagraphs | NSStringEnumerationSubstringNotRequired
+                            usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange,
+                                         BOOL *stop) {
+                              NSInteger existingLevel = 0;
+                              ENRMBlockRange *existing = [self listBlockAtPosition:substringRange.location inText:text];
+                              if (existing != nil) {
+                                existingLevel = existing.level;
+                              }
+                              [self->_blockStore setBlockType:type
+                                                        level:existingLevel
+                                            forParagraphRange:substringRange
+                                                       inText:text];
+                            }];
+    }
+  }
+
+  [_blockStore normalizeToLineBoundsInText:text];
+  return turningOff;
+}
+
+- (ENRMDepthChangeResult)changeDepthBy:(NSInteger)delta
+                        cursorPosition:(NSUInteger)cursorPos
+                        selectionRange:(NSRange)selection
+                                inText:(NSString *)text
+{
+  ENRMBlockRange *cursorBlock = [self listBlockAtPosition:cursorPos inText:text];
+  if (cursorBlock == nil) {
+    if (delta > 0 && [self headingLevelAtPosition:cursorPos inText:text] == 0) {
+      [self toggleListType:ENRMInputBlockTypeUnorderedListItem
+            cursorPosition:cursorPos
+            selectionRange:selection
+                    inText:text];
+      return ENRMDepthChangeResultStartedList;
+    }
+    return ENRMDepthChangeResultNoOp;
+  }
+
+  if (delta < 0 && cursorBlock.level == 0) {
+    [self toggleListType:cursorBlock.type cursorPosition:cursorPos selectionRange:selection inText:text];
+    return ENRMDepthChangeResultExitedList;
+  }
+
+  NSRange paragraphRange = [text paragraphRangeForRange:selection];
+
+  if (paragraphRange.length == 0) {
+    NSInteger newDepth = MIN(MAX(cursorBlock.level + delta, (NSInteger)0), kENRMMaxListDepth);
+    [_blockStore setBlockType:cursorBlock.type level:newDepth forParagraphRange:paragraphRange inText:text];
+  } else {
+    [text
+        enumerateSubstringsInRange:paragraphRange
+                           options:NSStringEnumerationByParagraphs | NSStringEnumerationSubstringNotRequired
+                        usingBlock:^(NSString *substring, NSRange substringRange, NSRange enclosingRange, BOOL *stop) {
+                          ENRMBlockRange *block = [self listBlockAtPosition:substringRange.location inText:text];
+                          if (block == nil) {
+                            return;
+                          }
+                          NSInteger newDepth = MIN(MAX(block.level + delta, (NSInteger)0), kENRMMaxListDepth);
+                          [self->_blockStore setBlockType:block.type
+                                                    level:newDepth
+                                        forParagraphRange:substringRange
+                                                   inText:text];
+                        }];
+  }
+
+  [_blockStore normalizeToLineBoundsInText:text];
+  return ENRMDepthChangeResultChanged;
+}
+
+@end

package/ios/input/ENRMBlockRange.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#import "ENRMInputBlockType.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A block-level element occupying a paragraph/line range. Mirrors
+/// ENRMFormattingRange but for block scope: the range always covers whole lines.
+@interface ENRMBlockRange : NSObject <NSCopying>
+
+@property (nonatomic, assign) ENRMInputBlockType type;
+@property (nonatomic, assign) NSRange range;
+
+/// Generic integer payload for the block. 0 by default. Headings use it for the
+/// H-level (1-6); list items use it for nesting depth.
+@property (nonatomic, assign) NSInteger level;
+
+/// 1-based position of an ordered item among its adjacent same-depth siblings;
+/// recomputed by the block store's list-metadata pass.
+@property (nonatomic, assign) NSInteger ordinal;
+
++ (instancetype)rangeWithType:(ENRMInputBlockType)type range:(NSRange)range;
++ (instancetype)rangeWithType:(ENRMInputBlockType)type range:(NSRange)range level:(NSInteger)level;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/input/ENRMBlockRange.mm

@@ -0,0 +1,30 @@
+#import "ENRMBlockRange.h"
+
+@implementation ENRMBlockRange
+
++ (instancetype)rangeWithType:(ENRMInputBlockType)type range:(NSRange)range
+{
+  return [self rangeWithType:type range:range level:0];
+}
+
++ (instancetype)rangeWithType:(ENRMInputBlockType)type range:(NSRange)range level:(NSInteger)level
+{
+  ENRMBlockRange *blockRange = [[ENRMBlockRange alloc] init];
+  blockRange.type = type;
+  blockRange.range = range;
+  blockRange.level = level;
+  blockRange.ordinal = 1;
+  return blockRange;
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+  ENRMBlockRange *copy = [[ENRMBlockRange allocWithZone:zone] init];
+  copy.type = _type;
+  copy.range = _range;
+  copy.level = _level;
+  copy.ordinal = _ordinal;
+  return copy;
+}
+
+@end