@symbiote-native/angular 3.1.2 → 3.2.0

package/src/components/virtualized-section-list/index.ts

@@ -1,22 +1,6 @@
-// VirtualizedSectionList, the Angular wrapper that flattens sections into one virtualized stream
-// over VirtualizedList. Each section contributes a header row, its item rows, then a footer row
-// (RN counts 2 per section); the flattened tagged sequence is fed to VirtualizedList as one list,
-// so headers/items/footers are all windowed by the same machinery. The flattening, entry keying,
-// separator-item unwrap, and scrollToLocation mapping are shared from @symbiote-native/components; this
-// file wires Angular's lifecycle (typed @Input/@Output surface + the imperative handle + the
-// per-cell-tag template dispatch). The Angular twin of the React/Vue adapters' VirtualizedSectionList.
-//
-// The KEY mechanic — per-cell-tag template dispatch. VirtualizedList renders every cell through ONE
-// `vListItem` template, but a section list has DIFFERENT cell types (section header, item, section
-// footer, between-section separators). So VSL supplies the inner list a SINGLE synthesized
-// `vListItem` template that @switch-es on the flattened entry's tag and stamps the matching app
-// template (captured via @ContentChild on the vSection* directives) through VListOutletDirective.
-// list-level header/footer/empty/item-separator reuse VirtualizedList's own directives, forwarded
-// the same way. Only the cell-AUTHORING shape is framework-specific; the rest of the surface
-// stays shared with React/Vue.
-//
-// Accessibility / aria props are forwarded unchanged to the inner VirtualizedList, which owns the
-// shared aria→accessibility* fold before the props reach the ScrollView host.
+// VirtualizedSectionList flattens sections into one virtualized stream over VirtualizedList
+// Flattening, entry keying and `scrollToLocation` are shared from `@symbiote-native/components`
+// This file is the Angular lifecycle and the per-entry template dispatch
 
 import {
   ChangeDetectionStrategy,
@@ -24,9 +8,7 @@ import {
   Component,
   ContentChild,
   ElementRef,
-  EventEmitter,
   Input,
-  Output,
   ViewChild,
   inject,
   type DoCheck,
@@ -38,7 +20,6 @@ import {
   sectionEntryKey,
   unwrapEntryItem,
   type IAccessibilityProps,
-  type IAccessibilityStateValue,
   type IAriaProps,
   type ISection,
   type ISectionEntry,
@@ -64,6 +45,8 @@ import {
   type IVListSeparatorContext,
 } from '../virtualized-list';
 import { VListOutletDirective } from '../virtualized-list/directives';
+import { ListEventsBase } from '../virtualized-list/list-events';
+import { provideGateDemand } from '../../gate-demand';
 import {
   stableAnchorStyle,
   SymbioteStyleInputDirective,
@@ -76,48 +59,32 @@ import {
   type IVSectionContext,
   type IVSectionItemContext,
 } from './directives';
+import { VIRTUALIZED_SECTION_LIST_TEMPLATE } from './section-list-template';
 
 export type { ISection } from '@symbiote-native/components';
-// Re-export the shared handle type so section-list imports it from '../virtualized-section-list'.
 export type { IVirtualizedSectionListHandle } from '@symbiote-native/components';
-// Re-export the section authoring directives + their contexts so flat consumers (and SectionList)
-// import them from '../virtualized-section-list', mirroring how VirtualizedList re-exports its own.
 export {
   VSectionFooterDirective,
   VSectionHeaderDirective,
   VSectionItemDirective,
   VSectionSeparatorDirective,
 } from './directives';
-import {
-  gateWanted,
-  injectGateDemandAbove,
-  provideGateDemand,
-  type IGatedAccessibilityEvent,
-} from '../../gate-demand';
 export type { IVSectionContext, IVSectionItemContext } from './directives';
 
-// The Angular VirtualizedSectionList prop surface. Mirrors React/Vue's IVirtualizedSectionListProps
-// MINUS the element-returning props (renderItem, renderSectionHeader/Footer, the *Component slots):
-// those are the per-adapter children/render fields and become `<ng-template>` directives in Angular.
-// Everything agnostic is the SAME surface as the
-// React/Vue adapters, including the a11y/aria prop family forwarded through VirtualizedList.
+type IItemLayout = { length: number; offset: number; index: number };
+
+// The React and Vue surface minus element-returning props, which are `<ng-template>` here
 export interface IVirtualizedSectionListProps<ItemT>
   extends IAccessibilityProps, IAriaProps {
   sections: ReadonlyArray<ISection<ItemT>>;
   keyExtractor?: (item: ItemT, index: number) => string;
-  // Fixed-layout fast path, FLAT like RN's: the SECTIONS array plus a flat entry index, where every
-  // section contributes two rows beyond its items (header, footer) and the caller accounts for them.
-  // A `({ section, index })` form would be our invention, not parity - `VirtualizedSectionList.js`
-  // has no getItemLayout code at all, the prop rides through `passThroughProps`; that shape is the
-  // community react-native-section-list-get-item-layout, layered on top. Without it a fast scroll
-  // outruns measurement and leaves blank windows.
+  // Flat like RN's: the sections array plus a flat entry index, where every section adds two rows
+  // beyond its items (header, footer). Without it a fast scroll outruns measurement
   getItemLayout?: (
     data: ReadonlyArray<ISection<ItemT>> | null,
     index: number,
-  ) => { length: number; offset: number; index: number };
-  // Stick each section header to the top as the next section scrolls up. Routed to the inner
-  // VirtualizedList's stickyHeaderIndices. Defaults to `Platform.OS === 'ios'`; Android does not
-  // stick by default. Pass true/false to override.
+  ) => IItemLayout;
+  // Defaults to `Platform.OS === 'ios'`, pass true or false to override
   stickySectionHeadersEnabled?: boolean;
   extraData?: unknown;
   onEndReached?: (info: { distanceFromEnd: number }) => void;
@@ -151,9 +118,7 @@ export interface IVirtualizedSectionListProps<ItemT>
   contentContainerStyle?: IStyleProp<IViewStyle>;
 }
 
-// What the VirtualizedSectionList component itself takes as plain @Input()s: the full surface
-// minus the list-lifecycle events, which it exposes as real @Output() EventEmitters instead (see
-// the class below) — mirrors IAngularPressableInputs in pressable/index.ts.
+// The plain inputs: the full surface minus the events exposed as real outputs
 export type IVirtualizedSectionListInputs<ItemT> = Omit<
   IVirtualizedSectionListProps<ItemT>,
   | 'onEndReached'
@@ -182,155 +147,10 @@ export type IVirtualizedSectionListInputs<ItemT> = Omit<
     VListOutletDirective,
   ],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `
-    <VirtualizedList
-      [data]="flatEntries"
-      [getItem]="getEntry"
-      [getItemCount]="getEntryCount"
-      [keyExtractor]="entryKeyExtractor"
-      [getItemLayout]="entryItemLayout"
-      [stickyHeaderIndices]="stickyHeaderIndices"
-      [extraData]="extraData"
-      [inverted]="inverted"
-      [refreshing]="refreshing"
-      [progressViewOffset]="progressViewOffset"
-      [refreshRequested]="refreshRequested ?? refresh.observed"
-      (refresh)="resolvedOnRefresh?.()"
-      (endReached)="resolvedOnEndReached?.($event)"
-      [onEndReachedThreshold]="onEndReachedThreshold"
-      (startReached)="resolvedOnStartReached?.($event)"
-      [onStartReachedThreshold]="onStartReachedThreshold"
-      [initialNumToRender]="initialNumToRender"
-      [initialScrollIndex]="initialScrollIndex"
-      [maxToRenderPerBatch]="maxToRenderPerBatch"
-      [updateCellsBatchingPeriod]="updateCellsBatchingPeriod"
-      [windowSize]="windowSize"
-      [maintainVisibleContentPosition]="maintainVisibleContentPosition"
-      [onScroll]="onScroll"
-      [onScrollBeginDrag]="onScrollBeginDrag"
-      [onScrollEndDrag]="onScrollEndDrag"
-      [onMomentumScrollBegin]="onMomentumScrollBegin"
-      [onMomentumScrollEnd]="onMomentumScrollEnd"
-      [scrollEventThrottle]="scrollEventThrottle"
-      [keyboardShouldPersistTaps]="keyboardShouldPersistTaps"
-      [keyboardDismissMode]="keyboardDismissMode"
-      [removeClippedSubviews]="removeClippedSubviews"
-      [nestedScrollEnabled]="nestedScrollEnabled"
-      [style]="resolvedStyle"
-      [contentContainerStyle]="contentContainerStyle"
-      [testID]="testID"
-      [nativeID]="nativeID"
-      [accessible]="accessible"
-      [accessibilityLabel]="accessibilityLabel"
-      [accessibilityHint]="accessibilityHint"
-      [accessibilityRole]="accessibilityRole"
-      [accessibilityState]="accessibilityState"
-      [accessibilityValue]="accessibilityValue"
-      [accessibilityActions]="accessibilityActions"
-      [accessibilityLabelledBy]="accessibilityLabelledBy"
-      [importantForAccessibility]="importantForAccessibility"
-      [accessibilityLiveRegion]="accessibilityLiveRegion"
-      [screenReaderFocusable]="screenReaderFocusable"
-      [accessibilityViewIsModal]="accessibilityViewIsModal"
-      [accessibilityElementsHidden]="accessibilityElementsHidden"
-      [accessibilityIgnoresInvertColors]="accessibilityIgnoresInvertColors"
-      [accessibilityLanguage]="accessibilityLanguage"
-      [accessibilityRespondsToUserInteraction]="
-        accessibilityRespondsToUserInteraction
-      "
-      [accessibilityShowsLargeContentViewer]="
-        accessibilityShowsLargeContentViewer
-      "
-      [accessibilityLargeContentTitle]="accessibilityLargeContentTitle"
-      (accessibilityAction)="resolvedOnAccessibilityAction?.($event)"
-      (accessibilityTap)="resolvedOnAccessibilityTap?.($event)"
-      (magicTap)="resolvedOnMagicTap?.($event)"
-      (accessibilityEscape)="resolvedOnAccessibilityEscape?.($event)"
-      [role]="role"
-      [ariaLabel]="ariaLabel"
-      [ariaLabelledBy]="ariaLabelledBy"
-      [ariaLive]="ariaLive"
-      [ariaHidden]="ariaHidden"
-      [ariaBusy]="ariaBusy"
-      [ariaChecked]="ariaChecked"
-      [ariaDisabled]="ariaDisabled"
-      [ariaExpanded]="ariaExpanded"
-      [ariaSelected]="ariaSelected"
-      [ariaModal]="ariaModal"
-      [ariaValueMax]="ariaValueMax"
-      [ariaValueMin]="ariaValueMin"
-      [ariaValueNow]="ariaValueNow"
-      [ariaValueText]="ariaValueText"
-    >
-      <!-- The single synthesized cell template: dispatch per flattened entry tag. -->
-      <ng-template vListItem let-entry let-separators="separators">
-        @switch (entryKind(entry)) {
-          @case ('header') {
-            <ng-container
-              [vListOutlet]="sectionHeaderDir?.templateRef"
-              [vListOutletContext]="sectionContextOf(entry)"
-            ></ng-container>
-          }
-          @case ('footer') {
-            <ng-container
-              [vListOutlet]="sectionFooterDir?.templateRef"
-              [vListOutletContext]="sectionContextOf(entry)"
-            ></ng-container>
-          }
-          @case ('section-separator') {
-            <ng-container
-              [vListOutlet]="sectionSeparatorDir?.templateRef"
-            ></ng-container>
-          }
-          @case ('item') {
-            <ng-container
-              [vListOutlet]="sectionItemDir?.templateRef"
-              [vListOutletContext]="itemContextOf(entry, separators)"
-            ></ng-container>
-          }
-        }
-      </ng-template>
-
-      <!-- list-level slots: forward the app's VirtualizedList directives to the inner list. -->
-      @if (listHeaderDir !== undefined) {
-        <ng-template vListHeader>
-          <ng-container
-            [vListOutlet]="listHeaderDir.templateRef"
-          ></ng-container>
-        </ng-template>
-      }
-      @if (listFooterDir !== undefined) {
-        <ng-template vListFooter>
-          <ng-container
-            [vListOutlet]="listFooterDir.templateRef"
-          ></ng-container>
-        </ng-template>
-      }
-      @if (listEmptyDir !== undefined) {
-        <ng-template vListEmpty>
-          <ng-container [vListOutlet]="listEmptyDir.templateRef"></ng-container>
-        </ng-template>
-      }
-      <!-- item separator: forward, unwrapping each flattened entry back to its ItemT. -->
-      @if (itemSeparatorDir !== undefined) {
-        <ng-template
-          vListSeparator
-          let-highlighted
-          let-leadingItem="leadingItem"
-          let-trailingItem="trailingItem"
-        >
-          <ng-container
-            [vListOutlet]="itemSeparatorDir.templateRef"
-            [vListOutletContext]="
-              itemSeparatorContextOf(highlighted, leadingItem, trailingItem)
-            "
-          ></ng-container>
-        </ng-template>
-      }
-    </VirtualizedList>
-  `,
+  template: VIRTUALIZED_SECTION_LIST_TEMPLATE,
 })
 export class VirtualizedSectionList<ItemT = unknown>
+  extends ListEventsBase
   implements
     IVirtualizedSectionListInputs<ItemT>,
     IVirtualizedSectionListHandle,
@@ -341,24 +161,15 @@ export class VirtualizedSectionList<ItemT = unknown>
   @Input() getItemLayout?: (
     data: ReadonlyArray<ISection<ItemT>> | null,
     index: number,
-  ) => { length: number; offset: number; index: number };
+  ) => IItemLayout;
   @Input() stickySectionHeadersEnabled?: boolean;
   @Input() extraData?: unknown;
-  @Output() readonly endReached = new EventEmitter<{
-    distanceFromEnd: number;
-  }>();
   @Input() onEndReachedThreshold?: number;
-  @Output() readonly startReached = new EventEmitter<{
-    distanceFromStart: number;
-  }>();
   @Input() onStartReachedThreshold?: number;
-  @Output() readonly refresh = new EventEmitter<void>();
   @Input() refreshing?: boolean | null;
   @Input() progressViewOffset?: number;
-  // See VirtualizedList's own refreshRequested doc comment: `(refresh)="resolvedOnRefresh?.()"`
-  // above always subscribes to the inner VirtualizedList's refresh output (to re-forward it),
-  // which would otherwise make its `.observed` permanently true. SectionList passes ITS OWN
-  // public `refresh.observed` here; direct usage falls back to this component's own `.observed`.
+  // The template always subscribes to the inner list's refresh to re-forward it, which keeps that
+  // `.observed` true. `SectionList` passes its own public `refresh.observed` here instead
   @Input() refreshRequested?: boolean;
   @Input() initialNumToRender?: number;
   @Input() initialScrollIndex?: number;
@@ -385,17 +196,8 @@ export class VirtualizedSectionList<ItemT = unknown>
   @Input() testID?: string;
   @Input() nativeID?: string;
 
-  // Bound to the template's `[style]="resolvedStyle"`, which Angular compiles to the built-in
-  // ɵɵstyleMap instruction — it only understands a flat object, never an array (RN's own
-  // `style={[a, b]}` composition idiom crashes deep inside Angular's styling engine), so this
-  // flattens `style` via the engine's own flattenStyle before it ever reaches that binding.
-  // anchorHostStyle merges in this component's OWN anchor's class-derived style (see its doc
-  // comment) — `elementRef` below is VirtualizedSectionList's OWN host, not `list`'s inner
-  // VirtualizedList. A plain `flattenStyle([...])` here would allocate a FRESH object on every
-  // getter read, which — bound onto the inner VirtualizedList's own `@Input() style` — defeats
-  // its `ngDoCheck` dedup gate and free-runs change detection forever (see stableAnchorStyle's
-  // doc comment and the `flat-list-array-style.test.ts` regression it fixes).
-  // `cachedResolvedStyle` is the getter's own persisted "previous" value across reads.
+  // A flat object bound to `[style]`, merged with this host's own class-derived style. A fresh
+  // object per read would defeat the inner list's dedup gate, `stableAnchorStyle` keeps it steady
   private cachedResolvedStyle: Record<string, unknown> | undefined;
   get resolvedStyle(): IViewStyle {
     this.cachedResolvedStyle = stableAnchorStyle(
@@ -405,59 +207,8 @@ export class VirtualizedSectionList<ItemT = unknown>
     );
     return this.cachedResolvedStyle;
   }
-  @Input() accessible?: boolean;
-  @Input() accessibilityLabel?: string;
-  @Input() accessibilityHint?: string;
-  @Input() accessibilityRole?: IAccessibilityProps['accessibilityRole'];
-  @Input() accessibilityState?: IAccessibilityStateValue;
-  @Input() accessibilityValue?: IAccessibilityProps['accessibilityValue'];
-  @Input() accessibilityActions?: IAccessibilityProps['accessibilityActions'];
-  @Input() accessibilityLabelledBy?: string | string[];
-  @Input()
-  importantForAccessibility?: IAccessibilityProps['importantForAccessibility'];
-  @Input()
-  accessibilityLiveRegion?: IAccessibilityProps['accessibilityLiveRegion'];
-  @Input() screenReaderFocusable?: boolean;
-  @Input() accessibilityViewIsModal?: boolean;
-  @Input() accessibilityElementsHidden?: boolean;
-  @Input() accessibilityIgnoresInvertColors?: boolean;
-  @Input() accessibilityLanguage?: string;
-  @Input() accessibilityRespondsToUserInteraction?: boolean;
-  @Input() accessibilityShowsLargeContentViewer?: boolean;
-  @Input() accessibilityLargeContentTitle?: string;
-  @Output() readonly accessibilityAction = new EventEmitter<ISymbioteEvent>();
-  @Output() readonly accessibilityTap = new EventEmitter<ISymbioteEvent>();
-  @Output() readonly magicTap = new EventEmitter<ISymbioteEvent>();
-  @Output() readonly accessibilityEscape = new EventEmitter<ISymbioteEvent>();
-
-  // This wrapper binds the four gated accessibility events on the component it renders, which
-  // Angular forces to be unconditional and which would light that component's gates on every
-  // instance. It answers for them instead — see `gate-demand.ts`.
-  private readonly gateDemandAbove = injectGateDemandAbove();
-
-  wantsGate(name: IGatedAccessibilityEvent): boolean {
-    return gateWanted(this.gateDemandAbove, name, this[name]);
-  }
 
-  @Input() role?: IAriaProps['role'];
-  @Input() ariaLabel?: string;
-  @Input() ariaLabelledBy?: string;
-  @Input() ariaLive?: IAriaProps['aria-live'];
-  @Input() ariaHidden?: boolean;
-  @Input() ariaBusy?: boolean;
-  @Input() ariaChecked?: boolean | 'mixed';
-  @Input() ariaDisabled?: boolean;
-  @Input() ariaExpanded?: boolean;
-  @Input() ariaSelected?: boolean;
-  @Input() ariaModal?: boolean;
-  @Input() ariaValueMax?: number;
-  @Input() ariaValueMin?: number;
-  @Input() ariaValueNow?: number;
-  @Input() ariaValueText?: string;
-
-  // The section cell templates the app authors (the Angular twin of renderItem /
-  // renderSectionHeader / renderSectionFooter / SectionSeparatorComponent), captured from projected
-  // <ng-template> content and stamped by the synthesized vListItem dispatch.
+  // The section cell templates the app authors, stamped by the synthesized entry dispatch
   @ContentChild(VSectionItemDirective)
   sectionItemDir?: VSectionItemDirective<ItemT>;
   @ContentChild(VSectionHeaderDirective)
@@ -467,33 +218,27 @@ export class VirtualizedSectionList<ItemT = unknown>
   @ContentChild(VSectionSeparatorDirective)
   sectionSeparatorDir?: VSectionSeparatorDirective;
 
-  // list-level slots reuse VirtualizedList's own directives; VSL forwards them to the inner list.
+  // List-level slots reuse the `VirtualizedList` directives and are forwarded to the inner list
   @ContentChild(VListHeaderDirective) listHeaderDir?: VListHeaderDirective;
   @ContentChild(VListFooterDirective) listFooterDir?: VListFooterDirective;
   @ContentChild(VListEmptyDirective) listEmptyDir?: VListEmptyDirective;
   @ContentChild(VListSeparatorDirective)
   itemSeparatorDir?: VListSeparatorDirective<ItemT>;
 
-  // The composed inner VirtualizedList. Its instance IS an IVirtualizedListHandle, so the section
-  // handle delegates straight to it. Available from ngAfterViewInit; reads lazily, no-ops pre-commit.
+  // The inner list, whose instance is the scroll handle, reads lazily and no-ops before commit
   @ViewChild(VirtualizedList) private list?: VirtualizedList<
     ISectionEntry<ItemT>
   >;
 
-  // This component's OWN host — the non-painting anchor `class="..."` at the use site resolves
-  // onto (see anchorHostStyle's doc comment) — NOT `list` above, which targets the real inner
-  // `<VirtualizedList>` one level down (itself its own separate anchor host).
+  // This component's own host, the anchor `class="..."` resolves onto, not the inner list's
   private readonly elementRef = inject(ElementRef);
 
-  // --- template-bound state, recomputed in ngDoCheck when sections / separator presence change ---
   flatEntries: ISectionEntry<ItemT>[] = [];
   stickyHeaderIndices: number[] | undefined = undefined;
 
-  // headerIndices are the flat positions of every section header; scrollToLocation maps a
-  // (sectionIndex, itemIndex) coordinate through them without re-deriving the flat layout.
+  // Flat positions of every section header, so `scrollToLocation` skips re-deriving the layout
   private headerIndices: number[] = [];
-  // Memo guards so flattenSections does not re-run on every CD (the inner list marks for check on
-  // every scroll tick, which re-runs VSL's ngDoCheck too).
+  // Memo guards, the inner list marks for check on every scroll tick and re-runs `ngDoCheck`
   private lastSectionsRef: ReadonlyArray<ISection<ItemT>> | null = null;
   private lastHasSectionSeparator = false;
 
@@ -518,7 +263,7 @@ export class VirtualizedSectionList<ItemT = unknown>
     this.flatEntries = entries;
     this.headerIndices = headerIndices;
 
-    // RN sticks section headers by default only on iOS; Android does not unless asked.
+    // RN sticks section headers by default only on iOS
     this.stickyHeaderIndices = resolveStickySectionHeaders(
       this.stickySectionHeadersEnabled,
       headerIndices,
@@ -531,57 +276,34 @@ export class VirtualizedSectionList<ItemT = unknown>
     this.cdr.markForCheck();
   }
 
-  // The derived flat-stream accessors handed to the inner VirtualizedList. Stable arrow fields so
-  // the bindings keep a constant identity; they read the live flatEntries.
+  // Stable arrow fields, so the bindings to the inner list keep a constant identity
   getEntry = (_source: unknown, index: number): ISectionEntry<ItemT> =>
     this.flatEntries[index];
   getEntryCount = (): number => this.flatEntries.length;
   entryKeyExtractor = (entry: ISectionEntry<ItemT>, index: number): string =>
     sectionEntryKey(entry, index, this.keyExtractor);
 
-  // Hand the callback `sections`, not the entries: RN's inner VirtualizedList gets
-  // `data={this.props.sections}` (VirtualizedSectionList.js:216) while ours streams the FLATTENED
-  // entries, so the same user code would otherwise see a different argument here than on RN.
-  //
-  // UPSTREAM-DIVERGENCE(react-native): the flat INDEX matches RN's (two rows per section, header
-  // and footer) only while the vSectionSeparator template is unset. With it, flattenSections emits
-  // an extra 'section-separator' row per boundary that RN renders inside the neighbouring cell, so
-  // indices shift by one per boundary from the second section on. Deliberate - that row is how this
-  // adapter paints the separator; a caller combining the two must account for it.
-  //
-  // Cached on the input's own identity, like resolvedStyle above: the inner VirtualizedList folds
-  // getItemLayout into its ngDoCheck dedup array, so a wrapper allocated per getter read would
-  // re-run its whole recompute every CD.
-  private cachedEntryItemLayout?: (
-    data: unknown,
-    index: number,
-  ) => { length: number; offset: number; index: number };
+  // RN hands the callback `sections`, not the flattened entries. The flat index matches RN's only
+  // while no section separator template is set, which adds one row per boundary here
+  // Cached on the input's identity, the inner list folds it into its dedup array
+  private cachedEntryItemLayout?: (data: unknown, index: number) => IItemLayout;
   private lastGetItemLayout?: IVirtualizedSectionListProps<ItemT>['getItemLayout'];
   get entryItemLayout():
-    | ((
-        data: unknown,
-        index: number,
-      ) => { length: number; offset: number; index: number })
-    | undefined {
+    ((data: unknown, index: number) => IItemLayout) | undefined {
     if (this.getItemLayout !== this.lastGetItemLayout) {
       const getItemLayout = this.getItemLayout;
       this.lastGetItemLayout = getItemLayout;
       this.cachedEntryItemLayout =
         getItemLayout === undefined
           ? undefined
-          : (
-              _entries: unknown,
-              index: number,
-            ): { length: number; offset: number; index: number } =>
+          : (_entries: unknown, index: number): IItemLayout =>
               getItemLayout(this.sections, index);
     }
     return this.cachedEntryItemLayout;
   }
 
-  // Adapts each @Output() into the plain callback VirtualizedList's own @Input() still wants,
-  // gated on `.observed` so an unlistened event forwards `undefined` — the same "nobody cares"
-  // contract the old @Input() callback passthrough had (e.g. onRefresh presence gates whether a
-  // RefreshControl is built downstream; see the Vue twin's `listens('onRefresh')` gate).
+  // Each output becomes the plain callback the inner list wants, or `undefined` when nobody
+  // listens, since a callback's presence gates whether a `RefreshControl` is built downstream
   get resolvedOnEndReached():
     ((info: { distanceFromEnd: number }) => void) | undefined {
     return this.endReached.observed
@@ -600,36 +322,7 @@ export class VirtualizedSectionList<ItemT = unknown>
     return this.refresh.observed ? () => this.refresh.emit() : undefined;
   }
 
-  get resolvedOnAccessibilityAction():
-    ((event: ISymbioteEvent) => void) | undefined {
-    return this.accessibilityAction.observed
-      ? event => this.accessibilityAction.emit(event)
-      : undefined;
-  }
-
-  get resolvedOnAccessibilityTap():
-    ((event: ISymbioteEvent) => void) | undefined {
-    return this.accessibilityTap.observed
-      ? event => this.accessibilityTap.emit(event)
-      : undefined;
-  }
-
-  get resolvedOnMagicTap(): ((event: ISymbioteEvent) => void) | undefined {
-    return this.magicTap.observed
-      ? event => this.magicTap.emit(event)
-      : undefined;
-  }
-
-  get resolvedOnAccessibilityEscape():
-    ((event: ISymbioteEvent) => void) | undefined {
-    return this.accessibilityEscape.observed
-      ? event => this.accessibilityEscape.emit(event)
-      : undefined;
-  }
-
-  // --- per-cell-tag dispatch (the inner vListItem context is typed `unknown` under strictTemplates,
-  // since VListItemDirective's generic is not bound here; narrow with a runtime guard, no casts). ---
-
+  // The inner cell context is typed `unknown` under strict templates, so entries are narrowed
   private isEntry(value: unknown): value is ISectionEntry<ItemT> {
     return typeof value === 'object' && value !== null && 'kind' in value;
   }
@@ -658,10 +351,8 @@ export class VirtualizedSectionList<ItemT = unknown>
     };
   }
 
-  // The inner list's separator context carries the flattened ENTRY as leading/trailing; unwrap each
-  // back to its ItemT (shared unwrapEntryItem) so the app's item separator, typed on ItemT, sees
-  // real items (header/footer/section-separator gaps unwrap to undefined). Mirrors the React/Vue
-  // entrySeparatorComponent wrap.
+  // The inner separator context carries flattened entries, unwrapped back to real items so the
+  // app's separator, typed on the item, never sees an envelope
   itemSeparatorContextOf(
     highlighted: unknown,
     leadingItem: unknown,
@@ -679,8 +370,6 @@ export class VirtualizedSectionList<ItemT = unknown>
     };
   }
 
-  // ---- imperative handle (the shared IVirtualizedSectionListHandle surface) ----
-
   scrollToLocation(params: {
     sectionIndex: number;
     itemIndex: number;