socket-function 0.9.4 → 0.9.5

package/package.json

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

package/require/require.js

@@ -27,7 +27,9 @@
             // https://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor
             inherits(constructor, superConstructor) {
                 Object.setPrototypeOf(constructor.prototype, superConstructor.prototype);
-            }
+            },
+            TextDecoder: TextDecoder,
+            TextEncoder: TextEncoder,
         },
         buffer: { Buffer },
         stream: {

package/src/JSONLACKS/JSONLACKS.ts

@@ -68,6 +68,18 @@ export class JSONLACKS {
             return Buffer.concat(buffers);
         });
     }
+    public static stringifyFileSync(obj: unknown[], config?: JSONLACKS_StringifyConfig): Buffer {
+        let serialized = JSONLACKS.escapeSpecialObjects(obj, config) as unknown[];
+        return measureBlock(function JSONstringifyAndJoin() {
+            let buffers: Buffer[] = [];
+            for (let i = 0; i < serialized.length; i += SERIALIZE_OBJECT_BATCH_COUNT) {
+                let str = serialized.slice(i, i + SERIALIZE_OBJECT_BATCH_COUNT).map(x => JSON.stringify(x) + "\n").join("");
+                buffers.push(Buffer.from(str));
+            }
+            // Break up into chunks, as string => Buffer i
+            return Buffer.concat(buffers);
+        });
+    }
     // TIMING: Seems to be about 40X slower than JSON.parse unless extended is set to false,
     //  then it is about 2X slower (although it depends on the size and complexity of the objects!)
     @measureFnc

package/src/batching.ts

@@ -113,15 +113,22 @@ export function batchFunction<Arg, Result = void>(
 }
 
 export function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T): T {
-    let updateQueue: (() => void)[] = [];
+    let updateQueue: { promise: Promise<void>; resolve: () => void; }[] = [];
 
     return (async (...args: any[]) => {
+        let promise = {
+            promise: null as any as Promise<void>,
+            resolve: () => { },
+        };
+        promise.promise = new Promise<void>(resolve => {
+            promise.resolve = resolve;
+        });
         const queueWasEmpty = updateQueue.length === 0;
-        if (!queueWasEmpty) {
-            // Wait for the previous promise to resolve
-            await new Promise<void>(resolve => updateQueue.push(resolve));
+        if (queueWasEmpty) {
+            promise.resolve();
         }
-        updateQueue.push(() => { });
+        updateQueue.push(promise);
+        await promise.promise;
 
         try {
             return await fnc(...args);
@@ -129,7 +136,7 @@ export function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T):
             // Pop ourself off
             updateQueue.shift();
             // Resolve the next promise
-            updateQueue[0]?.();
+            updateQueue[0]?.resolve();
         }
     }) as T;
 }

package/src/caching.ts

@@ -38,8 +38,10 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
     (key: Key): Output;
     // NOTE: If you want to clear all, just make a new cache!
     clear(key: Key): void;
+    clearAll(): void;
     forceSet(key: Key, value: Output): void;
     getAllKeys(): Key[];
+    get(key: Key): Output | undefined;
 } {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
@@ -69,6 +71,13 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
     cache.getAllKeys = () => {
         return [...values.keys()];
     };
+    cache.get = (key: Key) => {
+        return values.get(key);
+    };
+    cache.clearAll = () => {
+        values.clear();
+        startingCalculating.clear();
+    };
     return cache;
 }
 
@@ -114,6 +123,14 @@ export function cacheLimited<Output, Key>(
         values.set(key, value);
         startingCalculating.add(key);
     };
+    get["clearKey"] = (key: Key) => {
+        values.delete(key);
+        startingCalculating.delete(key);
+    };
+    get["clear"] = () => {
+        values.clear();
+        startingCalculating.clear();
+    };
 
     return get;
 }
@@ -186,6 +203,7 @@ export function cacheArrayEqual<Input extends unknown[] | undefined, Output>(
 ): {
     (array: Input): Output;
     clear(array: Input): void;
+    clearAll(): void;
 } {
     let state: {
         cache: {
@@ -227,7 +245,10 @@ export function cacheArrayEqual<Input extends unknown[] | undefined, Output>(
                         state.cache.splice(i, 1);
                     }
                 }
-            }
+            },
+            clearAll() {
+                state.cache = [];
+            },
         }
     );
 }
@@ -247,7 +268,7 @@ export function cacheArgsEqual<Fnc extends AnyFunction>(
         {
             clear(...args: unknown[]) {
                 cache.clear(args);
-            }
+            },
         }
     );
 }
@@ -255,13 +276,23 @@ export function cacheArgsEqual<Fnc extends AnyFunction>(
 export function cacheJSONArgsEqual<Fnc extends AnyFunction>(
     fnc: Fnc,
     limit = 10
-): Fnc {
+) {
     let cache = cacheLimited(limit, (argsJSON: string) => {
         return fnc(...JSON.parse(argsJSON));
     });
-    return ((...args: unknown[]) => {
-        return cache(JSON.stringify(args));
-    }) as Fnc;
+    return Object.assign(
+        ((...args: unknown[]) => {
+            return cache(JSON.stringify(args));
+        }) as Fnc,
+        {
+            clear(...args: unknown[]) {
+                cache.clearKey(JSON.stringify(args));
+            },
+            clearAll() {
+                cache.clear();
+            }
+        }
+    );
 }
 
 export function cacheShallowConfigArgEqual<Fnc extends AnyFunction>(
@@ -269,6 +300,7 @@ export function cacheShallowConfigArgEqual<Fnc extends AnyFunction>(
     limit = 10
 ): Fnc & {
     clear(...args: Args<Fnc>): void;
+    clearAll(): void;
 } {
     let cache = cacheArrayEqual((kvpsFlat: unknown[]) => {
         output.missCount++;
@@ -301,6 +333,9 @@ export function cacheShallowConfigArgEqual<Fnc extends AnyFunction>(
             clear(configArg: object) {
                 cache.clear(getKVPs(configArg));
             },
+            clearAll() {
+                cache.clearAll();
+            },
             callCount: 0,
             missCount: 0,
         }

package/src/misc.ts

@@ -1,6 +1,13 @@
 import * as crypto from "crypto";
 import { canHaveChildren, MaybePromise } from "./types";
 
+export const timeInSecond = 1000;
+export const timeInMinute = timeInSecond * 60;
+export const timeInHour = timeInMinute * 60;
+export const timeInDay = timeInHour * 24;
+export const timeInWeek = timeInDay * 7;
+export const timeInYear = timeInDay * 365;
+
 export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
 
 export function convertErrorStackToError(error: string): Error {
@@ -301,4 +308,9 @@ export function arrayFromOrderObject<T>(obj: { [order: number]: T }): T[] {
 
 export function last<T>(arr: T[]): T | undefined {
     return arr[arr.length - 1];
+}
+
+export type ObjectValues<T> = T[keyof T];
+export function entries<Obj extends { [key: string]: unknown }>(obj: Obj): [keyof Obj, ObjectValues<Obj>][] {
+    return Object.entries(obj) as any;
 }

package/src/profiling/getOwnTime.ts

@@ -8,39 +8,18 @@ export type OwnTimeObj = {
     time: number;
     ownTime: number;
 };
-type OwnTimeObjInternal = OwnTimeObj & {
+export type OwnTimeObjInternal = OwnTimeObj & {
     lastStartTime: number;
     firstStartTime: number;
-    parent: OwnTimeObjInternal | undefined;
-    child: OwnTimeObjInternal | undefined;
 };
 
-let pendingCallTime: OwnTimeObjInternal | undefined;
-export function getPendingOwnTimeObjs(): (OwnTimeObj & { source: OwnTimeObjInternal })[] | undefined {
-    let time = now();
-    let instances = getPendingOwnTimeInstances();
-    if (!instances) return undefined;
-    if (!pendingCallTime) return undefined;
-    let results = instances.map((instance) => ({
-        name: instance.name,
-        ownTime: instance.ownTime,
-        time: time - instance.firstStartTime,
-        source: instance
-    }));
-    results[0].ownTime += time - pendingCallTime.lastStartTime;
-    return results;
-}
-export function getPendingOwnTimeInstances(): OwnTimeObjInternal[] | undefined {
-    if (!pendingCallTime) return undefined;
-    let results: OwnTimeObjInternal[] = [];
-    let current: OwnTimeObjInternal | undefined = pendingCallTime;
-    while (current) {
-        results.push(current);
-        current = current.parent;
-    }
-    return results;
+let openTimes: OwnTimeObjInternal[] = [];
+
+export function getOpenTimesBase(): OwnTimeObjInternal[] {
+    return openTimes;
 }
-(global as any).pendingOwnCallTime = pendingCallTime;
+
+(global as any).pendingOwnCallTime = openTimes;
 
 // NOTE: This overhead time is actually mostly for aggregate time, but it is needed,
 //  otherwise we consistently underestimate the time spent.
@@ -85,39 +64,25 @@ export function getOwnTime<T>(
         ownTime: 0,
         firstStartTime: time,
         lastStartTime: time,
-        parent: pendingCallTime,
-        child: undefined,
     };
-    if (pendingCallTime) {
-        pendingCallTime.child = obj;
-    }
-    pendingCallTime = obj;
-    if (obj.parent) {
-        obj.parent.ownTime += obj.lastStartTime - obj.parent.lastStartTime;
+    let prevOwnTime = openTimes[openTimes.length - 1];
+    if (prevOwnTime) {
+        prevOwnTime.ownTime += time - prevOwnTime.lastStartTime;
     }
+    openTimes.push(obj);
 
     function finish() {
         let time = now();
         obj.time = time - obj.firstStartTime;
-        if (pendingCallTime === obj) {
-            // Good case, all of our children call ended before us.
-
-            // End our own time calculation
+        if (obj === openTimes[openTimes.length - 1]) {
             obj.ownTime += time - obj.lastStartTime;
-
-            // Our parent is now the last open call
-            pendingCallTime = obj.parent;
-            if (pendingCallTime) {
-                // Resume our parent ownTime counting
-                pendingCallTime.lastStartTime = time;
+            let newOwnTime = openTimes[openTimes.length - 2];
+            if (newOwnTime) {
+                newOwnTime.lastStartTime = time;
             }
         }
-        if (obj.child && obj.parent) {
-            obj.child.parent = obj.parent;
-            obj.parent.child = obj.child;
-        }
-        obj.parent = undefined;
-        obj.child = undefined;
+        let index = openTimes.indexOf(obj);
+        openTimes.splice(index, 1);
 
         obj.time += addMeasureOverheadTime;
         obj.ownTime += addMeasureOverheadTime;

package/src/profiling/measure.ts

@@ -2,12 +2,14 @@ import debugbreak from "debugbreak";
 import { formatTime, formatNumber } from "../formatting/format";
 import { red, yellow, blue, magenta } from "../formatting/logColors";
 
-import { getOwnTime, getPendingOwnTimeInstances, getPendingOwnTimeObjs, OwnTimeObj } from "./getOwnTime";
+import { getOpenTimesBase, getOwnTime, OwnTimeObj } from "./getOwnTime";
 import { addToStats, addToStatsValue, createStatsValue, getStatsTop, StatsValue } from "./stats";
 import { white } from "../formatting/logColors";
 import { isNode } from "../misc";
 
-/** NOTE: Must be called BEFORE anything else is imported! */
+/** NOTE: Must be called BEFORE anything else is imported!
+ *      NOTE: Measurements on on by default now, so this doesn't really need to be called...
+*/
 export function enableMeasurements() {
     if (functionsSkipped) {
         console.warn(red(`Skipped measure shimming ${functionsSkipped} functions. Fix this by calling enableMeasurements before any other imports.`));
@@ -75,15 +77,25 @@ export function startMeasure(): {
     let profile: MeasureProfile = {
         entries: Object.create(null),
     };
-    let openAtStart = new Set(getPendingOwnTimeInstances());
+    let openAtStart = new Set(getOpenTimesBase());
 
     outstandingProfiles.push(profile);
     return {
         finish() {
-            let pending = getPendingOwnTimeObjs() || [];
+            let pending = getOpenTimesBase();
+            let last = pending[pending.length - 1];
+            let time = Date.now();
             for (let timeObj of pending) {
-                if (openAtStart.has(timeObj.source)) continue;
-                addToProfile(profile, timeObj, true);
+                // Ignore any values that were already open, as they are clearly not
+                //  caused by our code.
+                if (openAtStart.has(timeObj)) continue;
+                timeObj = { ...timeObj };
+
+                if (timeObj === last) {
+                    timeObj.ownTime += time - timeObj.lastStartTime;
+                }
+                timeObj.time = time - timeObj.firstStartTime;
+                addToProfile(profile, timeObj);
             }
             outstandingProfiles.splice(outstandingProfiles.indexOf(profile), 1);
             return profile;
@@ -96,6 +108,8 @@ export interface LogMeasureTableConfig {
     name?: string;
     // Defaults to 0.05
     thresholdInTable?: number;
+    // Details to 50
+    minTimeToLog?: number;
 }
 
 export function logMeasureTable(
@@ -106,6 +120,7 @@ export function logMeasureTable(
     if (thresholdInTable === undefined) {
         thresholdInTable = 0.05;
     }
+    let minTimeToLog = config?.minTimeToLog ?? 50;
 
     function getTime(entry: ProfileEntry) {
         return useTotalTime ? entry.totalTime : entry.ownTime;
@@ -114,6 +129,7 @@ export function logMeasureTable(
     entries.sort((a, b) => getTime(b).sum - getTime(a).sum);
 
     let totalTime = entries.map(x => getTime(x).sum).reduce((a, b) => a + b, 0);
+    if (totalTime < minTimeToLog) return;
 
     console.log();
     let title = yellow(`Profiled ${formatTime(totalTime)} (logged at ${new Date().toISOString()})`);

package/src/webSocketServer.ts

@@ -96,7 +96,11 @@ export async function startSocketServer(
             console.error(`Connection attempt error ${e.message}`);
         });
         httpsServer.on("tlsClientError", e => {
-            console.error(`TLS client error ${e.message}`);
+            // NOTE: This happens a lot when we have tabs open that connected to an old
+            //  server (with old certs, that the browser will reject?)
+            if (!SocketFunction.silent) {
+                console.error(`TLS client error ${e.message}`);
+            }
         });
 
         httpsServer.on("request", httpCallHandler);