fix(native): re-run an effect a batch notifies twice, and release a style entry by identity

A batch collected notified effects in a Set and iterated it, which skips a
member added again after it ran. On a rotation, an entry that reads a
viewport unit before a :root variable another entry shares runs before the
variable recomputes, and the variable's notification then lands on a member
already passed, so the element keeps the previous orientation's value.
batch() deletes each effect before running it, so a second notification
queues it again; the Dimensions listener and StyleCollection.inject both
open their batch through it.

A style entry deleted its hash from the cache once its last observer left,
whatever entry the hash mapped to by then. React replays effects under
StrictMode and when an Activity is shown again: the replay acquires a fresh
entry for the hash and then releases the old one, which deleted the fresh
entry. family.deleteIf deletes a key only while it maps to the given value,
and an entry releases through it.

The tests also cover the release itself: an entry goes when its last element
unmounts, survives while shared, stays reactive while mounted, and the cache
returns to empty after repeated mounts.

Author: YevheniiKotyrlo

src/__tests__/native/batch.test.tsx

@@ -0,0 +1,93 @@
+import { Dimensions } from "react-native";
+
+import { act, render, screen } from "@testing-library/react-native";
+import { View } from "react-native-css/components/View";
+import { registerCSS } from "react-native-css/jest";
+
+import { batch, observable, type Effect } from "../../native/reactivity";
+
+jest.mock("react-native", () => {
+  const RN = jest.requireActual("react-native");
+  RN.Platform.OS = "ios";
+  return RN as unknown;
+});
+
+const rotate = (width: number) => {
+  act(() => {
+    const metrics = { width, height: 800, scale: 2, fontScale: 1 };
+    Dimensions.set({ window: metrics, screen: metrics });
+  });
+};
+
+const effectRecording = (record: () => void): Effect => ({
+  observers: new Set(),
+  run: record,
+});
+
+test.each([
+  ["before", ".a { width: 10vw; color: var(--c); }"],
+  ["after", ".a { color: var(--c); width: 10vw; }"],
+])(
+  "a rotation reaches an element reading a viewport unit %s a shared width-dependent variable",
+  (_, rule) => {
+    registerCSS(`
+      :root { --c: blue; }
+      @media (min-width: 500px) { :root { --c: red; } }
+      ${rule}
+      .b { color: var(--c); }
+    `);
+    rotate(300);
+    render(
+      <>
+        <View testID="a" className="a" />
+        <View testID="b" className="b" />
+      </>,
+    );
+
+    for (const [width, color] of [
+      [700, "red"],
+      [300, "blue"],
+      [700, "red"],
+    ] as const) {
+      rotate(width);
+      expect(screen.getByTestId("a")).toHaveStyle({ width: width / 10, color });
+      expect(screen.getByTestId("b")).toHaveStyle({ color });
+    }
+  },
+);
+
+test("an effect notified again while the batch drains runs again", () => {
+  const source = observable(1);
+  const derived = observable((read) => read(source) * 10);
+  const seen: string[] = [];
+  const subscriber = effectRecording(() => {
+    seen.push(`${source.get()},${derived.get()}`);
+  });
+
+  source.get(subscriber);
+  derived.get(subscriber);
+  batch(() => {
+    source.set(2);
+  });
+
+  expect(seen.at(-1)).toBe("2,20");
+});
+
+test("a batch defers every notification until its update returns, and runs each effect once", () => {
+  const width = observable(1);
+  const height = observable(1);
+  let runs = 0;
+  const subscriber = effectRecording(() => {
+    runs += 1;
+  });
+
+  width.get(subscriber);
+  height.get(subscriber);
+  batch(() => {
+    width.set(2);
+    height.set(2);
+    expect(runs).toBe(0);
+  });
+
+  expect(runs).toBe(1);
+});

src/__tests__/native/reactivity-dependencies.test.tsx

@@ -104,3 +104,35 @@ test("an explicit computed argument replaces its previous dependency", () => {
   cleanupEffect(subscriber);
   expect(second.observers.size).toBe(0);
 });
+
+test("an observed computed value runs once per change, not once per read", () => {
+  const source = observable(1);
+  let computed = 0;
+  const value = observable<number>((get) => {
+    computed += 1;
+    return get(source) * 2;
+  });
+  const subscriber: Effect = { observers: new Set(), run: jest.fn() };
+
+  for (let read = 0; read < 20; read += 1) {
+    expect(value.get(subscriber)).toBe(2);
+  }
+  expect(computed).toBe(1);
+
+  source.set(5);
+  expect(value.get(subscriber)).toBe(10);
+  expect(computed).toBe(2);
+});
+
+test("a family deletes a key by value only while the key still maps to it", () => {
+  const cached = family((key: string) => ({ key }));
+  const original = cached("shared");
+  cached.delete("shared");
+  const replacement = cached("shared");
+
+  expect(cached.deleteIf("shared", original)).toBe(false);
+  expect(cached("shared")).toBe(replacement);
+
+  expect(cached.deleteIf("shared", replacement)).toBe(true);
+  expect(cached.size()).toBe(0);
+});