fix(native): subscribe a component's rule effect once it commits

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

@@ -2,8 +2,11 @@ import {
   cleanupEffect,
   family,
   observable,
+  observeReads,
+  recordReads,
   weakFamily,
   type Effect,
+  type Getter,
 } from "../../native/reactivity";
 
 test.each([0, false, "", null, undefined, NaN])(
@@ -58,7 +61,7 @@ test("computed dependencies follow a conditional branch even when its value is u
   const first = observable(10);
   const second = observable(10);
   const selected = observable(true);
-  const compute = jest.fn((get: import("../../native/reactivity").Getter) =>
+  const compute = jest.fn((get: Getter) =>
     get(selected) ? get(first) : get(second),
   );
   const value = observable(compute);
@@ -104,3 +107,134 @@ test("an explicit computed argument replaces its previous dependency", () => {
   cleanupEffect(subscriber);
   expect(second.observers.size).toBe(0);
 });
+
+test("a computed value read without a subscriber is computed once until a source changes", () => {
+  const source = observable(10);
+  const compute = jest.fn((get: Getter) => ({ doubled: get(source) * 2 }));
+  const value = observable(compute);
+  const first = value.get();
+  expect(value.get()).toBe(first);
+  expect(compute).toHaveBeenCalledTimes(1);
+  source.set(20);
+  expect(value.get()).toEqual({ doubled: 40 });
+  expect(compute).toHaveBeenCalledTimes(2);
+});
+
+test("a computed value whose computation threw computes again on its next read", () => {
+  const source = observable(0);
+  const value = observable((get) => {
+    const current = get(source);
+    if (current === 0) {
+      throw new Error("no value yet");
+    }
+    return current * 2;
+  });
+  expect(() => value.get()).toThrow("no value yet");
+  expect(() => value.get()).toThrow("no value yet");
+  source.set(5);
+  expect(value.get()).toBe(10);
+});
+
+test("a read without a subscriber subscribes nothing", () => {
+  const source = observable(10);
+  const value = observable((get) => get(source) * 2);
+  value.get();
+  expect(source.observers.size).toBe(0);
+  expect(value.observers.size).toBe(0);
+});
+
+test("a first subscriber keeps the value an unsubscribed read computed", () => {
+  const source = observable(10);
+  const compute = jest.fn((get: Getter) => ({ doubled: get(source) * 2 }));
+  const value = observable(compute);
+  const read = value.get();
+  const run = jest.fn();
+  const subscriber: Effect = { observers: new Set(), run };
+  expect(value.get(subscriber)).toBe(read);
+  expect(compute).toHaveBeenCalledTimes(1);
+  source.set(20);
+  expect(run).toHaveBeenCalledTimes(1);
+  expect(value.get(subscriber)).toEqual({ doubled: 40 });
+  cleanupEffect(subscriber);
+});
+
+test("a chain of computed values read without subscribers follows a change at its root", () => {
+  const root = observable(1);
+  const middle = observable((get) => get(root) + 1);
+  const leaf = observable((get) => get(middle) * 10);
+  expect(leaf.get()).toBe(20);
+  root.set(4);
+  expect(leaf.get()).toBe(50);
+  expect(root.observers.size).toBe(0);
+});
+
+test("a value released by its last subscriber is not computed again until a source changes", () => {
+  const source = observable(10);
+  const compute = jest.fn((get: Getter) => get(source) * 2);
+  const value = observable(compute);
+  const subscriber: Effect = { observers: new Set(), run: jest.fn() };
+  value.get(subscriber);
+  cleanupEffect(subscriber);
+  expect(value.get()).toBe(20);
+  expect(compute).toHaveBeenCalledTimes(1);
+  source.set(30);
+  expect(value.get()).toBe(60);
+  expect(compute).toHaveBeenCalledTimes(2);
+});
+
+test("an observable's version moves only when its value changes", () => {
+  const source = observable(1);
+  const parity = observable((get) => get(source) % 2);
+  const sourceVersion = source.version;
+  parity.get();
+  const parityVersion = parity.version;
+  source.set(1);
+  expect(source.version).toBe(sourceVersion);
+  source.set(3);
+  expect(source.version).not.toBe(sourceVersion);
+  parity.get();
+  expect(parity.version).toBe(parityVersion);
+  source.set(4);
+  parity.get();
+  expect(parity.version).not.toBe(parityVersion);
+});
+
+test("recorded reads subscribe nothing until a commit observes them", () => {
+  const source = observable(10);
+  const value = observable((get) => get(source) * 2);
+  const recorded = recordReads();
+  expect(recorded.read(value)).toBe(20);
+  expect(value.observers.size).toBe(0);
+  const subscriber: Effect = { observers: new Set(), run: jest.fn() };
+  expect(observeReads(subscriber, recorded.reads)).toBe("unmoved");
+  expect(value.observers.has(subscriber)).toBe(true);
+  cleanupEffect(subscriber);
+});
+
+test("observing recorded reads answers moved for a change since the read", () => {
+  const source = observable(10);
+  const value = observable((get) => get(source) * 2);
+  const recorded = recordReads();
+  recorded.read(value);
+  source.set(30);
+  const run = jest.fn();
+  const subscriber: Effect = { observers: new Set(), run };
+  expect(observeReads(subscriber, recorded.reads)).toBe("moved");
+  expect(run).not.toHaveBeenCalled();
+  cleanupEffect(subscriber);
+});
+
+test("observing recorded reads releases what the effect observed and the commit no longer read", () => {
+  const first = observable(1);
+  const second = observable(2);
+  const subscriber: Effect = { observers: new Set(), run: jest.fn() };
+  const before = recordReads();
+  before.read(first);
+  observeReads(subscriber, before.reads);
+  const after = recordReads();
+  after.read(second);
+  observeReads(subscriber, after.reads);
+  expect(first.observers.size).toBe(0);
+  expect(second.observers.has(subscriber)).toBe(true);
+  cleanupEffect(subscriber);
+});