refactor: added when method to stores

Author: jakobrosenberg

src/utils/specs/store.spec.js

@@ -147,10 +147,28 @@ test("can unsub self", () => {
   let received = null;
   const myStore = writable("initial");
   myStore.subscribe((val, unsub) => {
-    received = val
-    unsub()
-  })
+    received = val;
+    unsub();
+  });
   myStore.set("foo");
   myStore.set("bar");
-  assert.equal(received, 'foo');
+  assert.equal(received, "foo");
+});
+
+test("when", async () => {
+  let events = [];
+  const myStore = writable("initial");
+
+  const promise = myStore.when("resolve-me").then((r) => events.push(r));
+  assert.equal(myStore["_listeners"].length, 1);
+  assert.deepEqual(events, []);
+
+  myStore.set("foobar");
+  assert.deepEqual(events, []);
+  assert.equal(myStore["_listeners"].length, 1);
+
+  myStore.set("resolve-me");
+  await promise;
+  assert.deepEqual(events, ["resolve-me"]);
+  assert.equal(myStore["_listeners"].length, 0);
 });

src/utils/store.js

@@ -34,25 +34,26 @@ const storeOptions = {
  * @returns {Writable<T>}
  */
 const writable = (initialValue, options) => {
-  let _value = initialValue;
+  let _storeValue = initialValue;
   const listeners = [];
   const _options = { ...storeOptions, ...options };
 
   const store = {
-    get: () => _value,
+    _listeners: listeners,
+    get: () => _storeValue,
     /** @param {T} value */
     set: (value) => {
-      if (!_options.lazy || value !== _value) {
-        _value = value;
+      if (!_options.lazy || value !== _storeValue) {
+        _storeValue = value;
 
         for (const listener of [...listeners]) {
           const index = listeners.indexOf(listener);
           const unsub = () => listeners.splice(index, 1);
-          listener(_value, unsub);
+          listener(_storeValue, unsub);
         }
       }
     },
-    update: (callback) => store.set(callback(_value)),
+    update: (callback) => store.set(callback(_storeValue)),
     subscribe: (listener) => {
       if (!listeners.length) _options.onFirstSub(store);
       _options.onSub(store);
@@ -72,6 +73,21 @@ const writable = (initialValue, options) => {
         listener(value);
       });
     },
+    when: (expected, strict) =>
+      new Promise((resolve) => {
+        const matchesExpected = (value) => value === expected || (!strict && value == expected);
+        if (matchesExpected(_storeValue)) {
+          console.log("resolved");
+          resolve(_storeValue);
+        } else {
+          const unsub = store.subscribe((newValue) => {
+            if (matchesExpected(newValue)) {
+              unsub();
+              resolve(newValue);
+            }
+          });
+        }
+      }),
   };
   return store;
 };

types/store.js

@@ -11,6 +11,7 @@
  * @prop {function(function(T):T):void} update Update the store value
  * @prop {function((payload: T, unsub: Unsubscribe)=>void):Unsubscribe} subscribe Subscribe to the store value
  * @prop {function(function(T):void):void} next Subscribe to the store value for a single update
+ * @prop {(expected: T, strict?: boolean)=>Promise<T>} when Returns a promise which resolves when the store value matches the expected value
  */
 
 /**
@@ -39,4 +40,4 @@
 /**
  * @template T
  * @typedef {{ [K in keyof T]: T[K] extends Readable<infer U> ? U : never }} StoreValues
- */
+ */