expo-iap 3.0.8 → 3.1.0

package/ios/ExpoIapLog.swift

@@ -0,0 +1,127 @@
+import Foundation
+#if canImport(os)
+import os
+#endif
+
+enum ExpoIapLog {
+    enum Level: String {
+        case debug
+        case info
+        case warn
+        case error
+    }
+
+    private static var isEnabled: Bool = {
+        #if DEBUG
+        true
+        #else
+        false
+        #endif
+    }()
+
+    private static var customHandler: ((Level, String) -> Void)?
+
+    static func setEnabled(_ enabled: Bool) {
+        isEnabled = enabled
+    }
+
+    static func setHandler(_ handler: ((Level, String) -> Void)?) {
+        customHandler = handler
+    }
+
+    static func debug(_ message: String) { log(.debug, message) }
+    static func info(_ message: String) { log(.info, message) }
+    static func warn(_ message: String) { log(.warn, message) }
+    static func error(_ message: String) { log(.error, message) }
+
+    static func payload(_ name: String, payload: Any?) {
+        debug("\(name) payload: \(stringify(payload))")
+    }
+
+    static func result(_ name: String, value: Any?) {
+        debug("\(name) result: \(stringify(value))")
+    }
+
+    static func failure(_ name: String, error: Error) {
+        ExpoIapLog.error("\(name) failed: \(error.localizedDescription)")
+    }
+
+    private static func log(_ level: Level, _ message: String) {
+        guard isEnabled else { return }
+
+        if let handler = customHandler {
+            handler(level, message)
+            return
+        }
+
+        #if canImport(os)
+        let logger = Logger(subsystem: "dev.hyo.expo-iap", category: "ExpoIap")
+        let formatted = "[ExpoIap] \(message)"
+        switch level {
+        case .debug:
+            logger.debug("\(formatted, privacy: .public)")
+        case .info:
+            logger.info("\(formatted, privacy: .public)")
+        case .warn:
+            logger.warning("\(formatted, privacy: .public)")
+        case .error:
+            logger.error("\(formatted, privacy: .public)")
+        }
+        #else
+        NSLog("[ExpoIap][%@] %@", level.rawValue.uppercased(), message)
+        #endif
+    }
+
+    private static func stringify(_ value: Any?) -> String {
+        guard let sanitized = sanitize(value) else {
+            return "null"
+        }
+
+        if JSONSerialization.isValidJSONObject(sanitized),
+           let data = try? JSONSerialization.data(withJSONObject: sanitized, options: []) {
+            return String(data: data, encoding: .utf8) ?? String(describing: sanitized)
+        }
+
+        return String(describing: sanitized)
+    }
+
+    private static func sanitize(_ value: Any?) -> Any? {
+        guard let value else { return nil }
+
+        if let dictionary = value as? [String: Any] {
+            return sanitizeDictionary(dictionary)
+        }
+
+        if let optionalDictionary = value as? [String: Any?] {
+            var compact: [String: Any] = [:]
+            for (key, optionalValue) in optionalDictionary {
+                if let optionalValue {
+                    compact[key] = optionalValue
+                }
+            }
+            return sanitizeDictionary(compact)
+        }
+
+        if let array = value as? [Any] {
+            return array.compactMap { sanitize($0) }
+        }
+
+        if let optionalArray = value as? [Any?] {
+            return optionalArray.compactMap { sanitize($0) }
+        }
+
+        return value
+    }
+
+    private static func sanitizeDictionary(_ dictionary: [String: Any]) -> [String: Any] {
+        var sanitized: [String: Any] = [:]
+        for (key, value) in dictionary {
+            if key.lowercased().contains("token") {
+                sanitized[key] = "hidden"
+            } else if let sanitizedValue = sanitize(value) {
+                sanitized[key] = sanitizedValue
+            }
+        }
+        return sanitized
+    }
+}