@capgo/capacitor-updater 8.45.10 → 8.46.0

package/ios/Sources/CapacitorUpdaterPlugin/BundleStatus.swift

@@ -31,18 +31,94 @@ func == (lhs: LocalizedString, rhs: LocalizedString) -> Bool {
     return lhs.value == rhs.value
 }
 
-enum BundleStatus: LocalizedString, Decodable, Encodable {
+enum BundleStatus: LocalizedString, CaseIterable, Decodable, Encodable {
     case SUCCESS = "success"
     case ERROR = "error"
     case PENDING  = "pending"
     case DELETED  = "deleted"
     case DOWNLOADING  = "downloading"
 
+    var storedValue: String {
+        switch self {
+        case .SUCCESS:
+            return "success"
+        case .ERROR:
+            return "error"
+        case .PENDING:
+            return "pending"
+        case .DELETED:
+            return "deleted"
+        case .DOWNLOADING:
+            return "downloading"
+        }
+    }
+
     var localizedString: String {
         return self.rawValue.value
     }
 
     init?(localizedString: String) {
-        self.init(rawValue: LocalizedString(localized: localizedString))
+        let normalized = localizedString.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let status = BundleStatus.allCases.first(where: { $0.localizedString == normalized }) else {
+            return nil
+        }
+        self = status
+    }
+
+    init?(storedValue: String) {
+        guard let status = BundleStatus.fromStoredValue(storedValue) else {
+            return nil
+        }
+        self = status
+    }
+
+    private static func fromStoredValue(_ value: String) -> BundleStatus? {
+        let normalized = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let status = BundleStatus(localizedString: normalized) {
+            return status
+        }
+
+        let storedValue = normalized.lowercased()
+        return BundleStatus.allCases.first(where: { $0.storedValue == storedValue })
+    }
+
+    init(from decoder: Decoder) throws {
+        if let container = try? decoder.singleValueContainer(),
+           let value = try? container.decode(String.self),
+           let status = BundleStatus.fromStoredValue(value) {
+            self = status
+            return
+        }
+
+        if let container = try? decoder.container(keyedBy: DynamicCodingKey.self),
+           let key = container.allKeys.first,
+           let status = BundleStatus.fromStoredValue(key.stringValue) {
+            self = status
+            return
+        }
+
+        throw DecodingError.dataCorrupted(
+            DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Invalid bundle status")
+        )
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(self.storedValue)
+    }
+}
+
+private struct DynamicCodingKey: CodingKey {
+    var stringValue: String
+    var intValue: Int?
+
+    init?(stringValue: String) {
+        self.stringValue = stringValue
+        self.intValue = nil
+    }
+
+    init?(intValue: Int) {
+        self.stringValue = String(intValue)
+        self.intValue = intValue
     }
 }