querysub 0.341.0 → 0.342.0

package/package.json

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

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];
+    });
+}