Improve documentation in MutateID.swift by adding missing comments for methods and properties, enhancing clarity on mutation ID functionality and usage.

Author: dankinsoid

Sources/VDFlow/MutateID.swift

@@ -7,15 +7,15 @@ import Foundation
 public struct MutateID: Comparable, Hashable, Codable, Sendable {
 
 	/// The timestamp of the mutation, represented as uptime nanoseconds.
-	/// 
+	///
 	/// A `nil` value indicates that no mutation has occurred yet.
 	var mutationDate: UInt64?
 
 	/// Creates a new mutation ID with no timestamp.
 	public init() {}
 
 	/// Creates a mutation ID by decoding it from a decoder.
-	/// 
+	///
 	/// - Parameter decoder: The decoder to read data from.
 	/// - Throws: An error if decoding fails.
 	public init(from decoder: Decoder) throws {
@@ -24,22 +24,22 @@ public struct MutateID: Comparable, Hashable, Codable, Sendable {
 	}
 
 	/// Encodes the mutation ID to an encoder.
-	/// 
+	///
 	/// - Parameter encoder: The encoder to write data to.
 	/// - Throws: An error if encoding fails.
 	public func encode(to encoder: Encoder) throws {
 		try (mutationDate ?? 0).encode(to: encoder)
 	}
 
 	/// Updates the mutation ID with the current timestamp.
-	/// 
+	///
 	/// This method sets the `mutationDate` to the current system uptime in nanoseconds.
-	mutating func update() {
+	public mutating func update() {
 		mutationDate = DispatchTime.now().uptimeNanoseconds
 	}
 
 	/// Compares two mutation IDs chronologically.
-	/// 
+	///
 	/// - Parameters:
 	///   - lhs: The left-hand side mutation ID.
 	///   - rhs: The right-hand side mutation ID.
@@ -49,7 +49,7 @@ public struct MutateID: Comparable, Hashable, Codable, Sendable {
 	}
 
 	/// Converts this mutation ID to an optional, returning `nil` if no mutation has occurred.
-	/// 
+	///
 	/// - Returns: This mutation ID if it has a timestamp, otherwise `nil`.
 	var optional: MutateID? {
 		mutationDate.map { _ in self }

Sources/VDFlowMacros/StepsMacro.swift

@@ -268,9 +268,9 @@ public struct StepsMacro: MemberAttributeMacro, ExtensionMacro, MemberMacro, Acc
 							type = "Int"
 						} else if value.is(FloatLiteralExprSyntax.self) {
 							type = "Double"
-                        } else if let typeName = value.baseName, typeName.first?.isLowercase == false {
-                            type = typeName
-                        } else {
+						} else if let typeName = value.baseName, typeName.first?.isLowercase == false {
+							type = typeName
+						} else {
 							throw MacroError("Type of `\(name)` must be provided explicitly with `:`")
 						}
 					} else {
@@ -320,21 +320,21 @@ public struct StepsMacro: MemberAttributeMacro, ExtensionMacro, MemberMacro, Acc
 			    get { if let result = lastMutateStepID { return result.0 } else { return \(raw: defaultValue) } }
 			    set {
 			        guard let selection = Self._selections[newValue] else {
-			            \(raw: hasDeselected ? "_deselectedMutateID._update()" : "")
+			            \(raw: hasDeselected ? "_deselectedMutateID.update()" : "")
 			            return
 			        }
 				    selection(&self)
 			    }
 			}
 			"""
 		result.append(selected)
-        
-        let isSelected: DeclSyntax =
-            """
-            public func isSelected<T>(_ keyPath: WritableKeyPath<Self, StepID<T>>) -> Bool {
-                selected == self[keyPath: keyPath].id
-            }
-            """
+
+		let isSelected: DeclSyntax =
+			"""
+			public func isSelected<T>(_ keyPath: WritableKeyPath<Self, StepID<T>>) -> Bool {
+			    selected == self[keyPath: keyPath].id
+			}
+			"""
 		result.append(isSelected)
 
 		let typealiasDecl: DeclSyntax = "public typealias AllSteps = \(raw: stepsType)"
@@ -476,11 +476,11 @@ private extension String {
 }
 
 private extension ExprSyntax {
-    
-    var baseName: String? {
-        self.as(FunctionCallExprSyntax.self)?.calledExpression.as(DeclReferenceExprSyntax.self)?.baseName.trimmed.text ??
-        self.as(FunctionCallExprSyntax.self)?.calledExpression.as(GenericSpecializationExprSyntax.self)?.trimmed.description
-    }
+
+	var baseName: String? {
+		self.as(FunctionCallExprSyntax.self)?.calledExpression.as(DeclReferenceExprSyntax.self)?.baseName.trimmed.text ??
+			self.as(FunctionCallExprSyntax.self)?.calledExpression.as(GenericSpecializationExprSyntax.self)?.trimmed.description
+	}
 }
 
 private struct MacroError: LocalizedError, CustomStringConvertible {