added store.enterWith()

Signed-off-by: Matteo Collina <[email protected]>

README.md

@@ -50,6 +50,13 @@ create(() => {
         console.log('b', b())
       })
     })
+
+    setImmediate(() => {
+      store.enterWith()
+      console.log('-- fourth event loop turn --')
+      console.log('a', a())
+      console.log('b', b())
+    })
   })
 })
 ```
@@ -59,25 +66,25 @@ create(() => {
 You can call the `asyncforge` functions in a type-safe way:
 
 ```ts
-import { start, memo, setAll } from "asyncforge";
+import { create, memo } from "asyncforge";
 const memoNum = memo<number>();
+const test = memo<string>();
 
-// This is okay for TypeScript, since you're passing a number
-memoNum.set(123);
-
-// This will not build
-memoNum.set('wrong');
+const store = create()
 
-// The `result` var will be of type `number`
-const result = memoNum()
+store.run(() => {
+  // This is okay for TypeScript, since you're passing a number
+  memoNum.set(123);
 
-const test = memo<string>();
 
-// This is correct, since `test.key` is a `symbol`
-setAll({ [test.key]: 42 });
+  // This will not build
+  memoNum.set('wrong');
+})
 
-// This will fail
-setAll({ 'wrong': 42 });
+store.run(() => {
+  // The `result` var will be of type `number`
+  const result = memoNum()
+})
 ```
 
 ## License

asyncforge.d.ts

@@ -1,6 +1,7 @@
 declare namespace asyncforge {
   interface Store {
     run<T>(fn: () => T) : T;
+    enterWith() : void;
   }
 
   export function create () : Store;

asyncforge.js

@@ -14,6 +14,10 @@ class Store {
   run (fn) {
     return asyncLocalStorage.run(this.#internal, fn)
   }
+
+  enterWith () {
+    asyncLocalStorage.enterWith(this.#internal)
+  }
 }
 
 function create (fn) {

asyncforge.test-d.ts

@@ -7,6 +7,7 @@ expectType<() => Store>(create);
 const store = create();
 
 expectType<number>(store.run(() => 42));
+expectType<void>(store.enterWith());
 
 // memo
 const memoNum = memo<number>();

example.mjs

@@ -34,5 +34,12 @@ create(() => {
         console.log('b', b())
       })
     })
+
+    setImmediate(() => {
+      store.enterWith()
+      console.log('-- fourth event loop turn --')
+      console.log('a', a())
+      console.log('b', b())
+    })
   })
 })

test/memo.test.js

@@ -116,3 +116,27 @@ test('run multiple times', async (t) => {
 
   await p.completed
 })
+
+test('enterWith', async (t) => {
+  const p = tspl(t, { plan: 5 })
+  const a = memo()
+
+  p.throws(a, /asyncforge store has not been created/)
+  p.throws(() => a.set('foo'), /asyncforge store has not been created/)
+
+  create().enterWith()
+
+  p.deepStrictEqual(a(), undefined)
+  a.set({ value: 'bar' })
+  p.deepStrictEqual(a(), { value: 'bar' })
+
+  setImmediate(() => {
+    p.deepStrictEqual(a(), { value: 'bar' })
+  })
+
+  queueMicrotask(() => {
+    p.deepStrictEqual(a(), { value: 'bar' })
+  })
+
+  await p.completed
+})