@symbiote-native/engine 0.4.0 → 1.0.0

package/build/pan-responder/index.d.ts

@@ -29,7 +29,7 @@ export interface IPanResponderCallbacks {
     onPanResponderTerminationRequest?: IActiveCallback;
     onShouldBlockNativeResponder?: IActiveCallback;
 }
-export interface IGestureResponderHandlers {
+export type IGestureResponderHandlers = {
     onStartShouldSetResponder: (event: ISymbioteEvent) => boolean;
     onStartShouldSetResponderCapture: (event: ISymbioteEvent) => boolean;
     onMoveShouldSetResponder: (event: ISymbioteEvent) => boolean;
@@ -42,7 +42,7 @@ export interface IGestureResponderHandlers {
     onResponderRelease: (event: ISymbioteEvent) => void;
     onResponderTerminate: (event: ISymbioteEvent) => void;
     onResponderTerminationRequest: (event: ISymbioteEvent) => boolean;
-}
+};
 export interface IPanResponderInstance {
     panHandlers: IGestureResponderHandlers;
     getInteractionHandle: () => number | null;

package/build/pan-responder/index.js

@@ -12,6 +12,8 @@
 // changed ones on `changedTouches`), so the centroid/velocity math here reads
 // those directly while keeping RN's accumulate-deltas-over-time behavior.
 import { dlog } from '../debug.js';
+// @ts-expect-error - untyped Flow source. Metro compiles it; vitest.config.ts strips the types.
+import TouchHistoryMath from 'react-native/Libraries/Interaction/TouchHistoryMath';
 import { isRecord } from '../type-guards.js';
 const SINGLE_TOUCH_COUNT = 1;
 // onShouldBlockNativeResponder defaults to true (RN: block native by default).
@@ -81,15 +83,6 @@ function mostRecentTimestamp(touches) {
 // that moved this frame, via each touch's own previous->current delta. Headless callers
 // that invoke the handlers directly (no shared, no store) carry no touchHistory and fall
 // back to the centroid path below, which keeps single-touch behavior.
-function isTouchRecord(value) {
-    return (isRecord(value) &&
-        typeof value.touchActive === 'boolean' &&
-        typeof value.currentPageX === 'number' &&
-        typeof value.currentPageY === 'number' &&
-        typeof value.currentTimeStamp === 'number' &&
-        typeof value.previousPageX === 'number' &&
-        typeof value.previousPageY === 'number');
-}
 function isTouchHistory(value) {
     return (isRecord(value) &&
         Array.isArray(value.touchBank) &&
@@ -101,58 +94,31 @@ function touchHistoryOf(event) {
     const raw = event.nativeEvent.touchHistory;
     return isTouchHistory(raw) ? raw : undefined;
 }
-// Ported from RN Interaction/TouchHistoryMath.js:centroidDimension (lines 30-85). Mean
-// of one coordinate over the touches that moved after `touchesChangedAfter`, taking each
-// touch's current or previous position. The single-active-touch fast path uses a strict
-// `>`; the multi-touch scan uses `>=`, both kept from RN.
-function centroidDimension(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
-    const { touchBank } = touchHistory;
-    let total = 0;
-    let count = 0;
-    const single = touchHistory.numberActiveTouches === SINGLE_TOUCH_COUNT
-        ? touchBank[touchHistory.indexOfSingleActiveTouch]
-        : undefined;
-    if (isTouchRecord(single)) {
-        if (single.touchActive && single.currentTimeStamp > touchesChangedAfter) {
-            total += dimensionOf(single, isXAxis, ofCurrent);
-            count = 1;
-        }
-    }
-    else {
-        for (const record of touchBank) {
-            if (isTouchRecord(record) &&
-                record.touchActive &&
-                record.currentTimeStamp >= touchesChangedAfter) {
-                total += dimensionOf(record, isXAxis, ofCurrent);
-                count++;
-            }
-        }
-    }
-    return count > 0 ? total / count : NO_CENTROID;
-}
-const NO_CENTROID = -1;
-function dimensionOf(record, isXAxis, ofCurrent) {
-    if (ofCurrent)
-        return isXAxis ? record.currentPageX : record.currentPageY;
-    return isXAxis ? record.previousPageX : record.previousPageY;
-}
+// The six readings PanResponder needs, under this file's shorter names. Upstream's own module is
+// imported rather than re-derived: it has no dependencies, no native access, and its two scans -
+// a strict `>` on the single-active-touch fast path, `>=` on the multi-touch loop - are
+// load-bearing and easy to reproduce subtly wrong.
+//
+// The per-record runtime guard that used to sit here went with it. It was forced by `nativeEvent`
+// being a Record<string, unknown>; `touchHistoryOf` above already validates the bank at the
+// boundary, and the records inside it are written by our own touch-history.ts.
 function currentCentroidXOfChanged(touchHistory, after) {
-    return centroidDimension(touchHistory, after, true, true);
+    return TouchHistoryMath.currentCentroidXOfTouchesChangedAfter(touchHistory, after);
 }
 function currentCentroidYOfChanged(touchHistory, after) {
-    return centroidDimension(touchHistory, after, false, true);
+    return TouchHistoryMath.currentCentroidYOfTouchesChangedAfter(touchHistory, after);
 }
 function previousCentroidXOfChanged(touchHistory, after) {
-    return centroidDimension(touchHistory, after, true, false);
+    return TouchHistoryMath.previousCentroidXOfTouchesChangedAfter(touchHistory, after);
 }
 function previousCentroidYOfChanged(touchHistory, after) {
-    return centroidDimension(touchHistory, after, false, false);
+    return TouchHistoryMath.previousCentroidYOfTouchesChangedAfter(touchHistory, after);
 }
 function currentCentroidXAll(touchHistory) {
-    return centroidDimension(touchHistory, 0, true, true);
+    return TouchHistoryMath.currentCentroidX(touchHistory);
 }
 function currentCentroidYAll(touchHistory) {
-    return centroidDimension(touchHistory, 0, false, true);
+    return TouchHistoryMath.currentCentroidY(touchHistory);
 }
 // RN PanResponder._updateGestureStateOnMove (Interaction/PanResponder.js lines 330-366):
 // accumulate the centroid change of touches that moved after `_accountsForMovesUpTo`,
@@ -250,9 +216,11 @@ const PanResponder = {
         };
         const panHandlers = {
             onStartShouldSetResponder(event) {
-                return config.onStartShouldSetPanResponder === undefined
+                const wants = config.onStartShouldSetPanResponder === undefined
                     ? false
                     : config.onStartShouldSetPanResponder(event, gestureState);
+                dlog(`PanResponder startShouldSet -> ${wants}`);
+                return wants;
             },
             onMoveShouldSetResponder(event) {
                 return config.onMoveShouldSetPanResponder === undefined
@@ -299,8 +267,17 @@ const PanResponder = {
                     : centroidY(touches);
                 gestureState.dx = 0;
                 gestureState.dy = 0;
-                // The grant frame is already accounted for, so the first move's velocity
-                // is measured from here, not from time 0.
+                // Two deliberate divergences from upstream's onResponderGrant (PanResponder.js:459),
+                // which sets x0/y0/dx/dy and nothing else. Both are decisions, not drift - recorded here
+                // because the first one spent months living in a comment nobody audited against upstream.
+                //
+                // 1. The grant frame is already accounted for, so the first move's velocity is measured
+                //    from here, not from time 0. packages/navigation's drawer reads vx through
+                //    resolveSwipeIntent with a 0.5 flick threshold, and upstream's version makes the first
+                //    move look instantaneous.
+                // 2. numberActiveTouches is refreshed at grant. Upstream leaves whatever the previous
+                //    gesture's onResponderEnd left behind - usually 0 - so an app reading it inside
+                //    onPanResponderGrant gets a stale count there and a correct one everywhere else.
                 gestureState._accountsForMovesUpTo = frameTimestampOf(event, touches);
                 gestureState.numberActiveTouches =
                     touchHistory?.numberActiveTouches ?? touches.length;
@@ -320,12 +297,16 @@ const PanResponder = {
             },
             onResponderMove(event) {
                 const touches = readTouches(event);
-                // Same duplicate-frame guard as the capture path.
-                if (gestureState._accountsForMovesUpTo ===
-                    frameTimestampOf(event, touches)) {
+                const frame = frameTimestampOf(event, touches);
+                // Same duplicate-frame guard as the capture path. Logged on BOTH sides: a frame
+                // stamp that never advances swallows every move while the handlers themselves keep
+                // firing, so the app looks inert with nothing to see from the outside.
+                if (gestureState._accountsForMovesUpTo === frame) {
+                    dlog(`PanResponder move SWALLOWED frame=${frame} touches=${touches.length} history=${touchHistoryOf(event) === undefined ? 'none' : 'yes'}`);
                     return;
                 }
                 updateGestureStateOnMove(gestureState, event, touches);
+                dlog(`PanResponder move frame=${frame} dx=${gestureState.dx} dy=${gestureState.dy}`);
                 config.onPanResponderMove?.(event, gestureState);
             },
             onResponderEnd(event) {

package/build/platform-color/index.d.ts

@@ -13,7 +13,7 @@ export interface IOpaqueColorValue {
         readonly highContrastDark?: IColorValue;
     };
 }
-export type IColorValue = string | IOpaqueColorValue;
+export type IColorValue = string | number | IOpaqueColorValue;
 export declare function PlatformColor(...names: string[]): IOpaqueColorValue;
 export declare function DynamicColorIOS(tuple: IDynamicColorIOSTuple): IOpaqueColorValue;
 export declare function isOpaqueColorValue(value: unknown): value is IOpaqueColorValue;

package/build/platform-color/index.js

@@ -43,9 +43,16 @@ export function setColorProcessor(process) {
 export function processColor(color) {
     return colorProcessor(color);
 }
-// A color-keyed value the platform processor must convert before Fabric: a CSS string, or an
-// opaque PlatformColor / DynamicColorIOS object. Numbers (already platform ints) and undefined
-// are left untouched.
+// A color-keyed value the platform processor must convert before Fabric: a CSS string, a numeric
+// literal, or an opaque PlatformColor / DynamicColorIOS object. `undefined` is left untouched.
+//
+// A number used to be excluded here on the reasoning that it was "already a resolved platform
+// int". Nothing in the pipeline produces one: the CSS parser emits hex STRINGS, and fabricProps
+// builds a fresh payload object instead of writing the resolved value back into node.props, so a
+// number reaching this guard is always the author's own literal. Excluding it committed
+// `color: 0xff0000ff` (opaque red, rrggbbaa) unrotated, and native reads that as aarrggbb: blue.
 export function isProcessableColor(value) {
-    return typeof value === 'string' || isOpaqueColorValue(value);
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        isOpaqueColorValue(value));
 }