querysub 0.174.0 → 0.176.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.174.0",
+  "version": "0.176.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -24,7 +24,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "preact": "^10.11.3",
-    "socket-function": "^0.121.0",
+    "socket-function": "^0.122.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.15.0",
     "yaml": "^2.5.0",

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -218,8 +218,8 @@ export type SyncWatcher = {
 
     dispose: () => void;
     disposed?: boolean;
-    // Reset every time the function is committed, so that inner callbacks can know when the dispose
-    //  happens, without having to dedupe their callback function.
+    // Reset every time the function is run, so this can be subscribed to every run, but will
+    //  only be called once the final commit.
     onInnerDisposed: (() => void)[];
     // Runs after any trigger happens (usually multiple triggers are required for a commit)
     onAfterTriggered: (() => void)[];
@@ -1082,6 +1082,8 @@ export class PathValueProxyWatcher {
 
             watcher.pendingAccesses.clear();
             watcher.pendingEpochAccesses.clear();
+            // IMPORTANT! Reset onInnerDisposed, so onCommitFinished doesn't result in a callback
+            //  per time we wan the watcher!
             watcher.onInnerDisposed = [];
 
             // NOTE: If runAtTime is undefined, the writeTime will be undefined, causing us to read the latest data.

package/src/4-querysub/Querysub.ts

@@ -388,6 +388,13 @@ export class Querysub {
         });
     }
 
+    public static afterAllRendersFinished(callback: () => void) {
+        // onCommitFinished prevents duplicates, as well as only running when we are actually done
+        Querysub.onCommitFinished(() => {
+            void clientWatcher.waitForTriggerFinished()?.finally(callback);
+        });
+    }
+
     /** Solely for use to prevent local writes from occuring before predictions. We MIGHT make this a framework thing,
      *      or just not bother with it (as after a prediction is run once the code will be loaded allowing it to always
      *      run before the next frame).

package/src/niceStringify.ts

@@ -0,0 +1,83 @@
+// true => ""
+// "" => JSON.stringify("")
+
+export const niceStringifyTrue = "";
+// Starting/ending with a JSON character means anything string that looks like this
+//  will be encoded like: `"{Nan`, and it is impossible for an object to serialize to look like this.
+export const niceStringifyNan = `{NaN}`;
+export const niceStringifyUndefined = `{Undefined}`;
+
+
+// BUG: This is actually broken for hex strings. Hex strings may sometimes be entirely numbers,
+//  which means they will randomly change type.
+function looksLikeJSON(str: string) {
+    return (
+        str === "null"
+        || str === "true"
+        || str === "false"
+        || str[0] === `"` && str[str.length - 1] === `"`
+        || str[0] === `[` && str[str.length - 1] === `]`
+        || str[0] === `{` && str[str.length - 1] === `}`
+        || (48 <= str.charCodeAt(0) && str.charCodeAt(0) <= 57)
+        || str.length > 1 && str[0] === "-" && (48 <= str.charCodeAt(1) && str.charCodeAt(1) <= 57)
+        || str === niceStringifyTrue
+        || str === niceStringifyUndefined
+    );
+}
+
+export function niceStringify(value: unknown): string {
+    if (value === undefined) {
+        return niceStringifyUndefined;
+    }
+    if (value === true) return niceStringifyTrue;
+    if (Number.isNaN(value)) return niceStringifyNan;
+
+    // Any strings that don't look like JSON, don't need to encoded as JSON, and can instead
+    //  just be stored as strings.
+    if (typeof value === "string" && !looksLikeJSON(value)) {
+        return value;
+    }
+
+
+    let str = JSON.stringify(value);
+    if (typeof value !== "object") {
+        let testParse = niceParse(str);
+        if (testParse !== value) {
+            console.log(`niceStringify did not reverse correctly. Should have received ${JSON.stringify(value)}, did received ${JSON.stringify(testParse)}`);
+            debugger;
+        }
+    }
+
+    return str;
+}
+
+export function niceParse(str: string | undefined, noSpecialTrue = false): unknown {
+    if (str === undefined) {
+        return undefined;
+    }
+    if (str === niceStringifyTrue && !noSpecialTrue) return true;
+    if (str === niceStringifyNan) return Number.NaN;
+    if (str === niceStringifyUndefined) return undefined;
+    if (str === "") return str;
+
+    if (looksLikeJSON(str)) {
+        try {
+            return JSON.parse(str);
+        } catch { }
+    }
+    return str;
+}
+
+/*
+
+function setFromUrlValue(key: string, valueJSON: string) {
+    if(isMaybeJSON(valueJSON)) {
+        try {
+            values[key] = JSON.parse(valueJSON);
+            return;
+        } catch { }
+    }
+    // Always set it, if it isn't JSON, just assume it is raw text.
+    values[key] = valueJSON;
+}
+*/