@hot-updater/react-native 1.0.8 → 1.1.1

package/ios/HotUpdater/Internal/StrictJson.swift

@@ -0,0 +1,363 @@
+import Foundation
+
+/// Parses exactly one JSON value (RFC 8259) as `JSON.parse` does, into
+/// Foundation values: `[String: Any]`, `[Any]`, `String`, `NSNumber` (a
+/// `Double`, or a Boolean) and `NSNull`. `JSONSerialization` accepts some
+/// non-JSON syntax, such as a trailing comma in an object, and rejects some
+/// JSON, such as an unpaired `\ud800` escape or a number that overflows to
+/// infinity, so update responses are parsed here instead.
+///
+/// Like `JSON.parse`, a duplicate key keeps its last value and an overflowing
+/// number is infinite. Parsing is iterative, but releasing nested Swift arrays
+/// and dictionaries recurses. So a value nested deeper than `maxDepth`, far
+/// deeper than any field Hot Updater reads, is checked but not built: it
+/// parses as `NSNull`, and the text is accepted as `JSON.parse` accepts it.
+///
+/// JavaScript compares strings by UTF-16 code units, but Swift strings
+/// compare canonically: `"scope\u{212A}ey"` (Kelvin sign) equals `"scopeKey"`,
+/// and a Swift string cannot hold an unpaired surrogate at all.
+/// - An object key that is not its own canonical decomposition, or that has
+///   an unpaired surrogate, is stored escaped. Lookups by plain names match
+///   only that exact key, and `originalKey` recovers the escaped one.
+/// - A string value with an unpaired surrogate is an `UnpairedString`, its
+///   code units as `JSON.parse` keeps them; every other value is a `String`
+///   exactly as the JSON spells it.
+enum StrictJson {
+    /// Starts every escaped key. A key that starts with it is escaped too.
+    private static let escapedKeyPrefix = "\u{E000}"
+
+    /// The deepest nesting of arrays and objects that is built.
+    static let maxDepth = 128
+
+    /// The object key under which `key` is stored.
+    static func storedKey(_ key: String) -> String {
+        storedKey(Array(key.utf16))
+    }
+
+    private static func storedKey(_ units: [UInt16]) -> String {
+        let key = String(decoding: units, as: UTF16.self)
+        if !needsEscape(units),
+           key.utf16.elementsEqual(key.decomposedStringWithCanonicalMapping.utf16) {
+            return key
+        }
+        return escaped(units)
+    }
+
+    /// A string value with an unpaired surrogate, which a Swift `String`
+    /// cannot hold: its UTF-16 code units, as `JSON.parse` keeps them.
+    struct UnpairedString: Hashable {
+        let units: [UInt16]
+
+        /// The text, each unpaired surrogate as U+FFFD.
+        var text: String { String(decoding: units, as: UTF16.self) }
+    }
+
+    /// The parsed value of a string with `units`.
+    private static func storedValue(_ units: [UInt16]) -> Any {
+        hasUnpairedSurrogate(units) ? UnpairedString(units: units) : String(decoding: units, as: UTF16.self)
+    }
+
+    /// Whether a Swift string would lose `units`, or they could be mistaken
+    /// for an escaped key.
+    private static func needsEscape(_ units: [UInt16]) -> Bool {
+        units.first == 0xE000 || hasUnpairedSurrogate(units)
+    }
+
+    private static func hasUnpairedSurrogate(_ units: [UInt16]) -> Bool {
+        var index = 0
+        while index < units.count {
+            let unit = units[index]
+            if (0xD800...0xDBFF).contains(unit) {
+                guard index + 1 < units.count, (0xDC00...0xDFFF).contains(units[index + 1]) else {
+                    return true
+                }
+                index += 2
+            } else if (0xDC00...0xDFFF).contains(unit) {
+                return true
+            } else {
+                index += 1
+            }
+        }
+        return false
+    }
+
+    private static func escaped(_ units: [UInt16]) -> String {
+        escapedKeyPrefix + units.map { String(format: "%04x", $0) }.joined()
+    }
+
+    /// The key as the JSON text spelled it, for a key read from a parsed
+    /// object; an unpaired surrogate becomes U+FFFD.
+    static func originalKey(_ storedKey: String) -> String {
+        guard storedKey.hasPrefix(escapedKeyPrefix) else { return storedKey }
+        let hex = Array(storedKey.dropFirst(escapedKeyPrefix.count))
+        var units: [UInt16] = []
+        var index = 0
+        while index + 4 <= hex.count, let unit = UInt16(String(hex[index..<(index + 4)]), radix: 16) {
+            units.append(unit)
+            index += 4
+        }
+        return String(decoding: units, as: UTF16.self)
+    }
+
+    static func isValid(_ text: String) -> Bool {
+        parse(text) != nil
+    }
+
+    /// The value of `text`, or nil when `text` is not exactly one JSON value.
+    static func parse(_ text: String) -> Any? {
+        var parser = Parser(bytes: Array(text.utf8))
+        return parser.parse()
+    }
+
+    private final class Container {
+        let isObject: Bool
+        /// Past `maxDepth`: checked, but neither built nor kept.
+        let discards: Bool
+        var object: [String: Any] = [:]
+        var array: [Any] = []
+        var key = ""
+
+        init(isObject: Bool, depth: Int) {
+            self.isObject = isObject
+            discards = depth >= StrictJson.maxDepth
+        }
+
+        var value: Any {
+            if discards { return NSNull() }
+            return isObject ? object : array
+        }
+
+        func add(_ value: Any) {
+            if discards { return }
+            if isObject {
+                object[key] = value
+            } else {
+                array.append(value)
+            }
+        }
+    }
+
+    private struct Parser {
+        let bytes: [UInt8]
+        var index = 0
+        var containers: [Container] = []
+
+        init(bytes: [UInt8]) {
+            self.bytes = bytes
+        }
+
+        mutating func parse() -> Any? {
+            var expectValue = true
+            var result: Any?
+            // Adds a finished value to the open container, or ends the parse.
+            func finish(_ value: Any, _ containers: [Container]) -> Bool {
+                if let container = containers.last {
+                    container.add(value)
+                    return false
+                }
+                result = value
+                return true
+            }
+
+            while true {
+                skipWhitespace()
+                if expectValue {
+                    let value: Any
+                    switch peek() {
+                    case UInt8(ascii: "{"):
+                        index += 1
+                        skipWhitespace()
+                        if peek() == UInt8(ascii: "}") {
+                            index += 1
+                            value = [String: Any]()
+                        } else {
+                            let container = Container(isObject: true, depth: containers.count)
+                            guard let key = member() else { return nil }
+                            container.key = key
+                            containers.append(container)
+                            continue
+                        }
+                    case UInt8(ascii: "["):
+                        index += 1
+                        skipWhitespace()
+                        if peek() == UInt8(ascii: "]") {
+                            index += 1
+                            value = [Any]()
+                        } else {
+                            containers.append(Container(isObject: false, depth: containers.count))
+                            continue
+                        }
+                    case UInt8(ascii: "\""):
+                        guard let units = string() else { return nil }
+                        value = StrictJson.storedValue(units)
+                    case UInt8(ascii: "t"):
+                        guard literal("true") else { return nil }
+                        value = NSNumber(value: true)
+                    case UInt8(ascii: "f"):
+                        guard literal("false") else { return nil }
+                        value = NSNumber(value: false)
+                    case UInt8(ascii: "n"):
+                        guard literal("null") else { return nil }
+                        value = NSNull()
+                    default:
+                        guard let number = number() else { return nil }
+                        value = NSNumber(value: number)
+                    }
+                    expectValue = false
+                    if finish(value, containers) {
+                        skipWhitespace()
+                        return index == bytes.count ? result : nil
+                    }
+                } else {
+                    guard let container = containers.last else { return nil }
+                    switch peek() {
+                    case UInt8(ascii: ","):
+                        index += 1
+                        if container.isObject {
+                            skipWhitespace()
+                            guard let key = member() else { return nil }
+                            container.key = key
+                        }
+                        expectValue = true
+                    case UInt8(ascii: "}") where container.isObject,
+                         UInt8(ascii: "]") where !container.isObject:
+                        index += 1
+                        containers.removeLast()
+                        if finish(container.value, containers) {
+                            skipWhitespace()
+                            return index == bytes.count ? result : nil
+                        }
+                    default:
+                        return nil
+                    }
+                }
+            }
+        }
+
+        /// An object member's stored key and colon; its value comes next.
+        private mutating func member() -> String? {
+            guard peek() == UInt8(ascii: "\""), let key = string() else { return nil }
+            skipWhitespace()
+            guard peek() == UInt8(ascii: ":") else { return nil }
+            index += 1
+            return StrictJson.storedKey(key)
+        }
+
+        /// A string's UTF-16 code units, as JSON.parse keeps them.
+        private mutating func string() -> [UInt16]? {
+            index += 1
+            var units: [UInt16] = []
+            var runStart = index
+            // Appends the unescaped UTF-8 bytes read since the last escape.
+            func flush(_ end: Int) {
+                if end > runStart {
+                    units.append(contentsOf: String(decoding: bytes[runStart..<end], as: UTF8.self).utf16)
+                }
+            }
+            while index < bytes.count {
+                let byte = bytes[index]
+                if byte == UInt8(ascii: "\"") {
+                    flush(index)
+                    index += 1
+                    return units
+                }
+                if byte < 0x20 { return nil }
+                if byte != UInt8(ascii: "\\") {
+                    index += 1
+                    continue
+                }
+                flush(index)
+                index += 1
+                guard index < bytes.count else { return nil }
+                let escape = bytes[index]
+                index += 1
+                switch escape {
+                case UInt8(ascii: "\""): units.append(0x22)
+                case UInt8(ascii: "\\"): units.append(0x5C)
+                case UInt8(ascii: "/"): units.append(0x2F)
+                case UInt8(ascii: "b"): units.append(0x08)
+                case UInt8(ascii: "f"): units.append(0x0C)
+                case UInt8(ascii: "n"): units.append(0x0A)
+                case UInt8(ascii: "r"): units.append(0x0D)
+                case UInt8(ascii: "t"): units.append(0x09)
+                case UInt8(ascii: "u"):
+                    guard index + 4 <= bytes.count else { return nil }
+                    var unit: UInt16 = 0
+                    for _ in 0..<4 {
+                        guard let digit = hexValue(bytes[index]) else { return nil }
+                        unit = unit << 4 | UInt16(digit)
+                        index += 1
+                    }
+                    units.append(unit)
+                default:
+                    return nil
+                }
+                runStart = index
+            }
+            return nil
+        }
+
+        private mutating func number() -> Double? {
+            let start = index
+            if peek() == UInt8(ascii: "-") { index += 1 }
+            if peek() == UInt8(ascii: "0") {
+                index += 1
+            } else if let byte = peek(), (UInt8(ascii: "1")...UInt8(ascii: "9")).contains(byte) {
+                skipDigits()
+            } else {
+                return nil
+            }
+            if peek() == UInt8(ascii: ".") {
+                index += 1
+                guard isDigit(peek()) else { return nil }
+                skipDigits()
+            }
+            if peek() == UInt8(ascii: "e") || peek() == UInt8(ascii: "E") {
+                index += 1
+                if peek() == UInt8(ascii: "+") || peek() == UInt8(ascii: "-") { index += 1 }
+                guard isDigit(peek()) else { return nil }
+                skipDigits()
+            }
+            // An overflowing literal is infinite, as in JSON.parse.
+            return Double(String(decoding: bytes[start..<index], as: UTF8.self))
+        }
+
+        private mutating func literal(_ word: String) -> Bool {
+            let wordBytes = Array(word.utf8)
+            guard index + wordBytes.count <= bytes.count,
+                  Array(bytes[index..<(index + wordBytes.count)]) == wordBytes else { return false }
+            index += wordBytes.count
+            return true
+        }
+
+        private mutating func skipWhitespace() {
+            while let byte = peek(),
+                  byte == UInt8(ascii: " ") || byte == UInt8(ascii: "\t") ||
+                  byte == UInt8(ascii: "\n") || byte == UInt8(ascii: "\r") {
+                index += 1
+            }
+        }
+
+        private mutating func skipDigits() {
+            while isDigit(peek()) { index += 1 }
+        }
+
+        private func peek() -> UInt8? {
+            index < bytes.count ? bytes[index] : nil
+        }
+
+        private func isDigit(_ byte: UInt8?) -> Bool {
+            guard let byte else { return false }
+            return (UInt8(ascii: "0")...UInt8(ascii: "9")).contains(byte)
+        }
+
+        private func hexValue(_ byte: UInt8) -> UInt8? {
+            switch byte {
+            case UInt8(ascii: "0")...UInt8(ascii: "9"): return byte - UInt8(ascii: "0")
+            case UInt8(ascii: "a")...UInt8(ascii: "f"): return byte - UInt8(ascii: "a") + 10
+            case UInt8(ascii: "A")...UInt8(ascii: "F"): return byte - UInt8(ascii: "A") + 10
+            default: return nil
+            }
+        }
+    }
+}

package/ios/HotUpdater/Internal/URLSessionDownloadService.swift

@@ -162,7 +162,9 @@ class URLSessionDownloadService: NSObject, DownloadService {
     private var destinations: [URLSessionTask: String] = [:]
     private var fileSizeHandlers: [URLSessionTask: (Int64) -> Void] = [:]
 
-    override init() {
+    /// Each instance passes its own `backgroundSessionIdentifier`: a process
+    /// must not create two background sessions with one identifier.
+    init(backgroundSessionIdentifier: String = HotUpdaterInstanceEnvironment.main.backgroundSessionIdentifier) {
         super.init()
 
         // Foreground session (existing behavior)
@@ -171,7 +173,7 @@ class URLSessionDownloadService: NSObject, DownloadService {
 
         // Background session for persistent downloads
         let backgroundConfig = URLSessionConfiguration.background(
-            withIdentifier: "com.hotupdater.background.download"
+            withIdentifier: backgroundSessionIdentifier
         )
         backgroundConfig.isDiscretionary = false
         if #available(macOS 11.0, *) {

package/ios/HotUpdater/Internal/UpdateFailure.swift

@@ -278,6 +278,8 @@ enum UpdateFailureClassifier {
             return classifySignatureError(error, during: phase)
         case let error as DownloadError:
             return classifyDownloadError(error)
+        case is ArtifactFileResolverError:
+            return .invalidResponse
         case let error as URLError:
             return classifyURLError(error)
         default:

package/ios/HotUpdater/Package.swift

@@ -12,9 +12,17 @@ let coreSources = [
     "FileManagerService.swift",
     "HashUtils.swift",
     "HotUpdaterConfig.swift",
+    "HotUpdaterInstanceEnvironment.swift",
+    "HotUpdaterInstanceRouter.swift",
+    "HotUpdaterLaunchRecovery.swift",
     "KeyValueStorageService.swift",
+    "LaunchPreparationLock.swift",
+    "NativeUpdateCheck.swift",
     "NotificationExtension.swift",
+    "ReleaseCatalog.swift",
     "ReleaseCatalogCacheService.swift",
+    "ReleaseSelection.swift",
+    "StrictJson.swift",
     "SignatureVerifier.swift",
     "UpdateFailure.swift",
     "URLSessionDownloadService.swift",
@@ -27,9 +35,12 @@ let coreExcludedFiles = [
     "CohortService.swift",
     "HotUpdater-Bridging-Header.h",
     "HotUpdater.mm",
+    "HotUpdaterAsync.swift",
     "HotUpdaterImpl.swift",
     "HotUpdaterInterface.swift",
     "HotUpdaterMinBundleId.m",
+    "HotUpdaterFingerprintHash.m",
+    "HotUpdaterNativeUpdates.swift",
 ]
 
 let bsdiffPatchBridgeExcludedFiles =

package/ios/HotUpdater/Public/HotUpdater/HotUpdater.h

@@ -0,0 +1,4 @@
+// Swift Package Manager only: the Objective-C++ target is HotUpdaterObjC there
+// (see Package.swift), so this keeps `#import <HotUpdater/HotUpdater.h>`, the
+// import CocoaPods builds use, working for Objective-C apps.
+#import "../HotUpdater.h"

package/ios/HotUpdater/Public/HotUpdater.h

@@ -19,7 +19,9 @@
  /**
  * Returns the currently active bundle URL with specific bundle from the default (static) instance.
  * Callable from Objective-C (e.g., AppDelegate).
- * This is implemented in HotUpdater.mm and calls the Swift static method.
+ * The bundle holds the embedded main.jsbundle, such as a brownfield XCFramework's
+ * bundle. Hot Updater reuses it for reloads and reads its HOT_UPDATER_* Info.plist
+ * keys before the main bundle's.
  */
 + (NSURL *)bundleURLWithBundle:(NSBundle *)bundle NS_SWIFT_NAME(bundleURL(bundle:));
 
@@ -36,13 +38,30 @@
 - (NSURL *)bundleURLWithBundle:(NSBundle *)bundle NS_SWIFT_NAME(bundleURL(bundle:));
 
 /**
+ * Deprecated: pass `channel`, `fingerprintHash`, and `publicKey` to the
+ * `HotUpdaterOptions` of the `main` `HotUpdaterInstance` instead. Still
+ * honored for main; named instances never read it.
+ *
  * Programmatic configuration for brownfield / XCFramework setups where
  * Info.plist (host) or string resources (Android) are not desirable.
+ * A nil argument means no override. Each call replaces all four values.
+ *
+ * `channel` is the app's fixed default channel, not a runtime switch: keep it
+ * the same from the first launch on. It is part of the storage isolation
+ * key, so changing it deletes the downloaded bundles. To check another
+ * channel at runtime, pass `channel` to `HotUpdaterInstance.checkForUpdate`,
+ * and undo that with its `resetChannel`.
+ *
+ * `isolationKey`, when set, replaces main's storage isolation key verbatim.
+ * It is no longer needed: under the fingerprint strategy the default key is
+ * the fingerprint, the build's MIN_BUNDLE_ID, and the channel, so a native
+ * release that ships the same artifact keeps its downloads.
  */
 + (void)configureWithFingerprintHash:(nullable NSString *)fingerprintHash
                            publicKey:(nullable NSString *)publicKey
                              channel:(nullable NSString *)channel
-                        isolationKey:(nullable NSString *)isolationKey;
+                        isolationKey:(nullable NSString *)isolationKey
+    DEPRECATED_MSG_ATTRIBUTE("Pass channel, fingerprintHash, and publicKey to HotUpdaterOptions. Fingerprint downloads now survive native releases that ship the same artifact.");
 
 /**
  * 다운로드 진행 상황 업데이트 시간을 추적하는 속성

package/ios/HotUpdater/Recovery/HotUpdaterRecoveryHooks.mm

@@ -4,6 +4,9 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTFabricSurface.h>
 #import <React/RCTSurfacePresenter.h>
+#import <React/RCTSurfaceView.h>
+#else
+#import <React/RCTRootView.h>
 #endif
 
 void HotUpdaterInstallRecoveryHooks(void)
@@ -42,8 +45,71 @@ void HotUpdaterInstallRecoveryHooks(void)
         // No coordination lock crosses the original call: older RN versions
         // invoke the completion synchronously on this same thread.
         ((void (*)(id, SEL))originalStart)(surface, startSelector);
+        // A surface of this runtime started: crash recovery starts the
+        // launch of the instance the runtime belongs to once its view is
+        // shown (see the attachment hook below).
+        [[NSNotificationCenter defaultCenter] postNotificationName:@"HotUpdaterSurfaceWillStart" object:surface];
       }
     }));
+
+    // A surface started for pre-rendering is shown only once its view moves
+    // into a window: reported as another start, which crash recovery checks
+    // for being shown. RCTSurfaceView doesn't override didMoveToWindow: add
+    // an override that calls UIView's, never exchanging UIView's own.
+    Class surfaceViewClass = RCTSurfaceView.class;
+    SEL moveSelector = @selector(didMoveToWindow);
+    Class surfaceViewSuperclass = class_getSuperclass(surfaceViewClass);
+    Method inheritedMove = class_getInstanceMethod(surfaceViewClass, moveSelector);
+    if (inheritedMove && surfaceViewSuperclass) {
+      IMP currentMove = class_getMethodImplementation(surfaceViewClass, moveSelector);
+      IMP ownMove = currentMove != class_getMethodImplementation(surfaceViewSuperclass, moveSelector) ? currentMove : NULL;
+      IMP moveReplacement = imp_implementationWithBlock(^(RCTSurfaceView *view) {
+        IMP next = ownMove ?: class_getMethodImplementation(surfaceViewSuperclass, moveSelector);
+        ((void (*)(id, SEL))next)(view, moveSelector);
+        id surface = view.surface;
+        if (view.window && surface) {
+          [[NSNotificationCenter defaultCenter] postNotificationName:@"HotUpdaterSurfaceWillStart" object:surface];
+        }
+      });
+      if (ownMove) {
+        method_setImplementation(inheritedMove, moveReplacement);
+      } else {
+        class_addMethod(surfaceViewClass, moveSelector, moveReplacement, method_getTypeEncoding(inheritedMove));
+      }
+    }
+  });
+#else
+  // Old architecture: a root view in a window shows its bridge's runtime,
+  // which starts the launch of the instance the bridge runs (attributed by
+  // its bundle URL). Repeats are harmless: a launch starts once.
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    Class rootViewClass = RCTRootView.class;
+#pragma clang diagnostic pop
+    SEL selector = @selector(didMoveToWindow);
+    Class superclass = class_getSuperclass(rootViewClass);
+    Method inherited = class_getInstanceMethod(rootViewClass, selector);
+    if (!inherited || !superclass) {
+      return;
+    }
+    // RCTRootView doesn't override didMoveToWindow today: add an override
+    // that calls UIView's, never exchanging UIView's own implementation.
+    IMP current = class_getMethodImplementation(rootViewClass, selector);
+    IMP own = current != class_getMethodImplementation(superclass, selector) ? current : NULL;
+    IMP replacement = imp_implementationWithBlock(^(UIView *view) {
+      IMP next = own ?: class_getMethodImplementation(superclass, selector);
+      ((void (*)(id, SEL))next)(view, selector);
+      if (view.window) {
+        [[NSNotificationCenter defaultCenter] postNotificationName:@"HotUpdaterSurfaceWillStart" object:view];
+      }
+    });
+    if (own) {
+      method_setImplementation(inherited, replacement);
+    } else {
+      class_addMethod(rootViewClass, selector, replacement, method_getTypeEncoding(inherited));
+    }
   });
 #endif
 }

package/ios/Plugins/HotUpdaterFingerprintPlugin/HotUpdaterFingerprintPlugin.swift

@@ -0,0 +1,45 @@
+import Foundation
+import PackagePlugin
+
+// Runs ios/scripts/generate-fingerprint-hash.zsh before every build of the
+// target, the SwiftPM counterpart of the podspec's script phase. The script
+// writes a Swift file defining HotUpdaterBuildFingerprintHash(), which
+// HotUpdater.mm calls.
+@main
+struct HotUpdaterFingerprintPlugin: BuildToolPlugin {
+    func createBuildCommands(context: PluginContext, target: Target) throws -> [Command] {
+        let script = context.package.directoryURL
+            .appending(path: "ios/scripts/generate-fingerprint-hash.zsh")
+        let outputDirectory = context.pluginWorkDirectoryURL
+            .appending(path: "Fingerprint")
+        // React Native's autolinker references this package through
+        // <app>/ios/build/generated/autolinking/libs/HotUpdater, as
+        // Package.swift's relative paths assume.
+        let appRoot = context.package.directoryURL
+            .appending(path: "../../../../../..")
+            .standardized
+        // A prebuild command gets only this environment. PATH lets the
+        // script find node, as React Native's own script phases do, when
+        // ios/.xcode.env.local sets no NODE_BINARY.
+        var environment: [String: String] = [:]
+        for key in ["HOT_UPDATER_APP_ROOT", "CONFIGURATION", "NODE_BINARY", "PATH"] {
+            if let value = ProcessInfo.processInfo.environment[key] {
+                environment[key] = value
+            }
+        }
+        return [
+            .prebuildCommand(
+                displayName: "[HotUpdater] Generate fingerprint",
+                executable: URL(filePath: "/bin/zsh"),
+                arguments: [
+                    script.path(percentEncoded: false),
+                    "--swift",
+                    outputDirectory.path(percentEncoded: false),
+                    appRoot.path(percentEncoded: false),
+                ],
+                environment: environment,
+                outputFilesDirectory: outputDirectory
+            ),
+        ]
+    }
+}