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

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

@@ -0,0 +1 @@
+{"version":3,"file":"style.js","sourceRoot":"","sources":["../../src/reanimated-compat/style.ts"],"names":[],"mappings":"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","sourcesContent":["// Turning a `useAnimatedStyle` updater's plain object into a style the view\n// layer can drive without React.\n//\n// The mapper returns ordinary values every frame. On the first run each\n// animatable leaf is replaced by a small animated NODE and the mapping is\n// remembered; later runs only push new values into those nodes, so a running\n// animation costs zero React renders. `src/components/animated.tsx`\n// recognises those nodes structurally and writes them straight to GTK —\n// `widget.setOpacity` for opacity, the rect store plus `queueAllocate` for\n// transforms, and a CSS provider private to the widget for colours.\n//\n// WHERE THE BOUNDARY IS NOW. Opacity, transforms and colours are driven\n// unconditionally. `flex`, every `margin*`/`padding*`, `gap`, `flexBasis` and\n// the `min*`/`max*` family are refused, and that is a refusal on measured\n// grounds rather than a gap waiting to be filled: a layout write has to go\n// through Yoga, and a pass plus its commit walk costs what the CONTAINER\n// costs, not what the animated value costs — 52 µs for a five-child\n// container, 133 µs at sixty, 496 µs at three hundred, per frame. The same\n// frame's transform write is 1.5 µs and does not grow at all.\n//\n// It is a cost argument and ONLY a cost argument, which is narrower than this\n// comment used to claim. docs/research/animated-size.md re-measured the two\n// other things that were said here: GTK re-measuring the ancestors after the\n// resize adds nothing at any tree size, and a size write cannot move the\n// window — the RN root reports a zero size request, so the toplevel never\n// re-negotiates. (An `IntrinsicRoot` mounted directly in GTK chrome is the one\n// exception, and it does change the window's request.)\n//\n// TWO CARVE-OUTS, and neither is a softening of that.\n//\n//  - `top`/`left`/`right`/`bottom` on a node whose OWN `position` is\n//    `\"absolute\"`, because an out-of-flow node's inset has an exact transform\n//    equivalent: moving it changes nothing but where it is drawn, which is\n//    what the transform path already does, so no Yoga pass is needed at all —\n//    src/style/absolute-insets.ts, docs/research/absolute-insets.md.\n//  - `width`/`height` where the change is CONFINED to the node that owns it.\n//    There is no transform that reproduces a size change (a scale grows about\n//    the centre and stretches the content instead of re-laying it out —\n//    measured), so this one really does run Yoga; it just runs it rooted at\n//    the animated node rather than at the tree's root, which is 6.6 µs for a\n//    leaf and 23 µs with wrapped text, IDENTICAL at 5, 60 and 300 siblings —\n//    src/style/animated-size.ts, docs/research/animated-size.md.\n//\n// Both rules are measured, neither is universal, and the configurations where\n// they fail are refused as loudly as `flex` is.\n//\n// The rule for everything undriveable stays what it was: it must be VISIBLE.\n// A property that changes between mapper runs but cannot be driven says so\n// once, by name — and layout properties say it in their own words, because\n// \"use translateX instead of left\" is advice and \"cannot be written\" is not.\n\nimport {\n  INSET_PROPERTIES,\n  insetRefusalReason,\n  insetTranslation,\n} from \"../style/absolute-insets\"\nimport { SIZE_PROPERTIES } from \"../style/animated-size\"\nimport { DRIVEABLE_COLOR_PROPERTIES } from \"../style/imperative-css\"\n\nexport type StyleValue = number | string\n\nexport type StyleObject = Record<string, unknown>\n\n/** The animated node a style leaf is replaced with. */\nexport type StyleNode = {\n  addListener(callback: (state: { value: StyleValue }) => void): string\n  removeListener(id: string): void\n  __getValue(): StyleValue\n  /** @internal Publishes a new value to the view layer. */\n  __push(value: StyleValue): void\n}\n\n/**\n * @internal Shared with `props.ts`: `useAnimatedProps` publishes through the\n * exact same node the style path does, because the receivers duck-type it the\n * same way (`addListener` + `__getValue`).\n */\nexport const createStyleNode = (initial: StyleValue): StyleNode => {\n  let current = initial\n  const listeners = new Map<string, (state: { value: StyleValue }) => void>()\n  let nextListenerId = 1\n  return {\n    addListener(callback) {\n      const id = String(nextListenerId++)\n      listeners.set(id, callback)\n      return id\n    },\n    removeListener(id) {\n      listeners.delete(id)\n    },\n    __getValue() {\n      return current\n    },\n    __push(value) {\n      if (Object.is(value, current)) {\n        return\n      }\n      current = value\n      for (const listener of [...listeners.values()]) {\n        listener({ value: current })\n      }\n    },\n  }\n}\n\nconst isStyleValue = (value: unknown): value is StyleValue =>\n  typeof value === \"number\" || typeof value === \"string\"\n\nconst OPACITY = \"opacity\"\nconst Z_INDEX = \"zIndex\"\n\nconst transformLeafKey = (index: number, part: string): string =>\n  `transform.${index}.${part}`\n\ntype InsetProperty = (typeof INSET_PROPERTIES)[number]\n\nconst isInsetProperty = (property: string): property is InsetProperty =>\n  (INSET_PROPERTIES as readonly string[]).includes(property)\n\nconst isSizeProperty = (property: string): boolean =>\n  (SIZE_PROPERTIES as readonly string[]).includes(property)\n\n/**\n * Whether this style's `property` is one of the insets that becomes a\n * transform. A number is required rather than merely a `DimensionValue`: a\n * percentage has no fixed offset from a point base, and switching to one\n * mid-animation changes the leaf signature, which rebuilds the style and puts\n * the property back on the refusal path where it belongs.\n *\n * The updater's object is not the whole style. `style={[styles.row, animated]}`\n * is how most people write this, so `position` and the opposite edge are very\n * often in a SIBLING entry that this module never sees. When the updater says\n * nothing about `position`, the question is simply not answerable here and the\n * leaf is made optimistically — the view layer re-asks it against the\n * FLATTENED style, which is the only place the true answer exists, and warns\n * there if the answer is no (components/animated.tsx). Nothing becomes silent\n * either way; only which channel says it moves.\n */\nconst isDriveableInset = (source: StyleObject, property: string): boolean => {\n  if (!isInsetProperty(property) || typeof source[property] !== \"number\") {\n    return false\n  }\n  return source.position === undefined\n    ? true\n    : insetTranslation(source, property) !== null\n}\n\n// RN's layout properties, as `STYLE_PROPERTIES_CONFIG` enumerates them.\n// Enumerated by hand rather than derived by subtracting the driveable set,\n// because the point of the list is to produce a DIFFERENT message: these are\n// refused for a measured reason and have a real alternative, which\n// `borderStyle` does not.\nconst LAYOUT_PROPERTIES = new Set([\n  \"aspectRatio\",\n  \"borderBottomWidth\",\n  \"borderEndWidth\",\n  \"borderLeftWidth\",\n  \"borderRightWidth\",\n  \"borderStartWidth\",\n  \"borderTopWidth\",\n  \"borderWidth\",\n  \"bottom\",\n  \"columnGap\",\n  \"end\",\n  \"flex\",\n  \"flexBasis\",\n  \"flexGrow\",\n  \"flexShrink\",\n  \"gap\",\n  \"height\",\n  \"left\",\n  \"margin\",\n  \"marginBottom\",\n  \"marginEnd\",\n  \"marginHorizontal\",\n  \"marginLeft\",\n  \"marginRight\",\n  \"marginStart\",\n  \"marginTop\",\n  \"marginVertical\",\n  \"maxHeight\",\n  \"maxWidth\",\n  \"minHeight\",\n  \"minWidth\",\n  \"padding\",\n  \"paddingBottom\",\n  \"paddingEnd\",\n  \"paddingHorizontal\",\n  \"paddingLeft\",\n  \"paddingRight\",\n  \"paddingStart\",\n  \"paddingTop\",\n  \"paddingVertical\",\n  \"right\",\n  \"rowGap\",\n  \"start\",\n  \"top\",\n  \"width\",\n])\n\n// Which transform to reach for instead, in the two kinds it comes in. The\n// distinction is not pedantry — `scaleX` was named as the replacement for\n// `width` here and it is not one, which docs/research/animated-size.md §6\n// measured on a 100×60 box widened to 260:\n//\n//   - a scale grows about the view's CENTRE, so the box MOVES: x went 500 →\n//     420, where the width change kept it at 500;\n//   - a scale scales the CONTENT with the box instead of re-laying it out: the\n//     label inside kept its three-line, 45 px-tall layout and was drawn 2.6×\n//     wide — stretched glyphs — where the width change re-wrapped it to one\n//     line, 15 px tall.\n//\n// So an inset really does have a transform that reproduces it, and a size does\n// not. Offering `scaleX` as if it did sends people to a different behaviour\n// with the same name on it — which is also why a numeric `width`/`height` is\n// driven for real now and only reaches this table as a PERCENTAGE, where\n// there is no point base to lay out at.\nconst EXACT_ALTERNATIVE: Record<string, string> = {\n  bottom: \"translateY\",\n  end: \"translateX\",\n  left: \"translateX\",\n  right: \"translateX\",\n  start: \"translateX\",\n  top: \"translateY\",\n}\n\nconst APPROXIMATE_ALTERNATIVE: Record<string, string> = {\n  height: \"scaleY\",\n  width: \"scaleX\",\n}\n\n// One warning per property name per session, matching the platform's\n// warnNativeDriverIgnored policy: a 60 Hz mapper must not produce 60 lines a\n// second, and the name is the actionable part.\nconst warned = new Set<string>()\n\nconst warnUndriveable = (property: string, source: StyleObject): void => {\n  if (warned.has(property)) {\n    return\n  }\n  warned.add(property)\n  const isProduction =\n    typeof process !== \"undefined\" && process.env.NODE_ENV === \"production\"\n  if (isProduction) {\n    return\n  }\n  const insetReason = isInsetProperty(property)\n    ? insetRefusalReason(source, property)\n    : null\n  if (insetReason) {\n    console.warn(\n      `react-native-reanimated: useAnimatedStyle changed \\`${property}\\`. This node IS absolutely ` +\n        `positioned — which is normally driven at frame rate here — but ${insetReason}, so no ` +\n        \"translation reproduces it and it would need a Yoga pass. Give the axis a single edge (or a \" +\n        `definite size) and \\`${property}\\` animates; otherwise animate ` +\n        `\\`transform: [{ ${EXACT_ALTERNATIVE[property]}: … }]\\`. The new value is applied on the next ` +\n        \"React render. See docs/api.md.\",\n    )\n    return\n  }\n  if (LAYOUT_PROPERTIES.has(property)) {\n    const exact = EXACT_ALTERNATIVE[property]\n    const approximate = APPROXIMATE_ALTERNATIVE[property]\n    console.warn(\n      `react-native-reanimated: useAnimatedStyle changed \\`${property}\\`, a LAYOUT property. ` +\n        \"react-native-gtkx does not drive layout at frame rate on purpose: a layout write costs a Yoga \" +\n        \"pass over the container plus the commit walk that follows it, and that cost grows with the \" +\n        \"CONTAINER rather than with the number of animated values — measured at 52 µs for a five-child \" +\n        \"container and 496 µs at three hundred, against a transform's 1.5 µs. \" +\n        (exact\n          ? `Animate \\`transform: [{ ${exact}: … }]\\` instead — it reproduces the move exactly, it is ` +\n            \"paint-only, it costs the same at any tree size, and it is what RN's own native driver \" +\n            \"restricts you to. \"\n          : approximate\n            ? `The closest transform is \\`transform: [{ ${approximate}: … }]\\`, but it is NOT the same ` +\n              \"thing and it is worth knowing how: a scale grows about the view's CENTRE, so the box \" +\n              \"moves as it grows, and it scales the CONTENT with the box instead of re-laying it out — \" +\n              \"text stretches rather than re-wrapping. Reach for it when the content can take being \" +\n              \"stretched (a plain box, an image), not as a replacement. \"\n            : \"Transforms are paint-only and cost the same at any tree size. \") +\n        (isInsetProperty(property)\n          ? `(\\`${property}\\` IS driven at frame rate on a node whose own \\`position\\` is \"absolute\", ` +\n            \"where moving it is exactly a translation and touches no sibling.) \"\n          : isSizeProperty(property)\n            ? `(A NUMERIC \\`${property}\\` IS driven at frame rate where the change is confined to the node ` +\n              \"that owns it. This one is a percentage, which has no point base to re-lay the subtree out \" +\n              \"at.) \"\n            : \"\") +\n        \"The new value is applied on the next React render. See docs/api.md.\",\n    )\n    return\n  }\n  console.warn(\n    `react-native-reanimated: useAnimatedStyle changed \\`${property}\\`, which react-native-gtkx cannot ` +\n      \"write to a mounted widget without a React render. `opacity`, `transform` and colours animate at \" +\n      \"frame rate here; the new value is applied on the next render instead. See docs/api.md.\",\n  )\n}\n\n/** @internal Test seam: the warning is once per session by design. */\nexport const resetUndriveableWarnings = (): void => {\n  warned.clear()\n}\n\n/**\n * Whether a property that finishes an animation has to be published through a\n * React render to land at all.\n *\n * Every warning on the layout path ends with \"the new value is applied on the\n * next React render\", and until now that was true only by luck: a value that\n * moves solely inside a `useAnimatedStyle` produces no render, so the last\n * frame of the animation was the last place it existed. `@gorhom/bottom-sheet`\n * is exactly that case — it bounds its scrollable with an animated `height`\n * and nothing else re-renders — and `spike/core-exports` is what found it.\n *\n * Layout properties only. `opacity`, `transform` and colours are written to\n * the widget on the frame they change, so a render at the end would be a\n * render for nothing; a `width`/`height` the driven-size rule ACCEPTS is on\n * screen at the right size already, and the render is what puts the same value\n * into Yoga so the committed layout and the override agree.\n *\n * At the end of the animation AND on a cadence while it runs, which is the\n * correction §10 made to §9: the settle alone kept the promise only when the\n * animation was short and never when its target moved every frame, and\n * gorhom's sheet was blank for 1.38 s because of it. Ten renders a second at\n * the very most, against sixty frames — still the whole difference between\n * this and the naive layout write the refusal is about\n * (docs/research/animated-size.md §3, and LANDING_INTERVAL_MS in\n * ./updater-animations.ts for the numbers).\n */\nexport const settlesThroughReact = (property: string): boolean =>\n  LAYOUT_PROPERTIES.has(property)\n\n/**\n * Collects the animatable leaves of a style, in the order the view layer\n * composes them (the transform array's order IS the composition order in RN).\n */\nconst leavesOf = (\n  source: StyleObject,\n): { key: string; value: StyleValue }[] => {\n  const leaves: { key: string; value: StyleValue }[] = []\n  if (typeof source[OPACITY] === \"number\") {\n    leaves.push({ key: OPACITY, value: source[OPACITY] })\n  }\n  // Driven for real, and by the same kind of write opacity uses: the paint\n  // and pick order of the container (gtkx/bridge/view-box.ts). It has to be\n  // driveable rather than merely accepted — `useSortable` puts it in the\n  // style object on every frame, so a refusal here is a refusal of the whole\n  // sortable-list shape.\n  if (typeof source[Z_INDEX] === \"number\") {\n    leaves.push({ key: Z_INDEX, value: source[Z_INDEX] })\n  }\n  for (const property of DRIVEABLE_COLOR_PROPERTIES) {\n    const value = source[property]\n    // Strings only. A colour is a string on this platform (RN's packed\n    // integers never reach a GTK stylesheet), so a number here is not a\n    // colour we can drive and belongs on the warn path with everything else.\n    if (typeof value === \"string\") {\n      leaves.push({ key: property, value })\n    }\n  }\n  for (const property of INSET_PROPERTIES) {\n    if (isDriveableInset(source, property)) {\n      leaves.push({ key: property, value: source[property] as number })\n    }\n  }\n  // Sizes: a number is the whole of what can be decided HERE. Whether the\n  // change is confined to the node depends on the container's\n  // `flexDirection`, its `alignItems` and where its own size comes from —\n  // none of which is in the updater's object, and none of which is even in\n  // the animated component's props. So the leaf is made optimistically and\n  // the view layer, which has the layout tree, answers and warns\n  // (src/style/animated-size.ts, components/animated.tsx). A percentage stays\n  // on the refusal path: it has no point base to lay out at, and switching to\n  // one mid-animation changes the leaf signature, which rebuilds the style.\n  for (const property of SIZE_PROPERTIES) {\n    if (typeof source[property] === \"number\") {\n      leaves.push({ key: property, value: source[property] })\n    }\n  }\n  if (Array.isArray(source.transform)) {\n    source.transform.forEach((entry, index) => {\n      if (typeof entry !== \"object\" || entry === null) {\n        return\n      }\n      const part = Object.keys(entry)[0]\n      if (part === undefined) {\n        return\n      }\n      const value = (entry as StyleObject)[part]\n      if (isStyleValue(value)) {\n        leaves.push({ key: transformLeafKey(index, part), value })\n      }\n    })\n  }\n  return leaves\n}\n\nconst signatureOf = (leaves: { key: string }[]): string =>\n  leaves.map((leaf) => leaf.key).join(\"|\")\n\nexport type AnimatedStyle = {\n  /**\n   * The object handed to `Animated.View`. Stable while an animation runs — a\n   * driven frame is a write into a node, not a new style — and replaced by a\n   * shallow copy exactly once per `renew()`, which is how a value that cannot\n   * be driven reaches the view layer at all.\n   */\n  readonly style: StyleObject\n  /** The nodes behind it, reusable when the style has to be rebuilt. */\n  readonly nodes: ReadonlyMap<string, StyleNode>\n  /**\n   * Publishes a fresh updater result. Returns false when the SHAPE changed\n   * (a transform entry appeared, vanished or swapped kind) and the caller\n   * must rebuild — the node set no longer matches, and the bindings in the\n   * view layer were made against the old one.\n   */\n  apply(next: StyleObject): boolean\n  /**\n   * Gives the style a new identity, so a render that follows actually reaches\n   * the view.\n   *\n   * A stable object was the right default and it is still what a running\n   * animation gets, but it is not enough on its own: `@gorhom/bottom-sheet`\n   * wraps the view this style lands on in `memo`, and a re-render of the\n   * component that OWNS the `useAnimatedStyle` stops at that boundary with\n   * every prop identical. The value then exists in the style and never reaches\n   * Yoga — measured, `spike/core-exports`: the sheet's content mask stayed at\n   * the height of the animation's first frame while the animation itself ran\n   * to 543 px.\n   *\n   * Called for a property the platform will not drive at frame rate when its\n   * animation settles, and at most ten times a second while it runs — never\n   * per frame. See LANDING_INTERVAL_MS in ./updater-animations.ts for why the\n   * settle on its own was not enough.\n   */\n  renew(): void\n}\n\n/**\n * Builds the node-backed style. `reuse` carries nodes over from a previous\n * build so a shape change keeps the identity of the leaves that survived it,\n * which is what stops the view layer re-binding the parts that did not move.\n */\nexport const createAnimatedStyle = (\n  source: StyleObject,\n  reuse?: ReadonlyMap<string, StyleNode>,\n): AnimatedStyle => {\n  const leaves = leavesOf(source)\n  const signature = signatureOf(leaves)\n  const nodes = new Map<string, StyleNode>()\n  for (const leaf of leaves) {\n    const existing = reuse?.get(leaf.key)\n    if (existing) {\n      existing.__push(leaf.value)\n      nodes.set(leaf.key, existing)\n    } else {\n      nodes.set(leaf.key, createStyleNode(leaf.value))\n    }\n  }\n\n  // Reassigned by `renew()` only. Every other write below — the node\n  // substitutions here, and `apply`'s update of a value it cannot drive — goes\n  // INTO the object currently published, so a renewed copy carries the latest\n  // of everything rather than a snapshot taken when it was made.\n  let style: StyleObject = { ...source }\n  const opacityNode = nodes.get(OPACITY)\n  if (opacityNode) {\n    style[OPACITY] = opacityNode\n  }\n  const zIndexNode = nodes.get(Z_INDEX)\n  if (zIndexNode) {\n    style[Z_INDEX] = zIndexNode\n  }\n  for (const property of DRIVEABLE_COLOR_PROPERTIES) {\n    const colorNode = nodes.get(property)\n    if (colorNode) {\n      style[property] = colorNode\n    }\n  }\n  // The view layer duck-types these exactly as it does opacity and colours,\n  // and turns each into a translate measured from the position Yoga committed\n  // (components/animated.tsx, splitAnimated).\n  for (const property of INSET_PROPERTIES) {\n    const insetNode = nodes.get(property)\n    if (insetNode) {\n      style[property] = insetNode\n    }\n  }\n  for (const property of SIZE_PROPERTIES) {\n    const sizeNode = nodes.get(property)\n    if (sizeNode) {\n      style[property] = sizeNode\n    }\n  }\n  if (Array.isArray(source.transform)) {\n    style.transform = source.transform.map((entry, index) => {\n      if (typeof entry !== \"object\" || entry === null) {\n        return entry as unknown\n      }\n      const part = Object.keys(entry)[0]\n      if (part === undefined) {\n        return entry as unknown\n      }\n      const node = nodes.get(transformLeafKey(index, part))\n      return node ? { [part]: node } : (entry as unknown)\n    })\n  }\n\n  // The last values seen for everything that is NOT node-backed, so a change\n  // can be reported rather than silently dropped.\n  let staticSnapshot = source\n\n  return {\n    get style() {\n      return style\n    },\n    nodes,\n    renew() {\n      style = { ...style }\n    },\n    apply(next) {\n      const nextLeaves = leavesOf(next)\n      if (signatureOf(nextLeaves) !== signature) {\n        return false\n      }\n      for (const leaf of nextLeaves) {\n        nodes.get(leaf.key)?.__push(leaf.value)\n      }\n      for (const key of Object.keys(next)) {\n        if (key === OPACITY || key === \"transform\" || nodes.has(key)) {\n          continue\n        }\n        if (!Object.is(next[key], staticSnapshot[key])) {\n          warnUndriveable(key, next)\n          // Kept up to date anyway: the next React render — whenever it\n          // happens, for whatever reason — then applies the current value\n          // rather than the one from mount.\n          style[key] = next[key]\n        }\n      }\n      staticSnapshot = next\n      return true\n    },\n  }\n}\n"]}

package/dist/reanimated-compat/test-timers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Runs `body` with the platform's frame driver replaced by one the test
+ * steps, then puts the real one back.
+ *
+ * ```tsx
+ * await withReanimatedTimer(async () => {
+ *   await render(<Fading />)
+ *   advanceAnimationByTime(150)
+ *   expect(widget.getOpacity()).toBeCloseTo(0.5, 1)
+ * })
+ * ```
+ *
+ * Async bodies are supported, unlike upstream's — a test here has to await a
+ * render before there is anything to animate. Note that no frame is delivered
+ * while the body is awaiting: the clock only moves when the test moves it, so
+ * an `await` in the middle cannot let an animation slip forward.
+ */
+export declare const withReanimatedTimer: <T>(body: () => T) => T extends Promise<unknown> ? Promise<void> : void;
+/**
+ * Moves the test clock forward, delivering one animation frame per 1/60 s of
+ * it. Everything the frame writes has already happened when this returns —
+ * see the header for the one write that has not.
+ */
+export declare const advanceAnimationByTime: (timeMs?: number) => void;
+/** {@link advanceAnimationByTime} in whole frames. */
+export declare const advanceAnimationByFrame: (count?: number) => void;
+/** @internal Test seam: is a manual clock installed right now? */
+export declare const isTestClockInstalled: () => boolean;

package/dist/reanimated-compat/test-timers.js

@@ -0,0 +1,136 @@
+// Reanimated's test helpers: `withReanimatedTimer`, `advanceAnimationByTime`,
+// `advanceAnimationByFrame`.
+//
+// WHY THESE EXIST HERE AT ALL. An app ported to this platform brings its own
+// test suite, and a suite that tests animations cannot assert on one without
+// controlling time — otherwise every case is `sleep(400)` and a prayer, which
+// is the shape that produces the flaky test rather than the passing one.
+// Upstream solves it by faking the timers Jest owns and by emulating frames
+// on top of them. Nothing here is emulated: the frame driver every animation
+// on this platform runs on is this repo's own (src/components/
+// frame-scheduler.ts), so the honest version is to TAKE that driver for the
+// duration of a test and step it by hand. Real animations, real widget
+// writes, a clock the test owns.
+//
+// THE VIRTUAL CLOCK CONTINUES THE REAL ONE rather than starting at zero, so
+// an animation still in flight when the helper hands the driver back sees
+// time move forward, not backwards by half a century of monotonic
+// microseconds. Handing back is therefore "the rest of it runs at wall
+// speed", not "it jumps to the end".
+//
+// THE ONE THING THAT IS NOT SYNCHRONOUS, and it is the difference an app's
+// tests will notice: `opacity` is a direct widget call and lands inside
+// `advanceAnimationByTime()`, but a transform or a position goes through the
+// rect store plus `queueAllocate()`, and GTK does that allocation on its own
+// main loop. Assert those after yielding to the loop once (`await
+// act(async () => {})` in a @gtkx/testing test); assert opacity straight
+// away. `getAnimatedStyle` and `setUpTests` are refused for a related reason
+// — see the refusals in index.tsx.
+import { installFrameDriver, realFrameClock, } from "../components/frame-scheduler";
+/** 60 fps, which is upstream's default and this platform's frame budget. */
+const FRAME_MS = 1000 / 60;
+const createManualDriver = () => {
+    let clock = realFrameClock();
+    let pending = [];
+    const deliver = () => {
+        // Taken whole: a callback that re-books (which every running animation
+        // does) must land on the NEXT frame, not on this one, or a single
+        // advance() would run an animation to completion in one tick.
+        const batch = pending;
+        pending = [];
+        for (const entry of batch) {
+            if (!entry.cancelled) {
+                entry.callback(clock);
+            }
+        }
+    };
+    return {
+        now: () => clock,
+        schedule(callback) {
+            const entry = { callback, cancelled: false };
+            pending.push(entry);
+            return () => {
+                entry.cancelled = true;
+            };
+        },
+        advance(ms) {
+            let remaining = ms;
+            while (remaining > 0) {
+                const step = Math.min(FRAME_MS, remaining);
+                clock += step;
+                remaining -= step;
+                deliver();
+            }
+        },
+    };
+};
+let active = null;
+const requireActive = (api) => {
+    if (active === null) {
+        throw new Error(`react-native-reanimated: ${api}() only works inside withReanimatedTimer(), which is what installs the ` +
+            "test clock. Outside it there is nothing to advance — animations are running on the GLib main loop at " +
+            "wall speed. See docs/api.md.");
+    }
+    return active;
+};
+/**
+ * Runs `body` with the platform's frame driver replaced by one the test
+ * steps, then puts the real one back.
+ *
+ * ```tsx
+ * await withReanimatedTimer(async () => {
+ *   await render(<Fading />)
+ *   advanceAnimationByTime(150)
+ *   expect(widget.getOpacity()).toBeCloseTo(0.5, 1)
+ * })
+ * ```
+ *
+ * Async bodies are supported, unlike upstream's — a test here has to await a
+ * render before there is anything to animate. Note that no frame is delivered
+ * while the body is awaiting: the clock only moves when the test moves it, so
+ * an `await` in the middle cannot let an animation slip forward.
+ */
+export const withReanimatedTimer = (body) => {
+    if (active !== null) {
+        throw new Error("react-native-reanimated: withReanimatedTimer() is already active — nesting it would leave the second " +
+            "clock installed when the inner call returns.");
+    }
+    const driver = createManualDriver();
+    active = driver;
+    installFrameDriver(driver);
+    const restore = () => {
+        active = null;
+        installFrameDriver(null);
+    };
+    let result;
+    try {
+        result = body();
+    }
+    catch (error) {
+        restore();
+        throw error;
+    }
+    if (result instanceof Promise) {
+        return result.then(restore, (error) => {
+            restore();
+            throw error;
+        });
+    }
+    restore();
+    return undefined;
+};
+/**
+ * Moves the test clock forward, delivering one animation frame per 1/60 s of
+ * it. Everything the frame writes has already happened when this returns —
+ * see the header for the one write that has not.
+ */
+export const advanceAnimationByTime = (timeMs = FRAME_MS) => {
+    requireActive("advanceAnimationByTime").advance(timeMs);
+};
+/** {@link advanceAnimationByTime} in whole frames. */
+export const advanceAnimationByFrame = (count = 1) => {
+    requireActive("advanceAnimationByFrame").advance(count * FRAME_MS);
+};
+/** @internal Test seam: is a manual clock installed right now? */
+export const isTestClockInstalled = () => active !== null;
+//# sourceMappingURL=test-timers.js.map

package/dist/reanimated-compat/test-timers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-timers.js","sourceRoot":"","sources":["../../src/reanimated-compat/test-timers.ts"],"names":[],"mappings":"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","sourcesContent":["// Reanimated's test helpers: `withReanimatedTimer`, `advanceAnimationByTime`,\n// `advanceAnimationByFrame`.\n//\n// WHY THESE EXIST HERE AT ALL. An app ported to this platform brings its own\n// test suite, and a suite that tests animations cannot assert on one without\n// controlling time — otherwise every case is `sleep(400)` and a prayer, which\n// is the shape that produces the flaky test rather than the passing one.\n// Upstream solves it by faking the timers Jest owns and by emulating frames\n// on top of them. Nothing here is emulated: the frame driver every animation\n// on this platform runs on is this repo's own (src/components/\n// frame-scheduler.ts), so the honest version is to TAKE that driver for the\n// duration of a test and step it by hand. Real animations, real widget\n// writes, a clock the test owns.\n//\n// THE VIRTUAL CLOCK CONTINUES THE REAL ONE rather than starting at zero, so\n// an animation still in flight when the helper hands the driver back sees\n// time move forward, not backwards by half a century of monotonic\n// microseconds. Handing back is therefore \"the rest of it runs at wall\n// speed\", not \"it jumps to the end\".\n//\n// THE ONE THING THAT IS NOT SYNCHRONOUS, and it is the difference an app's\n// tests will notice: `opacity` is a direct widget call and lands inside\n// `advanceAnimationByTime()`, but a transform or a position goes through the\n// rect store plus `queueAllocate()`, and GTK does that allocation on its own\n// main loop. Assert those after yielding to the loop once (`await\n// act(async () => {})` in a @gtkx/testing test); assert opacity straight\n// away. `getAnimatedStyle` and `setUpTests` are refused for a related reason\n// — see the refusals in index.tsx.\nimport {\n  installFrameDriver,\n  realFrameClock,\n  type FrameDriver,\n} from \"../components/frame-scheduler\"\n\n/** 60 fps, which is upstream's default and this platform's frame budget. */\nconst FRAME_MS = 1000 / 60\n\ntype Pending = {\n  callback: (timeMs: number) => void\n  cancelled: boolean\n}\n\ntype ManualDriver = FrameDriver & {\n  /** Steps the clock, delivering one frame per elapsed frame interval. */\n  advance(ms: number): void\n}\n\nconst createManualDriver = (): ManualDriver => {\n  let clock = realFrameClock()\n  let pending: Pending[] = []\n\n  const deliver = (): void => {\n    // Taken whole: a callback that re-books (which every running animation\n    // does) must land on the NEXT frame, not on this one, or a single\n    // advance() would run an animation to completion in one tick.\n    const batch = pending\n    pending = []\n    for (const entry of batch) {\n      if (!entry.cancelled) {\n        entry.callback(clock)\n      }\n    }\n  }\n\n  return {\n    now: () => clock,\n    schedule(callback) {\n      const entry: Pending = { callback, cancelled: false }\n      pending.push(entry)\n      return () => {\n        entry.cancelled = true\n      }\n    },\n    advance(ms) {\n      let remaining = ms\n      while (remaining > 0) {\n        const step = Math.min(FRAME_MS, remaining)\n        clock += step\n        remaining -= step\n        deliver()\n      }\n    },\n  }\n}\n\nlet active: ManualDriver | null = null\n\nconst requireActive = (api: string): ManualDriver => {\n  if (active === null) {\n    throw new Error(\n      `react-native-reanimated: ${api}() only works inside withReanimatedTimer(), which is what installs the ` +\n        \"test clock. Outside it there is nothing to advance — animations are running on the GLib main loop at \" +\n        \"wall speed. See docs/api.md.\",\n    )\n  }\n  return active\n}\n\n/**\n * Runs `body` with the platform's frame driver replaced by one the test\n * steps, then puts the real one back.\n *\n * ```tsx\n * await withReanimatedTimer(async () => {\n *   await render(<Fading />)\n *   advanceAnimationByTime(150)\n *   expect(widget.getOpacity()).toBeCloseTo(0.5, 1)\n * })\n * ```\n *\n * Async bodies are supported, unlike upstream's — a test here has to await a\n * render before there is anything to animate. Note that no frame is delivered\n * while the body is awaiting: the clock only moves when the test moves it, so\n * an `await` in the middle cannot let an animation slip forward.\n */\nexport const withReanimatedTimer = <T>(\n  body: () => T,\n): T extends Promise<unknown> ? Promise<void> : void => {\n  if (active !== null) {\n    throw new Error(\n      \"react-native-reanimated: withReanimatedTimer() is already active — nesting it would leave the second \" +\n        \"clock installed when the inner call returns.\",\n    )\n  }\n  const driver = createManualDriver()\n  active = driver\n  installFrameDriver(driver)\n\n  const restore = (): void => {\n    active = null\n    installFrameDriver(null)\n  }\n\n  let result: T\n  try {\n    result = body()\n  } catch (error) {\n    restore()\n    throw error\n  }\n  if (result instanceof Promise) {\n    return result.then(restore, (error: unknown) => {\n      restore()\n      throw error\n    }) as T extends Promise<unknown> ? Promise<void> : void\n  }\n  restore()\n  return undefined as T extends Promise<unknown> ? Promise<void> : void\n}\n\n/**\n * Moves the test clock forward, delivering one animation frame per 1/60 s of\n * it. Everything the frame writes has already happened when this returns —\n * see the header for the one write that has not.\n */\nexport const advanceAnimationByTime = (timeMs = FRAME_MS): void => {\n  requireActive(\"advanceAnimationByTime\").advance(timeMs)\n}\n\n/** {@link advanceAnimationByTime} in whole frames. */\nexport const advanceAnimationByFrame = (count = 1): void => {\n  requireActive(\"advanceAnimationByFrame\").advance(count * FRAME_MS)\n}\n\n/** @internal Test seam: is a manual clock installed right now? */\nexport const isTestClockInstalled = (): boolean => active !== null\n"]}

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

@@ -0,0 +1,13 @@
+export declare const createThreads: () => {
+    runOnUI: <A extends unknown[]>(worklet: (...args: A) => unknown) => (...args: A) => void;
+    scheduleOnUI: <A extends unknown[]>(worklet: (...args: A) => unknown, ...args: A) => void;
+    runOnJS: <A extends unknown[]>(fn: (...args: A) => unknown) => (...args: A) => void;
+    scheduleOnRN: <A extends unknown[]>(fn: (...args: A) => unknown, ...args: A) => void;
+};
+/**
+ * True only for a function the Babel plugin actually processed, matching
+ * upstream's `__workletHash` check. Without the plugin — which is this
+ * platform's normal case, since it never runs Babel — nothing is a worklet,
+ * and nothing here needs one: a `"worklet"` directive is an inert string.
+ */
+export declare const isWorkletFunction: (value: unknown) => boolean;

package/dist/reanimated-compat/threads.js

@@ -0,0 +1,41 @@
+export const createThreads = () => {
+    // Everything queued in one tick runs in one batch, in order — the queue is
+    // read when the timer fires, so a job pushed later in the same tick still
+    // joins it.
+    let queue = [];
+    const scheduleOnUI = (worklet, ...args) => {
+        queue.push(() => {
+            worklet(...args);
+        });
+        if (queue.length === 1) {
+            setTimeout(() => {
+                const batch = queue;
+                queue = [];
+                for (const job of batch) {
+                    job();
+                }
+            }, 0);
+        }
+    };
+    const runOnUI = (worklet) => (...args) => {
+        scheduleOnUI(worklet, ...args);
+    };
+    const scheduleOnRN = (fn, ...args) => {
+        queueMicrotask(() => {
+            fn(...args);
+        });
+    };
+    const runOnJS = (fn) => (...args) => {
+        scheduleOnRN(fn, ...args);
+    };
+    return { runOnUI, scheduleOnUI, runOnJS, scheduleOnRN };
+};
+/**
+ * True only for a function the Babel plugin actually processed, matching
+ * upstream's `__workletHash` check. Without the plugin — which is this
+ * platform's normal case, since it never runs Babel — nothing is a worklet,
+ * and nothing here needs one: a `"worklet"` directive is an inert string.
+ */
+export const isWorkletFunction = (value) => typeof value === "function" &&
+    !!value.__workletHash;
+//# sourceMappingURL=threads.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"threads.js","sourceRoot":"","sources":["../../src/reanimated-compat/threads.ts"],"names":[],"mappings":"AA+CA,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,EAAE;IAChC,2EAA2E;IAC3E,0EAA0E;IAC1E,YAAY;IACZ,IAAI,KAAK,GAAU,EAAE,CAAA;IAErB,MAAM,YAAY,GAAG,CACnB,OAAgC,EAChC,GAAG,IAAO,EACJ,EAAE;QACR,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE;YACd,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;QAClB,CAAC,CAAC,CAAA;QACF,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,UAAU,CAAC,GAAG,EAAE;gBACd,MAAM,KAAK,GAAG,KAAK,CAAA;gBACnB,KAAK,GAAG,EAAE,CAAA;gBACV,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;oBACxB,GAAG,EAAE,CAAA;gBACP,CAAC;YACH,CAAC,EAAE,CAAC,CAAC,CAAA;QACP,CAAC;IACH,CAAC,CAAA;IAED,MAAM,OAAO,GACX,CAAsB,OAAgC,EAAE,EAAE,CAC1D,CAAC,GAAG,IAAO,EAAQ,EAAE;QACnB,YAAY,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAA;IAChC,CAAC,CAAA;IAEH,MAAM,YAAY,GAAG,CACnB,EAA2B,EAC3B,GAAG,IAAO,EACJ,EAAE;QACR,cAAc,CAAC,GAAG,EAAE;YAClB,EAAE,CAAC,GAAG,IAAI,CAAC,CAAA;QACb,CAAC,CAAC,CAAA;IACJ,CAAC,CAAA;IAED,MAAM,OAAO,GACX,CAAsB,EAA2B,EAAE,EAAE,CACrD,CAAC,GAAG,IAAO,EAAQ,EAAE;QACnB,YAAY,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAAA;IAC3B,CAAC,CAAA;IAEH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,CAAA;AACzD,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,KAAc,EAAW,EAAE,CAC3D,OAAO,KAAK,KAAK,UAAU;IAC3B,CAAC,CAAE,KAA4C,CAAC,aAAa,CAAA","sourcesContent":["// `runOnUI` / `runOnJS` — the thread hop, on a platform with one thread.\n//\n// The spike called these direct synchronous calls, on the reasoning that\n// GTK's main loop IS the JS thread so there is nowhere to schedule to. That\n// reasoning is right about the DESTINATION and wrong about the CONTRACT, and\n// the implementation corrects it: upstream's thread functions are\n// asynchronous, return void rather than the function's result, and code\n// written for Reanimated assumes they do NOT run inline —\n// `runOnJS(setState)()` inside a gesture callback is written expecting to\n// finish the callback first. Making them synchronous would re-enter in places\n// the author never allowed for.\n//\n// HOW MUCH LATER is the part that had to be corrected a second time, and it\n// is measured rather than reasoned (docs/research/dnd-hover-flicker.md).\n//\n// `scheduleOnUI` used to defer by a microtask AND a frame, copying\n// `react-native-worklets/src/threads.ts` — the file the web and\n// react-native-windows run, which posts through `requestAnimationFrame`. That\n// is the web's way of standing in for a UI runtime it has not got: rAF is the\n// only \"later\" a browser offers that lands in the frame it will paint. React\n// Native itself does no such thing. `scheduleOnUI` there posts to a real UI\n// thread, which picks the job up as soon as it is scheduled and does not wait\n// for a frame; nothing about the RN contract makes a UI hop cost a frame.\n//\n// The frame gate is not free here, because it is ASYMMETRIC: `scheduleOnRN`\n// is a microtask, so the round trip every Reanimated-shaped measurement makes\n// — `scheduleOnUI(measure)` then `scheduleOnRN(use it)` — cost one whole\n// frame. And a gesture callback on this platform runs per GdkEvent, not per\n// frame: GTK delivers motion as it arrives, so the next pan update reliably\n// beat the round trip it had just started. `react-native-reanimated-dnd`\n// re-registers its drop zones through exactly that round trip and re-reads\n// them from exactly that pan update, and lost the race on every hover change\n// — the drop zone strobed for as long as the pointer kept moving.\n//\n// So a UI hop is a TASK, not a frame. That keeps everything the contract\n// asks for and drops only the wait nothing asked for:\n//\n//   - still asynchronous, so nothing re-enters its caller;\n//   - still batched, so everything queued in one tick runs in one go, in\n//     order — two `runOnUI` calls cannot be split;\n//   - still LATER than `scheduleOnRN`'s microtask, so the relative order of a\n//     UI-ward and an RN-ward hop issued in the same tick is upstream's;\n//   - and it cannot starve the main loop, which a microtask could: a worklet\n//     that re-arms itself is a legitimate shape, and on a single-threaded\n//     platform a microtask loop would take GTK's paint and input with it.\ntype Job = () => void\n\nexport const createThreads = () => {\n  // Everything queued in one tick runs in one batch, in order — the queue is\n  // read when the timer fires, so a job pushed later in the same tick still\n  // joins it.\n  let queue: Job[] = []\n\n  const scheduleOnUI = <A extends unknown[]>(\n    worklet: (...args: A) => unknown,\n    ...args: A\n  ): void => {\n    queue.push(() => {\n      worklet(...args)\n    })\n    if (queue.length === 1) {\n      setTimeout(() => {\n        const batch = queue\n        queue = []\n        for (const job of batch) {\n          job()\n        }\n      }, 0)\n    }\n  }\n\n  const runOnUI =\n    <A extends unknown[]>(worklet: (...args: A) => unknown) =>\n    (...args: A): void => {\n      scheduleOnUI(worklet, ...args)\n    }\n\n  const scheduleOnRN = <A extends unknown[]>(\n    fn: (...args: A) => unknown,\n    ...args: A\n  ): void => {\n    queueMicrotask(() => {\n      fn(...args)\n    })\n  }\n\n  const runOnJS =\n    <A extends unknown[]>(fn: (...args: A) => unknown) =>\n    (...args: A): void => {\n      scheduleOnRN(fn, ...args)\n    }\n\n  return { runOnUI, scheduleOnUI, runOnJS, scheduleOnRN }\n}\n\n/**\n * True only for a function the Babel plugin actually processed, matching\n * upstream's `__workletHash` check. Without the plugin — which is this\n * platform's normal case, since it never runs Babel — nothing is a worklet,\n * and nothing here needs one: a `\"worklet\"` directive is an inert string.\n */\nexport const isWorkletFunction = (value: unknown): boolean =>\n  typeof value === \"function\" &&\n  !!(value as unknown as Record<string, unknown>).__workletHash\n"]}

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

@@ -0,0 +1,41 @@
+/**
+ * Something a mapper can depend on. Implemented by shared values; kept as an
+ * interface so this module never imports the mutable, which imports back.
+ */
+export type Trackable = {
+    __addMapper(mapper: Mapper): void;
+    __removeMapper(mapper: Mapper): void;
+};
+export type Mapper = {
+    /** Re-runs the body, re-collecting dependencies. */
+    run(): void;
+    /** Detaches from every dependency. Idempotent. */
+    dispose(): void;
+};
+/**
+ * Called by a shared value's getter. Outside a mapper run this is a no-op,
+ * which is what makes `sharedValue.value` in an event handler or a React
+ * render subscribe to nothing.
+ */
+export declare const trackRead: (source: Trackable) => void;
+/**
+ * Runs `body` with tracking suspended, so reads inside it register nothing.
+ *
+ * `useAnimatedReaction` needs this: upstream derives a mapper's inputs from
+ * the `prepare` worklet's closure ALONE, so a shared value that only the
+ * `react` side reads must not become a trigger. Dynamic tracking would
+ * otherwise be more eager than upstream rather than merely more precise.
+ */
+export declare const untracked: <T>(body: () => T) => T;
+/**
+ * Runs `body` under tracking and keeps it subscribed to exactly the shared
+ * values that run read — no more (a value dropped between runs is
+ * unsubscribed) and no less.
+ *
+ * Re-entrancy: a mapper that writes a value it also reads would recurse
+ * forever. The guard below drops the nested re-run rather than throwing,
+ * because the outer run is still in progress and is about to publish the
+ * newer value anyway — the observable result is the same as the last write
+ * winning, which is what a synchronous observer graph has to converge on.
+ */
+export declare const createMapper: (body: () => void) => Mapper;

package/dist/reanimated-compat/tracking.js

@@ -0,0 +1,106 @@
+// Dependency tracking for mappers — the one part of Reanimated that does NOT
+// collapse on a single-runtime platform. Something still has to re-run a
+// mapper when a shared value it reads is written.
+//
+// Upstream solves it STATICALLY: its Babel plugin emits a `__closure` object
+// listing everything the worklet captured, and `extractInputs` filters that
+// candidate list down to the shared values. With one runtime we can do it
+// DYNAMICALLY instead — record which shared values a mapper actually reads
+// while it runs. That is strictly more precise (a value read only on one
+// branch is tracked on the runs that take that branch, and dropped on the
+// runs that do not) and it needs no build step, which matters because this
+// platform never runs Babel: the vite path is rolldown, and the Metro path
+// uses the app's own stock preset.
+//
+// The whole mechanism is one module-level variable. There is no runtime and
+// no thread to schedule onto; a write is a synchronous function call that
+// walks its subscribers.
+// The mapper currently running, so a read of `.value` knows who to register.
+let activeMapper = null;
+/**
+ * Called by a shared value's getter. Outside a mapper run this is a no-op,
+ * which is what makes `sharedValue.value` in an event handler or a React
+ * render subscribe to nothing.
+ */
+export const trackRead = (source) => {
+    activeMapper?.dependencies.add(source);
+};
+/**
+ * Runs `body` with tracking suspended, so reads inside it register nothing.
+ *
+ * `useAnimatedReaction` needs this: upstream derives a mapper's inputs from
+ * the `prepare` worklet's closure ALONE, so a shared value that only the
+ * `react` side reads must not become a trigger. Dynamic tracking would
+ * otherwise be more eager than upstream rather than merely more precise.
+ */
+export const untracked = (body) => {
+    const previousMapper = activeMapper;
+    activeMapper = null;
+    try {
+        return body();
+    }
+    finally {
+        activeMapper = previousMapper;
+    }
+};
+/**
+ * Runs `body` under tracking and keeps it subscribed to exactly the shared
+ * values that run read — no more (a value dropped between runs is
+ * unsubscribed) and no less.
+ *
+ * Re-entrancy: a mapper that writes a value it also reads would recurse
+ * forever. The guard below drops the nested re-run rather than throwing,
+ * because the outer run is still in progress and is about to publish the
+ * newer value anyway — the observable result is the same as the last write
+ * winning, which is what a synchronous observer graph has to converge on.
+ */
+export const createMapper = (body) => {
+    let disposed = false;
+    let running = false;
+    const dependencies = new Set();
+    const mapper = {
+        dependencies,
+        run() {
+            if (disposed || running) {
+                return;
+            }
+            running = true;
+            const previousMapper = activeMapper;
+            const previousDependencies = new Set(dependencies);
+            activeMapper = mapper;
+            dependencies.clear();
+            try {
+                body();
+            }
+            finally {
+                activeMapper = previousMapper;
+                running = false;
+                // Diffed rather than resubscribed wholesale: a mapper that reads the
+                // same values every frame must not churn its subscriptions 60 times
+                // a second.
+                for (const dependency of dependencies) {
+                    if (!previousDependencies.has(dependency)) {
+                        dependency.__addMapper(mapper);
+                    }
+                }
+                for (const dependency of previousDependencies) {
+                    if (!dependencies.has(dependency)) {
+                        dependency.__removeMapper(mapper);
+                    }
+                }
+            }
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            for (const dependency of dependencies) {
+                dependency.__removeMapper(mapper);
+            }
+            dependencies.clear();
+        },
+    };
+    return mapper;
+};
+//# sourceMappingURL=tracking.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tracking.js","sourceRoot":"","sources":["../../src/reanimated-compat/tracking.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,yEAAyE;AACzE,kDAAkD;AAClD,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAC5E,0EAA0E;AAC1E,2EAA2E;AAC3E,yEAAyE;AACzE,0EAA0E;AAC1E,2EAA2E;AAC3E,2EAA2E;AAC3E,mCAAmC;AACnC,EAAE;AACF,4EAA4E;AAC5E,0EAA0E;AAC1E,yBAAyB;AAsBzB,6EAA6E;AAC7E,IAAI,YAAY,GAA0B,IAAI,CAAA;AAE9C;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,MAAiB,EAAQ,EAAE;IACnD,YAAY,EAAE,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;AACxC,CAAC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAI,IAAa,EAAK,EAAE;IAC/C,MAAM,cAAc,GAAG,YAAY,CAAA;IACnC,YAAY,GAAG,IAAI,CAAA;IACnB,IAAI,CAAC;QACH,OAAO,IAAI,EAAE,CAAA;IACf,CAAC;YAAS,CAAC;QACT,YAAY,GAAG,cAAc,CAAA;IAC/B,CAAC;AACH,CAAC,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,IAAgB,EAAU,EAAE;IACvD,IAAI,QAAQ,GAAG,KAAK,CAAA;IACpB,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,MAAM,YAAY,GAAG,IAAI,GAAG,EAAa,CAAA;IAEzC,MAAM,MAAM,GAAmB;QAC7B,YAAY;QACZ,GAAG;YACD,IAAI,QAAQ,IAAI,OAAO,EAAE,CAAC;gBACxB,OAAM;YACR,CAAC;YACD,OAAO,GAAG,IAAI,CAAA;YACd,MAAM,cAAc,GAAG,YAAY,CAAA;YACnC,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAA;YAClD,YAAY,GAAG,MAAM,CAAA;YACrB,YAAY,CAAC,KAAK,EAAE,CAAA;YACpB,IAAI,CAAC;gBACH,IAAI,EAAE,CAAA;YACR,CAAC;oBAAS,CAAC;gBACT,YAAY,GAAG,cAAc,CAAA;gBAC7B,OAAO,GAAG,KAAK,CAAA;gBACf,qEAAqE;gBACrE,oEAAoE;gBACpE,YAAY;gBACZ,KAAK,MAAM,UAAU,IAAI,YAAY,EAAE,CAAC;oBACtC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;wBAC1C,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;oBAChC,CAAC;gBACH,CAAC;gBACD,KAAK,MAAM,UAAU,IAAI,oBAAoB,EAAE,CAAC;oBAC9C,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;wBAClC,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;oBACnC,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO;YACL,IAAI,QAAQ,EAAE,CAAC;gBACb,OAAM;YACR,CAAC;YACD,QAAQ,GAAG,IAAI,CAAA;YACf,KAAK,MAAM,UAAU,IAAI,YAAY,EAAE,CAAC;gBACtC,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;YACnC,CAAC;YACD,YAAY,CAAC,KAAK,EAAE,CAAA;QACtB,CAAC;KACF,CAAA;IAED,OAAO,MAAM,CAAA;AACf,CAAC,CAAA","sourcesContent":["// Dependency tracking for mappers — the one part of Reanimated that does NOT\n// collapse on a single-runtime platform. Something still has to re-run a\n// mapper when a shared value it reads is written.\n//\n// Upstream solves it STATICALLY: its Babel plugin emits a `__closure` object\n// listing everything the worklet captured, and `extractInputs` filters that\n// candidate list down to the shared values. With one runtime we can do it\n// DYNAMICALLY instead — record which shared values a mapper actually reads\n// while it runs. That is strictly more precise (a value read only on one\n// branch is tracked on the runs that take that branch, and dropped on the\n// runs that do not) and it needs no build step, which matters because this\n// platform never runs Babel: the vite path is rolldown, and the Metro path\n// uses the app's own stock preset.\n//\n// The whole mechanism is one module-level variable. There is no runtime and\n// no thread to schedule onto; a write is a synchronous function call that\n// walks its subscribers.\n\n/**\n * Something a mapper can depend on. Implemented by shared values; kept as an\n * interface so this module never imports the mutable, which imports back.\n */\nexport type Trackable = {\n  __addMapper(mapper: Mapper): void\n  __removeMapper(mapper: Mapper): void\n}\n\nexport type Mapper = {\n  /** Re-runs the body, re-collecting dependencies. */\n  run(): void\n  /** Detaches from every dependency. Idempotent. */\n  dispose(): void\n}\n\ntype MapperInternal = Mapper & {\n  readonly dependencies: Set<Trackable>\n}\n\n// The mapper currently running, so a read of `.value` knows who to register.\nlet activeMapper: MapperInternal | null = null\n\n/**\n * Called by a shared value's getter. Outside a mapper run this is a no-op,\n * which is what makes `sharedValue.value` in an event handler or a React\n * render subscribe to nothing.\n */\nexport const trackRead = (source: Trackable): void => {\n  activeMapper?.dependencies.add(source)\n}\n\n/**\n * Runs `body` with tracking suspended, so reads inside it register nothing.\n *\n * `useAnimatedReaction` needs this: upstream derives a mapper's inputs from\n * the `prepare` worklet's closure ALONE, so a shared value that only the\n * `react` side reads must not become a trigger. Dynamic tracking would\n * otherwise be more eager than upstream rather than merely more precise.\n */\nexport const untracked = <T>(body: () => T): T => {\n  const previousMapper = activeMapper\n  activeMapper = null\n  try {\n    return body()\n  } finally {\n    activeMapper = previousMapper\n  }\n}\n\n/**\n * Runs `body` under tracking and keeps it subscribed to exactly the shared\n * values that run read — no more (a value dropped between runs is\n * unsubscribed) and no less.\n *\n * Re-entrancy: a mapper that writes a value it also reads would recurse\n * forever. The guard below drops the nested re-run rather than throwing,\n * because the outer run is still in progress and is about to publish the\n * newer value anyway — the observable result is the same as the last write\n * winning, which is what a synchronous observer graph has to converge on.\n */\nexport const createMapper = (body: () => void): Mapper => {\n  let disposed = false\n  let running = false\n  const dependencies = new Set<Trackable>()\n\n  const mapper: MapperInternal = {\n    dependencies,\n    run() {\n      if (disposed || running) {\n        return\n      }\n      running = true\n      const previousMapper = activeMapper\n      const previousDependencies = new Set(dependencies)\n      activeMapper = mapper\n      dependencies.clear()\n      try {\n        body()\n      } finally {\n        activeMapper = previousMapper\n        running = false\n        // Diffed rather than resubscribed wholesale: a mapper that reads the\n        // same values every frame must not churn its subscriptions 60 times\n        // a second.\n        for (const dependency of dependencies) {\n          if (!previousDependencies.has(dependency)) {\n            dependency.__addMapper(mapper)\n          }\n        }\n        for (const dependency of previousDependencies) {\n          if (!dependencies.has(dependency)) {\n            dependency.__removeMapper(mapper)\n          }\n        }\n      }\n    },\n    dispose() {\n      if (disposed) {\n        return\n      }\n      disposed = true\n      for (const dependency of dependencies) {\n        dependency.__removeMapper(mapper)\n      }\n      dependencies.clear()\n    },\n  }\n\n  return mapper\n}\n"]}

package/dist/reanimated-compat/updater-animations.d.ts

@@ -0,0 +1,36 @@
+import { type AnimationEngine } from "./animation";
+/** What an updater returns: a style object, or a props object. */
+export type UpdaterObject = Record<string, unknown>;
+export type UpdaterAnimations = {
+    /**
+     * Resolves `source`'s animations and publishes the result. Called from the
+     * mapper, so `source` is a fresh object every time.
+     */
+    run(source: UpdaterObject): void;
+    dispose(): void;
+};
+/**
+ * @param publish Receives the updater's object with every animated key
+ *   replaced by a number. Called once per mapper run and once per animation
+ *   frame.
+ * @param onSettled Called when an animation on `key` reaches its target on its
+ *   own (never when it is cancelled or replaced). The style layer uses it for
+ *   the properties it refuses to drive at frame rate, whose contract is that
+ *   the value lands on the next React render — without it, that promise is
+ *   only kept when something else happens to re-render.
+ * @param onLanding Called when `key`'s current value has to reach React
+ *   without its animation having reached a target. Two occasions: while an
+ *   animation runs, at most once per `LANDING_INTERVAL_MS` and only when the
+ *   value has moved far enough to change a committed layout (the cadence); and
+ *   when a plain number REPLACES a running animation, where upstream cancels
+ *   and snaps and a refused property cannot snap without a render. The snap is
+ *   deliberately not rate-limited — it is a state change rather than a step of
+ *   one, it happens once per mapper run that flips the key rather than once per
+ *   frame, and upstream pushes exactly the same number of `updateProps` for it.
+ *   Same job as `onSettled` and the same handling at the call site; it is a
+ *   separate callback because a settle and a value that has merely got to be
+ *   published are different claims, and only the first one is a promise kept.
+ *   Omit it and both cost nothing at all — a caller with no refused properties
+ *   (`useAnimatedProps`) does.
+ */
+export declare const createUpdaterAnimations: (engine: AnimationEngine, publish: (resolved: UpdaterObject) => void, onSettled?: (key: string) => void, onLanding?: (key: string) => void) => UpdaterAnimations;