@symbiote-native/vue 0.5.0 → 2.0.0

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

@@ -1,271 +0,0 @@
-// ScrollView, the Vue lifecycle half. The Fabric tree is nested: a scroll view wraps a
-// content view holding the children (RN's ScrollView.js shape). Platform-invariant math
-// (decelerationRate, per-axis intrinsics/base style, content-size dedupe, imperative handle,
-// aria/role fold) lives in @symbiote-native/components, shared with React; Vue supplies only
-// the reactivity - shallowRef host node, setup-scope lastContentSize dedupe, expose() handle -
-// the twin of React's useRef + buildScrollViewHandle.
-//
-// Attrs are untyped, so every field is narrowed with a runtime guard, never a cast. The legacy
-// onContentSizeChange callback key MUST be consumed if present: it is NOT a ViewConfig event,
-// and forwarding a function prop reaches Fabric and crashes Android's folly::dynamic.
-//
-// Sticky headers are real: the scroll AnimatedValue, headerLayoutYs cross-talk map, viewport-
-// height capture, and onScroll composition (native attach vs Animated.event) live here; the
-// per-header component and children wrap live in sticky-header.ts.
-import { defineComponent, h, isVNode, markRaw, onBeforeUnmount, ref, shallowRef, watch, } from '@vue/runtime-core';
-import { attachStickyScroll, buildScrollViewHandle, didContentSizeChange, forwardScrollEvent, readLayoutDimension, resolveAccessibilityProps, resolveDecelerationRate, resolveScrollForwarding, selectScrollIntrinsics, } from '@symbiote-native/components';
-import { AnimatedValue, dlog, event as animatedEvent, isClassNameValue, isNativeAnimatedAvailable, isSymbioteNode, resolveClassName, } from '@symbiote-native/engine';
-import { wrapStickyHeaders, } from './sticky-header.js';
-import { normalizeVueAttrs } from '../../utils/normalize-attrs.js';
-function isHandler(value) {
-    return typeof value === 'function';
-}
-// Objects and arrays are valid StyleProp<ViewStyle>; primitives/null degrade to undefined.
-function isStyleProp(value) {
-    return typeof value === 'object' && value !== null;
-}
-// `class` forwards raw via forwardAttrs, resolved later by the renderer's patchProp. But the
-// Android RefreshControl wrap (index.android.ts) reads userStyle alone to splitLayoutProps()
-// the outer wrapper BEFORE that later resolution runs, so a class-only layout prop (flex,
-// height, gap, …) would otherwise never reach the wrapper.
-const isClassNameProp = isClassNameValue;
-function asDecelerationRate(value) {
-    if (typeof value === 'number')
-        return value;
-    if (value === 'normal' || value === 'fast')
-        return value;
-    return undefined;
-}
-function isNumberArray(value) {
-    return (Array.isArray(value) && value.every(entry => typeof entry === 'number'));
-}
-function isComponent(value) {
-    return (typeof value === 'function' || (typeof value === 'object' && value !== null));
-}
-// Prop/handler keys the lifecycle consumes itself; everything else forwards onto the scroll-view
-// node. onContentSizeChange is consumed (synthesized from the content onLayout); refreshControl
-// and the sticky-header props are consumed by the platform assemble / children wrap and must
-// NEVER reach Fabric.
-const HANDLED_ATTRS = [
-    'style',
-    'contentContainerStyle',
-    'horizontal',
-    'decelerationRate',
-    'onContentSizeChange',
-    'refreshControl',
-    'stickyHeaderIndices',
-    'invertStickyHeaders',
-    'StickyHeaderComponent',
-];
-function forwardAttrs(attrs) {
-    const result = {};
-    for (const key of Object.keys(attrs)) {
-        if (!HANDLED_ATTRS.includes(key))
-            result[key] = attrs[key];
-    }
-    return result;
-}
-export function createScrollView(platform) {
-    return defineComponent((_props, { slots, attrs: rawAttrs, expose, emit }) => {
-        // shallowRef, NOT ref: a plain ref() would run the node through Vue's toReactive(),
-        // handing back a Proxy the engine's WeakMap mirror doesn't recognize, so
-        // scrollTo/scrollToEnd/flashScrollIndicators would silently no-op. Same rule as Switch.
-        const nodeRef = shallowRef(null);
-        const setNodeRef = (el) => {
-            nodeRef.value = isSymbioteNode(el) ? el : null;
-        };
-        // Lazy getter, not the node captured once: it is null until the element commits, so an
-        // eager capture would freeze null. Vue twin of useImperativeHandle(ref, buildScrollViewHandle).
-        expose(buildScrollViewHandle(() => nodeRef.value));
-        // RN fires the content onLayout on every layout pass; only a real size change emits.
-        let lastContentSize = null;
-        // Drives every sticky header's translateY (RN's _scrollAnimatedValue). markRaw: an engine
-        // object held by identity, never run through toReactive. Allocated unconditionally
-        // (unused when no sticky headers are flagged), like React's unconditional hook.
-        const scrollAnimatedValue = markRaw(new AnimatedValue(0));
-        // Inverted sticky headers stick to the BOTTOM, so they need the viewport height (RN's
-        // _handleLayout). Fed back into the wrapped headers on the next render.
-        const viewportHeight = ref(undefined);
-        // Sticky-header cross-talk (RN ScrollView.js _headerLayoutYs): a child-index -> measured-y
-        // map so each header learns where the NEXT sticky header starts (its push-off collision
-        // point). Mutated imperatively from each header's onLayout; the bump ref forces the
-        // re-render that feeds the freshly-recorded y into the previous header's nextStickyHeaderY.
-        const headerLayoutYs = new Map();
-        const bumpHeaderLayout = ref(0);
-        const onHeaderLayoutY = (index, y) => {
-            if (headerLayoutYs.get(index) === y)
-                return;
-            headerLayoutYs.set(index, y);
-            dlog(`Vue ScrollView sticky-header layoutY index=${index} y=${y}`);
-            bumpHeaderLayout.value += 1;
-        };
-        // Native sticky-scroll attach (RN attachNativeEvent): when the native module is available,
-        // the scroll value is driven on the UI thread so interpolations ride scroll natively (no
-        // JS jitter). A plain non-reactive flag set in render; the post-commit watch reads it once
-        // the node commits. flush:'post' so the node has a Fabric handle before attachStickyScroll
-        // reads it. Detached on unmount and re-detached if the node identity changes.
-        let nativeStickyWanted = false;
-        let detachStickyScroll;
-        watch(() => nodeRef.value, node => {
-            if (detachStickyScroll !== undefined) {
-                detachStickyScroll();
-                detachStickyScroll = undefined;
-            }
-            if (!nativeStickyWanted || node === null)
-                return;
-            detachStickyScroll = attachStickyScroll(node, scrollAnimatedValue);
-        }, { flush: 'post' });
-        onBeforeUnmount(() => {
-            if (detachStickyScroll !== undefined)
-                detachStickyScroll();
-        });
-        return () => {
-            // Read the bump so a recorded header y re-runs render and feeds nextStickyHeaderY forward.
-            void bumpHeaderLayout.value;
-            // Fold kebab template props (:content-container-style) to the camelCase prop surface.
-            const attrs = normalizeVueAttrs(rawAttrs);
-            const isHorizontal = attrs.horizontal === true;
-            const userStyle = isStyleProp(attrs.style) ? attrs.style : undefined;
-            const classProp = isClassNameProp(attrs.class)
-                ? attrs.class
-                : undefined;
-            const layoutSplitStyle = [
-                resolveClassName(classProp),
-                userStyle,
-            ];
-            const contentContainerStyle = typeof attrs.contentContainerStyle === 'string'
-                ? resolveClassName(attrs.contentContainerStyle)
-                : isStyleProp(attrs.contentContainerStyle)
-                    ? attrs.contentContainerStyle
-                    : undefined;
-            const stickyHeaderIndices = isNumberArray(attrs.stickyHeaderIndices)
-                ? attrs.stickyHeaderIndices
-                : undefined;
-            const hasStickyHeaders = stickyHeaderIndices !== undefined && stickyHeaderIndices.length > 0;
-            const invertStickyHeaders = attrs.invertStickyHeaders === true ? true : undefined;
-            const stickyHeaderComponent = isComponent(attrs.StickyHeaderComponent)
-                ? attrs.StickyHeaderComponent
-                : undefined;
-            const { scrollViewIntrinsic, contentIntrinsic, scrollViewBaseStyle, contentStyle, } = selectScrollIntrinsics(isHorizontal, contentContainerStyle);
-            // RN defaults nested scrolling ON (ScrollView.js `nestedScrollEnabled ?? true`);
-            // horizontal forwards only when defined (load-bearing on iOS's RCTScrollView axis).
-            const outerProps = {
-                ...resolveAccessibilityProps(forwardAttrs(attrs)),
-            };
-            outerProps.nestedScrollEnabled =
-                typeof attrs.nestedScrollEnabled === 'boolean'
-                    ? attrs.nestedScrollEnabled
-                    : true;
-            if (attrs.horizontal !== undefined)
-                outerProps.horizontal = attrs.horizontal;
-            const decel = asDecelerationRate(attrs.decelerationRate);
-            if (decel !== undefined)
-                outerProps.decelerationRate = resolveDecelerationRate(decel);
-            // When sticky headers are active, the offset must reach the AnimatedValue (RN's
-            // _scrollAnimatedValueAttachment). forwardAttrs already put the user's onScroll/onLayout/
-            // scrollEventThrottle on outerProps; here we override per resolveScrollForwarding's
-            // decisions (which path, throttle default, inverted capture).
-            const nativeStickyAvailable = hasStickyHeaders && isNativeAnimatedAvailable();
-            nativeStickyWanted = nativeStickyAvailable;
-            const userThrottle = typeof attrs.scrollEventThrottle === 'number'
-                ? attrs.scrollEventThrottle
-                : undefined;
-            const forwarding = resolveScrollForwarding({
-                hasStickyHeaders,
-                nativeStickyAvailable,
-                invertStickyHeaders,
-                scrollEventThrottle: userThrottle,
-                maintainVisibleContentPosition: attrs.maintainVisibleContentPosition,
-                snapToAlignment: attrs.snapToAlignment,
-            });
-            if (hasStickyHeaders) {
-                const userOnScroll = isHandler(attrs.onScroll)
-                    ? attrs.onScroll
-                    : undefined;
-                if (forwarding.mode === 'sticky-js') {
-                    // JS fallback (no native module): correct, but lags a frame under fast scroll, which
-                    // the native path removes on a real host.
-                    outerProps.onScroll = animatedEvent([{ nativeEvent: { contentOffset: { y: scrollAnimatedValue } } }], userOnScroll === undefined
-                        ? undefined
-                        : {
-                            listener: (...args) => forwardScrollEvent(userOnScroll, args),
-                        });
-                }
-                // Native path: the value is driven on the UI thread by the post-commit watch above, so
-                // onScroll forwards untouched.
-                if (forwarding.scrollEventThrottle !== undefined) {
-                    outerProps.scrollEventThrottle = forwarding.scrollEventThrottle;
-                }
-                // Capture the viewport height for inverted sticky headers (RN _handleLayout), then call
-                // the user's handler.
-                if (forwarding.capturesViewportHeight) {
-                    const userOnLayout = isHandler(attrs.onLayout)
-                        ? attrs.onLayout
-                        : undefined;
-                    outerProps.onLayout = (event) => {
-                        const height = readLayoutDimension(event, 'height');
-                        if (height !== undefined)
-                            viewportHeight.value = height;
-                        if (userOnLayout !== undefined)
-                            userOnLayout(event);
-                    };
-                }
-            }
-            dlog(`Vue ScrollView -> ${scrollViewIntrinsic} (horizontal=${isHorizontal} sticky=${hasStickyHeaders})`);
-            // `collapsable: false` keeps the layout-only content view as a real native view: Android
-            // Fabric view-flattens it away otherwise, hoisting the cells as direct children of the
-            // scroll view (which hosts exactly one) - an addViewAt crash. iOS never flattens.
-            const contentProps = {
-                style: contentStyle,
-                collapsable: false,
-            };
-            if (forwarding.collapsableChildren) {
-                contentProps.collapsableChildren = false;
-            }
-            // Synthesized from the content view's own onLayout (RN _handleContentOnLayout); emit only
-            // on a real size change.
-            contentProps.onLayout = (event) => {
-                const width = readLayoutDimension(event, 'width');
-                const height = readLayoutDimension(event, 'height');
-                if (width === undefined || height === undefined)
-                    return;
-                if (!didContentSizeChange(lastContentSize, { width, height }))
-                    return;
-                lastContentSize = { width, height };
-                dlog(`Vue ScrollView contentSizeChange ${width}x${height}`);
-                emit('contentSizeChange', width, height);
-            };
-            const slotChildren = slots.default !== undefined ? slots.default() : [];
-            const contentChildren = hasStickyHeaders
-                ? wrapStickyHeaders(slotChildren, stickyHeaderIndices, scrollAnimatedValue, invertStickyHeaders, viewportHeight.value, stickyHeaderComponent, headerLayoutYs, onHeaderLayoutY)
-                : slotChildren;
-            const content = h(contentIntrinsic, contentProps, contentChildren);
-            // Base style UNDER user style so an explicit user value (height, flexDirection) still wins.
-            const scrollProps = {
-                ...outerProps,
-                style: [scrollViewBaseStyle, userStyle],
-                ref: setNodeRef,
-            };
-            const refreshControl = isVNode(attrs.refreshControl)
-                ? attrs.refreshControl
-                : undefined;
-            return platform.assemble({
-                scrollViewIntrinsic,
-                scrollProps,
-                content,
-                refreshControl,
-                scrollViewBaseStyle,
-                userStyle,
-                layoutSplitStyle,
-                scrollOuterProps: outerProps,
-                setNodeRef,
-            });
-        };
-    }, {
-        name: 'ScrollView',
-        inheritAttrs: false,
-        emits: {
-            contentSizeChange: (_width, _height) => true,
-        },
-    });
-}

package/build/components/scroll-view/sticky-header.d.ts

@@ -1,7 +0,0 @@
-import { type Component, type VNode } from '@vue/runtime-core';
-import { AnimatedValue } from '@symbiote-native/engine';
-export type IStickyHeaderComponentType = Component;
-export declare const ScrollViewStickyHeader: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export declare function wrapStickyHeaders(children: VNode[], stickyHeaderIndices: number[] | undefined, scrollAnimatedValue: AnimatedValue, invertStickyHeaders: boolean | undefined, scrollViewHeight: number | undefined, StickyHeaderComponent: IStickyHeaderComponentType | undefined, headerLayoutYs: ReadonlyMap<number, number>, onHeaderLayoutY: (index: number, y: number) => void): VNode[];

package/build/components/scroll-view/sticky-header.js

@@ -1,208 +0,0 @@
-// Sticky headers: the Vue twin of adapters/react/src/scroll-view-sticky-header.tsx, the JS layer
-// RN implements in ScrollView.js / ScrollViewStickyHeader.js.
-//
-// RN does stickiness PURELY IN JS: ScrollView.js wraps each flagged child in a
-// ScrollViewStickyHeader fed by a single _scrollAnimatedValue that Animated.event drives from
-// onScroll. The native scroll view does NOT honor the index array itself, so forwarding
-// stickyHeaderIndices to native is a silent no-op - we replicate the JS layer instead. The
-// interpolation math (non-inverted + inverted) lives framework-agnostic in
-// @symbiote-native/components (computeStickyInterpolation); this file holds the Vue component
-// shell, layout state, and child-wrapping. Vue supplies only the reactive lifecycle
-// (refs/watch instead of useState/useEffect).
-import { defineComponent, h, isVNode, onBeforeUnmount, ref, shallowRef, watchEffect, markRaw, } from '@vue/runtime-core';
-import { AnimatedValue, AnimatedInterpolation, Platform, dlog, } from '@symbiote-native/engine';
-import { createInitialStickyState, nextStickyHeaderY, readLayoutNumber, reduceSticky, STICKY_HEADER_Z_INDEX, } from '@symbiote-native/components';
-import { Animated } from '../../modules/animated/index.js';
-function isHandler(value) {
-    return typeof value === 'function';
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function isAnimatedValue(value) {
-    return value instanceof AnimatedValue;
-}
-// So the sticky wrapper can forward layout to the child (RN calls the child's onLayout after its own).
-function readChildOnLayout(child) {
-    if (!isRecord(child.props))
-        return undefined;
-    const handler = child.props.onLayout;
-    return isHandler(handler) ? handler : undefined;
-}
-// One sticky header. Measures its own y/height via onLayout, interpolates the shared scroll
-// offset into a translateY pinning it to the top (or bottom, inverted) until the next header
-// collides with it, driven through the native driver when available (no JS jitter). Ported from
-// ScrollViewStickyHeader.js, including the Fabric ShadowTree debounce path. inheritAttrs:false
-// so the IStickyHeaderProps inputs never fall through onto Animated.View and reach Fabric as
-// props (scrollAnimatedValue on a host node would crash Android's folly::dynamic).
-export const ScrollViewStickyHeader = defineComponent({
-    name: 'ScrollViewStickyHeader',
-    inheritAttrs: false,
-    setup(_props, { attrs, slots }) {
-        // Read once - stable across renders (the same markRaw'd AnimatedValue). Held by IDENTITY, never
-        // run through toReactive. A fresh fallback keeps working if wrapStickyHeaders ever fails to supply it.
-        const scrollAnimatedValue = isAnimatedValue(attrs.scrollAnimatedValue)
-            ? attrs.scrollAnimatedValue
-            : markRaw(new AnimatedValue(0));
-        // Mutated in place by reduceSticky. A plain object, not a ref: render reads it gated by the
-        // reactive `version` bump + `animatedTranslateY` below. DECISIONS (zero-swallow gate,
-        // debounce delay, rebuild ranges) all live in reduceSticky.
-        const state = createInitialStickyState();
-        // Bumped when the reducer commits a new translateY, forcing render to re-read state.translateY.
-        const version = ref(0);
-        // Engine node -> shallowRef (identity rule); the un-measured identity stub until the
-        // rebuild-interpolation effect below replaces it.
-        const animatedTranslateY = shallowRef(scrollAnimatedValue.interpolate({
-            inputRange: [-1, 0],
-            outputRange: [0, 0],
-        }));
-        let debounceTimer;
-        // Held so the next rebuild detaches the old listener and onBeforeUnmount cleans up.
-        let interpolation;
-        let listenerId;
-        const inputs = () => ({
-            os: Platform.OS,
-            inverted: typeof attrs.inverted === 'boolean' ? attrs.inverted : undefined,
-            scrollViewHeight: typeof attrs.scrollViewHeight === 'number'
-                ? attrs.scrollViewHeight
-                : undefined,
-            nextHeaderLayoutY: typeof attrs.nextHeaderLayoutY === 'number'
-                ? attrs.nextHeaderLayoutY
-                : undefined,
-        });
-        const runEffects = (effects) => {
-            for (const effect of effects) {
-                switch (effect.kind) {
-                    case 'rebuild-interpolation': {
-                        // Detach the old listener, build a fresh interpolation, and wire the settled-value listener.
-                        if (interpolation !== undefined && listenerId !== undefined) {
-                            interpolation.removeListener(listenerId);
-                            listenerId = undefined;
-                        }
-                        const next = scrollAnimatedValue.interpolate({
-                            inputRange: effect.inputRange,
-                            outputRange: effect.outputRange,
-                        });
-                        listenerId = next.addListener(({ value }) => {
-                            if (typeof value === 'number')
-                                dispatch({ kind: 'animated-tick', value });
-                        });
-                        interpolation = next;
-                        animatedTranslateY.value = next;
-                        break;
-                    }
-                    case 'schedule-debounce':
-                        // The animated value updates several times per frame; debounce the settled value so
-                        // hit detection stays current (a Fabric issue, worse on Android).
-                        if (debounceTimer !== undefined)
-                            clearTimeout(debounceTimer);
-                        debounceTimer = setTimeout(() => {
-                            debounceTimer = undefined;
-                            dispatch({ kind: 'debounce-fired', value: effect.value });
-                        }, effect.delay);
-                        break;
-                    case 'apply-passthrough':
-                        version.value += 1;
-                        break;
-                    case 'record-header-y':
-                        // Vue records through attrs.onLayout (the wrapper closure); the reducer emits no index for it.
-                        break;
-                }
-            }
-        };
-        const dispatch = (action) => {
-            runEffects(reduceSticky(state, action, inputs()).effects);
-        };
-        // Rebuild whenever the collision/viewport inputs change ([inverted, scrollViewHeight,
-        // nextHeaderLayoutY]); also runs once on mount.
-        watchEffect(() => {
-            dispatch({ kind: 'inputs-changed' });
-        });
-        onBeforeUnmount(() => {
-            if (interpolation !== undefined && listenerId !== undefined) {
-                interpolation.removeListener(listenerId);
-            }
-            if (debounceTimer !== undefined)
-                clearTimeout(debounceTimer);
-        });
-        // Dispatch the layout, fire the wrapper's recorder (onHeaderLayoutY via attrs.onLayout), then
-        // the child's own onLayout. Matches RN ScrollViewStickyHeader.js._onLayout.
-        const onLayout = (event) => {
-            const y = readLayoutNumber(event, 'y');
-            const height = readLayoutNumber(event, 'height');
-            // Keep the previous value when a field is absent (RN sets state only on a defined read).
-            dispatch({
-                kind: 'layout',
-                y: y ?? state.layoutY,
-                height: height ?? state.layoutHeight,
-            });
-            const recorder = attrs.onLayout;
-            if (isHandler(recorder))
-                recorder(event);
-            const children = slots.default !== undefined ? slots.default() : [];
-            const child = children[0];
-            const childOnLayout = isVNode(child)
-                ? readChildOnLayout(child)
-                : undefined;
-            if (childOnLayout !== undefined)
-                childOnLayout(event);
-        };
-        return () => {
-            // Read the version bump so a committed translateY re-runs render.
-            void version.value;
-            // The EXPLICIT debounced translateY overrides the committed transform for hit-testing, while
-            // animatedTranslateY does the smooth (native-driven) pin.
-            const passthroughAnimatedPropExplicitValues = state.translateY !== null
-                ? { style: { transform: [{ translateY: state.translateY }] } }
-                : null;
-            // collapsable:false keeps the wrapper a real Yoga node; zIndex makes the pinned header paint
-            // OVER the rows scrolling under it.
-            return h(Animated.View, {
-                style: {
-                    transform: [{ translateY: animatedTranslateY.value }],
-                    zIndex: STICKY_HEADER_Z_INDEX,
-                },
-                onLayout,
-                collapsable: false,
-                passthroughAnimatedPropExplicitValues,
-            }, { default: () => (slots.default !== undefined ? slots.default() : []) });
-        };
-    },
-});
-// Wrap each child flagged by `stickyHeaderIndices` in the sticky header component, fed by the
-// shared scroll AnimatedValue. Returns the children unchanged when no indices are flagged.
-//
-// Cross-talk plumbing (RN's _headerLayoutYs + _onStickyHeaderLayout): headerLayoutYs is a
-// child-index -> measured-y map; each header reports its own y through onHeaderLayoutY, and we
-// feed every header the y of the NEXT flagged header (the collision point past which it scrolls
-// off). The LAST flagged header has no successor, so its nextHeaderLayoutY stays undefined and
-// it sticks indefinitely (correct).
-export function wrapStickyHeaders(children, stickyHeaderIndices, scrollAnimatedValue, invertStickyHeaders, scrollViewHeight, StickyHeaderComponent, headerLayoutYs, onHeaderLayoutY) {
-    if (stickyHeaderIndices === undefined || stickyHeaderIndices.length === 0)
-        return children;
-    const Wrapper = StickyHeaderComponent ?? ScrollViewStickyHeader;
-    return children.map((child, index) => {
-        const indexOfIndex = stickyHeaderIndices.indexOf(index);
-        if (indexOfIndex === -1 || !isVNode(child))
-            return child;
-        // The next flagged header's measured y. undefined until that header has measured (or for the last).
-        const nextIndex = stickyHeaderIndices[indexOfIndex + 1];
-        const nextHeaderLayoutY = nextStickyHeaderY(stickyHeaderIndices, indexOfIndex, headerLayoutYs);
-        dlog(`Vue ScrollView sticky-header wrap index=${index} next=${nextIndex} nextY=${nextHeaderLayoutY}`);
-        const props = {
-            key: child.key ?? `sticky-${index}`,
-            nextHeaderLayoutY,
-            // Record this header's own y into the parent map; the lookup above feeds it forward to the
-            // previous header on the resulting re-render (the headerLayoutYs bump in scroll-view-shared).
-            onLayout: (event) => {
-                const y = readLayoutNumber(event, 'y');
-                if (y !== undefined)
-                    onHeaderLayoutY(index, y);
-            },
-            scrollAnimatedValue,
-            inverted: invertStickyHeaders,
-            scrollViewHeight,
-        };
-        return h(Wrapper, props, { default: () => [child] });
-    });
-}

package/build/components/switch/index.android.d.ts

@@ -1,12 +0,0 @@
-export declare const Switch: import("vue").DefineSetupFnComponent<import("./shared").ISwitchProps, {
-    valueChange: (value: boolean, event: import("@symbiote-native/engine").ISymbioteEvent) => boolean;
-    'update:modelValue': (value: boolean) => boolean;
-    'update:value': (value: boolean) => boolean;
-}, {}, Omit<import("@symbiote-native/components").ISwitchProps, "onValueChange"> & {
-    modelValue?: boolean;
-    class?: import("@symbiote-native/engine").IClassNameValue;
-} & {
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    "onUpdate:value"?: ((value: boolean) => any) | undefined;
-    onValueChange?: ((value: boolean, event: import("@symbiote-native/engine").ISymbioteEvent) => any) | undefined;
-}, import("vue").PublicProps>;

package/build/components/switch/index.android.js

@@ -1,13 +0,0 @@
-// Switch on Android: AndroidSwitch takes trackColorForTrue / trackColorForFalse plus
-// trackTintColor (the color for the CURRENT value), and snaps native back via the
-// `setNativeValue` command. Metro picks this on an Android host; no Platform.OS read.
-// Mirrors the React adapter's Android binding.
-import { createSwitch } from './shared.js';
-export const Switch = createSwitch({
-    snapBackCommand: 'setNativeValue',
-    trackColorProps: (value, trackColor) => ({
-        trackColorForFalse: trackColor?.false,
-        trackColorForTrue: trackColor?.true,
-        trackTintColor: value ? trackColor?.true : trackColor?.false,
-    }),
-});

package/build/components/switch/index.d.ts

@@ -1,2 +0,0 @@
-export * from './index.ios';
-export type { ISwitchProps, ISwitchTrackColor } from './shared';

package/build/components/switch/index.ios.d.ts

@@ -1,12 +0,0 @@
-export declare const Switch: import("vue").DefineSetupFnComponent<import("./shared").ISwitchProps, {
-    valueChange: (value: boolean, event: import("@symbiote-native/engine").ISymbioteEvent) => boolean;
-    'update:modelValue': (value: boolean) => boolean;
-    'update:value': (value: boolean) => boolean;
-}, {}, Omit<import("@symbiote-native/components").ISwitchProps, "onValueChange"> & {
-    modelValue?: boolean;
-    class?: import("@symbiote-native/engine").IClassNameValue;
-} & {
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    "onUpdate:value"?: ((value: boolean) => any) | undefined;
-    onValueChange?: ((value: boolean, event: import("@symbiote-native/engine").ISymbioteEvent) => any) | undefined;
-}, import("vue").PublicProps>;

package/build/components/switch/index.ios.js

@@ -1,11 +0,0 @@
-// Switch on iOS: the native Switch takes onTintColor (ON-track) / tintColor (OFF-track) and
-// snaps native back via the `setValue` command. Also the base (switch.ts re-exports it) for
-// headless / web. Mirrors the React adapter's iOS binding.
-import { createSwitch } from './shared.js';
-export const Switch = createSwitch({
-    snapBackCommand: 'setValue',
-    trackColorProps: (_value, trackColor) => ({
-        onTintColor: trackColor?.true,
-        tintColor: trackColor?.false,
-    }),
-});

package/build/components/switch/index.js

@@ -1,5 +0,0 @@
-// Base / default Switch. Re-exports the iOS build. Metro overrides this with switch.ios.ts /
-// switch.android.ts on a real host; under tsx / tsc / web the host resolves here. Filename is
-// the selector, no Platform.OS read. Switch is the first component to bring the
-// state half (the reducer) into the Vue adapter: render-and-state, not render-only.
-export * from './index.ios.js';

package/build/components/switch/shared.d.ts

@@ -1,23 +0,0 @@
-import { type ISwitchPlatform, type ISwitchProps as ISwitchBaseProps, type ISwitchTrackColor } from '@symbiote-native/components';
-import { type IClassNameValue, type ISymbioteEvent } from '@symbiote-native/engine';
-type ISwitchHostPlatform = ISwitchPlatform & {
-    snapBackCommand: string;
-};
-export type ISwitchProps = Omit<ISwitchBaseProps, 'onValueChange'> & {
-    modelValue?: boolean;
-    class?: IClassNameValue;
-};
-export type { ISwitchTrackColor };
-type ISwitchEmits = {
-    valueChange: (value: boolean, event: ISymbioteEvent) => boolean;
-    'update:modelValue': (value: boolean) => boolean;
-    'update:value': (value: boolean) => boolean;
-};
-export declare function createSwitch(platform: ISwitchHostPlatform): import("vue").DefineSetupFnComponent<ISwitchProps, ISwitchEmits, {}, Omit<ISwitchBaseProps, "onValueChange"> & {
-    modelValue?: boolean;
-    class?: IClassNameValue;
-} & {
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    "onUpdate:value"?: ((value: boolean) => any) | undefined;
-    onValueChange?: ((value: boolean, event: ISymbioteEvent) => any) | undefined;
-}, import("vue").PublicProps>;