@symbiote-native/angular 3.3.0 → 3.5.0

package/src/components/keyboard-avoiding-view/index.ts

@@ -25,12 +25,8 @@ import {
   type OnInit,
 } from '@angular/core';
 import {
-  computeInset,
-  configureKeyboardAvoidingAnimation,
+  createKeyboardAvoidingModel,
   keyboardAvoidingEventNamesFor,
-  readKeyboardAnimationTiming,
-  readKeyboardFrame,
-  readLayoutFrame,
   readPrefersCrossFadeTransitions,
   resolveAccessibilityProps,
   resolveKeyboardAvoidingLayout,
@@ -39,12 +35,10 @@ import {
   type IAriaProps,
   type IKeyboardAvoidingBehavior,
   type IKeyboardAvoidingLayout,
-  type IMeasuredFrame,
 } from '@symbiote-native/components';
 import {
   Keyboard,
   Platform,
-  dlog,
   isSymbioteEvent,
   type IEventSubscription,
   type IStyleProp,
@@ -64,15 +58,15 @@ export type { IKeyboardAvoidingBehavior } from '@symbiote-native/components';
 // Mirrors React's IKeyboardAvoidingViewProps minus children (Angular takes children via
 // <ng-content>), declared per-adapter over the shared accessibility base since a framework-specific
 // children field keeps it from being fully shared across adapters.
-export interface IAngularKeyboardAvoidingViewProps
-  extends IAccessibilityProps, IAriaProps {
-  behavior?: IKeyboardAvoidingBehavior;
-  enabled?: boolean;
-  keyboardVerticalOffset?: number;
-  contentContainerStyle?: IStyleProp<IViewStyle>;
-  style?: IStyleProp<IViewStyle>;
-  onLayout?: (event: ISymbioteEvent) => void;
-}
+export type IAngularKeyboardAvoidingViewProps = IAccessibilityProps &
+  IAriaProps & {
+    behavior?: IKeyboardAvoidingBehavior;
+    enabled?: boolean;
+    keyboardVerticalOffset?: number;
+    contentContainerStyle?: IStyleProp<IViewStyle>;
+    style?: IStyleProp<IViewStyle>;
+    onLayout?: (event: ISymbioteEvent) => void;
+  };
 
 // What the component itself takes as plain @Input()s: the full surface minus onLayout and the
 // accessibility callbacks, which it exposes as real @Output() EventEmitters instead (see the
@@ -133,36 +127,41 @@ export class KeyboardAvoidingView
   @Input() testID?: string;
   @Input() nativeID?: string;
 
-  // How far the view must move so it no longer overlaps the keyboard. A plain field, not reactive:
-  // OnPush + zoneless means a keyboard event mutates it and pulls the view via markForCheck.
+  // Plain field, the model sets it and `markForCheck` pulls the OnPush view
   private inset = 0;
-  // Mutable, not state: changing the measured frame alone shouldn't re-render; it feeds the next
-  // keyboard event's inset math (React's frameRef / initialHeightRef, Vue's frame / initialHeight).
-  private frame?: IMeasuredFrame;
-  private initialHeight?: number;
-  // The iOS "Prefer Cross-Fade Transitions" setting, read once per mount. Deliberately a plain
-  // field and NOT markForCheck'd when the promise lands: it is a device setting that cannot change
-  // mid-session, and it feeds only the NEXT keyboard event's math — never the current render — so
-  // under zoneless CD there is nothing to repaint at resolve time. The keyboard event that does use
-  // it already calls markForCheck itself.
+  // A device setting that cannot change mid-session, learning it must not repaint
   private prefersCrossFadeTransitions = false;
   private subscriptions: IEventSubscription[] = [];
 
   private readonly changeDetector = inject(ChangeDetectorRef);
-  // This component's OWN host — the non-painting anchor `class="..."` at the use site resolves
-  // onto (see anchorHostStyle's doc comment) — NOT a ViewChild into the inner view (this
-  // component has none; the wrapper IS the outer template node hostProps binds onto).
+  // This component's own host, the anchor that `class` at the use site resolves onto
   private readonly elementRef = inject(ElementRef);
 
+  // Options are read at event time, т.к. an `@Input` can change under a live subscription
+  private readonly model = createKeyboardAvoidingModel({
+    options: () => ({
+      behavior: this.behavior,
+      enabled: this.enabled !== false,
+      keyboardVerticalOffset:
+        this.keyboardVerticalOffset ?? DEFAULT_VERTICAL_OFFSET,
+    }),
+    setInset: value => {
+      this.inset = value;
+      this.changeDetector.markForCheck();
+    },
+    prefersCrossFade: () => this.prefersCrossFadeTransitions,
+  });
+
   ngOnInit(): void {
-    // TWO events, picked per host, never three: iOS takes the will* pair so the view rides up with
-    // the keyboard animation, Android the did* pair. The change-frame notification is deliberately
-    // absent — with an undocked/split/floating iOS keyboard it fires BEFORE the hide, so listening
-    // to it applies a frame captured mid-dismissal (RN KeyboardAvoidingView.js's own comment).
+    // iOS takes the `will*` pair so the view rides up with the keyboard, Android the `did*` pair
     const events = keyboardAvoidingEventNamesFor(Platform.OS);
     this.subscriptions = [
-      Keyboard.addListener(events.show, payload => this.onShow(payload)),
-      Keyboard.addListener(events.hide, () => this.onHide()),
+      Keyboard.addListener(events.show, payload => {
+        this.model.keyboardShown(payload);
+        // An unchanged inset skips `setInset`, the event still has to carry a new `@Input` down
+        this.changeDetector.markForCheck();
+      }),
+      Keyboard.addListener(events.hide, this.model.keyboardHidden),
     ];
     // The core wrapper, not AccessibilityInfo directly: the engine's iOS getter REJECTS on a
     // native error (RN parity), and nobody awaits this read, so an unwrapped call would surface
@@ -177,47 +176,10 @@ export class KeyboardAvoidingView
     this.subscriptions = [];
   }
 
-  private onShow(payload: unknown): void {
-    const keyboard = readKeyboardFrame(payload);
-    const offset = this.keyboardVerticalOffset ?? DEFAULT_VERTICAL_OFFSET;
-    const next = computeInset(this.frame, keyboard, offset, {
-      // Read off the field at event time, not captured when the subscription was built: `behavior`
-      // is an @Input that can change under a long-lived subscription, and a stale one keeps
-      // applying the old mode's math (it gates the previous-inset correction below).
-      behavior: this.behavior,
-      // The inset CURRENTLY applied (RN's this.state.bottom), read off the field at event time so
-      // 'height' mode's fixpoint correction sees the live value: that mode SHRINKS the wrapper by
-      // the inset, so the next onLayout reports a frame shorter by exactly that much.
-      previousInset: this.inset,
-      prefersCrossFadeTransitions: this.prefersCrossFadeTransitions,
-    });
-    // RN's `_updateBottomIfNecessary` skips the animation when the inset did not change.
-    if (next !== this.inset)
-      configureKeyboardAvoidingAnimation(
-        readKeyboardAnimationTiming(payload),
-        this.enabled !== false,
-      );
-    dlog(`KeyboardAvoidingView show -> inset ${next}`);
-    this.inset = next;
-    this.changeDetector.markForCheck();
-  }
-
-  private onHide(): void {
-    dlog('KeyboardAvoidingView hide -> inset 0');
-    this.inset = 0;
-    this.changeDetector.markForCheck();
-  }
-
-  // The wrapper's onLayout measures the frame BEFORE forwarding to the caller's onLayout, so the
-  // next keyboard event's inset math has the view's real position (React/Vue's handleLayout).
+  // Measured before the caller's `layout` output fires
   handleLayout(event: unknown): void {
     if (!isSymbioteEvent(event)) return;
-    const measured = readLayoutFrame(event.nativeEvent.layout);
-    if (measured !== undefined) {
-      this.frame = measured;
-      if (this.initialHeight === undefined)
-        this.initialHeight = measured.height;
-    }
+    this.model.laidOut(event.nativeEvent.layout);
     this.layout.emit(event);
   }
 
@@ -227,14 +189,12 @@ export class KeyboardAvoidingView
     return this.enabled === false ? 0 : this.inset;
   }
 
-  // The behavior + effective inset → wrapper/inner styles and the nesting decision (the shared core
-  // of RN's render). Recomputed per CD pass, the Angular twin of React/Vue's per-render call.
-  // Named `resolvedLayout`, not `layout` — that name is now the onLayout @Output() EventEmitter.
+  // Not `layout`, that name is the `onLayout` output
   private get resolvedLayout(): IKeyboardAvoidingLayout {
     return resolveKeyboardAvoidingLayout({
       behavior: this.behavior,
       effectiveInset: this.effectiveInset,
-      initialHeight: this.initialHeight,
+      initialHeight: this.model.initialHeight(),
       style: this.style,
       contentContainerStyle: this.contentContainerStyle,
     });

package/src/components/layout-conformance-props.ts

@@ -0,0 +1,8 @@
+// The prop surface of `<layout-conformance>`, RN's `experimental_LayoutConformance`, for Angular
+// Children come through `<ng-content>`, so there is no `children` here
+import type { ILayoutConformanceMode } from '@symbiote-native/components';
+
+export type IAngularLayoutConformanceProps = {
+  // `strict` lays out by the W3C spec even where it breaks compatibility
+  mode: ILayoutConformanceMode;
+};

package/src/components/modal/index.ts

@@ -31,6 +31,7 @@ import {
   renderModal,
   resolveAccessibilityProps,
   shouldRenderModal,
+  warnAboutModalProps,
   type IAccessibilityProps,
   type IAriaProps,
   type IModalAnimationType,
@@ -42,11 +43,16 @@ import {
   dlog,
   isSymbioteEvent,
   Platform,
+  type IColorValue,
   type IStyleProp,
   type ISymbioteEvent,
   type IViewStyle,
 } from '@symbiote-native/engine';
 import { AccessibilityEventsBase } from '../../accessibility-events';
+import {
+  ListScopeProvider,
+  NO_LIST_SCOPE,
+} from '../virtualized-list/nested-scope';
 import {
   anchorHostStyle,
   ModalHost,
@@ -63,25 +69,26 @@ export type {
 } from '@symbiote-native/components';
 
 // Mirrors React's IModalProps minus children (Angular takes children via <ng-content>).
-export interface IAngularModalProps extends IAccessibilityProps, IAriaProps {
-  visible?: boolean;
-  transparent?: boolean;
-  backdropColor?: string;
-  animationType?: IModalAnimationType;
-  presentationStyle?: IModalPresentationStyle;
-  supportedOrientations?: ReadonlyArray<IModalOrientation>;
-  hardwareAccelerated?: boolean;
-  statusBarTranslucent?: boolean;
-  navigationBarTranslucent?: boolean;
-  allowSwipeDismissal?: boolean;
-  onShow?: () => void;
-  onDismiss?: () => void;
-  onRequestClose?: () => void;
-  // The engine hands every listener the ISymbioteEvent wrapper, so the orientation is read at
-  // event.nativeEvent.orientation (IModalOrientationChangeEvent describes that payload).
-  onOrientationChange?: (event: ISymbioteEvent) => void;
-  style?: IStyleProp<IViewStyle>;
-}
+export type IAngularModalProps = IAccessibilityProps &
+  IAriaProps & {
+    visible?: boolean;
+    transparent?: boolean;
+    backdropColor?: IColorValue;
+    animationType?: IModalAnimationType;
+    presentationStyle?: IModalPresentationStyle;
+    supportedOrientations?: ReadonlyArray<IModalOrientation>;
+    hardwareAccelerated?: boolean;
+    statusBarTranslucent?: boolean;
+    navigationBarTranslucent?: boolean;
+    allowSwipeDismissal?: boolean;
+    onShow?: () => void;
+    onDismiss?: () => void;
+    onRequestClose?: () => void;
+    // The engine hands every listener the ISymbioteEvent wrapper, so the orientation is read at
+    // event.nativeEvent.orientation (IModalOrientationChangeEvent describes that payload).
+    onOrientationChange?: (event: ISymbioteEvent) => void;
+    style?: IStyleProp<IViewStyle>;
+  };
 
 // What the Modal component itself takes as plain @Input()s: the full surface minus the
 // show/dismiss/close/orientation and accessibility events, which it exposes as real @Output()
@@ -107,6 +114,8 @@ export type IAngularModalInputs = Omit<
   ],
   schemas: [CUSTOM_ELEMENTS_SCHEMA],
   imports: [ModalHost, ViewHost, SymbioteHostPropsDirective],
+  // The content sits outside the list's scroll, so a list in it is not nested in that list
+  providers: [{ provide: ListScopeProvider, useValue: NO_LIST_SCOPE }],
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `
     @if (shouldRender) {
@@ -133,7 +142,7 @@ export class Modal
   @Output() readonly requestClose = new EventEmitter<void>();
   @Input() visible?: boolean;
   @Input() transparent?: boolean;
-  @Input() backdropColor?: string;
+  @Input() backdropColor?: IColorValue;
   @Input() animationType?: IModalAnimationType;
   @Input() presentationStyle?: IModalPresentationStyle;
   @Input() supportedOrientations?: ReadonlyArray<IModalOrientation>;
@@ -160,6 +169,18 @@ export class Modal
     this.state = createInitialModalState(isModalVisible(this.visible));
   }
 
+  // RN checks on mount and on every update, a dev build only
+  private warnOnMisuse(): void {
+    warnAboutModalProps({
+      presentationStyle: this.presentationStyle,
+      transparent: this.transparent,
+      navigationBarTranslucent: this.navigationBarTranslucent,
+      statusBarTranslucent: this.statusBarTranslucent,
+      allowSwipeDismissal: this.allowSwipeDismissal,
+      onRequestClose: this.requestClose.observed,
+    });
+  }
+
   // Bridges the non-reactive @Input fields `hostProps` reads into the reactive graph, so it can
   // memoize. Plain fields read inside a computed() are UNTRACKED - something must signal "a
   // dependency changed" or the bag goes stale. Signal inputs would do this natively, but `input()`
@@ -174,6 +195,7 @@ export class Modal
     // Before the keep-alive early-return below: this is the single moment Angular has finished
     // writing every changed @Input, and `hostProps` depends on far more than `visible`.
     this.hostPropsRevision.update(revision => revision + 1);
+    this.warnOnMisuse();
     const visibleChange = changes.visible;
     // First change is reflected by the ngOnInit seed; only later toggles drive the keep-alive.
     if (visibleChange === undefined || visibleChange.firstChange) return;

package/src/components/refresh-control-props.ts

@@ -13,29 +13,33 @@ import type {
   IAccessibilityProps,
   IAriaProps,
 } from '@symbiote-native/components';
-import type { IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type {
+  IColorValue,
+  IStyleProp,
+  IViewStyle,
+} from '@symbiote-native/engine';
 
-export interface IAngularRefreshControlProps
-  extends IAccessibilityProps, IAriaProps {
-  refreshing: boolean;
-  // `id` — RN's W3C alias for `nativeID`, folded by the spec entry's ID_ALIAS.
-  id?: string;
-  // RN's onRefresh is `() => void | Promise<void>`, the handler may be async; the promise is
-  // fire-and-forget (native already starts refreshing on the gesture).
-  onRefresh?: () => void | Promise<void>;
-  tintColor?: string;
-  title?: string;
-  titleColor?: string;
-  progressViewOffset?: number;
-  // Android-only spinner styling (RN RefreshControlPropsAndroid): `colors` are the indicator's
-  // animated stroke colors, `progressBackgroundColor` the disc behind it, `size` the diameter
-  // preset. AndroidSwipeRefreshLayout reads them; PullToRefreshView on iOS ignores unknown props.
-  colors?: readonly string[];
-  progressBackgroundColor?: string;
-  size?: 'default' | 'large';
-  // Android-only native prop forwarded to AndroidSwipeRefreshLayout; iOS native never reads it.
-  enabled?: boolean;
-  // The Android scroll-view wrap injects the layout half of the style onto this host; iOS leaves it
-  // unset (the RefreshControl is a childless sibling). Harmless to forward on both.
-  style?: IStyleProp<IViewStyle>;
-}
+export type IAngularRefreshControlProps = IAccessibilityProps &
+  IAriaProps & {
+    refreshing: boolean;
+    // `id` — RN's W3C alias for `nativeID`, folded by the spec entry's ID_ALIAS.
+    id?: string;
+    // RN's onRefresh is `() => void | Promise<void>`, the handler may be async; the promise is
+    // fire-and-forget (native already starts refreshing on the gesture).
+    onRefresh?: () => void | Promise<void>;
+    tintColor?: IColorValue;
+    title?: string;
+    titleColor?: IColorValue;
+    progressViewOffset?: number;
+    // Android-only spinner styling (RN RefreshControlPropsAndroid): `colors` are the indicator's
+    // animated stroke colors, `progressBackgroundColor` the disc behind it, `size` the diameter
+    // preset. AndroidSwipeRefreshLayout reads them; PullToRefreshView on iOS ignores unknown props.
+    colors?: readonly IColorValue[];
+    progressBackgroundColor?: IColorValue;
+    size?: 'default' | 'large';
+    // Android-only native prop forwarded to AndroidSwipeRefreshLayout; iOS native never reads it.
+    enabled?: boolean;
+    // The Android scroll-view wrap injects the layout half of the style onto this host; iOS leaves it
+    // unset (the RefreshControl is a childless sibling). Harmless to forward on both.
+    style?: IStyleProp<IViewStyle>;
+  };

package/src/components/scroll-view-props.ts

@@ -15,8 +15,11 @@
 import type {
   IAccessibilityProps,
   IAriaProps,
+  IInnerViewRef,
+  IScrollViewNativeOnlyProps,
 } from '@symbiote-native/components';
 import type {
+  IColorValue,
   IStyleProp,
   ISymbioteEvent,
   IViewStyle,
@@ -27,80 +30,85 @@ export type { IScrollViewHandle } from '@symbiote-native/components';
 type IScrollHandler = (event: ISymbioteEvent) => void;
 type IContentSizeHandler = (width: number, height: number) => void;
 
-export interface IAngularScrollViewProps
-  extends IAccessibilityProps, IAriaProps {
-  style?: IStyleProp<IViewStyle>;
-  // A bare string resolves through the shared style registry, like `class` on the host node.
-  contentContainerStyle?: IStyleProp<IViewStyle> | string;
-  scrollEnabled?: boolean;
-  showsVerticalScrollIndicator?: boolean;
-  showsHorizontalScrollIndicator?: boolean;
-  pagingEnabled?: boolean;
-  bounces?: boolean;
-  decelerationRate?: 'normal' | 'fast' | number;
-  scrollEventThrottle?: number;
-  contentInset?: {
-    top?: number;
-    left?: number;
-    bottom?: number;
-    right?: number;
+export type IAngularScrollViewProps = IAccessibilityProps &
+  IAriaProps &
+  IScrollViewNativeOnlyProps & {
+    style?: IStyleProp<IViewStyle>;
+    // A bare string resolves through the shared style registry, like `class` on the host node.
+    contentContainerStyle?: IStyleProp<IViewStyle> | string;
+    scrollEnabled?: boolean;
+    showsVerticalScrollIndicator?: boolean;
+    showsHorizontalScrollIndicator?: boolean;
+    pagingEnabled?: boolean;
+    bounces?: boolean;
+    decelerationRate?: 'normal' | 'fast' | number;
+    scrollEventThrottle?: number;
+    contentInset?: {
+      top?: number;
+      left?: number;
+      bottom?: number;
+      right?: number;
+    };
+    contentOffset?: { x: number; y: number };
+    removeClippedSubviews?: boolean;
+    snapToInterval?: number;
+    snapToOffsets?: number[];
+    snapToAlignment?: 'start' | 'center' | 'end';
+    snapToStart?: boolean;
+    snapToEnd?: boolean;
+    disableIntervalMomentum?: boolean;
+    experimental_endDraggingSensitivityMultiplier?: number;
+    // Sticky headers: RN implements stickiness PURELY IN JS — the native scroll view does not honor
+    // an index array. The engine's behavior resolves the indices against its own content children.
+    stickyHeaderIndices?: number[];
+    invertStickyHeaders?: boolean;
+    stickyHeaderHiddenOnScroll?: boolean;
+    // Gets the content view after the first commit and null when it goes away
+    innerViewRef?: IInnerViewRef;
+    keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+    keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
+    maintainVisibleContentPosition?: {
+      minIndexForVisible: number;
+      autoscrollToTopThreshold?: number;
+    };
+    // iOS-only forwarding props (harmless on Android: its manager ignores unknown props).
+    alwaysBounceHorizontal?: boolean;
+    alwaysBounceVertical?: boolean;
+    centerContent?: boolean;
+    scrollIndicatorInsets?: {
+      top?: number;
+      left?: number;
+      bottom?: number;
+      right?: number;
+    };
+    indicatorStyle?: 'default' | 'black' | 'white';
+    directionalLockEnabled?: boolean;
+    automaticallyAdjustKeyboardInsets?: boolean;
+    contentInsetAdjustmentBehavior?:
+      'automatic' | 'scrollableAxes' | 'never' | 'always';
+    minimumZoomScale?: number;
+    maximumZoomScale?: number;
+    zoomScale?: number;
+    bouncesZoom?: boolean;
+    pinchGestureEnabled?: boolean;
+    // Android-only forwarding props (harmless on iOS).
+    nestedScrollEnabled?: boolean;
+    overScrollMode?: 'auto' | 'always' | 'never';
+    fadingEdgeLength?: number;
+    persistentScrollbar?: boolean;
+    endFillColor?: IColorValue;
+    onLayout?: IScrollHandler;
+    onScroll?: IScrollHandler;
+    onScrollBeginDrag?: IScrollHandler;
+    onScrollEndDrag?: IScrollHandler;
+    onMomentumScrollBegin?: IScrollHandler;
+    onMomentumScrollEnd?: IScrollHandler;
+    // iOS-only: user tapped the status bar to scroll to top. Inert on Android.
+    onScrollToTop?: IScrollHandler;
+    // Synthesized in JS from the content view's onLayout (RN _handleContentOnLayout); deduped.
+    onContentSizeChange?: IContentSizeHandler;
+    onAccessibilityAction?: (event: ISymbioteEvent) => void;
+    onAccessibilityTap?: (event: ISymbioteEvent) => void;
+    onMagicTap?: (event: ISymbioteEvent) => void;
+    onAccessibilityEscape?: (event: ISymbioteEvent) => void;
   };
-  contentOffset?: { x: number; y: number };
-  removeClippedSubviews?: boolean;
-  snapToInterval?: number;
-  snapToOffsets?: number[];
-  snapToAlignment?: 'start' | 'center' | 'end';
-  snapToStart?: boolean;
-  snapToEnd?: boolean;
-  disableIntervalMomentum?: boolean;
-  // Sticky headers: RN implements stickiness PURELY IN JS — the native scroll view does not honor
-  // an index array. The engine's behavior resolves the indices against its own content children.
-  stickyHeaderIndices?: number[];
-  invertStickyHeaders?: boolean;
-  keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
-  keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
-  maintainVisibleContentPosition?: {
-    minIndexForVisible: number;
-    autoscrollToTopThreshold?: number;
-  };
-  // iOS-only forwarding props (harmless on Android: its manager ignores unknown props).
-  alwaysBounceHorizontal?: boolean;
-  alwaysBounceVertical?: boolean;
-  centerContent?: boolean;
-  scrollIndicatorInsets?: {
-    top?: number;
-    left?: number;
-    bottom?: number;
-    right?: number;
-  };
-  indicatorStyle?: 'default' | 'black' | 'white';
-  directionalLockEnabled?: boolean;
-  automaticallyAdjustKeyboardInsets?: boolean;
-  contentInsetAdjustmentBehavior?:
-    'automatic' | 'scrollableAxes' | 'never' | 'always';
-  minimumZoomScale?: number;
-  maximumZoomScale?: number;
-  zoomScale?: number;
-  bouncesZoom?: boolean;
-  pinchGestureEnabled?: boolean;
-  // Android-only forwarding props (harmless on iOS).
-  nestedScrollEnabled?: boolean;
-  overScrollMode?: 'auto' | 'always' | 'never';
-  fadingEdgeLength?: number;
-  persistentScrollbar?: boolean;
-  endFillColor?: string;
-  onLayout?: IScrollHandler;
-  onScroll?: IScrollHandler;
-  onScrollBeginDrag?: IScrollHandler;
-  onScrollEndDrag?: IScrollHandler;
-  onMomentumScrollBegin?: IScrollHandler;
-  onMomentumScrollEnd?: IScrollHandler;
-  // iOS-only: user tapped the status bar to scroll to top. Inert on Android.
-  onScrollToTop?: IScrollHandler;
-  // Synthesized in JS from the content view's onLayout (RN _handleContentOnLayout); deduped.
-  onContentSizeChange?: IContentSizeHandler;
-  onAccessibilityAction?: (event: ISymbioteEvent) => void;
-  onAccessibilityTap?: (event: ISymbioteEvent) => void;
-  onMagicTap?: (event: ISymbioteEvent) => void;
-  onAccessibilityEscape?: (event: ISymbioteEvent) => void;
-}