Support nonReactive to avoid encouraging use of noContext (#510)

Author: benjamn

src/context.ts

@@ -1,7 +1,11 @@
 import { Slot } from "@wry/context";
 import { AnyEntry } from "./entry.js";
 
-export const parentEntrySlot = new Slot<AnyEntry>();
+export const parentEntrySlot = new Slot<AnyEntry | undefined>();
+
+export function nonReactive<R>(fn: () => R): R {
+  return parentEntrySlot.withValue(void 0, fn);
+}
 
 export {
   bind as bindContext,

src/index.ts

@@ -13,6 +13,7 @@ import { parentEntrySlot } from "./context.js";
 export {
   bindContext,
   noContext,
+  nonReactive,
   setTimeout,
   asyncFromGen,
 } from "./context.js";

src/tests/context.ts

@@ -1,5 +1,12 @@
+import { Slot } from "@wry/context";
 import * as assert from "assert";
-import { wrap, setTimeout, asyncFromGen, noContext } from '../index.js';
+import {
+  wrap,
+  setTimeout,
+  asyncFromGen,
+  noContext,
+  nonReactive,
+} from '../index.js';
 
 describe("asyncFromGen", function () {
   it("is importable", function () {
@@ -154,4 +161,48 @@ describe("noContext", function () {
     parent.dirty();
     assert.deepEqual(parent(), [4, 2]);
   });
-});
+});
+
+describe("nonReactive", function () {
+  const otherSlot = new Slot<string>();
+
+  it("censors only optimism-related context", function () {
+    let innerCounter = 0;
+    const inner = wrap(() => ++innerCounter);
+    const outer = wrap(() => ({
+      fromInner: nonReactive(() => inner()),
+      fromOther: nonReactive(() => otherSlot.getValue()),
+    }));
+    assert.strictEqual(otherSlot.getValue(), undefined);
+    otherSlot.withValue("preserved", () => {
+      assert.deepEqual(outer(), { fromInner: 1, fromOther: "preserved" });
+      assert.deepEqual(outer(), { fromInner: 1, fromOther: "preserved" });
+      inner.dirty();
+      assert.deepEqual(outer(), { fromInner: 1, fromOther: "preserved" });
+      assert.strictEqual(inner(), 2);
+      outer.dirty();
+      assert.deepEqual(outer(), { fromInner: 2, fromOther: "preserved" });
+    });
+    assert.strictEqual(otherSlot.getValue(), undefined);
+  });
+
+  it("same test using noContext, for comparison", function () {
+    let innerCounter = 0;
+    const inner = wrap(() => ++innerCounter);
+    const outer = wrap(() => ({
+      fromInner: noContext(inner),
+      fromOther: noContext(() => otherSlot.getValue()),
+    }));
+    assert.strictEqual(otherSlot.getValue(), undefined);
+    otherSlot.withValue("preserved", () => {
+      assert.deepEqual(outer(), { fromInner: 1, fromOther: void 0 });
+      assert.deepEqual(outer(), { fromInner: 1, fromOther: void 0 });
+      inner.dirty();
+      assert.deepEqual(outer(), { fromInner: 1, fromOther: void 0 });
+      assert.strictEqual(inner(), 2);
+      outer.dirty();
+      assert.deepEqual(outer(), { fromInner: 2, fromOther: void 0 });
+    });
+    assert.strictEqual(otherSlot.getValue(), undefined);
+  });
+});