@symbiote-native/angular 0.0.0-canary-20260724081123

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

@@ -0,0 +1,682 @@
+// ScrollView, the Angular lifecycle half. The Fabric tree is nested: a scroll view
+// wraps a content view that holds the children (RN's ScrollView.js shape). The platform-invariant
+// math (decelerationRate, the per-axis intrinsics/base style, the content-size dedupe, the
+// imperative handle, the native sticky scroll-attach, the aria/role fold) lives in
+// @symbiote-native/components, shared verbatim with React/Vue. Here Angular supplies only the lifecycle:
+// the host node held by IDENTITY through a directive's ElementRef, a forwarded-prop bag set onto
+// that node through Renderer2 (-> routeProp), the imperative handle (scrollTo/scrollToEnd/
+// flashScrollIndicators), the content-size dedupe, and the native sticky scroll-attach wired
+// through whenCommitted. This is the Angular twin of the React useRef + Vue shallowRef host.
+//
+// What diverges per platform, how a RefreshControl integrates, stays in the
+// .ios/.android files (Metro filename-selected): iOS renders the RefreshControl as a SIBLING
+// before the content container; on Android an AndroidSwipeRefreshLayout WRAPS the scroll view.
+//
+// Angular cannot transform <ng-content> children in the template the way React children.map /
+// Vue slots() can, so ScrollView owns a tiny projection bridge: the content host registers a
+// ScrollViewProjectionController with the Angular renderer, and the renderer wraps direct projected
+// children whose indices match stickyHeaderIndices. Android RefreshControl projection is handled by
+// re-rendering the projected component's native prop surface as the wrapper around the scroll view
+// (RN's Android shape), while excluding the original projected node from the content slot.
+import { Directive, 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 { 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.5", ngImport: i0, type: ScrollViewProjectionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.5", type: ScrollViewProjectionDirective, isStandalone: true, selector: "[symbioteScrollViewProjection]", inputs: { symbioteScrollViewProjection: "symbioteScrollViewProjection" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", 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;
+    // 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;
+    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;
+    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');
+        if (height !== undefined)
+            this.viewportHeight = height;
+        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
+    // (identity holds across ScrollViewBase's own @Output()s and a projected RefreshControl's,
+    // since a WeakMap key is just object identity). Without this, `scrollProps`/`refreshControlProps`
+    // handed a fresh `(event) => emitter.emit(event)` closure to the forwarded prop bag on every
+    // evaluation — the same jsonEqual/Object.is function-leaf problem as the arrow fields above, one
+    // level further removed. `.observed` is checked BEFORE the cache so an unbound event still
+    // resolves to `undefined` (the "nobody cares" contract `emitterCallback`'s own comment documents),
+    // not a stale cached wrapper from before the last subscriber unsubscribed.
+    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;
+    }
+    // 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.
+    get scrollProps() {
+        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 value is driven on the UI thread
+        // by the post-commit attach below, so onScroll forwards to the user with throttle 1
+        // (ScrollView.js:1798). Without it, Animated.event drives the value each frame (the JS jitter)
+        // and forwards the user handler as the listener passthrough.
+        // The scroll-forwarding DECISIONS (which onScroll path, the 1/16 throttle defaults, whether to
+        // capture the viewport height) are folded out to the shared resolveScrollForwarding; here Angular
+        // only EXECUTES them, keeping its stable-reference handlers (stickyOnScrollHandler /
+        // handleInvertedStickyLayout / emitterCallback) so a fresh closure never forces a re-clone cascade.
+        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;
+        }
+        dlog(`Angular ScrollView -> ${this.isHorizontal ? 'horizontal' : 'vertical'} (sticky=${this.hasStickyHeaders})`);
+        bag.style = [this.scrollViewBaseStyle, this.style];
+        this.updateProjectionController();
+        return bag;
+    }
+    // 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 ever carries the explicit `[style]` @Input — a composed
+    // component's OWN anchor host (see anchorHostStyle's doc comment in primitives/shared.ts) can
+    // hold ADDITIONAL class-derived layout style that's otherwise invisible to this split, so its
+    // wrapper never gets its needed layout (collapses to zero size — the Android outer wrapper
+    // shows literally nothing on screen). This mirrors the Vue adapter's identical
+    // `layoutSplitStyle` field and the real Android device bug it fixes; the Angular Android
+    // ScrollView (index.android.ts) overrides this to merge in `anchorHostStyle`. Default here is
+    // `this.style` alone, preserving current behavior for anything that doesn't override it.
+    get layoutSplitStyle() {
+        return this.style;
+    }
+    get androidWrappedScrollProps() {
+        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;
+    }
+    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.
+    get contentProps() {
+        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;
+    }
+    // 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.
+    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() {
+        this.updateProjectionController();
+        this.attachSticky();
+    }
+    // Wire the native sticky-scroll attach after the view exists. Re-attaches if the node identity
+    // changes; no-op when sticky is off or the native module is absent.
+    attachSticky() {
+        this.cancelStickyBind?.();
+        this.cancelStickyBind = undefined;
+        if (this.detachStickyScroll !== undefined) {
+            this.detachStickyScroll();
+            this.detachStickyScroll = undefined;
+        }
+        if (!this.hasStickyHeaders || !isNativeAnimatedAvailable())
+            return;
+        const node = this.hostNode;
+        if (node === null)
+            return;
+        this.cancelStickyBind = whenCommitted(node, () => {
+            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.5", ngImport: i0, type: ScrollViewBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.5", 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 }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", 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