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

package/ios/ProcivisRNOneCore.xcodeproj/project.pbxproj

@@ -3,7 +3,7 @@
 	archiveVersion = 1;
 	classes = {
 	};
-	objectVersion = 54;
+	objectVersion = 70;
 	objects = {
 
 /* Begin PBXBuildFile section */
@@ -49,6 +49,10 @@
 		33F2711A292F97400090E4DB /* ProcivisOneCoreModule.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ProcivisOneCoreModule.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
+/* Begin PBXFileSystemSynchronizedRootGroup section */
+		33CF268B2CB97A5700E95B65 /* RNEncoder */ = {isa = PBXFileSystemSynchronizedRootGroup; explicitFileTypes = {}; explicitFolders = (); path = RNEncoder; sourceTree = "<group>"; };
+/* End PBXFileSystemSynchronizedRootGroup section */
+
 /* Begin PBXFrameworksBuildPhase section */
 		58B511D81A9E6C8500147676 /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
@@ -79,6 +83,7 @@
 				15260DEB2D561D7F00797D80 /* RSEPinPadManager.m */,
 				15260DE92D561D6900797D80 /* RSEKeyStorage.swift */,
 				15260DE72D561D4300797D80 /* UBQKit.xcframework */,
+				33CF268B2CB97A5700E95B65 /* RNEncoder */,
 				33F27119292F97400090E4DB /* ProcivisOneCoreModule.m */,
 				339DE1312A4EB16300F68DE2 /* ProcivisOneCore.xcframework */,
 				33F2711A292F97400090E4DB /* ProcivisOneCoreModule.swift */,
@@ -105,6 +110,9 @@
 			);
 			dependencies = (
 			);
+			fileSystemSynchronizedGroups = (
+				33CF268B2CB97A5700E95B65 /* RNEncoder */,
+			);
 			name = ProcivisRNOneCore;
 			productName = RCTDataManager;
 			productReference = 134814201AA4EA6300B7C361 /* libProcivisRNOneCore.a */;

package/ios/RNDecoder/RNDecoder.swift

@@ -0,0 +1,191 @@
+import Foundation
+
+public typealias CustomDecoder = (_ value: Any, _ type: Any.Type, _ codingPath: [CodingKey]) throws
+  -> Any?
+public let customDecoderKey = CodingUserInfoKey(rawValue: "customDecoder")!
+
+final public class RNDecoder {
+  public init() {}
+
+  public var userInfo: [CodingUserInfoKey: Any] = [:]
+
+  public func decode<T: Decodable>(_ value: Any) throws -> T {
+    return try decode(T.self, from: value)
+  }
+
+  public func decode<T: Decodable>(_ type: T.Type, from data: Any) throws -> T {
+    let decoder = RNInternalDecoder(referencing: data, userInfo: self.userInfo)
+
+    guard let value = try decoder.unbox(data, as: type) else {
+      throw DecodingError.valueNotFound(
+        type,
+        DecodingError.Context(
+          codingPath: [],
+          debugDescription: "The given data did not contain a top-level value."
+        )
+      )
+    }
+
+    return value
+  }
+}
+
+// MARK: - TopLevelDecoder
+
+#if canImport(Combine)
+  import Combine
+
+  extension RNDecoder: TopLevelDecoder {
+    public typealias Input = Any
+  }
+#endif
+
+// MARK: -
+
+class RNInternalDecoder {
+  internal var storage: RNDecodingStorage
+  internal let userInfo: [CodingUserInfoKey: Any]
+  internal(set) public var codingPath: [CodingKey]
+
+  internal init(
+    referencing container: Any,
+    at codingPath: [CodingKey] = [],
+    userInfo: [CodingUserInfoKey: Any]
+  ) {
+    self.storage = RNDecodingStorage()
+    self.storage.push(container: container)
+    self.codingPath = codingPath
+    self.userInfo = userInfo
+  }
+}
+
+extension RNInternalDecoder: Decoder {
+  func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key>
+  where Key: CodingKey {
+    guard !(self.storage.topContainer is NSNull) else {
+      throw DecodingError.valueNotFound(
+        KeyedDecodingContainer<Key>.self,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription: "Cannot get keyed decoding container -- found null value instead."
+        )
+      )
+    }
+
+    guard let topContainer = self.storage.topContainer as? [String: Any] else {
+      let description =
+        "Expected to decode \([String : Any].self) but found '\(self.storage.topContainer)' instead."
+      throw DecodingError.typeMismatch(
+        [String: Any].self,
+        DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+      )
+    }
+
+    let container = RNKeyedDecodingContainer<Key>(referencing: self, wrapping: topContainer)
+    return KeyedDecodingContainer(container)
+  }
+
+  func unkeyedContainer() throws -> any UnkeyedDecodingContainer {
+    guard !(self.storage.topContainer is NSNull) else {
+      throw DecodingError.valueNotFound(
+        UnkeyedDecodingContainer.self,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription: "Cannot get unkeyed decoding container -- found null value instead."
+        )
+      )
+    }
+
+    let topContainer: [Any]
+
+    if let container = self.storage.topContainer as? [Any] {
+      topContainer = container
+    } else if let container = self.storage.topContainer as? [AnyHashable: Any] {
+      topContainer = [container]
+    } else {
+      let description =
+        "Expected to decode \([Any].self) but found '\(self.storage.topContainer)' instead."
+      throw DecodingError.typeMismatch(
+        [Any].self,
+        DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+      )
+    }
+
+    return RNUnkeyedDecodingContainer(referencing: self, wrapping: topContainer)
+  }
+
+  public func singleValueContainer() throws -> SingleValueDecodingContainer {
+    return self
+  }
+}
+
+extension RNInternalDecoder: SingleValueDecodingContainer {
+  private func expectNonNull<T>(_ type: T.Type) throws {
+    guard !self.decodeNil() else {
+      throw DecodingError.valueNotFound(
+        type,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription: "Expected \(type) but found null value instead."
+        )
+      )
+    }
+  }
+
+  public func decodeNil() -> Bool {
+    return self.storage.topContainer is NSNull
+  }
+
+  public func decode<T: Decodable>(_ type: T.Type) throws -> T {
+    try expectNonNull(type)
+    return try self.unbox(self.storage.topContainer, as: type)!
+  }
+}
+
+extension RNInternalDecoder {
+  internal func unbox<T: Decodable>(_ value: Any, as type: T.Type) throws -> T? {
+    if let customDecoder = self.userInfo[customDecoderKey] {
+      if let result = try (customDecoder as! CustomDecoder)(value, type, self.codingPath) {
+        return (result as! T)
+      }
+    }
+
+    if type == String.self || type == Bool.self || type is any Numeric.Type {
+      guard let data = value as? T else {
+        let description = "Expected to decode \(type) but found '\(value)' instead."
+        throw DecodingError.typeMismatch(
+          type,
+          DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+        )
+      }
+      return data
+    }
+
+    if let enumType = type as? any CaseIterable.Type {
+      guard let data = value as? String else {
+        let description = "Expected to decode \(type) but found '\(value)' instead."
+        throw DecodingError.typeMismatch(
+          type,
+          DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+        )
+      }
+
+      let match = enumType.allCases.first {
+        return serializeEnumValue(value: $0) == data
+      }
+
+      guard let result = match as? T else {
+        let description = "Expected to decode \(type) but found '\(value)' instead."
+        throw DecodingError.typeMismatch(
+          type,
+          DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+        )
+      }
+      return result
+    }
+
+    self.storage.push(container: value)
+    defer { self.storage.popContainer() }
+    return try type.init(from: self)
+  }
+}

package/ios/RNDecoder/RNDecodingStorage.swift

@@ -0,0 +1,33 @@
+import Foundation
+
+internal struct RNDecodingStorage {
+  // MARK: Properties
+
+  /// The container stack.
+  private(set) internal var containers: [Any] = []
+
+  // MARK: - Initialization
+
+  /// Initializes `self` with no containers.
+  internal init() {}
+
+  // MARK: - Modifying the Stack
+
+  internal var count: Int {
+    return self.containers.count
+  }
+
+  internal var topContainer: Any {
+    precondition(!self.containers.isEmpty, "Empty container stack.")
+    return self.containers.last!
+  }
+
+  internal mutating func push(container: Any) {
+    self.containers.append(container)
+  }
+
+  internal mutating func popContainer() {
+    precondition(!self.containers.isEmpty, "Empty container stack.")
+    self.containers.removeLast()
+  }
+}

package/ios/RNDecoder/RNKeyedDecodingContainer.swift

@@ -0,0 +1,133 @@
+import Foundation
+
+internal class RNKeyedDecodingContainer<Key: CodingKey> {
+  private let decoder: RNInternalDecoder
+  private let container: [String: Any]
+  private(set) public var codingPath: [CodingKey]
+
+  internal init(referencing decoder: RNInternalDecoder, wrapping container: [String: Any]) {
+    self.decoder = decoder
+    self.container = container
+    self.codingPath = decoder.codingPath
+  }
+}
+
+extension RNKeyedDecodingContainer: KeyedDecodingContainerProtocol {
+  public var allKeys: [Key] {
+    return self.container.keys.compactMap { Key(stringValue: $0) }
+  }
+
+  public func contains(_ key: Key) -> Bool {
+    return self.container[key.stringValue] != nil
+  }
+
+  public func decodeNil(forKey key: Key) throws -> Bool {
+    return !self.contains(key)
+  }
+
+  private func _errorDescription(of key: CodingKey) -> String {
+    return "\(key) (\"\(key.stringValue)\")"
+  }
+
+  func decode<T: Decodable>(_ type: T.Type, forKey key: Key) throws -> T {
+    guard let entry = self.container[key.stringValue] else {
+      throw DecodingError.keyNotFound(
+        key,
+        DecodingError.Context(
+          codingPath: self.decoder.codingPath,
+          debugDescription: "No value associated with key \(_errorDescription(of: key))."
+        )
+      )
+    }
+
+    self.decoder.codingPath.append(key)
+    defer { self.decoder.codingPath.removeLast() }
+
+    guard let value = try self.decoder.unbox(entry, as: type) else {
+      throw DecodingError.valueNotFound(
+        type,
+        DecodingError.Context(
+          codingPath: self.decoder.codingPath,
+          debugDescription: "Expected \(type) value but found null instead."
+        )
+      )
+    }
+
+    return value
+  }
+
+  func nestedContainer<NestedKey>(keyedBy type: NestedKey.Type, forKey key: Key) throws
+    -> KeyedDecodingContainer<NestedKey> where NestedKey: CodingKey
+  {
+    self.decoder.codingPath.append(key)
+    defer { self.decoder.codingPath.removeLast() }
+
+    guard let value = self.container[key.stringValue] else {
+      throw DecodingError.keyNotFound(
+        key,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription:
+            "Cannot get \(KeyedDecodingContainer<NestedKey>.self) -- no value found for key \"\(key.stringValue)\""
+        )
+      )
+    }
+
+    guard let dictionary = value as? [String: Any] else {
+      let description = "Expected to decode \([String : Any].self) but found '\(value)' instead."
+      throw DecodingError.typeMismatch(
+        [String: Any].self,
+        DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+      )
+    }
+
+    let container = RNKeyedDecodingContainer<NestedKey>(
+      referencing: self.decoder,
+      wrapping: dictionary
+    )
+    return KeyedDecodingContainer(container)
+  }
+
+  func nestedUnkeyedContainer(forKey key: Key) throws -> any UnkeyedDecodingContainer {
+    self.decoder.codingPath.append(key)
+    defer { self.decoder.codingPath.removeLast() }
+
+    guard let value = self.container[key.stringValue] else {
+      throw DecodingError.keyNotFound(
+        key,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription:
+            "Cannot get UnkeyedDecodingContainer -- no value found for key \"\(key.stringValue)\""
+        )
+      )
+    }
+
+    guard let array = value as? [Any] else {
+      let description = "Expected to decode \([Any].self) but found '\(value)' instead."
+      throw DecodingError.typeMismatch(
+        [Any].self,
+        DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+      )
+    }
+
+    return RNUnkeyedDecodingContainer(referencing: self.decoder, wrapping: array)
+  }
+
+  private func _superDecoder(forKey key: CodingKey) throws -> Decoder {
+    let value: Any = self.container[key.stringValue] ?? NSNull()
+    return RNInternalDecoder(
+      referencing: value,
+      at: self.decoder.codingPath + [key],
+      userInfo: self.decoder.userInfo
+    )
+  }
+
+  public func superDecoder() throws -> Decoder {
+    fatalError("Unimplemented")
+  }
+
+  public func superDecoder(forKey key: Key) throws -> Decoder {
+    return try _superDecoder(forKey: key)
+  }
+}

package/ios/RNDecoder/RNUnkeyedDecodingContainer.swift

@@ -0,0 +1,175 @@
+import Foundation
+
+internal class RNUnkeyedDecodingContainer {
+  private let decoder: RNInternalDecoder
+  private let container: [Any]
+  private(set) public var codingPath: [CodingKey]
+  private(set) public var currentIndex: Int
+
+  internal init(referencing decoder: RNInternalDecoder, wrapping container: [Any]) {
+    self.decoder = decoder
+    self.container = container
+    self.codingPath = decoder.codingPath
+    self.currentIndex = 0
+  }
+}
+
+extension RNUnkeyedDecodingContainer: UnkeyedDecodingContainer {
+  var count: Int? {
+    return self.container.count
+  }
+
+  var isAtEnd: Bool {
+    return self.currentIndex >= self.container.count
+  }
+
+  func decodeNil() throws -> Bool {
+    guard !self.isAtEnd else {
+      throw DecodingError.valueNotFound(
+        Any?.self,
+        DecodingError.Context(
+          codingPath: self.decoder.codingPath + [RNAnyCodingKey(intValue: self.currentIndex)],
+          debugDescription: "Unkeyed container is at end."
+        )
+      )
+    }
+
+    if self.container[self.currentIndex] is NSNull {
+      self.currentIndex += 1
+      return true
+    } else {
+      return false
+    }
+  }
+
+  func decode<T: Decodable>(_ type: T.Type) throws -> T {
+    guard !self.isAtEnd else {
+      throw DecodingError.valueNotFound(
+        type,
+        DecodingError.Context(
+          codingPath: self.decoder.codingPath + [RNAnyCodingKey(intValue: self.currentIndex)],
+          debugDescription: "Unkeyed container is at end."
+        )
+      )
+    }
+
+    self.decoder.codingPath.append(RNAnyCodingKey(intValue: self.currentIndex))
+    defer { self.decoder.codingPath.removeLast() }
+
+    guard let decoded = try self.decoder.unbox(self.container[self.currentIndex], as: type) else {
+      throw DecodingError.valueNotFound(
+        type,
+        DecodingError.Context(
+          codingPath: self.decoder.codingPath + [RNAnyCodingKey(intValue: self.currentIndex)],
+          debugDescription: "Expected \(type) but found null instead."
+        )
+      )
+    }
+
+    self.currentIndex += 1
+    return decoded
+  }
+
+  func nestedContainer<NestedKey>(keyedBy type: NestedKey.Type) throws -> KeyedDecodingContainer<
+    NestedKey
+  > where NestedKey: CodingKey {
+    self.decoder.codingPath.append(RNAnyCodingKey(intValue: self.currentIndex))
+    defer { self.decoder.codingPath.removeLast() }
+
+    guard !self.isAtEnd else {
+      throw DecodingError.valueNotFound(
+        KeyedDecodingContainer<NestedKey>.self,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription: "Cannot get nested keyed container -- unkeyed container is at end."
+        )
+      )
+    }
+
+    let value = self.container[self.currentIndex]
+    guard !(value is NSNull) else {
+      throw DecodingError.valueNotFound(
+        KeyedDecodingContainer<NestedKey>.self,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription: "Cannot get keyed decoding container -- found null value instead."
+        )
+      )
+    }
+
+    guard let dictionary = value as? [String: Any] else {
+      let description = "Expected to decode \([String : Any].self) but found '\(value)' instead."
+      throw DecodingError.typeMismatch(
+        [String: Any].self,
+        DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+      )
+    }
+
+    self.currentIndex += 1
+    let container = RNKeyedDecodingContainer<NestedKey>(
+      referencing: self.decoder,
+      wrapping: dictionary
+    )
+    return KeyedDecodingContainer(container)
+  }
+
+  func nestedUnkeyedContainer() throws -> any UnkeyedDecodingContainer {
+    self.decoder.codingPath.append(RNAnyCodingKey(intValue: self.currentIndex))
+    defer { self.decoder.codingPath.removeLast() }
+
+    guard !self.isAtEnd else {
+      throw DecodingError.valueNotFound(
+        UnkeyedDecodingContainer.self,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription: "Cannot get nested keyed container -- unkeyed container is at end."
+        )
+      )
+    }
+
+    let value = self.container[self.currentIndex]
+    guard !(value is NSNull) else {
+      throw DecodingError.valueNotFound(
+        UnkeyedDecodingContainer.self,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription: "Cannot get keyed decoding container -- found null value instead."
+        )
+      )
+    }
+
+    guard let array = value as? [Any] else {
+      let description = "Expected to decode \([Any].self) but found '\(value)' instead."
+      throw DecodingError.typeMismatch(
+        [Any].self,
+        DecodingError.Context(codingPath: self.codingPath, debugDescription: description)
+      )
+    }
+
+    self.currentIndex += 1
+    return RNUnkeyedDecodingContainer(referencing: self.decoder, wrapping: array)
+  }
+
+  func superDecoder() throws -> any Decoder {
+    self.decoder.codingPath.append(RNAnyCodingKey(intValue: self.currentIndex))
+    defer { self.decoder.codingPath.removeLast() }
+
+    guard !self.isAtEnd else {
+      throw DecodingError.valueNotFound(
+        Decoder.self,
+        DecodingError.Context(
+          codingPath: self.codingPath,
+          debugDescription: "Cannot get superDecoder() -- unkeyed container is at end."
+        )
+      )
+    }
+
+    let value = self.container[self.currentIndex]
+    self.currentIndex += 1
+    return RNInternalDecoder(
+      referencing: value,
+      at: self.decoder.codingPath,
+      userInfo: self.decoder.userInfo
+    )
+  }
+}

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