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

package/dist/reanimated-compat/interpolation.js

@@ -0,0 +1,122 @@
+// `interpolate`, `Extrapolation` and `clamp` — pure functions over numbers,
+// portable from upstream as-is (nothing in them touches a runtime, a thread
+// or the DOM).
+//
+// Not `src/animated/interpolate.ts`: that one COMPILES an
+// InterpolationConfig into a node-to-node mapping for `Animated.Value`, takes
+// a single `extrapolate` for both edges and produces suffixed strings.
+// Reanimated's is a plain `number → number` call taken inside a mapper, with
+// independently configurable left and right extrapolation. Different shape,
+// different call site; the two do not fold into one.
+/** Behaviour for inputs outside `inputRange`. */
+export var Extrapolation;
+(function (Extrapolation) {
+    Extrapolation["IDENTITY"] = "identity";
+    Extrapolation["CLAMP"] = "clamp";
+    Extrapolation["EXTEND"] = "extend";
+})(Extrapolation || (Extrapolation = {}));
+const SUPPORTED = 'Supported values: "extend", "clamp", "identity", Extrapolation.CLAMP, ' +
+    "Extrapolation.EXTEND, Extrapolation.IDENTITY";
+const isExtrapolation = (value) => value === Extrapolation.EXTEND ||
+    value === Extrapolation.CLAMP ||
+    value === Extrapolation.IDENTITY;
+const resolveExtrapolation = (type) => {
+    const resolved = {
+        extrapolateLeft: Extrapolation.EXTEND,
+        extrapolateRight: Extrapolation.EXTEND,
+    };
+    if (!type) {
+        return resolved;
+    }
+    if (typeof type === "string") {
+        if (!isExtrapolation(type)) {
+            throw new Error(`react-native-reanimated: unsupported extrapolation "${type}" for interpolate(). ${SUPPORTED}`);
+        }
+        resolved.extrapolateLeft = type;
+        resolved.extrapolateRight = type;
+        return resolved;
+    }
+    const { extrapolateLeft, extrapolateRight } = type;
+    if ((extrapolateLeft && !isExtrapolation(extrapolateLeft)) ||
+        (extrapolateRight && !isExtrapolation(extrapolateRight))) {
+        throw new Error(`react-native-reanimated: unsupported extrapolation for interpolate(). ${SUPPORTED}`);
+    }
+    if (extrapolateLeft) {
+        resolved.extrapolateLeft = extrapolateLeft;
+    }
+    if (extrapolateRight) {
+        resolved.extrapolateRight = extrapolateRight;
+    }
+    return resolved;
+};
+const extrapolated = (type, direction, value, leftEdgeOutput, rightEdgeOutput, input) => {
+    switch (type) {
+        case Extrapolation.IDENTITY:
+            return input;
+        case Extrapolation.CLAMP:
+            return direction * value < direction * leftEdgeOutput
+                ? leftEdgeOutput
+                : rightEdgeOutput;
+        default:
+            return value;
+    }
+};
+const interpolateSegment = (input, segment, config) => {
+    const { leftEdgeInput, rightEdgeInput, leftEdgeOutput, rightEdgeOutput } = segment;
+    if (rightEdgeInput - leftEdgeInput === 0) {
+        return leftEdgeOutput;
+    }
+    const progress = (input - leftEdgeInput) / (rightEdgeInput - leftEdgeInput);
+    const value = leftEdgeOutput + progress * (rightEdgeOutput - leftEdgeOutput);
+    // Which way the output range runs, so "past the left edge" is a comparison
+    // that works for a descending outputRange too.
+    const direction = rightEdgeOutput >= leftEdgeOutput ? 1 : -1;
+    if (direction * value < direction * leftEdgeOutput) {
+        return extrapolated(config.extrapolateLeft, direction, value, leftEdgeOutput, rightEdgeOutput, input);
+    }
+    if (direction * value > direction * rightEdgeOutput) {
+        return extrapolated(config.extrapolateRight, direction, value, leftEdgeOutput, rightEdgeOutput, input);
+    }
+    return value;
+};
+/**
+ * Maps `value` from `inputRange` onto `outputRange` with linear
+ * interpolation between the two enclosing stops.
+ */
+export const interpolate = (value, inputRange, outputRange, type) => {
+    if (inputRange.length < 2 || outputRange.length < 2) {
+        throw new Error("react-native-reanimated: interpolate() input and output ranges must contain at least two values");
+    }
+    const config = resolveExtrapolation(type);
+    const length = inputRange.length;
+    if (value > inputRange[length - 1]) {
+        return interpolateSegment(value, {
+            leftEdgeInput: inputRange[length - 2],
+            rightEdgeInput: inputRange[length - 1],
+            leftEdgeOutput: outputRange[length - 2],
+            rightEdgeOutput: outputRange[length - 1],
+        }, config);
+    }
+    // Binary search for the first stop at or above the value: an interpolation
+    // taken per frame over a long keyframe list should not be linear in it.
+    let left = 1;
+    let right = length - 1;
+    while (left < right) {
+        const middle = Math.floor((left + right) / 2);
+        if (value <= inputRange[middle]) {
+            right = middle;
+        }
+        else {
+            left = middle + 1;
+        }
+    }
+    return interpolateSegment(value, {
+        leftEdgeInput: inputRange[left - 1],
+        rightEdgeInput: inputRange[left],
+        leftEdgeOutput: outputRange[left - 1],
+        rightEdgeOutput: outputRange[left],
+    }, config);
+};
+/** Constrains `value` to `[min, max]`. */
+export const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+//# sourceMappingURL=interpolation.js.map

package/dist/reanimated-compat/interpolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolation.js","sourceRoot":"","sources":["../../src/reanimated-compat/interpolation.ts"],"names":[],"mappings":"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","sourcesContent":["// `interpolate`, `Extrapolation` and `clamp` — pure functions over numbers,\n// portable from upstream as-is (nothing in them touches a runtime, a thread\n// or the DOM).\n//\n// Not `src/animated/interpolate.ts`: that one COMPILES an\n// InterpolationConfig into a node-to-node mapping for `Animated.Value`, takes\n// a single `extrapolate` for both edges and produces suffixed strings.\n// Reanimated's is a plain `number → number` call taken inside a mapper, with\n// independently configurable left and right extrapolation. Different shape,\n// different call site; the two do not fold into one.\n\n/** Behaviour for inputs outside `inputRange`. */\nexport enum Extrapolation {\n  IDENTITY = \"identity\",\n  CLAMP = \"clamp\",\n  EXTEND = \"extend\",\n}\n\nexport type ExtrapolationConfig = {\n  extrapolateLeft?: Extrapolation | string\n  extrapolateRight?: Extrapolation | string\n}\n\nexport type ExtrapolationType =\n  | ExtrapolationConfig\n  | Extrapolation\n  | \"identity\"\n  | \"clamp\"\n  | \"extend\"\n  | undefined\n\ntype ResolvedExtrapolation = {\n  extrapolateLeft: Extrapolation\n  extrapolateRight: Extrapolation\n}\n\ntype Segment = {\n  leftEdgeInput: number\n  rightEdgeInput: number\n  leftEdgeOutput: number\n  rightEdgeOutput: number\n}\n\nconst SUPPORTED =\n  'Supported values: \"extend\", \"clamp\", \"identity\", Extrapolation.CLAMP, ' +\n  \"Extrapolation.EXTEND, Extrapolation.IDENTITY\"\n\nconst isExtrapolation = (value: string): value is Extrapolation =>\n  value === Extrapolation.EXTEND ||\n  value === Extrapolation.CLAMP ||\n  value === Extrapolation.IDENTITY\n\nconst resolveExtrapolation = (\n  type: ExtrapolationType,\n): ResolvedExtrapolation => {\n  const resolved: ResolvedExtrapolation = {\n    extrapolateLeft: Extrapolation.EXTEND,\n    extrapolateRight: Extrapolation.EXTEND,\n  }\n  if (!type) {\n    return resolved\n  }\n  if (typeof type === \"string\") {\n    if (!isExtrapolation(type)) {\n      throw new Error(\n        `react-native-reanimated: unsupported extrapolation \"${type}\" for interpolate(). ${SUPPORTED}`,\n      )\n    }\n    resolved.extrapolateLeft = type\n    resolved.extrapolateRight = type\n    return resolved\n  }\n  const { extrapolateLeft, extrapolateRight } = type\n  if (\n    (extrapolateLeft && !isExtrapolation(extrapolateLeft)) ||\n    (extrapolateRight && !isExtrapolation(extrapolateRight))\n  ) {\n    throw new Error(\n      `react-native-reanimated: unsupported extrapolation for interpolate(). ${SUPPORTED}`,\n    )\n  }\n  if (extrapolateLeft) {\n    resolved.extrapolateLeft = extrapolateLeft as Extrapolation\n  }\n  if (extrapolateRight) {\n    resolved.extrapolateRight = extrapolateRight as Extrapolation\n  }\n  return resolved\n}\n\nconst extrapolated = (\n  type: Extrapolation,\n  direction: number,\n  value: number,\n  leftEdgeOutput: number,\n  rightEdgeOutput: number,\n  input: number,\n): number => {\n  switch (type) {\n    case Extrapolation.IDENTITY:\n      return input\n    case Extrapolation.CLAMP:\n      return direction * value < direction * leftEdgeOutput\n        ? leftEdgeOutput\n        : rightEdgeOutput\n    default:\n      return value\n  }\n}\n\nconst interpolateSegment = (\n  input: number,\n  segment: Segment,\n  config: ResolvedExtrapolation,\n): number => {\n  const { leftEdgeInput, rightEdgeInput, leftEdgeOutput, rightEdgeOutput } =\n    segment\n  if (rightEdgeInput - leftEdgeInput === 0) {\n    return leftEdgeOutput\n  }\n  const progress = (input - leftEdgeInput) / (rightEdgeInput - leftEdgeInput)\n  const value = leftEdgeOutput + progress * (rightEdgeOutput - leftEdgeOutput)\n  // Which way the output range runs, so \"past the left edge\" is a comparison\n  // that works for a descending outputRange too.\n  const direction = rightEdgeOutput >= leftEdgeOutput ? 1 : -1\n\n  if (direction * value < direction * leftEdgeOutput) {\n    return extrapolated(\n      config.extrapolateLeft,\n      direction,\n      value,\n      leftEdgeOutput,\n      rightEdgeOutput,\n      input,\n    )\n  }\n  if (direction * value > direction * rightEdgeOutput) {\n    return extrapolated(\n      config.extrapolateRight,\n      direction,\n      value,\n      leftEdgeOutput,\n      rightEdgeOutput,\n      input,\n    )\n  }\n  return value\n}\n\n/**\n * Maps `value` from `inputRange` onto `outputRange` with linear\n * interpolation between the two enclosing stops.\n */\nexport const interpolate = (\n  value: number,\n  inputRange: readonly number[],\n  outputRange: readonly number[],\n  type?: ExtrapolationType,\n): number => {\n  if (inputRange.length < 2 || outputRange.length < 2) {\n    throw new Error(\n      \"react-native-reanimated: interpolate() input and output ranges must contain at least two values\",\n    )\n  }\n  const config = resolveExtrapolation(type)\n  const length = inputRange.length\n\n  if (value > inputRange[length - 1]!) {\n    return interpolateSegment(\n      value,\n      {\n        leftEdgeInput: inputRange[length - 2]!,\n        rightEdgeInput: inputRange[length - 1]!,\n        leftEdgeOutput: outputRange[length - 2]!,\n        rightEdgeOutput: outputRange[length - 1]!,\n      },\n      config,\n    )\n  }\n\n  // Binary search for the first stop at or above the value: an interpolation\n  // taken per frame over a long keyframe list should not be linear in it.\n  let left = 1\n  let right = length - 1\n  while (left < right) {\n    const middle = Math.floor((left + right) / 2)\n    if (value <= inputRange[middle]!) {\n      right = middle\n    } else {\n      left = middle + 1\n    }\n  }\n\n  return interpolateSegment(\n    value,\n    {\n      leftEdgeInput: inputRange[left - 1]!,\n      rightEdgeInput: inputRange[left]!,\n      leftEdgeOutput: outputRange[left - 1]!,\n      rightEdgeOutput: outputRange[left]!,\n    },\n    config,\n  )\n}\n\n/** Constrains `value` to `[min, max]`. */\nexport const clamp = (value: number, min: number, max: number): number =>\n  Math.min(Math.max(value, min), max)\n"]}

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

@@ -0,0 +1,43 @@
+import { type ReactNode, type RefObject } from "react";
+export type LayoutAnimationSkip = {
+    /** True for the one commit a `skipEntering` wrapper mounts in. */
+    entering: RefObject<boolean>;
+    /** True once a `skipExiting` wrapper has begun unmounting. */
+    exiting: RefObject<boolean>;
+};
+/** @internal Read by `withLayoutAnimations`; not part of upstream's surface. */
+export declare const useLayoutAnimationSkip: () => LayoutAnimationSkip | null;
+export type LayoutAnimationConfigProps = {
+    /** Suppresses the `entering` of children that mount with this wrapper. */
+    skipEntering?: boolean;
+    /** Suppresses the `exiting` of children when this wrapper unmounts. */
+    skipExiting?: boolean;
+    children?: ReactNode;
+};
+/**
+ * Suppresses `entering` and/or `exiting` for the subtree below it.
+ *
+ * The classic use is a screen that mounts with a list already populated: the
+ * rows should animate when they are ADDED, not when the screen appears.
+ *
+ * ```tsx
+ * <LayoutAnimationConfig skipEntering>
+ *   {items.map((item) => (
+ *     <Animated.View key={item.id} entering={FadeIn} />
+ *   ))}
+ * </LayoutAnimationConfig>
+ * ```
+ *
+ * Adds no widget to the tree — it renders its children and nothing else.
+ */
+export declare const LayoutAnimationConfig: ({ skipEntering, skipExiting, children, }: LayoutAnimationConfigProps) => ReactNode;
+/**
+ * Deprecated upstream, where it warns and does nothing — the allow-list it
+ * used to write to is gone from Reanimated itself. Mirrored exactly: refusing
+ * would break startup code calling it for a setting that changes nothing on
+ * any platform, and honouring it would be inventing behaviour upstream
+ * removed. Use {@link LayoutAnimationConfig} to actually skip animations.
+ */
+export declare const enableLayoutAnimations: () => void;
+/** @internal Test seam: the deprecation warning is once per session. */
+export declare const resetEnableLayoutAnimationsWarning: () => void;

package/dist/reanimated-compat/layout-animation-config.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// `<LayoutAnimationConfig>`: turning entering and exiting animations off for a
+// subtree, and `enableLayoutAnimations`.
+//
+// Both halves are ordinary React here, where upstream needs the native side
+// for one of them. `skipEntering` is a context whose ref is true for exactly
+// one commit — children mounted WITH the wrapper read it from their layout
+// effect and skip; children mounted later find it already false. `skipExiting`
+// is the same trick backwards: React runs a deleted subtree's layout-effect
+// cleanups from the OUTSIDE IN, so this component's own cleanup runs before
+// any of its descendants' and can tell them, through the same context, that
+// the whole subtree is going. Upstream reaches for `findNodeHandle` plus
+// `setShouldAnimateExitingForTag` for that second half only because its
+// exiting animations are configured on the native shadow node, one commit
+// earlier than the information exists; nothing here is configured that early.
+import { createContext, useContext, useEffect, useLayoutEffect, useRef, useState, } from "react";
+const LayoutAnimationSkipContext = createContext(null);
+/** @internal Read by `withLayoutAnimations`; not part of upstream's surface. */
+export const useLayoutAnimationSkip = () => useContext(LayoutAnimationSkipContext);
+/**
+ * Suppresses `entering` and/or `exiting` for the subtree below it.
+ *
+ * The classic use is a screen that mounts with a list already populated: the
+ * rows should animate when they are ADDED, not when the screen appears.
+ *
+ * ```tsx
+ * <LayoutAnimationConfig skipEntering>
+ *   {items.map((item) => (
+ *     <Animated.View key={item.id} entering={FadeIn} />
+ *   ))}
+ * </LayoutAnimationConfig>
+ * ```
+ *
+ * Adds no widget to the tree — it renders its children and nothing else.
+ */
+export const LayoutAnimationConfig = ({ skipEntering, skipExiting, children, }) => {
+    const entering = useRef(skipEntering ?? false);
+    const exiting = useRef(false);
+    // A passive effect, deliberately: every layout effect in the mounting
+    // commit — which is where a child's `entering` starts — has already run by
+    // the time this fires, so the flag covers that commit and no other.
+    useEffect(() => {
+        entering.current = false;
+    });
+    useLayoutEffect(() => {
+        return () => {
+            if (skipExiting) {
+                exiting.current = true;
+            }
+        };
+    }, [skipExiting]);
+    // `useState` rather than `useRef` for the context VALUE: it has to be
+    // stable (a new object would remount every consumer's effects) and it has
+    // to be readable during render, and a ref is only the first of those.
+    const [skip] = useState(() => ({ entering, exiting }));
+    return (_jsx(LayoutAnimationSkipContext, { value: skip, children: children }));
+};
+let warnedAboutEnable = false;
+/**
+ * Deprecated upstream, where it warns and does nothing — the allow-list it
+ * used to write to is gone from Reanimated itself. Mirrored exactly: refusing
+ * would break startup code calling it for a setting that changes nothing on
+ * any platform, and honouring it would be inventing behaviour upstream
+ * removed. Use {@link LayoutAnimationConfig} to actually skip animations.
+ */
+export const enableLayoutAnimations = () => {
+    const isProduction = typeof process !== "undefined" && process.env.NODE_ENV === "production";
+    if (warnedAboutEnable || isProduction) {
+        return;
+    }
+    warnedAboutEnable = true;
+    console.warn("`enableLayoutAnimations` is deprecated and will be removed in the future.");
+};
+/** @internal Test seam: the deprecation warning is once per session. */
+export const resetEnableLayoutAnimationsWarning = () => {
+    warnedAboutEnable = false;
+};
+//# sourceMappingURL=layout-animation-config.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layout-animation-config.js","sourceRoot":"","sources":["../../src/reanimated-compat/layout-animation-config.tsx"],"names":[],"mappings":";AAAA,+EAA+E;AAC/E,yCAAyC;AACzC,EAAE;AACF,4EAA4E;AAC5E,6EAA6E;AAC7E,2EAA2E;AAC3E,+EAA+E;AAC/E,4EAA4E;AAC5E,4EAA4E;AAC5E,4EAA4E;AAC5E,yEAAyE;AACzE,wEAAwE;AACxE,0EAA0E;AAC1E,8EAA8E;AAC9E,OAAO,EACL,aAAa,EACb,UAAU,EACV,SAAS,EACT,eAAe,EACf,MAAM,EACN,QAAQ,GAGT,MAAM,OAAO,CAAA;AASd,MAAM,0BAA0B,GAAG,aAAa,CAC9C,IAAI,CACL,CAAA;AAED,gFAAgF;AAChF,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAA+B,EAAE,CACrE,UAAU,CAAC,0BAA0B,CAAC,CAAA;AAUxC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,EACpC,YAAY,EACZ,WAAW,EACX,QAAQ,GACmB,EAAa,EAAE;IAC1C,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,IAAI,KAAK,CAAC,CAAA;IAC9C,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAA;IAC7B,sEAAsE;IACtE,2EAA2E;IAC3E,oEAAoE;IACpE,SAAS,CAAC,GAAG,EAAE;QACb,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAA;IAC1B,CAAC,CAAC,CAAA;IACF,eAAe,CAAC,GAAG,EAAE;QACnB,OAAO,GAAG,EAAE;YACV,IAAI,WAAW,EAAE,CAAC;gBAChB,OAAO,CAAC,OAAO,GAAG,IAAI,CAAA;YACxB,CAAC;QACH,CAAC,CAAA;IACH,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,CAAA;IACjB,sEAAsE;IACtE,0EAA0E;IAC1E,sEAAsE;IACtE,MAAM,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAsB,GAAG,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAA;IAC3E,OAAO,CACL,KAAC,0BAA0B,IAAC,KAAK,EAAE,IAAI,YACpC,QAAQ,GACkB,CAC9B,CAAA;AACH,CAAC,CAAA;AAED,IAAI,iBAAiB,GAAG,KAAK,CAAA;AAE7B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAS,EAAE;IAC/C,MAAM,YAAY,GAChB,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAA;IACzE,IAAI,iBAAiB,IAAI,YAAY,EAAE,CAAC;QACtC,OAAM;IACR,CAAC;IACD,iBAAiB,GAAG,IAAI,CAAA;IACxB,OAAO,CAAC,IAAI,CACV,2EAA2E,CAC5E,CAAA;AACH,CAAC,CAAA;AAED,wEAAwE;AACxE,MAAM,CAAC,MAAM,kCAAkC,GAAG,GAAS,EAAE;IAC3D,iBAAiB,GAAG,KAAK,CAAA;AAC3B,CAAC,CAAA","sourcesContent":["// `<LayoutAnimationConfig>`: turning entering and exiting animations off for a\n// subtree, and `enableLayoutAnimations`.\n//\n// Both halves are ordinary React here, where upstream needs the native side\n// for one of them. `skipEntering` is a context whose ref is true for exactly\n// one commit — children mounted WITH the wrapper read it from their layout\n// effect and skip; children mounted later find it already false. `skipExiting`\n// is the same trick backwards: React runs a deleted subtree's layout-effect\n// cleanups from the OUTSIDE IN, so this component's own cleanup runs before\n// any of its descendants' and can tell them, through the same context, that\n// the whole subtree is going. Upstream reaches for `findNodeHandle` plus\n// `setShouldAnimateExitingForTag` for that second half only because its\n// exiting animations are configured on the native shadow node, one commit\n// earlier than the information exists; nothing here is configured that early.\nimport {\n  createContext,\n  useContext,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useState,\n  type ReactNode,\n  type RefObject,\n} from \"react\"\n\nexport type LayoutAnimationSkip = {\n  /** True for the one commit a `skipEntering` wrapper mounts in. */\n  entering: RefObject<boolean>\n  /** True once a `skipExiting` wrapper has begun unmounting. */\n  exiting: RefObject<boolean>\n}\n\nconst LayoutAnimationSkipContext = createContext<LayoutAnimationSkip | null>(\n  null,\n)\n\n/** @internal Read by `withLayoutAnimations`; not part of upstream's surface. */\nexport const useLayoutAnimationSkip = (): LayoutAnimationSkip | null =>\n  useContext(LayoutAnimationSkipContext)\n\nexport type LayoutAnimationConfigProps = {\n  /** Suppresses the `entering` of children that mount with this wrapper. */\n  skipEntering?: boolean\n  /** Suppresses the `exiting` of children when this wrapper unmounts. */\n  skipExiting?: boolean\n  children?: ReactNode\n}\n\n/**\n * Suppresses `entering` and/or `exiting` for the subtree below it.\n *\n * The classic use is a screen that mounts with a list already populated: the\n * rows should animate when they are ADDED, not when the screen appears.\n *\n * ```tsx\n * <LayoutAnimationConfig skipEntering>\n *   {items.map((item) => (\n *     <Animated.View key={item.id} entering={FadeIn} />\n *   ))}\n * </LayoutAnimationConfig>\n * ```\n *\n * Adds no widget to the tree — it renders its children and nothing else.\n */\nexport const LayoutAnimationConfig = ({\n  skipEntering,\n  skipExiting,\n  children,\n}: LayoutAnimationConfigProps): ReactNode => {\n  const entering = useRef(skipEntering ?? false)\n  const exiting = useRef(false)\n  // A passive effect, deliberately: every layout effect in the mounting\n  // commit — which is where a child's `entering` starts — has already run by\n  // the time this fires, so the flag covers that commit and no other.\n  useEffect(() => {\n    entering.current = false\n  })\n  useLayoutEffect(() => {\n    return () => {\n      if (skipExiting) {\n        exiting.current = true\n      }\n    }\n  }, [skipExiting])\n  // `useState` rather than `useRef` for the context VALUE: it has to be\n  // stable (a new object would remount every consumer's effects) and it has\n  // to be readable during render, and a ref is only the first of those.\n  const [skip] = useState<LayoutAnimationSkip>(() => ({ entering, exiting }))\n  return (\n    <LayoutAnimationSkipContext value={skip}>\n      {children}\n    </LayoutAnimationSkipContext>\n  )\n}\n\nlet warnedAboutEnable = false\n\n/**\n * Deprecated upstream, where it warns and does nothing — the allow-list it\n * used to write to is gone from Reanimated itself. Mirrored exactly: refusing\n * would break startup code calling it for a setting that changes nothing on\n * any platform, and honouring it would be inventing behaviour upstream\n * removed. Use {@link LayoutAnimationConfig} to actually skip animations.\n */\nexport const enableLayoutAnimations = (): void => {\n  const isProduction =\n    typeof process !== \"undefined\" && process.env.NODE_ENV === \"production\"\n  if (warnedAboutEnable || isProduction) {\n    return\n  }\n  warnedAboutEnable = true\n  console.warn(\n    \"`enableLayoutAnimations` is deprecated and will be removed in the future.\",\n  )\n}\n\n/** @internal Test seam: the deprecation warning is once per session. */\nexport const resetEnableLayoutAnimationsWarning = (): void => {\n  warnedAboutEnable = false\n}\n"]}

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

@@ -0,0 +1,117 @@
+import { AnimationBuilder, type BuiltLayoutAnimation, type LayoutAnimationValues } from "./layout-animation";
+/** A constant, or a number derived from the rects the builder was handed. */
+type Measure = number | ((values: LayoutAnimationValues) => number);
+/**
+ * One animated property: where it starts, and where it goes.
+ *
+ * `to` is animated with the BUILDER's animation, so `.springify()`,
+ * `.duration()` and `.easing()` all reach it. `steps` is an explicit timing
+ * track — upstream writes the bounce curves as literal `withTiming`
+ * sequences, and a spring has no way to express "overshoot to 1.2, settle
+ * through 0.9 and 1.1" — where each step is a target plus the fraction of the
+ * builder's duration it takes.
+ */
+type Track = {
+    from: Measure;
+    to?: Measure;
+    steps?: readonly (readonly [Measure, number])[];
+};
+/**
+ * The transform keys the catalogue uses, which are exactly the keys
+ * src/style/transform.ts folds into its matrix. `rotate` is in DEGREES here:
+ * upstream spells it `'-90deg'`/`'5rad'`, and a string cannot go through a
+ * numeric animation — `parseAngle` reads a bare number as degrees, so the
+ * matrix that reaches GTK is the same one either spelling produces.
+ */
+type TransformKey = "translateX" | "translateY" | "scale" | "scaleX" | "scaleY" | "rotate";
+type TransformTrack = Track & {
+    key: TransformKey;
+};
+type PresetSpec = {
+    opacity?: Track;
+    /** `SlideIn*`/`SlideOut*`: the only presets that move the layout origin. */
+    origin?: Track & {
+        axis: "x" | "y";
+    };
+    transform?: readonly TransformTrack[];
+};
+/**
+ * The one preset body. Every entry in the catalogue is an empty subclass of
+ * this carrying its own {@link PresetSpec}.
+ */
+export declare class LayoutAnimationPreset extends AnimationBuilder {
+    /**
+     * Replaced by every generated subclass — see `definePreset`. A method
+     * rather than a field so the two `.rotate()`-aware presets can compute
+     * theirs from builder state that is only settled by the time `build()` runs.
+     */
+    protected spec(): PresetSpec;
+    build(): (values: LayoutAnimationValues) => BuiltLayoutAnimation;
+}
+export declare const FadeInRight: typeof LayoutAnimationPreset;
+export declare const FadeInLeft: typeof LayoutAnimationPreset;
+export declare const FadeInUp: typeof LayoutAnimationPreset;
+export declare const FadeInDown: typeof LayoutAnimationPreset;
+export declare const FadeOutRight: typeof LayoutAnimationPreset;
+export declare const FadeOutLeft: typeof LayoutAnimationPreset;
+export declare const FadeOutUp: typeof LayoutAnimationPreset;
+export declare const FadeOutDown: typeof LayoutAnimationPreset;
+export declare const BounceIn: typeof LayoutAnimationPreset;
+export declare const BounceInDown: typeof LayoutAnimationPreset;
+export declare const BounceInUp: typeof LayoutAnimationPreset;
+export declare const BounceInLeft: typeof LayoutAnimationPreset;
+export declare const BounceInRight: typeof LayoutAnimationPreset;
+export declare const BounceOut: typeof LayoutAnimationPreset;
+export declare const BounceOutDown: typeof LayoutAnimationPreset;
+export declare const BounceOutUp: typeof LayoutAnimationPreset;
+export declare const BounceOutLeft: typeof LayoutAnimationPreset;
+export declare const BounceOutRight: typeof LayoutAnimationPreset;
+export declare const PinwheelIn: typeof LayoutAnimationPreset;
+export declare const PinwheelOut: typeof LayoutAnimationPreset;
+export declare const RollInLeft: typeof LayoutAnimationPreset;
+export declare const RollInRight: typeof LayoutAnimationPreset;
+export declare const RollOutLeft: typeof LayoutAnimationPreset;
+export declare const RollOutRight: typeof LayoutAnimationPreset;
+export declare const RotateInDownLeft: typeof LayoutAnimationPreset;
+export declare const RotateInDownRight: typeof LayoutAnimationPreset;
+export declare const RotateInUpLeft: typeof LayoutAnimationPreset;
+export declare const RotateInUpRight: typeof LayoutAnimationPreset;
+export declare const RotateOutDownLeft: typeof LayoutAnimationPreset;
+export declare const RotateOutDownRight: typeof LayoutAnimationPreset;
+export declare const RotateOutUpLeft: typeof LayoutAnimationPreset;
+export declare const RotateOutUpRight: typeof LayoutAnimationPreset;
+export declare const SlideInRight: typeof LayoutAnimationPreset;
+export declare const SlideInLeft: typeof LayoutAnimationPreset;
+export declare const SlideOutRight: typeof LayoutAnimationPreset;
+export declare const SlideOutLeft: typeof LayoutAnimationPreset;
+export declare const SlideInUp: typeof LayoutAnimationPreset;
+export declare const SlideInDown: typeof LayoutAnimationPreset;
+export declare const SlideOutUp: typeof LayoutAnimationPreset;
+export declare const SlideOutDown: typeof LayoutAnimationPreset;
+export declare const StretchInX: typeof LayoutAnimationPreset;
+export declare const StretchInY: typeof LayoutAnimationPreset;
+export declare const StretchOutX: typeof LayoutAnimationPreset;
+export declare const StretchOutY: typeof LayoutAnimationPreset;
+export declare const ZoomIn: typeof LayoutAnimationPreset;
+export declare const ZoomInLeft: typeof LayoutAnimationPreset;
+export declare const ZoomInRight: typeof LayoutAnimationPreset;
+export declare const ZoomInUp: typeof LayoutAnimationPreset;
+export declare const ZoomInDown: typeof LayoutAnimationPreset;
+export declare const ZoomInEasyUp: typeof LayoutAnimationPreset;
+export declare const ZoomInEasyDown: typeof LayoutAnimationPreset;
+export declare const ZoomOut: typeof LayoutAnimationPreset;
+export declare const ZoomOutLeft: typeof LayoutAnimationPreset;
+export declare const ZoomOutRight: typeof LayoutAnimationPreset;
+export declare const ZoomOutUp: typeof LayoutAnimationPreset;
+export declare const ZoomOutDown: typeof LayoutAnimationPreset;
+export declare const ZoomOutEasyUp: typeof LayoutAnimationPreset;
+export declare const ZoomOutEasyDown: typeof LayoutAnimationPreset;
+/** `ZoomIn` with a spin. `.rotate()` sets the angle; upstream's default is 0.3 rad. */
+export declare class ZoomInRotate extends LayoutAnimationPreset {
+    protected spec(): PresetSpec;
+}
+/** `ZoomOut` with a spin. `.rotate()` sets the angle; upstream's default is 0.3 rad. */
+export declare class ZoomOutRotate extends LayoutAnimationPreset {
+    protected spec(): PresetSpec;
+}
+export {};