socket-function 0.8.9 → 0.8.12

package/mobx/promiseToObservable.tsx

@@ -6,7 +6,9 @@ export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefi
     let error: unknown;
     let result: T | undefined;
 
-    let isDoneTrigger = observable({ value: false });
+    let isDoneTrigger = observable({
+        value: false
+    });
     promise.then(
         r => {
             result = r;
@@ -32,21 +34,53 @@ export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefi
     };
 }
 
-export function cacheLimitedAsyncObservable<Output, Key>(maxCount: number, getValue: (key: Key) => Promise<Output>): {
+export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: Key) => Promise<Output>): {
     (key: Key): Output | undefined;
     invalidate(key: Key): void;
+    invalidateAll(): void;
 } {
-    let cache = cacheLimited(maxCount, (keyJSON: string) => {
-        let key = keyJSON ? JSON.parse(keyJSON) : keyJSON;
-        // We call inside another function so that synchronous errors still get wrapped in the observable
-        let value = (async () => getValue(key))();
-        return promiseToObservable(value);
-    });
+    // 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 startingCalculating = new Set<string>();
+    let values = new Map<string, { value: Output | undefined }>();
+
     get["invalidate"] = (key: Key) => {
-        cache.invalidate(JSON.stringify(key));
+        let hash = JSON.stringify(key);
+        let value = values.get(hash);
+        if (!value) return;
+        values.delete(hash);
+        startingCalculating.delete(hash);
+        invalidateSeqNum.seqNum++;
+    };
+    get["invalidateAll"] = () => {
+        startingCalculating.clear();
+        values.clear();
+        invalidateSeqNum.seqNum++;
     };
     function get(key: Key) {
-        return cache(JSON.stringify(key)).value;
+        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);
+
+        // 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;
     }
     return get;
 }

package/package.json

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

package/src/caching.ts

@@ -64,17 +64,10 @@ export function cacheLimited<Output, Key>(
     //  calculating, keeping a consistent output can save (a considerable amount of) time in downstream caches.
     maxCount: number,
     getValue: (key: Key) => Output
-): {
-    (key: Key): Output;
-    invalidate(key: Key): void;
-} {
+): (key: Key) => Output {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
-    get["invalidate"] = (key: Key) => {
-        values.delete(key);
-        startingCalculating.delete(key);
-    };
-    function get(input: Key) {
+    return (input) => {
         let key = input;
         if (values.has(key)) {
             return values.get(key) as any;
@@ -98,8 +91,7 @@ export function cacheLimited<Output, Key>(
         let value = getValue(input);
         values.set(key, value);
         return value;
-    }
-    return get;
+    };
 }
 
 export function cacheWeak<Output, Key extends object>(getValue: (key: Key) => Output): (key: Key) => Output {