chore: pump auto_route (#27876)

* chore: pump auto_route * make build * chore: use drift from pubdev (#27877) Co-authored-by: shenlong-tanwen <139912620+shalong-tanwen@users.noreply.github.com> --------- Co-authored-by: shenlong-tanwen <139912620+shalong-tanwen@users.noreply.github.com>
2026-05-18 03:10:24 +03:00 · 2026-04-18 01:58:36 +05:30
parent 6798d5df32
commit fd5e8d6521
36 changed files with 1826 additions and 940 deletions
@@ -1,4 +1,4 @@
-// Autogenerated from Pigeon (v26.0.2), do not edit directly.
+// Autogenerated from Pigeon (v26.3.4), do not edit directly.
 // See also: https://pub.dev/packages/pigeon

 import Foundation
@@ -50,7 +50,7 @@ private func wrapError(_ error: Any) -> [Any?] {
  }
  return [
    "\(error)",
-    "\(type(of: error))",
+    "\(Swift.type(of: error))",
    "Stacktrace: \(Thread.callStackSymbols)",
  ]
 }
@@ -64,6 +64,19 @@ private func nilOrValue<T>(_ value: Any?) -> T? {
  return value as! T?
 }

+private func doubleEqualsMessages(_ lhs: Double, _ rhs: Double) -> Bool {
+  return (lhs.isNaN && rhs.isNaN) || lhs == rhs
+}
+
+private func doubleHashMessages(_ value: Double, _ hasher: inout Hasher) {
+  if value.isNaN {
+    hasher.combine(0x7FF8000000000000)
+  } else {
+    // Normalize -0.0 to 0.0
+    hasher.combine(value == 0 ? 0 : value)
+  }
+}
+
 func deepEqualsMessages(_ lhs: Any?, _ rhs: Any?) -> Bool {
  let cleanLhs = nilOrValue(lhs) as Any?
  let cleanRhs = nilOrValue(rhs) as Any?
@@ -74,59 +87,92 @@ func deepEqualsMessages(_ lhs: Any?, _ rhs: Any?) -> Bool {
  case (nil, _), (_, nil):
    return false

+  case (let lhs as AnyObject, let rhs as AnyObject) where lhs === rhs:
+    return true
+
  case is (Void, Void):
    return true

-  case let (cleanLhsHashable, cleanRhsHashable) as (AnyHashable, AnyHashable):
-    return cleanLhsHashable == cleanRhsHashable
-
-  case let (cleanLhsArray, cleanRhsArray) as ([Any?], [Any?]):
-    guard cleanLhsArray.count == cleanRhsArray.count else { return false }
-    for (index, element) in cleanLhsArray.enumerated() {
-      if !deepEqualsMessages(element, cleanRhsArray[index]) {
+  case (let lhsArray, let rhsArray) as ([Any?], [Any?]):
+    guard lhsArray.count == rhsArray.count else { return false }
+    for (index, element) in lhsArray.enumerated() {
+      if !deepEqualsMessages(element, rhsArray[index]) {
        return false
      }
    }
    return true

-  case let (cleanLhsDictionary, cleanRhsDictionary) as ([AnyHashable: Any?], [AnyHashable: Any?]):
-    guard cleanLhsDictionary.count == cleanRhsDictionary.count else { return false }
-    for (key, cleanLhsValue) in cleanLhsDictionary {
-      guard cleanRhsDictionary.index(forKey: key) != nil else { return false }
-      if !deepEqualsMessages(cleanLhsValue, cleanRhsDictionary[key]!) {
+  case (let lhsArray, let rhsArray) as ([Double], [Double]):
+    guard lhsArray.count == rhsArray.count else { return false }
+    for (index, element) in lhsArray.enumerated() {
+      if !doubleEqualsMessages(element, rhsArray[index]) {
        return false
      }
    }
    return true

+  case (let lhsDictionary, let rhsDictionary) as ([AnyHashable: Any?], [AnyHashable: Any?]):
+    guard lhsDictionary.count == rhsDictionary.count else { return false }
+    for (lhsKey, lhsValue) in lhsDictionary {
+      var found = false
+      for (rhsKey, rhsValue) in rhsDictionary {
+        if deepEqualsMessages(lhsKey, rhsKey) {
+          if deepEqualsMessages(lhsValue, rhsValue) {
+            found = true
+            break
+          } else {
+            return false
+          }
+        }
+      }
+      if !found { return false }
+    }
+    return true
+
+  case (let lhs as Double, let rhs as Double):
+    return doubleEqualsMessages(lhs, rhs)
+
+  case (let lhsHashable, let rhsHashable) as (AnyHashable, AnyHashable):
+    return lhsHashable == rhsHashable
+
  default:
-    // Any other type shouldn't be able to be used with pigeon. File an issue if you find this to be untrue.
    return false
  }
 }

 func deepHashMessages(value: Any?, hasher: inout Hasher) {
-  if let valueList = value as? [AnyHashable] {
-     for item in valueList { deepHashMessages(value: item, hasher: &hasher) }
-     return
-  }
-
-  if let valueDict = value as? [AnyHashable: AnyHashable] {
-    for key in valueDict.keys { 
-      hasher.combine(key)
-      deepHashMessages(value: valueDict[key]!, hasher: &hasher)
+  let cleanValue = nilOrValue(value) as Any?
+  if let cleanValue = cleanValue {
+    if let doubleValue = cleanValue as? Double {
+      doubleHashMessages(doubleValue, &hasher)
+    } else if let valueList = cleanValue as? [Any?] {
+      for item in valueList {
+        deepHashMessages(value: item, hasher: &hasher)
+      }
+    } else if let valueList = cleanValue as? [Double] {
+      for item in valueList {
+        doubleHashMessages(item, &hasher)
+      }
+    } else if let valueDict = cleanValue as? [AnyHashable: Any?] {
+      var result = 0
+      for (key, value) in valueDict {
+        var entryKeyHasher = Hasher()
+        deepHashMessages(value: key, hasher: &entryKeyHasher)
+        var entryValueHasher = Hasher()
+        deepHashMessages(value: value, hasher: &entryValueHasher)
+        result = result &+ ((entryKeyHasher.finalize() &* 31) ^ entryValueHasher.finalize())
+      }
+      hasher.combine(result)
+    } else if let hashableValue = cleanValue as? AnyHashable {
+      hasher.combine(hashableValue)
+    } else {
+      hasher.combine(String(describing: cleanValue))
    }
-    return
+  } else {
+    hasher.combine(0)
  }
-
-  if let hashableValue = value as? AnyHashable {
-    hasher.combine(hashableValue.hashValue)
-  }
-
-  return hasher.combine(String(describing: value))
 }

-    

 enum PlatformAssetPlaybackStyle: Int {
  case unknown = 0
@@ -208,9 +254,28 @@ struct PlatformAsset: Hashable {
    ]
  }
  static func == (lhs: PlatformAsset, rhs: PlatformAsset) -> Bool {
-    return deepEqualsMessages(lhs.toList(), rhs.toList())  }
+    if Swift.type(of: lhs) != Swift.type(of: rhs) {
+      return false
+    }
+    return deepEqualsMessages(lhs.id, rhs.id) && deepEqualsMessages(lhs.name, rhs.name) && deepEqualsMessages(lhs.type, rhs.type) && deepEqualsMessages(lhs.createdAt, rhs.createdAt) && deepEqualsMessages(lhs.updatedAt, rhs.updatedAt) && deepEqualsMessages(lhs.width, rhs.width) && deepEqualsMessages(lhs.height, rhs.height) && deepEqualsMessages(lhs.durationInSeconds, rhs.durationInSeconds) && deepEqualsMessages(lhs.orientation, rhs.orientation) && deepEqualsMessages(lhs.isFavorite, rhs.isFavorite) && deepEqualsMessages(lhs.adjustmentTime, rhs.adjustmentTime) && deepEqualsMessages(lhs.latitude, rhs.latitude) && deepEqualsMessages(lhs.longitude, rhs.longitude) && deepEqualsMessages(lhs.playbackStyle, rhs.playbackStyle)
+  }
+
  func hash(into hasher: inout Hasher) {
-    deepHashMessages(value: toList(), hasher: &hasher)
+    hasher.combine("PlatformAsset")
+    deepHashMessages(value: id, hasher: &hasher)
+    deepHashMessages(value: name, hasher: &hasher)
+    deepHashMessages(value: type, hasher: &hasher)
+    deepHashMessages(value: createdAt, hasher: &hasher)
+    deepHashMessages(value: updatedAt, hasher: &hasher)
+    deepHashMessages(value: width, hasher: &hasher)
+    deepHashMessages(value: height, hasher: &hasher)
+    deepHashMessages(value: durationInSeconds, hasher: &hasher)
+    deepHashMessages(value: orientation, hasher: &hasher)
+    deepHashMessages(value: isFavorite, hasher: &hasher)
+    deepHashMessages(value: adjustmentTime, hasher: &hasher)
+    deepHashMessages(value: latitude, hasher: &hasher)
+    deepHashMessages(value: longitude, hasher: &hasher)
+    deepHashMessages(value: playbackStyle, hasher: &hasher)
  }
 }

@@ -249,9 +314,19 @@ struct PlatformAlbum: Hashable {
    ]
  }
  static func == (lhs: PlatformAlbum, rhs: PlatformAlbum) -> Bool {
-    return deepEqualsMessages(lhs.toList(), rhs.toList())  }
+    if Swift.type(of: lhs) != Swift.type(of: rhs) {
+      return false
+    }
+    return deepEqualsMessages(lhs.id, rhs.id) && deepEqualsMessages(lhs.name, rhs.name) && deepEqualsMessages(lhs.updatedAt, rhs.updatedAt) && deepEqualsMessages(lhs.isCloud, rhs.isCloud) && deepEqualsMessages(lhs.assetCount, rhs.assetCount)
+  }
+
  func hash(into hasher: inout Hasher) {
-    deepHashMessages(value: toList(), hasher: &hasher)
+    hasher.combine("PlatformAlbum")
+    deepHashMessages(value: id, hasher: &hasher)
+    deepHashMessages(value: name, hasher: &hasher)
+    deepHashMessages(value: updatedAt, hasher: &hasher)
+    deepHashMessages(value: isCloud, hasher: &hasher)
+    deepHashMessages(value: assetCount, hasher: &hasher)
  }
 }

@@ -286,9 +361,18 @@ struct SyncDelta: Hashable {
    ]
  }
  static func == (lhs: SyncDelta, rhs: SyncDelta) -> Bool {
-    return deepEqualsMessages(lhs.toList(), rhs.toList())  }
+    if Swift.type(of: lhs) != Swift.type(of: rhs) {
+      return false
+    }
+    return deepEqualsMessages(lhs.hasChanges, rhs.hasChanges) && deepEqualsMessages(lhs.updates, rhs.updates) && deepEqualsMessages(lhs.deletes, rhs.deletes) && deepEqualsMessages(lhs.assetAlbums, rhs.assetAlbums)
+  }
+
  func hash(into hasher: inout Hasher) {
-    deepHashMessages(value: toList(), hasher: &hasher)
+    hasher.combine("SyncDelta")
+    deepHashMessages(value: hasChanges, hasher: &hasher)
+    deepHashMessages(value: updates, hasher: &hasher)
+    deepHashMessages(value: deletes, hasher: &hasher)
+    deepHashMessages(value: assetAlbums, hasher: &hasher)
  }
 }

@@ -319,9 +403,17 @@ struct HashResult: Hashable {
    ]
  }
  static func == (lhs: HashResult, rhs: HashResult) -> Bool {
-    return deepEqualsMessages(lhs.toList(), rhs.toList())  }
+    if Swift.type(of: lhs) != Swift.type(of: rhs) {
+      return false
+    }
+    return deepEqualsMessages(lhs.assetId, rhs.assetId) && deepEqualsMessages(lhs.error, rhs.error) && deepEqualsMessages(lhs.hash, rhs.hash)
+  }
+
  func hash(into hasher: inout Hasher) {
-    deepHashMessages(value: toList(), hasher: &hasher)
+    hasher.combine("HashResult")
+    deepHashMessages(value: assetId, hasher: &hasher)
+    deepHashMessages(value: error, hasher: &hasher)
+    deepHashMessages(value: hash, hasher: &hasher)
  }
 }

@@ -352,9 +444,17 @@ struct CloudIdResult: Hashable {
    ]
  }
  static func == (lhs: CloudIdResult, rhs: CloudIdResult) -> Bool {
-    return deepEqualsMessages(lhs.toList(), rhs.toList())  }
+    if Swift.type(of: lhs) != Swift.type(of: rhs) {
+      return false
+    }
+    return deepEqualsMessages(lhs.assetId, rhs.assetId) && deepEqualsMessages(lhs.error, rhs.error) && deepEqualsMessages(lhs.cloudId, rhs.cloudId)
+  }
+
  func hash(into hasher: inout Hasher) {
-    deepHashMessages(value: toList(), hasher: &hasher)
+    hasher.combine("CloudIdResult")
+    deepHashMessages(value: assetId, hasher: &hasher)
+    deepHashMessages(value: error, hasher: &hasher)
+    deepHashMessages(value: cloudId, hasher: &hasher)
  }
 }