react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/reanimated-compat/animated-ref.js

@@ -0,0 +1,57 @@
+// `useAnimatedRef` and `measure`.
+//
+// Upstream's `measure()` is synchronous but may only be called INSIDE a
+// worklet, because only the UI thread holds the current shadow tree. Here it
+// is synchronous for a simpler reason — there is one thread, and the
+// platform's own `measure()` already invokes its callback before returning.
+// So it works from anywhere, which is strictly more permissive than upstream
+// and needs no worklet.
+//
+// It still returns null before the first committed layout. That is not a
+// shortcut: it is RN's contract, which the platform implements faithfully —
+// a view whose rect has not been committed, or that is not in a window, has
+// nothing true to report, and RN answers by not calling back rather than by
+// inventing a number.
+import { useState } from "react";
+// useState, not a lazily-filled useRef: the ref is READ during render (it is
+// the hook's return value), and reading a ref during render is exactly what
+// react-hooks/refs exists to stop. Upstream's own `useSharedValue` reaches
+// for useState for the same reason.
+export const useAnimatedRef = () => {
+    const [animatedRef] = useState(() => {
+        const handle = ((instance) => {
+            if (instance === undefined) {
+                return handle.current;
+            }
+            // Cleared on unmount (React passes null), unlike upstream, which keeps
+            // the last instance forever. Measuring a widget that has been freed is
+            // not a measurement worth having.
+            handle.current = instance;
+            return undefined;
+        });
+        handle.current = null;
+        return handle;
+    });
+    return animatedRef;
+};
+/**
+ * Reads a view's geometry: its own size, its position in its parent and its
+ * position in the window. Returns null when the view is not mounted or its
+ * layout has not been committed yet.
+ */
+export const measure = (animatedRef) => {
+    if (!animatedRef) {
+        return null;
+    }
+    const instance = typeof animatedRef === "function" ? animatedRef() : animatedRef.current;
+    const handle = instance;
+    if (!handle || typeof handle.measure !== "function") {
+        return null;
+    }
+    let measured = null;
+    handle.measure((x, y, width, height, pageX, pageY) => {
+        measured = { x, y, width, height, pageX, pageY };
+    });
+    return measured;
+};
+//# sourceMappingURL=animated-ref.js.map

package/dist/reanimated-compat/animated-ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animated-ref.js","sourceRoot":"","sources":["../../src/reanimated-compat/animated-ref.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,EAAE;AACF,wEAAwE;AACxE,6EAA6E;AAC7E,qEAAqE;AACrE,4EAA4E;AAC5E,6EAA6E;AAC7E,wBAAwB;AACxB,EAAE;AACF,yEAAyE;AACzE,4EAA4E;AAC5E,4EAA4E;AAC5E,4EAA4E;AAC5E,sBAAsB;AACtB,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AA2BhC,6EAA6E;AAC7E,4EAA4E;AAC5E,2EAA2E;AAC3E,oCAAoC;AACpC,MAAM,CAAC,MAAM,cAAc,GAAG,GAAsC,EAAE;IACpE,MAAM,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAiB,GAAG,EAAE;QAClD,MAAM,MAAM,GAAG,CAAC,CAAC,QAAmB,EAAE,EAAE;YACtC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,OAAO,MAAM,CAAC,OAAO,CAAA;YACvB,CAAC;YACD,uEAAuE;YACvE,uEAAuE;YACvE,kCAAkC;YAClC,MAAM,CAAC,OAAO,GAAG,QAAQ,CAAA;YACzB,OAAO,SAAS,CAAA;QAClB,CAAC,CAAmB,CAAA;QACpB,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;QACrB,OAAO,MAAM,CAAA;IACf,CAAC,CAAC,CAAA;IACF,OAAO,WAAW,CAAA;AACpB,CAAC,CAAA;AAID;;;;GAIG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,WAAsE,EAC3C,EAAE;IAC7B,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,IAAI,CAAA;IACb,CAAC;IACD,MAAM,QAAQ,GACZ,OAAO,WAAW,KAAK,UAAU,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAA;IACzE,MAAM,MAAM,GAAG,QAA6B,CAAA;IAC5C,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACpD,OAAO,IAAI,CAAA;IACb,CAAC;IACD,IAAI,QAAQ,GAA8B,IAAI,CAAA;IAC9C,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QACnD,QAAQ,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;IAClD,CAAC,CAAC,CAAA;IACF,OAAO,QAAQ,CAAA;AACjB,CAAC,CAAA","sourcesContent":["// `useAnimatedRef` and `measure`.\n//\n// Upstream's `measure()` is synchronous but may only be called INSIDE a\n// worklet, because only the UI thread holds the current shadow tree. Here it\n// is synchronous for a simpler reason — there is one thread, and the\n// platform's own `measure()` already invokes its callback before returning.\n// So it works from anywhere, which is strictly more permissive than upstream\n// and needs no worklet.\n//\n// It still returns null before the first committed layout. That is not a\n// shortcut: it is RN's contract, which the platform implements faithfully —\n// a view whose rect has not been committed, or that is not in a window, has\n// nothing true to report, and RN answers by not calling back rather than by\n// inventing a number.\nimport { useState } from \"react\"\nimport type { MeasureHandle } from \"../components/measure\"\n\n/**\n * A ref that is also callable, as upstream's is: React sets it through the\n * call, and `measure()` reads it back through a call with no argument.\n *\n * The no-argument read is this platform's own shape rather than upstream's.\n * Upstream's callback ref RETURNS the instance, which React 19 reads as a\n * callback-ref cleanup value and complains about; discriminating on the\n * argument keeps both callers working and keeps React quiet.\n */\nexport type AnimatedRef<T> = {\n  (): T | null\n  (instance: T | null): void\n  current: T | null\n}\n\nexport type MeasuredDimensions = {\n  x: number\n  y: number\n  width: number\n  height: number\n  pageX: number\n  pageY: number\n}\n\n// useState, not a lazily-filled useRef: the ref is READ during render (it is\n// the hook's return value), and reading a ref during render is exactly what\n// react-hooks/refs exists to stop. Upstream's own `useSharedValue` reaches\n// for useState for the same reason.\nexport const useAnimatedRef = <T = MeasureHandle>(): AnimatedRef<T> => {\n  const [animatedRef] = useState<AnimatedRef<T>>(() => {\n    const handle = ((instance?: T | null) => {\n      if (instance === undefined) {\n        return handle.current\n      }\n      // Cleared on unmount (React passes null), unlike upstream, which keeps\n      // the last instance forever. Measuring a widget that has been freed is\n      // not a measurement worth having.\n      handle.current = instance\n      return undefined\n    }) as AnimatedRef<T>\n    handle.current = null\n    return handle\n  })\n  return animatedRef\n}\n\ntype Measurable = Partial<MeasureHandle>\n\n/**\n * Reads a view's geometry: its own size, its position in its parent and its\n * position in the window. Returns null when the view is not mounted or its\n * layout has not been committed yet.\n */\nexport const measure = <T>(\n  animatedRef: AnimatedRef<T> | { current: T | null } | null | undefined,\n): MeasuredDimensions | null => {\n  if (!animatedRef) {\n    return null\n  }\n  const instance =\n    typeof animatedRef === \"function\" ? animatedRef() : animatedRef.current\n  const handle = instance as Measurable | null\n  if (!handle || typeof handle.measure !== \"function\") {\n    return null\n  }\n  let measured: MeasuredDimensions | null = null\n  handle.measure((x, y, width, height, pageX, pageY) => {\n    measured = { x, y, width, height, pageX, pageY }\n  })\n  return measured\n}\n"]}

package/dist/reanimated-compat/animation.d.ts

@@ -0,0 +1,177 @@
+import { type AnimatedApi, type AnimatedValue, type CompositeAnimation, type FrameScheduler } from "../animated/index";
+import { resolveDecayConfig, type WithDecayConfig } from "./decay";
+import { type EasingFunction } from "./easing";
+/** Called when an animation settles or is cancelled, as upstream. */
+export type AnimationCallback = (finished?: boolean, current?: number) => void;
+export type WithTimingConfig = {
+    duration?: number;
+    easing?: EasingFunction | {
+        factory: () => EasingFunction;
+    };
+};
+/**
+ * Upstream's config is a mutually exclusive union: either the physical
+ * parameterisation (`stiffness`/`damping`) or the perceptual one
+ * (`duration`/`dampingRatio`). Both are accepted here and normalised into the
+ * physical one, which is what the platform's spring solver takes.
+ */
+export type WithSpringConfig = {
+    mass?: number;
+    stiffness?: number;
+    damping?: number;
+    duration?: number;
+    dampingRatio?: number;
+    clamp?: {
+        min?: number;
+        max?: number;
+    };
+    velocity?: number;
+    overshootClamping?: boolean;
+    energyThreshold?: number;
+};
+type TimingSpec = {
+    kind: "timing";
+    toValue: number;
+    config: WithTimingConfig;
+    callback?: AnimationCallback;
+};
+type SpringSpec = {
+    kind: "spring";
+    toValue: number;
+    config: WithSpringConfig;
+    callback?: AnimationCallback;
+};
+type DelaySpec = {
+    kind: "delay";
+    delayMs: number;
+    animation: AnimationSpec;
+};
+type SequenceSpec = {
+    kind: "sequence";
+    animations: AnimationSpec[];
+};
+type RepeatSpec = {
+    kind: "repeat";
+    animation: AnimationSpec;
+    numberOfReps: number;
+    reverse: boolean;
+    callback?: AnimationCallback;
+};
+type DecaySpec = {
+    kind: "decay";
+    config: ReturnType<typeof resolveDecayConfig>;
+    callback?: AnimationCallback;
+};
+type ClampSpec = {
+    kind: "clamp";
+    min?: number;
+    max?: number;
+    animation: AnimationSpec;
+};
+export type AnimationSpec = TimingSpec | SpringSpec | DelaySpec | SequenceSpec | RepeatSpec | DecaySpec | ClampSpec;
+export declare const isAnimationSpec: (value: unknown) => value is AnimationSpec;
+/**
+ * Runs an updater in "seed the value" mode, where every animation collapses
+ * to the value it would have finished at.
+ */
+export declare const initialUpdaterRun: <T>(updater: () => T) => T;
+/**
+ * Lets you animate a value over a duration with an easing curve. Assign the
+ * result to a shared value to start it.
+ */
+export declare const withTiming: (toValue: number, config?: WithTimingConfig, callback?: AnimationCallback) => number;
+/** Lets you animate a value with spring physics. */
+export declare const withSpring: (toValue: number, config?: WithSpringConfig, callback?: AnimationCallback) => number;
+/** Delays another animation by `delayMs`. */
+export declare const withDelay: (delayMs: number, animation: number) => number;
+/** Runs animations one after another on the same shared value. */
+export declare const withSequence: (...animations: number[]) => number;
+/**
+ * Repeats an animation. `numberOfReps <= 0` repeats forever; `reverse` plays
+ * every other repetition backwards.
+ */
+export declare const withRepeat: (animation: number, numberOfReps?: number, reverse?: boolean, callback?: AnimationCallback) => number;
+/**
+ * Coasts to a stop from an initial velocity — the release half of a fling.
+ * Unlike every other animation here it has no target: where it lands is the
+ * result of the velocity and the friction, which is exactly what makes it the
+ * one an inertial gesture needs.
+ *
+ * ```tsx
+ * onPanResponderRelease: (_, g) => {
+ *   x.value = withDecay({ velocity: g.vx * 1000, clamp: [0, width] })
+ * }
+ * ```
+ *
+ * `velocity` is in units per SECOND, as upstream — `PanResponder`'s
+ * `gestureState.vx` is per millisecond, so it wants the ×1000 above.
+ */
+export declare const withDecay: (config?: WithDecayConfig, callback?: AnimationCallback) => number;
+/**
+ * Confines another animation to a range: the inner animation runs its own
+ * un-truncated course and what reaches the value is clipped to `[min, max]`.
+ * That distinction is upstream's and it is observable — a spring clamped at
+ * 100 that would have overshot to 120 sits at 100 and then comes back down,
+ * rather than settling at 100 the moment it first arrives.
+ */
+export declare const withClamp: (config: {
+    min?: number;
+    max?: number;
+}, animation: number) => number;
+export type { WithDecayConfig } from "./decay";
+type PlatformSpringConfig = {
+    toValue: number;
+    mass: number;
+    stiffness: number;
+    damping: number;
+    initialVelocity: number;
+    overshootClamping: boolean;
+    restDisplacementThreshold: number;
+    restSpeedThreshold: number;
+};
+/**
+ * Turns a Reanimated spring config into the platform solver's config.
+ *
+ * The rest condition is the one place the two genuinely differ. Upstream
+ * stops when the oscillator's remaining energy falls to `energyThreshold` of
+ * its initial energy — a RELATIVE criterion; the platform's solver stops on
+ * absolute displacement and speed thresholds. Rather than accept RN's
+ * absolute defaults (which would end a 400px spring at a different point than
+ * a 4px one), the thresholds are derived per animation from the same energy
+ * budget, so the stopping point tracks upstream's to well under a pixel.
+ */
+export declare const toPlatformSpringConfig: (config: WithSpringConfig, toValue: number, from: number) => PlatformSpringConfig;
+/**
+ * The last value an animation aims at, used by `withRepeat`'s reverse and by
+ * `updater-animations.ts` to seed a key that is animating for the first time.
+ */
+export declare const targetOf: (spec: AnimationSpec) => number | null;
+/**
+ * What makes two descriptors the SAME animation, for a caller that gets a
+ * freshly built one on every evaluation and must decide whether to restart.
+ *
+ * The target and the shape, not object identity and not the whole config: a
+ * mapper re-runs whenever anything it read changed, so `withSpring(open.value
+ * ? 320 : 0)` produces a new object many times a second while asking for the
+ * same animation every time. Config fields that change WHERE the animation
+ * ends are in (a `duration`, a decay's `velocity`); ones that only change how
+ * it gets there are not, because re-aiming a running animation at the value it
+ * is already aimed at is a no-op that costs a restart.
+ */
+export declare const animationSignature: (spec: AnimationSpec) => string;
+/**
+ * What a descriptor needs to become a running animation: the platform's
+ * Animated api for the animations it already has, and the frame scheduler
+ * behind it for the one it does not (`withDecay` — see decay.ts). Both come
+ * from the same place, so there is still exactly one clock under this layer.
+ */
+export type AnimationEngine = {
+    api: AnimatedApi;
+    scheduler: FrameScheduler;
+};
+/**
+ * Turns a descriptor into a running animation on `driver`. Every leaf is one
+ * of the platform's own animations, so the whole tree runs off the single
+ * injected frame scheduler.
+ */
+export declare const buildAnimation: (engine: AnimationEngine, driver: AnimatedValue, spec: AnimationSpec) => CompositeAnimation;