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

package/dist/reanimated-compat/layout-animation-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-animation-view.js","sourceRoot":"","sources":["../../src/reanimated-compat/layout-animation-view.tsx"],"names":[],"mappings":"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","sourcesContent":["// `entering`, `exiting` and `layout` on an animated component.\n//\n// The three props are added by WRAPPING, not by changing the platform's\n// `Animated.View`: the wrapper renders the component it was given, adds no\n// widget to the tree, and reaches the real one through the handle that\n// component already exposes — the same seam `createAnimatedComponent` uses.\n// That is what lets `Animated.Text` and anything through\n// `createAnimatedComponent` take a layout animation on exactly the same\n// terms as `Animated.View`.\n//\n// WHY THE WRAPPER IS WHERE `exiting` LIVES, and this is the whole reason it\n// exists as a component rather than a hook inside the platform: React runs a\n// deleted subtree's layout-effect cleanups from the OUTSIDE IN, and unparents\n// its topmost widget last. A cleanup registered here — one component above\n// the one that owns the widget — therefore runs at the only moment when the\n// widget is still parented, its Yoga node still alive and its layout manager\n// still attached. It hands all three to the platform's retention primitive\n// (src/components/widget-retention.ts), which puts the widget back after the\n// reconciler takes it out and holds everything else until the fade ends or\n// the fallback timer fires.\n//\n// The other two need nothing new. `entering` is \"write the initial values on\n// mount and animate to the real ones\"; `layout` is \"the engine committed a\n// different rect for this child, so walk it there from where it was\" — both\n// are snapshot-measure-animate, which is exactly what upstream's own web\n// implementation does on its single thread.\nimport {\n  useInsertionEffect,\n  useLayoutEffect,\n  useRef,\n  useState,\n  type ComponentProps,\n  type ComponentType,\n  type ElementType,\n  type ReactNode,\n  type Ref,\n} from \"react\"\nimport { Dimensions } from \"../apis/index\"\nimport { Animated as PlatformAnimated } from \"../components/animated\"\nimport { glibScheduler } from \"../components/frame-scheduler\"\nimport { useHostNode } from \"../components/host-node\"\nimport { widgetForHandle } from \"../components/measure\"\nimport {\n  getStoredLayoutOffset,\n  getStoredRect,\n  observeStoredRect,\n  type StoredRect,\n} from \"../components/rect-store\"\nimport {\n  retainWidget,\n  type WidgetRetention,\n} from \"../components/widget-retention\"\nimport { computePointInWindow, type Gtk } from \"../gtkx/bridge/index\"\nimport type { AnimationEngine } from \"./animation\"\nimport type {\n  LayoutAnimationBuilderLike,\n  LayoutAnimationValues,\n} from \"./layout-animation\"\nimport { useLayoutAnimationSkip } from \"./layout-animation-config\"\nimport {\n  runLayoutAnimation,\n  type RunningLayoutAnimation,\n} from \"./layout-animation-runtime\"\n\n/**\n * How much longer than the animation itself a widget may be retained before\n * the fallback drops it. The timer exists for the case where the animation\n * never reports an end at all, so the margin only has to cover the ordinary\n * jitter of a frame source — not a whole animation.\n */\nconst RETENTION_MARGIN_MS = 500\n\n/** What `entering`, `exiting` and `layout` accept: a builder, or its class. */\nexport type LayoutAnimationProps = {\n  /** Runs once, when the component mounts. */\n  entering?: LayoutAnimationBuilderLike | false | null\n  /**\n   * Runs when the component unmounts, on a widget the platform keeps on\n   * screen for the duration. Ignored when the component's own container is\n   * unmounting in the same commit — there would be nothing left to animate\n   * inside.\n   */\n  exiting?: LayoutAnimationBuilderLike | false | null\n  /** Runs whenever the layout engine commits a new position for this child. */\n  layout?: LayoutAnimationBuilderLike | false | null\n}\n\nconst ZERO_RECT: StoredRect = { x: 0, y: 0, width: 0, height: 0 }\n\n// The platform's own Animated api and the frame scheduler behind it: the same\n// pair every other animation in this surface runs on, so a layout animation\n// adds no second clock.\nconst ENGINE: AnimationEngine = {\n  api: PlatformAnimated,\n  scheduler: glibScheduler,\n}\n\nconst retainForExit = (\n  widget: Gtk.Widget,\n  parentWidget: Gtk.Widget,\n  builder: LayoutAnimationBuilderLike,\n  stop: () => void,\n): WidgetRetention | null =>\n  retainWidget(widget, parentWidget, {\n    // The fallback covers a frame source that never delivers an end, so it\n    // only has to outlast the animation the builder describes.\n    fallbackMs: builder.getMaxDuration() + RETENTION_MARGIN_MS,\n    onRelease: stop,\n  })\n\nconst warnedWithoutWidget = new Set<string>()\n\nconst warnNoWidget = (name: string): void => {\n  if (warnedWithoutWidget.has(name)) {\n    return\n  }\n  warnedWithoutWidget.add(name)\n  const isProduction =\n    typeof process !== \"undefined\" && process.env.NODE_ENV === \"production\"\n  if (!isProduction) {\n    console.warn(\n      `react-native-reanimated: ${name} was given an \\`entering\\`, \\`exiting\\` or \\`layout\\` animation, but ` +\n        \"the component exposed no ref carrying a widget, so there is nothing to animate. Put the animation on \" +\n        \"an `Animated.View`, or give the component a `ref` built with the platform's own measure handle. \" +\n        \"See docs/api.md.\",\n    )\n  }\n}\n\n/** @internal Test seam: the warning is once per component per session. */\nexport const resetLayoutAnimationComponentWarnings = (): void => {\n  warnedWithoutWidget.clear()\n}\n\nconst valuesFor = (\n  widget: Gtk.Widget,\n  current: StoredRect,\n  target: StoredRect,\n): LayoutAnimationValues => {\n  const window = Dimensions.get(\"window\")\n  // One FFI call per animation START (never per frame), so a builder reading\n  // the global origin gets a real answer rather than a parent-relative one\n  // wearing its name.\n  const page = computePointInWindow(widget, 0, 0)\n  const dx = page ? page.x - target.x : 0\n  const dy = page ? page.y - target.y : 0\n  return {\n    targetOriginX: target.x,\n    targetOriginY: target.y,\n    targetWidth: target.width,\n    targetHeight: target.height,\n    targetGlobalOriginX: target.x + dx,\n    targetGlobalOriginY: target.y + dy,\n    currentOriginX: current.x,\n    currentOriginY: current.y,\n    currentWidth: current.width,\n    currentHeight: current.height,\n    currentGlobalOriginX: current.x + dx,\n    currentGlobalOriginY: current.y + dy,\n    windowWidth: window.width,\n    windowHeight: window.height,\n  }\n}\n\nconst displayNameOf = (component: unknown): string => {\n  if (typeof component === \"string\") {\n    return component\n  }\n  const named = component as { displayName?: string; name?: string }\n  return named?.displayName ?? named?.name ?? \"Component\"\n}\n\n/** The props a layout-animated wrapper adds on top of the component's own. */\nexport type LayoutAnimatedComponent<C extends ElementType> = (\n  props: ComponentProps<C> & LayoutAnimationProps,\n) => ReactNode\n\n/**\n * Adds `entering`, `exiting` and `layout` to an animated component.\n *\n * The rendered output is byte-for-byte what the wrapped component produces —\n * the wrapper is a function component with no host element of its own.\n */\nexport const withLayoutAnimations = <C extends ElementType>(\n  component: C,\n): LayoutAnimatedComponent<C> => {\n  const name = displayNameOf(component)\n\n  const LayoutAnimated = ({\n    entering,\n    exiting,\n    layout,\n    ref,\n    ...rest\n  }: LayoutAnimationProps & {\n    ref?: Ref<unknown>\n    [key: string]: unknown\n  }) => {\n    const host = useHostNode()\n    const handleRef = useRef<unknown>(null)\n    // Null unless a `<LayoutAnimationConfig>` is above. Captured once and read\n    // from inside the effects below: the object identity is stable for the\n    // life of that wrapper, and both of its flags are only meaningful at the\n    // moment the effect (or its cleanup) actually runs.\n    const skip = useLayoutAnimationSkip()\n\n    // Read by an unmount cleanup and by a rect observer, both of which\n    // outlive the render that produced them. Refreshed in an insertion effect\n    // — the project's standard escape from writing a ref during render, and\n    // early enough that a layout effect in the same commit sees it.\n    const exitingRef = useRef<LayoutAnimationBuilderLike | false | null>(\n      exiting ?? null,\n    )\n    const layoutRef = useRef<LayoutAnimationBuilderLike | false | null>(\n      layout ?? null,\n    )\n    const forwardedRef = useRef<Ref<unknown> | undefined>(ref)\n    useInsertionEffect(() => {\n      exitingRef.current = exiting ?? null\n      layoutRef.current = layout ?? null\n      forwardedRef.current = ref\n    })\n\n    // Stable identity: a fresh callback ref every render would detach and\n    // reattach the wrapped component's handle on every render.\n    const [assignHandle] = useState(() => (instance: unknown) => {\n      handleRef.current = instance\n      const target = forwardedRef.current\n      if (typeof target === \"function\") {\n        target(instance)\n      } else if (target) {\n        ;(target as { current: unknown }).current = instance\n      }\n      // No return value: React 19 reads one as a callback-ref cleanup.\n    })\n\n    const parentWidgetRef = host.widgetRef\n\n    // --- entering --------------------------------------------------------\n    // Never refreshed, unlike the two above: an entering animation runs once,\n    // on mount, so the builder that counts is the one this component was\n    // mounted with.\n    const enteringRef = useRef<LayoutAnimationBuilderLike | false | null>(\n      entering ?? null,\n    )\n    useLayoutEffect(() => {\n      const builder = enteringRef.current\n      if (!builder || skip?.entering.current) {\n        return\n      }\n      const widget = widgetForHandle(handleRef.current)\n      if (!widget) {\n        warnNoWidget(name)\n        return\n      }\n      const rect = getStoredRect(widget) ?? ZERO_RECT\n      const values = valuesFor(widget, rect, rect)\n      const running = runLayoutAnimation(\n        ENGINE,\n        { widget, parentWidget: parentWidgetRef.current },\n        builder.build()(values),\n        values,\n      )\n      return () => running.stop()\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [])\n\n    // --- layout ----------------------------------------------------------\n    // Keyed on whether there IS a layout animation, not on which one: a rect\n    // observer is what turns on the rect store's notify path, and a view that\n    // never asked for a layout transition must not pay for it.\n    const hasLayout = Boolean(layout)\n    useLayoutEffect(() => {\n      if (!hasLayout) {\n        return\n      }\n      const widget = widgetForHandle(handleRef.current)\n      if (!widget) {\n        warnNoWidget(name)\n        return\n      }\n      let running: RunningLayoutAnimation | null = null\n      const unobserve = observeStoredRect(widget, (next, previous) => {\n        const builder = layoutRef.current\n        // Nothing to walk from on the first commit, and a pure resize has no\n        // position to animate — the size lands immediately either way.\n        if (!builder || previous === undefined) {\n          return\n        }\n        if (previous.x === next.x && previous.y === next.y) {\n          return\n        }\n        // Where the child is being DRAWN right now, which is the rect it had\n        // plus whatever a transition still in flight has added to it.\n        const offset = getStoredLayoutOffset(widget)\n        const drawn: StoredRect = {\n          x: previous.x + offset.dx,\n          y: previous.y + offset.dy,\n          width: previous.width,\n          height: previous.height,\n        }\n        running?.stop()\n        const values = valuesFor(widget, drawn, next)\n        running = runLayoutAnimation(\n          ENGINE,\n          { widget, parentWidget: parentWidgetRef.current },\n          builder.build()(values),\n          values,\n          () => {\n            running = null\n          },\n        )\n      })\n      return () => {\n        unobserve()\n        running?.stop()\n      }\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [hasLayout])\n\n    // --- exiting ---------------------------------------------------------\n    // Declared last so its cleanup runs after the other two have stopped\n    // whatever they were driving: React tears a component's layout effects\n    // down in the order they were created.\n    useLayoutEffect(() => {\n      return () => {\n        const builder = exitingRef.current\n        // `skip.exiting` is set by a `<LayoutAnimationConfig skipExiting>`\n        // above us, whose own cleanup React already ran — deletions tear down\n        // outside in, which is the same ordering `exiting` itself relies on.\n        if (!builder || skip?.exiting.current) {\n          return\n        }\n        const widget = widgetForHandle(handleRef.current)\n        // Read HERE and not captured when the effect ran, which is the whole\n        // point: null means this component's own container is unmounting in\n        // the same commit (React detaches the container's ref before\n        // descending into it), and there is then no container left to hold\n        // the widget — an exit animation inside a disappearing parent is not\n        // one anybody sees.\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        const parentWidget = parentWidgetRef.current\n        if (!widget || !parentWidget) {\n          return\n        }\n        const rect = getStoredRect(widget) ?? ZERO_RECT\n        const values = valuesFor(widget, rect, rect)\n        let running: RunningLayoutAnimation | null = null\n        const retention = retainForExit(widget, parentWidget, builder, () =>\n          running?.stop(),\n        )\n        if (retention === null) {\n          return\n        }\n        running = runLayoutAnimation(\n          ENGINE,\n          { widget, parentWidget },\n          builder.build()(values),\n          values,\n          () => retention.release(),\n        )\n      }\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [])\n\n    const targetProps: Record<string, unknown> = { ...rest }\n    if (entering || exiting || layout || ref) {\n      targetProps.ref = assignHandle\n    }\n\n    const Target = component as ComponentType<Record<string, unknown>>\n    return <Target {...targetProps} />\n  }\n  LayoutAnimated.displayName = `LayoutAnimated(${name})`\n\n  return LayoutAnimated as unknown as LayoutAnimatedComponent<C>\n}\n"]}

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

@@ -0,0 +1,171 @@
+import { type WithSpringConfig } from "./animation";
+import type { EasingFunction, EasingFunctionFactory } from "./easing";
+/**
+ * What a builder is handed when it is asked to produce a config. Upstream
+ * fills the `target*` half for an entering animation and the `current*` half
+ * for an exiting one; both halves are always populated here, from the rects
+ * the layout engine committed, because a superset costs nothing and a builder
+ * that reads the wrong half would otherwise get `undefined`.
+ */
+export type LayoutAnimationValues = {
+    targetOriginX: number;
+    targetOriginY: number;
+    targetWidth: number;
+    targetHeight: number;
+    targetGlobalOriginX: number;
+    targetGlobalOriginY: number;
+    currentOriginX: number;
+    currentOriginY: number;
+    currentWidth: number;
+    currentHeight: number;
+    currentGlobalOriginX: number;
+    currentGlobalOriginY: number;
+    windowWidth: number;
+    windowHeight: number;
+};
+/** Called when a layout animation settles or is cut short, as upstream. */
+export type LayoutAnimationCallback = (finished: boolean) => void;
+/** Upstream's built config: where to start, what to run, who to tell. */
+export type BuiltLayoutAnimation = {
+    initialValues: Record<string, unknown>;
+    animations: Record<string, unknown>;
+    callback?: LayoutAnimationCallback;
+};
+/** Anything an `entering`, `exiting` or `layout` prop accepts. */
+export type LayoutAnimationBuilderLike = {
+    build(): (values: LayoutAnimationValues) => BuiltLayoutAnimation;
+    /** The longest this animation can run, which is what arms a retention. */
+    getMaxDuration(): number;
+};
+type TimingLike = (toValue: number) => number;
+export declare class AnimationBuilder {
+    durationV: number | undefined;
+    delayV: number | undefined;
+    easingV: EasingFunction | EasingFunctionFactory | undefined;
+    randomizeDelay: boolean;
+    type: "timing" | "spring";
+    springConfigV: WithSpringConfig;
+    initialValuesV: Record<string, unknown>;
+    callbackV: LayoutAnimationCallback | undefined;
+    rotateV: string | number | undefined;
+    static createInstance<T extends typeof AnimationBuilder>(this: T): InstanceType<T>;
+    duration(durationMs: number): this;
+    delay(delayMs: number): this;
+    easing(easingFunction: EasingFunction | EasingFunctionFactory): this;
+    /** Upstream's "spread the delay over a window" helper, ported as-is. */
+    randomDelay(): this;
+    springify(durationMs?: number): this;
+    /**
+     * The angle `ZoomInRotate` / `ZoomOutRotate` spin through.
+     *
+     * Upstream takes a bare number of RADIANS in a string (its default is
+     * `'0.3'`, interpolated into `` `${rotate}rad` ``), and a united value like
+     * `'90deg'` reaches its template as `'90degrad'`. A bare number or numeric
+     * string is read as radians here, exactly as upstream; a value that carries
+     * its own `deg`/`rad` unit is parsed instead of being concatenated into
+     * nonsense.
+     */
+    rotate(angle: string | number): this;
+    damping(value: number): this;
+    dampingRatio(value: number): this;
+    mass(value: number): this;
+    stiffness(value: number): this;
+    overshootClamping(value: number): this;
+    /**
+     * Accepted and ignored, because this platform's spring solver derives its
+     * rest condition from the same energy budget upstream stops on rather than
+     * from absolute thresholds — the difference is well under a pixel and is
+     * already in docs/api.md's differences table.
+     */
+    restDisplacementThreshold(): this;
+    restSpeedThreshold(): this;
+    /**
+     * Accepted and ignored: no reduce-motion source is wired on this platform
+     * yet, so every value behaves as `ReduceMotion.Never` — the same answer
+     * `useReducedMotion()` gives.
+     */
+    reduceMotion(): this;
+    withInitialValues(values: Record<string, unknown>): this;
+    withCallback(callback: LayoutAnimationCallback): this;
+    getDelay(): number;
+    /** The nominal length, as upstream reports it. */
+    getDuration(): number;
+    /**
+     * The UPPER BOUND on delay plus duration, which is what a retention arms
+     * its fallback timer from. Not `getDelay() + getDuration()`: `randomDelay`
+     * draws a fresh number on every call — deliberately, so a list staggers —
+     * and a fallback armed from one draw could cut short an animation built
+     * from another.
+     */
+    getMaxDuration(): number;
+    /**
+     * `.rotate()` resolved to degrees, or `fallbackDegrees` when it was never
+     * called. See {@link AnimationBuilder.rotate} for the unit rules.
+     */
+    protected getRotationDegrees(fallbackDegrees: number): number;
+    protected animation(): TimingLike;
+    protected delayed(delayMs: number, animation: number): number;
+    build(): (values: LayoutAnimationValues) => BuiltLayoutAnimation;
+    static duration<T extends typeof AnimationBuilder>(this: T, durationMs: number): InstanceType<T>;
+    static delay<T extends typeof AnimationBuilder>(this: T, delayMs: number): InstanceType<T>;
+    static easing<T extends typeof AnimationBuilder>(this: T, easingFunction: EasingFunction | EasingFunctionFactory): InstanceType<T>;
+    static randomDelay<T extends typeof AnimationBuilder>(this: T): InstanceType<T>;
+    static springify<T extends typeof AnimationBuilder>(this: T, durationMs?: number): InstanceType<T>;
+    static rotate<T extends typeof AnimationBuilder>(this: T, angle: string | number): InstanceType<T>;
+    static damping<T extends typeof AnimationBuilder>(this: T, value: number): InstanceType<T>;
+    static dampingRatio<T extends typeof AnimationBuilder>(this: T, value: number): InstanceType<T>;
+    static mass<T extends typeof AnimationBuilder>(this: T, value: number): InstanceType<T>;
+    static stiffness<T extends typeof AnimationBuilder>(this: T, value: number): InstanceType<T>;
+    static overshootClamping<T extends typeof AnimationBuilder>(this: T, value: number): InstanceType<T>;
+    static restDisplacementThreshold<T extends typeof AnimationBuilder>(this: T): InstanceType<T>;
+    static restSpeedThreshold<T extends typeof AnimationBuilder>(this: T): InstanceType<T>;
+    static reduceMotion<T extends typeof AnimationBuilder>(this: T): InstanceType<T>;
+    static withInitialValues<T extends typeof AnimationBuilder>(this: T, values: Record<string, unknown>): InstanceType<T>;
+    static withCallback<T extends typeof AnimationBuilder>(this: T, callback: LayoutAnimationCallback): InstanceType<T>;
+    static build<T extends typeof AnimationBuilder>(this: T): (values: LayoutAnimationValues) => BuiltLayoutAnimation;
+    static getDuration<T extends typeof AnimationBuilder>(this: T): number;
+    static getDelay<T extends typeof AnimationBuilder>(this: T): number;
+    static getMaxDuration<T extends typeof AnimationBuilder>(this: T): number;
+}
+/** Fades a view in as it mounts. */
+export declare class FadeIn extends AnimationBuilder {
+    build(): (values: LayoutAnimationValues) => BuiltLayoutAnimation;
+}
+/** Fades a view out as it unmounts — the animation that needs retention. */
+export declare class FadeOut extends AnimationBuilder {
+    build(): (values: LayoutAnimationValues) => BuiltLayoutAnimation;
+}
+/**
+ * Walks a view from where it was to where the layout engine just put it.
+ *
+ * Upstream animates `originX`/`originY`/`width`/`height`; the same four are
+ * produced here, and the runtime honours the origins (as a translation, which
+ * is paint-only) and applies the size immediately. See docs/api.md.
+ */
+export declare class LinearTransition extends AnimationBuilder {
+    build(): (values: LayoutAnimationValues) => BuiltLayoutAnimation;
+}
+type KeyframeStyle = Record<string, unknown> & {
+    easing?: EasingFunction | EasingFunctionFactory;
+};
+export type KeyframeDefinitions = Record<string | number, KeyframeStyle>;
+/**
+ * A hand-written keyframe track — the one builder that is a class you
+ * instantiate (`new Keyframe({...})`) rather than a preset you configure.
+ *
+ * Each keyframe is a percentage (or `from`/`to`) mapped to a style. Every
+ * property is turned into a `withSequence` of `withTiming` steps whose
+ * durations are the gaps between the offsets it appears at, which is exactly
+ * how upstream compiles them; a per-keyframe `easing` applies to the step
+ * that ENDS there, as in CSS.
+ */
+export declare class Keyframe extends AnimationBuilder {
+    private readonly definitions;
+    constructor(definitions: KeyframeDefinitions);
+    /** Keyframes and springs are different clocks; upstream refuses this too. */
+    springify(): this;
+    private readonly unhandled;
+    private tracks;
+    build(): (values: LayoutAnimationValues) => BuiltLayoutAnimation;
+}
+export {};