socket-function 0.8.8 → 0.8.11

package/mobx/promiseToObservable.tsx

@@ -1,4 +1,5 @@
 import { observable, Reaction, IObservable } from "mobx";
+import { cacheLimited } from "../src/caching";
 
 export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefined } {
     let isDone = false;
@@ -29,4 +30,25 @@ export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefi
             return undefined;
         }
     };
+}
+
+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);
+    });
+    get["invalidate"] = (key: Key) => {
+        cache.invalidate(JSON.stringify(key));
+    };
+    get["invalidateAll"] = () => cache.invalidateAll();
+    function get(key: Key) {
+        return cache(JSON.stringify(key)).value;
+    }
+    return get;
 }

package/package.json

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

package/src/caching.ts

@@ -64,10 +64,22 @@ 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 {
+): {
+    (key: Key): Output;
+    invalidate(key: Key): void;
+    invalidateAll(): void;
+} {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
-    return (input) => {
+    get["invalidate"] = (key: Key) => {
+        values.delete(key);
+        startingCalculating.delete(key);
+    };
+    get["invalidateAll"] = () => {
+        values.clear();
+        startingCalculating.clear();
+    };
+    function get(input: Key) {
         let key = input;
         if (values.has(key)) {
             return values.get(key) as any;
@@ -91,7 +103,8 @@ 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 {