Add 'Repeated' array encoding strategy

Package.swift

···
 import PackageDescription
 
 let package = Package(
-    name: "URLQueryItemCoder",
+    name: "swift-urlqueryitem-encoder",
     platforms: [
         .iOS(.v13),
         .macOS(.v10_15),

Sources/URLQueryItemCoder/Encoder/Generic Implementation/Strategies/ArrayEncodingStrategy.swift

···
+//
+//  ArrayEncodingStrategy.swift
+//  URLQueryItemCoder
+//
+
+/// The strategy to use for encoding `Array` values.
+public enum ArrayEncodingStrategy: Sendable {
+    /// An array encoding strategy that encodes arrays as indexed keys.
+    ///
+    /// Each element is encoded under a key suffixed with its zero-based index, separated by a dot.
+    /// For example, an array `["a", "b"]` at key `"tags"` produces `tags.0=a&tags.1=b`.
+    ///
+    /// The `ArrayEncodingStrategy.indexed` strategy is the strategy used if you don't specify one.
+    case indexed
+
+    /// An array encoding strategy that encodes arrays as repeated keys.
+    ///
+    /// Each element is encoded under the same key. For example, an array `["a", "b"]` at key `"tags"`
+    /// produces `tags=a&tags=b`.
+    ///
+    /// This is required by protocols such as XRPC (AT Protocol) which expect repeated query parameters
+    /// for array values.
+    case repeated
+
+    // MARK: Public Static Interface
+
+    /// The default array encoding strategy.
+    ///
+    /// Equals `.indexed`.
+    public static let `default`: ArrayEncodingStrategy = .indexed
+}

Sources/URLQueryItemCoder/Encoder/Generic Implementation/Strategies/EncodingStrategies.swift

···
 public struct EncodingStrategies {
     /// The collection initialized to all default values.
     public static let `default` = Self()
-    
+
+    /// The strategy to use for encoding `Array` values.
+    public var arrayStrategy: ArrayEncodingStrategy
+
     /// The strategy to use for encoding `Data` values.
     public var dataStrategy: DataEncodingStrategy
-    
+
     /// The strategy to use for encoding `Date` values.
     public var dateStrategy: DateEncodingStrategy
-    
+
     /// The strategy to use for automatically changing the value of keys before encoding.
     public var keyStrategy: KeyEncodingStrategy
-    
+
     /// The strategy to use for non-conforming floating-point values (IEEE 754 infinity and NaN).
     public var nonConformingFloatStrategy: NonConformingFloatEncodingStrategy
-    
+
     // MARK: Public Initialization
 
     /// Creates a new collection of encoding strategies for encoding `Encodable` values.
     ///
     /// The default encoding strategies are used if none are supplied.
     ///
+    /// - Parameter arrayStrategy: The strategy to use for encoding `Array` values.
     /// - Parameter dataStrategy: The strategy to use for encoding `Data` values.
     /// - Parameter dateStrategy: The strategy to use for encoding `Date` values.
     /// - Parameter keyStrategy: The strategy to use for encoding keys on keyed containers.
···
     ///   (IEEE 754 infinity and NaN).
     /// - Returns: Encoding strategies for encoding `Encodable` values.
     public init(
+        arrayStrategy: ArrayEncodingStrategy = .default,
         dataStrategy: DataEncodingStrategy = .default,
         dateStrategy: DateEncodingStrategy = .default,
         keyStrategy: KeyEncodingStrategy = .default,
         nonConformingFloatStrategy: NonConformingFloatEncodingStrategy = .default
     ) {
+        self.arrayStrategy = arrayStrategy
         self.dataStrategy = dataStrategy
         self.dateStrategy = dateStrategy
         self.keyStrategy = keyStrategy

Sources/URLQueryItemCoder/Encoder/URLQueryItemEncoder.swift

···
     /// - Returns: A new, reusable `URLQueryItem` encoder.
     @inlinable
     public init(
+        arrayStrategy: ArrayEncodingStrategy = .default,
         dataStrategy: DataEncodingStrategy = .default,
         dateStrategy: DateEncodingStrategy = .default,
         keyStrategy: KeyEncodingStrategy = .default,
···
     ) {
         self.init(
             strategies: EncodingStrategies(
+                arrayStrategy: arrayStrategy,
                 dataStrategy: dataStrategy,
                 dateStrategy: dateStrategy,
                 keyStrategy: keyStrategy,
···
     private func encode(
         _ container: EncodingContainer?,
         at key: String = String(),
-        into dictionaryRepresentation: inout [String: String?]
+        into queryItems: inout [URLQueryItem]
     ) {
         guard let container else {
             return
         }
-        
+
         let separator = key.isEmpty ? "" : "."
-        
+
         switch container {
         case let .keyed(keyedContainer):
             if keyedContainer.children.isEmpty {
                 if !key.isEmpty {
-                    dictionaryRepresentation[key] = String()
+                    queryItems.append(URLQueryItem(name: key, value: String()))
                 }
             } else {
                 for (subKey, childContainer) in keyedContainer.children {
                     let nextKey = "\(key)\(separator)\(subKey)"
-                    encode(childContainer, at: nextKey, into: &dictionaryRepresentation)
+                    encode(childContainer, at: nextKey, into: &queryItems)
                 }
             }
         case let .lowLevelEncoder(lowLevelEncoder):
             guard let childContainer = lowLevelEncoder.container else {
                 preconditionFailure("Nothing was never encoded to nested low level encoder.")
             }
-            encode(childContainer, at: key, into: &dictionaryRepresentation)
+            encode(childContainer, at: key, into: &queryItems)
         case let .singleValue(singleValueContainer):
             switch singleValueContainer.storage {
             case let .container(childContainer):
-                encode(childContainer, at: key, into: &dictionaryRepresentation)
+                encode(childContainer, at: key, into: &queryItems)
             case let .primitive(value):
-                if let value {
-                    dictionaryRepresentation[key] = String(describing: value)
-                } else if !key.isEmpty {
-                    dictionaryRepresentation.updateValue(nil, forKey: key)
+                if !key.isEmpty {
+                    queryItems.append(URLQueryItem(name: key, value: value.map { String(describing: $0) }))
                 }
             case .none:
                 preconditionFailure("Value was never encoded to single value container.")
             }
         case let .unkeyed(unkeyedContainer):
-            for index in unkeyedContainer.children.indices {
-                let childContainer = unkeyedContainer.children[index]
-                let nextKey = "\(key)\(separator)\(index)"
-                encode(childContainer, at: nextKey, into: &dictionaryRepresentation)
+            for (index, childContainer) in unkeyedContainer.children.enumerated() {
+                switch strategies.arrayStrategy {
+                case .indexed:
+                    let nextKey = "\(key)\(separator)\(index)"
+                    encode(childContainer, at: nextKey, into: &queryItems)
+                case .repeated:
+                    encode(childContainer, at: key, into: &queryItems)
+                }
             }
         }
     }
···
     public func encode(_ value: some Encodable) throws -> [URLQueryItem] {
         let container = try EncodingContainer.encodeWithSpecialTreatment(value, at: [], using: strategies)
         
-        var dictionaryRepresentation: [String: String?] = [:]
-        
-        encode(container, into: &dictionaryRepresentation)
-        
-        let queryItems = dictionaryRepresentation.map(URLQueryItem.init)
-        
+        var queryItems: [URLQueryItem] = []
+
+        encode(container, into: &queryItems)
+
         if outputFormatting.contains(.sortedKeys) {
             return queryItems.sorted { $0.name < $1.name }
         } else {