@symbiote-native/angular 0.8.0 → 2.0.0

package/build/angular/components/scroll-view/shared.js

@@ -1,832 +0,0 @@
-// ScrollView, the Angular lifecycle half. The Fabric tree is nested: a scroll view wraps a
-// content view holding the children (RN's ScrollView.js shape). The platform-invariant math
-// (decelerationRate, per-axis intrinsics, content-size dedupe, imperative handle, native sticky
-// scroll-attach, aria/role fold) lives in @symbiote-native/components, shared with React/Vue.
-// Angular supplies only the lifecycle: the host node held by IDENTITY through a directive's
-// ElementRef, a forwarded-prop bag set via Renderer2 (-> routeProp), and the native sticky attach
-// wired through whenCommitted.
-//
-// RefreshControl integration diverges per platform (.ios/.android, Metro filename-selected): iOS
-// renders it as a SIBLING before the content container; Android WRAPS the scroll view in an
-// AndroidSwipeRefreshLayout.
-//
-// Angular cannot transform <ng-content> children the way React children.map / Vue slots() can, so
-// ScrollView owns a projection bridge: the content host registers a ScrollViewProjectionController
-// with the Angular renderer, which wraps projected children whose indices match
-// stickyHeaderIndices. Android RefreshControl projection re-renders the projected component as the
-// wrapper around the scroll view (RN's Android shape), excluding it from the content slot.
-import { Directive, computed, signal, ElementRef, EventEmitter, Output, ViewChild, ContentChild, inject, } from '@angular/core';
-import { attachStickyScroll, buildScrollViewHandle, didContentSizeChange, forwardScrollEvent, readLayoutDimension, resolveAccessibilityProps, resolveDecelerationRate, resolveScrollForwarding, selectScrollIntrinsics, splitLayoutProps, } from '@symbiote-native/components';
-import { AnimatedValue, dlog, event as animatedEvent, isNativeAnimatedAvailable, isSymbioteNode, resolveClassName, whenCommitted, } from '@symbiote-native/engine';
-import { anchorHostStyle, SymbioteHostPropsDirective } from '../../primitives';
-import { RefreshControl } from '../refresh-control';
-import { ScrollViewProjectionController } from './projection';
-import * as i0 from "@angular/core";
-// The inputs every platform ScrollView accepts, listed on each concrete @Component (the adapter
-// convention, mirroring Switch/Animated) so the base fields bind consistently. The aria-* /
-// role aliases ride here too and are folded by resolveAccessibilityProps before reaching native.
-export const SCROLL_VIEW_INPUTS = [
-    'style',
-    'contentContainerStyle',
-    'horizontal',
-    'scrollEnabled',
-    'showsVerticalScrollIndicator',
-    'showsHorizontalScrollIndicator',
-    'pagingEnabled',
-    'bounces',
-    'decelerationRate',
-    'scrollEventThrottle',
-    'contentInset',
-    'contentOffset',
-    'removeClippedSubviews',
-    'snapToInterval',
-    'snapToOffsets',
-    'snapToAlignment',
-    'snapToStart',
-    'snapToEnd',
-    'disableIntervalMomentum',
-    'stickyHeaderIndices',
-    'invertStickyHeaders',
-    'StickyHeaderComponent',
-    'keyboardDismissMode',
-    'keyboardShouldPersistTaps',
-    'maintainVisibleContentPosition',
-    'alwaysBounceHorizontal',
-    'alwaysBounceVertical',
-    'centerContent',
-    'scrollIndicatorInsets',
-    'indicatorStyle',
-    'directionalLockEnabled',
-    'automaticallyAdjustKeyboardInsets',
-    'contentInsetAdjustmentBehavior',
-    'minimumZoomScale',
-    'maximumZoomScale',
-    'zoomScale',
-    'bouncesZoom',
-    'pinchGestureEnabled',
-    'nestedScrollEnabled',
-    'overScrollMode',
-    'fadingEdgeLength',
-    'persistentScrollbar',
-    'endFillColor',
-    'onScroll',
-    'onScrollBeginDrag',
-    'onScrollEndDrag',
-    'onMomentumScrollBegin',
-    'onMomentumScrollEnd',
-    'testID',
-    'nativeID',
-    'accessible',
-    'accessibilityLabel',
-    'accessibilityHint',
-    'accessibilityRole',
-    'accessibilityState',
-    'accessibilityValue',
-    'accessibilityActions',
-    'accessibilityLabelledBy',
-    'importantForAccessibility',
-    'accessibilityLiveRegion',
-    'screenReaderFocusable',
-    'accessibilityViewIsModal',
-    'accessibilityElementsHidden',
-    'accessibilityIgnoresInvertColors',
-    'accessibilityLanguage',
-    'accessibilityRespondsToUserInteraction',
-    'accessibilityShowsLargeContentViewer',
-    'accessibilityLargeContentTitle',
-    'role',
-    'aria-label',
-    'aria-labelledby',
-    'aria-live',
-    'aria-hidden',
-    'aria-busy',
-    'aria-checked',
-    'aria-disabled',
-    'aria-expanded',
-    'aria-selected',
-    'aria-modal',
-    'aria-valuemax',
-    'aria-valuemin',
-    'aria-valuenow',
-    'aria-valuetext',
-];
-// Strip undefined entries so a prop the user never set is not forwarded to the host (an undefined
-// reaching Fabric is at best a no-op, at worst clears a default). The Angular twin of React/Vue
-// destructuring `...rest` past the defined props.
-function compact(bag) {
-    const result = {};
-    for (const key of Object.keys(bag)) {
-        if (bag[key] !== undefined)
-            result[key] = bag[key];
-    }
-    return result;
-}
-// ScrollView's forwarded surface (scroll events + the snap/keyboard/zoom families) is exactly the
-// flat-bag shape SymbioteHostPropsDirective spreads onto a host element via Renderer2 (-> routeProp).
-// The scroll-event callbacks ride this bag (not the (event) channel) because routeProp must be free
-// to wire onScroll as an Animated.event when sticky headers drive the value natively, which the
-// listen()/setEventListener channel cannot carry. This mirrors React/Vue putting onScroll on
-// outerProps.
-export class ScrollViewProjectionDirective {
-    elementRef = inject(ElementRef);
-    set symbioteScrollViewProjection(controller) {
-        const node = this.elementRef.nativeElement;
-        if (isSymbioteNode(node))
-            controller.bindContentNode(node);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ScrollViewProjectionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ScrollViewProjectionDirective, isStandalone: true, selector: "[symbioteScrollViewProjection]", inputs: { symbioteScrollViewProjection: "symbioteScrollViewProjection" }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ScrollViewProjectionDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[symbioteScrollViewProjection]',
-                    standalone: true,
-                    inputs: ['symbioteScrollViewProjection'],
-                }]
-        }] });
-// @Directive() (no selector) is the Angular-sanctioned decorator for an abstract base that
-// declares lifecycle hooks and @ViewChild queries (mirrors AnimatedComponentBase) — without it
-// ngtsc rejects the inherited hooks/queries (NG2007). The concrete platform @Components add ONLY a
-// decorator + their platform template; all behavior lives here.
-export class ScrollViewBase {
-    style;
-    contentContainerStyle;
-    horizontal;
-    scrollEnabled;
-    showsVerticalScrollIndicator;
-    showsHorizontalScrollIndicator;
-    pagingEnabled;
-    bounces;
-    decelerationRate;
-    scrollEventThrottle;
-    contentInset;
-    contentOffset;
-    removeClippedSubviews;
-    snapToInterval;
-    snapToOffsets;
-    snapToAlignment;
-    snapToStart;
-    snapToEnd;
-    disableIntervalMomentum;
-    stickyHeaderIndices;
-    invertStickyHeaders;
-    StickyHeaderComponent;
-    keyboardDismissMode;
-    keyboardShouldPersistTaps;
-    maintainVisibleContentPosition;
-    alwaysBounceHorizontal;
-    alwaysBounceVertical;
-    centerContent;
-    scrollIndicatorInsets;
-    indicatorStyle;
-    directionalLockEnabled;
-    automaticallyAdjustKeyboardInsets;
-    contentInsetAdjustmentBehavior;
-    minimumZoomScale;
-    maximumZoomScale;
-    zoomScale;
-    bouncesZoom;
-    pinchGestureEnabled;
-    nestedScrollEnabled;
-    overScrollMode;
-    fadingEdgeLength;
-    persistentScrollbar;
-    endFillColor;
-    onScroll;
-    onScrollBeginDrag;
-    onScrollEndDrag;
-    onMomentumScrollBegin;
-    onMomentumScrollEnd;
-    // The layout/content-size/accessibility events as real Angular events: `(layout)="…"`, not
-    // `[onLayout]="…"`. onScroll and the drag/momentum family stay plain @Input() callbacks above —
-    // they must also accept an Animated.event(...) native-driver marker (see the file header note),
-    // which no @Output() binding can carry.
-    layout = new EventEmitter();
-    scrollToTop = new EventEmitter();
-    contentSizeChange = new EventEmitter();
-    accessibilityAction = new EventEmitter();
-    accessibilityTap = new EventEmitter();
-    magicTap = new EventEmitter();
-    accessibilityEscape = new EventEmitter();
-    testID;
-    nativeID;
-    accessible;
-    accessibilityLabel;
-    accessibilityHint;
-    accessibilityRole;
-    accessibilityState;
-    accessibilityValue;
-    accessibilityActions;
-    accessibilityLabelledBy;
-    importantForAccessibility;
-    accessibilityLiveRegion;
-    screenReaderFocusable;
-    accessibilityViewIsModal;
-    accessibilityElementsHidden;
-    accessibilityIgnoresInvertColors;
-    accessibilityLanguage;
-    accessibilityRespondsToUserInteraction;
-    accessibilityShowsLargeContentViewer;
-    accessibilityLargeContentTitle;
-    role;
-    'aria-label';
-    'aria-labelledby';
-    'aria-live';
-    'aria-hidden';
-    'aria-busy';
-    'aria-checked';
-    'aria-disabled';
-    'aria-expanded';
-    'aria-selected';
-    'aria-modal';
-    'aria-valuemax';
-    'aria-valuemin';
-    'aria-valuenow';
-    'aria-valuetext';
-    // The host directive on the scroll-view intrinsic; `.node` is the committed SymbioteNode held by
-    // IDENTITY (Renderer2.createElement returned the engine node, ElementRef hands it back unwrapped).
-    // Inherited by the decorated subclass — Angular collects base-class @ViewChild queries.
-    hostDirective;
-    projectedRefreshControl;
-    // This component's OWN anchor host — where a `class="..."` at the use site resolves (see
-    // anchorHostStyle's doc comment) — NOT `#host` in the platform templates, which targets the real
-    // inner scroll-view primitive one level down. Injected in the BASE because both platform
-    // subclasses merged the identical anchor style into their `scrollProps` override.
-    elementRef = inject(ElementRef);
-    // The anchor's class-derived style is written by the RENDERER (addClass/removeClass ->
-    // commitClassStyle), never through an @Input, so `inputsRevision` cannot cover it and a bag
-    // memoized on plain reads of it would keep a stale class forever. It gets its own signal, polled
-    // in ngDoCheck below: that hook runs on exactly the checks that could have changed it (Angular
-    // applies the parent's class bindings before flushing this directive's pre-order hooks), which is
-    // the same cadence the old `scrollProps` getter was re-read at.
-    anchorStyle = signal(undefined, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "anchorStyle" }] : /* istanbul ignore next */ []));
-    // A single AnimatedValue tracks the scroll offset and drives every sticky header's translateY
-    // (RN's _scrollAnimatedValue). A stable field (allocated once, held by identity — Angular does
-    // not proxy class fields, so no markRaw needed); the native attach below feeds it on the UI
-    // thread. Allocated unconditionally; inert until a sticky header consumes it.
-    scrollAnimatedValue = new AnimatedValue(0);
-    // The last-seen content size, used to dedupe onContentSizeChange: RN fires the content onLayout
-    // on every layout pass; only real size changes emit (didContentSizeChange).
-    lastContentSize = null;
-    // Inverted sticky headers stick to the BOTTOM, so they need the viewport height (RN _handleLayout).
-    viewportHeight = undefined;
-    // What the projection controller was last told about the projected RefreshControl, so
-    // ngAfterContentChecked can tell a real content change from an ordinary check.
-    lastHasProjectedRefreshControl = false;
-    projectionController = new ScrollViewProjectionController({
-        stickyHeaderIndices: undefined,
-        invertStickyHeaders: undefined,
-        scrollViewHeight: undefined,
-        scrollAnimatedValue: this.scrollAnimatedValue,
-        customStickyHeaderComponent: undefined,
-        excludeRefreshControl: false,
-    });
-    // Native sticky-scroll attach (RN attachNativeEvent): when the native module is available the
-    // scroll value is driven on the UI thread so the interpolations ride scroll natively (no JS
-    // jitter). Through whenCommitted because under Angular's zoneless batched CD the host's Fabric
-    // tag does not exist yet at ngAfterViewInit time (the async-commit gotcha Vue documents); the
-    // bind runs now if committed, else after the commit that assigns the tag. Detached on destroy.
-    detachStickyScroll;
-    cancelStickyBind;
-    // What the current attach was made for, so a re-run that changes nothing stays a no-op.
-    stickyAttachedEnabled = false;
-    stickyAttachedNode = null;
-    lastLoggedIsHorizontal = undefined;
-    // Stable reference (bound once): inverted sticky headers need the viewport height captured off
-    // the scroll-view's own onLayout before forwarding to the user (RN _handleLayout). A getter that
-    // built this arrow function fresh on every `scrollProps` access would hand `[symbioteHostProps]`
-    // a new function reference every change-detection pass touching this component — jsonEqual
-    // (commit.ts) falls back to Object.is on a function leaf, so even a structurally-identical bag
-    // reads as "props changed" and forces a real Fabric re-clone that cascades up every ancestor
-    // (see AnimatedComponentBase.reconcile()'s identical warning).
-    handleInvertedStickyLayout = (event) => {
-        const height = readLayoutDimension(event, 'height');
-        // The projection controller is pushed from here rather than picked up on the next prop-bag
-        // read: viewportHeight is internal mutable state, so once `scrollProps` became a memoized
-        // computed nothing would re-read it. Guarded on a real change - an onLayout that reports the
-        // same height must not cost a sticky reconcile walk.
-        if (height !== undefined && height !== this.viewportHeight) {
-            this.viewportHeight = height;
-            this.updateProjectionController();
-        }
-        this.layout.emit(event);
-    };
-    // Same reasoning as handleInvertedStickyLayout: the content view's onLayout synthesizes
-    // onContentSizeChange (deduped) and must stay a stable reference across `contentProps` re-reads.
-    handleContentLayout = (event) => {
-        const width = readLayoutDimension(event, 'width');
-        const height = readLayoutDimension(event, 'height');
-        if (width === undefined || height === undefined)
-            return;
-        if (!didContentSizeChange(this.lastContentSize, { width, height }))
-            return;
-        this.lastContentSize = { width, height };
-        dlog(`Angular ScrollView contentSizeChange ${width}x${height}`);
-        this.contentSizeChange.emit({ width, height });
-    };
-    // Memoizes the wrapper each `emitterCallback` builds, keyed by the emitter it closes over.
-    // Without this, `scrollProps`/`refreshControlProps` would hand a fresh closure to the forwarded
-    // prop bag on every evaluation — the same jsonEqual/Object.is function-leaf problem as the arrow
-    // fields above. `.observed` is checked BEFORE the cache so an unbound event still resolves to
-    // `undefined` rather than a stale wrapper from before the last unsubscribe.
-    emitterCallbackCache = new WeakMap();
-    // The sticky JS-path Animated.event handler depends on a REAL input (onScroll), so it can't be a
-    // plain stable field the way handleInvertedStickyLayout/handleContentLayout are — it must track
-    // `this.onScroll` genuinely changing, mirroring sticky-header.ts's own rebuildInterpolation cache
-    // (rebuild only when the tracked dependency's reference actually differs, not on every getter
-    // read). A fresh `animatedEvent(...)` call every `scrollProps` access would otherwise construct a
-    // new listener wrapper (and a new AnimatedEvent walking `collectMappedValues`) on every unrelated
-    // change-detection pass while sticky headers are active.
-    cachedStickyOnScrollSource;
-    cachedStickyOnScrollHandler;
-    get isHorizontal() {
-        const value = this.horizontal === true;
-        if (value !== this.lastLoggedIsHorizontal) {
-            this.lastLoggedIsHorizontal = value;
-            dlog(`Angular ScrollView isHorizontal changed to ${value} (horizontal input=${this.horizontal})`);
-        }
-        return value;
-    }
-    get hasStickyHeaders() {
-        return (this.stickyHeaderIndices !== undefined &&
-            this.stickyHeaderIndices.length > 0);
-    }
-    // A class-name string resolves through the shared registry before it reaches
-    // selectScrollIntrinsics, which only understands style objects/arrays.
-    get resolvedContentContainerStyle() {
-        return typeof this.contentContainerStyle === 'string'
-            ? resolveClassName(this.contentContainerStyle)
-            : this.contentContainerStyle;
-    }
-    get scrollViewBaseStyle() {
-        return selectScrollIntrinsics(this.isHorizontal, this.resolvedContentContainerStyle).scrollViewBaseStyle;
-    }
-    // Bridges non-reactive @Input fields into the reactive graph, so a computed() can memoize a
-    // bag derived from them. Signal inputs would make this unnecessary, but `input()` is visible
-    // only to the AOT compiler and this package's unit suite runs on JIT - see the
-    // `angular-adapter-change-detection` skill, §6. `signal()`/`computed()` themselves are plain
-    // runtime APIs and need no compiler support, which is what makes this bridge possible at all.
-    //
-    // ONLY safe for a bag whose every dependency is an @Input. A bag that also reads internal
-    // mutable state (viewportHeight, lastContentSize, the anchor's class-derived style) would go
-    // stale, because nothing bumps this for those - make that state its own signal (see
-    // `anchorStyle`) instead of widening this one.
-    inputsRevision = signal(0, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "inputsRevision" }] : /* istanbul ignore next */ []));
-    // The forwarded host-prop bag for the scroll-view node: aria/role folded, the native pass-through
-    // families, the scroll-event callbacks, then the lifecycle-managed overrides (nestedScrollEnabled
-    // default ON, horizontal when defined, decelerationRate resolved per-platform, the sticky onScroll
-    // path). Base style UNDER user style so an explicit user value still wins. Mirrors Vue's outerProps
-    // + scrollProps assembly.
-    //
-    // MEASURED 2026-08-16: as a getter this rebuilt the whole bag on every refresh of this view, so
-    // the `symbioteHostProps` reference check failed every time and every key was re-pushed through
-    // the renderer - once per scroll frame per host binding (2 before `contentProps` was memoized,
-    // 1 after, 0 now; the pin lives in prop-bag-stability.test.ts).
-    //
-    // It is a `computed` on the BASE and no longer overridable: a subclass getter cannot override a
-    // field. The platform subclasses used to override it with byte-identical bodies (merge the
-    // anchor's class-derived style ahead of the resolved style), so that merge moved down here
-    // rather than into a `decorateScrollProps` hook both of them would implement the same way.
-    scrollProps = computed(() => {
-        this.inputsRevision();
-        const bag = compact({
-            ...resolveAccessibilityProps(this.accessibilityInputs()),
-            scrollEnabled: this.scrollEnabled,
-            showsVerticalScrollIndicator: this.showsVerticalScrollIndicator,
-            showsHorizontalScrollIndicator: this.showsHorizontalScrollIndicator,
-            pagingEnabled: this.pagingEnabled,
-            bounces: this.bounces,
-            contentInset: this.contentInset,
-            contentOffset: this.contentOffset,
-            removeClippedSubviews: this.removeClippedSubviews,
-            snapToInterval: this.snapToInterval,
-            snapToOffsets: this.snapToOffsets,
-            snapToAlignment: this.snapToAlignment,
-            snapToStart: this.snapToStart,
-            snapToEnd: this.snapToEnd,
-            disableIntervalMomentum: this.disableIntervalMomentum,
-            keyboardDismissMode: this.keyboardDismissMode,
-            keyboardShouldPersistTaps: this.keyboardShouldPersistTaps,
-            maintainVisibleContentPosition: this.maintainVisibleContentPosition,
-            alwaysBounceHorizontal: this.alwaysBounceHorizontal,
-            alwaysBounceVertical: this.alwaysBounceVertical,
-            centerContent: this.centerContent,
-            scrollIndicatorInsets: this.scrollIndicatorInsets,
-            indicatorStyle: this.indicatorStyle,
-            directionalLockEnabled: this.directionalLockEnabled,
-            automaticallyAdjustKeyboardInsets: this.automaticallyAdjustKeyboardInsets,
-            contentInsetAdjustmentBehavior: this.contentInsetAdjustmentBehavior,
-            minimumZoomScale: this.minimumZoomScale,
-            maximumZoomScale: this.maximumZoomScale,
-            zoomScale: this.zoomScale,
-            bouncesZoom: this.bouncesZoom,
-            pinchGestureEnabled: this.pinchGestureEnabled,
-            overScrollMode: this.overScrollMode,
-            fadingEdgeLength: this.fadingEdgeLength,
-            persistentScrollbar: this.persistentScrollbar,
-            endFillColor: this.endFillColor,
-            onScrollBeginDrag: this.onScrollBeginDrag,
-            onScrollEndDrag: this.onScrollEndDrag,
-            onMomentumScrollBegin: this.onMomentumScrollBegin,
-            onMomentumScrollEnd: this.onMomentumScrollEnd,
-            onScrollToTop: this.emitterCallback(this.scrollToTop),
-            onAccessibilityAction: this.emitterCallback(this.accessibilityAction),
-            onAccessibilityTap: this.emitterCallback(this.accessibilityTap),
-            onMagicTap: this.emitterCallback(this.magicTap),
-            onAccessibilityEscape: this.emitterCallback(this.accessibilityEscape),
-        });
-        // RN defaults nested scrolling ON (ScrollView.js `nestedScrollEnabled ?? true`); Android needs
-        // it to scroll a nested scrollable independently, iOS handles nesting natively (a no-op there).
-        bag.nestedScrollEnabled = this.nestedScrollEnabled ?? true;
-        // iOS needs `horizontal` to flip RCTScrollView's axis; Android's dedicated manager ignores it.
-        if (this.horizontal !== undefined)
-            bag.horizontal = this.horizontal;
-        if (this.decelerationRate !== undefined) {
-            bag.decelerationRate = resolveDecelerationRate(this.decelerationRate);
-        }
-        // onScroll: when sticky headers are active, the offset must reach the AnimatedValue (RN
-        // _scrollAnimatedValueAttachment). With the native module, the post-commit attach below drives
-        // it on the UI thread (throttle 1, ScrollView.js:1798); without it, Animated.event drives the
-        // value each frame (JS jitter). The DECISIONS (which path, throttle defaults, whether to
-        // capture viewport height) are folded out to the shared resolveScrollForwarding; Angular only
-        // EXECUTES them, keeping stable-reference handlers so a fresh closure never forces a re-clone.
-        const nativeStickyAvailable = this.hasStickyHeaders && isNativeAnimatedAvailable();
-        const forwarding = resolveScrollForwarding({
-            hasStickyHeaders: this.hasStickyHeaders,
-            nativeStickyAvailable,
-            invertStickyHeaders: this.invertStickyHeaders,
-            scrollEventThrottle: this.scrollEventThrottle,
-            maintainVisibleContentPosition: this.maintainVisibleContentPosition,
-            snapToAlignment: this.snapToAlignment,
-        });
-        // onScroll: the JS-fallback path uses the cached Animated.event handler; the native + plain paths
-        // forward the user handler as-is (the native driver attaches the value on the UI thread).
-        if (forwarding.mode === 'sticky-js') {
-            bag.onScroll = this.stickyOnScrollHandler(this.onScroll);
-        }
-        else if (this.onScroll !== undefined) {
-            bag.onScroll = this.onScroll;
-        }
-        if (forwarding.scrollEventThrottle !== undefined) {
-            bag.scrollEventThrottle = forwarding.scrollEventThrottle;
-        }
-        // Inverted sticky headers need the viewport height (RN _handleLayout): capture it on the
-        // scroll-view onLayout, then call the user's handler. Otherwise forward the layout emitter.
-        if (forwarding.capturesViewportHeight) {
-            bag.onLayout = this.handleInvertedStickyLayout;
-        }
-        else {
-            const layoutCallback = this.emitterCallback(this.layout);
-            if (layoutCallback !== undefined)
-                bag.onLayout = layoutCallback;
-        }
-        // Thunks, not strings: an eagerly built message would be paid with logging off (see dlog's own
-        // comment). Less often than it used to fire now that this bag is memoized, but the recompute
-        // still rides every real input change.
-        dlog(() => `Angular ScrollView -> ${this.isHorizontal ? 'horizontal' : 'vertical'} (sticky=${this.hasStickyHeaders})`);
-        dlog(() => `STICKY[sv] forwarding mode=${forwarding.mode} throttle=${forwarding.scrollEventThrottle} ` +
-            `nativeStickyAvailable=${nativeStickyAvailable} onScrollBound=${bag.onScroll !== undefined}`);
-        // The anchor's class-derived style goes FIRST: flattenStyle's later-wins collapse keeps an
-        // explicit [style] winning over the ambient class. Flat rather than the nested
-        // `[anchor, [base, style]]` the platform overrides used to build - flattenStyle folds nested
-        // arrays in the same order, so the resolved value is unchanged.
-        bag.style = [this.anchorStyle(), this.scrollViewBaseStyle, this.style];
-        return bag;
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "scrollProps" }] : /* istanbul ignore next */ []));
-    // Overridable hook, NOT `this.style` directly: `splitLayoutProps` below decides which layout
-    // properties (flex/height/gap/…) go on the Android outer refresh-control wrapper vs. the inner
-    // scroll view. `this.style` alone only carries the explicit `[style]` @Input — a composed
-    // component's own anchor host can hold ADDITIONAL class-derived layout style invisible to this
-    // split, so the wrapper collapses to zero size on real Android devices. Angular's Android
-    // ScrollView (index.android.ts) overrides this to merge in `anchorHostStyle` (mirrors Vue's
-    // identical `layoutSplitStyle` field and the device bug it fixes).
-    get layoutSplitStyle() {
-        return this.style;
-    }
-    // Memoizable for the same reasons `scrollProps` is: `layoutSplitStyle` resolves to @Input `style`
-    // plus (on Android) the `anchorStyle` signal, both covered. The anchor style is deliberately NOT
-    // re-merged into `props.style` here - `splitLayoutProps` already routed its layout half to the
-    // outer refresh-control wrapper and left the rest in `inner`.
-    androidWrappedScrollProps = computed(() => {
-        this.inputsRevision();
-        const props = { ...this.scrollProps() };
-        const { inner, outer } = splitLayoutProps(this.layoutSplitStyle);
-        dlog(() => `Angular ScrollView splitProbe layoutSplitStyle=${JSON.stringify(this.layoutSplitStyle)} ` +
-            `outer=${JSON.stringify(outer)} inner=${JSON.stringify(inner)}`);
-        props.style = [this.scrollViewBaseStyle, inner];
-        props.nestedScrollEnabled = true;
-        return props;
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "androidWrappedScrollProps" }] : /* istanbul ignore next */ []));
-    // Deliberately still GETTERS, unlike every other bag on this class. Their whole content comes
-    // from the PROJECTED RefreshControl's own @Input()s (refreshing, tintColor, colors, …), which
-    // Angular routes through THAT component's ngOnChanges - `inputsRevision` here never moves for
-    // them. Memoizing on it would freeze `refreshing` at its first value and strand the native
-    // spinner forever, which is exactly the silent-staleness class this file avoids elsewhere.
-    // Making them memoizable means giving RefreshControl its own revision signal to read here.
-    get iosRefreshControlProps() {
-        return this.refreshControlProps();
-    }
-    get androidRefreshControlProps() {
-        const { outer } = splitLayoutProps(this.layoutSplitStyle);
-        dlog(() => `Angular ScrollView refreshControlProbe outer=${JSON.stringify(outer)} ` +
-            `hasRefresh=${this.projectedRefreshControl !== undefined}`);
-        return this.refreshControlProps(outer);
-    }
-    handleProjectedRefresh(nativeNode) {
-        this.projectedRefreshControl?.handleRefresh(nativeNode);
-    }
-    refreshControlProps(style) {
-        const refresh = this.projectedRefreshControl;
-        if (refresh === undefined)
-            return {};
-        return compact({
-            ...refresh.folded,
-            refreshing: refresh.refreshing,
-            tintColor: refresh.tintColor,
-            title: refresh.title,
-            titleColor: refresh.titleColor,
-            progressViewOffset: refresh.progressViewOffset,
-            colors: refresh.colors,
-            progressBackgroundColor: refresh.progressBackgroundColor,
-            size: refresh.size,
-            enabled: refresh.enabled,
-            style,
-            testID: refresh.testID,
-            nativeID: refresh.nativeID,
-            accessible: refresh.accessible,
-            onAccessibilityAction: this.emitterCallback(refresh.accessibilityAction),
-            onAccessibilityTap: this.emitterCallback(refresh.accessibilityTap),
-            onMagicTap: this.emitterCallback(refresh.magicTap),
-            onAccessibilityEscape: this.emitterCallback(refresh.accessibilityEscape),
-        });
-    }
-    get hasProjectedRefreshControl() {
-        return this.projectedRefreshControl !== undefined;
-    }
-    // The content (inner) view's prop bag. `collapsable: false` keeps the layout-only content view a
-    // real native view (Android Fabric view-flattens it away otherwise, hoisting cells as direct
-    // children of a scroll view that hosts exactly one — an addViewAt crash). collapsableChildren
-    // false preserves the cell views maintainVisibleContentPosition/snapToAlignment anchor against.
-    // onLayout synthesizes onContentSizeChange (deduped). iOS never flattens; both are no-ops there.
-    contentProps = computed(() => {
-        this.inputsRevision();
-        const { contentStyle } = selectScrollIntrinsics(this.isHorizontal, this.resolvedContentContainerStyle);
-        const bag = {
-            style: contentStyle,
-            collapsable: false,
-        };
-        if (this.maintainVisibleContentPosition !== undefined ||
-            this.snapToAlignment !== undefined) {
-            bag.collapsableChildren = false;
-        }
-        bag.onLayout = this.handleContentLayout;
-        return bag;
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "contentProps" }] : /* istanbul ignore next */ []));
-    // Wraps an @Output() as a plain callback only while it has a subscriber, so an unbound event
-    // still leaves the forwarded prop bag key absent — the same "undefined means nobody cares"
-    // contract the old @Input() callbacks had. Mirrors Pressable's emitterHandler. The wrapper itself
-    // is memoized per emitter (emitterCallbackCache) rather than rebuilt on every call: see that
-    // field's comment for why an unstable closure here breaks the forwarded prop bag.
-    //
-    // `.observed` is NOT reactive, and `scrollProps` memoizes over it. That is sound because Angular
-    // subscribes a template's (event) listeners in its CREATION pass, before any input is written and
-    // before this component's own view is first refreshed - so `observed` is already settled at the
-    // first evaluation and cannot flip afterwards without destroying the whole component.
-    emitterCallback(emitter) {
-        if (!emitter.observed)
-            return undefined;
-        let cached = this.emitterCallbackCache.get(emitter);
-        if (cached === undefined) {
-            cached = (event) => emitter.emit(event);
-            this.emitterCallbackCache.set(emitter, cached);
-        }
-        return cached;
-    }
-    // Rebuilds the JS-path Animated.event handler only when the tracked `onScroll` input actually
-    // changes reference (see cachedStickyOnScrollHandler's comment).
-    stickyOnScrollHandler(userOnScroll) {
-        if (this.cachedStickyOnScrollHandler === undefined ||
-            this.cachedStickyOnScrollSource !== userOnScroll) {
-            this.cachedStickyOnScrollSource = userOnScroll;
-            this.cachedStickyOnScrollHandler = animatedEvent([{ nativeEvent: { contentOffset: { y: this.scrollAnimatedValue } } }], userOnScroll === undefined
-                ? undefined
-                : {
-                    listener: (...args) => forwardScrollEvent(userOnScroll, args),
-                });
-        }
-        return this.cachedStickyOnScrollHandler;
-    }
-    // The committed scroll-view node held by IDENTITY (the directive's ElementRef). null until the
-    // element commits; the imperative handle and the sticky attach both read it through this getter.
-    get hostNode() {
-        const native = this.hostDirective?.node;
-        return isSymbioteNode(native) ? native : null;
-    }
-    // The imperative API a parent reaches via @ViewChild(ScrollView). buildScrollViewHandle is the
-    // shared, proven handle (React/Vue use it verbatim); it reads the node through the LAZY getter on
-    // every call, so a command before commit no-ops rather than freezing a null node.
-    handle = buildScrollViewHandle(() => this.hostNode);
-    scrollTo(options) {
-        this.handle.scrollTo(options);
-    }
-    scrollToEnd(options) {
-        this.handle.scrollToEnd(options);
-    }
-    flashScrollIndicators() {
-        this.handle.flashScrollIndicators();
-    }
-    getScrollNode() {
-        return this.handle.getScrollNode();
-    }
-    ngAfterViewInit() {
-        dlog('STICKY[sv] ngAfterViewInit');
-        // Runs once the template has bound the content node, so this is the reconcile that actually
-        // wraps the sticky children (the ngOnChanges one above fires before the content node exists).
-        this.updateProjectionController();
-        this.attachSticky();
-    }
-    // Re-read the anchor's class-derived style. It is written by the renderer's addClass/removeClass,
-    // never through an @Input, so this poll is the only thing that can invalidate a bag holding it -
-    // ngOnChanges alone would strand a class toggled after mount (covered by
-    // scroll-view-class-style.test.ts's toggle case, which goes red the moment this hook stops
-    // polling). ngDoCheck is the right hook, not a near-enough one: render3's `callHooks` flushes a
-    // node's pre-order hooks at the next `ɵɵadvance` PAST it, which is after the parent wrote this
-    // element's `ɵɵclassProp` and before this component's own view refreshes. It also runs under
-    // `setActiveConsumer(null)`, so the write registers no dependency on the caller's view and cannot
-    // throw NG0600. And `commitClassStyle` allocates a fresh style array only when a class token
-    // actually moved, so `signal.set`'s own Object.is check makes an unchanged poll dirty nothing.
-    ngDoCheck() {
-        this.anchorStyle.set(anchorHostStyle(this.elementRef));
-        // The attach can want a node that does not exist yet, and nothing else would ask again.
-        // ngOnChanges covers "indices arrived late"; it does NOT cover "indices arrived late AND the host
-        // node had not committed yet", which is exactly what a VirtualizedList does - it derives
-        // stickyHeaderIndices from the measured window, so they land after this component's
-        // ngAfterViewInit and before its host node resolves. Device-diagnosed 2026-08-18 on
-        // examples/angular BenchmarkScreen STICKY PATH B, whose log ends on `attachSticky NOT attaching
-        // (wantsAttach=true hasNode=false)` - sticky never turned on, while PATH A (literal indices in
-        // the template) worked because ngAfterViewInit already saw a node. Retried ONLY from that stuck
-        // state, so a settled ScrollView pays nothing per check. Device-verified the same day.
-        // Not covered headless: sticky-native-attach.test.ts's late-indices case has its node resolved by
-        // the time the indices land, and the deferred-creation ordering under `@if` never rendered the
-        // ScrollView at all.
-        if (this.stickyAttachedEnabled && this.stickyAttachedNode === null)
-            this.attachSticky();
-    }
-    // The projected RefreshControl is a @ContentChild, not an @Input, so ngOnChanges never fires when
-    // one is added or removed at the use site - and `excludeRefreshControl` decides whether the
-    // projection walk pulls it out of the scroll content. Angular resolves the query before this
-    // hook. Guarded on the flag itself so a check that changed nothing skips the reconcile walk,
-    // which the old getter-driven update could not do.
-    ngAfterContentChecked() {
-        if (this.hasProjectedRefreshControl === this.lastHasProjectedRefreshControl)
-            return;
-        this.lastHasProjectedRefreshControl = this.hasProjectedRefreshControl;
-        this.updateProjectionController();
-    }
-    // `stickyHeaderIndices` is an ordinary @Input, so it can arrive AFTER the first change-detection
-    // pass - any app deriving it from data rather than writing a literal in the template does exactly
-    // that. ngAfterViewInit runs once, so without this the native attach below would be skipped on
-    // that first pass and never retried: the wrapper still projects (that half self-heals), the
-    // header sits at the right place with the right z-index, and simply never moves. Device-reported
-    // 2026-08-16, regression-covered in sticky-native-attach.test.ts. The other three adapters never
-    // had this hole because they re-run the attach from a reactive effect keyed on the same
-    // condition (Svelte's `$effect` in index.svelte, React's useEffect deps, Vue's watcher).
-    ngOnChanges() {
-        dlog('STICKY[sv] ngOnChanges');
-        // Every computed() prop bag below reads plain @Input fields, which are NOT reactive on their
-        // own - this bump is what tells them an input changed. It must stay in ngOnChanges: that is
-        // the single moment Angular has finished writing every changed input for this pass.
-        this.inputsRevision.update(revision => revision + 1);
-        // stickyHeaderIndices / invertStickyHeaders / StickyHeaderComponent are @Inputs, so this is
-        // where the projection controller learns about them. It used to be a side effect of reading
-        // the `scrollProps` getter - which a memoized computed no longer performs per pass.
-        this.updateProjectionController();
-        this.attachSticky();
-    }
-    // Wire the native sticky-scroll attach once the view exists AND sticky is actually on. Re-runs
-    // on every input change, so it must be idempotent: see the guard below.
-    attachSticky() {
-        const wantsAttach = this.hasStickyHeaders && isNativeAnimatedAvailable();
-        const node = wantsAttach ? this.hostNode : null;
-        dlog(() => `STICKY[sv] attachSticky indices=${JSON.stringify(this.stickyHeaderIndices)} ` +
-            `hasSticky=${this.hasStickyHeaders} nativeAvailable=${isNativeAnimatedAvailable()} ` +
-            `wantsAttach=${wantsAttach} hasNode=${node !== null} ` +
-            `wasEnabled=${this.stickyAttachedEnabled} nodeChanged=${node !== this.stickyAttachedNode}`);
-        // Nothing that decides the attach has changed - return rather than detach and rebind the
-        // native scroll event, which every unrelated @Input change would otherwise churn now that
-        // ngOnChanges drives this too.
-        if (wantsAttach === this.stickyAttachedEnabled &&
-            node === this.stickyAttachedNode) {
-            dlog('STICKY[sv] attachSticky skipped (nothing about the attach changed)');
-            return;
-        }
-        this.cancelStickyBind?.();
-        this.cancelStickyBind = undefined;
-        if (this.detachStickyScroll !== undefined) {
-            this.detachStickyScroll();
-            this.detachStickyScroll = undefined;
-        }
-        // Recorded even when the node is not resolved yet, so the NEXT call (which will see a real
-        // node) reads as a change and attaches.
-        this.stickyAttachedEnabled = wantsAttach;
-        this.stickyAttachedNode = node;
-        if (!wantsAttach || node === null) {
-            dlog(`STICKY[sv] attachSticky NOT attaching (wantsAttach=${wantsAttach} hasNode=${node !== null})`);
-            return;
-        }
-        dlog('STICKY[sv] attachSticky waiting for commit to bind the native scroll event');
-        this.cancelStickyBind = whenCommitted(node, () => {
-            dlog('STICKY[sv] attachSticky node committed -> attachStickyScroll');
-            this.detachStickyScroll = attachStickyScroll(node, this.scrollAnimatedValue);
-        });
-    }
-    ngOnDestroy() {
-        this.cancelStickyBind?.();
-        this.cancelStickyBind = undefined;
-        if (this.detachStickyScroll !== undefined)
-            this.detachStickyScroll();
-    }
-    updateProjectionController() {
-        this.projectionController.update({
-            stickyHeaderIndices: this.stickyHeaderIndices,
-            invertStickyHeaders: this.invertStickyHeaders,
-            scrollViewHeight: this.viewportHeight,
-            scrollAnimatedValue: this.scrollAnimatedValue,
-            customStickyHeaderComponent: this.StickyHeaderComponent,
-            excludeRefreshControl: this.hasProjectedRefreshControl,
-        });
-    }
-    // Typed as the a11y intersection WITH the string index so resolveAccessibilityProps's result
-    // stays assignable into the forwarded bag (a genuine narrowing, built at that type — no cast).
-    accessibilityInputs() {
-        return {
-            testID: this.testID,
-            nativeID: this.nativeID,
-            accessible: this.accessible,
-            accessibilityLabel: this.accessibilityLabel,
-            accessibilityHint: this.accessibilityHint,
-            accessibilityRole: this.accessibilityRole,
-            accessibilityState: this.accessibilityState,
-            accessibilityValue: this.accessibilityValue,
-            accessibilityActions: this.accessibilityActions,
-            accessibilityLabelledBy: this.accessibilityLabelledBy,
-            importantForAccessibility: this.importantForAccessibility,
-            accessibilityLiveRegion: this.accessibilityLiveRegion,
-            screenReaderFocusable: this.screenReaderFocusable,
-            accessibilityViewIsModal: this.accessibilityViewIsModal,
-            accessibilityElementsHidden: this.accessibilityElementsHidden,
-            accessibilityIgnoresInvertColors: this.accessibilityIgnoresInvertColors,
-            accessibilityLanguage: this.accessibilityLanguage,
-            accessibilityRespondsToUserInteraction: this.accessibilityRespondsToUserInteraction,
-            accessibilityShowsLargeContentViewer: this.accessibilityShowsLargeContentViewer,
-            accessibilityLargeContentTitle: this.accessibilityLargeContentTitle,
-            role: this.role,
-            'aria-label': this['aria-label'],
-            'aria-labelledby': this['aria-labelledby'],
-            'aria-live': this['aria-live'],
-            'aria-hidden': this['aria-hidden'],
-            'aria-busy': this['aria-busy'],
-            'aria-checked': this['aria-checked'],
-            'aria-disabled': this['aria-disabled'],
-            'aria-expanded': this['aria-expanded'],
-            'aria-selected': this['aria-selected'],
-            'aria-modal': this['aria-modal'],
-            'aria-valuemax': this['aria-valuemax'],
-            'aria-valuemin': this['aria-valuemin'],
-            'aria-valuenow': this['aria-valuenow'],
-            'aria-valuetext': this['aria-valuetext'],
-        };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ScrollViewBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ScrollViewBase, isStandalone: true, outputs: { layout: "layout", scrollToTop: "scrollToTop", contentSizeChange: "contentSizeChange", accessibilityAction: "accessibilityAction", accessibilityTap: "accessibilityTap", magicTap: "magicTap", accessibilityEscape: "accessibilityEscape" }, queries: [{ propertyName: "projectedRefreshControl", first: true, predicate: RefreshControl, descendants: true }], viewQueries: [{ propertyName: "hostDirective", first: true, predicate: ["host"], descendants: true, read: SymbioteHostPropsDirective }], usesOnChanges: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ScrollViewBase, decorators: [{
-            type: Directive
-        }], propDecorators: { layout: [{
-                type: Output
-            }], scrollToTop: [{
-                type: Output
-            }], contentSizeChange: [{
-                type: Output
-            }], accessibilityAction: [{
-                type: Output
-            }], accessibilityTap: [{
-                type: Output
-            }], magicTap: [{
-                type: Output
-            }], accessibilityEscape: [{
-                type: Output
-            }], hostDirective: [{
-                type: ViewChild,
-                args: ['host', { read: SymbioteHostPropsDirective }]
-            }], projectedRefreshControl: [{
-                type: ContentChild,
-                args: [RefreshControl]
-            }] } });
-//# sourceMappingURL=shared.js.map