@symbiote-native/vue 0.5.0 → 2.0.0

package/README.md

@@ -34,9 +34,23 @@ additionally needs a Metro transformer for `.vue` files (see
 
 ## Use it
 
-The native entry reaches the _same_ `registerRunnable` seam as React — only the adapter changes. It
-hands the surface's `rootTag` to `mount` from `@symbiote-native/vue`, which drives the engine through Vue's
-`createRenderer`:
+The zero-config entry mirrors real Vue's own `createApp(App).mount(...)` idiom and wires the same
+RN-backed host seams React's `registerApp` does — this is what
+[`examples/vue-tsx`](../../examples/vue-tsx) and [`examples/vue-sfc`](../../examples/vue-sfc)
+actually use:
+
+```js
+// index.js
+import { createApp } from '@symbiote-native/vue/bootstrap';
+import App from './App';
+import { name as appName } from './app.json';
+
+createApp(App).mount(appName);
+```
+
+For anything the defaults don't cover, drive the lower-level seam directly — the same
+`registerRunnable` seam React uses, with `mount` from `@symbiote-native/vue` driving the engine
+through Vue's `createRenderer`:
 
 ```js
 // index.js
@@ -52,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>
     );
   },
 };
@@ -115,7 +129,8 @@ React doesn't hit this because `react-reconciler` commits synchronously.
 The fix lives in the engine: `whenCommitted(node, action)` runs `action` now if the node already
 has a tag, else after the commit that assigns it. Any native/imperative call wired at Vue lifecycle
 time must go through it. This is the only place the Vue adapter's timing differs from React's; the
-implementation is in `core/engine/src/post-commit.ts`.
+implementation is `whenCommitted` in `core/engine/src/commit.ts`, built on the generic hook
+registry in `core/engine/src/post-commit.ts`.
 
 ---
 

package/babel-jsx.cjs

@@ -0,0 +1,52 @@
+// The Babel plugins a Vue TSX/JSX app puts in its babel.config.js, as ONE list:
+//
+//   const symbioteVueJsx = require('@symbiote-native/vue/babel-jsx');
+//   module.exports = {
+//     presets: ['module:@react-native/babel-preset'],
+//     plugins: [...symbioteVueJsx(), myOtherPlugin],
+//   };
+//
+// A list rather than a preset, on purpose. `@vue/babel-plugin-jsx` MUST run before the RN preset's
+// React-JSX transform claims the same JSXElements, and Babel applies `plugins` before `presets` —
+// 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        -> `view` compiles to resolveComponent("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.
+//
+// @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.
+
+const vueJsx = require('@vue/babel-plugin-jsx');
+
+// 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 INTRINSIC_TAGS.has(tag);
+}
+
+module.exports = function symbioteVueJsx(options = {}) {
+  return [
+    [
+      vueJsx,
+      {
+        ...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.
+        isCustomElement: isSymbioteIntrinsic,
+      },
+    ],
+  ];
+};

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).

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

@@ -122,11 +122,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,29 @@
+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;
+    hitSlop?: IRectOffset;
+    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,6 @@
+import type { INativeFeedbackBackground } from '@symbiote-native/components';
+import type { IPressableProps } from './pressable-props';
+export type ITouchableNativeFeedbackProps = Omit<IPressableProps, 'style'> & {
+    background?: INativeFeedbackBackground;
+    useForeground?: boolean;
+};

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

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

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

@@ -0,0 +1,15 @@
+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;
+    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,3 @@
+import type { IPressTimingProps } from '@symbiote-native/components';
+import type { IPressableProps } from './pressable-props';
+export type ITouchableWithoutFeedbackProps = Omit<IPressableProps, 'style'> & IPressTimingProps;

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;
+}

package/build/components/view-props.js

@@ -0,0 +1,5 @@
+// The `<view>` tag's prop surface. There is no `View` component: it was a functional wrapper whose
+// whole body was `h('view', normalizeVueAttrs(attrs))`, and that fold moved to the renderer's
+// `patchProp` (kebab->camel per key, then `id -> nativeID`) — which covers a hand-written `h('view')`
+// and both compiled paths alike, where a wrapper covered only the call sites that named it.
+export {};