[Work in progress] new styles system

Author: Amy Worrall

Lexical/Core/Constants.swift

@@ -70,6 +70,7 @@ public enum DirtyType {
   case fullReconcile
 }
 
+@available(*, deprecated, message: "Use new styles system")
 @objc public enum TextFormatType: Int {
   case bold
   case italic

Lexical/Core/Editor.swift

@@ -94,6 +94,9 @@ public class Editor: NSObject {
 
   internal var nodeTransforms: [NodeType: [(Int, NodeTransform)]] = [:]
 
+  // Styles. For all methods to manipulate these, see Styles.swift
+  internal var registeredStyles: StylesRegistrationDict = [:]
+
   // Used to help co-ordinate selection and events
   internal var compositionKey: NodeKey?
   public var dirtyType: DirtyType = .noDirtyNodes // TODO: I made this public to work around an issue in playground. @amyworrall

Lexical/Core/Errors.swift

@@ -13,4 +13,5 @@ public enum LexicalError: Error {
   case sanityCheck(errorMessage: String, textViewText: String, fullReconcileText: String)
   case reconciler(String)
   case rangeCacheSearch(String)
+  case styleValidation(String)
 }

Lexical/Core/Events.swift

@@ -217,6 +217,10 @@ internal func handleIndentAndOutdent(insertTab: (Node) -> Void, indentOrOutdent:
 
 public func registerRichText(editor: Editor) {
 
+  // Style defaults and commands are handled in Styles.swift
+  registerDefaultStyles(editor: editor)
+  registerStyleCommands(editor: editor)
+
   _ = editor.registerCommand(type: .insertLineBreak, listener: { [weak editor] payload in
     guard let editor else { return false }
     do {

Lexical/Core/Nodes/HeadingNode.swift

@@ -36,21 +36,21 @@ public class HeadingNode: ElementNode {
     self.tag = tag
 
     super.init()
-    self.type = NodeType.heading
   }
 
   public required init(_ key: NodeKey?, tag: HeadingTagType) {
     self.tag = tag
     super.init(key)
-    self.type = NodeType.heading
+  }
+
+  override class public func getType() -> NodeType {
+    return .heading
   }
 
   public required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: CodingKeys.self)
     self.tag = try container.decode(HeadingTagType.self, forKey: .tag)
     try super.init(from: decoder)
-
-    self.type = NodeType.heading
   }
 
   override public func encode(to encoder: Encoder) throws {

Lexical/Core/Nodes/LineBreakNode.swift

@@ -6,34 +6,31 @@
  */
 
 public class LineBreakNode: Node {
-  override public init() {
-    super.init()
-    self.type = NodeType.linebreak
-  }
-
-  override required init(_ key: NodeKey?) {
-    super.init(key)
-    self.type = NodeType.linebreak
+  required public init(styles: StylesDict, key: NodeKey?) {
+    super.init(styles: styles, key: key)
   }
 
   public required init(from decoder: Decoder) throws {
     try super.init(from: decoder)
-    self.type = NodeType.linebreak
+  }
+
+  public override class func getType() -> NodeType {
+    .linebreak
   }
 
   override public func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)
   }
 
   override public func clone() -> Self {
-    Self(key)
+    Self(styles: styles, key: key)
   }
 
   override public func getPostamble() -> String {
     return "\n"
   }
 
   public func createLineBreakNode() -> LineBreakNode {
-    return LineBreakNode()
+    return LineBreakNode(styles: [:], key: nil)
   }
 }

Lexical/Core/Nodes/Node.swift

@@ -18,24 +18,22 @@ open class Node: Codable {
   enum CodingKeys: String, CodingKey {
     case type
     case version
+    case styles
   }
 
   public var key: NodeKey
   var parent: NodeKey?
-  public var type: NodeType
   public var version: Int
 
-  public init() {
-    self.type = Node.getType()
-    self.version = 1
-    self.key = LexicalConstants.uninitializedNodeKey
+  // Use style APIs to manipulate styles: see Styles.swift
+  var styles: StylesDict = [:]
 
-    _ = try? generateKey(node: self)
-  }
-
-  public init(_ key: NodeKey?) {
-    self.type = Node.getType()
+  // This change will be a code-breaking change for subclasses, which must now all implement this method. However,
+  // the effort required to update each class will be minimal. The rationale for this breaking change is to avoid
+  // bugs where styles disappear when nodes are copied, etc.
+  public required init(styles: StylesDict, key: NodeKey?) {
     self.version = 1
+    self.styles = styles
 
     if let key, key != LexicalConstants.uninitializedNodeKey {
       self.key = key
@@ -49,17 +47,45 @@ open class Node: Codable {
   public required init(from decoder: Decoder) throws {
     let values = try decoder.container(keyedBy: CodingKeys.self)
     key = LexicalConstants.uninitializedNodeKey
-    type = try NodeType(rawValue: values.decode(String.self, forKey: .type))
     version = try values.decode(Int.self, forKey: .version)
 
+    // styles
+    if let styleContainer = try? values.nestedContainer(keyedBy: StyleCodingKeys.self, forKey: .styles) {
+      guard let editor = getActiveEditor() else {
+        throw LexicalError.internal("Could not get active editor")
+      }
+      // try each style and see if there's a value
+      var newStyles: StylesDict = [:]
+      for (styleName, style) in editor.registeredStyles {
+        guard let styleKey = StyleCodingKeys(stringValue: styleName.rawValue) else { continue }
+        guard let superDecoder = try? styleContainer.superDecoder(forKey: styleKey) else { continue }
+        if let value = try? styleValueFromDecoder(style, decoder: superDecoder) {
+          newStyles[styleName] = value
+        }
+      }
+      self.styles = newStyles
+    }
+
     _ = try? generateKey(node: self)
   }
 
   /// Used when serialising node to JSON
   open func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
-    try container.encode(self.type.rawValue, forKey: .type)
     try container.encode(self.version, forKey: .version)
+
+    // styles
+    if styles.count > 0 {
+      var stylesContainer = container.nestedContainer(keyedBy: StyleCodingKeys.self, forKey: .styles)
+      guard let editor = getActiveEditor() else {
+        throw LexicalError.internal("Could not get active editor")
+      }
+      for (styleName, style) in editor.registeredStyles {
+        guard let styleValue = self.getStyle(style),
+              let styleKey = StyleCodingKeys(stringValue: styleName.rawValue) else { continue }
+        try stylesContainer.encode(styleValue, forKey: styleKey)
+      }
+    }
   }
 
   /**
@@ -68,13 +94,16 @@ open class Node: Codable {
    */
   open func didMoveTo(newEditor editor: Editor) {}
 
-  // This is an initial value for `type`.
-  // static methods cannot be overridden in swift so,
-  // each subclass needs to assign the type property in their init method
-  static func getType() -> NodeType {
+  open class func getType() -> NodeType {
     NodeType.unknown
   }
 
+  public var type: NodeType {
+    get {
+      Self.getType()
+    }
+  }
+
   /// Provides the **preamble** part of the node's content. Typically the preamble is used for control characters to represent embedded objects (see ``DecoratorNode``).
   ///
   /// In Lexical iOS, a node's content is split into four parts: preamble, children, text, postamble. ``ElementNode`` subclasses can implement preamble/postamble, and TextNode subclasses can implement the text part.
@@ -124,7 +153,17 @@ open class Node: Codable {
 
   /// Lets the node provide attributes for TextKit to use to render the node's content.
   open func getAttributedStringAttributes(theme: Theme) -> [NSAttributedString.Key: Any] {
-    [:]
+    let node = getLatest()
+    let attributesDict = theme.getValue(node.type, withSubtype: nil) ?? [:]
+    guard let editor = getActiveEditor() else {
+      return attributesDict
+    }
+    let styleAttributeDicts: [Theme.AttributeDict] = node.styles.map { (key: StyleName, value: Any) in
+      guard let styleType = editor.registeredStyles[key] else { return [:] }
+      return styleAttributesDictFor(node: node, style: styleType, theme: theme)
+    }
+    let dicts = [attributesDict] + styleAttributeDicts
+    return dicts.reduce([:]) { $0.merging($1) { (_, next) in next } }
   }
 
   /**

Lexical/Core/Nodes/TextNode.swift

@@ -83,6 +83,7 @@ public struct SerializedTextFormat: OptionSet, Codable {
   }
 }
 
+@available(*, deprecated, message: "use new styles system")
 public struct TextFormat: Equatable, Codable {
 
   public var bold: Bool
@@ -187,16 +188,12 @@ open class TextNode: Node {
   enum CodingKeys: String, CodingKey {
     case text
     case mode
-    case format
     case detail
-    case style
   }
 
   private var text: String = ""
   var mode: Mode = .normal
-  var format: TextFormat = TextFormat()
   var detail = TextNodeDetail()
-  var style: String = ""
 
   override public init() {
     super.init()
@@ -260,12 +257,12 @@ open class TextNode: Node {
 
   public func setBold(_ isBold: Bool) throws {
     try errorOnReadOnly()
-    try getWritable().format.bold = isBold
+    try getWritable().setStyle(Styles.Bold.self, isBold)
   }
 
   public func setItalic(_ isItalic: Bool) throws {
     try errorOnReadOnly()
-    try getWritable().format.italic = isItalic
+    try getWritable().setStyle(Styles.Italic.self, isItalic)
   }
 
   public func canInsertTextAfter() -> Bool {
@@ -394,28 +391,29 @@ open class TextNode: Node {
     return true
   }
 
+  @available(*, deprecated, message: "Use new styles system")
   public func getFormat() -> TextFormat {
     let node = getLatest() as TextNode
-    return node.format
+    return compatibilityFormatFromStyles(node.styles)
   }
 
+  @available(*, deprecated, message: "Use new styles system")
   @discardableResult
   public func setFormat(format: TextFormat) throws -> TextNode {
     try errorOnReadOnly()
     let node = try getWritable() as TextNode
-    node.format = format
+    let newStyles = compatibilityStylesFromFormat(format)
+    node.styles = compatibilityMergeStylesAssumingAllFormats(old: node.styles, newFormats: newStyles)
     return node
   }
 
+  @available(*, deprecated, message: "Use new styles system")
   public func getStyle() -> String {
-    let node = getLatest() as TextNode
-    return node.style
+    return ""
   }
 
-  public func setStyle(_ style: String) throws {
-    let writable = try getWritable()
-    writable.style = style
-  }
+  @available(*, deprecated, message: "Use new styles system")
+  public func setStyle(_ style: String) throws {}
 
   public func splitText(splitOffsets: [Int]) throws -> [TextNode] {
     try errorOnReadOnly()

Lexical/Core/Selection/BaseSelection.swift

@@ -62,4 +62,10 @@ public protocol BaseSelection: AnyObject, CustomDebugStringConvertible {
 
   /// Handles user-provided text to insert, applying a series of insertion heuristics based on the selection type and position.
   func insertText(_ text: String) throws
+
+  /// Applies a style to the text nodes in the selection, splitting if necessary
+  func applyTextStyle<T: Style>(_ style: T.Type, value: T.StyleValueType?) throws
+
+  /// Applies a style to the top level element nodes that are inside or overlap the selection
+  func applyBlockStyle<T: Style>(_ style: T.Type, value: T.StyleValueType?) throws
 }