socket-function 0.8.19 → 0.8.21

package/mobx/promiseToObservable.tsx

@@ -1,16 +1,22 @@
 import { observable, Reaction, IObservable } from "mobx";
 import { cacheLimited } from "../src/caching";
 
-export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefined } {
+export interface InternalResult {
+    result: { value: unknown } | undefined;
+}
+export function promiseToObservable<T>(promise: Promise<T>, staleValue?: T): { value: T | undefined } {
     let isDone = false;
     let error: unknown;
     let result: T | undefined;
 
+    let internalResult: InternalResult = { result: undefined };
+
     let isDoneTrigger = observable({
         value: false
     });
     promise.then(
         r => {
+            internalResult.result = { value: r };
             result = r;
             isDoneTrigger.value = true;
             isDone = true;
@@ -22,73 +28,14 @@ export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefi
         }
     );
 
-    return {
+    return Object.assign({
         get value() {
             if (isDone) {
                 if (error) throw error;
                 return result;
             }
             isDoneTrigger.value;
-            return undefined;
+            return staleValue;
         }
-    };
+    }, { internalResult });
 }
-
-export function asyncObservable<Output, Args extends any[]>(maxCount: number, getValue: (...args: Args) => Promise<Output>): {
-    (...args: Args): Output | undefined;
-    invalidate(...args: Args): void;
-    invalidateAll(): void;
-} {
-    let invalidateAllSeqNum = observable({ seqNum: 1 }, undefined, { deep: false, proxy: false });
-    let startingCalculating = new Set<string>();
-    let values = new Map<string, {
-        valueObs: { value: Output | undefined };
-        seqNum: { value: number };
-    }>();
-
-    get["invalidate"] = (...args: Args) => {
-        let hash = JSON.stringify(args);
-        let value = values.get(hash);
-        if (!value) return;
-        values.delete(hash);
-        startingCalculating.delete(hash);
-        value.seqNum.value++;
-    };
-    get["invalidateAll"] = () => {
-        startingCalculating.clear();
-        values.clear();
-        invalidateAllSeqNum.seqNum++;
-    };
-    function get(...args: Args) {
-
-        let hash = JSON.stringify(args);
-        let value = values.get(hash);
-        if (!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
-            let valueObs = promiseToObservable((async () => getValue(...args))());
-            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.19",
+	"version": "0.8.21",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {