@procivis/react-native-one-core 1.41710.0 → 1.43299.1

package/ios/RNEncoder/RNKeyedEncodingContainer.swift

@@ -0,0 +1,81 @@
+import Foundation
+
+final class RNKeyedEncodingContainer<Key> where Key: CodingKey {
+  private var storage: [RNAnyCodingKey: RNEncodingContainer] = [:]
+
+  var codingPath: [CodingKey]
+  var userInfo: [CodingUserInfoKey: Any]
+
+  func nestedCodingPath(forKey key: CodingKey) -> [CodingKey] {
+    return self.codingPath + [key]
+  }
+
+  init(codingPath: [CodingKey], userInfo: [CodingUserInfoKey: Any]) {
+    self.codingPath = codingPath
+    self.userInfo = userInfo
+  }
+}
+
+extension RNKeyedEncodingContainer: KeyedEncodingContainerProtocol {
+  func encodeNil(forKey key: Key) throws {
+    var container = self.nestedSingleValueContainer(forKey: key)
+    try container.encodeNil()
+  }
+
+  func encode<T>(_ value: T, forKey key: Key) throws where T: Encodable {
+    var container = self.nestedSingleValueContainer(forKey: key)
+    try container.encode(value)
+  }
+
+  private func nestedSingleValueContainer(forKey key: Key) -> SingleValueEncodingContainer {
+    let container = RNSingleValueEncodingContainer(
+      codingPath: self.nestedCodingPath(forKey: key),
+      userInfo: self.userInfo
+    )
+    self.storage[RNAnyCodingKey(key)] = container
+    return container
+  }
+
+  func nestedUnkeyedContainer(forKey key: Key) -> UnkeyedEncodingContainer {
+    let container = RNUnkeyedEncodingContainer(
+      codingPath: self.nestedCodingPath(forKey: key),
+      userInfo: self.userInfo
+    )
+    self.storage[RNAnyCodingKey(key)] = container
+
+    return container
+  }
+
+  func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type, forKey key: Key)
+    -> KeyedEncodingContainer<NestedKey> where NestedKey: CodingKey
+  {
+    let container = RNKeyedEncodingContainer<NestedKey>(
+      codingPath: self.nestedCodingPath(forKey: key),
+      userInfo: self.userInfo
+    )
+    self.storage[RNAnyCodingKey(key)] = container
+
+    return KeyedEncodingContainer(container)
+  }
+
+  func superEncoder() -> Encoder {
+    fatalError("Unimplemented")
+  }
+
+  func superEncoder(forKey key: Key) -> Encoder {
+    fatalError("Unimplemented")
+  }
+}
+
+extension RNKeyedEncodingContainer: RNEncodingContainer {
+  var data: Any? {
+    var result: [String: Any] = [:]
+    for (key, container) in self.storage {
+      let data = container.data
+      if data != nil {
+        result[key.stringValue] = data
+      }
+    }
+    return result
+  }
+}

package/ios/RNEncoder/RNSingleValueEncodingContainer.swift

@@ -0,0 +1,78 @@
+import Foundation
+
+final class RNSingleValueEncodingContainer {
+  private var storage: Any? = nil
+
+  fileprivate var canEncodeNewValue = true
+  fileprivate func checkCanEncode(value: Any?) throws {
+    guard self.canEncodeNewValue else {
+      let context = EncodingError.Context(
+        codingPath: self.codingPath,
+        debugDescription:
+          "Attempt to encode value through single value container when previously value already encoded."
+      )
+      throw EncodingError.invalidValue(value as Any, context)
+    }
+  }
+
+  var codingPath: [CodingKey]
+  var userInfo: [CodingUserInfoKey: Any]
+
+  init(codingPath: [CodingKey], userInfo: [CodingUserInfoKey: Any]) {
+    self.codingPath = codingPath
+    self.userInfo = userInfo
+  }
+}
+
+extension RNSingleValueEncodingContainer: SingleValueEncodingContainer {
+  func encodeNil() throws {
+    try checkCanEncode(value: nil)
+    defer { self.canEncodeNewValue = false }
+
+    self.storage = nil
+  }
+
+  func encode<T>(_ value: T) throws where T: Encodable {
+    try checkCanEncode(value: value)
+    defer { self.canEncodeNewValue = false }
+    self.storage = try encodeSingle(value)
+  }
+
+  private func encodeSingle<T>(_ value: T) throws -> Any where T: Encodable {
+    if let customEncoder = self.userInfo[customEncoderKey] {
+      if let result = try (customEncoder as! CustomEncoder)(value) {
+        return result
+      }
+    }
+
+    switch value {
+    case let data as String:
+      return data
+    case let data as Double:
+      return data
+    case let data as Float:
+      return Double(data)
+    case let data as Bool:
+      return data
+    case let data as any BinaryInteger:
+      return data
+    case let data as any CaseIterable:
+      return serializeEnumValue(value: data)
+    case let data as [any Encodable]:
+      return try data.map { try encodeSingle($0) }
+    default:
+      break
+    }
+
+    // Object
+    let encoder = RNObjectEncoder(userInfo: self.userInfo)
+    try value.encode(to: encoder)
+    return encoder.data
+  }
+}
+
+extension RNSingleValueEncodingContainer: RNEncodingContainer {
+  var data: Any? {
+    return storage
+  }
+}

package/ios/RNEncoder/RNUnkeyedEncodingContainer.swift

@@ -0,0 +1,84 @@
+import Foundation
+
+final class RNUnkeyedEncodingContainer {
+  private var storage: [RNEncodingContainer] = []
+
+  var count: Int {
+    return storage.count
+  }
+
+  var codingPath: [CodingKey]
+
+  var nestedCodingPath: [CodingKey] {
+    return self.codingPath + [RNAnyCodingKey(intValue: self.count)]
+  }
+
+  var userInfo: [CodingUserInfoKey: Any]
+
+  init(codingPath: [CodingKey], userInfo: [CodingUserInfoKey: Any]) {
+    self.codingPath = codingPath
+    self.userInfo = userInfo
+  }
+}
+
+extension RNUnkeyedEncodingContainer: UnkeyedEncodingContainer {
+  func encodeNil() throws {
+    var container = self.nestedSingleValueContainer()
+    try container.encodeNil()
+  }
+
+  func encode<T>(_ value: T) throws where T: Encodable {
+    var container = self.nestedSingleValueContainer()
+    try container.encode(value)
+  }
+
+  private func nestedSingleValueContainer() -> SingleValueEncodingContainer {
+    let container = RNSingleValueEncodingContainer(
+      codingPath: self.nestedCodingPath,
+      userInfo: self.userInfo
+    )
+    self.storage.append(container)
+
+    return container
+  }
+
+  func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<
+    NestedKey
+  > where NestedKey: CodingKey {
+    let container = RNKeyedEncodingContainer<NestedKey>(
+      codingPath: self.nestedCodingPath,
+      userInfo: self.userInfo
+    )
+    self.storage.append(container)
+
+    return KeyedEncodingContainer(container)
+  }
+
+  func nestedUnkeyedContainer() -> UnkeyedEncodingContainer {
+    let container = RNUnkeyedEncodingContainer(
+      codingPath: self.nestedCodingPath,
+      userInfo: self.userInfo
+    )
+    self.storage.append(container)
+
+    return container
+  }
+
+  func superEncoder() -> Encoder {
+    fatalError("Unimplemented")
+  }
+}
+
+extension RNUnkeyedEncodingContainer: RNEncodingContainer {
+  var data: Any? {
+    var result: [Any] = []
+
+    for container in storage {
+      if let data = container.data {
+        result.append(data)
+      }
+    }
+
+    return result
+  }
+}