querysub 0.341.0 → 0.343.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.341.0",
+  "version": "0.343.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1071,7 +1071,7 @@ export class PathValueProxyWatcher {
             let runLeeway = MAX_ACCEPTED_CHANGE_AGE * 0.8;
             let runCutoffTime = Date.now() - runLeeway;
             if (options.runAtTime && options.runAtTime.time < runCutoffTime) {
-                let message = `MAX_CHANGE_AGE_EXCEEDED! Cannot run watcher at time ${options.runAtTime.time} because it is older than the cutOff time of ${runCutoffTime}. Writing this far in the past would break things, and might be rejected by other authorities due to being too old.`;
+                let message = `MAX_CHANGE_AGE_EXCEEDED! Cannot run watcher ${options.debugName} at time ${options.runAtTime.time} because it is older than the cutOff time of ${runCutoffTime}. Writing this far in the past would break things, and might be rejected by other authorities due to being too old.`;
                 console.error(red(message));
                 // NOTE: We could also adjust the to be more recent, to allow it to be commited anyway,
                 //  in a slightly different state than originally expected.
@@ -1181,9 +1181,6 @@ export class PathValueProxyWatcher {
         };
         const getReadyToCommit = () => {
             let blocked = isProxyBlockedByOrder(watcher);
-            if (blocked) {
-                console.info(`Proxy ${watcher.debugName} is blocked by order`);
-            }
             return (
                 watcher.lastUnsyncedAccesses.size === 0
                 && watcher.lastUnsyncedParentAccesses.size === 0
@@ -2419,7 +2416,7 @@ const finishProxyAndTriggerNext = runInSerial(
         let next = proxiesOrdered[index];
         // Only trigger if it's the first entry and therefore it won't be blocked by the previous proxy, or, of course, if it's from a timeout, In which case, it won't be blocked anyway. 
         if (next && (index === 0 || fromTimeout)) {
-            console.info(`Triggering next proxy in order: ${next.debugName}`, next.options.baseFunction || next.options.watchFunction);
+            //console.info(`Triggering next proxy in order: ${next.debugName}`, next.options.baseFunction || next.options.watchFunction);
             next.explicitlyTrigger({
                 newParentsSynced: new Set(),
                 pathSources: new Set(),

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

@@ -520,7 +520,6 @@ export class PathFunctionRunner {
                         runCount++;
                         if (PathFunctionRunner.DEBUG_CALLS) {
                             console.log(`Evaluating (try count ${runCount}) ${getDebugName(callPath, functionSpec, true)}`);
-                            console.log(`    RUNNING AT REAL TIME ${debugTime(proxyWatcher.getTriggeredWatcher().currentReadTime || callPath.runAtTime)}`);
                         }
                         if (PathFunctionRunner.DEBUG_CALL_TRIGGERS && runCount > PathFunctionRunner.DEBUG_WATCHES_THRESHOLD) {
                             // NOTE: If this happens a few times during initial loading it is fine. If it happens a lot... and with values MUCH
@@ -672,7 +671,7 @@ export class PathFunctionRunner {
         }
 
         if (PathFunctionRunner.DEBUG_CALLS) {
-            console.log(`FINISHED${nooped ? " (skipped)" : ""} ${getDebugName(callPath, functionSpec, true)}, writes: ${finalWrites?.length}`);
+            console.log(`FINISHED${nooped ? " (skipped)" : ""} ${getDebugName(callPath, functionSpec, true)}, writes: ${finalWrites?.length}, took ${blue(formatTime(Date.now() - startTime))}`);
         }
 
         let wallTime = Date.now() - startTime;

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

@@ -30,7 +30,7 @@ async function main() {
     //ActionsHistory.LOG_ACTION_HISTORY = "runner";
 
     // ClientWatcher.DEBUG_READS = true;
-    ClientWatcher.DEBUG_WRITES = true;
+    //ClientWatcher.DEBUG_WRITES = true;
     // ClientWatcher.DEBUG_TRIGGERS = "heavy";
     // authorityStorage.DEBUG_UNWATCH = true;
 

package/src/4-dom/qreact.tsx

@@ -2436,7 +2436,7 @@ export function getSourceVSCodeLink(element: DOMNode | undefined) {
             Command palette: You can trigger VS Code commands using vscode://file/{file}?command={commandId}.
             Extensions: Some VS Code extensions may add support for additional URL parameters.
     */
-    let path = `cursor://file/${sourceInfo.sourceFileName}`;
+    let path = `cursor://file${new URL(sourceInfo.sourceFileName).pathname}`;
     if (sourceInfo.lineNumber) {
         path += `:${sourceInfo.lineNumber}:${sourceInfo.columnNumber}`;
         path += `?selection=${sourceInfo.lineNumber},${sourceInfo.columnNumber}`;

package/src/4-querysub/Querysub.ts

@@ -53,6 +53,8 @@ import { parseArgsFactory } from "../misc/rawParams";
 
 import * as typesafecss from "typesafecss";
 import "../library-components/urlResetGroups";
+import { createLocalSchema } from "./schemaHelpers";
+
 
 
 typesafecss.setMeasureBlock(measureBlock);
@@ -1069,32 +1071,6 @@ export class Querysub {
     //      like just relying on the automatic checking is better?
 }
 
-let localSchemaNames = new Set<string>();
-function createLocalSchema<T>(name: string): () => T;
-function createLocalSchema<SchemaDef extends Schema2>(name: string, schema: SchemaDef): () => Schema2T<SchemaDef>;
-function createLocalSchema<T>(name: string, schema2?: Schema2): () => T {
-    if (localSchemaNames.has(name) && !isHotReloading() && !isDynamicallyLoading()) {
-        debugbreak(2);
-        debugger;
-        throw new Error(`Already have local schema with name ${JSON.stringify(name)}`);
-    }
-    if (schema2) {
-        registerSchemaPrefix({
-            schema: schema2,
-            prefixPathStr: getPathStr2(LOCAL_DOMAIN, name),
-        });
-    }
-    localSchemaNames.add(name);
-    let schema = rawSchema<{
-        [LOCAL_DOMAIN]: {
-            [name: string]: T;
-        }
-    }>();
-    // Lazy saves a lot of time on accesses by skipping a few proxy accesses
-    return lazy(() => {
-        return schema()[LOCAL_DOMAIN][name];
-    });
-}
 
 let nextGlobalIndex = 1000 * 1000 * 1000 * 100;
 let nextCallIndex = 1;

package/src/4-querysub/predictionQueue.tsx

@@ -10,8 +10,9 @@ import { blue, green, magenta, yellow } from "socket-function/src/formatting/log
 import { formatTime } from "socket-function/src/formatting/format";
 import { measureBlock, measureWrap } from "socket-function/src/profiling/measure";
 import { debugTime } from "../0-path-value-core/pathValueCore";
-import { t } from "./Querysub";
 import { getProxyPath } from "../2-proxy/pathValueProxy";
+import { createLocalSchema } from "./schemaHelpers";
+import { t } from "../2-proxy/schema2";
 
 let commitQueues: Map<string, {
     callSpec: CallSpec;
@@ -22,7 +23,7 @@ let commitQueues: Map<string, {
     resolveOrderedPromise: PromiseObj<void>;
     canBeClobbered: boolean;
 }[]> = new Map();
-let commitQueueCount = Querysub.createLocalSchema("commitQueueCount", {
+let commitQueueCount = createLocalSchema("commitQueueCount", {
     count: t.number,
 });
 

package/src/4-querysub/schemaHelpers.ts

@@ -0,0 +1,36 @@
+import { lazy } from "socket-function/src/caching";
+import { LOCAL_DOMAIN } from "../0-path-value-core/NodePathAuthorities";
+import { registerSchemaPrefix } from "../2-proxy/PathValueProxyWatcher";
+import { rawSchema } from "../2-proxy/pathDatabaseProxyBase";
+import { Schema2, Schema2T } from "../2-proxy/schema2";
+import { isDynamicallyLoading } from "../config";
+import { getPathStr2 } from "../path";
+import { isHotReloading } from "socket-function/hot/HotReloadController";
+import debugbreak from "debugbreak";
+
+let localSchemaNames = new Set<string>();
+export function createLocalSchema<T>(name: string): () => T;
+export function createLocalSchema<SchemaDef extends Schema2>(name: string, schema: SchemaDef): () => Schema2T<SchemaDef>;
+export function createLocalSchema<T>(name: string, schema2?: Schema2): () => T {
+    if (localSchemaNames.has(name) && !isHotReloading() && !isDynamicallyLoading()) {
+        debugbreak(2);
+        debugger;
+        throw new Error(`Already have local schema with name ${JSON.stringify(name)}`);
+    }
+    if (schema2) {
+        registerSchemaPrefix({
+            schema: schema2,
+            prefixPathStr: getPathStr2(LOCAL_DOMAIN, name),
+        });
+    }
+    localSchemaNames.add(name);
+    let schema = rawSchema<{
+        [LOCAL_DOMAIN]: {
+            [name: string]: T;
+        }
+    }>();
+    // Lazy saves a lot of time on accesses by skipping a few proxy accesses
+    return lazy(() => {
+        return schema()[LOCAL_DOMAIN][name];
+    });
+}