@octane-xplat/lottie 0.9.0 → 0.11.0

package/platforms/macos/src/vendor/Lottie/Private/Model/Layers/ShapeLayerModel.swift

@@ -0,0 +1,50 @@
+//
+//  ShapeLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - ShapeLayerModel
+
+/// A layer that holds vector shape objects.
+final class ShapeLayerModel: LayerModel {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: ShapeLayerModel.CodingKeys.self)
+    items = try container.decode([ShapeItem].self, ofFamily: ShapeType.self, forKey: .items)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let itemDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.items)
+    items = try [ShapeItem].fromDictionaries(itemDictionaries)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// A list of shape items.
+  let items: [ShapeItem]
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(items, forKey: .items)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case items = "shapes"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `ShapeLayerModel` inherits `@unchecked Sendable` from `LayerModel` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension ShapeLayerModel: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Layers/SolidLayerModel.swift

@@ -0,0 +1,63 @@
+//
+//  SolidLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - SolidLayerModel
+
+/// A layer that holds a solid color.
+final class SolidLayerModel: LayerModel {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: SolidLayerModel.CodingKeys.self)
+    colorHex = try container.decode(String.self, forKey: .colorHex)
+    width = try container.decode(Double.self, forKey: .width)
+    height = try container.decode(Double.self, forKey: .height)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    colorHex = try dictionary.value(for: CodingKeys.colorHex)
+    width = try dictionary.value(for: CodingKeys.width)
+    height = try dictionary.value(for: CodingKeys.height)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The color of the solid in Hex // Change to value provider.
+  let colorHex: String
+
+  /// The Width of the color layer
+  let width: Double
+
+  /// The height of the color layer
+  let height: Double
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(colorHex, forKey: .colorHex)
+    try container.encode(width, forKey: .width)
+    try container.encode(height, forKey: .height)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case colorHex = "sc"
+    case width = "sw"
+    case height = "sh"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `SolidLayerModel` inherits `@unchecked Sendable` from `LayerModel` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension SolidLayerModel: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Layers/TextLayerModel.swift

@@ -0,0 +1,65 @@
+//
+//  TextLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - TextLayerModel
+
+/// A layer that holds text.
+final class TextLayerModel: LayerModel {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: TextLayerModel.CodingKeys.self)
+    let textContainer = try container.nestedContainer(keyedBy: TextCodingKeys.self, forKey: .textGroup)
+    text = try textContainer.decode(KeyframeGroup<TextDocument>.self, forKey: .text)
+    animators = try textContainer.decode([TextAnimator].self, forKey: .animators)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let containerDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textGroup)
+    let textDictionary: [String: Any] = try containerDictionary.value(for: TextCodingKeys.text)
+    text = try KeyframeGroup<TextDocument>(dictionary: textDictionary)
+    let animatorDictionaries: [[String: Any]] = try containerDictionary.value(for: TextCodingKeys.animators)
+    animators = try animatorDictionaries.map { try TextAnimator(dictionary: $0) }
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The text for the layer
+  let text: KeyframeGroup<TextDocument>
+
+  /// Text animators
+  let animators: [TextAnimator]
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    var textContainer = container.nestedContainer(keyedBy: TextCodingKeys.self, forKey: .textGroup)
+    try textContainer.encode(text, forKey: .text)
+    try textContainer.encode(animators, forKey: .animators)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case textGroup = "t"
+  }
+
+  private enum TextCodingKeys: String, CodingKey {
+    case text = "d"
+    case animators = "a"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `TextLayerModel` inherits `@unchecked Sendable` from `LayerModel` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension TextLayerModel: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Objects/DashPattern.swift

@@ -0,0 +1,42 @@
+//
+//  DashPattern.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/22/19.
+//
+
+// MARK: - DashElementType
+
+enum DashElementType: String, Codable {
+  case offset = "o"
+  case dash = "d"
+  case gap = "g"
+}
+
+// MARK: - DashElement
+
+final class DashElement: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  init(dictionary: [String: Any]) throws {
+    let typeRawValue: String = try dictionary.value(for: CodingKeys.type)
+    guard let type = DashElementType(rawValue: typeRawValue) else {
+      throw InitializableError.invalidInput()
+    }
+    self.type = type
+    let valueDictionary: [String: Any] = try dictionary.value(for: CodingKeys.value)
+    value = try KeyframeGroup<LottieVector1D>(dictionary: valueDictionary)
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case type = "n"
+    case value = "v"
+  }
+
+  let type: DashElementType
+  let value: KeyframeGroup<LottieVector1D>
+
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Objects/Marker.swift

@@ -0,0 +1,35 @@
+//
+//  Marker.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+/// A time marker
+final class Marker: Codable, Sendable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  init(dictionary: [String: Any]) throws {
+    name = try dictionary.value(for: CodingKeys.name)
+    frameTime = try dictionary.value(for: CodingKeys.frameTime)
+    durationFrameTime = try dictionary.value(for: CodingKeys.durationFrameTime)
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case name = "cm"
+    case frameTime = "tm"
+    case durationFrameTime = "dr"
+  }
+
+  /// The Marker Name
+  let name: String
+
+  /// The Frame time of the marker
+  let frameTime: AnimationFrameTime
+
+  /// The duration of the marker, in frames.
+  let durationFrameTime: AnimationFrameTime
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Objects/Mask.swift

@@ -0,0 +1,80 @@
+//
+//  Mask.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - MaskMode
+
+enum MaskMode: String, Codable {
+  case add = "a"
+  case subtract = "s"
+  case intersect = "i"
+  case lighten = "l"
+  case darken = "d"
+  case difference = "f"
+  case none = "n"
+}
+
+// MARK: - Mask
+
+final class Mask: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Mask.CodingKeys.self)
+    mode = try container.decodeIfPresent(MaskMode.self, forKey: .mode) ?? .add
+    opacity = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity) ?? KeyframeGroup(LottieVector1D(100))
+    shape = try container.decode(KeyframeGroup<BezierPath>.self, forKey: .shape)
+    inverted = try container.decodeIfPresent(Bool.self, forKey: .inverted) ?? false
+    expansion = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .expansion) ?? KeyframeGroup(LottieVector1D(0))
+  }
+
+  init(dictionary: [String: Any]) throws {
+    if
+      let modeRawType = dictionary[CodingKeys.mode.rawValue] as? String,
+      let mode = MaskMode(rawValue: modeRawType)
+    {
+      self.mode = mode
+    } else {
+      mode = .add
+    }
+    if let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any] {
+      opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
+    } else {
+      opacity = KeyframeGroup(LottieVector1D(100))
+    }
+    let shapeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.shape)
+    shape = try KeyframeGroup<BezierPath>(dictionary: shapeDictionary)
+    inverted = (try? dictionary.value(for: CodingKeys.inverted)) ?? false
+    if let expansionDictionary = dictionary[CodingKeys.expansion.rawValue] as? [String: Any] {
+      expansion = try KeyframeGroup<LottieVector1D>(dictionary: expansionDictionary)
+    } else {
+      expansion = KeyframeGroup(LottieVector1D(0))
+    }
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case mode
+    case opacity = "o"
+    case inverted = "inv"
+    case shape = "pt"
+    case expansion = "x"
+  }
+
+  let mode: MaskMode
+
+  let opacity: KeyframeGroup<LottieVector1D>
+
+  let shape: KeyframeGroup<BezierPath>
+
+  let inverted: Bool
+
+  let expansion: KeyframeGroup<LottieVector1D>
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Objects/Transform.swift

@@ -0,0 +1,261 @@
+//
+//  Transform.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/7/19.
+//
+
+/// The animatable transform for a layer. Controls position, rotation, scale, and opacity.
+final class Transform: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    /// This manual override of decode is required because we want to throw an error
+    /// in the case that there is not position data.
+    let container = try decoder.container(keyedBy: Transform.CodingKeys.self)
+
+    // AnchorPoint
+    anchorPoint = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchorPoint) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+
+    // Position
+    if container.contains(.positionX), container.contains(.positionY) {
+      // Position dimensions are split into two keyframe groups
+      positionX = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .positionX)
+      positionY = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .positionY)
+      position = nil
+    } else if let positionKeyframes = try? container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .position) {
+      // Position dimensions are a single keyframe group.
+      position = positionKeyframes
+      positionX = nil
+      positionY = nil
+    } else if
+      let positionContainer = try? container.nestedContainer(keyedBy: PositionCodingKeys.self, forKey: .position),
+      let positionX = try? positionContainer.decode(KeyframeGroup<LottieVector1D>.self, forKey: .positionX),
+      let positionY = try? positionContainer.decode(KeyframeGroup<LottieVector1D>.self, forKey: .positionY)
+    {
+      /// Position keyframes are split and nested.
+      self.positionX = positionX
+      self.positionY = positionY
+      position = nil
+    } else {
+      /// Default value.
+      position = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
+      positionX = nil
+      positionY = nil
+    }
+
+    // Scale
+    scale = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale) ??
+      KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
+
+    // Rotation
+    if let rotation = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationX) {
+      rotationX = rotation
+    } else {
+      rotationX = KeyframeGroup(LottieVector1D(0))
+    }
+
+    if let rotation = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationY) {
+      rotationY = rotation
+    } else {
+      rotationY = KeyframeGroup(LottieVector1D(0))
+    }
+
+    if let rotation = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ) {
+      rotationZ = rotation
+    } else {
+      rotationZ = try container
+        .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) ?? KeyframeGroup(LottieVector1D(0))
+    }
+    rotation = nil
+    // Opacity
+    opacity = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity) ?? KeyframeGroup(LottieVector1D(100))
+  }
+
+  init(dictionary: [String: Any]) throws {
+    if
+      let anchorPointDictionary = dictionary[CodingKeys.anchorPoint.rawValue] as? [String: Any],
+      let anchorPoint = try? KeyframeGroup<LottieVector3D>(dictionary: anchorPointDictionary)
+    {
+      self.anchorPoint = anchorPoint
+    } else {
+      anchorPoint = Transform.default.anchorPoint
+    }
+
+    if
+      let xDictionary = dictionary[CodingKeys.positionX.rawValue] as? [String: Any],
+      let yDictionary = dictionary[CodingKeys.positionY.rawValue] as? [String: Any]
+    {
+      positionX = try KeyframeGroup<LottieVector1D>(dictionary: xDictionary)
+      positionY = try KeyframeGroup<LottieVector1D>(dictionary: yDictionary)
+      position = nil
+    } else if
+      let positionDictionary = dictionary[CodingKeys.position.rawValue] as? [String: Any],
+      positionDictionary[KeyframeGroup<LottieVector3D>.KeyframeWrapperKey.keyframeData.rawValue] != nil
+    {
+      position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
+      positionX = nil
+      positionY = nil
+    } else if
+      let positionDictionary = dictionary[CodingKeys.position.rawValue] as? [String: Any],
+      let xDictionary = positionDictionary[PositionCodingKeys.positionX.rawValue] as? [String: Any],
+      let yDictionary = positionDictionary[PositionCodingKeys.positionY.rawValue] as? [String: Any]
+    {
+      positionX = try KeyframeGroup<LottieVector1D>(dictionary: xDictionary)
+      positionY = try KeyframeGroup<LottieVector1D>(dictionary: yDictionary)
+      position = nil
+    } else {
+      position = Transform.default.position
+      positionX = nil
+      positionY = nil
+    }
+
+    if
+      let scaleDictionary = dictionary[CodingKeys.scale.rawValue] as? [String: Any],
+      let scale = try? KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
+    {
+      self.scale = scale
+    } else {
+      scale = Transform.default.scale
+    }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotationX.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationX = rotation
+    } else {
+      rotationX = Transform.default.rotationX
+    }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotationY.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationY = rotation
+    } else {
+      rotationY = Transform.default.rotationY
+    }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationZ = rotation
+    } else if
+      let rotationDictionary = dictionary[CodingKeys.rotationZ.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationZ = rotation
+    } else {
+      rotationZ = Transform.default.rotationZ
+    }
+    rotation = nil
+    if
+      let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any],
+      let opacity = try? KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
+    {
+      self.opacity = opacity
+    } else {
+      opacity = Transform.default.opacity
+    }
+  }
+
+  init(
+    anchorPoint: KeyframeGroup<LottieVector3D>,
+    position: KeyframeGroup<LottieVector3D>?,
+    positionX: KeyframeGroup<LottieVector1D>?,
+    positionY: KeyframeGroup<LottieVector1D>?,
+    scale: KeyframeGroup<LottieVector3D>,
+    rotationX: KeyframeGroup<LottieVector1D>,
+    rotationY: KeyframeGroup<LottieVector1D>,
+    rotationZ: KeyframeGroup<LottieVector1D>,
+    opacity: KeyframeGroup<LottieVector1D>,
+    rotation: KeyframeGroup<LottieVector1D>?
+  ) {
+    self.anchorPoint = anchorPoint
+    self.position = position
+    self.positionX = positionX
+    self.positionY = positionY
+    self.scale = scale
+    self.rotationX = rotationX
+    self.rotationY = rotationY
+    self.rotationZ = rotationZ
+    self.opacity = opacity
+    self.rotation = rotation
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case anchorPoint = "a"
+    case position = "p"
+    case positionX = "px"
+    case positionY = "py"
+    case scale = "s"
+    case rotation = "r"
+    case rotationX = "rx"
+    case rotationY = "ry"
+    case rotationZ = "rz"
+    case opacity = "o"
+  }
+
+  enum PositionCodingKeys: String, CodingKey {
+    case split = "s"
+    case positionX = "x"
+    case positionY = "y"
+  }
+
+  /// Default transform values to use if no transform is provided
+  static var `default`: Transform {
+    Transform(
+      anchorPoint: KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0)),
+      position: KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0)),
+      positionX: nil,
+      positionY: nil,
+      scale: KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100)),
+      rotationX: KeyframeGroup(LottieVector1D(0)),
+      rotationY: KeyframeGroup(LottieVector1D(0)),
+      rotationZ: KeyframeGroup(LottieVector1D(0)),
+      opacity: KeyframeGroup(LottieVector1D(100)),
+      rotation: nil
+    )
+  }
+
+  /// The anchor point of the transform.
+  let anchorPoint: KeyframeGroup<LottieVector3D>
+
+  /// The position of the transform. This is nil if the position data was split.
+  let position: KeyframeGroup<LottieVector3D>?
+
+  /// The positionX of the transform. This is nil if the position property is set.
+  let positionX: KeyframeGroup<LottieVector1D>?
+
+  /// The positionY of the transform. This is nil if the position property is set.
+  let positionY: KeyframeGroup<LottieVector1D>?
+
+  /// The scale of the transform.
+  let scale: KeyframeGroup<LottieVector3D>
+
+  /// The rotation of the transform on X axis.
+  let rotationX: KeyframeGroup<LottieVector1D>
+
+  /// The rotation of the transform on Y axis.
+  let rotationY: KeyframeGroup<LottieVector1D>
+
+  /// The rotation of the transform on Z axis.
+  let rotationZ: KeyframeGroup<LottieVector1D>
+
+  /// The opacity of the transform.
+  let opacity: KeyframeGroup<LottieVector1D>
+
+  // MARK: Private
+
+  /// Here for the CodingKeys.rotation = "r". `r` and `rz` are the same.
+  private let rotation: KeyframeGroup<LottieVector1D>?
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/Ellipse.swift

@@ -0,0 +1,79 @@
+//
+//  EllipseItem.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - PathDirection
+
+enum PathDirection: Int, Codable {
+  case clockwise = 1
+  case userSetClockwise = 2
+  case counterClockwise = 3
+}
+
+// MARK: - Ellipse
+
+final class Ellipse: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Ellipse.CodingKeys.self)
+    direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction) ?? .clockwise
+    position = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .position)
+    size = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .size)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if
+      let directionRawType = dictionary[CodingKeys.direction.rawValue] as? Int,
+      let direction = PathDirection(rawValue: directionRawType)
+    {
+      self.direction = direction
+    } else {
+      direction = .clockwise
+    }
+    let positionDictionary: [String: Any] = try dictionary.value(for: CodingKeys.position)
+    position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
+    let sizeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.size)
+    size = try KeyframeGroup<LottieVector3D>(dictionary: sizeDictionary)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The direction of the ellipse.
+  let direction: PathDirection
+
+  /// The position of the ellipse
+  let position: KeyframeGroup<LottieVector3D>
+
+  /// The size of the ellipse
+  let size: KeyframeGroup<LottieVector3D>
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(direction, forKey: .direction)
+    try container.encode(position, forKey: .position)
+    try container.encode(size, forKey: .size)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case direction = "d"
+    case position = "p"
+    case size = "s"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `Ellipse` inherits `@unchecked Sendable` from `ShapeItem` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension Ellipse: @unchecked Sendable { }