querysub 0.431.0 → 0.433.0

package/src/0-path-value-core/pathValueCore.ts

@@ -14,7 +14,7 @@ import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSeriali
 import { AuthoritySpec, PathRouter } from "./PathRouter";
 import { formatTime } from "socket-function/src/formatting/format";
 import { isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
-import { PromiseRace } from "../../src/misc/PromiseRace";
+import { PromiseRace } from "socket-function/src/PromiseRace";
 
 import yargs from "yargs";
 import { PromiseObj } from "../promise";

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -554,6 +554,7 @@ export class PathValueProxyWatcher {
     public getCallbackPathValue = (pathStr: string, syncParentKeys?: "parentKeys"): PathValue | undefined => {
         const watcher = this.runningWatcher;
         if (!watcher) {
+            debugger;
             throw new Error(`Tried to get path "${pathStr}" outside of a watcher function.`);
         }
 
@@ -652,6 +653,7 @@ export class PathValueProxyWatcher {
         }
         const watcher = this.runningWatcher;
         if (!watcher) {
+            debugger;
             throw new Error(`Tried to get path "${pathStr}" outside of a watcher function.`);
         }
 
@@ -762,6 +764,7 @@ export class PathValueProxyWatcher {
             if (lastPart.startsWith("__") || lastPart === "type") {
                 return;
             }
+            debugger;
             throw new Error(`Tried to set path "${pathStr}" outside of a watcher function.`);
         }
         if (!watcher.options.canWrite) {
@@ -899,6 +902,7 @@ export class PathValueProxyWatcher {
 
         const watcher = this.runningWatcher;
         if (!watcher) {
+            debugger;
             throw new Error(`Tried to getKeys on path "${pathStr}" outside of a watcher function.`);
         }
 

package/src/2-proxy/schema2.ts

@@ -22,7 +22,7 @@ function example() {
     };
 }
 
-type TypeDefType<T = never, Optional = false> = {
+export type TypeDefType<T = never, Optional = false> = {
 
     /** A passthrough to strip the type wrapper for qreact.state,
      *      or for piecing together schemas.

package/src/3-path-functions/pathFunctionLoader.ts

@@ -208,6 +208,10 @@ async function tryGetFileLock(file: string) {
         if (lastHeartbeat > expiryTime) return false;
     } catch { }
     let heartbeatWrite = Date.now() + "-" + nextId();
+    let dir = path.dirname(file);
+    if (!fs.existsSync(dir)) {
+        await fs.promises.mkdir(dir, { recursive: true });
+    }
     await fs.promises.writeFile(file, heartbeatWrite);
     await delay(lockCheckTime);
     let readBack = await fs.promises.readFile(file, "utf8");

package/src/4-querysub/Querysub.ts

@@ -4,8 +4,8 @@
 import "../inject";
 
 // Shim Promise.race, as no one wants their promises to leak...
-import { promiseRace } from "socket-function/src/promiseRace";
-Promise.race = promiseRace;
+import { PromiseRace } from "socket-function/src/promiseRace";
+Promise.race = PromiseRace;
 
 import { shimDateNow } from "socket-function/time/trueTimeShim";
 shimDateNow();
@@ -378,6 +378,7 @@ export class Querysub {
     public static fastReadAsync<T>(fnc: () => T, options?: Partial<WatcherOptions<T>>) {
         return Querysub.serviceWrite(fnc, { ...options, allowProxyResults: true, noWaitForCommit: true });
     }
+    public static readLocal = Querysub.localRead;
     public static localRead<T>(fnc: () => T, options?: Partial<WatcherOptions<T>>) {
         return proxyWatcher.runOnce({
             watchFunction: fnc,

package/src/misc/PromiseRace.ts

@@ -1,101 +0,0 @@
-/** Fixed Promise.race, which doesn't leak promises values. Promises still leak, but a Promise is < 100 bytes,
- *      where as the promise value might be huge.
- */
-export function PromiseRace<T extends any[]>(promises: { [K in keyof T]: Promise<T[K]> }): Promise<T[number]> {
-    return new PromiseLessLeaky((resolve: any, reject: any) => {
-        function onFinally() {
-            for (let promise of promises) {
-                if (promise && typeof promise === "object" && promise instanceof Promise) {
-                    let callbackObj = promiseCallbacks.get(promise);
-                    if (!callbackObj) continue;
-                    remove(callbackObj.onResolve, resolve);
-                    remove(callbackObj.onReject, reject);
-                    remove(callbackObj.onFinally, onFinally);
-                }
-            }
-        }
-        for (let promise of promises) {
-            // NOTE: This "if" statement greatly reduce leaks, although it might
-            //  reduce speed as well?
-            if (promise && typeof promise === "object" && promise instanceof Promise) {
-                let callbackObj = promiseCallbacks.get(promise);
-                if (!callbackObj) {
-                    callbackObj = {
-                        onResolve: [],
-                        onReject: [],
-                        onFinally: [],
-                    };
-                    promiseCallbacks.set(promise, callbackObj);
-                    connectPromiseToCallbackObj(promise, callbackObj);
-                }
-                callbackObj.onResolve.push(resolve);
-                callbackObj.onReject.push(reject);
-                callbackObj.onFinally.push(onFinally);
-                continue;
-            }
-
-            Promise.resolve(promise).then(resolve, reject);
-        }
-    }) as any;
-}
-
-// Less leaky promise.
-//  See https://github.com/nodejs/node/issues/17469
-//  See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-// Basically, make resolve/reject weakly reference the Promise, so that
-//  resolved promises aren't kept alive. The `resolve` function is still leaked
-//  itself, but at least it doesn't leak the underlying data.
-// IMPORTANT! This still leaks! So... maybe don't even use Promise.race?
-class PromiseLessLeaky extends Promise<any> {
-    constructor(executor: any) {
-        super((resolve, reject) => {
-            executor(
-                function PromiseLessLeakyResolved(value: any) {
-                    let callback = resolve;
-                    resolve = undefined as any;
-                    reject = undefined as any;
-                    if (callback) {
-                        callback(value);
-                    }
-                },
-                function PromiseLessLeakyRejected(value: any) {
-                    let callback = reject;
-                    resolve = undefined as any;
-                    reject = undefined as any;
-                    if (callback) {
-                        callback(value);
-                    }
-                }
-            );
-            executor = undefined;
-        });
-    }
-}
-function remove(list: any, value: any) {
-    let index = list.indexOf(value);
-    if (index >= 0) {
-        list.splice(index, 1);
-    }
-}
-const promiseCallbacks = new WeakMap();
-
-function connectPromiseToCallbackObj(promise: any, callbackObj: any) {
-    // NOTE: If the promise stays alive forever... this will leak callbackObj. BUT,
-    //  it is only called once per promise, ever, so... the leak isn't so bad!
-    promise.then(
-        (value: any) => {
-            for (let fnc of callbackObj.onResolve) {
-                try { fnc(value); } finally { }
-            }
-        },
-        (value: any) => {
-            for (let fnc of callbackObj.onReject) {
-                try { fnc(value); } finally { }
-            }
-        }
-    ).finally(() => {
-        for (let fnc of callbackObj.onFinally) {
-            try { fnc(); } finally { }
-        }
-    });
-}