@symbiote-native/angular 3.2.0 → 3.4.0

package/build/angular/element-base.js

@@ -0,0 +1,304 @@
+import { ChangeDetectorRef, Directive, ElementRef, ErrorHandler, Input, Renderer2, inject, } from '@angular/core';
+import { VALUE_CHANGE_EVENT } from './renderer/value-change';
+import { registerViewFlush, unregisterViewFlush, } from './change-detection-flush';
+import * as i0 from "@angular/core";
+/**
+ * The shared half of every element directive: the prop surface all tags accept, and the ONE
+ * generic forward that puts a claimed binding back on the engine node.
+ *
+ * The forward is the deciding fact of this whole route. A binding claimed by a directive input
+ * never reaches `Renderer2.setProperty` on its own — Angular writes it to the directive instance
+ * — so without this loop a bare tag commits nothing at all. It stays generic on purpose: per-prop
+ * forwarding code is a component wrapper by another name, which is what this migration removes.
+ * `renderer.setProperty` lands in the adapter's own renderer, which routes the value through the
+ * engine's `routeProp` and applies the `id` -> `nativeID` alias.
+ */
+export class SymbioteElement {
+    constructor() {
+        this.renderer = inject(Renderer2);
+        this.host = inject(ElementRef);
+    }
+    ngOnChanges(changes) {
+        for (const name of Object.keys(changes)) {
+            this.renderer.setProperty(this.host.nativeElement, name, 
+            // Unwrapped on purpose: `SymbioteRenderer.setProperty` is where an `on*` value is wrapped
+            // now, and it is the call this line makes.
+            changes[name]?.currentValue);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SymbioteElement, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: SymbioteElement, isStandalone: true, inputs: { testID: "testID", nativeID: "nativeID", id: "id", accessible: "accessible", accessibilityLabel: "accessibilityLabel", accessibilityHint: "accessibilityHint", accessibilityRole: "accessibilityRole", accessibilityState: "accessibilityState", accessibilityValue: "accessibilityValue", accessibilityActions: "accessibilityActions", experimental_accessibilityOrder: "experimental_accessibilityOrder", accessibilityLabelledBy: "accessibilityLabelledBy", importantForAccessibility: "importantForAccessibility", accessibilityLiveRegion: "accessibilityLiveRegion", screenReaderFocusable: "screenReaderFocusable", accessibilityViewIsModal: "accessibilityViewIsModal", accessibilityElementsHidden: "accessibilityElementsHidden", accessibilityIgnoresInvertColors: "accessibilityIgnoresInvertColors", accessibilityLanguage: "accessibilityLanguage", accessibilityRespondsToUserInteraction: "accessibilityRespondsToUserInteraction", accessibilityShowsLargeContentViewer: "accessibilityShowsLargeContentViewer", accessibilityLargeContentTitle: "accessibilityLargeContentTitle", onAccessibilityAction: "onAccessibilityAction", onAccessibilityTap: "onAccessibilityTap", onMagicTap: "onMagicTap", onAccessibilityEscape: "onAccessibilityEscape", role: "role", "aria-label": "aria-label", "aria-labelledby": "aria-labelledby", "aria-live": "aria-live", "aria-hidden": "aria-hidden", "aria-busy": "aria-busy", "aria-checked": "aria-checked", "aria-disabled": "aria-disabled", "aria-expanded": "aria-expanded", "aria-selected": "aria-selected", "aria-modal": "aria-modal", "aria-valuemax": "aria-valuemax", "aria-valuemin": "aria-valuemin", "aria-valuenow": "aria-valuenow", "aria-valuetext": "aria-valuetext", onStartShouldSetResponder: "onStartShouldSetResponder", onStartShouldSetResponderCapture: "onStartShouldSetResponderCapture", onMoveShouldSetResponder: "onMoveShouldSetResponder", onMoveShouldSetResponderCapture: "onMoveShouldSetResponderCapture", onResponderGrant: "onResponderGrant", onResponderReject: "onResponderReject", onResponderStart: "onResponderStart", onResponderMove: "onResponderMove", onResponderEnd: "onResponderEnd", onResponderRelease: "onResponderRelease", onResponderTerminate: "onResponderTerminate", onResponderTerminationRequest: "onResponderTerminationRequest", onTouchStart: "onTouchStart", onTouchStartCapture: "onTouchStartCapture", onTouchMove: "onTouchMove", onTouchMoveCapture: "onTouchMoveCapture", onTouchEnd: "onTouchEnd", onTouchEndCapture: "onTouchEndCapture", onTouchCancel: "onTouchCancel", onTouchCancelCapture: "onTouchCancelCapture", onFocusCapture: "onFocusCapture", onBlurCapture: "onBlurCapture", onClickCapture: "onClickCapture", onKeyDown: "onKeyDown", onKeyDownCapture: "onKeyDownCapture", onKeyUp: "onKeyUp", onKeyUpCapture: "onKeyUpCapture", pointerEvents: "pointerEvents", hitSlop: "hitSlop", focusable: "focusable", collapsable: "collapsable", removeClippedSubviews: "removeClippedSubviews", renderToHardwareTextureAndroid: "renderToHardwareTextureAndroid", shouldRasterizeIOS: "shouldRasterizeIOS", needsOffscreenAlphaCompositing: "needsOffscreenAlphaCompositing", style: "style", styleProp: "styleProp", class: "class", onPress: "onPress", onPressIn: "onPressIn", onPressOut: "onPressOut", onPressMove: "onPressMove", onLongPress: "onLongPress", onLayout: "onLayout", onFocus: "onFocus", onBlur: "onBlur" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SymbioteElement, decorators: [{
+            type: Directive
+        }], propDecorators: { testID: [{
+                type: Input
+            }], nativeID: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], accessible: [{
+                type: Input
+            }], accessibilityLabel: [{
+                type: Input
+            }], accessibilityHint: [{
+                type: Input
+            }], accessibilityRole: [{
+                type: Input
+            }], accessibilityState: [{
+                type: Input
+            }], accessibilityValue: [{
+                type: Input
+            }], accessibilityActions: [{
+                type: Input
+            }], experimental_accessibilityOrder: [{
+                type: Input
+            }], accessibilityLabelledBy: [{
+                type: Input
+            }], importantForAccessibility: [{
+                type: Input
+            }], accessibilityLiveRegion: [{
+                type: Input
+            }], screenReaderFocusable: [{
+                type: Input
+            }], accessibilityViewIsModal: [{
+                type: Input
+            }], accessibilityElementsHidden: [{
+                type: Input
+            }], accessibilityIgnoresInvertColors: [{
+                type: Input
+            }], accessibilityLanguage: [{
+                type: Input
+            }], accessibilityRespondsToUserInteraction: [{
+                type: Input
+            }], accessibilityShowsLargeContentViewer: [{
+                type: Input
+            }], accessibilityLargeContentTitle: [{
+                type: Input
+            }], onAccessibilityAction: [{
+                type: Input
+            }], onAccessibilityTap: [{
+                type: Input
+            }], onMagicTap: [{
+                type: Input
+            }], onAccessibilityEscape: [{
+                type: Input
+            }], role: [{
+                type: Input
+            }], "aria-label": [{
+                type: Input
+            }], "aria-labelledby": [{
+                type: Input
+            }], "aria-live": [{
+                type: Input
+            }], "aria-hidden": [{
+                type: Input
+            }], "aria-busy": [{
+                type: Input
+            }], "aria-checked": [{
+                type: Input
+            }], "aria-disabled": [{
+                type: Input
+            }], "aria-expanded": [{
+                type: Input
+            }], "aria-selected": [{
+                type: Input
+            }], "aria-modal": [{
+                type: Input
+            }], "aria-valuemax": [{
+                type: Input
+            }], "aria-valuemin": [{
+                type: Input
+            }], "aria-valuenow": [{
+                type: Input
+            }], "aria-valuetext": [{
+                type: Input
+            }], onStartShouldSetResponder: [{
+                type: Input
+            }], onStartShouldSetResponderCapture: [{
+                type: Input
+            }], onMoveShouldSetResponder: [{
+                type: Input
+            }], onMoveShouldSetResponderCapture: [{
+                type: Input
+            }], onResponderGrant: [{
+                type: Input
+            }], onResponderReject: [{
+                type: Input
+            }], onResponderStart: [{
+                type: Input
+            }], onResponderMove: [{
+                type: Input
+            }], onResponderEnd: [{
+                type: Input
+            }], onResponderRelease: [{
+                type: Input
+            }], onResponderTerminate: [{
+                type: Input
+            }], onResponderTerminationRequest: [{
+                type: Input
+            }], onTouchStart: [{
+                type: Input
+            }], onTouchStartCapture: [{
+                type: Input
+            }], onTouchMove: [{
+                type: Input
+            }], onTouchMoveCapture: [{
+                type: Input
+            }], onTouchEnd: [{
+                type: Input
+            }], onTouchEndCapture: [{
+                type: Input
+            }], onTouchCancel: [{
+                type: Input
+            }], onTouchCancelCapture: [{
+                type: Input
+            }], onFocusCapture: [{
+                type: Input
+            }], onBlurCapture: [{
+                type: Input
+            }], onClickCapture: [{
+                type: Input
+            }], onKeyDown: [{
+                type: Input
+            }], onKeyDownCapture: [{
+                type: Input
+            }], onKeyUp: [{
+                type: Input
+            }], onKeyUpCapture: [{
+                type: Input
+            }], pointerEvents: [{
+                type: Input
+            }], hitSlop: [{
+                type: Input
+            }], focusable: [{
+                type: Input
+            }], collapsable: [{
+                type: Input
+            }], removeClippedSubviews: [{
+                type: Input
+            }], renderToHardwareTextureAndroid: [{
+                type: Input
+            }], shouldRasterizeIOS: [{
+                type: Input
+            }], needsOffscreenAlphaCompositing: [{
+                type: Input
+            }], style: [{
+                type: Input
+            }], styleProp: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], onPress: [{
+                type: Input
+            }], onPressIn: [{
+                type: Input
+            }], onPressOut: [{
+                type: Input
+            }], onPressMove: [{
+                type: Input
+            }], onLongPress: [{
+                type: Input
+            }], onLayout: [{
+                type: Input
+            }], onFocus: [{
+                type: Input
+            }], onBlur: [{
+                type: Input
+            }] } });
+/**
+ * The base for a tag whose app callback an engine behavior READS BACK inside the same microtask
+ * turn — `<text-input>`, `<switch>`, `<refresh-control>`. Zoneless change detection is a macrotask,
+ * so without this the behavior sees the PRE-event value and undoes the user; the full mechanism,
+ * and why this is `detectChanges()` on one view rather than `ApplicationRef.tick()`, is in
+ * `./change-detection-flush`.
+ *
+ * The directive is the only thing in the adapter that owns a `ChangeDetectorRef` for the view
+ * holding the binding, so it hands one to the renderer keyed on its own node.
+ */
+export class ReadBackElement extends SymbioteElement {
+    constructor() {
+        super();
+        // ITS OWN, now that the base has none. Three tags reach this class, so the injection is paid where
+        // it is read instead of on every element of a screen.
+        this.detector = inject(ChangeDetectorRef);
+        this.errorHandler = inject(ErrorHandler);
+        const node = this.host.nativeElement;
+        if (typeof node === 'object' && node !== null) {
+            registerViewFlush(node, () => this.flush());
+        }
+    }
+    // REPORTED, NOT RETHROWN — Angular's own contract. Every other change detection runs inside
+    // `ApplicationRef.tick()`, caught by `ErrorHandler` (`SymbioteErrorHandler`); this flush instead
+    // runs from a native event dispatch, where an uncaught throw has nowhere to go but `RCTFatal`.
+    flush() {
+        try {
+            this.detector.detectChanges();
+        }
+        catch (error) {
+            this.errorHandler.handleError(error);
+        }
+    }
+    ngOnDestroy() {
+        const node = this.host.nativeElement;
+        if (typeof node === 'object' && node !== null)
+            unregisterViewFlush(node);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ReadBackElement, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ReadBackElement, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ReadBackElement, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+/**
+ * The `[(value)]` half of a controlled tag — `<switch>` and `<text-input>`.
+ *
+ * The one `@Output` in this file, and it is FORCED rather than chosen. `[(value)]` desugars to
+ * `[value]` + `(valueChange)`, and ngtsc requires both halves to resolve to the SAME target: a
+ * declared `value` input beside an event no directive claims is NG8007, "the property and event
+ * halves are not bound to the same target". So the sugar this adapter documents cannot work without
+ * the output existing, whatever the file header says about events in general.
+ *
+ * The bridge below is NOT what makes the binding work today, and the comment says so because the
+ * obvious reading is wrong: the file header's "an `@Output` CONSUMES the binding" holds for a
+ * COMPONENT, and an element is the other case — Angular attaches the renderer listener for the
+ * event as well, so `Renderer2.listen` still runs and the engine still hears the change. Measured
+ * under JIT by deleting this whole hook: every case in `renderer/two-way-value.test.ts` stayed
+ * green, delivery included, and exactly ONCE (nothing double-fires when both paths exist).
+ *
+ * It is kept because the measurement is JIT-only and this adapter has a recorded case of JIT and
+ * AOT resolving a binding differently (`test-harness-false-greens.md` §21). If AOT routes the event
+ * exclusively to the output, this hook is the only thing keeping `[(value)]` alive; if it routes to
+ * both, it is one extra listener on a control an app explicitly bound. Delete it once something
+ * executes the LINKED artifact and shows the renderer listener is attached there too.
+ *
+ * Opened only when something is SUBSCRIBED: the prop's PRESENCE is what a behavior reads to decide
+ * it is controlled, so a `<switch>` given a handler nobody asked for changes how it snaps back.
+ * `.observed` is readable from `ngOnInit` because Angular subscribes outputs in the creation pass,
+ * before the update pass runs the hook — observed directly (true for the two bound tags, false for
+ * an unbound one), not assumed.
+ */
+export class ValueChangeElement extends ReadBackElement {
+    constructor() {
+        super(...arguments);
+        this.valueRenderer = inject(Renderer2);
+        this.valueHost = inject(ElementRef);
+    }
+    ngOnInit() {
+        if (!this.hasValueSubscriber())
+            return;
+        this.unlistenValue = this.valueRenderer.listen(this.valueHost.nativeElement, VALUE_CHANGE_EVENT, (value) => {
+            this.emitValue(value);
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.unlistenValue?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ValueChangeElement, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: ValueChangeElement, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ValueChangeElement, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=element-base.js.map

package/build/angular/element-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-base.js","sourceRoot":"","sources":["../../src/element-base.ts"],"names":[],"mappings":"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"}

package/build/angular/element-props.d.ts

@@ -1,4 +1,4 @@
-import type { IAccessibilityProps, IAriaProps, IPressState, IRectOffset, IResponderProps } from '@symbiote-native/components';
+import type { IAccessibilityProps, IAriaProps, IPressState, IRectOffset, IResponderProps, ITextNativeOnlyProps } from '@symbiote-native/components';
 import type { ISymbioteEvent, IStyleProp, ITextStyle, IViewStyle } from '@symbiote-native/engine';
 type IEventHandler = (event: ISymbioteEvent) => void;
 /**
@@ -9,7 +9,7 @@ type IEventHandler = (event: ISymbioteEvent) => void;
 export type IAngularStyleBinding<TStyle> = TStyle | string | null | undefined;
 /** RN's full StyleProp, press-state callback included: the `[styleProp]` binding. */
 export type IElementStyleProp = IStyleProp<IViewStyle> | ((state: IPressState) => IStyleProp<IViewStyle>);
-export interface IElementProps extends IAccessibilityProps, IAriaProps, IResponderProps {
+export type IElementProps = IAccessibilityProps & IAriaProps & IResponderProps & {
     /** RN's modern W3C-named alias for `nativeID`; the renderer folds it (`PROP_ALIASES`). */
     id?: string;
     pointerEvents?: 'auto' | 'none' | 'box-none' | 'box-only';
@@ -36,9 +36,9 @@ export interface IElementProps extends IAccessibilityProps, IAriaProps, IRespond
     onLayout?: IEventHandler;
     onFocus?: IEventHandler;
     onBlur?: IEventHandler;
-}
+};
 /** Text's own surface on top of the shared one. `onTextLayout` is an event, so it is not here. */
-export interface ITextElementProps {
+export type ITextElementProps = ITextNativeOnlyProps & {
     /** Narrows the shared `style` so `fontSize` / `fontWeight` type-check on a `<text>`. */
     style?: IAngularStyleBinding<ITextStyle>;
     styleProp?: IStyleProp<ITextStyle>;
@@ -51,12 +51,12 @@ export interface ITextElementProps {
     maxFontSizeMultiplier?: number | null;
     selectionColor?: string;
     disabled?: boolean;
-}
+};
 /** The sticky-header wrapper RN builds in JS (ScrollViewStickyHeader.js). */
-export interface IStickyHeaderElementProps {
+export type IStickyHeaderElementProps = {
     inverted?: boolean;
     nextHeaderLayoutY?: number | null;
     scrollAnimatedValue?: unknown;
     scrollViewHeight?: number | null;
-}
+};
 export {};

package/build/angular/element-text-input-native.d.ts

@@ -0,0 +1,27 @@
+import type { ITextInputProps } from '@symbiote-native/components';
+import { ValueChangeElement } from './element-base';
+import * as i0 from "@angular/core";
+export declare abstract class TextInputNativeInputs extends ValueChangeElement {
+    caretHidden?: ITextInputProps['caretHidden'];
+    clearButtonMode?: ITextInputProps['clearButtonMode'];
+    clearTextOnFocus?: ITextInputProps['clearTextOnFocus'];
+    contextMenuHidden?: ITextInputProps['contextMenuHidden'];
+    dataDetectorTypes?: ITextInputProps['dataDetectorTypes'];
+    disableFullscreenUI?: ITextInputProps['disableFullscreenUI'];
+    disableKeyboardShortcuts?: ITextInputProps['disableKeyboardShortcuts'];
+    enablesReturnKeyAutomatically?: ITextInputProps['enablesReturnKeyAutomatically'];
+    importantForAutofill?: ITextInputProps['importantForAutofill'];
+    inlineImageLeft?: ITextInputProps['inlineImageLeft'];
+    inlineImagePadding?: ITextInputProps['inlineImagePadding'];
+    inputAccessoryViewButtonLabel?: ITextInputProps['inputAccessoryViewButtonLabel'];
+    keyboardAppearance?: ITextInputProps['keyboardAppearance'];
+    lineBreakModeIOS?: ITextInputProps['lineBreakModeIOS'];
+    lineBreakStrategyIOS?: ITextInputProps['lineBreakStrategyIOS'];
+    passwordRules?: ITextInputProps['passwordRules'];
+    returnKeyLabel?: ITextInputProps['returnKeyLabel'];
+    smartInsertDelete?: ITextInputProps['smartInsertDelete'];
+    spellCheck?: ITextInputProps['spellCheck'];
+    textBreakStrategy?: ITextInputProps['textBreakStrategy'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextInputNativeInputs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextInputNativeInputs, never, never, { "caretHidden": { "alias": "caretHidden"; "required": false; }; "clearButtonMode": { "alias": "clearButtonMode"; "required": false; }; "clearTextOnFocus": { "alias": "clearTextOnFocus"; "required": false; }; "contextMenuHidden": { "alias": "contextMenuHidden"; "required": false; }; "dataDetectorTypes": { "alias": "dataDetectorTypes"; "required": false; }; "disableFullscreenUI": { "alias": "disableFullscreenUI"; "required": false; }; "disableKeyboardShortcuts": { "alias": "disableKeyboardShortcuts"; "required": false; }; "enablesReturnKeyAutomatically": { "alias": "enablesReturnKeyAutomatically"; "required": false; }; "importantForAutofill": { "alias": "importantForAutofill"; "required": false; }; "inlineImageLeft": { "alias": "inlineImageLeft"; "required": false; }; "inlineImagePadding": { "alias": "inlineImagePadding"; "required": false; }; "inputAccessoryViewButtonLabel": { "alias": "inputAccessoryViewButtonLabel"; "required": false; }; "keyboardAppearance": { "alias": "keyboardAppearance"; "required": false; }; "lineBreakModeIOS": { "alias": "lineBreakModeIOS"; "required": false; }; "lineBreakStrategyIOS": { "alias": "lineBreakStrategyIOS"; "required": false; }; "passwordRules": { "alias": "passwordRules"; "required": false; }; "returnKeyLabel": { "alias": "returnKeyLabel"; "required": false; }; "smartInsertDelete": { "alias": "smartInsertDelete"; "required": false; }; "spellCheck": { "alias": "spellCheck"; "required": false; }; "textBreakStrategy": { "alias": "textBreakStrategy"; "required": false; }; }, {}, never, never, true, never>;
+}

package/build/angular/element-text-input-native.js

@@ -0,0 +1,52 @@
+import { Directive, Input } from '@angular/core';
+import { ValueChangeElement } from './element-base';
+import * as i0 from "@angular/core";
+// The inputs only one platform's native view reads, split from `TextInputElement` for file size
+export class TextInputNativeInputs extends ValueChangeElement {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TextInputNativeInputs, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.8", type: TextInputNativeInputs, isStandalone: true, inputs: { caretHidden: "caretHidden", clearButtonMode: "clearButtonMode", clearTextOnFocus: "clearTextOnFocus", contextMenuHidden: "contextMenuHidden", dataDetectorTypes: "dataDetectorTypes", disableFullscreenUI: "disableFullscreenUI", disableKeyboardShortcuts: "disableKeyboardShortcuts", enablesReturnKeyAutomatically: "enablesReturnKeyAutomatically", importantForAutofill: "importantForAutofill", inlineImageLeft: "inlineImageLeft", inlineImagePadding: "inlineImagePadding", inputAccessoryViewButtonLabel: "inputAccessoryViewButtonLabel", keyboardAppearance: "keyboardAppearance", lineBreakModeIOS: "lineBreakModeIOS", lineBreakStrategyIOS: "lineBreakStrategyIOS", passwordRules: "passwordRules", returnKeyLabel: "returnKeyLabel", smartInsertDelete: "smartInsertDelete", spellCheck: "spellCheck", textBreakStrategy: "textBreakStrategy" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TextInputNativeInputs, decorators: [{
+            type: Directive
+        }], propDecorators: { caretHidden: [{
+                type: Input
+            }], clearButtonMode: [{
+                type: Input
+            }], clearTextOnFocus: [{
+                type: Input
+            }], contextMenuHidden: [{
+                type: Input
+            }], dataDetectorTypes: [{
+                type: Input
+            }], disableFullscreenUI: [{
+                type: Input
+            }], disableKeyboardShortcuts: [{
+                type: Input
+            }], enablesReturnKeyAutomatically: [{
+                type: Input
+            }], importantForAutofill: [{
+                type: Input
+            }], inlineImageLeft: [{
+                type: Input
+            }], inlineImagePadding: [{
+                type: Input
+            }], inputAccessoryViewButtonLabel: [{
+                type: Input
+            }], keyboardAppearance: [{
+                type: Input
+            }], lineBreakModeIOS: [{
+                type: Input
+            }], lineBreakStrategyIOS: [{
+                type: Input
+            }], passwordRules: [{
+                type: Input
+            }], returnKeyLabel: [{
+                type: Input
+            }], smartInsertDelete: [{
+                type: Input
+            }], spellCheck: [{
+                type: Input
+            }], textBreakStrategy: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=element-text-input-native.js.map

package/build/angular/element-text-input-native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-text-input-native.js","sourceRoot":"","sources":["../../src/element-text-input-native.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;;AAEpD,gGAAgG;AAEhG,MAAM,OAAgB,qBAAsB,SAAQ,kBAAkB;8GAAhD,qBAAqB;kGAArB,qBAAqB;;2FAArB,qBAAqB;kBAD1C,SAAS;;sBAEP,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBAEL,KAAK;;sBAEL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBAEL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK;;sBACL,KAAK"}

package/build/angular/elements-controls.d.ts

@@ -0,0 +1,171 @@
+import { EventEmitter } from '@angular/core';
+import type { OnDestroy } from '@angular/core';
+import { type ControlValueAccessor } from '@angular/forms';
+import type { IActivityIndicatorProps, IInputAccessoryViewViewProps, ILayoutConformanceMode, IModalViewProps, ISwitchProps, ITextInputProps } from '@symbiote-native/components';
+import type { IStickyHeaderElementProps } from './element-props';
+import type { IAngularRefreshControlProps } from './components/refresh-control-props';
+import { TextInputNativeInputs } from './element-text-input-native';
+import { ReadBackElement, SymbioteElement, ValueChangeElement } from './element-base';
+import * as i0 from "@angular/core";
+export declare class TextInputElement extends TextInputNativeInputs {
+    value?: ITextInputProps['value'];
+    defaultValue?: ITextInputProps['defaultValue'];
+    placeholder?: ITextInputProps['placeholder'];
+    placeholderTextColor?: ITextInputProps['placeholderTextColor'];
+    multiline?: ITextInputProps['multiline'];
+    numberOfLines?: ITextInputProps['numberOfLines'];
+    maxLength?: ITextInputProps['maxLength'];
+    editable?: ITextInputProps['editable'];
+    readOnly?: ITextInputProps['readOnly'];
+    autoFocus?: ITextInputProps['autoFocus'];
+    autoCapitalize?: ITextInputProps['autoCapitalize'];
+    autoComplete?: ITextInputProps['autoComplete'];
+    autoCorrect?: ITextInputProps['autoCorrect'];
+    blurOnSubmit?: ITextInputProps['blurOnSubmit'];
+    submitBehavior?: ITextInputProps['submitBehavior'];
+    cursorColor?: ITextInputProps['cursorColor'];
+    enterKeyHint?: ITextInputProps['enterKeyHint'];
+    returnKeyType?: ITextInputProps['returnKeyType'];
+    inputMode?: ITextInputProps['inputMode'];
+    keyboardType?: ITextInputProps['keyboardType'];
+    inputAccessoryViewID?: ITextInputProps['inputAccessoryViewID'];
+    scrollEnabled?: ITextInputProps['scrollEnabled'];
+    secureTextEntry?: ITextInputProps['secureTextEntry'];
+    selectTextOnFocus?: ITextInputProps['selectTextOnFocus'];
+    selection?: ITextInputProps['selection'];
+    selectionColor?: ITextInputProps['selectionColor'];
+    selectionHandleColor?: ITextInputProps['selectionHandleColor'];
+    showSoftInputOnFocus?: ITextInputProps['showSoftInputOnFocus'];
+    textAlign?: ITextInputProps['textAlign'];
+    textContentType?: ITextInputProps['textContentType'];
+    underlineColorAndroid?: ITextInputProps['underlineColorAndroid'];
+    onValueChange?: ITextInputProps['onValueChange'];
+    onChangeText?: ITextInputProps['onChangeText'];
+    onContentSizeChange?: ITextInputProps['onContentSizeChange'];
+    onEndEditing?: ITextInputProps['onEndEditing'];
+    onKeyPress?: ITextInputProps['onKeyPress'];
+    onSelectionChange?: ITextInputProps['onSelectionChange'];
+    onSubmitEditing?: ITextInputProps['onSubmitEditing'];
+    readonly valueChange: EventEmitter<string>;
+    protected hasValueSubscriber(): boolean;
+    protected emitValue(value: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextInputElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextInputElement, "text-input", never, { "value": { "alias": "value"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderTextColor": { "alias": "placeholderTextColor"; "required": false; }; "multiline": { "alias": "multiline"; "required": false; }; "numberOfLines": { "alias": "numberOfLines"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "autoCapitalize": { "alias": "autoCapitalize"; "required": false; }; "autoComplete": { "alias": "autoComplete"; "required": false; }; "autoCorrect": { "alias": "autoCorrect"; "required": false; }; "blurOnSubmit": { "alias": "blurOnSubmit"; "required": false; }; "submitBehavior": { "alias": "submitBehavior"; "required": false; }; "cursorColor": { "alias": "cursorColor"; "required": false; }; "enterKeyHint": { "alias": "enterKeyHint"; "required": false; }; "returnKeyType": { "alias": "returnKeyType"; "required": false; }; "inputMode": { "alias": "inputMode"; "required": false; }; "keyboardType": { "alias": "keyboardType"; "required": false; }; "inputAccessoryViewID": { "alias": "inputAccessoryViewID"; "required": false; }; "scrollEnabled": { "alias": "scrollEnabled"; "required": false; }; "secureTextEntry": { "alias": "secureTextEntry"; "required": false; }; "selectTextOnFocus": { "alias": "selectTextOnFocus"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "selectionColor": { "alias": "selectionColor"; "required": false; }; "selectionHandleColor": { "alias": "selectionHandleColor"; "required": false; }; "showSoftInputOnFocus": { "alias": "showSoftInputOnFocus"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; "textContentType": { "alias": "textContentType"; "required": false; }; "underlineColorAndroid": { "alias": "underlineColorAndroid"; "required": false; }; "onValueChange": { "alias": "onValueChange"; "required": false; }; "onChangeText": { "alias": "onChangeText"; "required": false; }; "onContentSizeChange": { "alias": "onContentSizeChange"; "required": false; }; "onEndEditing": { "alias": "onEndEditing"; "required": false; }; "onKeyPress": { "alias": "onKeyPress"; "required": false; }; "onSelectionChange": { "alias": "onSelectionChange"; "required": false; }; "onSubmitEditing": { "alias": "onSubmitEditing"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+export declare class MultilineTextInputElement extends TextInputElement {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultilineTextInputElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultilineTextInputElement, "text-input-multiline", never, {}, {}, never, never, true, never>;
+}
+export declare class SwitchElement extends ValueChangeElement {
+    value?: ISwitchProps['value'];
+    disabled?: ISwitchProps['disabled'];
+    trackColor?: ISwitchProps['trackColor'];
+    thumbColor?: ISwitchProps['thumbColor'];
+    ios_backgroundColor?: ISwitchProps['ios_backgroundColor'];
+    onValueChange?: ISwitchProps['onValueChange'];
+    readonly valueChange: EventEmitter<NonNullable<boolean | undefined>>;
+    protected hasValueSubscriber(): boolean;
+    protected emitValue(value: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SwitchElement, "switch, symbiote-switch", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "trackColor": { "alias": "trackColor"; "required": false; }; "thumbColor": { "alias": "thumbColor"; "required": false; }; "ios_backgroundColor": { "alias": "ios_backgroundColor"; "required": false; }; "onValueChange": { "alias": "onValueChange"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+/**
+ * `[(ngModel)]` / `formControlName` on a `<text-input>` or a `<switch>`.
+ *
+ * The wrappers provided `NG_VALUE_ACCESSOR` themselves; a tag has no class for @angular/forms to
+ * call into, so the accessor moves onto a directive of its own rather than being dropped — the
+ * shape Angular's own `DefaultValueAccessor` takes for `<input>`. Providing it unconditionally is
+ * safe: @angular/forms looks the accessor up only when an `ngModel` / `formControl*` directive sits
+ * on the SAME element, so a plain `<switch [(value)]>` never reaches it.
+ *
+ * Everything below goes through `Renderer2`, which is the adapter's own — `setProperty` lands in
+ * `routeProp` and `listen('valueChange')` is already unwrapped to a bare value there, so this
+ * directive holds no fold of its own.
+ */
+declare abstract class SymbioteValueAccessor implements ControlValueAccessor, OnDestroy {
+    private readonly renderer;
+    private readonly host;
+    private unlisten?;
+    protected abstract writeDisabled(isDisabled: boolean): void;
+    protected setProp(name: string, value: unknown): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SymbioteValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SymbioteValueAccessor, never, never, {}, {}, never, never, true, never>;
+}
+export declare class TextInputValueAccessor extends SymbioteValueAccessor {
+    protected writeDisabled(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextInputValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextInputValueAccessor, "text-input[ngModel], text-input[formControl], text-input[formControlName], text-input-multiline[ngModel], text-input-multiline[formControl], text-input-multiline[formControlName]", never, {}, {}, never, never, true, never>;
+}
+export declare class SwitchValueAccessor extends SymbioteValueAccessor {
+    protected writeDisabled(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SwitchValueAccessor, "switch[ngModel], switch[formControl], switch[formControlName]", never, {}, {}, never, never, true, never>;
+}
+export declare class ActivityIndicatorElement extends SymbioteElement {
+    animating?: IActivityIndicatorProps['animating'];
+    color?: IActivityIndicatorProps['color'];
+    size?: IActivityIndicatorProps['size'];
+    hidesWhenStopped?: IActivityIndicatorProps['hidesWhenStopped'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityIndicatorElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ActivityIndicatorElement, "activity-indicator", never, { "animating": { "alias": "animating"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "hidesWhenStopped": { "alias": "hidesWhenStopped"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class ActivityIndicatorSpinnerElement extends ActivityIndicatorElement {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityIndicatorSpinnerElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ActivityIndicatorSpinnerElement, "activity-indicator-spinner", never, {}, {}, never, never, true, never>;
+}
+export declare class SafeAreaViewElement extends SymbioteElement {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeAreaViewElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SafeAreaViewElement, "safe-area-view", never, {}, {}, never, never, true, never>;
+}
+export declare class LayoutConformanceElement extends SymbioteElement {
+    mode?: ILayoutConformanceMode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutConformanceElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LayoutConformanceElement, "layout-conformance", never, { "mode": { "alias": "mode"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class ModalElement extends SymbioteElement {
+    visible?: IModalViewProps['visible'];
+    transparent?: IModalViewProps['transparent'];
+    animationType?: IModalViewProps['animationType'];
+    presentationStyle?: IModalViewProps['presentationStyle'];
+    supportedOrientations?: IModalViewProps['supportedOrientations'];
+    hardwareAccelerated?: IModalViewProps['hardwareAccelerated'];
+    statusBarTranslucent?: IModalViewProps['statusBarTranslucent'];
+    navigationBarTranslucent?: IModalViewProps['navigationBarTranslucent'];
+    allowSwipeDismissal?: IModalViewProps['allowSwipeDismissal'];
+    backdropColor?: IModalViewProps['backdropColor'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ModalElement, "modal, symbiote-modal", never, { "visible": { "alias": "visible"; "required": false; }; "transparent": { "alias": "transparent"; "required": false; }; "animationType": { "alias": "animationType"; "required": false; }; "presentationStyle": { "alias": "presentationStyle"; "required": false; }; "supportedOrientations": { "alias": "supportedOrientations"; "required": false; }; "hardwareAccelerated": { "alias": "hardwareAccelerated"; "required": false; }; "statusBarTranslucent": { "alias": "statusBarTranslucent"; "required": false; }; "navigationBarTranslucent": { "alias": "navigationBarTranslucent"; "required": false; }; "allowSwipeDismissal": { "alias": "allowSwipeDismissal"; "required": false; }; "backdropColor": { "alias": "backdropColor"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class RefreshControlElement extends ReadBackElement {
+    refreshing?: IAngularRefreshControlProps['refreshing'];
+    enabled?: IAngularRefreshControlProps['enabled'];
+    colors?: IAngularRefreshControlProps['colors'];
+    tintColor?: IAngularRefreshControlProps['tintColor'];
+    title?: IAngularRefreshControlProps['title'];
+    titleColor?: IAngularRefreshControlProps['titleColor'];
+    size?: IAngularRefreshControlProps['size'];
+    progressBackgroundColor?: IAngularRefreshControlProps['progressBackgroundColor'];
+    progressViewOffset?: IAngularRefreshControlProps['progressViewOffset'];
+    onRefresh?: IAngularRefreshControlProps['onRefresh'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RefreshControlElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RefreshControlElement, "refresh-control", never, { "refreshing": { "alias": "refreshing"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "tintColor": { "alias": "tintColor"; "required": false; }; "title": { "alias": "title"; "required": false; }; "titleColor": { "alias": "titleColor"; "required": false; }; "size": { "alias": "size"; "required": false; }; "progressBackgroundColor": { "alias": "progressBackgroundColor"; "required": false; }; "progressViewOffset": { "alias": "progressViewOffset"; "required": false; }; "onRefresh": { "alias": "onRefresh"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class StickyHeaderElement extends SymbioteElement {
+    inverted?: IStickyHeaderElementProps['inverted'];
+    nextHeaderLayoutY?: IStickyHeaderElementProps['nextHeaderLayoutY'];
+    scrollAnimatedValue?: IStickyHeaderElementProps['scrollAnimatedValue'];
+    scrollViewHeight?: IStickyHeaderElementProps['scrollViewHeight'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<StickyHeaderElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StickyHeaderElement, "sticky-header", never, { "inverted": { "alias": "inverted"; "required": false; }; "nextHeaderLayoutY": { "alias": "nextHeaderLayoutY"; "required": false; }; "scrollAnimatedValue": { "alias": "scrollAnimatedValue"; "required": false; }; "scrollViewHeight": { "alias": "scrollViewHeight"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class InputAccessoryViewElement extends SymbioteElement {
+    backgroundColor?: IInputAccessoryViewViewProps['backgroundColor'];
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputAccessoryViewElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputAccessoryViewElement, "input-accessory-view", never, { "backgroundColor": { "alias": "backgroundColor"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};