@symbiote-native/react 1.0.0 → 2.0.0

package/build/components/text-input/index.d.ts

@@ -1,50 +0,0 @@
-import { type ISymbioteEvent } from '@symbiote-native/engine';
-import type { ITextInputProps as ITextInputBaseProps, ITextInputHandle } from '@symbiote-native/components';
-export type { ITextInputHandle } from '@symbiote-native/components';
-export type ITextInputProps = ITextInputBaseProps & {
-    className?: string;
-};
-export declare const TextInput: import("react").ForwardRefExoticComponent<import("@symbiote-native/components").IAccessibilityProps & import("@symbiote-native/components").IAriaProps & {
-    value?: string;
-    defaultValue?: string;
-    placeholder?: string;
-    placeholderTextColor?: string;
-    editable?: boolean;
-    keyboardType?: string;
-    secureTextEntry?: boolean;
-    maxLength?: number;
-    multiline?: boolean;
-    selection?: import("@symbiote-native/components").ITextInputSelection;
-    autoCapitalize?: "none" | "sentences" | "words" | "characters";
-    autoCorrect?: boolean;
-    autoComplete?: string;
-    textContentType?: string;
-    autoFocus?: boolean;
-    showSoftInputOnFocus?: boolean;
-    returnKeyType?: string;
-    selectTextOnFocus?: boolean;
-    scrollEnabled?: boolean;
-    numberOfLines?: number;
-    textAlign?: "left" | "center" | "right";
-    blurOnSubmit?: boolean;
-    inputMode?: import("@symbiote-native/components").IInputMode;
-    enterKeyHint?: import("@symbiote-native/components").IEnterKeyHint;
-    readOnly?: boolean;
-    submitBehavior?: import("@symbiote-native/components").ISubmitBehavior;
-    cursorColor?: string;
-    selectionColor?: string;
-    selectionHandleColor?: string;
-    underlineColorAndroid?: string;
-    inputAccessoryViewID?: string;
-    style?: import("@symbiote-native/engine").ITextStyle;
-    onValueChange?: (text: string, event: ISymbioteEvent) => void;
-    onFocus?: import("@symbiote-native/components").ITextInputEventHandler;
-    onBlur?: import("@symbiote-native/components").ITextInputEventHandler;
-    onEndEditing?: import("@symbiote-native/components").ITextInputEventHandler;
-    onSubmitEditing?: import("@symbiote-native/components").ITextInputEventHandler;
-    onKeyPress?: import("@symbiote-native/components").ITextInputEventHandler;
-    onSelectionChange?: import("@symbiote-native/components").ITextInputEventHandler;
-    onContentSizeChange?: import("@symbiote-native/components").ITextInputEventHandler;
-} & {
-    className?: string;
-} & import("react").RefAttributes<ITextInputHandle>>;

package/build/components/text-input/index.js

@@ -1,180 +0,0 @@
-// TextInput: the React lifecycle half. The folds/maps (value->text, the W3C/alias resolution)
-// and the controlled-write predicate live in @symbiote-native/components/state; the render (intrinsic
-// + native-prop mapping) in @symbiote-native/components/view; both shared verbatim with the Vue
-// adapter. Here React supplies only the lifecycle: useState for the acknowledged event count
-// (it must re-render so the imperative handle echoes the latest), a ref for the host node and
-// the last text native holds, the useLayoutEffect controlled-write, the mount autoFocus, and
-// useImperativeHandle for focus/blur/clear/isFocused/setSelection.
-//
-// The controlled handshake hinges on commanding native back with the ACKNOWLEDGED event count
-// (setTextAndSelection), never a plain prop re-push. See @symbiote-native/components/state/text-input.
-import { forwardRef, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState, } from 'react';
-import { dispatchViewCommand, dlog, } from '@symbiote-native/engine';
-import { blurTextInput, setInputBlurred, setInputFocused, } from '@symbiote-native/engine';
-import { resolveAccessibilityProps, resolveTextInputProps, renderTextInput, foldText, textFromChange, eventCountFromChange, shouldCommandText, INITIAL_EVENT_COUNT, SELECTION_NONE, } from '@symbiote-native/components';
-import { descriptorToReact } from '../../descriptor-to-react/index.js';
-export const TextInput = forwardRef((rawProps, forwardedRef) => {
-    // TextInput is its own host element (not a View wrapper), so it folds aria/role here.
-    const props = resolveAccessibilityProps(rawProps);
-    // Pull out the fields the lifecycle owns (controlled value, the wrapped handlers, the folded
-    // aliases) so they don't reach Fabric raw; everything else rides down via `passthrough`.
-    const { value, defaultValue, multiline, selection, onValueChange, onFocus, onBlur, inputMode, enterKeyHint, readOnly, submitBehavior, blurOnSubmit, cursorColor, selectionColor, selectionHandleColor, keyboardType, returnKeyType, editable, autoComplete, textContentType, autoFocus, showSoftInputOnFocus, underlineColorAndroid, ...passthrough } = props;
-    const isMultiline = multiline === true;
-    const folded = resolveTextInputProps({
-        inputMode,
-        keyboardType,
-        enterKeyHint,
-        returnKeyType,
-        readOnly,
-        editable,
-        submitBehavior,
-        blurOnSubmit,
-        multiline: isMultiline,
-        cursorColor,
-        selectionColor,
-        selectionHandleColor,
-        autoComplete,
-        textContentType,
-        showSoftInputOnFocus,
-        underlineColorAndroid,
-    });
-    const ref = useRef(null);
-    // JS-side focus state, mirrored from the focus/blur events for isFocused(). RN's
-    // TextInputState holds the same; native exposes no synchronous focus getter.
-    const focused = useRef(false);
-    // The count native last acknowledged. We echo it back on every controlled write so native's
-    // eventLag lands on 0 and the write applies.
-    const [mostRecentEventCount, setMostRecentEventCount] = useState(INITIAL_EVENT_COUNT);
-    // The last text native holds, as far as JS knows. Seeded from the mount-time value because the
-    // `text` prop already carries that value down via createNode, so the FIRST controlled value is
-    // not a divergence and must NOT re-command. Only later, post-keystroke divergences flow through
-    // setTextAndSelection.
-    const lastNativeText = useRef(foldText(value, defaultValue));
-    const handleChange = useCallback((event) => {
-        // Event seam: the controlled handshake hinges on the change payload carrying `text`
-        // (+ `eventCount`). iOS and Android Fabric can key these differently, so log the actual
-        // shape here; a missing `text` means onValueChange never fires.
-        dlog(`TextInput change keys=[${Object.keys(event.nativeEvent).join(',')}] ` +
-            `text=${JSON.stringify(event.nativeEvent.text)} count=${JSON.stringify(event.nativeEvent.eventCount)}`);
-        const text = textFromChange(event);
-        if (text !== undefined) {
-            lastNativeText.current = text;
-            onValueChange?.(text, event);
-        }
-        // Ordering matters: record the text first, then bump the acknowledged count, so the count
-        // never runs ahead of the text it stands for.
-        const count = eventCountFromChange(event);
-        if (count !== undefined)
-            setMostRecentEventCount(count);
-    }, [onValueChange]);
-    const text = foldText(value, defaultValue);
-    // Controlled write: when JS-side `value` diverges from what native reported, command the new
-    // text down with the acknowledged count. A plain prop re-push would race the user's keystrokes;
-    // the command is the only stale-safe path. No deps; it runs after every render and the
-    // predicate makes it a no-op unless the text diverged.
-    useLayoutEffect(() => {
-        const node = ref.current;
-        if (node === null)
-            return;
-        if (!shouldCommandText(lastNativeText.current, value))
-            return;
-        const selStart = selection?.start ?? SELECTION_NONE;
-        const selEnd = selection?.end ?? selection?.start ?? SELECTION_NONE;
-        dlog(`TextInput setTextAndSelection count=${mostRecentEventCount} text=${JSON.stringify(value)}`);
-        dispatchViewCommand(node, 'setTextAndSelection', [
-            mostRecentEventCount,
-            value,
-            selStart,
-            selEnd,
-        ]);
-        lastNativeText.current = value;
-    });
-    // autoFocus is driven in JS, not as a native prop: on mount, command `focus` down once (RN does
-    // the same via TextInputState.focusInput, TextInput.js:538). Empty deps so it fires only on
-    // mount; the native `focus` command is idempotent if already focused.
-    useEffect(() => {
-        if (autoFocus !== true)
-            return;
-        const node = ref.current;
-        if (node === null)
-            return;
-        dlog('TextInput autoFocus -> focus command');
-        dispatchViewCommand(node, 'focus', []);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
-    const handleFocus = useCallback((event) => {
-        focused.current = true;
-        // Track focus app-wide so Keyboard.dismiss can blur this input without a ref.
-        if (ref.current !== null)
-            setInputFocused(ref.current);
-        onFocus?.(event);
-    }, [onFocus]);
-    const handleBlur = useCallback((event) => {
-        focused.current = false;
-        if (ref.current !== null)
-            setInputBlurred(ref.current);
-        onBlur?.(event);
-    }, [onBlur]);
-    // The imperative API RN exposes on the ref. focus/blur drive native view commands; clear and
-    // setSelection reuse setTextAndSelection (the same stale-safe path as a controlled write),
-    // echoing the acknowledged event count so native applies them.
-    useImperativeHandle(forwardedRef, () => ({
-        // Forwarded from the node so a TextInput ref is not poorer than any other host ref. An
-        // `expose`/`useImperativeHandle` that lists only the five TextInput methods CLOSES the
-        // node off, and the lowered path loses the opposite four — two different surfaces an app
-        // crosses between without touching its ref code. `ITextInputHandle` carries the account.
-        measure: (callback) => ref.current?.measure(callback),
-        measureInWindow: (callback) => ref.current?.measureInWindow(callback),
-        measureLayout: (relativeToNativeNode, onSuccess, onFail) => ref.current?.measureLayout(relativeToNativeNode, onSuccess, onFail),
-        setNativeProps: (nativeProps) => ref.current?.setNativeProps(nativeProps),
-        focus: () => {
-            const node = ref.current;
-            if (node !== null)
-                dispatchViewCommand(node, 'focus', []);
-        },
-        blur: () => {
-            // Routes through TextInputState so the app-wide focus tracking clears too.
-            blurTextInput(ref.current);
-        },
-        clear: () => {
-            const node = ref.current;
-            if (node === null)
-                return;
-            dispatchViewCommand(node, 'setTextAndSelection', [
-                mostRecentEventCount,
-                '',
-                0,
-                0,
-            ]);
-            lastNativeText.current = '';
-        },
-        isFocused: () => focused.current,
-        setSelection: (start, end) => {
-            const node = ref.current;
-            if (node === null)
-                return;
-            const current = lastNativeText.current ?? '';
-            dispatchViewCommand(node, 'setTextAndSelection', [
-                mostRecentEventCount,
-                current,
-                start,
-                end,
-            ]);
-        },
-    }), [mostRecentEventCount]);
-    return descriptorToReact(renderTextInput({
-        multiline: isMultiline,
-        text,
-        mostRecentEventCount,
-        selection,
-        folded,
-        passthrough: {
-            ...passthrough,
-            ref,
-            onChange: handleChange,
-            onFocus: handleFocus,
-            onBlur: handleBlur,
-        },
-    }));
-});
-TextInput.displayName = 'TextInput';

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

@@ -1,22 +0,0 @@
-import { type FC, type ReactNode } from 'react';
-import { type IPressTimingProps } from '@symbiote-native/components';
-import { type IPressableProps } from '../pressable';
-import type { IStyleProp, IViewStyle } from '../../utils/styles';
-type ITouchableBaseProps = Omit<IPressableProps, 'style' | 'children'> & IPressTimingProps & {
-    style?: IStyleProp<IViewStyle>;
-    children?: ReactNode;
-};
-export interface ITouchableOpacityProps extends ITouchableBaseProps {
-    activeOpacity?: number;
-}
-export declare const TouchableOpacity: FC<ITouchableOpacityProps>;
-export interface ITouchableHighlightProps extends ITouchableBaseProps {
-    activeOpacity?: number;
-    underlayColor?: string;
-    onShowUnderlay?: () => void;
-    onHideUnderlay?: () => void;
-}
-export declare const TouchableHighlight: FC<ITouchableHighlightProps>;
-export type ITouchableWithoutFeedbackProps = ITouchableBaseProps;
-export declare const TouchableWithoutFeedback: FC<ITouchableWithoutFeedbackProps>;
-export {};

package/build/components/touchable/index.js

@@ -1,165 +0,0 @@
-// The Touchable* family, all built on Pressable. Ported against RN's own sources
-// (.vendors/react-native/.../Components/Touchable/*.js) after the 2026-08-19 audit found ten
-// divergences; the shared halves live in @symbiote-native/components and React owns only the
-// lifecycle — refs, effects, the real timers, the Animated wiring, and the child clone:
-//   TouchableOpacity:   an Animated.Value fades toward activeOpacity on press-in and back to the
-//     style's own resting opacity on press-out, driven from onPressIn/onPressOut.
-//   TouchableHighlight: the underlay machine drives a `shown` flag (NOT `pressed` — RN holds the
-//     underlay for delayPressOut past the tap); the container takes the underlay color and the
-//     child takes the lowered opacity, RN's split.
-//   TouchableWithoutFeedback: the same press-timing machine with the visual half left empty —
-//     "without feedback" means no VISUAL, not no timing.
-import { Children, cloneElement, createElement, isValidElement, useEffect, useRef, useState, } from 'react';
-import { createHighlightUnderlayHandlers, createHighlightUnderlayRuntime, createTouchableFeedbackHandlers, createTouchableFeedbackRuntime, hasTouchablePressHandler, resolveHighlightExtraStyles, restingOpacityFromStyle, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_GRANT_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, TOUCHABLE_MIN_PRESS_DURATION_MS, } from '@symbiote-native/components';
-import { TouchablePressable as Pressable, } from '../pressable/index.js';
-import { Animated } from '../../modules/animated/index.js';
-// The real setTimeout the shared machines schedule on (core/components has no timer globals).
-// Returns a canceller so an early release flushes the timer.
-function scheduleTimeout(callback, ms) {
-    const id = setTimeout(callback, ms);
-    return () => clearTimeout(id);
-}
-export const TouchableOpacity = props => {
-    const { activeOpacity = DEFAULT_ACTIVE_OPACITY, style, 
-    // className is pulled out here, like style, and applied to the inner Animated.View below —
-    // left in ...rest it would land on the outer Pressable instead, which is not where `style`
-    // (the opacity-fade node) goes.
-    className, children, disabled, onPressIn, onPressOut, delayPressIn = 0, delayPressOut = 0, 
-    // RN's Touchables override Pressability's 130ms floor with 0 (TouchableOpacity.js:195); the
-    // active visual is held by the fade's own duration instead.
-    minPressDuration = TOUCHABLE_MIN_PRESS_DURATION_MS, ...rest } = props;
-    // RN's _getChildStyleOpacityWithDefault: the fade settles at the opacity the CALLER's style
-    // asks for, not at a hard 1 — and must START there, or the first paint jumps to fully opaque.
-    const restingOpacity = restingOpacityFromStyle(style);
-    // One Animated.Value per mount. The Animated.View leaf commits its current value every frame,
-    // so timing it animates the real view.
-    const opacity = useRef(new Animated.Value(restingOpacity)).current;
-    // The shared press-scheduling cell (delayPressIn timer + activation clock), held across renders.
-    const runtime = useRef(createTouchableFeedbackRuntime()).current;
-    function setOpacityTo(toValue, duration) {
-        // useNativeDriver: true is RN's own (TouchableOpacity.js:242). opacity is natively drivable
-        // and the fade then survives a busy JS thread, which is the whole point of the feedback.
-        Animated.timing(opacity, {
-            toValue,
-            duration,
-            easing: Animated.Easing.inOut(Animated.Easing.quad),
-            useNativeDriver: true,
-        }).start();
-    }
-    // RN's componentDidUpdate: a changed `disabled` or a changed style opacity re-settles the view,
-    // so a Touchable disabled mid-press does not stay stuck at its active opacity.
-    const hasRendered = useRef(false);
-    useEffect(() => {
-        // RN runs this on UPDATE only. Firing at mount would animate over the value the
-        // Animated.Value was just constructed with.
-        if (!hasRendered.current) {
-            hasRendered.current = true;
-            return;
-        }
-        setOpacityTo(restingOpacity, OPACITY_INACTIVE_DURATION_MS);
-        // eslint-disable-next-line react-hooks/exhaustive-deps -- setOpacityTo is re-made per render
-    }, [disabled, restingOpacity]);
-    // RN's componentWillUnmount: stop the fade so a teardown mid-animation leaves no driver running
-    // against a node that is gone.
-    useEffect(() => () => {
-        opacity.resetAnimation();
-    }, [opacity]);
-    // The shared machine owns the delayPressIn/minPressDuration scheduling; the adapter supplies only
-    // the native seam — the Animated opacity fade + the framework emit — as activate/deactivate.
-    const { handlePressIn, handlePressOut } = createTouchableFeedbackHandlers({
-        delayPressIn,
-        delayPressOut,
-        minPressDuration,
-        schedule: scheduleTimeout,
-        now: Date.now,
-    }, runtime, {
-        activate(event) {
-            setOpacityTo(activeOpacity, OPACITY_ACTIVE_GRANT_DURATION_MS);
-            onPressIn?.(event);
-        },
-        deactivate(event) {
-            setOpacityTo(restingOpacity, OPACITY_INACTIVE_DURATION_MS);
-            onPressOut?.(event);
-        },
-    });
-    return createElement(Pressable, { ...rest, disabled, onPressIn: handlePressIn, onPressOut: handlePressOut }, createElement(Animated.View, { style: [style, { opacity }], className }, children));
-};
-// RN's render: the lowered opacity is cloned onto the CHILD while the container keeps an opaque
-// underlay (TouchableHighlight.js). Fold both onto the container instead and the opacity fades the
-// very underlay it is meant to reveal — `underlayColor: 'black'` paints grey. React is the one
-// adapter that can reach the child without a wrapper view perturbing the flex chain.
-// A non-element child (text, a fragment, nothing at all) has no style prop to compose onto, so it
-// passes through untouched rather than throwing the way RN's Children.only would.
-function withChildStyle(children, extra) {
-    const child = Children.count(children) === 1 ? children : undefined;
-    if (!isValidElement(child))
-        return children;
-    return cloneElement(child, { style: [child.props.style, extra] });
-}
-export const TouchableHighlight = props => {
-    const { activeOpacity, underlayColor, style, children, onPress, onPressIn, onPressOut, onShowUnderlay, onHideUnderlay, delayPressOut = 0, ...rest } = props;
-    // `shown` is NOT `pressed`: RN holds the underlay for delayPressOut past the tap so a press too
-    // fast to see still flashes, and the pressed flag is already false by then.
-    const [shown, setShown] = useState(false);
-    const runtime = useRef(createHighlightUnderlayRuntime()).current;
-    // RN's _hasPressHandler gate: no press handler, no underlay. onLongPress is only READ here —
-    // it stays in `rest` for Pressable to fire directly.
-    const hasPressHandler = hasTouchablePressHandler({
-        onPress,
-        onPressIn,
-        onPressOut,
-        onLongPress: rest.onLongPress,
-    });
-    const underlay = createHighlightUnderlayHandlers({ delayPressOut, hasPressHandler, schedule: scheduleTimeout }, runtime, { setShown, onShowUnderlay, onHideUnderlay });
-    const extraStyles = resolveHighlightExtraStyles({
-        shown,
-        hasPressHandler,
-        underlayColor,
-        activeOpacity,
-    });
-    // Visual first, then the caller's callback — RN's order in _createPressabilityConfig.
-    function handlePressIn(event) {
-        underlay.handlePressIn(event);
-        onPressIn?.(event);
-    }
-    function handlePress(event) {
-        underlay.handlePress(event);
-        onPress?.(event);
-    }
-    function handlePressOut(event) {
-        underlay.handlePressOut(event);
-        onPressOut?.(event);
-    }
-    return createElement(Pressable, {
-        ...rest,
-        style: extraStyles === undefined ? style : [style, extraStyles.underlay],
-        onPress: handlePress,
-        onPressIn: handlePressIn,
-        onPressOut: handlePressOut,
-    }, extraStyles === undefined
-        ? children
-        : withChildStyle(children, extraStyles.child));
-};
-export const TouchableWithoutFeedback = props => {
-    const { children, onPressIn, onPressOut, delayPressIn = 0, delayPressOut = 0, minPressDuration = TOUCHABLE_MIN_PRESS_DURATION_MS, ...rest } = props;
-    // RN's TouchableWithoutFeedback builds a FULL Pressability config with delayPressIn /
-    // delayPressOut / minPressDuration: 0 — the same shared machine TouchableOpacity uses, with the
-    // visual half left empty. Spreading the delay props onto Pressable instead did nothing: it does
-    // not read them, and they leaked to the host as unknown props.
-    const runtime = useRef(createTouchableFeedbackRuntime()).current;
-    const { handlePressIn, handlePressOut } = createTouchableFeedbackHandlers({
-        delayPressIn,
-        delayPressOut,
-        minPressDuration,
-        schedule: scheduleTimeout,
-        now: Date.now,
-    }, runtime, {
-        activate(event) {
-            onPressIn?.(event);
-        },
-        deactivate(event) {
-            onPressOut?.(event);
-        },
-    });
-    return createElement(Pressable, { ...rest, onPressIn: handlePressIn, onPressOut: handlePressOut }, children);
-};

package/build/components/touchable-native-feedback/index.d.ts

@@ -1,18 +0,0 @@
-import { type FC, type ReactNode } from 'react';
-import { type INativeFeedbackBackground, type IThemeAttrBackground, type IRippleBackground } from '@symbiote-native/components';
-import { type IPressableProps } from '../pressable';
-export type { INativeFeedbackBackground, IThemeAttrBackground, IRippleBackground, } from '@symbiote-native/components';
-type ITouchableNativeFeedbackBaseProps = Omit<IPressableProps, 'style' | 'children'> & {
-    background?: INativeFeedbackBackground;
-    useForeground?: boolean;
-    children?: ReactNode;
-};
-export type ITouchableNativeFeedbackProps = ITouchableNativeFeedbackBaseProps;
-interface ITouchableNativeFeedbackComponent extends FC<ITouchableNativeFeedbackProps> {
-    SelectableBackground: (rippleRadius?: number) => IThemeAttrBackground;
-    SelectableBackgroundBorderless: (rippleRadius?: number) => IThemeAttrBackground;
-    Ripple: (color: string, borderless: boolean, rippleRadius?: number) => IRippleBackground;
-    canUseNativeForeground: () => boolean;
-}
-declare const TouchableNativeFeedback: ITouchableNativeFeedbackComponent;
-export { TouchableNativeFeedback };

package/build/components/touchable-native-feedback/index.js

@@ -1,32 +0,0 @@
-// TouchableNativeFeedback: Android's ripple/state-drawable touchable, built on Pressable like the
-// rest of the family. RN realizes its feedback by cloning the child into an RCTView carrying native
-// ripple props; we instead nest the child under a feedback View that carries those props, inside a
-// Pressable that owns the press wiring. The native props (nativeBackgroundAndroid /
-// nativeForegroundAndroid) are read by Android's ReactViewManager; on iOS they are inert props, so
-// the component still renders its child with working press wiring. The static factories +
-// background mapping are shared in @symbiote-native/components/view. React only attaches them onto the
-// component value and nests the feedback View.
-import { createElement } from 'react';
-import { dlog } from '@symbiote-native/engine';
-import { backgroundProps, canUseNativeForeground, rippleBackground, selectableBackground, selectableBackgroundBorderless, } from '@symbiote-native/components';
-import { View } from '../../components.js';
-import { TouchablePressable as Pressable, } from '../pressable/index.js';
-const TouchableNativeFeedbackImpl = props => {
-    const { background, useForeground = false, children, ...rest } = props;
-    // RN defaults a missing background to SelectableBackground() so the touchable always has
-    // feedback; mirror that here.
-    const resolved = background ?? selectableBackground();
-    dlog(`TouchableNativeFeedback render ${resolved.type} useForeground ${useForeground}`);
-    const nativeProps = backgroundProps(resolved, useForeground);
-    // The native ripple props ride a dedicated feedback View nested under the Pressable; the
-    // Pressable owns the press wiring, the feedback View owns the drawable.
-    const feedback = createElement(View, nativeProps, children);
-    return createElement(Pressable, rest, feedback);
-};
-const TouchableNativeFeedback = Object.assign(TouchableNativeFeedbackImpl, {
-    SelectableBackground: selectableBackground,
-    SelectableBackgroundBorderless: selectableBackgroundBorderless,
-    Ripple: rippleBackground,
-    canUseNativeForeground,
-});
-export { TouchableNativeFeedback };

package/build/jsx.d.ts

@@ -1,18 +0,0 @@
-import type { ISymbioteIntrinsic } from '@symbiote-native/components';
-import type { IViewProps, ITextProps } from './components';
-interface HostProps {
-    style?: unknown;
-    children?: import('react').ReactNode;
-    [key: string]: unknown;
-}
-type ILooseIntrinsics = Omit<Record<ISymbioteIntrinsic, HostProps>, 'symbiote-view' | 'symbiote-text'>;
-declare module 'react' {
-    namespace JSX {
-        interface IntrinsicElements extends ILooseIntrinsics {
-            'symbiote-view': IViewProps;
-            'symbiote-text': ITextProps;
-        }
-    }
-}
-export type ISymbioteIntrinsicTag = keyof import('react').JSX.IntrinsicElements;
-export {};

package/build/state-style.d.ts

@@ -1 +0,0 @@
-export { resolveStateStyle, type IPressStateArgument, type IResolvedStateStyle, } from '@symbiote-native/components/state-style';

package/build/state-style.js

@@ -1,13 +0,0 @@
-// Re-export only. The implementation is shared (`@symbiote-native/components`) because two adapters
-// had written byte-identical copies; this file exists so the code a transform EMITS keeps importing
-// from the adapter package the app already depends on, rather than reaching past it.
-//
-// Imported from the SUBPATH, not the barrel: every adapter barrel re-exports
-// `@symbiote-native/components` wholesale, so a name on that barrel silently becomes public API on
-// all five — which is how a transform internal nearly shipped as a supported export.
-//
-// Present on every adapter, including those with no lowering transform yet: a per-framework subpath
-// that four of five declare is exactly the silent gap `tests/package-subpath-parity.test.ts` exists
-// to catch, and the file costs a re-export. Deliberately NOT on the public barrel — the emitted
-// code names it, app code does not.
-export { resolveStateStyle, } from '@symbiote-native/components/state-style';