@onekeyfe/react-native-bottom-tabs 6.7.0-alpha.382 → 6.7.0-alpha.384

package/docs/SPEC.md

@@ -1,5 +1,123 @@
 # Native Tab View behavioral contract
 
+## Native left drawer
+
+Status: implemented in module source. Package TypeScript, iOS/Android Fabric
+code generation, iOS Objective-C++ Fabric bridge compilation against RN 0.86.2,
+13 React wrapper checks, eleven Android API 36 native tests and four real-Fabric
+iOS review cases passed (shared-header/body arbitration and bar-height switches).
+The static Home example also passed a focused TypeScript check.
+Detailed iOS runtime evidence is recorded separately; physical-device and exact
+reference-video acceptance remain pending.
+
+`renderDrawerContent?: () => React.ReactNode` supplies an optional menu slot.
+`drawerOpen?: boolean` defaults to false and requests its stable open state.
+`onDrawerOpenChange?: (open: boolean) => void` reports a completed user transition;
+controlled consumers MUST mirror it into `drawerOpen`. Prop-driven transitions,
+initial layout and cancellation emit no event. A user transition returning to
+the previous stable state emits only when it overrides an in-flight external
+target, so the consumer can reconcile that target. `drawerSwipeEnabled?: boolean`
+defaults to false; callers MUST enable it only where drawer navigation is appropriate (normally a root
+screen). Existing `hapticFeedbackEnabled` enables one light native haptic after
+a completed user transition changes the stable state. Programmatic updates and
+cancelled gestures do not vibrate.
+
+The drawer is physically left on both iOS and Android, including RTL. Its width
+is 78 percent of the host. The foreground is the full tab container, including
+the native tab bar and an optional custom JS bar. It keeps its full width and
+height while moving right, without scaling, scene reparenting or remounting.
+The native host and two slots remain mounted when the drawer is disabled or its
+content changes. Missing content disables the drawer, resets it closed without
+an event, and passes foreground input through. Web omits the drawer host/menu
+and passes the existing tab content through; it implements no drawer gestures.
+The existing tab view's other Web support is unchanged.
+
+For normalized progress `p` in [0, 1], foreground translation is `.78 * width * p`,
+its left circular corner radius is `64 * p` points/dp and its neutral gray
+dim surface (RGB 28/28/28) has opacity `.7 * p`.
+The menu translates from `-.12 * drawerWidth` to zero; a black menu shade fades
+from .12 to zero. These are initial reference-video tuning values, not a claim
+of pixel-perfect parity. Closed menus are hidden from touch/accessibility;
+while visible, the foreground is blocked by a native dim surface. Tapping that
+surface closes the drawer. iOS accessibility escape and Android Back close an
+open drawer; the dim surface exposes an accessible close action.
+On Android the dim surface MUST retain full foreground bounds even while hidden
+and after React/Fabric ancestors suppress `requestLayout`. Internal containers
+and both slots MUST be measured and laid out on host layout and slot changes,
+without relying on a later ancestor layout pass. Visible dim input MUST prevent
+native foreground controls from receiving the same touch.
+While closed, that retained dim surface MUST also be excluded from React Native
+touch-target lookup, so JS Pressable taps reach the foreground. Visibility alone
+is insufficient for React Native's native target traversal.
+
+The reported native tab-bar height MUST become zero when hidden and restore the
+current height when shown. The context and drawer exclusion use one effective
+height: a rendered custom bar's own measured height takes precedence; otherwise
+`tabBarHidden` forces zero. Native hide measurements MUST NOT overwrite a custom
+bar's height, including across native/custom presentation switches.
+
+With opening swipes enabled, a one-finger rightward gesture may start anywhere
+in the foreground content. At the first confirmed direction, the actual native
+touch target and its ancestor chain determine ownership. A horizontal scroll
+view, list or pager which can consume that physical direction takes priority;
+only when every such ancestor is at its boundary may the drawer open. Vertical
+scroll views do not block horizontal drawer intent. Once selected, the owner is
+locked until up/cancel: reaching a boundary mid-gesture does not hand off.
+Disabled pager input does not claim a gesture based on its retained scroll
+range; an independently enabled horizontal child inside that page still can.
+An ancestor pager which explicitly excludes the touched shared header MUST NOT
+claim that header gesture solely because its horizontal offset is nonzero.
+The header's own nested horizontal content retains its normal boundary priority.
+On iOS this uses the repository's existing `excludedHeaderView` Objective-C
+getter on the native smooth pager and the real touch target's ancestry. It does
+not invoke another scroll view's UIKit recognition lifecycle hook, add a Pager
+API, or infer a header exclusion from a pager's selected page.
+The iOS UIPageViewController boundary uses its public data-source query once per
+decision, skipping its internally centered scroll offset. Android observes
+pending direction even when a nested pager initially disallows interception,
+but stops overriding that request after the child wins. Sliders and editing controls,
+web/graphics surfaces, system back gestures and starts in the bottom tab-bar
+footprint take priority. When open, closing gestures
+remain enabled even if opening swipes are disabled. Only the exposed
+foreground accepts a closing pan; menu scrolling remains the consumer's own.
+Vertical gestures fail before taking ownership. Active touches interrupted by
+a second finger, system cancellation, disabling, detach or a newer prop update
+cannot later emit an event. Cancellation returns to the previous stable state,
+or resumes an external target whose programmatic animation the gesture interrupted.
+No gesture progress crosses the JS bridge.
+
+Both platforms settle on their UI thread with the same critically damped curve:
+`p(t) = target + (a + b*t) * exp(-22*t)`, where `a = p0-target`,
+`b = v0 + 22*a`, and normalized velocity `v0` is clamped to [-8, 8] per second.
+Presentation is clamped to [0, 1], and the transition ends at or before 500 ms.
+Release targets open when `p + v0*.12 >= .5`. A newer animation or touch starts
+from the current displayed progress and cancels the previous completion.
+Resize snaps a pending settlement to its target, emitting its user event once
+if appropriate; an active drag follows the same cancellation rule. Detach cancels
+animations and callbacks; reattachment reapplies the latest external target.
+The host retains at most one display-link/animator, one touch
+sequence, two React child slots, and native dim surfaces. It owns no snapshots,
+workers, persistence, JS animation objects, RNGH or Reanimated dependency.
+
+Implementation boundaries: `src/BottomTabs.tsx` owns slots and settled callbacks;
+`src/BottomTabsDrawerNativeComponent.ts` defines the Fabric boundary;
+`ios/RCTBottomTabsDrawerContainerView.swift` and
+`android/src/main/java/com/onekey/bottomtabs/BottomTabsDrawerView.kt` own native
+input, layout, animation and cleanup. The iOS Fabric component and Android manager only forward children,
+props and the settled event. Required acceptance includes both bar styles,
+custom bars, content/vertical gestures, dim close, rapid reversal, cancellation,
+disable/remove-content, resize, detach, accessibility, RTL and bottom-bar
+gesture ownership, including a real pager, nested horizontal list and vertical
+scrolling in the complete Fabric example. Source checks and emulator checks do not establish physical
+device smoothness or exact reference-video fidelity.
+
+The standalone `example/react-native/pages/BottomTabsHomeDrawerExample.tsx`
+reproduces Home’s wallet toolbar, balance/actions/banner shared header and
+Spot/Perps/Earn/NFT/History hierarchy using static data, native CollapsiblePager
+and standard React Native scroll views. It is an equivalent interaction fixture;
+the application’s existing JS collapsible-header implementation and business
+NativeList pages are not migrated or exercised by this fixture.
+
 ## Tab presses and double press
 
 Status: implemented in module source. Runtime verification status is recorded
@@ -146,8 +264,9 @@ page exposes the switch and its scrolling scene reserves the reported bar height
 
 All gesture handling, animations, and timers run on the platform UI thread in
 the main-runtime native view. The view owns no background-runtime or shared JS
-objects. Retained state is bounded to the current touch sequence, the last
-pressed tab and timestamp, and at most two running animators.
+objects. The tab bar retains the current touch sequence, the last pressed tab
+and timestamp, and at most two running animators. The optional drawer's additional
+single animation and touch ownership are bounded in the Native left drawer section.
 
 ## Conformance and acceptance
 

package/ios/RCTBottomTabsContainerView.swift

@@ -225,9 +225,7 @@ class RCTBottomTabsContainerView: UIView {
 
     DispatchQueue.main.async { [weak self] in
       guard let self, let tbc = self.tabBarController else { return }
-      if !tbc.tabBar.isHidden {
-        self.onTabBarMeasured?(["height": Double(tbc.tabBar.frame.size.height)])
-      }
+      self.onTabBarMeasured?(["height": self.tabBarHidden ? 0 : Double(tbc.tabBar.frame.size.height)])
     }
   }
 
@@ -499,9 +497,7 @@ class RCTBottomTabsContainerView: UIView {
     #endif
     tbc.tabBar.isUserInteractionEnabled = !tabBarHidden
 
-    if !tabBarHidden {
-      onTabBarMeasured?(["height": Double(tbc.tabBar.frame.size.height)])
-    }
+    onTabBarMeasured?(["height": tabBarHidden ? 0 : Double(tbc.tabBar.frame.size.height)])
   }
 
   private func updateSidebarAdaptable() {

package/ios/RCTBottomTabsDrawerComponentView.h

@@ -0,0 +1,8 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+@interface RCTBottomTabsDrawerComponentView : RCTViewComponentView
+@end
+NS_ASSUME_NONNULL_END
+#endif

package/ios/RCTBottomTabsDrawerComponentView.mm

@@ -0,0 +1,79 @@
+#import "RCTBottomTabsDrawerComponentView.h"
+#import <react/renderer/components/RNBottomTabs/ComponentDescriptors.h>
+#import <react/renderer/components/RNBottomTabs/EventEmitters.h>
+#import <react/renderer/components/RNBottomTabs/Props.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+// Swift keeps the host internal to this module, so its framework compatibility
+// header does not export the class. Its explicit @objc name and selectors form
+// this private boundary, matching the existing tab container's runtime lookup.
+@protocol RNBottomTabsDrawerContainer <NSObject>
+@property(nonatomic) BOOL enabled;
+@property(nonatomic) BOOL open;
+@property(nonatomic) BOOL swipeEnabled;
+@property(nonatomic) BOOL hapticFeedbackEnabled;
+@property(nonatomic) double bottomBarHeight;
+@property(nonatomic, copy) void (^onDrawerOpenChange)(BOOL open);
+- (void)insertChild:(UIView *)child atIndex:(NSInteger)index;
+- (void)removeChildAtIndex:(NSInteger)index;
+@end
+
+using namespace facebook::react;
+
+@implementation RCTBottomTabsDrawerComponentView {
+  UIView<RNBottomTabsDrawerContainer> *_drawer;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNBottomTabsDrawerComponentDescriptor>();
+}
+
++ (BOOL)shouldBeRecycled { return NO; }
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _props = std::make_shared<const RNBottomTabsDrawerProps>();
+    Class containerClass = NSClassFromString(@"RCTBottomTabsDrawerContainerView");
+    _drawer = (UIView<RNBottomTabsDrawerContainer> *)[[containerClass alloc] initWithFrame:frame];
+    self.contentView = _drawer;
+    __weak RCTBottomTabsDrawerComponentView *weakSelf = self;
+    _drawer.onDrawerOpenChange = ^(BOOL open) {
+      auto strongSelf = weakSelf;
+      if (!strongSelf) return;
+      auto emitter = std::static_pointer_cast<const RNBottomTabsDrawerEventEmitter>(strongSelf->_eventEmitter);
+      if (emitter) emitter->onDrawerOpenChange({.open = (bool)open});
+    };
+  }
+  return self;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)child index:(NSInteger)index
+{
+  [_drawer insertChild:child atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)child index:(NSInteger)index
+{
+  [_drawer removeChildAtIndex:index];
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &next = *std::static_pointer_cast<const RNBottomTabsDrawerProps>(props);
+  const auto &previous = *std::static_pointer_cast<const RNBottomTabsDrawerProps>(_props);
+  if (next.enabled != previous.enabled) _drawer.enabled = next.enabled;
+  if (next.open != previous.open) _drawer.open = next.open;
+  if (next.swipeEnabled != previous.swipeEnabled) _drawer.swipeEnabled = next.swipeEnabled;
+  if (next.hapticFeedbackEnabled != previous.hapticFeedbackEnabled)
+    _drawer.hapticFeedbackEnabled = next.hapticFeedbackEnabled;
+  if (next.bottomBarHeight != previous.bottomBarHeight) _drawer.bottomBarHeight = next.bottomBarHeight;
+  [super updateProps:props oldProps:oldProps];
+}
+@end
+
+Class<RCTComponentViewProtocol> RNBottomTabsDrawerCls(void)
+{
+  return RCTBottomTabsDrawerComponentView.class;
+}

package/ios/RCTBottomTabsDrawerContainerView.swift

@@ -0,0 +1,327 @@
+import UIKit
+
+/// Internal native host. React owns two fixed slots: menu, then foreground.
+@objc(RCTBottomTabsDrawerContainerView)
+final class RCTBottomTabsDrawerContainerView: UIView, UIGestureRecognizerDelegate {
+  @objc var enabled = false {
+    didSet {
+      guard enabled != oldValue else { return }
+      interruptGesture()
+      stopAnimation()
+      stableOpen = false
+      setProgress(0)
+      if enabled && open { settle(to: true, velocity: 0, user: false) }
+    }
+  }
+  @objc var open = false {
+    didSet {
+      guard open != oldValue else { return }
+      interruptGesture()
+      settle(to: enabled && open, velocity: 0, user: false)
+    }
+  }
+  @objc var swipeEnabled = false
+  @objc var hapticFeedbackEnabled = false
+  @objc var bottomBarHeight: Double = 0
+  @objc var onDrawerOpenChange: ((Bool) -> Void)?
+
+  private let menu = UIView()
+  private let menuShade = UIView()
+  private let foreground = UIView()
+  private let foregroundContent = UIView()
+  private let dim = UIButton(type: .custom)
+  private var slots: [UIView] = []
+  private var pan: UIPanGestureRecognizer!
+  private var progress: CGFloat = 0
+  private var stableOpen = false
+  private var gestureStartProgress: CGFloat = 0
+  private var gestureReturnOpen = false
+  private weak var touchTarget: UIView?
+  private var suppressCancellation = false
+  private var displayLink: CADisplayLink?
+  private var animationStart: CFTimeInterval = 0
+  private var animationFrom: CGFloat = 0
+  private var animationVelocity: CGFloat = 0
+  private var animationTarget = false
+  private var animationUser = false
+  private var previousSize = CGSize.zero
+
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    clipsToBounds = true
+    addSubview(menu)
+    menuShade.backgroundColor = .black
+    menuShade.isUserInteractionEnabled = false
+    menu.addSubview(menuShade)
+    addSubview(foreground)
+    foreground.addSubview(foregroundContent)
+    dim.backgroundColor = UIColor(white: 28.0 / 255.0, alpha: 1)
+    dim.accessibilityLabel = NSLocalizedString("Close menu", comment: "Close the tab drawer")
+    dim.addTarget(self, action: #selector(closeFromUser), for: .touchUpInside)
+    foreground.addSubview(dim)
+    foreground.layer.maskedCorners = [.layerMinXMinYCorner, .layerMinXMaxYCorner]
+    foreground.layer.cornerCurve = .circular
+    foreground.clipsToBounds = true
+    pan = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))
+    pan.maximumNumberOfTouches = 1
+    pan.delegate = self
+    addGestureRecognizer(pan)
+    setProgress(0)
+  }
+
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  @objc func insertChild(_ child: UIView, atIndex index: Int) {
+    guard index >= 0 && index <= slots.count && slots.count < 2 else { return }
+    slots.insert(child, at: index)
+    updateSlots()
+  }
+
+  @objc func removeChild(atIndex index: Int) {
+    guard slots.indices.contains(index) else { return }
+    slots.remove(at: index).removeFromSuperview()
+    updateSlots()
+  }
+
+  private func updateSlots() {
+    for (index, child) in slots.enumerated() {
+      (index == 0 ? menu : foregroundContent).insertSubview(child, at: 0)
+    }
+    menu.bringSubviewToFront(menuShade)
+    setNeedsLayout()
+  }
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    if previousSize != bounds.size {
+      let dragging = pan.state == .began || pan.state == .changed
+      let target = displayLink != nil ? animationTarget : (dragging ? gestureReturnOpen : stableOpen)
+      let user = displayLink != nil && animationUser && previousSize != .zero
+      interruptGesture()
+      stopAnimation()
+      finish(target: enabled && (previousSize == .zero ? open : target), user: user)
+      previousSize = bounds.size
+    }
+    menu.transform = .identity
+    foreground.transform = .identity
+    menu.frame = CGRect(x: 0, y: 0, width: bounds.width * 0.78, height: bounds.height)
+    foreground.frame = bounds
+    foregroundContent.frame = foreground.bounds
+    dim.frame = foreground.bounds
+    menuShade.frame = menu.bounds
+    if slots.count > 0 { slots[0].frame = menu.bounds }
+    if slots.count > 1 { slots[1].frame = foreground.bounds }
+    setProgress(progress)
+  }
+
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window == nil {
+      interruptGesture()
+      stopAnimation()
+      setProgress(stableOpen && enabled ? 1 : 0)
+    } else if enabled && stableOpen != open {
+      settle(to: open, velocity: 0, user: false)
+    }
+  }
+
+  override func accessibilityPerformEscape() -> Bool {
+    guard enabled && progress > 0 else { return false }
+    closeFromUser()
+    return true
+  }
+
+  func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+    guard enabled else { return false }
+    let start = touch.location(in: self)
+    guard start.y < bounds.height - CGFloat(max(0, bottomBarHeight)) else { return false }
+    touchTarget = touch.view
+    if progress > 0 { return start.x >= bounds.width * 0.78 * progress }
+    return swipeEnabled && !touchPathContainsExclusiveControl()
+  }
+
+  override func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
+    guard enabled, bounds.width > 0 else { return false }
+    let velocity = pan.velocity(in: self)
+    guard abs(velocity.x) > abs(velocity.y) else { return false }
+    let location = pan.location(in: self)
+    let translation = pan.translation(in: self)
+    let start = CGPoint(x: location.x - translation.x, y: location.y - translation.y)
+    guard start.y < bounds.height - CGFloat(max(0, bottomBarHeight)) else { return false }
+    if progress > 0 {
+      return start.x >= bounds.width * 0.78 * progress
+    }
+    return swipeEnabled && velocity.x > 0 && !touchPathCanScrollRight()
+  }
+
+  // Let this recognizer make its one-time direction/boundary decision before
+  // descendant scroll pans. Returning false from shouldBegin releases them.
+  func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer,
+                         shouldBeRequiredToFailBy other: UIGestureRecognizer) -> Bool {
+    guard gestureRecognizer === pan,
+          let scroll = other.view as? UIScrollView,
+          other === scroll.panGestureRecognizer else { return false }
+    return scroll.isDescendant(of: foregroundContent)
+  }
+
+  func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer,
+                         shouldRequireFailureOf other: UIGestureRecognizer) -> Bool {
+    guard gestureRecognizer === pan else { return false }
+    // UIKit's navigation edge gesture retains priority over the drawer.
+    return other is UIScreenEdgePanGestureRecognizer
+  }
+
+  private func touchPathContainsExclusiveControl() -> Bool {
+    var view = touchTarget
+    while let current = view, current !== self {
+      if current is UISlider || current is UISwitch || current is UISegmentedControl ||
+          current is UITextField || current is UITextView { return true }
+      if let webClass = NSClassFromString("WKWebView"), current.isKind(of: webClass) { return true }
+      if current.layer is CAMetalLayer { return true }
+      view = current.superview
+    }
+    return false
+  }
+
+  private func pageController(for scroll: UIScrollView) -> UIPageViewController? {
+    var responder: UIResponder? = scroll.next
+    while let current = responder, current !== self {
+      if let page = current as? UIPageViewController, scroll.superview === page.view { return page }
+      responder = current.next
+    }
+    return nil
+  }
+
+  private func touchPathCanScrollRight() -> Bool {
+    var view = touchTarget
+    while let current = view, current !== self {
+      if let scroll = current as? UIScrollView, scroll.isScrollEnabled {
+        // The native smooth pager exposes this existing header exclusion. Read
+        // its getter instead of invoking UIKit's recognition lifecycle hook.
+        let selector = NSSelectorFromString("excludedHeaderView")
+        if scroll.responds(to: selector),
+           let header = scroll.perform(selector)?.takeUnretainedValue() as? UIView,
+           let target = touchTarget, target.isDescendant(of: header) {
+          view = current.superview
+          continue
+        }
+        if let page = pageController(for: scroll) {
+          // UIPageViewController keeps its private scroll view centered even at
+          // the first page. Its public before query describes physical right.
+          if page.navigationOrientation == .horizontal,
+             let displayed = page.viewControllers?.first,
+             page.dataSource?.pageViewController(page, viewControllerBefore: displayed) != nil { return true }
+        } else {
+          let inset = scroll.adjustedContentInset
+          let horizontal = scroll.contentSize.width + inset.left + inset.right > scroll.bounds.width + 0.5
+          if horizontal && scroll.contentOffset.x > -inset.left + 0.5 { return true }
+        }
+      }
+      view = current.superview
+    }
+    return false
+  }
+
+  @objc private func handlePan(_ recognizer: UIPanGestureRecognizer) {
+    switch recognizer.state {
+    case .began:
+      gestureReturnOpen = displayLink != nil && !animationUser ? animationTarget : stableOpen
+      stopAnimation()
+      gestureStartProgress = progress
+    case .changed:
+      guard recognizer.numberOfTouches <= 1 else {
+        interruptGesture()
+        settle(to: gestureReturnOpen, velocity: 0, user: false)
+        return
+      }
+      setProgress(gestureStartProgress + recognizer.translation(in: self).x / max(1, bounds.width * 0.78))
+    case .ended:
+      let velocity = min(8, max(-8, recognizer.velocity(in: self).x / max(1, bounds.width * 0.78)))
+      settle(to: progress + velocity * 0.12 >= 0.5, velocity: velocity, user: true)
+    case .cancelled, .failed:
+      if !suppressCancellation { settle(to: gestureReturnOpen, velocity: 0, user: false) }
+    default: break
+    }
+  }
+
+  private func interruptGesture() {
+    guard pan != nil else { return }
+    suppressCancellation = true
+    pan.isEnabled = false
+    pan.isEnabled = true
+    touchTarget = nil
+    suppressCancellation = false
+  }
+
+  @objc private func closeFromUser() {
+    interruptGesture()
+    settle(to: false, velocity: 0, user: true)
+  }
+
+  private func setProgress(_ value: CGFloat) {
+    progress = min(1, max(0, enabled ? value : 0))
+    foreground.transform = CGAffineTransform(translationX: bounds.width * 0.78 * progress, y: 0)
+    foreground.layer.cornerRadius = 64 * progress
+    dim.alpha = 0.7 * progress
+    dim.isHidden = progress == 0
+    foregroundContent.isUserInteractionEnabled = progress == 0
+    foregroundContent.accessibilityElementsHidden = progress > 0
+    menu.transform = CGAffineTransform(translationX: -0.12 * bounds.width * 0.78 * (1 - progress), y: 0)
+    menuShade.alpha = 0.12 * (1 - progress)
+    menu.isHidden = progress == 0
+    menu.accessibilityElementsHidden = progress == 0
+  }
+
+  private func settle(to target: Bool, velocity: CGFloat, user: Bool) {
+    stopAnimation()
+    let target = enabled && target
+    guard bounds.width > 0, window != nil else {
+      stableOpen = target
+      setProgress(target ? 1 : 0)
+      return
+    }
+    if progress == (target ? 1 : 0) {
+      finish(target: target, user: user)
+      return
+    }
+    animationFrom = progress
+    animationVelocity = min(8, max(-8, velocity))
+    animationTarget = target
+    animationUser = user
+    animationStart = CACurrentMediaTime()
+    let link = CADisplayLink(target: self, selector: #selector(tick))
+    link.add(to: .main, forMode: .common)
+    displayLink = link
+  }
+
+  @objc private func tick() {
+    let elapsed = CGFloat(CACurrentMediaTime() - animationStart)
+    let target: CGFloat = animationTarget ? 1 : 0
+    let a = animationFrom - target
+    let b = animationVelocity + 22 * a
+    setProgress(target + (a + b * elapsed) * exp(-22 * elapsed))
+    if elapsed >= 0.5 {
+      let target = animationTarget
+      let user = animationUser
+      stopAnimation()
+      finish(target: target, user: user)
+    }
+  }
+
+  private func finish(target: Bool, user: Bool) {
+    let changed = stableOpen != target
+    stableOpen = target
+    setProgress(target ? 1 : 0)
+    if user && (changed || target != open) {
+      if hapticFeedbackEnabled && changed { UIImpactFeedbackGenerator(style: .light).impactOccurred() }
+      onDrawerOpenChange?(target)
+    }
+  }
+
+  private func stopAnimation() {
+    displayLink?.invalidate()
+    displayLink = nil
+  }
+
+  deinit { displayLink?.invalidate() }
+}