@symbiote-native/angular 1.0.0 → 2.0.1

package/src/components/scroll-view-props.ts

@@ -0,0 +1,109 @@
+// The `<scroll-view>` / `<horizontal-scroll-view>` tag's prop surface — the axis is the TAG you
+// write, not a `horizontal` binding, because Android resolves a different native class per axis.
+//
+// The wrapper was deleted 2026-09-11 and nothing replaced it in the adapter: the ENGINE owns the
+// whole shape now (`core/components/src/behaviors/scroll-view/`). `buildStructure` builds the
+// content node the children go under, `slotProps` routes `contentContainerStyle` onto it as its
+// `style`, `payloadFold` composes the two base styles, and the sticky machinery pins by DOCUMENT
+// ORDER through the `<sticky-header>` tag — so the Angular projection bridge that used to wrap
+// projected children by index is gone with it, along with its renderer hooks.
+//
+// A `<refresh-control>` is an ordinary FIRST CHILD on both platforms; the behavior re-parents it
+// per platform (iOS a sibling before the content, Android the swipe layout WRAPPING the scroll
+// view), which is why the adapter no longer has an `.ios`/`.android` split here.
+//
+// The imperative surface comes from `buildScrollViewHandle` (`@symbiote-native/components`) over
+// the node a template ref hands back.
+
+import type {
+  IAccessibilityProps,
+  IAriaProps,
+} from '@symbiote-native/components';
+import type {
+  IStyleProp,
+  ISymbioteEvent,
+  IViewStyle,
+} from '@symbiote-native/engine';
+
+export type { IScrollViewHandle } from '@symbiote-native/components';
+
+type IScrollHandler = (event: ISymbioteEvent) => void;
+type IContentSizeHandler = (width: number, height: number) => void;
+
+export interface IAngularScrollViewProps
+  extends IAccessibilityProps, IAriaProps {
+  style?: IStyleProp<IViewStyle>;
+  // A bare string resolves through the shared style registry, like `class` on the host node.
+  contentContainerStyle?: IStyleProp<IViewStyle> | string;
+  scrollEnabled?: boolean;
+  showsVerticalScrollIndicator?: boolean;
+  showsHorizontalScrollIndicator?: boolean;
+  pagingEnabled?: boolean;
+  bounces?: boolean;
+  decelerationRate?: 'normal' | 'fast' | number;
+  scrollEventThrottle?: number;
+  contentInset?: {
+    top?: number;
+    left?: number;
+    bottom?: number;
+    right?: number;
+  };
+  contentOffset?: { x: number; y: number };
+  removeClippedSubviews?: boolean;
+  snapToInterval?: number;
+  snapToOffsets?: number[];
+  snapToAlignment?: 'start' | 'center' | 'end';
+  snapToStart?: boolean;
+  snapToEnd?: boolean;
+  disableIntervalMomentum?: boolean;
+  // Sticky headers: RN implements stickiness PURELY IN JS — the native scroll view does not honor
+  // an index array. The engine's behavior resolves the indices against its own content children.
+  stickyHeaderIndices?: number[];
+  invertStickyHeaders?: boolean;
+  keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+  keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
+  maintainVisibleContentPosition?: {
+    minIndexForVisible: number;
+    autoscrollToTopThreshold?: number;
+  };
+  // iOS-only forwarding props (harmless on Android: its manager ignores unknown props).
+  alwaysBounceHorizontal?: boolean;
+  alwaysBounceVertical?: boolean;
+  centerContent?: boolean;
+  scrollIndicatorInsets?: {
+    top?: number;
+    left?: number;
+    bottom?: number;
+    right?: number;
+  };
+  indicatorStyle?: 'default' | 'black' | 'white';
+  directionalLockEnabled?: boolean;
+  automaticallyAdjustKeyboardInsets?: boolean;
+  contentInsetAdjustmentBehavior?:
+    'automatic' | 'scrollableAxes' | 'never' | 'always';
+  minimumZoomScale?: number;
+  maximumZoomScale?: number;
+  zoomScale?: number;
+  bouncesZoom?: boolean;
+  pinchGestureEnabled?: boolean;
+  // Android-only forwarding props (harmless on iOS).
+  nestedScrollEnabled?: boolean;
+  overScrollMode?: 'auto' | 'always' | 'never';
+  fadingEdgeLength?: number;
+  persistentScrollbar?: boolean;
+  endFillColor?: string;
+  onLayout?: IScrollHandler;
+  onScroll?: IScrollHandler;
+  onScrollBeginDrag?: IScrollHandler;
+  onScrollEndDrag?: IScrollHandler;
+  onMomentumScrollBegin?: IScrollHandler;
+  onMomentumScrollEnd?: IScrollHandler;
+  // iOS-only: user tapped the status bar to scroll to top. Inert on Android.
+  onScrollToTop?: IScrollHandler;
+  // Synthesized in JS from the content view's onLayout (RN _handleContentOnLayout); deduped.
+  onContentSizeChange?: IContentSizeHandler;
+  onAccessibilityAction?: (event: ISymbioteEvent) => void;
+  onAccessibilityTap?: (event: ISymbioteEvent) => void;
+  onMagicTap?: (event: ISymbioteEvent) => void;
+  onAccessibilityEscape?: (event: ISymbioteEvent) => void;
+}

package/src/components/text-input-props.ts

@@ -0,0 +1,72 @@
+// The `<text-input>` / `<text-input-multiline>` tag's prop surface. The tags are matched by
+// `TextInputElement` / `MultilineTextInputElement` (`../elements`) and carry the controlled-input
+// machine as an engine behavior (`registerTextInputBehavior`), so the wrapper that used to run the
+// handshake, the imperative handle and the autoFocus command in Angular was deleted 2026-09-11.
+//
+// Which of the two intrinsics a `<text-input multiline>` commits is the ENGINE's decision
+// (`intrinsicWhen` on the spec entry), not a template branch — the wrapper's `@if`/`@else` over two
+// hand-picked hosts is what that replaces.
+//
+// The imperative surface (`focus` / `blur` / `clear` / `isFocused` / `setSelection`) comes from the
+// engine node itself, reached through a template ref, the same way every other adapter reaches it.
+// `[(ngModel)]` / `formControl*` is `TextInputValueAccessor` (`../elements`), which is where the
+// wrapper's `NG_VALUE_ACCESSOR` went.
+//
+// The type stays for a component forwarding a bag, and because `IAngularTextInputProps` is public
+// API.
+
+import type {
+  IAccessibilityProps,
+  IAriaProps,
+  IEnterKeyHint,
+  IInputMode,
+  ISubmitBehavior,
+  ITextInputEventHandler,
+  ITextInputSelection,
+} from '@symbiote-native/components';
+import type { IStyleProp, ITextStyle } from '@symbiote-native/engine';
+
+export interface IAngularTextInputProps
+  extends IAccessibilityProps, IAriaProps {
+  value?: string;
+  defaultValue?: string;
+  placeholder?: string;
+  placeholderTextColor?: string;
+  editable?: boolean;
+  keyboardType?: string;
+  secureTextEntry?: boolean;
+  maxLength?: number;
+  multiline?: boolean;
+  selection?: 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?: IInputMode;
+  enterKeyHint?: IEnterKeyHint;
+  readOnly?: boolean;
+  submitBehavior?: ISubmitBehavior;
+  cursorColor?: string;
+  selectionColor?: string;
+  selectionHandleColor?: string;
+  underlineColorAndroid?: string;
+  inputAccessoryViewID?: string;
+  style?: IStyleProp<ITextStyle>;
+  onValueChange?: (text: string) => void;
+  onChange?: ITextInputEventHandler;
+  onFocus?: ITextInputEventHandler;
+  onBlur?: ITextInputEventHandler;
+  onEndEditing?: ITextInputEventHandler;
+  onSubmitEditing?: ITextInputEventHandler;
+  onKeyPress?: ITextInputEventHandler;
+  onSelectionChange?: ITextInputEventHandler;
+  onContentSizeChange?: ITextInputEventHandler;
+}

package/src/components/touchable-native-feedback/touchable-native-feedback-props.ts

@@ -0,0 +1,23 @@
+// The prop surface of `<touchable-native-feedback>`, for Angular.
+//
+// No component left to type — the element IS the tag, matched by `TouchableNativeFeedbackElement`
+// (`../../elements.ts`), and RN's own TNF renders nothing (TouchableNativeFeedback.js:289,339); the
+// engine behavior clones these props onto the single child. This stays exported because an app that
+// wraps the tag in its own component types the bag it forwards against something.
+//
+// Declared here rather than shared, over the Angular Pressable INPUT surface: children arrive
+// through content projection, not as a prop, which is the split
+// <prop_types_split_agnostic_vs_per_adapter> describes. `style` is absent because RN's TNF declares
+// none — the drawable is the whole visual, and a `style` on this tag would sit on a node that never
+// commits.
+import type { INativeFeedbackBackground } from '@symbiote-native/components';
+
+import type { IAngularPressableInputs } from '../pressable-props';
+
+export type IAngularTouchableNativeFeedbackProps = Omit<
+  IAngularPressableInputs,
+  'style'
+> & {
+  background?: INativeFeedbackBackground;
+  useForeground?: boolean;
+};

package/src/components/touchable-props.ts

@@ -0,0 +1,30 @@
+// The prop surfaces of `<touchable-opacity>` and `<touchable-highlight>`, for Angular.
+//
+// No components left to type — the elements ARE the tags, matched by `TouchableOpacityElement` and
+// `TouchableHighlightElement` (`../elements`), and both machines run on the engine node
+// (`registerTouchableOpacityBehavior` / `registerTouchableHighlightBehavior`): the opacity fade is
+// an engine-side style layer over the responder, and the underlay swap is the same `activeStyle`
+// channel a `:active` rule uses. The wrappers that ran those in Angular were deleted 2026-09-11.
+//
+// Declared per-adapter over the Angular Pressable INPUT surface, since children arrive through
+// content projection rather than as a field — the split
+// <prop_types_split_agnostic_vs_per_adapter> describes. Mirrors React/Vue's ITouchableBaseProps.
+
+import type { IPressTimingProps } from '@symbiote-native/components';
+import type { IStyleProp, IViewStyle } from '@symbiote-native/engine';
+
+import type { IAngularPressableInputs } from './pressable-props';
+
+type IAngularTouchableBaseProps = Omit<IAngularPressableInputs, 'style'> &
+  IPressTimingProps & {
+    style?: IStyleProp<IViewStyle>;
+  };
+
+export type IAngularTouchableOpacityProps = IAngularTouchableBaseProps & {
+  activeOpacity?: number;
+};
+
+export type IAngularTouchableHighlightProps = IAngularTouchableBaseProps & {
+  activeOpacity?: number;
+  underlayColor?: string;
+};

package/src/components/touchable-without-feedback/touchable-without-feedback-props.ts

@@ -0,0 +1,21 @@
+// The prop surface of `<touchable-without-feedback>`, for Angular.
+//
+// No component left to type — the element IS the tag, matched by `TouchableWithoutFeedbackElement`
+// (`../../elements.ts`), and RN's own TWF renders nothing (TouchableWithoutFeedback.js:229,286); the
+// engine behavior clones these props onto the single child. This stays exported because an app that
+// wraps the tag in its own component types the bag it forwards against something.
+//
+// Declared here rather than shared, over the Angular Pressable INPUT surface: children arrive
+// through content projection, not as a prop, which is the split
+// <prop_types_split_agnostic_vs_per_adapter> describes. `style` is absent because RN's TWF never
+// clones it — the prop is declared upstream (:122, tagged "FIXME: not in doc") and left out of
+// `elementProps`, so on the tag it would sit on a node that never commits.
+import type { IPressTimingProps } from '@symbiote-native/components';
+
+import type { IAngularPressableInputs } from '../pressable-props';
+
+export type IAngularTouchableWithoutFeedbackProps = Omit<
+  IAngularPressableInputs,
+  'style'
+> &
+  IPressTimingProps;