socket-function 0.8.15 → 0.8.16

package/mobx/promiseToObservable.tsx

@@ -39,11 +39,12 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
     invalidate(key: Key): void;
     invalidateAll(): void;
 } {
-    // NOTE: Not very efficient (invalidates too much), but... makes triggering invalidations much faster/easier,
-    //  making an invalidate depend on the total render time, not the total cached state size.
-    let invalidateSeqNum = observable({ seqNum: 1 }, undefined, { deep: false, proxy: false });
+    let invalidateAllSeqNum = observable({ seqNum: 1 }, undefined, { deep: false, proxy: false });
     let startingCalculating = new Set<string>();
-    let values = new Map<string, { value: Output | undefined }>();
+    let values = new Map<string, {
+        valueObs: { value: Output | undefined };
+        seqNum: { value: number };
+    }>();
 
     get["invalidate"] = (key: Key) => {
         let hash = JSON.stringify(key);
@@ -51,37 +52,43 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
         if (!value) return;
         values.delete(hash);
         startingCalculating.delete(hash);
-        invalidateSeqNum.seqNum++;
+        value.seqNum.value++;
     };
     get["invalidateAll"] = () => {
         startingCalculating.clear();
         values.clear();
-        invalidateSeqNum.seqNum++;
+        invalidateAllSeqNum.seqNum++;
     };
     function get(key: Key) {
-        invalidateSeqNum.seqNum;
+
         let hash = JSON.stringify(key);
         let value = values.get(hash);
-        if (value) {
-            return value.value;
-        }
-        if (startingCalculating.has(hash)) {
-            throw new Error(`Cyclic access in cache`);
-        }
-        startingCalculating.add(hash);
+        if (!value) {
 
-        // Not very efficient, but clearing the entire state is a lot easier to do then
-        //  keep track of the order they are accessed (and it does make MOST accesses
-        //  MUCH faster).
-        if (values.size >= maxCount) {
-            values.clear();
-            startingCalculating.clear();
-        }
+            if (startingCalculating.has(hash)) {
+                throw new Error(`Cyclic access in cache`);
+            }
+            startingCalculating.add(hash);
+
+            // Not very efficient, but clearing the entire state is a lot easier to do then
+            //  keep track of the order they are accessed (and it does make MOST accesses
+            //  MUCH faster).
+            if (values.size >= maxCount) {
+                values.clear();
+                startingCalculating.clear();
+            }
 
-        // We call inside another function so that synchronous errors still get wrapped in the observable
-        value = promiseToObservable((async () => getValue(key))());
-        values.set(hash, value);
-        return value.value;
+            // We call inside another function so that synchronous errors still get wrapped in the observable
+            let valueObs = promiseToObservable((async () => getValue(key))());
+            value = {
+                valueObs,
+                seqNum: observable({ value: 1 }, undefined, { deep: false, proxy: false }),
+            };
+            values.set(hash, value);
+        }
+        invalidateAllSeqNum.seqNum;
+        value.seqNum.value;
+        return value.valueObs.value;
     }
     return get;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.8.15",
+	"version": "0.8.16",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {