@symbiote-native/angular 0.8.0 → 2.0.0

package/src/components/refresh-control-props.ts

@@ -0,0 +1,43 @@
+// The `<refresh-control>` tag's prop surface. The tag is matched by `RefreshControlElement`
+// (`../elements`) and carries the controlled-spinner handshake as an engine behavior
+// (`registerRefreshControlBehavior` — mirror what native last reported, command it back when the
+// app's `refreshing` disagrees, RefreshControl.js:145-166), so the wrapper that ran that in Angular
+// was deleted 2026-09-11.
+//
+// WHERE it goes is the ScrollView's decision, not this tag's: write it as an ordinary FIRST CHILD
+// on both platforms and the scroll-view behavior re-parents it — iOS a sibling before the content
+// container, Android the `AndroidSwipeRefreshLayout` WRAPPING the scroll view.
+//
+// The type stays for a component forwarding a bag, and because `IAngularRefreshControlProps` is
+// public API.
+
+import type {
+  IAccessibilityProps,
+  IAriaProps,
+} from '@symbiote-native/components';
+import type { IStyleProp, IViewStyle } from '@symbiote-native/engine';
+
+export interface IAngularRefreshControlProps
+  extends IAccessibilityProps, IAriaProps {
+  refreshing: boolean;
+  // `id` — RN's W3C alias for `nativeID`, folded by the spec entry's ID_ALIAS.
+  id?: string;
+  // RN's onRefresh is `() => void | Promise<void>`, the handler may be async; the promise is
+  // fire-and-forget (native already starts refreshing on the gesture).
+  onRefresh?: () => void | Promise<void>;
+  tintColor?: string;
+  title?: string;
+  titleColor?: string;
+  progressViewOffset?: number;
+  // Android-only spinner styling (RN RefreshControlPropsAndroid): `colors` are the indicator's
+  // animated stroke colors, `progressBackgroundColor` the disc behind it, `size` the diameter
+  // preset. AndroidSwipeRefreshLayout reads them; PullToRefreshView on iOS ignores unknown props.
+  colors?: readonly string[];
+  progressBackgroundColor?: string;
+  size?: 'default' | 'large';
+  // Android-only native prop forwarded to AndroidSwipeRefreshLayout; iOS native never reads it.
+  enabled?: boolean;
+  // The Android scroll-view wrap injects the layout half of the style onto this host; iOS leaves it
+  // unset (the RefreshControl is a childless sibling). Harmless to forward on both.
+  style?: IStyleProp<IViewStyle>;
+}

package/src/components/safe-area-view-props.ts

@@ -0,0 +1,28 @@
+// The `<safe-area-view>` tag's prop surface. The tag is matched by `SafeAreaViewElement`
+// (`../elements`) and commits a single `SafeAreaView` native view whose host insets its children to
+// the safe area; there is no JS-side translation to do, so the wrapper that used to fold
+// aria/role and forward a host bag was deleted 2026-09-10 — the engine's own aria fold and the
+// renderer's `id` -> `nativeID` alias cover both, on every path.
+//
+// The type stays for a component forwarding a bag, and because `IAngularSafeAreaViewProps` is
+// public API. Mirrors React's ISafeAreaViewProps minus children, which Angular takes via
+// `<ng-content>`.
+
+import type {
+  IAccessibilityProps,
+  IAriaProps,
+} from '@symbiote-native/components';
+import type {
+  IStyleProp,
+  ISymbioteEvent,
+  IViewStyle,
+} from '@symbiote-native/engine';
+
+export interface IAngularSafeAreaViewProps
+  extends IAccessibilityProps, IAriaProps {
+  style?: IStyleProp<IViewStyle>;
+  // `id` — accepted here and folded to `nativeID` by the renderer, matching upstream, whose
+  // SafeAreaView takes the full ViewProps surface.
+  id?: string;
+  onLayout?: (event: ISymbioteEvent) => void;
+}

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/section-list/index.ts

@@ -100,6 +100,13 @@ export {
   VListHeaderDirective,
   VListSeparatorDirective,
 } from '../virtualized-list';
+import {
+  gateWanted,
+  injectGateDemandAbove,
+  provideGateDemand,
+  type IGateDemand,
+  type IGatedAccessibilityEvent,
+} from '../../gate-demand';
 
 // SectionList's public surface is exactly VirtualizedSectionList's (RN layers them one-for-one), so
 // the prop type is shared verbatim — no SectionList-only field exists.
@@ -123,6 +130,7 @@ export type ISectionListInputs<ItemT> = Omit<
 @Component({
   selector: 'SectionList',
   standalone: true,
+  viewProviders: [provideGateDemand(() => SectionList)],
   hostDirectives: [
     { directive: SymbioteStyleInputDirective, inputs: ['style'] },
   ],
@@ -381,6 +389,16 @@ export class SectionList<ItemT = unknown>
   @Output() readonly accessibilityTap = new EventEmitter<ISymbioteEvent>();
   @Output() readonly magicTap = new EventEmitter<ISymbioteEvent>();
   @Output() readonly accessibilityEscape = new EventEmitter<ISymbioteEvent>();
+
+  // This wrapper binds the four gated accessibility events on the component it renders, which
+  // Angular forces to be unconditional and which would light that component's gates on every
+  // instance. It answers for them instead — see `gate-demand.ts`.
+  private readonly gateDemandAbove = injectGateDemandAbove();
+
+  wantsGate(name: IGatedAccessibilityEvent): boolean {
+    return gateWanted(this.gateDemandAbove, name, this[name]);
+  }
+
   @Input() role?: IAriaProps['role'];
   @Input() ariaLabel?: string;
   @Input() ariaLabelledBy?: string;

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;