Action send object 2 time in one change

[saroar]

Xcode version
Version 14.0.1 (14A400)

DEmoAPP
DuplicateActio.zip

[tgrapperon]

Hey @saroar! This is very likely the same SwiftUI bug as #800. You can probably try the .removeDuplicates() method from there on the Binding to see if it helps.

[saroar]

also removeDuplicates will not work as code can be 33 or 55 its code for mobile auth

[stephencelis]

but vanilla swift dont have this issue ? did you try my demo app I attached ?

Vanilla Swift definitely has this issue, but your demo app doesn't appear to be observing it. If you add the following binding extension:

extension Binding {
  func debug(_ prefix: String) -> Self {
    Self(
      get: { self.wrappedValue },
      set: {
        print(prefix, "set", self.wrappedValue, "to", $0)
        self.wrappedValue = $0
      }
    )
  }
}

And then update your view:

// this action dont send multiple time
TextField(
  "000000",
  text: $phoneNumber
    .debug("$phoneNumber") // 👈
)

Editing the field will result in 2 lines printed to the console, where the second line is simply setting itself with the current value. This is the Apple bug Thomas is referring to.

also removeDuplicates will not work as code can be 33 or 55 its code for mobile auth

Thomas is specifically referring to an extension you can define on Binding. From #800:

extension Binding where Value: Equatable {
  func removeDuplicates() -> Self {
    .init(
      get: { self.wrappedValue },
      set: { newValue, transaction in
        guard newValue != self.wrappedValue else { return }
        self.transaction(transaction).wrappedValue = newValue
      }
    )
  }
}

With this defined you can prevent duplicate actions from entering the store by calling .removeDuplicates() on your view store binding:

TextField(
  "Untitled Todo",
  text: viewStore.binding(
    get: \.description,
    send: TodoAction.textFieldChanged
  )
  .removeDuplicates() // 👈
)

[tgrapperon]

Thanks for elaborating on my terse response @stephencelis.
@saroar The .removeDuplicates() method works because bindings are sending the whole value and not only what's changed. So when you enter "B" from the "A" state, it will send "AB" and not only "B". So when you enter "5" after "5", it'll send "55". From there, it easy to check if one just emitted "55" and avoid to do it again, as clients of the binding already received the correct value.

Because bindings are very general and values are not constrained and can be anything, it is probably better to not bake this into the library to avoid potential bottlenecks caused by the deduplication, although a compromise is possible. For example, we can imagine timing the bindings in DEBUG and showing a runtime warning if two emissions are too close to each other:

extension Binding {
  func warnIfDuplicated() -> Self {
    #if DEBUG
    var date = Date()
    #endif
    return Self(
      get: { self.wrappedValue },
      set: {
        self.transaction($1).wrappedValue = $0
        #if DEBUG
        let now = Date()
        defer { date = now }
        if date.distance(to: now) < 10E-3 {
          rw("Explain workarounds…")
        }
        #endif
      }
    )
  }
}

According to my experiments, the second emission occurs quite fast (~100µs), even with formatters, and it seems difficult to emit legitimately faster than 1000Hz, even while smashing several keys at once on a mechanical keyboard. And as it is only a warning, we can probably allow a few false positive at this regime. This can be backed in all ViewStore.bindings or reserved to BindableAction. This won't increase the API surface of the library, and this can be rescinded quietly if it's not working as one would expect.

[saroar]

are both removeDuplicates same ?

extension Binding where Value: Equatable {
  // NB: Custom bindings can over-emit in certain situations, like sheet dismissal.
  //     This helper can be used to avoid those over-emissions.
  //     https://gist.github.com/stephencelis/09695c901d3ec9f443069ea8c41c4716
  public func removeDuplicates(by predicate: @escaping (Value, Value) -> Bool) -> Self { 
**copy from ISOWords package**
    Binding(
      get: { self.wrappedValue },
      set: { if !predicate(self.wrappedValue, $0) { self.wrappedValue = $0 } }
    )
  }
}

extension Binding where Value: Equatable {
  public func removeDuplicates() -> Self {
    self.removeDuplicates(by: ==)
  }
}

extension Binding where Value: Equatable {
  func removeDuplicates() -> Self { 
**from @tgrapperon**
    .init(
      get: { self.wrappedValue },
      set: { newValue, transaction in
        guard newValue != self.wrappedValue else { return }
        self.transaction(transaction).wrappedValue = newValue
      }
    )
  }
}

[tgrapperon]

They provide more or less the same function, but the second one is a newer refined variant that handles animations, albeit specialized to Equatable. If your binding's value is Equatable, the last one is probably the one you want. Otherwise, you can mix the logic from the first with the transaction thing to set the newValue from the second.

[yuanhang]

There is another workaround I know. Just append .textFieldStyle(.plain) to TextField() and the problem would go (tested on Xcode 14.2).