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

package/ios/RNEncoder/RNAnyCodingKey.swift

@@ -0,0 +1,31 @@
+struct RNAnyCodingKey: CodingKey, Equatable {
+  var stringValue: String
+  var intValue: Int?
+
+  init(stringValue: String) {
+    self.stringValue = stringValue
+    self.intValue = nil
+  }
+
+  init(intValue: Int) {
+    self.stringValue = "\(intValue)"
+    self.intValue = intValue
+  }
+
+  init<Key>(_ base: Key) where Key: CodingKey {
+    if let intValue = base.intValue {
+      self.init(intValue: intValue)
+    } else {
+      self.init(stringValue: base.stringValue)
+    }
+  }
+}
+
+extension RNAnyCodingKey: Hashable {
+  public func hash(into hasher: inout Hasher) {
+    if intValue != nil {
+      hasher.combine(intValue)
+    }
+    hasher.combine(stringValue)
+  }
+}

package/ios/RNEncoder/RNEncoder.swift

@@ -0,0 +1,95 @@
+import Foundation
+
+public typealias CustomEncoder = (_ value: Encodable) throws -> Any?
+public let customEncoderKey = CodingUserInfoKey(rawValue: "customEncoder")!
+
+final public class RNEncoder {
+  public init() {}
+
+  /**
+   A dictionary you use to customize the encoding process
+   by providing contextual information.
+   */
+  public var userInfo: [CodingUserInfoKey: Any] = [:]
+
+  public func encode<T>(_ value: T) throws -> Any where T: Encodable {
+    if let customEncoder = self.userInfo[customEncoderKey] {
+      if let result = try (customEncoder as! CustomEncoder)(value) {
+        return result
+      }
+    }
+
+    let encoder = RNObjectEncoder(userInfo: self.userInfo)
+    try value.encode(to: encoder)
+    return encoder.data
+  }
+}
+
+// MARK: - TopLevelEncoder
+
+#if canImport(Combine)
+  import Combine
+
+  extension RNEncoder: TopLevelEncoder {}
+#endif
+
+// MARK: -
+
+protocol RNEncodingContainer {
+  var data: Any? { get }
+}
+
+class RNObjectEncoder {
+  var codingPath: [CodingKey] = []
+
+  var userInfo: [CodingUserInfoKey: Any] = [:]
+
+  fileprivate var container: RNEncodingContainer?
+
+  var data: Any {
+    return container?.data ?? NSDictionary()
+  }
+
+  init(userInfo: [CodingUserInfoKey: Any]) {
+    self.userInfo = userInfo
+  }
+}
+
+extension RNObjectEncoder: Encoder {
+  fileprivate func assertCanCreateContainer() {
+    precondition(self.container == nil)
+  }
+
+  func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {
+    assertCanCreateContainer()
+
+    let container = RNKeyedEncodingContainer<Key>(
+      codingPath: self.codingPath,
+      userInfo: self.userInfo
+    )
+    self.container = container
+
+    return KeyedEncodingContainer(container)
+  }
+
+  func unkeyedContainer() -> UnkeyedEncodingContainer {
+    assertCanCreateContainer()
+
+    let container = RNUnkeyedEncodingContainer(codingPath: self.codingPath, userInfo: self.userInfo)
+    self.container = container
+
+    return container
+  }
+
+  func singleValueContainer() -> SingleValueEncodingContainer {
+    assertCanCreateContainer()
+
+    let container = RNSingleValueEncodingContainer(
+      codingPath: self.codingPath,
+      userInfo: self.userInfo
+    )
+    self.container = container
+
+    return container
+  }
+}

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
+  }
+}