react-native-gtkx 0.1.0-alpha.4 → 0.2.0-alpha.2

package/dist/svg/view-box.js

@@ -0,0 +1,108 @@
+// Pure viewBox / preserveAspectRatio math (SVG 1.1 §7.11). No gtkx imports —
+// the bridge feeds the result into Gtk.Snapshot.scale()/translate(), but the
+// arithmetic itself has nothing to do with GTK and is fully unit-testable.
+// "minX minY width height", comma or whitespace separated (SVG allows
+// either). Returns null for anything that doesn't parse to exactly 4
+// numbers or has a non-positive size — callers fall back to the identity
+// transform, same as SVG does when viewBox is absent.
+export const parseViewBox = (value) => {
+    if (!value) {
+        return null;
+    }
+    const parts = value
+        .trim()
+        .split(/[\s,]+/)
+        .map(Number);
+    if (parts.length !== 4 || parts.some((n) => Number.isNaN(n))) {
+        return null;
+    }
+    const [minX, minY, width, height] = parts;
+    if (width <= 0 || height <= 0) {
+        return null;
+    }
+    return { minX, minY, width, height };
+};
+const ALIGN_PATTERN = /^x(Min|Mid|Max)Y(Min|Mid|Max)$/;
+export const DEFAULT_PRESERVE_ASPECT_RATIO = {
+    align: { x: "mid", y: "mid" },
+    meetOrSlice: "meet",
+};
+// Tolerant like the transform-string parser: unrecognized tokens fall back
+// to the SVG default (xMidYMid meet) rather than throwing.
+export const parsePreserveAspectRatio = (value) => {
+    if (!value) {
+        return DEFAULT_PRESERVE_ASPECT_RATIO;
+    }
+    const tokens = value.trim().split(/\s+/);
+    const alignToken = tokens[0] ?? "";
+    const meetOrSlice = tokens[1] === "slice" ? "slice" : "meet";
+    if (alignToken === "none") {
+        return { align: "none", meetOrSlice };
+    }
+    const match = ALIGN_PATTERN.exec(alignToken);
+    if (!match) {
+        return DEFAULT_PRESERVE_ASPECT_RATIO;
+    }
+    const x = match[1].toLowerCase();
+    const y = match[2].toLowerCase();
+    return { align: { x, y }, meetOrSlice };
+};
+const IDENTITY = {
+    scaleX: 1,
+    scaleY: 1,
+    translateX: 0,
+    translateY: 0,
+};
+/**
+ * Maps viewBox user-space coordinates onto a `viewportWidth` x
+ * `viewportHeight` box: `screen = user * scale + translate`. Mirrors the SVG
+ * algorithm exactly (see spec §7.11) — "none" stretches independently per
+ * axis, "meet" fits the whole viewBox inside the viewport (letterboxing),
+ * "slice" fills the viewport and overflows the viewBox (the bridge clips to
+ * the viewport bounds, same as a real SVG renderer).
+ */
+export const resolveViewBoxTransform = (viewBox, viewportWidth, viewportHeight, preserveAspectRatio = DEFAULT_PRESERVE_ASPECT_RATIO) => {
+    if (!viewBox || viewportWidth <= 0 || viewportHeight <= 0) {
+        return IDENTITY;
+    }
+    const rawScaleX = viewportWidth / viewBox.width;
+    const rawScaleY = viewportHeight / viewBox.height;
+    let scaleX;
+    let scaleY;
+    if (preserveAspectRatio.align === "none") {
+        scaleX = rawScaleX;
+        scaleY = rawScaleY;
+    }
+    else {
+        const scale = preserveAspectRatio.meetOrSlice === "meet"
+            ? Math.min(rawScaleX, rawScaleY)
+            : Math.max(rawScaleX, rawScaleY);
+        scaleX = scale;
+        scaleY = scale;
+    }
+    let alignOffsetX = 0;
+    let alignOffsetY = 0;
+    if (preserveAspectRatio.align !== "none") {
+        const extraX = viewportWidth - viewBox.width * scaleX;
+        const extraY = viewportHeight - viewBox.height * scaleY;
+        if (preserveAspectRatio.align.x === "mid") {
+            alignOffsetX = extraX / 2;
+        }
+        else if (preserveAspectRatio.align.x === "max") {
+            alignOffsetX = extraX;
+        }
+        if (preserveAspectRatio.align.y === "mid") {
+            alignOffsetY = extraY / 2;
+        }
+        else if (preserveAspectRatio.align.y === "max") {
+            alignOffsetY = extraY;
+        }
+    }
+    return {
+        scaleX,
+        scaleY,
+        translateX: alignOffsetX - viewBox.minX * scaleX,
+        translateY: alignOffsetY - viewBox.minY * scaleY,
+    };
+};
+//# sourceMappingURL=view-box.js.map

package/dist/svg/view-box.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-box.js","sourceRoot":"","sources":["../../src/svg/view-box.ts"],"names":[],"mappings":"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","sourcesContent":["// Pure viewBox / preserveAspectRatio math (SVG 1.1 §7.11). No gtkx imports —\n// the bridge feeds the result into Gtk.Snapshot.scale()/translate(), but the\n// arithmetic itself has nothing to do with GTK and is fully unit-testable.\n\nexport type ViewBox = {\n  minX: number\n  minY: number\n  width: number\n  height: number\n}\n\n// \"minX minY width height\", comma or whitespace separated (SVG allows\n// either). Returns null for anything that doesn't parse to exactly 4\n// numbers or has a non-positive size — callers fall back to the identity\n// transform, same as SVG does when viewBox is absent.\nexport const parseViewBox = (value: string | undefined): ViewBox | null => {\n  if (!value) {\n    return null\n  }\n  const parts = value\n    .trim()\n    .split(/[\\s,]+/)\n    .map(Number)\n  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n))) {\n    return null\n  }\n  const [minX, minY, width, height] = parts as [number, number, number, number]\n  if (width <= 0 || height <= 0) {\n    return null\n  }\n  return { minX, minY, width, height }\n}\n\nexport type AlignX = \"min\" | \"mid\" | \"max\"\nexport type AlignY = \"min\" | \"mid\" | \"max\"\nexport type MeetOrSlice = \"meet\" | \"slice\"\n\nexport type PreserveAspectRatio = {\n  align: \"none\" | { x: AlignX; y: AlignY }\n  meetOrSlice: MeetOrSlice\n}\n\nconst ALIGN_PATTERN = /^x(Min|Mid|Max)Y(Min|Mid|Max)$/\n\nexport const DEFAULT_PRESERVE_ASPECT_RATIO: PreserveAspectRatio = {\n  align: { x: \"mid\", y: \"mid\" },\n  meetOrSlice: \"meet\",\n}\n\n// Tolerant like the transform-string parser: unrecognized tokens fall back\n// to the SVG default (xMidYMid meet) rather than throwing.\nexport const parsePreserveAspectRatio = (\n  value: string | undefined,\n): PreserveAspectRatio => {\n  if (!value) {\n    return DEFAULT_PRESERVE_ASPECT_RATIO\n  }\n  const tokens = value.trim().split(/\\s+/)\n  const alignToken = tokens[0] ?? \"\"\n  const meetOrSlice: MeetOrSlice = tokens[1] === \"slice\" ? \"slice\" : \"meet\"\n  if (alignToken === \"none\") {\n    return { align: \"none\", meetOrSlice }\n  }\n  const match = ALIGN_PATTERN.exec(alignToken)\n  if (!match) {\n    return DEFAULT_PRESERVE_ASPECT_RATIO\n  }\n  const x = match[1]!.toLowerCase() as AlignX\n  const y = match[2]!.toLowerCase() as AlignY\n  return { align: { x, y }, meetOrSlice }\n}\n\nexport type ViewBoxTransform = {\n  scaleX: number\n  scaleY: number\n  translateX: number\n  translateY: number\n}\n\nconst IDENTITY: ViewBoxTransform = {\n  scaleX: 1,\n  scaleY: 1,\n  translateX: 0,\n  translateY: 0,\n}\n\n/**\n * Maps viewBox user-space coordinates onto a `viewportWidth` x\n * `viewportHeight` box: `screen = user * scale + translate`. Mirrors the SVG\n * algorithm exactly (see spec §7.11) — \"none\" stretches independently per\n * axis, \"meet\" fits the whole viewBox inside the viewport (letterboxing),\n * \"slice\" fills the viewport and overflows the viewBox (the bridge clips to\n * the viewport bounds, same as a real SVG renderer).\n */\nexport const resolveViewBoxTransform = (\n  viewBox: ViewBox | null,\n  viewportWidth: number,\n  viewportHeight: number,\n  preserveAspectRatio: PreserveAspectRatio = DEFAULT_PRESERVE_ASPECT_RATIO,\n): ViewBoxTransform => {\n  if (!viewBox || viewportWidth <= 0 || viewportHeight <= 0) {\n    return IDENTITY\n  }\n  const rawScaleX = viewportWidth / viewBox.width\n  const rawScaleY = viewportHeight / viewBox.height\n\n  let scaleX: number\n  let scaleY: number\n  if (preserveAspectRatio.align === \"none\") {\n    scaleX = rawScaleX\n    scaleY = rawScaleY\n  } else {\n    const scale =\n      preserveAspectRatio.meetOrSlice === \"meet\"\n        ? Math.min(rawScaleX, rawScaleY)\n        : Math.max(rawScaleX, rawScaleY)\n    scaleX = scale\n    scaleY = scale\n  }\n\n  let alignOffsetX = 0\n  let alignOffsetY = 0\n  if (preserveAspectRatio.align !== \"none\") {\n    const extraX = viewportWidth - viewBox.width * scaleX\n    const extraY = viewportHeight - viewBox.height * scaleY\n    if (preserveAspectRatio.align.x === \"mid\") {\n      alignOffsetX = extraX / 2\n    } else if (preserveAspectRatio.align.x === \"max\") {\n      alignOffsetX = extraX\n    }\n    if (preserveAspectRatio.align.y === \"mid\") {\n      alignOffsetY = extraY / 2\n    } else if (preserveAspectRatio.align.y === \"max\") {\n      alignOffsetY = extraY\n    }\n  }\n\n  return {\n    scaleX,\n    scaleY,\n    translateX: alignOffsetX - viewBox.minX * scaleX,\n    translateY: alignOffsetY - viewBox.minY * scaleY,\n  }\n}\n"]}

package/dist/svg-compat/index.d.ts

@@ -0,0 +1 @@
+export { Circle, Defs, Ellipse, G, Line, LinearGradient, Path, Polygon, Polyline, RadialGradient, Rect, Stop, Svg, Svg as default, type AnimatableNumber, type CircleProps, type DefsProps, type EllipseProps, type GProps, type LinearGradientProps, type LineProps, type PathProps, type PolygonProps, type PolylineProps, type RadialGradientProps, type RectProps, type StopProps, type SvgFillRule, type SvgLineCap, type SvgLineJoin, type SvgProps, } from "../components/svg/index";

package/dist/svg-compat/index.js

@@ -0,0 +1,16 @@
+// react-native-svg compatibility subpath (by the same pattern as
+// react-native-gtkx/navigation): re-exports our SVG component set in the
+// shape portable code expects — `Svg` as both the default and a named
+// export, everything else named — once an app aliases the bare
+// react-native-svg package name to this subpath. See the alias the metro/
+// vite presets add automatically (packages/react-native-gtkx/src/metro/
+// index.ts, src/vite/index.ts), or a manual bundler alias for apps using
+// neither. The upstream package itself is never a dependency of this one;
+// nothing here imports it — this module only mirrors its export shape.
+//
+// Deliberate gaps against react-native-svg's full surface (see docs/api.md
+// "Svg" for the complete list and the reasoning): no SvgXml/SvgUri (SVG
+// files already load through Image, a different mechanism), no Text/
+// TSpan/TextPath, no Mask/ClipPath/Filter/Marker/Symbol/Use/Pattern.
+export { Circle, Defs, Ellipse, G, Line, LinearGradient, Path, Polygon, Polyline, RadialGradient, Rect, Stop, Svg, Svg as default, } from "../components/svg/index";
+//# sourceMappingURL=index.js.map

package/dist/svg-compat/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/svg-compat/index.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,yEAAyE;AACzE,sEAAsE;AACtE,+DAA+D;AAC/D,0EAA0E;AAC1E,wEAAwE;AACxE,yEAAyE;AACzE,0EAA0E;AAC1E,uEAAuE;AACvE,EAAE;AACF,2EAA2E;AAC3E,wEAAwE;AACxE,qEAAqE;AACrE,qEAAqE;AACrE,OAAO,EACL,MAAM,EACN,IAAI,EACJ,OAAO,EACP,CAAC,EACD,IAAI,EACJ,cAAc,EACd,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,cAAc,EACd,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,GAAG,IAAI,OAAO,GAkBf,MAAM,yBAAyB,CAAA","sourcesContent":["// react-native-svg compatibility subpath (by the same pattern as\n// react-native-gtkx/navigation): re-exports our SVG component set in the\n// shape portable code expects — `Svg` as both the default and a named\n// export, everything else named — once an app aliases the bare\n// react-native-svg package name to this subpath. See the alias the metro/\n// vite presets add automatically (packages/react-native-gtkx/src/metro/\n// index.ts, src/vite/index.ts), or a manual bundler alias for apps using\n// neither. The upstream package itself is never a dependency of this one;\n// nothing here imports it — this module only mirrors its export shape.\n//\n// Deliberate gaps against react-native-svg's full surface (see docs/api.md\n// \"Svg\" for the complete list and the reasoning): no SvgXml/SvgUri (SVG\n// files already load through Image, a different mechanism), no Text/\n// TSpan/TextPath, no Mask/ClipPath/Filter/Marker/Symbol/Use/Pattern.\nexport {\n  Circle,\n  Defs,\n  Ellipse,\n  G,\n  Line,\n  LinearGradient,\n  Path,\n  Polygon,\n  Polyline,\n  RadialGradient,\n  Rect,\n  Stop,\n  Svg,\n  Svg as default,\n  type AnimatableNumber,\n  type CircleProps,\n  type DefsProps,\n  type EllipseProps,\n  type GProps,\n  type LinearGradientProps,\n  type LineProps,\n  type PathProps,\n  type PolygonProps,\n  type PolylineProps,\n  type RadialGradientProps,\n  type RectProps,\n  type StopProps,\n  type SvgFillRule,\n  type SvgLineCap,\n  type SvgLineJoin,\n  type SvgProps,\n} from \"../components/svg/index\"\n"]}

package/dist/testing/index.d.ts

@@ -0,0 +1,14 @@
+import type { RenderHookOptions, RenderHookResult, RenderResult } from "@gtkx/testing";
+export * from "@gtkx/testing";
+/**
+ * Like `renderHook`, but first creates and presents a harness window (via
+ * `render(null)`), so window-dependent hooks have a toplevel to read.
+ * Cleanup is automatic — @gtkx/testing tears down every active render
+ * (including the harness window) after each test.
+ */
+export declare function renderHookWithWindow<Result>(callback: () => Result, options?: RenderHookOptions<undefined>): Promise<RenderHookResult<Result, undefined> & {
+    window: RenderResult["container"];
+}>;
+export declare function renderHookWithWindow<Result, Props>(callback: (props: Props) => Result, options: RenderHookOptions<Props>): Promise<RenderHookResult<Result, Props> & {
+    window: RenderResult["container"];
+}>;

package/dist/testing/index.js

@@ -0,0 +1,14 @@
+import { render, renderHook } from "@gtkx/testing";
+// react-native-gtkx/testing — @gtkx/testing's queries, render, renderHook,
+// fireEvent and userEvent already operate on the real GTK widget tree our
+// RN components render into, so `getByText` on a `Text` or `userEvent.click`
+// on a `Pressable` already work with no RN-flavoured wrapper: this subpath
+// re-exports that surface as-is, one import source for a consumer, plus the
+// one genuinely repeated workaround (see below).
+export * from "@gtkx/testing";
+export async function renderHookWithWindow(callback, options) {
+    const { container: window } = await render(null);
+    const hook = await renderHook(callback, options);
+    return { ...hook, window };
+}
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAOlD,2EAA2E;AAC3E,0EAA0E;AAC1E,6EAA6E;AAC7E,2EAA2E;AAC3E,4EAA4E;AAC5E,iDAAiD;AACjD,cAAc,eAAe,CAAA;AA2B7B,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,QAAmC,EACnC,OAAkC;IAIlC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,CAAA;IAChD,MAAM,IAAI,GAAG,MAAM,UAAU,CAC3B,QAAoC,EACpC,OAAmC,CACpC,CAAA;IACD,OAAO,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAA;AAC5B,CAAC","sourcesContent":["import { render, renderHook } from \"@gtkx/testing\"\nimport type {\n  RenderHookOptions,\n  RenderHookResult,\n  RenderResult,\n} from \"@gtkx/testing\"\n\n// react-native-gtkx/testing — @gtkx/testing's queries, render, renderHook,\n// fireEvent and userEvent already operate on the real GTK widget tree our\n// RN components render into, so `getByText` on a `Text` or `userEvent.click`\n// on a `Pressable` already work with no RN-flavoured wrapper: this subpath\n// re-exports that surface as-is, one import source for a consumer, plus the\n// one genuinely repeated workaround (see below).\nexport * from \"@gtkx/testing\"\n\n// RC3-WORKAROUND(renderhook-no-window): see docs/gtkx-rc3-notes.md\n// @gtkx/testing's renderHook() always mounts its test component into a bare\n// Gtk.Box, so a hook that reads the active toplevel (useWindowDimensions,\n// anything through Gtk.Window.getToplevels()) has nothing to read. render()\n// always creates and presents a harness window when no container is given,\n// regardless of what it renders — rendering null is enough to get one.\n\n/**\n * Like `renderHook`, but first creates and presents a harness window (via\n * `render(null)`), so window-dependent hooks have a toplevel to read.\n * Cleanup is automatic — @gtkx/testing tears down every active render\n * (including the harness window) after each test.\n */\nexport function renderHookWithWindow<Result>(\n  callback: () => Result,\n  options?: RenderHookOptions<undefined>,\n): Promise<\n  RenderHookResult<Result, undefined> & { window: RenderResult[\"container\"] }\n>\nexport function renderHookWithWindow<Result, Props>(\n  callback: (props: Props) => Result,\n  options: RenderHookOptions<Props>,\n): Promise<\n  RenderHookResult<Result, Props> & { window: RenderResult[\"container\"] }\n>\nexport async function renderHookWithWindow<Result, Props>(\n  callback: (props?: Props) => Result,\n  options?: RenderHookOptions<Props>,\n): Promise<\n  RenderHookResult<Result, Props> & { window: RenderResult[\"container\"] }\n> {\n  const { container: window } = await render(null)\n  const hook = await renderHook(\n    callback as (props: Props) => Result,\n    options as RenderHookOptions<Props>,\n  )\n  return { ...hook, window }\n}\n"]}

package/dist/vendor/react-native/pan-responder.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { GestureResponderEvent } from "../../responder/types";
+export type PanResponderGestureState = {
+    /** ID of the gestureState - persisted as long as there's a touch on screen */
+    stateID: number;
+    /** the latest screen coordinates of the recently-moved touch */
+    moveX: number;
+    /** the latest screen coordinates of the recently-moved touch */
+    moveY: number;
+    /** the screen coordinates of the responder grant */
+    x0: number;
+    /** the screen coordinates of the responder grant */
+    y0: number;
+    /** accumulated distance of the gesture since the touch started */
+    dx: number;
+    /** accumulated distance of the gesture since the touch started */
+    dy: number;
+    /** current velocity of the gesture */
+    vx: number;
+    /** current velocity of the gesture */
+    vy: number;
+    /** Number of touches currently on screen */
+    numberActiveTouches: number;
+    /** All `gestureState` accounts for timeStamps up until this value */
+    _accountsForMovesUpTo: number;
+};
+type ActiveCallback = (event: GestureResponderEvent, gestureState: PanResponderGestureState) => boolean;
+type PassiveCallback = (event: GestureResponderEvent, gestureState: PanResponderGestureState) => unknown;
+export type GestureResponderHandlerMethods = {
+    onMoveShouldSetResponder: (event: GestureResponderEvent) => boolean;
+    onMoveShouldSetResponderCapture: (event: GestureResponderEvent) => boolean;
+    onResponderEnd: (event: GestureResponderEvent) => void;
+    onResponderGrant: (event: GestureResponderEvent) => boolean;
+    onResponderMove: (event: GestureResponderEvent) => void;
+    onResponderReject: (event: GestureResponderEvent) => void;
+    onResponderRelease: (event: GestureResponderEvent) => void;
+    onResponderStart: (event: GestureResponderEvent) => void;
+    onResponderTerminate: (event: GestureResponderEvent) => void;
+    onResponderTerminationRequest: (event: GestureResponderEvent) => boolean;
+    onStartShouldSetResponder: (event: GestureResponderEvent) => boolean;
+    onStartShouldSetResponderCapture: (event: GestureResponderEvent) => boolean;
+};
+export type PanResponderCallbacks = Readonly<{
+    onMoveShouldSetPanResponder?: ActiveCallback;
+    onMoveShouldSetPanResponderCapture?: ActiveCallback;
+    onStartShouldSetPanResponder?: ActiveCallback;
+    onStartShouldSetPanResponderCapture?: ActiveCallback;
+    onPanResponderGrant?: PassiveCallback;
+    onPanResponderMove?: PassiveCallback;
+    onPanResponderRelease?: PassiveCallback;
+    onPanResponderTerminate?: PassiveCallback;
+    onPanResponderReject?: PassiveCallback;
+    onPanResponderStart?: PassiveCallback;
+    onPanResponderEnd?: PassiveCallback;
+    onPanResponderTerminationRequest?: ActiveCallback;
+    onShouldBlockNativeResponder?: ActiveCallback;
+}>;
+declare const PanResponder: {
+    _initializeGestureState(gestureState: PanResponderGestureState): void;
+    /**
+     * This is nuanced and is necessary. It is incorrect to continuously take all
+     * active *and* recently moved touches, find the centroid, and track how that
+     * result changes over time. Instead, we must take all recently moved
+     * touches, and calculate how the centroid has changed just for those
+     * recently moved touches, and append that change to an accumulator. This is
+     * to (at least) handle the case where the user is moving three fingers, and
+     * then one of the fingers stops but the other two continue.
+     *
+     * This is very different than taking all of the recently moved touches and
+     * storing their centroid as `dx/dy`. For correctness, we must *accumulate
+     * changes* in the centroid of recently moved touches.
+     *
+     * There is also some nuance with how we handle multiple moved touches in a
+     * single event. With the way `ReactNativeEventEmitter` dispatches touches as
+     * individual events, multiple touches generate two 'move' events, each of
+     * them triggering `onResponderMove`. But with the way `PanResponder` works,
+     * all of the gesture inference is performed on the first dispatch, since it
+     * looks at all of the touches (even the ones for which there hasn't been a
+     * native dispatch yet). Therefore, `PanResponder` does not call
+     * `onResponderMove` passed the first dispatch. This diverges from the
+     * typical responder callback pattern (without using `PanResponder`), but
+     * avoids more dispatches than necessary.
+     */
+    _updateGestureStateOnMove(gestureState: PanResponderGestureState, touchHistory: GestureResponderEvent["touchHistory"]): void;
+    /**
+     * @param config Enhanced versions of all of the responder callbacks that
+     * provide not only the typical `ResponderSyntheticEvent`, but also the
+     * `PanResponder` gesture state. Simply replace the word `Responder` with
+     * `PanResponder` in each of the typical `onResponder*` callbacks.
+     */
+    create(config: PanResponderCallbacks): {
+        getInteractionHandle: () => number | null;
+        panHandlers: GestureResponderHandlerMethods;
+    };
+};
+export type PanResponderInstance = ReturnType<(typeof PanResponder)["create"]>;
+export default PanResponder;

package/dist/vendor/react-native/pan-responder.js

@@ -0,0 +1,196 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import TouchHistoryMath from "./touch-history-math";
+const currentCentroidXOfTouchesChangedAfter = TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;
+const currentCentroidYOfTouchesChangedAfter = TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;
+const previousCentroidXOfTouchesChangedAfter = TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;
+const previousCentroidYOfTouchesChangedAfter = TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;
+const currentCentroidX = TouchHistoryMath.currentCentroidX;
+const currentCentroidY = TouchHistoryMath.currentCentroidY;
+const PanResponder = {
+    _initializeGestureState(gestureState) {
+        gestureState.moveX = 0;
+        gestureState.moveY = 0;
+        gestureState.x0 = 0;
+        gestureState.y0 = 0;
+        gestureState.dx = 0;
+        gestureState.dy = 0;
+        gestureState.vx = 0;
+        gestureState.vy = 0;
+        gestureState.numberActiveTouches = 0;
+        // All `gestureState` accounts for timeStamps up until:
+        gestureState._accountsForMovesUpTo = 0;
+    },
+    /**
+     * This is nuanced and is necessary. It is incorrect to continuously take all
+     * active *and* recently moved touches, find the centroid, and track how that
+     * result changes over time. Instead, we must take all recently moved
+     * touches, and calculate how the centroid has changed just for those
+     * recently moved touches, and append that change to an accumulator. This is
+     * to (at least) handle the case where the user is moving three fingers, and
+     * then one of the fingers stops but the other two continue.
+     *
+     * This is very different than taking all of the recently moved touches and
+     * storing their centroid as `dx/dy`. For correctness, we must *accumulate
+     * changes* in the centroid of recently moved touches.
+     *
+     * There is also some nuance with how we handle multiple moved touches in a
+     * single event. With the way `ReactNativeEventEmitter` dispatches touches as
+     * individual events, multiple touches generate two 'move' events, each of
+     * them triggering `onResponderMove`. But with the way `PanResponder` works,
+     * all of the gesture inference is performed on the first dispatch, since it
+     * looks at all of the touches (even the ones for which there hasn't been a
+     * native dispatch yet). Therefore, `PanResponder` does not call
+     * `onResponderMove` passed the first dispatch. This diverges from the
+     * typical responder callback pattern (without using `PanResponder`), but
+     * avoids more dispatches than necessary.
+     */
+    _updateGestureStateOnMove(gestureState, touchHistory) {
+        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+        gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+        gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+        const movedAfter = gestureState._accountsForMovesUpTo;
+        const prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+        const x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+        const prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+        const y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+        const nextDX = gestureState.dx + (x - prevX);
+        const nextDY = gestureState.dy + (y - prevY);
+        // TODO: This must be filtered intelligently.
+        const dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
+        gestureState.vx = (nextDX - gestureState.dx) / dt;
+        gestureState.vy = (nextDY - gestureState.dy) / dt;
+        gestureState.dx = nextDX;
+        gestureState.dy = nextDY;
+        gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
+    },
+    /**
+     * @param config Enhanced versions of all of the responder callbacks that
+     * provide not only the typical `ResponderSyntheticEvent`, but also the
+     * `PanResponder` gesture state. Simply replace the word `Responder` with
+     * `PanResponder` in each of the typical `onResponder*` callbacks.
+     */
+    create(config) {
+        const gestureState = {
+            // Useful for debugging
+            stateID: Math.random(),
+            moveX: 0,
+            moveY: 0,
+            x0: 0,
+            y0: 0,
+            dx: 0,
+            dy: 0,
+            vx: 0,
+            vy: 0,
+            numberActiveTouches: 0,
+            _accountsForMovesUpTo: 0,
+        };
+        const panHandlers = {
+            onStartShouldSetResponder(event) {
+                return config.onStartShouldSetPanResponder == null
+                    ? false
+                    : config.onStartShouldSetPanResponder(event, gestureState);
+            },
+            onMoveShouldSetResponder(event) {
+                return config.onMoveShouldSetPanResponder == null
+                    ? false
+                    : config.onMoveShouldSetPanResponder(event, gestureState);
+            },
+            onStartShouldSetResponderCapture(event) {
+                // TODO: Actually, we should reinitialize the state any time
+                // touches.length increases from 0 active to > 0 active.
+                if (event.nativeEvent.touches.length === 1) {
+                    PanResponder._initializeGestureState(gestureState);
+                }
+                gestureState.numberActiveTouches =
+                    event.touchHistory.numberActiveTouches;
+                return config.onStartShouldSetPanResponderCapture != null
+                    ? config.onStartShouldSetPanResponderCapture(event, gestureState)
+                    : false;
+            },
+            onMoveShouldSetResponderCapture(event) {
+                const touchHistory = event.touchHistory;
+                // Responder system incorrectly dispatches should* to current responder
+                // Filter out any touch moves past the first one - we would have
+                // already processed multi-touch geometry during the first event.
+                if (gestureState._accountsForMovesUpTo ===
+                    touchHistory.mostRecentTimeStamp) {
+                    return false;
+                }
+                PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+                return config.onMoveShouldSetPanResponderCapture
+                    ? config.onMoveShouldSetPanResponderCapture(event, gestureState)
+                    : false;
+            },
+            onResponderGrant(event) {
+                gestureState.x0 = currentCentroidX(event.touchHistory);
+                gestureState.y0 = currentCentroidY(event.touchHistory);
+                gestureState.dx = 0;
+                gestureState.dy = 0;
+                if (config.onPanResponderGrant) {
+                    config.onPanResponderGrant(event, gestureState);
+                }
+                // TODO: t7467124 investigate if this can be removed
+                return config.onShouldBlockNativeResponder == null
+                    ? true
+                    : config.onShouldBlockNativeResponder(event, gestureState);
+            },
+            onResponderReject(event) {
+                config.onPanResponderReject?.call(undefined, event, gestureState);
+            },
+            onResponderRelease(event) {
+                config.onPanResponderRelease?.call(undefined, event, gestureState);
+                PanResponder._initializeGestureState(gestureState);
+            },
+            onResponderStart(event) {
+                const touchHistory = event.touchHistory;
+                gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+                if (config.onPanResponderStart) {
+                    config.onPanResponderStart(event, gestureState);
+                }
+            },
+            onResponderMove(event) {
+                const touchHistory = event.touchHistory;
+                // Guard against the dispatch of two touch moves when there are two
+                // simultaneously changed touches.
+                if (gestureState._accountsForMovesUpTo ===
+                    touchHistory.mostRecentTimeStamp) {
+                    return;
+                }
+                // Filter out any touch moves past the first one - we would have
+                // already processed multi-touch geometry during the first event.
+                PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+                if (config.onPanResponderMove) {
+                    config.onPanResponderMove(event, gestureState);
+                }
+            },
+            onResponderEnd(event) {
+                const touchHistory = event.touchHistory;
+                gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+                config.onPanResponderEnd?.call(undefined, event, gestureState);
+            },
+            onResponderTerminate(event) {
+                config.onPanResponderTerminate?.call(undefined, event, gestureState);
+                PanResponder._initializeGestureState(gestureState);
+            },
+            onResponderTerminationRequest(event) {
+                return config.onPanResponderTerminationRequest == null
+                    ? true
+                    : config.onPanResponderTerminationRequest(event, gestureState);
+            },
+        };
+        return {
+            panHandlers,
+            getInteractionHandle() {
+                // TODO: Deprecate and delete this method.
+                return null;
+            },
+        };
+    },
+};
+export default PanResponder;
+//# sourceMappingURL=pan-responder.js.map

package/dist/vendor/react-native/pan-responder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pan-responder.js","sourceRoot":"","sources":["../../../src/vendor/react-native/pan-responder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n// VENDORED from react-native (MIT), Libraries/Interaction/PanResponder.js.\n//\n// react-native-web re-exports Meta's file directly and it works untouched,\n// because RNW reproduces the touchHistory structure PanResponder expects. We\n// reproduce the same structure (src/responder/touch-history.ts), so the\n// algorithm below is upstream's, unmodified in substance.\n//\n// We cannot re-export it the way RNW does: upstream ships Flow, and this\n// package is one tsc emit. So it is transliterated, and ONLY transliterated:\n// - Flow annotations to TypeScript (`?number` to `number | null`,\n//   inexact object types to plain ones, `Readonly<{}>` kept as-is);\n// - `GestureResponderEvent` imported from our responder types instead of\n//   RN's CoreEventTypes;\n// - `require` to `import`.\n//\n// The logic is deliberately untouched, comments included — especially the\n// clustered multi-touch accumulation in _updateGestureStateOnMove, which is\n// the part with no obvious specification and the reason vendoring beats\n// reimplementing.\nimport type { GestureResponderEvent } from \"../../responder/types\"\nimport TouchHistoryMath from \"./touch-history-math\"\n\nconst currentCentroidXOfTouchesChangedAfter =\n  TouchHistoryMath.currentCentroidXOfTouchesChangedAfter\nconst currentCentroidYOfTouchesChangedAfter =\n  TouchHistoryMath.currentCentroidYOfTouchesChangedAfter\nconst previousCentroidXOfTouchesChangedAfter =\n  TouchHistoryMath.previousCentroidXOfTouchesChangedAfter\nconst previousCentroidYOfTouchesChangedAfter =\n  TouchHistoryMath.previousCentroidYOfTouchesChangedAfter\nconst currentCentroidX = TouchHistoryMath.currentCentroidX\nconst currentCentroidY = TouchHistoryMath.currentCentroidY\n\nexport type PanResponderGestureState = {\n  /** ID of the gestureState - persisted as long as there's a touch on screen */\n  stateID: number\n  /** the latest screen coordinates of the recently-moved touch */\n  moveX: number\n  /** the latest screen coordinates of the recently-moved touch */\n  moveY: number\n  /** the screen coordinates of the responder grant */\n  x0: number\n  /** the screen coordinates of the responder grant */\n  y0: number\n  /** accumulated distance of the gesture since the touch started */\n  dx: number\n  /** accumulated distance of the gesture since the touch started */\n  dy: number\n  /** current velocity of the gesture */\n  vx: number\n  /** current velocity of the gesture */\n  vy: number\n  /** Number of touches currently on screen */\n  numberActiveTouches: number\n  /** All `gestureState` accounts for timeStamps up until this value */\n  _accountsForMovesUpTo: number\n}\n\ntype ActiveCallback = (\n  event: GestureResponderEvent,\n  gestureState: PanResponderGestureState,\n) => boolean\n\ntype PassiveCallback = (\n  event: GestureResponderEvent,\n  gestureState: PanResponderGestureState,\n) => unknown\n\nexport type GestureResponderHandlerMethods = {\n  onMoveShouldSetResponder: (event: GestureResponderEvent) => boolean\n  onMoveShouldSetResponderCapture: (event: GestureResponderEvent) => boolean\n  onResponderEnd: (event: GestureResponderEvent) => void\n  onResponderGrant: (event: GestureResponderEvent) => boolean\n  onResponderMove: (event: GestureResponderEvent) => void\n  onResponderReject: (event: GestureResponderEvent) => void\n  onResponderRelease: (event: GestureResponderEvent) => void\n  onResponderStart: (event: GestureResponderEvent) => void\n  onResponderTerminate: (event: GestureResponderEvent) => void\n  onResponderTerminationRequest: (event: GestureResponderEvent) => boolean\n  onStartShouldSetResponder: (event: GestureResponderEvent) => boolean\n  onStartShouldSetResponderCapture: (event: GestureResponderEvent) => boolean\n}\n\nexport type PanResponderCallbacks = Readonly<{\n  onMoveShouldSetPanResponder?: ActiveCallback\n  onMoveShouldSetPanResponderCapture?: ActiveCallback\n  onStartShouldSetPanResponder?: ActiveCallback\n  onStartShouldSetPanResponderCapture?: ActiveCallback\n  onPanResponderGrant?: PassiveCallback\n  onPanResponderMove?: PassiveCallback\n  onPanResponderRelease?: PassiveCallback\n  onPanResponderTerminate?: PassiveCallback\n  onPanResponderReject?: PassiveCallback\n  onPanResponderStart?: PassiveCallback\n  onPanResponderEnd?: PassiveCallback\n  onPanResponderTerminationRequest?: ActiveCallback\n  onShouldBlockNativeResponder?: ActiveCallback\n}>\n\nconst PanResponder = {\n  _initializeGestureState(gestureState: PanResponderGestureState): void {\n    gestureState.moveX = 0\n    gestureState.moveY = 0\n    gestureState.x0 = 0\n    gestureState.y0 = 0\n    gestureState.dx = 0\n    gestureState.dy = 0\n    gestureState.vx = 0\n    gestureState.vy = 0\n    gestureState.numberActiveTouches = 0\n    // All `gestureState` accounts for timeStamps up until:\n    gestureState._accountsForMovesUpTo = 0\n  },\n\n  /**\n   * This is nuanced and is necessary. It is incorrect to continuously take all\n   * active *and* recently moved touches, find the centroid, and track how that\n   * result changes over time. Instead, we must take all recently moved\n   * touches, and calculate how the centroid has changed just for those\n   * recently moved touches, and append that change to an accumulator. This is\n   * to (at least) handle the case where the user is moving three fingers, and\n   * then one of the fingers stops but the other two continue.\n   *\n   * This is very different than taking all of the recently moved touches and\n   * storing their centroid as `dx/dy`. For correctness, we must *accumulate\n   * changes* in the centroid of recently moved touches.\n   *\n   * There is also some nuance with how we handle multiple moved touches in a\n   * single event. With the way `ReactNativeEventEmitter` dispatches touches as\n   * individual events, multiple touches generate two 'move' events, each of\n   * them triggering `onResponderMove`. But with the way `PanResponder` works,\n   * all of the gesture inference is performed on the first dispatch, since it\n   * looks at all of the touches (even the ones for which there hasn't been a\n   * native dispatch yet). Therefore, `PanResponder` does not call\n   * `onResponderMove` passed the first dispatch. This diverges from the\n   * typical responder callback pattern (without using `PanResponder`), but\n   * avoids more dispatches than necessary.\n   */\n  _updateGestureStateOnMove(\n    gestureState: PanResponderGestureState,\n    touchHistory: GestureResponderEvent[\"touchHistory\"],\n  ): void {\n    gestureState.numberActiveTouches = touchHistory.numberActiveTouches\n    gestureState.moveX = currentCentroidXOfTouchesChangedAfter(\n      touchHistory,\n      gestureState._accountsForMovesUpTo,\n    )\n    gestureState.moveY = currentCentroidYOfTouchesChangedAfter(\n      touchHistory,\n      gestureState._accountsForMovesUpTo,\n    )\n    const movedAfter = gestureState._accountsForMovesUpTo\n    const prevX = previousCentroidXOfTouchesChangedAfter(\n      touchHistory,\n      movedAfter,\n    )\n    const x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter)\n    const prevY = previousCentroidYOfTouchesChangedAfter(\n      touchHistory,\n      movedAfter,\n    )\n    const y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter)\n    const nextDX = gestureState.dx + (x - prevX)\n    const nextDY = gestureState.dy + (y - prevY)\n\n    // TODO: This must be filtered intelligently.\n    const dt =\n      touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo\n    gestureState.vx = (nextDX - gestureState.dx) / dt\n    gestureState.vy = (nextDY - gestureState.dy) / dt\n\n    gestureState.dx = nextDX\n    gestureState.dy = nextDY\n    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp\n  },\n\n  /**\n   * @param config Enhanced versions of all of the responder callbacks that\n   * provide not only the typical `ResponderSyntheticEvent`, but also the\n   * `PanResponder` gesture state. Simply replace the word `Responder` with\n   * `PanResponder` in each of the typical `onResponder*` callbacks.\n   */\n  create(config: PanResponderCallbacks): {\n    getInteractionHandle: () => number | null\n    panHandlers: GestureResponderHandlerMethods\n  } {\n    const gestureState: PanResponderGestureState = {\n      // Useful for debugging\n      stateID: Math.random(),\n      moveX: 0,\n      moveY: 0,\n      x0: 0,\n      y0: 0,\n      dx: 0,\n      dy: 0,\n      vx: 0,\n      vy: 0,\n      numberActiveTouches: 0,\n      _accountsForMovesUpTo: 0,\n    }\n    const panHandlers: GestureResponderHandlerMethods = {\n      onStartShouldSetResponder(event: GestureResponderEvent): boolean {\n        return config.onStartShouldSetPanResponder == null\n          ? false\n          : config.onStartShouldSetPanResponder(event, gestureState)\n      },\n      onMoveShouldSetResponder(event: GestureResponderEvent): boolean {\n        return config.onMoveShouldSetPanResponder == null\n          ? false\n          : config.onMoveShouldSetPanResponder(event, gestureState)\n      },\n      onStartShouldSetResponderCapture(event: GestureResponderEvent): boolean {\n        // TODO: Actually, we should reinitialize the state any time\n        // touches.length increases from 0 active to > 0 active.\n        if (event.nativeEvent.touches.length === 1) {\n          PanResponder._initializeGestureState(gestureState)\n        }\n        gestureState.numberActiveTouches =\n          event.touchHistory.numberActiveTouches\n        return config.onStartShouldSetPanResponderCapture != null\n          ? config.onStartShouldSetPanResponderCapture(event, gestureState)\n          : false\n      },\n\n      onMoveShouldSetResponderCapture(event: GestureResponderEvent): boolean {\n        const touchHistory = event.touchHistory\n        // Responder system incorrectly dispatches should* to current responder\n        // Filter out any touch moves past the first one - we would have\n        // already processed multi-touch geometry during the first event.\n        if (\n          gestureState._accountsForMovesUpTo ===\n          touchHistory.mostRecentTimeStamp\n        ) {\n          return false\n        }\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory)\n        return config.onMoveShouldSetPanResponderCapture\n          ? config.onMoveShouldSetPanResponderCapture(event, gestureState)\n          : false\n      },\n\n      onResponderGrant(event: GestureResponderEvent): boolean {\n        gestureState.x0 = currentCentroidX(event.touchHistory)\n        gestureState.y0 = currentCentroidY(event.touchHistory)\n        gestureState.dx = 0\n        gestureState.dy = 0\n        if (config.onPanResponderGrant) {\n          config.onPanResponderGrant(event, gestureState)\n        }\n        // TODO: t7467124 investigate if this can be removed\n        return config.onShouldBlockNativeResponder == null\n          ? true\n          : config.onShouldBlockNativeResponder(event, gestureState)\n      },\n\n      onResponderReject(event: GestureResponderEvent): void {\n        config.onPanResponderReject?.call(undefined, event, gestureState)\n      },\n\n      onResponderRelease(event: GestureResponderEvent): void {\n        config.onPanResponderRelease?.call(undefined, event, gestureState)\n        PanResponder._initializeGestureState(gestureState)\n      },\n\n      onResponderStart(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches\n        if (config.onPanResponderStart) {\n          config.onPanResponderStart(event, gestureState)\n        }\n      },\n\n      onResponderMove(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory\n        // Guard against the dispatch of two touch moves when there are two\n        // simultaneously changed touches.\n        if (\n          gestureState._accountsForMovesUpTo ===\n          touchHistory.mostRecentTimeStamp\n        ) {\n          return\n        }\n        // Filter out any touch moves past the first one - we would have\n        // already processed multi-touch geometry during the first event.\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory)\n        if (config.onPanResponderMove) {\n          config.onPanResponderMove(event, gestureState)\n        }\n      },\n\n      onResponderEnd(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches\n        config.onPanResponderEnd?.call(undefined, event, gestureState)\n      },\n\n      onResponderTerminate(event: GestureResponderEvent): void {\n        config.onPanResponderTerminate?.call(undefined, event, gestureState)\n        PanResponder._initializeGestureState(gestureState)\n      },\n\n      onResponderTerminationRequest(event: GestureResponderEvent): boolean {\n        return config.onPanResponderTerminationRequest == null\n          ? true\n          : config.onPanResponderTerminationRequest(event, gestureState)\n      },\n    }\n    return {\n      panHandlers,\n      getInteractionHandle(): number | null {\n        // TODO: Deprecate and delete this method.\n        return null\n      },\n    }\n  },\n}\n\nexport type PanResponderInstance = ReturnType<(typeof PanResponder)[\"create\"]>\n\nexport default PanResponder\n"]}

package/dist/vendor/react-native/touch-history-math.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { TouchHistory } from "../../responder/types";
+declare const TouchHistoryMath: {
+    centroidDimension: (touchHistory: TouchHistory, touchesChangedAfter: number, isXAxis: boolean, ofCurrent: boolean) => number;
+    currentCentroidXOfTouchesChangedAfter(touchHistory: TouchHistory, touchesChangedAfter: number): number;
+    currentCentroidYOfTouchesChangedAfter(touchHistory: TouchHistory, touchesChangedAfter: number): number;
+    previousCentroidXOfTouchesChangedAfter(touchHistory: TouchHistory, touchesChangedAfter: number): number;
+    previousCentroidYOfTouchesChangedAfter(touchHistory: TouchHistory, touchesChangedAfter: number): number;
+    currentCentroidX(touchHistory: TouchHistory): number;
+    currentCentroidY(touchHistory: TouchHistory): number;
+    noCentroid: number;
+};
+export default TouchHistoryMath;