@ng-native/components 0.0.1 → 0.1.1

package/dist/pressable.js

@@ -0,0 +1,484 @@
+/**
+ * Press handling, built on the engine's responder system as RN's `Pressability` is.
+ *
+ * `onPress` is not a native event: RN synthesises it in JS from the touch primitives, with a
+ * press rectangle, delays and a long-press timer around them. This is that machine, on the same
+ * responder negotiation, so a button and an enclosing scroll view agree on who owns a drag.
+ */
+import { Directive, booleanAttribute, forwardRef, input, numberAttribute, output, signal, } from '@angular/core';
+import { ViewBase } from "./view-base.js";
+import * as i0 from "@angular/core";
+/**
+ * How far outside its own bounds a control keeps a press: RN's `DEFAULT_PRESS_RECT_OFFSETS`.
+ * More room below, because a thumb rolls downwards as it lifts.
+ */
+const DEFAULT_PRESS_RETENTION = { top: 20, left: 20, right: 20, bottom: 30 };
+/** RN's `DEFAULT_LONG_PRESS_DELAY_MS`. */
+const DEFAULT_LONG_PRESS_DELAY = 500;
+/** RN's `DEFAULT_MIN_PRESS_DURATION`: the pressed look stays at least this long on a quick tap. */
+const DEFAULT_MIN_PRESS_DURATION = 130;
+/**
+ * Used only until a control has been measured. RN measures the view and cancels when the touch
+ * leaves its bounds plus the retention offset; before the first layout arrives there are no
+ * bounds to compare against, so fall back to a small movement threshold rather than treating a
+ * drag of any length as a tap.
+ */
+const PRESS_CANCEL_DISTANCE = 15;
+const insets = (value, fallback) => {
+    if (value === undefined)
+        return fallback;
+    if (typeof value === 'number')
+        return { top: value, left: value, right: value, bottom: value };
+    return {
+        top: value.top ?? 0,
+        left: value.left ?? 0,
+        right: value.right ?? 0,
+        bottom: value.bottom ?? 0,
+    };
+};
+/** Page-space touch point, tolerating the several shapes a Fabric touch payload can take. */
+function touchPoint(event) {
+    const native = (event.nativeEvent ?? {});
+    const touch = native.touches?.[0];
+    return {
+        x: native.pageX ?? touch?.pageX ?? 0,
+        y: native.pageY ?? touch?.pageY ?? 0,
+    };
+}
+const now = () => globalThis.performance?.now?.() ?? Date.now();
+/**
+ * The press machine, and the base of every primitive that takes a touch.
+ *
+ * It declares no host bindings of its own, because `Text` extends it and a host binding runs on
+ * every element that carries it, on every pass. The controls bind theirs through `ControlBase`.
+ */
+export class TouchableBase extends ViewBase {
+    /** Ignore touches entirely. */
+    disabled = input(false, { ...(ngDevMode ? { debugName: "disabled" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * How far outside the hit area a touch may wander before the press is cancelled. Native's
+     * `hitSlop` grows the area a touch can start in; this grows the area it may move within.
+     */
+    pressRetentionOffset = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "pressRetentionOffset" }] : /* istanbul ignore next */ []));
+    /** Milliseconds a touch must be held before `(longPress)` fires. */
+    delayLongPress = input(DEFAULT_LONG_PRESS_DELAY, { ...(ngDevMode ? { debugName: "delayLongPress" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    /** Milliseconds between the touch landing and `(pressIn)`, so a scroll can start first. */
+    delayPressIn = input(0, { ...(ngDevMode ? { debugName: "delayPressIn" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    /** Milliseconds between the touch lifting and `(pressOut)`. */
+    delayPressOut = input(0, { ...(ngDevMode ? { debugName: "delayPressOut" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    /** The pressed state lasts at least this long, so a quick tap still shows it. */
+    minPressDuration = input(DEFAULT_MIN_PRESS_DURATION, { ...(ngDevMode ? { debugName: "minPressDuration" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    /** Whether a scrolling ancestor may take the gesture away mid-press. */
+    cancelable = input(true, { ...(ngDevMode ? { debugName: "cancelable" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /** Android: a native ripple on press. */
+    androidRipple = input(undefined, { ...(ngDevMode ? { debugName: "androidRipple" } : /* istanbul ignore next */ {}), alias: 'android_ripple' });
+    /** The touch lifted inside the press area. Not fired after a `(longPress)` that has a listener. */
+    press = output();
+    pressIn = output();
+    pressOut = output();
+    /**
+     * The touch has been held for `delayLongPress`. With no listener there is no long press, as in
+     * React Native, so a slow tap is still a `press`.
+     */
+    longPress = output();
+    /** Whether a press is in progress, for the pressed look. */
+    pressed = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "pressed" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether a pointer is over the control, which on this platform means an iPad with a trackpad
+     * or a mouse. Always false on a phone, because a phone never sends a pointer event.
+     *
+     * Opted into by exactly the elements that opt into being measured, which is the same question
+     * asked twice: is this a control, or is it a piece of text that merely inherits the machinery.
+     * Registering on everything was the first attempt and put two props on every paragraph on
+     * screen, which is the most numerous node in an app paying for a state a label cannot use.
+     */
+    hovered = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "hovered" }] : /* istanbul ignore next */ []));
+    /*
+     * Methods rather than `computed()`s, because nearly every instance has no ripple and a computed
+     * is an allocation per element whether or not it ever holds anything. The drawable is kept for as
+     * long as the ripple it came from, which is the memo the computed was there to provide: a fresh
+     * object on every pass would re-send the prop on every pass.
+     */
+    rippleBackground() {
+        const ripple = this.androidRipple();
+        return ripple && !ripple.foreground ? this.drawable(ripple) : undefined;
+    }
+    rippleForeground() {
+        const ripple = this.androidRipple();
+        return ripple?.foreground ? this.drawable(ripple) : undefined;
+    }
+    drawn = null;
+    drawable(ripple) {
+        if (this.drawn?.ripple !== ripple)
+            this.drawn = { ripple, drawable: this.rippleDrawable(ripple) };
+        return this.drawn.drawable;
+    }
+    /**
+     * The drawable description Android's `ReactDrawableHelper` reads.
+     *
+     * `color` goes through the engine the way every other colour prop does, and has to: the helper
+     * switches on the value's runtime type and takes a number or a platform-colour map, and anything
+     * else - a `'#ff0000'` written at the call site, say - falls through to `null` and the ripple
+     * draws in the theme's own `colorControlHighlight` instead. Nothing is logged and nothing throws,
+     * so the ripple appears and is simply the wrong colour. RN's own `TouchableNativeFeedback.Ripple`
+     * calls `processColor` here for the same reason.
+     */
+    rippleDrawable(ripple) {
+        return {
+            type: 'RippleAndroid',
+            color: this.engine.color(ripple.color),
+            borderless: ripple.borderless ?? false,
+            rippleRadius: ripple.radius,
+        };
+    }
+    /** Where the touch started, so a drag can be told apart from a tap. */
+    origin = null;
+    /** The control's own size, from its last layout. Null until it has been measured once. */
+    size = null;
+    cancelled = false;
+    longPressed = false;
+    /** How many `(longPress)` listeners there are; the long-press clock only runs with one. */
+    longPressListeners = 0;
+    pressedAt = 0;
+    pressInTimer = null;
+    longPressTimer = null;
+    pressOutTimer = null;
+    constructor() {
+        super();
+        // output() has to be a member's own initializer for the compiler to see it, so its listeners
+        // are counted here, through its public subscribe.
+        const subscribe = this.longPress.subscribe.bind(this.longPress);
+        this.longPress.subscribe = (callback) => {
+            this.longPressListeners++;
+            const subscription = subscribe(callback);
+            let open = true;
+            return {
+                unsubscribe: () => {
+                    if (open)
+                        this.longPressListeners--;
+                    open = false;
+                    subscription.unsubscribe();
+                },
+            };
+        };
+    }
+    /** Called as a press starts and ends, for a subclass that shows it natively. `Text` does. */
+    pressedChanged(_pressed) { }
+    /** Whether a touch starting on this node should be claimed. `Text` narrows it. */
+    claims() {
+        return !this.disabled();
+    }
+    /**
+     * Whether the control's size should be tracked. Native only measures a view that asks, so
+     * this must not be true for every `<text>`: a pressable text opts in, a label never does.
+     */
+    measures() {
+        return true;
+    }
+    /**
+     * Whether a touch this far from where it started is still on the control.
+     *
+     * Distance from the origin is the wrong question on anything large: a thumb tap on a full-width
+     * button easily travels twenty points without ever leaving it, and cancelling there reads as
+     * "the button doesn't work", intermittently and only for some people. What matters is whether
+     * the finger is still within the control plus its hit slop, plus the slop RN allows.
+     *
+     * The touch began somewhere inside the control but we do not know where, so the bound is the
+     * full extent rather than half of it. That errs towards keeping the press, which is the right
+     * way to be wrong: a press that survives a drag the user meant as a scroll is a smaller sin
+     * than a tap that does nothing.
+     */
+    stillOnControl(dx, dy) {
+        if (!this.size)
+            return Math.hypot(dx, dy) <= PRESS_CANCEL_DISTANCE;
+        const slop = insets(this.hitSlop(), { top: 0, left: 0, right: 0, bottom: 0 });
+        const keep = insets(this.pressRetentionOffset(), DEFAULT_PRESS_RETENTION);
+        const horizontal = dx < 0 ? slop.left + keep.left : slop.right + keep.right;
+        const vertical = dy < 0 ? slop.top + keep.top : slop.bottom + keep.bottom;
+        return (Math.abs(dx) <= this.size.width + horizontal && Math.abs(dy) <= this.size.height + vertical);
+    }
+    /**
+     * A lifecycle hook rather than `inject(DestroyRef).onDestroy`: Angular registers a hook once per
+     * directive type, where the callback was a closure and a lookup for every instance - and every
+     * `<text>` on screen is one.
+     */
+    ngOnDestroy() {
+        this.clearTimers();
+        this.stopResponding?.();
+        this.stopLayout?.();
+        this.stopHover?.();
+    }
+    stopResponding = null;
+    stopLayout = null;
+    stopHover = null;
+    ngOnInit() {
+        super.ngOnInit();
+        this.respondIfNeeded();
+        this.measureIfNeeded();
+        this.hoverIfNeeded();
+    }
+    ngOnChanges() {
+        super.ngOnChanges();
+        this.respondIfNeeded();
+        this.measureIfNeeded();
+        this.hoverIfNeeded();
+    }
+    /**
+     * Join the responder negotiation, once this is something a touch can press.
+     *
+     * Behind `measures()` for the same reason as layout and hover: a `<text>` is the commonest node
+     * on screen and almost never a control, and registering every one cost a handler object, six
+     * closures and a responder entry apiece for a touch it would have refused anyway.
+     */
+    respondIfNeeded() {
+        if (this.stopResponding || !this.measures())
+            return;
+        this.stopResponding = this.engine.setResponder(this.node, {
+            // Claim the gesture on touch down unless disabled. Because this goes through the
+            // negotiation, an ancestor can pre-empt us in the capture pass and a nested pressable
+            // wins over us in the bubble pass, neither of which raw touch listeners could express.
+            onStartShouldSetResponder: () => this.claims(),
+            onResponderGrant: (event) => this.onGrant(event),
+            onResponderMove: (event) => this.onMove(event),
+            onResponderRelease: (event) => this.onRelease(event),
+            onResponderTerminate: (event) => this.onTerminate(event),
+            // Yield to an enclosing scroll view when it takes over the drag, unless told not to.
+            onResponderTerminationRequest: () => this.cancelable(),
+        });
+    }
+    /**
+     * `onLayout` is opted into by the engine as soon as something listens for it, which is the only
+     * way the native side reports a view's size at all, and the reason it is only asked for once
+     * `measures()` says so - a `<text>` answers that from an input, and most of them say no.
+     *
+     * Called from the lifecycle rather than watched by an effect. An effect per element is an
+     * allocation and a scheduler entry for every pressable and every piece of text on screen, to
+     * notice a change these two hooks already see.
+     */
+    /**
+     * Hover, on the same terms and behind the same question.
+     *
+     * Fabric will not dispatch a pointer event to a view whose props have not asked for one, and
+     * the engine writes those props when something listens - so listening is the whole opt-in. The
+     * gate is `measures()`, which is not what its name is about but is the right question underneath
+     * it: is this an actual control, or a piece of text that merely inherits the machinery. A label
+     * says no, and two props on every paragraph on screen is not a cost worth paying for a hover
+     * state a label has no use for.
+     *
+     * Never true on a phone, which sends no pointer events at all. This is the one thing an iPad
+     * with a trackpad has that a phone does not.
+     */
+    hoverIfNeeded() {
+        if (this.stopHover || !this.measures())
+            return;
+        const enter = this.engine.setEventListener(this.node, 'topPointerEnter', () => this.hovered.set(true));
+        const leave = this.engine.setEventListener(this.node, 'topPointerLeave', () => this.hovered.set(false));
+        this.stopHover = () => {
+            enter();
+            leave();
+        };
+    }
+    measureIfNeeded() {
+        if (this.stopLayout || !this.measures())
+            return;
+        this.stopLayout = this.engine.setEventListener(this.node, 'topLayout', (event) => {
+            const layout = event
+                .nativeEvent?.layout;
+            if (layout)
+                this.size = { width: layout.width, height: layout.height };
+        });
+    }
+    onGrant(event) {
+        this.origin = touchPoint(event);
+        this.cancelled = false;
+        this.longPressed = false;
+        this.clearTimers();
+        if (this.androidRipple()) {
+            const { x, y } = this.origin;
+            this.engine.dispatchCommand(this.node, 'hotspotUpdate', [x, y]);
+            this.engine.dispatchCommand(this.node, 'setPressed', [true]);
+        }
+        const delay = this.delayPressIn();
+        if (delay > 0)
+            this.pressInTimer = setTimeout(() => this.activate(event), delay);
+        else
+            this.activate(event);
+    }
+    /** `pressIn`, and the long-press clock starts from here. */
+    activate(event) {
+        this.pressInTimer = null;
+        this.pressedAt = now();
+        this.pressed.set(true);
+        this.pressedChanged(true);
+        this.pressIn.emit(event);
+        if (!this.longPressListeners)
+            return;
+        this.longPressTimer = setTimeout(() => {
+            this.longPressTimer = null;
+            this.longPressed = true;
+            this.longPress.emit(event);
+        }, this.delayLongPress());
+    }
+    onMove(event) {
+        if (this.cancelled || !this.origin)
+            return;
+        const point = touchPoint(event);
+        if (this.stillOnControl(point.x - this.origin.x, point.y - this.origin.y))
+            return;
+        // The finger has wandered: this is a drag, not a tap. Give up the press but stay the
+        // responder, so a scroll view underneath still gets its gesture.
+        this.cancelled = true;
+        this.deactivate(event);
+    }
+    onRelease(event) {
+        if (this.androidRipple())
+            this.engine.dispatchCommand(this.node, 'setPressed', [false]);
+        if (this.cancelled)
+            return;
+        // Lifted before the press-in delay ran out: RN still reports a full press.
+        if (this.pressInTimer) {
+            clearTimeout(this.pressInTimer);
+            this.activate(event);
+        }
+        const longPressed = this.longPressed;
+        this.deactivate(event);
+        if (!longPressed)
+            this.press.emit(event);
+    }
+    onTerminate(event) {
+        if (this.androidRipple())
+            this.engine.dispatchCommand(this.node, 'setPressed', [false]);
+        if (this.cancelled)
+            return;
+        this.cancelled = true;
+        this.deactivate(event);
+    }
+    /** `pressOut`, no sooner than `minPressDuration` after `pressIn` and after `delayPressOut`. */
+    deactivate(event) {
+        if (this.pressInTimer) {
+            clearTimeout(this.pressInTimer);
+            this.pressInTimer = null;
+            return;
+        }
+        if (this.longPressTimer) {
+            clearTimeout(this.longPressTimer);
+            this.longPressTimer = null;
+        }
+        if (!this.pressed())
+            return;
+        const held = now() - this.pressedAt;
+        const delay = Math.max(this.delayPressOut(), this.minPressDuration() - held);
+        const out = () => {
+            this.pressOutTimer = null;
+            this.pressed.set(false);
+            this.pressedChanged(false);
+            this.pressOut.emit(event);
+        };
+        if (delay > 0)
+            this.pressOutTimer = setTimeout(out, delay);
+        else
+            out();
+    }
+    clearTimers() {
+        // Every touchable is destroyed through here, and nearly all of them were never pressed.
+        if (!this.pressInTimer && !this.longPressTimer && !this.pressOutTimer)
+            return;
+        for (const timer of [this.pressInTimer, this.longPressTimer, this.pressOutTimer]) {
+            if (timer)
+                clearTimeout(timer);
+        }
+        this.pressInTimer = this.longPressTimer = this.pressOutTimer = null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: TouchableBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.2.0", type: TouchableBase, isStandalone: true, inputs: { disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, pressRetentionOffset: { classPropertyName: "pressRetentionOffset", publicName: "pressRetentionOffset", isSignal: true, isRequired: false, transformFunction: null }, delayLongPress: { classPropertyName: "delayLongPress", publicName: "delayLongPress", isSignal: true, isRequired: false, transformFunction: null }, delayPressIn: { classPropertyName: "delayPressIn", publicName: "delayPressIn", isSignal: true, isRequired: false, transformFunction: null }, delayPressOut: { classPropertyName: "delayPressOut", publicName: "delayPressOut", isSignal: true, isRequired: false, transformFunction: null }, minPressDuration: { classPropertyName: "minPressDuration", publicName: "minPressDuration", isSignal: true, isRequired: false, transformFunction: null }, cancelable: { classPropertyName: "cancelable", publicName: "cancelable", isSignal: true, isRequired: false, transformFunction: null }, androidRipple: { classPropertyName: "androidRipple", publicName: "android_ripple", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { press: "press", pressIn: "pressIn", pressOut: "pressOut", longPress: "longPress" }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: TouchableBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [], propDecorators: { disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], pressRetentionOffset: [{ type: i0.Input, args: [{ isSignal: true, alias: "pressRetentionOffset", required: false }] }], delayLongPress: [{ type: i0.Input, args: [{ isSignal: true, alias: "delayLongPress", required: false }] }], delayPressIn: [{ type: i0.Input, args: [{ isSignal: true, alias: "delayPressIn", required: false }] }], delayPressOut: [{ type: i0.Input, args: [{ isSignal: true, alias: "delayPressOut", required: false }] }], minPressDuration: [{ type: i0.Input, args: [{ isSignal: true, alias: "minPressDuration", required: false }] }], cancelable: [{ type: i0.Input, args: [{ isSignal: true, alias: "cancelable", required: false }] }], androidRipple: [{ type: i0.Input, args: [{ isSignal: true, alias: "android_ripple", required: false }] }], press: [{ type: i0.Output, args: ["press"] }], pressIn: [{ type: i0.Output, args: ["pressIn"] }], pressOut: [{ type: i0.Output, args: ["pressOut"] }], longPress: [{ type: i0.Output, args: ["longPress"] }] } });
+/**
+ * A touchable that is a control: `Pressable`, `TouchableOpacity` and `PressBehavior`.
+ *
+ * The three host bindings every control needs live here rather than on `TouchableBase`, which
+ * `Text` extends: the state that follows `disabled`, and the Android ripple. Controls are few
+ * enough on a screen to pay for a binding on every pass; texts are not.
+ */
+export class ControlBase extends TouchableBase {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ControlBase, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.0", type: ControlBase, isStandalone: true, host: { properties: { "accessibilityState": "accessibilityStateProp()", "nativeBackgroundAndroid": "rippleBackground()", "nativeForegroundAndroid": "rippleForeground()" } }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: ControlBase, decorators: [{
+            type: Directive,
+            args: [{
+                    host: {
+                        // `disabled` is an input of ours, so it cannot reach `ngOnChanges` on the base; this is
+                        // the one binding that keeps the announced state in step with it.
+                        '[accessibilityState]': 'accessibilityStateProp()',
+                        '[nativeBackgroundAndroid]': 'rippleBackground()',
+                        '[nativeForegroundAndroid]': 'rippleForeground()',
+                    },
+                }]
+        }] });
+/**
+ * The press machine on its own, for a component that wants to be pressable rather than to
+ * contain something that is.
+ *
+ * No selector: this is only ever a `hostDirectives` entry. A component listing it gets the whole
+ * of `TouchableBase` on its own host node - the responder negotiation, the press rectangle, the
+ * delays and the long-press timer - instead of wrapping a `<pressable>` and paying for a second
+ * native view.
+ *
+ * It provides `TouchableBase`, so a primitive on the same node can `inject(TouchableBase)` and
+ * read `pressed` without caring whether it landed on this or on a real `<pressable>`.
+ */
+export class PressBehavior extends ControlBase {
+    accessibleByDefault() {
+        return true;
+    }
+    focusableByDefault() {
+        return true;
+    }
+    disabledForAccessibility() {
+        return this.disabled();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: PressBehavior, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.0", type: PressBehavior, isStandalone: true, providers: [{ provide: TouchableBase, useExisting: forwardRef(() => PressBehavior) }], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: PressBehavior, decorators: [{
+            type: Directive,
+            args: [{
+                    providers: [{ provide: TouchableBase, useExisting: forwardRef(() => PressBehavior) }],
+                }]
+        }] });
+/**
+ * A view that responds to presses. RN's `Pressable`, with the same configuration: hit slop,
+ * retention offset, press-in and press-out delays, long press, and an Android ripple.
+ *
+ * `pressed` is a public signal, so a template can style from it through a template reference:
+ * `<pressable #p [style.opacity]="p.pressed() ? 0.5 : 1">`.
+ */
+export class Pressable extends ControlBase {
+    /** `Pressable.js`: a control is an accessibility element, and focusable, unless refused. */
+    accessibleByDefault() {
+        return true;
+    }
+    focusableByDefault() {
+        return true;
+    }
+    disabledForAccessibility() {
+        return this.disabled();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Pressable, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.2.0", type: Pressable, isStandalone: true, selector: "pressable", providers: [{ provide: TouchableBase, useExisting: forwardRef(() => Pressable) }], exportAs: ["pressable"], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Pressable, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'pressable',
+                    exportAs: 'pressable',
+                    providers: [{ provide: TouchableBase, useExisting: forwardRef(() => Pressable) }],
+                }]
+        }] });
+//# sourceMappingURL=pressable.js.map

package/dist/pressable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pressable.js","sourceRoot":"","sources":["../src/pressable.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,KAAK,EACL,eAAe,EACf,MAAM,EACN,MAAM,GACP,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;;AAe1C;;;GAGG;AACH,MAAM,uBAAuB,GAAqB,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;AAC/F,0CAA0C;AAC1C,MAAM,wBAAwB,GAAG,GAAG,CAAC;AACrC,mGAAmG;AACnG,MAAM,0BAA0B,GAAG,GAAG,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAEjC,MAAM,MAAM,GAAG,CAAC,KAAkC,EAAE,QAA0B,EAAE,EAAE;IAChF,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC;IACzC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAC/F,OAAO;QACL,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;QACnB,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC;QACrB,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC;QACvB,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC;KAC1B,CAAC;AACJ,CAAC,CAAC;AAEF,6FAA6F;AAC7F,SAAS,UAAU,CAAC,KAA2B;IAC7C,MAAM,MAAM,GAAG,CAAC,KAAK,CAAC,WAAW,IAAI,EAAE,CAItC,CAAC;IACF,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;IAClC,OAAO;QACL,CAAC,EAAE,MAAM,CAAC,KAAK,IAAI,KAAK,EAAE,KAAK,IAAI,CAAC;QACpC,CAAC,EAAE,MAAM,CAAC,KAAK,IAAI,KAAK,EAAE,KAAK,IAAI,CAAC;KACrC,CAAC;AACJ,CAAC;AAUD,MAAM,GAAG,GAAG,GAAW,EAAE,CAAC,UAAU,CAAC,WAAW,EAAE,GAAG,EAAE,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;AAExE;;;;;GAKG;AAEH,MAAM,OAAgB,aAAc,SAAQ,QAAQ;IAClD,+BAA+B;IACtB,QAAQ,GAAG,KAAK,CAAC,KAAK,gFAAI,SAAS,EAAE,gBAAgB,GAAG,CAAC;IAElE;;;OAGG;IACM,oBAAoB,GAAG,KAAK;wGAAmB,CAAC;IACzD,oEAAoE;IAC3D,cAAc,GAAG,KAAK,CAAC,wBAAwB,sFAAI,SAAS,EAAE,eAAe,GAAG,CAAC;IAC1F,2FAA2F;IAClF,YAAY,GAAG,KAAK,CAAC,CAAC,oFAAI,SAAS,EAAE,eAAe,GAAG,CAAC;IACjE,+DAA+D;IACtD,aAAa,GAAG,KAAK,CAAC,CAAC,qFAAI,SAAS,EAAE,eAAe,GAAG,CAAC;IAClE,iFAAiF;IACxE,gBAAgB,GAAG,KAAK,CAAC,0BAA0B,wFAAI,SAAS,EAAE,eAAe,GAAG,CAAC;IAC9F,wEAAwE;IAC/D,UAAU,GAAG,KAAK,CAAC,IAAI,kFAAI,SAAS,EAAE,gBAAgB,GAAG,CAAC;IACnE,yCAAyC;IAChC,aAAa,GAAG,KAAK,CAAgB,SAAS,qFAAI,KAAK,EAAE,gBAAgB,GAAG,CAAC;IAEtF,mGAAmG;IAC1F,KAAK,GAAG,MAAM,EAAc,CAAC;IAC7B,OAAO,GAAG,MAAM,EAAc,CAAC;IAC/B,QAAQ,GAAG,MAAM,EAAc,CAAC;IACzC;;;OAGG;IACM,SAAS,GAAG,MAAM,EAAc,CAAC;IAE1C,4DAA4D;IACnD,OAAO,GAAG,MAAM,CAAC,KAAK;gFAAC,CAAC;IAEjC;;;;;;;;OAQG;IACM,OAAO,GAAG,MAAM,CAAC,KAAK;gFAAC,CAAC;IAEjC;;;;;OAKG;IACO,gBAAgB;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACpC,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IAES,gBAAgB;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACpC,OAAO,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAChE,CAAC;IAEO,KAAK,GAA+D,IAAI,CAAC;IAEzE,QAAQ,CAAC,MAAqB;QACpC,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM;YAC/B,IAAI,CAAC,KAAK,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;QACjE,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;IAC7B,CAAC;IAED;;;;;;;;;OASG;IACK,cAAc,CAAC,MAAqB;QAC1C,OAAO;YACL,IAAI,EAAE,eAAwB;YAC9B,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;YACtC,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,KAAK;YACtC,YAAY,EAAE,MAAM,CAAC,MAAM;SAC5B,CAAC;IACJ,CAAC;IAED,uEAAuE;IAC/D,MAAM,GAAoC,IAAI,CAAC;IACvD,0FAA0F;IAClF,IAAI,GAA6C,IAAI,CAAC;IACtD,SAAS,GAAG,KAAK,CAAC;IAClB,WAAW,GAAG,KAAK,CAAC;IAC5B,2FAA2F;IACnF,kBAAkB,GAAG,CAAC,CAAC;IACvB,SAAS,GAAG,CAAC,CAAC;IACd,YAAY,GAAyC,IAAI,CAAC;IAC1D,cAAc,GAAyC,IAAI,CAAC;IAC5D,aAAa,GAAyC,IAAI,CAAC;IAEnE;QACE,KAAK,EAAE,CAAC;QACR,6FAA6F;QAC7F,kDAAkD;QAClD,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAChE,IAAI,CAAC,SAAS,CAAC,SAAS,GAAG,CAAC,QAAQ,EAAE,EAAE;YACtC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,MAAM,YAAY,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;YACzC,IAAI,IAAI,GAAG,IAAI,CAAC;YAChB,OAAO;gBACL,WAAW,EAAE,GAAG,EAAE;oBAChB,IAAI,IAAI;wBAAE,IAAI,CAAC,kBAAkB,EAAE,CAAC;oBACpC,IAAI,GAAG,KAAK,CAAC;oBACb,YAAY,CAAC,WAAW,EAAE,CAAC;gBAC7B,CAAC;aACF,CAAC;QACJ,CAAC,CAAC;IACJ,CAAC;IAED,6FAA6F;IACnF,cAAc,CAAC,QAAiB,IAAS,CAAC;IAEpD,kFAAkF;IACxE,MAAM;QACd,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACO,QAAQ;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;OAYG;IACK,cAAc,CAAC,EAAU,EAAE,EAAU;QAC3C,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,qBAAqB,CAAC;QACnE,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QAC9E,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,uBAAuB,CAAC,CAAC;QAC1E,MAAM,UAAU,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAC5E,MAAM,QAAQ,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1E,OAAO,CACL,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,UAAU,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,QAAQ,CAC5F,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,WAAW;QACT,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;QACxB,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;QACpB,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;IACrB,CAAC;IAEO,cAAc,GAAwB,IAAI,CAAC;IAC3C,UAAU,GAAwB,IAAI,CAAC;IACvC,SAAS,GAAwB,IAAI,CAAC;IAErC,QAAQ;QACf,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAEQ,WAAW;QAClB,KAAK,CAAC,WAAW,EAAE,CAAC;QACpB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAED;;;;;;OAMG;IACK,eAAe;QACrB,IAAI,IAAI,CAAC,cAAc,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAAE,OAAO;QACpD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE;YACxD,iFAAiF;YACjF,sFAAsF;YACtF,uFAAuF;YACvF,yBAAyB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE;YAC9C,gBAAgB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;YAChD,eAAe,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YAC9C,kBAAkB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;YACpD,oBAAoB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;YACxD,qFAAqF;YACrF,6BAA6B,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE;SACvD,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH;;;;;;;;;;;;OAYG;IACK,aAAa;QACnB,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAAE,OAAO;QAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,iBAAiB,EAAE,GAAG,EAAE,CAC5E,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CACvB,CAAC;QACF,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,iBAAiB,EAAE,GAAG,EAAE,CAC5E,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,IAAI,CAAC,SAAS,GAAG,GAAG,EAAE;YACpB,KAAK,EAAE,CAAC;YACR,KAAK,EAAE,CAAC;QACV,CAAC,CAAC;IACJ,CAAC;IAEO,eAAe;QACrB,IAAI,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAAE,OAAO;QAChD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE;YAC/E,MAAM,MAAM,GAAI,KAA8E;iBAC3F,WAAW,EAAE,MAAM,CAAC;YACvB,IAAI,MAAM;gBAAE,IAAI,CAAC,IAAI,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;QACzE,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,OAAO,CAAC,KAAiB;QAC/B,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;YACzB,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;YAC7B,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAChE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;QAC/D,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QAClC,IAAI,KAAK,GAAG,CAAC;YAAE,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;;YAC5E,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,4DAA4D;IACpD,QAAQ,CAAC,KAAiB;QAChC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAC1B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,kBAAkB;YAAE,OAAO;QACrC,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,GAAG,EAAE;YACpC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YACxB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;IAC5B,CAAC;IAEO,MAAM,CAAC,KAAiB;QAC9B,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO;QAC3C,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAAE,OAAO;QAClF,qFAAqF;QACrF,iEAAiE;QACjE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAEO,SAAS,CAAC,KAAiB;QACjC,IAAI,IAAI,CAAC,aAAa,EAAE;YAAE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;QACxF,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,2EAA2E;QAC3E,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAChC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvB,IAAI,CAAC,WAAW;YAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAEO,WAAW,CAAC,KAAiB;QACnC,IAAI,IAAI,CAAC,aAAa,EAAE;YAAE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;QACxF,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,+FAA+F;IACvF,UAAU,CAAC,KAAiB;QAClC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAClC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YAAE,OAAO;QAC5B,MAAM,IAAI,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,CAAC;QAC7E,MAAM,GAAG,GAAG,GAAG,EAAE;YACf,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACxB,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAC3B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC,CAAC;QACF,IAAI,KAAK,GAAG,CAAC;YAAE,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;;YACtD,GAAG,EAAE,CAAC;IACb,CAAC;IAEO,WAAW;QACjB,wFAAwF;QACxF,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,cAAc,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO;QAC9E,KAAK,MAAM,KAAK,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;YACjF,IAAI,KAAK;gBAAE,YAAY,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IACtE,CAAC;uGA9VmB,aAAa;2FAAb,aAAa;;2FAAb,aAAa;kBADlC,SAAS;;AAkWV;;;;;;GAMG;AAUH,MAAM,OAAgB,WAAY,SAAQ,aAAa;uGAAjC,WAAW;2FAAX,WAAW;;2FAAX,WAAW;kBAThC,SAAS;mBAAC;oBACT,IAAI,EAAE;wBACJ,wFAAwF;wBACxF,kEAAkE;wBAClE,sBAAsB,EAAE,0BAA0B;wBAClD,2BAA2B,EAAE,oBAAoB;wBACjD,2BAA2B,EAAE,oBAAoB;qBAClD;iBACF;;AAGD;;;;;;;;;;;GAWG;AAIH,MAAM,OAAO,aAAc,SAAQ,WAAW;IACzB,mBAAmB;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAEkB,kBAAkB;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAEkB,wBAAwB;QACzC,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;uGAXU,aAAa;2FAAb,aAAa,iCAFb,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,EAAE,CAAC;;2FAE1E,aAAa;kBAHzB,SAAS;mBAAC;oBACT,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,cAAc,CAAC,EAAE,CAAC;iBACtF;;AAeD;;;;;;GAMG;AAMH,MAAM,OAAO,SAAU,SAAQ,WAAW;IACxC,4FAA4F;IACzE,mBAAmB;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAEkB,kBAAkB;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAEkB,wBAAwB;QACzC,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;uGAZU,SAAS;2FAAT,SAAS,wDAFT,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;;2FAEtE,SAAS;kBALrB,SAAS;mBAAC;oBACT,QAAQ,EAAE,WAAW;oBACrB,QAAQ,EAAE,WAAW;oBACrB,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,CAAC;iBAClF","sourcesContent":["/**\n * Press handling, built on the engine's responder system as RN's `Pressability` is.\n *\n * `onPress` is not a native event: RN synthesises it in JS from the touch primitives, with a\n * press rectangle, delays and a long-press timer around them. This is that machine, on the same\n * responder negotiation, so a button and an enclosing scroll view agree on who owns a drag.\n */\nimport {\n  Directive,\n  booleanAttribute,\n  forwardRef,\n  input,\n  numberAttribute,\n  output,\n  signal,\n} from '@angular/core';\nimport type { NativeSyntheticEvent } from '@ng-native/fabric';\nimport type { Insets, TouchEvent } from './events.ts';\nimport { ViewBase } from './view-base.ts';\n\n/** What a press handler receives: RN's `{nativeEvent}` shape, passed straight through. */\nexport type PressEvent = TouchEvent;\n\n/**\n * Android's ripple, drawn natively. `foreground` paints it over the content rather than behind.\n */\nexport interface AndroidRipple {\n  readonly color?: string | number;\n  readonly borderless?: boolean;\n  readonly radius?: number;\n  readonly foreground?: boolean;\n}\n\n/**\n * How far outside its own bounds a control keeps a press: RN's `DEFAULT_PRESS_RECT_OFFSETS`.\n * More room below, because a thumb rolls downwards as it lifts.\n */\nconst DEFAULT_PRESS_RETENTION: Required<Insets> = { top: 20, left: 20, right: 20, bottom: 30 };\n/** RN's `DEFAULT_LONG_PRESS_DELAY_MS`. */\nconst DEFAULT_LONG_PRESS_DELAY = 500;\n/** RN's `DEFAULT_MIN_PRESS_DURATION`: the pressed look stays at least this long on a quick tap. */\nconst DEFAULT_MIN_PRESS_DURATION = 130;\n\n/**\n * Used only until a control has been measured. RN measures the view and cancels when the touch\n * leaves its bounds plus the retention offset; before the first layout arrives there are no\n * bounds to compare against, so fall back to a small movement threshold rather than treating a\n * drag of any length as a tap.\n */\nconst PRESS_CANCEL_DISTANCE = 15;\n\nconst insets = (value: Insets | number | undefined, fallback: Required<Insets>) => {\n  if (value === undefined) return fallback;\n  if (typeof value === 'number') return { top: value, left: value, right: value, bottom: value };\n  return {\n    top: value.top ?? 0,\n    left: value.left ?? 0,\n    right: value.right ?? 0,\n    bottom: value.bottom ?? 0,\n  };\n};\n\n/** Page-space touch point, tolerating the several shapes a Fabric touch payload can take. */\nfunction touchPoint(event: NativeSyntheticEvent): { x: number; y: number } {\n  const native = (event.nativeEvent ?? {}) as {\n    pageX?: number;\n    pageY?: number;\n    touches?: { pageX?: number; pageY?: number }[];\n  };\n  const touch = native.touches?.[0];\n  return {\n    x: native.pageX ?? touch?.pageX ?? 0,\n    y: native.pageY ?? touch?.pageY ?? 0,\n  };\n}\n\n/** What `rippleDrawable` builds: Android's `RippleAndroid` drawable description. */\ninterface RippleDrawable {\n  readonly type: 'RippleAndroid';\n  readonly color: unknown;\n  readonly borderless: boolean;\n  readonly rippleRadius: number | undefined;\n}\n\nconst now = (): number => globalThis.performance?.now?.() ?? Date.now();\n\n/**\n * The press machine, and the base of every primitive that takes a touch.\n *\n * It declares no host bindings of its own, because `Text` extends it and a host binding runs on\n * every element that carries it, on every pass. The controls bind theirs through `ControlBase`.\n */\n@Directive()\nexport abstract class TouchableBase extends ViewBase {\n  /** Ignore touches entirely. */\n  readonly disabled = input(false, { transform: booleanAttribute });\n\n  /**\n   * How far outside the hit area a touch may wander before the press is cancelled. Native's\n   * `hitSlop` grows the area a touch can start in; this grows the area it may move within.\n   */\n  readonly pressRetentionOffset = input<Insets | number>();\n  /** Milliseconds a touch must be held before `(longPress)` fires. */\n  readonly delayLongPress = input(DEFAULT_LONG_PRESS_DELAY, { transform: numberAttribute });\n  /** Milliseconds between the touch landing and `(pressIn)`, so a scroll can start first. */\n  readonly delayPressIn = input(0, { transform: numberAttribute });\n  /** Milliseconds between the touch lifting and `(pressOut)`. */\n  readonly delayPressOut = input(0, { transform: numberAttribute });\n  /** The pressed state lasts at least this long, so a quick tap still shows it. */\n  readonly minPressDuration = input(DEFAULT_MIN_PRESS_DURATION, { transform: numberAttribute });\n  /** Whether a scrolling ancestor may take the gesture away mid-press. */\n  readonly cancelable = input(true, { transform: booleanAttribute });\n  /** Android: a native ripple on press. */\n  readonly androidRipple = input<AndroidRipple>(undefined, { alias: 'android_ripple' });\n\n  /** The touch lifted inside the press area. Not fired after a `(longPress)` that has a listener. */\n  readonly press = output<PressEvent>();\n  readonly pressIn = output<PressEvent>();\n  readonly pressOut = output<PressEvent>();\n  /**\n   * The touch has been held for `delayLongPress`. With no listener there is no long press, as in\n   * React Native, so a slow tap is still a `press`.\n   */\n  readonly longPress = output<PressEvent>();\n\n  /** Whether a press is in progress, for the pressed look. */\n  readonly pressed = signal(false);\n\n  /**\n   * Whether a pointer is over the control, which on this platform means an iPad with a trackpad\n   * or a mouse. Always false on a phone, because a phone never sends a pointer event.\n   *\n   * Opted into by exactly the elements that opt into being measured, which is the same question\n   * asked twice: is this a control, or is it a piece of text that merely inherits the machinery.\n   * Registering on everything was the first attempt and put two props on every paragraph on\n   * screen, which is the most numerous node in an app paying for a state a label cannot use.\n   */\n  readonly hovered = signal(false);\n\n  /*\n   * Methods rather than `computed()`s, because nearly every instance has no ripple and a computed\n   * is an allocation per element whether or not it ever holds anything. The drawable is kept for as\n   * long as the ripple it came from, which is the memo the computed was there to provide: a fresh\n   * object on every pass would re-send the prop on every pass.\n   */\n  protected rippleBackground(): RippleDrawable | undefined {\n    const ripple = this.androidRipple();\n    return ripple && !ripple.foreground ? this.drawable(ripple) : undefined;\n  }\n\n  protected rippleForeground(): RippleDrawable | undefined {\n    const ripple = this.androidRipple();\n    return ripple?.foreground ? this.drawable(ripple) : undefined;\n  }\n\n  private drawn: { ripple: AndroidRipple; drawable: RippleDrawable } | null = null;\n\n  private drawable(ripple: AndroidRipple): RippleDrawable {\n    if (this.drawn?.ripple !== ripple)\n      this.drawn = { ripple, drawable: this.rippleDrawable(ripple) };\n    return this.drawn.drawable;\n  }\n\n  /**\n   * The drawable description Android's `ReactDrawableHelper` reads.\n   *\n   * `color` goes through the engine the way every other colour prop does, and has to: the helper\n   * switches on the value's runtime type and takes a number or a platform-colour map, and anything\n   * else - a `'#ff0000'` written at the call site, say - falls through to `null` and the ripple\n   * draws in the theme's own `colorControlHighlight` instead. Nothing is logged and nothing throws,\n   * so the ripple appears and is simply the wrong colour. RN's own `TouchableNativeFeedback.Ripple`\n   * calls `processColor` here for the same reason.\n   */\n  private rippleDrawable(ripple: AndroidRipple): RippleDrawable {\n    return {\n      type: 'RippleAndroid' as const,\n      color: this.engine.color(ripple.color),\n      borderless: ripple.borderless ?? false,\n      rippleRadius: ripple.radius,\n    };\n  }\n\n  /** Where the touch started, so a drag can be told apart from a tap. */\n  private origin: { x: number; y: number } | null = null;\n  /** The control's own size, from its last layout. Null until it has been measured once. */\n  private size: { width: number; height: number } | null = null;\n  private cancelled = false;\n  private longPressed = false;\n  /** How many `(longPress)` listeners there are; the long-press clock only runs with one. */\n  private longPressListeners = 0;\n  private pressedAt = 0;\n  private pressInTimer: ReturnType<typeof setTimeout> | null = null;\n  private longPressTimer: ReturnType<typeof setTimeout> | null = null;\n  private pressOutTimer: ReturnType<typeof setTimeout> | null = null;\n\n  constructor() {\n    super();\n    // output() has to be a member's own initializer for the compiler to see it, so its listeners\n    // are counted here, through its public subscribe.\n    const subscribe = this.longPress.subscribe.bind(this.longPress);\n    this.longPress.subscribe = (callback) => {\n      this.longPressListeners++;\n      const subscription = subscribe(callback);\n      let open = true;\n      return {\n        unsubscribe: () => {\n          if (open) this.longPressListeners--;\n          open = false;\n          subscription.unsubscribe();\n        },\n      };\n    };\n  }\n\n  /** Called as a press starts and ends, for a subclass that shows it natively. `Text` does. */\n  protected pressedChanged(_pressed: boolean): void {}\n\n  /** Whether a touch starting on this node should be claimed. `Text` narrows it. */\n  protected claims(): boolean {\n    return !this.disabled();\n  }\n\n  /**\n   * Whether the control's size should be tracked. Native only measures a view that asks, so\n   * this must not be true for every `<text>`: a pressable text opts in, a label never does.\n   */\n  protected measures(): boolean {\n    return true;\n  }\n\n  /**\n   * Whether a touch this far from where it started is still on the control.\n   *\n   * Distance from the origin is the wrong question on anything large: a thumb tap on a full-width\n   * button easily travels twenty points without ever leaving it, and cancelling there reads as\n   * \"the button doesn't work\", intermittently and only for some people. What matters is whether\n   * the finger is still within the control plus its hit slop, plus the slop RN allows.\n   *\n   * The touch began somewhere inside the control but we do not know where, so the bound is the\n   * full extent rather than half of it. That errs towards keeping the press, which is the right\n   * way to be wrong: a press that survives a drag the user meant as a scroll is a smaller sin\n   * than a tap that does nothing.\n   */\n  private stillOnControl(dx: number, dy: number): boolean {\n    if (!this.size) return Math.hypot(dx, dy) <= PRESS_CANCEL_DISTANCE;\n    const slop = insets(this.hitSlop(), { top: 0, left: 0, right: 0, bottom: 0 });\n    const keep = insets(this.pressRetentionOffset(), DEFAULT_PRESS_RETENTION);\n    const horizontal = dx < 0 ? slop.left + keep.left : slop.right + keep.right;\n    const vertical = dy < 0 ? slop.top + keep.top : slop.bottom + keep.bottom;\n    return (\n      Math.abs(dx) <= this.size.width + horizontal && Math.abs(dy) <= this.size.height + vertical\n    );\n  }\n\n  /**\n   * A lifecycle hook rather than `inject(DestroyRef).onDestroy`: Angular registers a hook once per\n   * directive type, where the callback was a closure and a lookup for every instance - and every\n   * `<text>` on screen is one.\n   */\n  ngOnDestroy(): void {\n    this.clearTimers();\n    this.stopResponding?.();\n    this.stopLayout?.();\n    this.stopHover?.();\n  }\n\n  private stopResponding: (() => void) | null = null;\n  private stopLayout: (() => void) | null = null;\n  private stopHover: (() => void) | null = null;\n\n  override ngOnInit(): void {\n    super.ngOnInit();\n    this.respondIfNeeded();\n    this.measureIfNeeded();\n    this.hoverIfNeeded();\n  }\n\n  override ngOnChanges(): void {\n    super.ngOnChanges();\n    this.respondIfNeeded();\n    this.measureIfNeeded();\n    this.hoverIfNeeded();\n  }\n\n  /**\n   * Join the responder negotiation, once this is something a touch can press.\n   *\n   * Behind `measures()` for the same reason as layout and hover: a `<text>` is the commonest node\n   * on screen and almost never a control, and registering every one cost a handler object, six\n   * closures and a responder entry apiece for a touch it would have refused anyway.\n   */\n  private respondIfNeeded(): void {\n    if (this.stopResponding || !this.measures()) return;\n    this.stopResponding = this.engine.setResponder(this.node, {\n      // Claim the gesture on touch down unless disabled. Because this goes through the\n      // negotiation, an ancestor can pre-empt us in the capture pass and a nested pressable\n      // wins over us in the bubble pass, neither of which raw touch listeners could express.\n      onStartShouldSetResponder: () => this.claims(),\n      onResponderGrant: (event) => this.onGrant(event),\n      onResponderMove: (event) => this.onMove(event),\n      onResponderRelease: (event) => this.onRelease(event),\n      onResponderTerminate: (event) => this.onTerminate(event),\n      // Yield to an enclosing scroll view when it takes over the drag, unless told not to.\n      onResponderTerminationRequest: () => this.cancelable(),\n    });\n  }\n\n  /**\n   * `onLayout` is opted into by the engine as soon as something listens for it, which is the only\n   * way the native side reports a view's size at all, and the reason it is only asked for once\n   * `measures()` says so - a `<text>` answers that from an input, and most of them say no.\n   *\n   * Called from the lifecycle rather than watched by an effect. An effect per element is an\n   * allocation and a scheduler entry for every pressable and every piece of text on screen, to\n   * notice a change these two hooks already see.\n   */\n  /**\n   * Hover, on the same terms and behind the same question.\n   *\n   * Fabric will not dispatch a pointer event to a view whose props have not asked for one, and\n   * the engine writes those props when something listens - so listening is the whole opt-in. The\n   * gate is `measures()`, which is not what its name is about but is the right question underneath\n   * it: is this an actual control, or a piece of text that merely inherits the machinery. A label\n   * says no, and two props on every paragraph on screen is not a cost worth paying for a hover\n   * state a label has no use for.\n   *\n   * Never true on a phone, which sends no pointer events at all. This is the one thing an iPad\n   * with a trackpad has that a phone does not.\n   */\n  private hoverIfNeeded(): void {\n    if (this.stopHover || !this.measures()) return;\n    const enter = this.engine.setEventListener(this.node, 'topPointerEnter', () =>\n      this.hovered.set(true),\n    );\n    const leave = this.engine.setEventListener(this.node, 'topPointerLeave', () =>\n      this.hovered.set(false),\n    );\n    this.stopHover = () => {\n      enter();\n      leave();\n    };\n  }\n\n  private measureIfNeeded(): void {\n    if (this.stopLayout || !this.measures()) return;\n    this.stopLayout = this.engine.setEventListener(this.node, 'topLayout', (event) => {\n      const layout = (event as NativeSyntheticEvent<{ layout?: { width: number; height: number } }>)\n        .nativeEvent?.layout;\n      if (layout) this.size = { width: layout.width, height: layout.height };\n    });\n  }\n\n  private onGrant(event: PressEvent): void {\n    this.origin = touchPoint(event);\n    this.cancelled = false;\n    this.longPressed = false;\n    this.clearTimers();\n    if (this.androidRipple()) {\n      const { x, y } = this.origin;\n      this.engine.dispatchCommand(this.node, 'hotspotUpdate', [x, y]);\n      this.engine.dispatchCommand(this.node, 'setPressed', [true]);\n    }\n    const delay = this.delayPressIn();\n    if (delay > 0) this.pressInTimer = setTimeout(() => this.activate(event), delay);\n    else this.activate(event);\n  }\n\n  /** `pressIn`, and the long-press clock starts from here. */\n  private activate(event: PressEvent): void {\n    this.pressInTimer = null;\n    this.pressedAt = now();\n    this.pressed.set(true);\n    this.pressedChanged(true);\n    this.pressIn.emit(event);\n    if (!this.longPressListeners) return;\n    this.longPressTimer = setTimeout(() => {\n      this.longPressTimer = null;\n      this.longPressed = true;\n      this.longPress.emit(event);\n    }, this.delayLongPress());\n  }\n\n  private onMove(event: PressEvent): void {\n    if (this.cancelled || !this.origin) return;\n    const point = touchPoint(event);\n    if (this.stillOnControl(point.x - this.origin.x, point.y - this.origin.y)) return;\n    // The finger has wandered: this is a drag, not a tap. Give up the press but stay the\n    // responder, so a scroll view underneath still gets its gesture.\n    this.cancelled = true;\n    this.deactivate(event);\n  }\n\n  private onRelease(event: PressEvent): void {\n    if (this.androidRipple()) this.engine.dispatchCommand(this.node, 'setPressed', [false]);\n    if (this.cancelled) return;\n    // Lifted before the press-in delay ran out: RN still reports a full press.\n    if (this.pressInTimer) {\n      clearTimeout(this.pressInTimer);\n      this.activate(event);\n    }\n    const longPressed = this.longPressed;\n    this.deactivate(event);\n    if (!longPressed) this.press.emit(event);\n  }\n\n  private onTerminate(event: PressEvent): void {\n    if (this.androidRipple()) this.engine.dispatchCommand(this.node, 'setPressed', [false]);\n    if (this.cancelled) return;\n    this.cancelled = true;\n    this.deactivate(event);\n  }\n\n  /** `pressOut`, no sooner than `minPressDuration` after `pressIn` and after `delayPressOut`. */\n  private deactivate(event: PressEvent): void {\n    if (this.pressInTimer) {\n      clearTimeout(this.pressInTimer);\n      this.pressInTimer = null;\n      return;\n    }\n    if (this.longPressTimer) {\n      clearTimeout(this.longPressTimer);\n      this.longPressTimer = null;\n    }\n    if (!this.pressed()) return;\n    const held = now() - this.pressedAt;\n    const delay = Math.max(this.delayPressOut(), this.minPressDuration() - held);\n    const out = () => {\n      this.pressOutTimer = null;\n      this.pressed.set(false);\n      this.pressedChanged(false);\n      this.pressOut.emit(event);\n    };\n    if (delay > 0) this.pressOutTimer = setTimeout(out, delay);\n    else out();\n  }\n\n  private clearTimers(): void {\n    // Every touchable is destroyed through here, and nearly all of them were never pressed.\n    if (!this.pressInTimer && !this.longPressTimer && !this.pressOutTimer) return;\n    for (const timer of [this.pressInTimer, this.longPressTimer, this.pressOutTimer]) {\n      if (timer) clearTimeout(timer);\n    }\n    this.pressInTimer = this.longPressTimer = this.pressOutTimer = null;\n  }\n}\n\n/**\n * A touchable that is a control: `Pressable`, `TouchableOpacity` and `PressBehavior`.\n *\n * The three host bindings every control needs live here rather than on `TouchableBase`, which\n * `Text` extends: the state that follows `disabled`, and the Android ripple. Controls are few\n * enough on a screen to pay for a binding on every pass; texts are not.\n */\n@Directive({\n  host: {\n    // `disabled` is an input of ours, so it cannot reach `ngOnChanges` on the base; this is\n    // the one binding that keeps the announced state in step with it.\n    '[accessibilityState]': 'accessibilityStateProp()',\n    '[nativeBackgroundAndroid]': 'rippleBackground()',\n    '[nativeForegroundAndroid]': 'rippleForeground()',\n  },\n})\nexport abstract class ControlBase extends TouchableBase {}\n\n/**\n * The press machine on its own, for a component that wants to be pressable rather than to\n * contain something that is.\n *\n * No selector: this is only ever a `hostDirectives` entry. A component listing it gets the whole\n * of `TouchableBase` on its own host node - the responder negotiation, the press rectangle, the\n * delays and the long-press timer - instead of wrapping a `<pressable>` and paying for a second\n * native view.\n *\n * It provides `TouchableBase`, so a primitive on the same node can `inject(TouchableBase)` and\n * read `pressed` without caring whether it landed on this or on a real `<pressable>`.\n */\n@Directive({\n  providers: [{ provide: TouchableBase, useExisting: forwardRef(() => PressBehavior) }],\n})\nexport class PressBehavior extends ControlBase {\n  protected override accessibleByDefault(): boolean {\n    return true;\n  }\n\n  protected override focusableByDefault(): boolean {\n    return true;\n  }\n\n  protected override disabledForAccessibility(): boolean {\n    return this.disabled();\n  }\n}\n\n/**\n * A view that responds to presses. RN's `Pressable`, with the same configuration: hit slop,\n * retention offset, press-in and press-out delays, long press, and an Android ripple.\n *\n * `pressed` is a public signal, so a template can style from it through a template reference:\n * `<pressable #p [style.opacity]=\"p.pressed() ? 0.5 : 1\">`.\n */\n@Directive({\n  selector: 'pressable',\n  exportAs: 'pressable',\n  providers: [{ provide: TouchableBase, useExisting: forwardRef(() => Pressable) }],\n})\nexport class Pressable extends ControlBase {\n  /** `Pressable.js`: a control is an accessibility element, and focusable, unless refused. */\n  protected override accessibleByDefault(): boolean {\n    return true;\n  }\n\n  protected override focusableByDefault(): boolean {\n    return true;\n  }\n\n  protected override disabledForAccessibility(): boolean {\n    return this.disabled();\n  }\n}\n"]}

package/dist/reanimated.d.ts

@@ -0,0 +1,19 @@
+import { type SharedValue as Mutable } from 'react-native-reanimated';
+import { WorkletScrollBase } from './worklet-scroll.ts';
+import { WorkletStyleBase } from './worklet-style.ts';
+import * as i0 from "@angular/core";
+export { workletScroll, workletStyle, type SharedValue, type WorkletScrollSpec, type WorkletStyleSpec, } from './worklets.ts';
+/**
+ * A value both runtimes can see. Reanimated's own `useSharedValue` is this plus a React ref, and
+ * the ref is the half that does not apply here. Typed as Reanimated's own, so it goes to
+ * `cancelAnimation` and the rest of the library as one of theirs would.
+ */
+export declare function sharedValue<T>(initial: T): Mutable<T>;
+export declare class WorkletStyle extends WorkletStyleBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkletStyle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WorkletStyle, "[workletStyle]", never, {}, {}, never, never, true, never>;
+}
+export declare class WorkletScroll extends WorkletScrollBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkletScroll, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WorkletScroll, "[workletScroll]", never, {}, {}, never, never, true, never>;
+}