Fixed overlaping style will gnerate duplicate and incorect span

Author: cp-divyesh-v

RichEditorDemo/RichEditorDemo/ContentView.swift

@@ -28,7 +28,7 @@ struct ContentView: View {
       {
         self.state = .init(richText: richText)
       } else {
-        self.state = .init(input: "Bold \n Italic \n Underline \n Strikethrough \n ")
+        self.state = .init(input: "Hello World!")
       }
     }
   }

Sources/RichEditorSwiftUI/UI/Editor/RichEditorState+Spans.swift

@@ -67,9 +67,9 @@ extension RichEditorState {
      - style: is of type RichTextSpanStyle
      */
   public func updateStyle(style: RichTextSpanStyle, shouldRegisterUndo: Bool = true) {
+    setInternalStyles(style: style)
     setStyle(style, shouldRegisterUndo: shouldRegisterUndo)
     /// Don't change order of function call as it is comparing active attributes with new one so updating it before applying attribute will break the behavior of undo and redo
-    setInternalStyles(style: style)
   }
 }
 
@@ -150,8 +150,9 @@ extension RichEditorState {
     if style.isHeaderStyle || style.isDefault  //|| style.isList
       || style.isAlignmentStyle
     {
+      let shouldAdd = style.isHeaderStyle ? style.headerType != .default : !style.isDefault
       handleAddOrRemoveStyleToLine(
-        in: selectedRange, style: style, byAdding: !style.isDefault)
+        in: selectedRange, style: style, byAdding: shouldAdd)
       if shouldRegisterUndo {
         registerUndoForSetStyle(newStyle: style)
       }
@@ -176,16 +177,17 @@ extension RichEditorState {
         addStyle = CGFloat(size) != CGFloat.standardRichTextFontSize
       }
     case .font(let fontName):
-      if let fontName {
-        addStyle = fontName == self.fontName
+      let defaultName = RichTextFont.PickerFont.standardSystemFontDisplayName
+      if let fontName, fontName != defaultName {
+        addStyle = fontName != defaultName
+      } else {
+        addStyle = false
       }
     case .color(let color):
       let defaultColor = RichTextColor.foreground.adjust(nil, for: colorScheme)
       if let color, color.toHex() != defaultColor.toHex() {
         if let internalColor = self.color(for: .foreground) {
-          addStyle = (Color(internalColor) != color)
-        } else {
-          addStyle = true
+          addStyle = (Color(internalColor) == color && Color(internalColor) != defaultColor)
         }
       } else {
         addStyle = false
@@ -194,9 +196,7 @@ extension RichEditorState {
       let defaultColor = RichTextColor.background.adjust(nil, for: colorScheme)
       if let color = bgColor, color.toHex() != defaultColor.toHex() {
         if let internalColor = self.color(for: .background) {
-          addStyle = (Color(internalColor) == color)
-        } else {
-          addStyle = true
+          addStyle = (Color(internalColor) == color && Color(internalColor) != defaultColor)
         }
       } else {
         addStyle = false
@@ -207,6 +207,7 @@ extension RichEditorState {
       }
     case .link(let link):
       addStyle = link != nil
+
     default:
       return addStyle
     }
@@ -587,8 +588,10 @@ extension RichEditorState {
 
     internalSpans.removeAll(where: { selectedParts.contains($0) })
   }
+}
 
-  //MARK: - Add Header style
+//MARK: - Process Spans for style
+extension RichEditorState {
   /**
      This will create span for selected text with provided style
      - Parameters:
@@ -604,151 +607,97 @@ extension RichEditorState {
 
     var processedSpans: [RichTextSpanInternal] = []
 
-    let completeOverlap = getCompleteOverlappingSpans(for: range)
-    var partialOverlap = getPartialOverlappingSpans(for: range)
-    var sameSpans = getSameSpans(for: range)
-
-    partialOverlap.removeAll(where: { completeOverlap.contains($0) })
-    sameSpans.removeAll(where: { completeOverlap.contains($0) })
-
-    let partialOverlapSpan = processPartialOverlappingSpans(
-      partialOverlap, range: range, style: style, addStyle: addStyle)
-    let completeOverlapSpan = processCompleteOverlappingSpans(
-      completeOverlap, range: range, style: style, addStyle: addStyle)
-    let sameSpan = processSameSpans(
-      sameSpans, range: range, style: style, addStyle: addStyle)
-
-    processedSpans.append(contentsOf: partialOverlapSpan)
-    processedSpans.append(contentsOf: completeOverlapSpan)
-    processedSpans.append(contentsOf: sameSpan)
-
-    processedSpans = mergeSameStyledSpans(processedSpans)
-
-    internalSpans.removeAll(where: {
-      $0.closedRange.overlaps(range.closedRange)
-    })
-    internalSpans.append(contentsOf: processedSpans)
-    internalSpans = mergeSameStyledSpans(internalSpans)
-    internalSpans.sort(by: { $0.from < $1.from })
-  }
-
-  private func processCompleteOverlappingSpans(
-    _ spans: [RichTextSpanInternal], range: NSRange,
-    style: RichTextSpanStyle, addStyle: Bool = true
-  ) -> [RichTextSpanInternal] {
-    var processedSpans: [RichTextSpanInternal] = []
-
-    for span in spans {
-      if span.closedRange.isInRange(range.closedRange) {
-        processedSpans.append(
-          span.copy(
-            attributes: span.attributes?.copy(
-              with: style, byAdding: addStyle)))
-      } else {
-        if span.from < range.lowerBound {
-          let leftPart = span.copy(to: range.lowerBound - 1)
-          processedSpans.append(leftPart)
-        }
-
-        if span.from <= (range.lowerBound)
-          && span.to >= (range.upperBound - 1)
-        {
-          let centerPart = span.copy(
-            from: range.lowerBound, to: range.upperBound - 1,
-            attributes: span.attributes?.copy(
-              with: style, byAdding: addStyle))
-          processedSpans.append(centerPart)
-        }
-
-        if span.to > (range.upperBound - 1) {
-          let rightPart = span.copy(from: range.upperBound)
-          processedSpans.append(rightPart)
+    // First split existing spans at selection boundaries
+    let splitPoints = Set([range.lowerBound, range.upperBound])
+    var currentSpans = internalSpans
+
+    // Split spans at boundaries
+    for splitPoint in splitPoints {
+      currentSpans = currentSpans.flatMap { span -> [RichTextSpanInternal] in
+        if span.from < splitPoint && span.to >= splitPoint {
+          return [
+            span.copy(to: splitPoint - 1),
+            span.copy(from: splitPoint),
+          ]
         }
+        return [span]
       }
     }
 
-    processedSpans = mergeSameStyledSpans(processedSpans)
-
-    return processedSpans
-  }
-
-  private func processPartialOverlappingSpans(
-    _ spans: [RichTextSpanInternal], range: NSRange,
-    style: RichTextSpanStyle, addStyle: Bool = true
-  ) -> [RichTextSpanInternal] {
-    var processedSpans: [RichTextSpanInternal] = []
-
-    for span in spans {
-      if span.from < range.location {
-        let leftPart = span.copy(to: range.lowerBound - 1)
-        let rightPart = span.copy(
-          from: range.lowerBound,
-          attributes: span.attributes?.copy(
-            with: style, byAdding: addStyle))
-        processedSpans.append(leftPart)
-        processedSpans.append(rightPart)
+    // Process spans in selection range
+    for span in currentSpans {
+      if span.closedRange.overlaps(range.closedRange) {
+        // Span is within selection - apply new style
+        if span.closedRange.isInRange(range.closedRange) {
+          let newAttributes = span.attributes?.copy(with: style, byAdding: addStyle)
+          processedSpans.append(span.copy(attributes: newAttributes))
+        }
+        // Span partially overlaps - split and apply style only to overlapping part
+        else {
+          if span.from < range.lowerBound {
+            processedSpans.append(span.copy(to: range.lowerBound - 1))
+          }
+
+          let overlapStart = max(span.from, range.lowerBound)
+          let overlapEnd = min(span.to, range.upperBound - 1)
+
+          if overlapStart <= overlapEnd {
+            let newAttributes = span.attributes?.copy(with: style, byAdding: addStyle)
+            processedSpans.append(
+              span.copy(
+                from: overlapStart,
+                to: overlapEnd,
+                attributes: newAttributes
+              )
+            )
+          }
+
+          if span.to >= range.upperBound {
+            processedSpans.append(span.copy(from: range.upperBound))
+          }
+        }
       } else {
-        let leftPart = span.copy(
-          to: min(span.to, range.upperBound),
-          attributes: span.attributes?.copy(
-            with: style, byAdding: addStyle))
-        let rightPart = span.copy(from: range.location)
-        processedSpans.append(leftPart)
-        processedSpans.append(rightPart)
+        // Span outside selection - keep unchanged
+        processedSpans.append(span)
       }
     }
 
+    // Merge adjacent spans with identical styles
     processedSpans = mergeSameStyledSpans(processedSpans)
-    return processedSpans
-  }
 
-  private func processSameSpans(
-    _ spans: [RichTextSpanInternal], range: NSRange,
-    style: RichTextSpanStyle, addStyle: Bool = true
-  ) -> [RichTextSpanInternal] {
-    var processedSpans: [RichTextSpanInternal] = []
-
-    processedSpans = spans.map({
-      $0.copy(
-        attributes: $0.attributes?.copy(with: style, byAdding: addStyle)
-      )
-    })
-
-    processedSpans = mergeSameStyledSpans(processedSpans)
-    return processedSpans
+    // Update internal spans
+    internalSpans = processedSpans.sorted(by: { $0.from < $1.from })
   }
 
-  // merge adjacent spans with same style
-  private func mergeSameStyledSpans(_ spans: [RichTextSpanInternal])
-    -> [RichTextSpanInternal]
-  {
+  ///Merge adjacent spans with same style
+  private func mergeSameStyledSpans(_ spans: [RichTextSpanInternal]) -> [RichTextSpanInternal] {
     guard !spans.isEmpty else { return [] }
+
     var mergedSpans: [RichTextSpanInternal] = []
-    var previousSpan: RichTextSpanInternal?
+    var currentSpan: RichTextSpanInternal? = spans[0]
 
-    for span in spans.sorted(by: { $0.from < $1.from }) {
-      if let current = previousSpan {
-        if span.attributes?.stylesSet()
-          == current.attributes?.stylesSet()
-        {
-          // Merge overlapping spans
-          previousSpan = current.copy(to: max(current.to, span.to))
-        } else {
-          // Add merged span and start a new span
-          mergedSpans.append(current)
-          previousSpan = span
-        }
+    for nextSpan in spans.dropFirst() {
+      guard let current = currentSpan else {
+        currentSpan = nextSpan
+        continue
+      }
+
+      // Only merge if styles exactly match and spans are adjacent
+      if current.attributes?.stylesSet() == nextSpan.attributes?.stylesSet()
+        && current.to + 1 == nextSpan.from
+      {
+        currentSpan = current.copy(to: nextSpan.to)
       } else {
-        previousSpan = span
+        mergedSpans.append(current)
+        currentSpan = nextSpan
       }
     }
 
-    // Append the last current span
-    if let lastSpan = previousSpan {
+    if let lastSpan = currentSpan {
       mergedSpans.append(lastSpan)
     }
 
-    return mergedSpans.sorted(by: { $0.from < $1.from })
+    return mergedSpans
   }
 }
 
@@ -783,61 +732,6 @@ extension RichEditorState {
   }
 }
 
-//MARK: - RichTextSpanInternal Helper
-extension RichEditorState {
-  /**
-     This will provide overlapping span for range
-     - Parameters:
-     - selectedRange:  is of type NSRange
-     */
-  private func getOverlappingSpans(for selectedRange: NSRange)
-    -> [RichTextSpanInternal]
-  {
-    return internalSpans.filter {
-      $0.closedRange.overlaps(selectedRange.closedRange)
-    }
-  }
-
-  /**
-     This will provide partial overlapping span for range
-     - Parameters:
-     - selectedRange: selectedRange is of type NSRange
-     */
-  func getPartialOverlappingSpans(for selectedRange: NSRange)
-    -> [RichTextSpanInternal]
-  {
-    return getOverlappingSpans(for: selectedRange).filter({
-      $0.closedRange.isPartialOverlap(selectedRange.closedRange)
-    })
-  }
-
-  /**
-     This will provide complete overlapping span for range
-     - Parameters:
-     - selectedRange: selectedRange is of type NSRange
-     */
-  func getCompleteOverlappingSpans(for selectedRange: NSRange)
-    -> [RichTextSpanInternal]
-  {
-    return getOverlappingSpans(for: selectedRange).filter({
-      $0.closedRange.isInRange(selectedRange.closedRange)
-        || selectedRange.closedRange.isInRange($0.closedRange)
-    })
-  }
-
-  /**
-     This will provide same span for range
-     - Parameters:
-     - selectedRange: selectedRange is of type NSRange
-     */
-
-  func getSameSpans(for selectedRange: NSRange) -> [RichTextSpanInternal] {
-    return getOverlappingSpans(for: selectedRange).filter({
-      $0.closedRange.isSameAs(selectedRange.closedRange)
-    })
-  }
-}
-
 //MARK: - Helper Methods
 extension RichEditorState {
   /**