@capgo/capacitor-updater 8.51.24 → 8.52.0

package/ios/Sources/CapacitorUpdaterPlugin/CapacitorUpdaterPlugin.swift

@@ -8,7 +8,6 @@ import Foundation
 import Capacitor
 import UIKit
 import WebKit
-import Version
 
 /**
  * Please read the Capacitor iOS Plugin Development Guide
@@ -96,7 +95,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     deinit {
         implementation.shutdown()
     }
-    private let pluginVersion: String = "8.51.24"
+    private let pluginVersion: String = "8.52.0"
     private let launchStartedAtMs = Int64(Date().timeIntervalSince1970 * 1000)
     static let updateUrlDefault = "https://plugin.capgo.app/updates"
     static let statsUrlDefault = "https://plugin.capgo.app/stats"
@@ -147,7 +146,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     // Note: DELAY_CONDITION_PREFERENCES is now defined in DelayUpdateUtils.DELAY_CONDITION_PREFERENCES
     private var updateUrl = ""
     private var backgroundTaskID: UIBackgroundTaskIdentifier = UIBackgroundTaskIdentifier.invalid
-    private var currentVersionNative: Version = "0.0.0"
+    private var currentVersionNative = CapgoSemanticVersion(major: 0, minor: 0, patch: 0)
     private var currentBuildVersion: String = "0"
     private var autoUpdate = false
     private var autoUpdateMode = CapacitorUpdaterPlugin.autoUpdateModeOff
@@ -219,6 +218,10 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     // Best-effort flag: set before we expect notifyAppReady (load/reload).
     // No lock — never held across waits; a rare race only mis-times one wait.
     private var pendingNotifyAppReady = false
+    // Armed only after a reload. The next document stamps this generation into notifyAppReady.
+    // A call from the previous page has no matching generation and must not mark the new bundle successful.
+    private var readyGuardArmed = false
+    private var readyGeneration = 0
     private let semaphoreWaitTestingLock = NSLock()
     private var didEnterSemaphoreWaitForTesting = false
 
@@ -264,7 +267,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             fatalError("Cannot get version name")
         }
         do {
-            currentVersionNative = try Version(versionName)
+            currentVersionNative = try CapgoSemanticVersion(versionName)
         } catch {
             logger.error("Cannot parse versionName \(versionName)")
         }
@@ -288,6 +291,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         configureAutoUpdateModeFromConfig()
         appReadyTimeout = max(1000, getConfig().getInt("appReadyTimeout", 10000))  // Minimum 1 second
         implementation.timeout = Double(getConfig().getInt("responseTimeout", 20))
+        implementation.allowHttpsToHttpRedirect = getConfig().getBoolean("allowHttpsToHttpRedirect", false)
         resetWhenUpdate = getConfig().getBoolean("resetWhenUpdate", true)
         shakeMenuEnabled = getConfig().getBoolean("shakeMenu", false)
         shakeChannelSelectorEnabled = getConfig().getBoolean("allowShakeChannelSelector", false)
@@ -308,16 +312,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         implementation.setPublicKey(getConfig().getString("publicKey") ?? "")
         implementation.notifyDownloadRaw = notifyDownload
         implementation.notifyListeners = { [weak self] eventName, data in
-            let emit = {
-                self?.notifyListeners(eventName, data: data)
-            }
-            if Thread.isMainThread {
-                emit()
-            } else {
-                DispatchQueue.main.async {
-                    emit()
-                }
-            }
+            self?.notifyListenersOnMain(eventName, data: data)
         }
         implementation.pluginVersion = self.pluginVersion
 
@@ -1244,9 +1239,11 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         call.keepAlive = true
     }
 
-    private func notifyListenersOnMain(_ eventName: String, data: JSObject) {
+    /// CAPPlugin's listener storage is not thread-safe (ionic-team/capacitor#8157), so every
+    /// event this plugin emits goes through the main thread. Calls already on main stay synchronous.
+    private func notifyListenersOnMain(_ eventName: String, data: [String: Any]?, retainUntilConsumed: Bool = false) {
         let notify = {
-            self.notifyListeners(eventName, data: data)
+            self.notifyListeners(eventName, data: data, retainUntilConsumed: retainUntilConsumed)
         }
 
         if Thread.isMainThread {
@@ -1716,6 +1713,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             self.logger.error("Cannot get capBridge")
             return false
         }
+        self.armReadyGuard(webView: vc.webView)
         if self.keepUrlPathAfterReload {
             if let currentURL = vc.webView?.url {
                 capBridge.setServerBasePath(dest.path)
@@ -1767,7 +1765,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                 return false
             }
             self.checkAppReady()
-            self.notifyListeners("appReloaded", data: [:])
+            self.notifyListenersOnMain("appReloaded", data: [:])
             return true
         }
 
@@ -1790,7 +1788,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                 return false
             }
             self.checkAppReady()
-            self.notifyListeners("appReloaded", data: [:])
+            self.notifyListenersOnMain("appReloaded", data: [:])
             return true
         }
 
@@ -2705,12 +2703,12 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         var response: URLResponse?
         var responseError: Error?
 
-        URLSession.shared.dataTask(with: request) { data, urlResponse, error in
+        self.implementation.startRawDataTask(request) { data, urlResponse, error in
             responseData = data
             response = urlResponse
             responseError = error
             semaphore.signal()
-        }.resume()
+        }
 
         if semaphore.wait(timeout: .now() + 60) == .timedOut {
             throw makePreviewError("Preview payload request timed out")
@@ -3025,11 +3023,16 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         self.saveCallForAsyncHandling(call)
         DispatchQueue.global(qos: .utility).async {
             let configDefaultChannel = self.getConfig().getString("defaultChannel", "")!
-            let res = self.implementation.unsetChannel(defaultChannelKey: self.defaultChannelDefaultsKey, configDefaultChannel: configDefaultChannel)
+            let res = self.implementation.unsetChannel(
+                defaultChannelKey: self.defaultChannelDefaultsKey,
+                configDefaultChannel: configDefaultChannel,
+                allowSetDefaultChannel: self.allowSetDefaultChannel
+            )
             if res.error != "" {
-                self.rejectCall(call, message: res.error, code: "UNSETCHANNEL_FAILED", data: [
-                    "message": res.error,
-                    "error": res.error.contains("Channel URL") ? "missing_config" : "request_failed"
+                let message = res.message.isEmpty ? res.error : res.message
+                self.rejectCall(call, message: message, code: "UNSETCHANNEL_FAILED", data: [
+                    "message": message,
+                    "error": res.error
                 ])
             } else {
                 guard self.persistDefaultChannelStateFromDefaults() else {
@@ -3077,9 +3080,20 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                         "message": res.error
                     ])
                 }
-                self.rejectCall(call, message: res.error, code: "SETCHANNEL_FAILED", data: [
-                    "message": res.error,
-                    "error": res.error.contains("Channel URL") ? "missing_config" : (res.error.contains("cannot_update_via_private_channel") || res.error.contains("channel_self_set_not_allowed")) ? "channel_private" : "request_failed"
+                let message = res.message.isEmpty ? res.error : res.message
+                let errorCode: String
+                if res.error == "disabled_by_config" {
+                    errorCode = res.error
+                } else if res.error.contains("cannot_update_via_private_channel") || res.error.contains("channel_self_set_not_allowed") {
+                    errorCode = "channel_private"
+                } else if res.error.contains("Channel URL") {
+                    errorCode = "missing_config"
+                } else {
+                    errorCode = "request_failed"
+                }
+                self.rejectCall(call, message: message, code: "SETCHANNEL_FAILED", data: [
+                    "message": message,
+                    "error": errorCode
                 ])
             } else {
                 guard self.persistDefaultChannelStateFromDefaults() else {
@@ -3309,7 +3323,65 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         )
     }
 
+    static func shouldAcceptReadyCall(guardArmed: Bool, expectedGeneration: Int, reportedGeneration: Int?) -> Bool {
+        if !guardArmed {
+            return true
+        }
+        guard let reportedGeneration else {
+            return false
+        }
+        return reportedGeneration == expectedGeneration
+    }
+
+    static func readyGenerationScript(_ generation: Int) -> String {
+        // Wrap Capacitor.nativePromise, not the plugin proxy. registerPlugin's get trap
+        // ignores assignments to notifyAppReady. Each document keeps its own generation.
+        return "(function(){window.__CAPGO_READY_GEN=\(generation);if(window.__capgoReadyBridge)return;function arm(){var cap=window.Capacitor;if(!cap||typeof cap.nativePromise!=='function'||cap.__capgoNativePromise)return false;var orig=cap.nativePromise.bind(cap);cap.nativePromise=function(pluginName,methodName,options){if(pluginName==='CapacitorUpdater'&&methodName==='notifyAppReady'){var next={};if(options&&typeof options==='object'){for(var k in options){if(Object.prototype.hasOwnProperty.call(options,k))next[k]=options[k];}}next.loadGeneration=window.__CAPGO_READY_GEN;options=next;}return orig(pluginName,methodName,options);};cap.__capgoNativePromise=true;window.__capgoReadyBridge=true;return true;}if(!arm()){var n=0;var t=setInterval(function(){if(arm()||++n>100)clearInterval(t);},20);}})();"
+    }
+
+    private func armReadyGuard(webView: WKWebView?) {
+        let generation = self.readyGeneration + 1
+        guard let webView else {
+            logger.warn("Cannot stamp notifyAppReady generation without a webview")
+            self.readyGuardArmed = false
+            return
+        }
+        let userScript = WKUserScript(
+            source: CapacitorUpdaterPlugin.readyGenerationScript(generation),
+            injectionTime: .atDocumentStart,
+            forMainFrameOnly: true
+        )
+        webView.configuration.userContentController.addUserScript(userScript)
+        self.readyGeneration = generation
+        self.readyGuardArmed = true
+    }
+
+    private func reportedReadyGeneration(_ call: CAPPluginCall) -> Int? {
+        if let generation = call.getInt("loadGeneration") {
+            return generation
+        }
+        // The bridge often boxes JS numbers as NSNumber, which getInt does not cast.
+        if let number = call.getValue("loadGeneration") as? NSNumber {
+            return number.intValue
+        }
+        return nil
+    }
+
+    private func acceptsReadyCall(_ call: CAPPluginCall) -> Bool {
+        let reported = self.readyGuardArmed ? self.reportedReadyGeneration(call) : nil
+        return CapacitorUpdaterPlugin.shouldAcceptReadyCall(
+            guardArmed: self.readyGuardArmed,
+            expectedGeneration: self.readyGeneration,
+            reportedGeneration: reported
+        )
+    }
+
     @objc func notifyAppReady(_ call: CAPPluginCall) {
+        if !self.acceptsReadyCall(call) {
+            logger.info("Ignoring notifyAppReady from a page that is no longer current")
+            call.resolve(["bundle": self.implementation.getCurrentBundle().toJSON()])
+            return
+        }
         self.semaphoreDown()
         let bundle = self.implementation.getCurrentBundle()
         self.implementation.setSuccess(bundle: bundle, autoDeletePrevious: self.autoDeletePrevious)
@@ -3417,7 +3489,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         if BundleStatus.SUCCESS.storedValue != current.getStatus() {
             logger.error("notifyAppReady was not called, roll back current bundle: \(current.toString())")
             logger.error("Did you forget to call 'notifyAppReady()' in your Capacitor App code?")
-            self.notifyListeners("updateFailed", data: [
+            self.notifyListenersOnMain("updateFailed", data: [
                 "bundle": current.toJSON()
             ])
             self.persistLastFailedBundle(current)
@@ -3459,7 +3531,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     private func notifyBundleSet(_ bundle: BundleInfo) {
-        self.notifyListeners("set", data: ["bundle": bundle.toJSON()], retainUntilConsumed: true)
+        self.notifyListenersOnMain("set", data: ["bundle": bundle.toJSON()], retainUntilConsumed: true)
     }
 
     func sendReadyToJs(current: BundleInfo, msg: String) {
@@ -3471,7 +3543,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             if self.consumePendingNotifyAppReady() {
                 self.semaphoreWait(waitTime: self.appReadyTimeout)
             }
-            self.notifyListeners("appReady", data: ["bundle": current.toJSON(), "status": msg], retainUntilConsumed: true)
+            self.notifyListenersOnMain("appReady", data: ["bundle": current.toJSON(), "status": msg], retainUntilConsumed: true)
 
             // Auto hide splashscreen if enabled
             // We show it on background when conditions are met, so we should hide it on foreground regardless of update outcome
@@ -4247,8 +4319,8 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             return
         }
         let payload: [String: Any] = ["version": version]
-        self.notifyListeners("breakingAvailable", data: payload)
-        self.notifyListeners("majorAvailable", data: payload)
+        self.notifyListenersOnMain("breakingAvailable", data: payload)
+        self.notifyListenersOnMain("majorAvailable", data: payload)
     }
 
     private func shouldNotifyBreakingEvents(response: AppVersion) -> Bool {
@@ -4288,7 +4360,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
         let responseMessage = res.message?.isEmpty == false ? res.message : nil
         let message = responseMessage ?? (backendError.isEmpty ? "server did not provide a message" : backendError)
         let latestVersionName = res.version.isEmpty ? current.getVersionName() : res.version
-        self.notifyListeners("updateCheckResult", data: [
+        self.notifyListenersOnMain("updateCheckResult", data: [
             "kind": responseKind,
             "error": backendError,
             "message": message,
@@ -4341,10 +4413,10 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
             if sendStats {
                 self.implementation.sendStats(action: failureAction, versionName: current.getVersionName())
             }
-            self.notifyListeners(failureEvent, data: ["version": latestVersionName])
+            self.notifyListenersOnMain(failureEvent, data: ["version": latestVersionName])
         }
         if notifyNoNeedUpdate {
-            self.notifyListeners("noNeedUpdate", data: ["bundle": current.toJSON()])
+            self.notifyListenersOnMain("noNeedUpdate", data: ["bundle": current.toJSON()])
         }
         self.sendReadyToJs(current: current, msg: msg)
         logger.info("endBackGroundTaskWithNotif \(msg) current: \(current.getVersionName()) latestVersionName: \(latestVersionName)")
@@ -4501,7 +4573,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                     let builtinUpdateAvailable = !current.isBuiltin()
                     if builtinUpdateAvailable {
                         let builtinBundle = self.implementation.getBundleInfo(id: BundleInfo.ID_BUILTIN)
-                        self.notifyListeners("updateAvailable", data: ["bundle": builtinBundle.toJSON()], retainUntilConsumed: true)
+                        self.notifyListenersOnMain("updateAvailable", data: ["bundle": builtinBundle.toJSON()], retainUntilConsumed: true)
                     }
                     self.endBackGroundTaskWithNotif(
                         msg: "Latest version is builtin, autoUpdate onlyDownload",
@@ -4652,7 +4724,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                                 plannedDirectUpdate: plannedDirectUpdate
                             )
                         } else if self.queueBundleForNextBackgroundInstall(next) {
-                            self.notifyListeners("updateAvailable", data: ["bundle": next.toJSON()])
+                            self.notifyListenersOnMain("updateAvailable", data: ["bundle": next.toJSON()])
                             self.endBackGroundTaskWithNotif(
                                 msg: "Direct update reload failed, update will install next background",
                                 latestVersionName: latestVersionName,
@@ -4673,7 +4745,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                             self.logger.info("Direct update skipped because splashscreen timeout occurred. Update will install on next app background.")
                         }
                         if self.queueBundleForNextBackgroundInstall(next) {
-                            self.notifyListeners("updateAvailable", data: ["bundle": next.toJSON()])
+                            self.notifyListenersOnMain("updateAvailable", data: ["bundle": next.toJSON()])
                             self.endBackGroundTaskWithNotif(
                                 msg: "update downloaded, will install next background",
                                 latestVersionName: latestVersionName,
@@ -4691,7 +4763,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                         }
                     } else {
                         self.logger.info("autoUpdate is set to onlyDownload, downloaded update will not be set as next bundle")
-                        self.notifyListeners("updateAvailable", data: ["bundle": next.toJSON()], retainUntilConsumed: true)
+                        self.notifyListenersOnMain("updateAvailable", data: ["bundle": next.toJSON()], retainUntilConsumed: true)
                         self.endBackGroundTaskWithNotif(
                             msg: "update downloaded, autoUpdate onlyDownload",
                             latestVersionName: latestVersionName,
@@ -5036,8 +5108,8 @@ public class CapacitorUpdaterPlugin: CAPPlugin, CAPBridgedPlugin {
                         // Determine update availability by comparing versions
                         if let availableVersion = availableVersion {
                             do {
-                                let currentVer = try Version(currentVersionName)
-                                let availableVer = try Version(availableVersion)
+                                let currentVer = try CapgoSemanticVersion(currentVersionName)
+                                let availableVer = try CapgoSemanticVersion(availableVersion)
                                 if availableVer > currentVer {
                                     result["updateAvailability"] = AppUpdateAvailability.updateAvailable.rawValue
                                 } else {

package/ios/Sources/CapacitorUpdaterPlugin/CapgoSemanticVersion.swift

@@ -0,0 +1,162 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import Foundation
+
+/// Minimal version value used for native version comparisons.
+///
+/// Parsing and ordering intentionally mirror the lenient parser of the `Version` package
+/// (mrackwitz/Version 0.8.0) that this type replaces, so existing comparisons keep the same results:
+/// - `MAJOR[.MINOR[.PATCH]][-PRERELEASE][+BUILD]`, numeric components are ASCII digits (leading zeros allowed).
+/// - Missing minor/patch compare as `0`.
+/// - A version with a prerelease is lower than the same version without one.
+/// - Prerelease identifiers are compared dot by dot: numerically when both are digits, lexically otherwise.
+/// - Build metadata is ignored for equality and ordering.
+public struct CapgoSemanticVersion: Comparable, Hashable, CustomStringConvertible {
+    public enum ParseError: Error {
+        case invalidComponents
+        case invalidMajorComponent
+        case invalidMinorComponent
+        case invalidPatchComponent
+    }
+
+    public let major: Int
+    public let minor: Int?
+    public let patch: Int?
+    public let prerelease: String?
+    public let build: String?
+
+    public var canonicalMinor: Int { minor ?? 0 }
+    public var canonicalPatch: Int { patch ?? 0 }
+
+    // Same pattern as the lenient `Version` parser (including its build group quirk: no dots in build metadata).
+    private static let versionPattern =
+        "\\A([0-9]+)(?:\\.([0-9]+))?(?:\\.([0-9]+))?(?:-([0-9A-Za-z-.]+))?(?:\\+([0-9A-Za-z-]+))??\\z"
+    private static let versionRegex = try? NSRegularExpression(pattern: versionPattern)
+
+    public init(major: Int, minor: Int? = nil, patch: Int? = nil, prerelease: String? = nil, build: String? = nil) {
+        self.major = max(0, major)
+        self.minor = minor.map { max(0, $0) }
+        self.patch = patch.map { max(0, $0) }
+        self.prerelease = prerelease
+        self.build = build
+    }
+
+    public init(_ string: String) throws {
+        guard let regex = Self.versionRegex else {
+            throw ParseError.invalidComponents
+        }
+        let nsString = string as NSString
+        guard let match = regex.firstMatch(in: string, options: [], range: NSRange(location: 0, length: nsString.length)),
+              match.numberOfRanges == 6 else {
+            throw ParseError.invalidComponents
+        }
+
+        func group(_ index: Int) -> String? {
+            let range = match.range(at: index)
+            return range.location == NSNotFound ? nil : nsString.substring(with: range)
+        }
+
+        guard let major = group(1).flatMap({ Int($0) }) else {
+            throw ParseError.invalidMajorComponent
+        }
+        let minorComponent = group(2)
+        let minor = minorComponent.flatMap { Int($0) }
+        if minorComponent != nil && minor == nil {
+            throw ParseError.invalidMinorComponent
+        }
+        let patchComponent = group(3)
+        let patch = patchComponent.flatMap { Int($0) }
+        if patchComponent != nil && patch == nil {
+            throw ParseError.invalidPatchComponent
+        }
+
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+        self.prerelease = group(4)
+        self.build = group(5)
+    }
+
+    public var description: String {
+        var result = "\(major)"
+        if let minor {
+            result += ".\(minor)"
+        }
+        if let patch {
+            result += ".\(patch)"
+        }
+        if let prerelease {
+            result += "-\(prerelease)"
+        }
+        if let build {
+            result += "+\(build)"
+        }
+        return result
+    }
+
+    public static func == (lhs: CapgoSemanticVersion, rhs: CapgoSemanticVersion) -> Bool {
+        return lhs.major == rhs.major
+            && lhs.canonicalMinor == rhs.canonicalMinor
+            && lhs.canonicalPatch == rhs.canonicalPatch
+            && lhs.prerelease == rhs.prerelease
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(major)
+        hasher.combine(canonicalMinor)
+        hasher.combine(canonicalPatch)
+        hasher.combine(prerelease)
+    }
+
+    public static func < (lhs: CapgoSemanticVersion, rhs: CapgoSemanticVersion) -> Bool {
+        if lhs.major != rhs.major {
+            return lhs.major < rhs.major
+        }
+        if lhs.canonicalMinor != rhs.canonicalMinor {
+            return lhs.canonicalMinor < rhs.canonicalMinor
+        }
+        if lhs.canonicalPatch != rhs.canonicalPatch {
+            return lhs.canonicalPatch < rhs.canonicalPatch
+        }
+
+        switch (lhs.prerelease, rhs.prerelease) {
+        case (.some, .none):
+            return true
+        case (.none, .some), (.none, .none):
+            return false
+        case let (.some(lpre), .some(rpre)):
+            return comparePrerelease(lpre, rpre) == .orderedAscending
+        }
+    }
+
+    private static func isNumericIdentifier(_ value: String) -> Bool {
+        return !value.isEmpty && value.utf8.allSatisfy { $0 >= 0x30 && $0 <= 0x39 }
+    }
+
+    private static func comparePrerelease(_ lhs: String, _ rhs: String) -> ComparisonResult {
+        let lhsComponents = lhs.components(separatedBy: ".")
+        let rhsComponents = rhs.components(separatedBy: ".")
+        if let (left, right) = zip(lhsComponents, rhsComponents).first(where: { $0.0 != $0.1 }) {
+            if isNumericIdentifier(left) && isNumericIdentifier(right) {
+                let leftValue = Int(left) ?? 0
+                let rightValue = Int(right) ?? 0
+                if leftValue == rightValue {
+                    return .orderedSame
+                }
+                return leftValue < rightValue ? .orderedAscending : .orderedDescending
+            }
+            if left == right {
+                return .orderedSame
+            }
+            return left < right ? .orderedAscending : .orderedDescending
+        }
+        if lhsComponents.count != rhsComponents.count {
+            return lhsComponents.count < rhsComponents.count ? .orderedAscending : .orderedDescending
+        }
+        return .orderedSame
+    }
+}