@symbiote-native/vue 1.0.0 → 3.0.0

package/README.md

@@ -27,8 +27,8 @@ npm install @symbiote-native/vue react-native vue
 `react-native` and `vue` stay your app's own top-level dependencies — this package only replaces
 the JS renderer that drives them. **TSX** needs nothing beyond the install above; **SFC**
 additionally needs a Metro transformer for `.vue` files (see
-[`examples/vue-sfc`](../../examples/vue-sfc)'s `metro.config.js`), since there's no
-`create-symbiote` scaffolder yet to wire it for you.
+[`examples/vue-sfc`](../../examples/vue-sfc)'s `metro.config.js`) — `npx @symbiote-native/cli new`
+wires this for a new app; an existing app still needs it copied in by hand.
 
 ---
 
@@ -66,23 +66,23 @@ RNAppRegistry.registerRunnable(appName, ({ rootTag }) => {
 });
 ```
 
-The app is ordinary Vue — it just imports primitives from `@symbiote-native/vue` instead of
-`react-native`. A tap→increment counter, authored in TSX:
+The app is ordinary Vue. The primitives are TAGS — `<view>`, `<text>`, `<pressable>` — so there is
+nothing to import for them at all; both Vue compilers resolve them as elements and the renderer
+maps each to its Fabric view. A tap→increment counter, authored in TSX:
 
 ```jsx
 import { ref } from '@vue/runtime-core';
-import { View, Text, Pressable } from '@symbiote-native/vue';
 
 export default {
   setup() {
     const count = ref(0);
     return () => (
-      <View style={{ padding: 24 }}>
-        <Text>Taps: {count.value}</Text>
-        <Pressable onPress={() => count.value++}>
-          <Text>Tap me</Text>
-        </Pressable>
-      </View>
+      <view style={{ padding: 24 }}>
+        <text>Taps: {count.value}</text>
+        <pressable onPress={() => count.value++}>
+          <text>Tap me</text>
+        </pressable>
+      </view>
     );
   },
 };
@@ -102,7 +102,8 @@ the demo above is the first one running on the iOS simulator:
 ## Parity — and the one gap
 
 Both adapters reach the same primitives, runtime modules, `Animated` on both drivers, gestures,
-accessibility, and the `VirtualizedList` family. That parity is **structural, not hand-copied**: the
+accessibility, and the `VirtualizedList` family, verified on-device on iOS and Android. That
+parity is **structural, not hand-copied**: the
 component logic (state machines + render functions) is written **once** in `@symbiote-native/components`,
 and each adapter supplies only its lifecycle (Vue's `ref`/`watch` + the descriptor→`h()` bridge).
 

package/babel-jsx.cjs

@@ -11,38 +11,46 @@
 // so it has to stay in the app's plugins array, where the app also controls its position relative
 // to its own plugins. A preset would move it after every plugin and silently change that order.
 //
-// The two entries are handed out together because either alone is broken:
-//
-//   lowering only        -> `symbiote-view` compiles to resolveComponent("symbiote-view"), a
-//                           component that resolves to nothing, with SLOT children an element path
-//                           never mounts. Blank subtree, no error.
-//   isCustomElement only -> nothing was rewritten, so <View> is still a Vue component and the whole
-//                           point (one component instance per node on ~73% of the tree) is unpaid.
-//
-// Same "both halves or nothing" invariant the SFC path states in metro-vue-transformer.cjs, and the
-// reason it is expressed as one require() here rather than two lines of documentation.
+// `isCustomElement` is the load-bearing option: without it `<view>` compiles to
+// `resolveComponent("view")`, a component that resolves to nothing, with SLOT children an element
+// path never mounts. Blank subtree, no error.
 //
 // @vue/babel-plugin-jsx is OUR dependency and require() resolves relative to this file, so the app
 // declares no extra devDependency — same reasoning as ./metro-css-parser.cjs.
-
+//
+// `optimize: true` defaults ON, an app may override it. The plugin's own README calls it
+// experimental ("the optimized code may skip certain re-renders... we strongly recommend thorough
+// testing") because it generates PatchFlags/dynamicProps from JSX's syntax alone, without the
+// template compiler's data-flow analysis. `.vue` SFCs get the equivalent from `@vue/compiler-sfc`
+// unconditionally already (`metro-vue-transformer.cjs`) — this closes the same gap for TSX, which
+// had none. `vue-row-component-shape-cost.itest.ts` measured why it matters: a stateful component
+// re-render pays for `hasPropsChanged`'s full `Object.keys(nextProps)` walk on every patch, even
+// when nothing changed; a patchFlag lets Vue check only the flagged dynamic keys instead.
+// Correctness (a changed prop still recommits, a conditional branch still flips, a keyed list still
+// reorders, and — the shape that actually matters here — a child COMPONENT still re-renders when a
+// nested prop field changes) is pinned in `optimize-flag-safety.test.ts`, including the exact
+// stateful-row shape the itest above measures; that file also confirms a measurable, reproducible
+// JS-side speedup on the identical partial-relabel pattern. NOT verified on-device/Hermes — only
+// headless, through this adapter's real renderer.
 const vueJsx = require('@vue/babel-plugin-jsx');
-const lowerHostPrimitives = require('./babel-lower-host-primitives.cjs');
 
-// Every `symbiote-*` tag is an intrinsic the renderer resolves through descriptorFor, never a Vue
-// component — including one an app writes by hand, which is why this is a prefix test rather than a
-// list of the two tags the lowering emits.
-const SYMBIOTE_TAG_PREFIX = 'symbiote-';
+// An intrinsic the renderer resolves through descriptorFor, never a Vue component — including one
+// an app writes by hand. A CLOSED set and not a prefix or shape test: an app's own kebab-case
+// component looks identical to ours since the `symbiote-` marker was dropped, and answering true
+// for it would stop resolving it with nothing red.
+const INTRINSIC_TAGS = require('./intrinsic-tags.cjs');
 
 function isSymbioteIntrinsic(tag) {
-  return tag.startsWith(SYMBIOTE_TAG_PREFIX);
+  return INTRINSIC_TAGS.has(tag);
 }
 
 module.exports = function symbioteVueJsx(options = {}) {
   return [
-    lowerHostPrimitives,
     [
       vueJsx,
       {
+        // A default an app may override — see the file-level comment above for what backs it.
+        optimize: true,
         ...options,
         // Last, deliberately: an app may pass other @vue/babel-plugin-jsx options through, but
         // overriding this one silently produces output this adapter cannot render.

package/build/components/activity-indicator-props.d.ts

@@ -0,0 +1,5 @@
+import type { IActivityIndicatorProps as IActivityIndicatorBaseProps } from '@symbiote-native/components';
+import type { IClassNameValue } from '@symbiote-native/engine';
+export type IActivityIndicatorProps = IActivityIndicatorBaseProps & {
+    class?: IClassNameValue;
+};

package/build/components/activity-indicator-props.js

@@ -0,0 +1 @@
+export {};

package/build/components/button-props.d.ts

@@ -0,0 +1,5 @@
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { IButtonProps as ICoreButtonProps } from '@symbiote-native/components';
+export type IButtonProps = ICoreButtonProps & {
+    class?: IClassNameValue;
+};

package/build/components/button-props.js

@@ -0,0 +1 @@
+export {};

package/build/components/flat-list/index.d.ts

@@ -37,7 +37,6 @@ export type IFlatListEmits<ItemT> = {
     }) => void;
 };
 export declare const FlatList: new <ItemT>(props: (IFlatListProps<ItemT> & ({} | {
-    onRefresh?: (() => any) | undefined;
     onViewableItemsChanged?: ((info: IViewableItemsChangedInfo<ItemT>) => any) | undefined;
     onEndReached?: ((info: {
         distanceFromEnd: number;
@@ -45,13 +44,13 @@ export declare const FlatList: new <ItemT>(props: (IFlatListProps<ItemT> & ({} |
     onStartReached?: ((info: {
         distanceFromStart: number;
     }) => any) | undefined;
+    onRefresh?: (() => any) | undefined;
     onScrollToIndexFailed?: ((info: {
         index: number;
         highestMeasuredFrameIndex: number;
         averageItemLength: number;
     }) => any) | undefined;
 })) & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps) => import("vue").CreateComponentPublicInstanceWithMixins<IFlatListProps<ItemT> & ({} | {
-    onRefresh?: (() => any) | undefined;
     onViewableItemsChanged?: ((info: IViewableItemsChangedInfo<ItemT>) => any) | undefined;
     onEndReached?: ((info: {
         distanceFromEnd: number;
@@ -59,6 +58,7 @@ export declare const FlatList: new <ItemT>(props: (IFlatListProps<ItemT> & ({} |
     onStartReached?: ((info: {
         distanceFromStart: number;
     }) => any) | undefined;
+    onRefresh?: (() => any) | undefined;
     onScrollToIndexFailed?: ((info: {
         index: number;
         highestMeasuredFrameIndex: number;
@@ -72,7 +72,6 @@ export declare const FlatList: new <ItemT>(props: (IFlatListProps<ItemT> & ({} |
     M: {};
     Defaults: {};
 }, (IFlatListProps<ItemT> & {}) | (IFlatListProps<ItemT> & {
-    onRefresh?: (() => any) | undefined;
     onViewableItemsChanged?: ((info: IViewableItemsChangedInfo<ItemT>) => any) | undefined;
     onEndReached?: ((info: {
         distanceFromEnd: number;
@@ -80,6 +79,7 @@ export declare const FlatList: new <ItemT>(props: (IFlatListProps<ItemT> & ({} |
     onStartReached?: ((info: {
         distanceFromStart: number;
     }) => any) | undefined;
+    onRefresh?: (() => any) | undefined;
     onScrollToIndexFailed?: ((info: {
         index: number;
         highestMeasuredFrameIndex: number;

package/build/components/flat-list/index.js

@@ -133,11 +133,11 @@ export const FlatList = defineComponent((props, { attrs, expose, emit, slots, })
                 const key = keyExtractor ? keyExtractor(item, index) : String(index);
                 // The row IS the virtualized cell, so every item in it shares the row's separators
                 // handle (the divider sits between rows, not columns), like RN's multi-column FlatList.
-                return h('symbiote-view', { key, style: { flex: 1 } }, slots.item !== undefined
+                return h('view', { key, style: { flex: 1 } }, slots.item !== undefined
                     ? slots.item({ item, index, separators: info.separators })
                     : []);
             });
-            return [h('symbiote-view', { style: rowStyle }, cells)];
+            return [h('view', { style: rowStyle }, cells)];
         };
         // Viewability over rows expands back to per-item tokens so the caller sees item-level
         // visibility, not row-level (shared expandRowViewability).
@@ -165,7 +165,7 @@ export const FlatList = defineComponent((props, { attrs, expose, emit, slots, })
             data: rows,
             getItem: (_source, index) => rows[index],
             getItemCount: () => rows.length,
-            keyExtractor: rowKeyExtractor,
+            keyExtractor: (row) => rowKeyExtractor(row, keyExtractor),
             onEndReached: endReached,
             onStartReached: startReached,
             onRefresh: refresh,

package/build/components/image-background-props.d.ts

@@ -0,0 +1,7 @@
+import type { IImageProps } from '@symbiote-native/components';
+import type { IClassNameValue, IStyleProp, IViewStyle } from '@symbiote-native/engine';
+export interface IImageBackgroundProps extends Omit<IImageProps, 'style'> {
+    style?: IStyleProp<IViewStyle>;
+    imageStyle?: IStyleProp<IViewStyle> | string;
+    class?: IClassNameValue;
+}

package/build/components/image-background-props.js

@@ -0,0 +1 @@
+export {};

package/build/components/image-props.d.ts

@@ -0,0 +1,5 @@
+import type { IImageProps as IImageBaseProps } from '@symbiote-native/components';
+import type { IClassNameValue } from '@symbiote-native/engine';
+export type IImageProps = IImageBaseProps & {
+    class?: IClassNameValue;
+};

package/build/components/image-props.js

@@ -0,0 +1,5 @@
+// The `<image>` tag's prop surface. The wrapper is gone: the whole source/src/srcSet resolution,
+// the width/height -> style fold and `alt` -> accessibility now run in `registerImageBehavior`, on
+// the tag itself. The Image STATICS moved to `modules/image` — an imperative API with no view,
+// which living beside a component made read as one.
+export {};

package/build/components/{input-accessory-view.d.ts → input-accessory-view-props.d.ts}

@@ -1,5 +1,4 @@
-import { type FunctionalComponent } from '@vue/runtime-core';
-import { type IAccessibilityProps, type IAriaProps } from '@symbiote-native/components';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
 import type { IClassNameValue, IStyleProp, IViewStyle } from '@symbiote-native/engine';
 export interface IInputAccessoryViewProps extends IAccessibilityProps, IAriaProps {
     nativeID?: string;
@@ -7,4 +6,3 @@ export interface IInputAccessoryViewProps extends IAccessibilityProps, IAriaProp
     style?: IStyleProp<IViewStyle>;
     class?: IClassNameValue;
 }
-export declare const InputAccessoryView: FunctionalComponent<{}, {}, any, {}>;

package/build/components/input-accessory-view-props.js

@@ -0,0 +1,5 @@
+// The `<input-accessory-view>` tag's prop surface. The wrapper is gone: it narrowed attrs, called
+// `renderInputAccessoryView` and nested the slot children under the host — and that fold is now
+// `registerInputAccessoryViewBehavior`'s, running on the tag itself. The prop type stays, for a
+// component forwarding a bag.
+export {};

package/build/components/keyboard-avoiding-view.js

@@ -9,7 +9,7 @@
 // rawAttrs runs through normalizeVueAttrs so a template `:keyboard-vertical-offset` resolves.
 import { defineComponent, h, ref, onMounted, onUnmounted, } from '@vue/runtime-core';
 import { Keyboard, Platform, dlog, } from '@symbiote-native/engine';
-import { computeInset, keyboardAvoidingEventNamesFor, readKeyboardFrame, readPrefersCrossFadeTransitions, readLayoutFrame, resolveKeyboardAvoidingLayout, resolveAccessibilityProps, DEFAULT_VERTICAL_OFFSET, } from '@symbiote-native/components';
+import { computeInset, configureKeyboardAvoidingAnimation, keyboardAvoidingEventNamesFor, readKeyboardAnimationTiming, readKeyboardFrame, readPrefersCrossFadeTransitions, readLayoutFrame, resolveKeyboardAvoidingLayout, resolveAccessibilityProps, DEFAULT_VERTICAL_OFFSET, } from '@symbiote-native/components';
 import { normalizeVueAttrs } from '../utils/normalize-attrs.js';
 function isStyleProp(value) {
     return typeof value === 'object' && value !== null;
@@ -53,14 +53,18 @@ export const KeyboardAvoidingView = defineComponent((_props, { attrs: rawAttrs,
     };
     const onShow = (payload) => {
         const keyboard = readKeyboardFrame(payload);
+        const previousInset = inset.value;
         const next = computeInset(frame, keyboard, verticalOffset(), {
             behavior: asBehavior(currentAttrs().behavior),
             // The inset CURRENTLY applied (RN's this.state.bottom), read live off the reactive cell:
             // in 'height' mode the wrapper is shrunk by it, so the next onLayout under-reports the
             // frame by exactly that much and core adds it back.
-            previousInset: inset.value,
+            previousInset,
             prefersCrossFadeTransitions,
         });
+        // RN's `_updateBottomIfNecessary` skips the animation when the inset did not change.
+        if (next !== previousInset)
+            configureKeyboardAvoidingAnimation(readKeyboardAnimationTiming(payload), currentAttrs().enabled !== false);
         dlog(`KeyboardAvoidingView show -> inset ${next}`);
         inset.value = next;
     };
@@ -122,11 +126,11 @@ export const KeyboardAvoidingView = defineComponent((_props, { attrs: rawAttrs,
         // 'nested' pushes the children in an inner view by `bottom: inset`; the wrapper modes
         // adjust the single wrapper directly.
         if (layout.kind === 'nested') {
-            return h('symbiote-view', wrapperProps, [
-                h('symbiote-view', { style: layout.innerStyle }, childNodes),
+            return h('view', wrapperProps, [
+                h('view', { style: layout.innerStyle }, childNodes),
             ]);
         }
-        return h('symbiote-view', wrapperProps, childNodes);
+        return h('view', wrapperProps, childNodes);
     };
 }, {
     name: 'KeyboardAvoidingView',

package/build/components/modal/index.js

@@ -108,7 +108,7 @@ export const Modal = defineComponent((_props, { attrs: rawAttrs, slots, emit })
             style: isStyleProp(attrs.style) ? attrs.style : undefined,
             passthrough: resolveAccessibilityProps(forwardAttrs(attrs)),
         });
-        // root = symbiote-modal > [container]; the slot children nest UNDER the container View, never
+        // root = modal > [container]; the slot children nest UNDER the container View, never
         // as a direct sibling of the host (RN's modal content layout).
         const [container] = root.children;
         if (typeof container === 'string')

package/build/components/pressable-props.d.ts

@@ -0,0 +1,31 @@
+import type { IClassNameValue, IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps, IPressHandler, IPressState, IPressableAndroidRippleConfig, IRectOffset } from '@symbiote-native/components';
+import type { VNodeRef } from '@vue/runtime-core';
+export type { IPressState, IPressableAndroidRippleConfig, } from '@symbiote-native/components';
+export interface IPressableProps extends IAccessibilityProps, IAriaProps {
+    onPress?: IPressHandler;
+    onPressIn?: IPressHandler;
+    onPressOut?: IPressHandler;
+    onPressMove?: IPressHandler;
+    onLongPress?: IPressHandler;
+    delayLongPress?: number;
+    disabled?: boolean;
+    focusable?: boolean;
+    cancelable?: boolean;
+    blockNativeResponder?: boolean;
+    hitSlop?: IRectOffset;
+    testOnly_pressed?: boolean;
+    pressRetentionOffset?: IRectOffset;
+    unstable_pressDelay?: number;
+    minPressDuration?: number;
+    android_ripple?: IPressableAndroidRippleConfig;
+    android_disableSound?: boolean;
+    onHoverIn?: IPressHandler;
+    onHoverOut?: IPressHandler;
+    delayHoverIn?: number;
+    delayHoverOut?: number;
+    testID?: string;
+    style?: IStyleProp<IViewStyle> | ((state: IPressState) => IStyleProp<IViewStyle>);
+    class?: IClassNameValue;
+    ref?: VNodeRef;
+}

package/build/components/pressable-props.js

@@ -0,0 +1,12 @@
+// The `<pressable>` tag's prop surface. The press machine — timers, the retention region, the
+// long-press and hover legs, the `disabled`/`focusable`/`accessible` folds and the Android ripple —
+// lives on the engine node as `core/components/src/behaviors/pressable.ts`, wired by
+// `../register`. `@press` / `@press-in` / … reach it as ordinary `onPress` / `onPressIn` props.
+//
+// THERE IS NO SCOPED SLOT, and that is the one surface a tag cannot carry: press state lives on the
+// engine node and never crosses back into Vue's reactivity, so `#default="{ pressed }"` has no
+// channel. A `style` CALLBACK still works — the engine resolves it at both values of `pressed`
+// (`isStyleCallback`, `core/engine/src/node.ts`) — and a `:active` CSS rule is cheaper still. A
+// CHILD that needs the state has to be given it: mirror `@press-in`/`@press-out` into a local ref,
+// which is what any app styling a descendant does.
+export {};

package/build/components/refresh-control-props.d.ts

@@ -0,0 +1,16 @@
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
+export interface IRefreshControlProps extends IAccessibilityProps, IAriaProps {
+    refreshing: boolean;
+    id?: string;
+    onRefresh?: () => void | Promise<void>;
+    tintColor?: string;
+    title?: string;
+    titleColor?: string;
+    progressViewOffset?: number;
+    colors?: readonly string[];
+    progressBackgroundColor?: string;
+    size?: 'default' | 'large';
+    enabled?: boolean;
+    class?: IClassNameValue;
+}

package/build/components/refresh-control-props.js

@@ -0,0 +1,9 @@
+// The `<refresh-control>` tag's prop surface. The wrapper is gone: it forwarded every prop and
+// turned the host's `onRefresh` into a typed `refresh` emit, which a tag needs no help with —
+// `@refresh` compiles to an `onRefresh` prop and `routeProp` sends it to the native `topRefresh`
+// event. The controlled-spinner handshake lives in `registerRefreshControlBehavior`.
+//
+// Where the node SITS is still the parent's decision and differs per platform: on iOS a
+// PullToRefreshView sibling inside the ScrollView, on Android an AndroidSwipeRefreshLayout wrapping
+// it. `registerScrollViewBehavior` claims the tag and places it.
+export {};

package/build/components/safe-area-view-props.d.ts

@@ -0,0 +1,6 @@
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
+export type ISafeAreaViewProps = IAccessibilityProps & IAriaProps & {
+    id?: string;
+    class?: IClassNameValue;
+};

package/build/components/safe-area-view-props.js

@@ -0,0 +1,5 @@
+// The `<safe-area-view>` tag's prop surface. The wrapper is gone: its whole body was
+// `normalizeVueAttrs` + `resolveAccessibilityProps` + one `h()`, and both folds now run below every
+// path — kebab->camel and `id -> nativeID` in the renderer's `patchProp`, aria/role in the engine's
+// `fabricProps`. The prop type stays, for a component forwarding a bag.
+export {};

package/build/components/scroll-view/{shared.d.ts → scroll-view-props.d.ts}

@@ -1,7 +1,5 @@
-import { type VNode } from '@vue/runtime-core';
-import { type IAccessibilityProps, type IAriaProps, type ISymbioteIntrinsic } from '@symbiote-native/components';
-import { type IClassNameValue, type IStyleProp, type ISymbioteEvent, type IViewStyle } from '@symbiote-native/engine';
-import { type IStickyHeaderComponentType } from './sticky-header';
+import type { IClassNameValue, ISymbioteEvent, IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
 export type { IScrollViewHandle } from '@symbiote-native/components';
 type IScrollHandler = (event: ISymbioteEvent) => void;
 export interface IScrollViewProps extends IAccessibilityProps, IAriaProps {
@@ -25,9 +23,8 @@ export interface IScrollViewProps extends IAccessibilityProps, IAriaProps {
         x: number;
         y: number;
     };
-    refreshControl?: VNode;
     removeClippedSubviews?: boolean;
-    class?: IClassNameValue;
+    onContentSizeChange?: (width: number, height: number) => void;
     snapToInterval?: number;
     snapToOffsets?: number[];
     snapToAlignment?: 'start' | 'center' | 'end';
@@ -36,7 +33,6 @@ export interface IScrollViewProps extends IAccessibilityProps, IAriaProps {
     disableIntervalMomentum?: boolean;
     stickyHeaderIndices?: number[];
     invertStickyHeaders?: boolean;
-    StickyHeaderComponent?: IStickyHeaderComponentType;
     keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
     keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
     maintainVisibleContentPosition?: {
@@ -73,24 +69,5 @@ export interface IScrollViewProps extends IAccessibilityProps, IAriaProps {
     onMomentumScrollBegin?: IScrollHandler;
     onMomentumScrollEnd?: IScrollHandler;
     onScrollToTop?: IScrollHandler;
+    class?: IClassNameValue;
 }
-export type IScrollViewEmits = {
-    contentSizeChange: (width: number, height: number) => boolean;
-};
-export interface IScrollViewAssembleInput {
-    scrollViewIntrinsic: ISymbioteIntrinsic;
-    scrollProps: Record<string, unknown>;
-    content: VNode;
-    refreshControl: VNode | undefined;
-    scrollViewBaseStyle: IViewStyle;
-    userStyle: IStyleProp<IViewStyle> | undefined;
-    layoutSplitStyle: IStyleProp<IViewStyle>;
-    scrollOuterProps: Record<string, unknown>;
-    setNodeRef: (el: unknown) => void;
-}
-export interface IScrollViewPlatform {
-    assemble: (input: IScrollViewAssembleInput) => VNode;
-}
-export declare function createScrollView(platform: IScrollViewPlatform): import("vue").DefineSetupFnComponent<IScrollViewProps, IScrollViewEmits, {}, IScrollViewProps & {
-    onContentSizeChange?: ((width: number, height: number) => any) | undefined;
-}, import("vue").PublicProps>;

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

@@ -0,0 +1 @@
+export {};

package/build/components/section-list/index.d.ts

@@ -6,21 +6,21 @@ export type ISectionListProps<ItemT> = IVirtualizedSectionListProps<ItemT>;
 export type ISectionListEmits = IVirtualizedSectionListEmits;
 export type ISectionListSlots<ItemT> = IVirtualizedSectionListSlots<ItemT>;
 export declare const SectionList: new <ItemT>(props: (ISectionListProps<ItemT> & ({} | {
-    onRefresh?: (() => any) | undefined;
     onEndReached?: ((info: {
         distanceFromEnd: number;
     }) => any) | undefined;
     onStartReached?: ((info: {
         distanceFromStart: number;
     }) => any) | undefined;
-})) & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps) => import("vue").CreateComponentPublicInstanceWithMixins<ISectionListProps<ItemT> & ({} | {
     onRefresh?: (() => any) | undefined;
+})) & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps) => import("vue").CreateComponentPublicInstanceWithMixins<ISectionListProps<ItemT> & ({} | {
     onEndReached?: ((info: {
         distanceFromEnd: number;
     }) => any) | undefined;
     onStartReached?: ((info: {
         distanceFromStart: number;
     }) => any) | undefined;
+    onRefresh?: (() => any) | undefined;
 }), {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} | IVirtualizedSectionListEmits, import("vue").PublicProps, {}, false, {}, import("vue").SlotsType<ISectionListSlots<ItemT>>, {}, {}, string, {}, any, import("vue").ComponentProvideOptions, {
     P: {};
     B: {};
@@ -29,11 +29,11 @@ export declare const SectionList: new <ItemT>(props: (ISectionListProps<ItemT> &
     M: {};
     Defaults: {};
 }, (ISectionListProps<ItemT> & {}) | (ISectionListProps<ItemT> & {
-    onRefresh?: (() => any) | undefined;
     onEndReached?: ((info: {
         distanceFromEnd: number;
     }) => any) | undefined;
     onStartReached?: ((info: {
         distanceFromStart: number;
     }) => any) | undefined;
+    onRefresh?: (() => any) | undefined;
 }), {}, {}, {}, {}, {}>;

package/build/components/switch/switch-props.d.ts

@@ -0,0 +1,6 @@
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { ISwitchProps as ISwitchBaseProps } from '@symbiote-native/components';
+export type ISwitchProps = ISwitchBaseProps & {
+    class?: IClassNameValue;
+};
+export type { ISwitchTrackColor, ISwitchChangeEvent, } from '@symbiote-native/components';

package/build/components/switch/switch-props.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { ITextInputProps as ITextInputBaseProps } from '@symbiote-native/components';
+export type ITextInputProps = ITextInputBaseProps & {
+    class?: IClassNameValue;
+};

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

@@ -0,0 +1 @@
+export {};

package/build/components/text-props.d.ts

@@ -0,0 +1,24 @@
+import type { IClassNameValue, IStyleProp, ISymbioteEvent, ITextStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
+import type { VNodeRef } from '@vue/runtime-core';
+export interface ITextProps extends IAccessibilityProps, IAriaProps {
+    style?: IStyleProp<ITextStyle>;
+    class?: IClassNameValue;
+    onPress?: (event: ISymbioteEvent) => void;
+    onLongPress?: (event: ISymbioteEvent) => void;
+    onPressIn?: (event: ISymbioteEvent) => void;
+    onPressOut?: (event: ISymbioteEvent) => void;
+    onLayout?: (event: ISymbioteEvent) => void;
+    onTextLayout?: (event: ISymbioteEvent) => void;
+    numberOfLines?: number;
+    ellipsizeMode?: 'head' | 'middle' | 'tail' | 'clip';
+    selectable?: boolean;
+    disabled?: boolean;
+    adjustsFontSizeToFit?: boolean;
+    minimumFontScale?: number;
+    allowFontScaling?: boolean;
+    maxFontSizeMultiplier?: number | null;
+    selectionColor?: string;
+    ref?: VNodeRef;
+    key?: string | number | symbol;
+}

package/build/components/text-props.js

@@ -0,0 +1,6 @@
+// The `<text>` tag's prop surface. There is no `Text` component: the wrapper's one job beyond
+// forwarding attrs was RN's `Text.js` defaults (`ellipsizeMode: 'tail'`, `allowFontScaling: true`),
+// and those are seeded in the renderer's `createElement` (`seedTextDefaults`) plus re-seeded in
+// `patchProp` when a value arrives as an explicit `undefined`. A `<text>` inside another `<text>`
+// still commits as `RCTVirtualText`; that is the engine's commit walk, never an adapter's.
+export {};

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

@@ -0,0 +1,7 @@
+import type { INativeFeedbackBackground } from '@symbiote-native/components';
+import type { IPressableProps } from './pressable-props';
+export type ITouchableNativeFeedbackProps = Omit<IPressableProps, 'style'> & {
+    background?: INativeFeedbackBackground;
+    useForeground?: boolean;
+    touchSoundDisabled?: boolean;
+};

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

@@ -0,0 +1 @@
+export {};

package/build/components/touchable-props.d.ts

@@ -0,0 +1,17 @@
+import type { IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IPressTimingProps } from '@symbiote-native/components';
+import type { IPressableProps } from './pressable-props';
+export type ITouchableBaseProps = Omit<IPressableProps, 'style'> & IPressTimingProps & {
+    style?: IStyleProp<IViewStyle>;
+};
+export interface ITouchableOpacityProps extends ITouchableBaseProps {
+    activeOpacity?: number;
+}
+export interface ITouchableHighlightProps extends ITouchableBaseProps {
+    activeOpacity?: number;
+    underlayColor?: string;
+    touchSoundDisabled?: boolean;
+    testOnly_pressed?: boolean;
+    onShowUnderlay?: () => void;
+    onHideUnderlay?: () => void;
+}

package/build/components/touchable-props.js

@@ -0,0 +1 @@
+export {};

package/build/components/touchable-without-feedback-props.d.ts

@@ -0,0 +1,5 @@
+import type { IPressTimingProps } from '@symbiote-native/components';
+import type { IPressableProps } from './pressable-props';
+export type ITouchableWithoutFeedbackProps = Omit<IPressableProps, 'style'> & IPressTimingProps & {
+    touchSoundDisabled?: boolean;
+};

package/build/components/touchable-without-feedback-props.js

@@ -0,0 +1 @@
+export {};

package/build/components/view-props.d.ts

@@ -0,0 +1,29 @@
+import type { IClassNameValue, IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps, IResponderProps } from '@symbiote-native/components';
+import type { VNodeRef } from '@vue/runtime-core';
+export interface IViewProps extends IAccessibilityProps, IAriaProps, IResponderProps {
+    style?: IStyleProp<IViewStyle>;
+    class?: IClassNameValue;
+    onPress?: (event: ISymbioteEvent) => void;
+    onPressIn?: (event: ISymbioteEvent) => void;
+    onPressOut?: (event: ISymbioteEvent) => void;
+    onLayout?: (event: ISymbioteEvent) => void;
+    onFocus?: (event: ISymbioteEvent) => void;
+    onBlur?: (event: ISymbioteEvent) => void;
+    pointerEvents?: 'auto' | 'none' | 'box-none' | 'box-only';
+    hitSlop?: number | {
+        top?: number;
+        left?: number;
+        bottom?: number;
+        right?: number;
+    };
+    id?: string;
+    focusable?: boolean;
+    collapsable?: boolean;
+    removeClippedSubviews?: boolean;
+    renderToHardwareTextureAndroid?: boolean;
+    shouldRasterizeIOS?: boolean;
+    needsOffscreenAlphaCompositing?: boolean;
+    ref?: VNodeRef;
+    key?: string | number | symbol;
+}