querysub 0.2.0

package/src/library-components/niceStringify.ts

@@ -0,0 +1,50 @@
+
+let specialStringValuesDecode = new Map<string, unknown>([
+    // NOTE: Starting with `"`, but not ending with quotes will not be normally generated, as anything starting 
+    //  with a quote will be encoded as a string.
+    [`"undefined`, undefined],
+    [`"nan`, Number.NaN],
+]);
+let specialStringValuesEncode = new Map([...specialStringValuesDecode].map(([key, value]) => [value, key]));
+
+export function serializeURLParam(value: unknown): string | undefined {
+    if (value === true) return undefined;
+    // If it is a string and doesn't look JSON encoded, then just use it raw.
+    if (typeof value === "string" && !lookJSONEncoded(value)) {
+        return value;
+    }
+    let specialValue = specialStringValuesEncode.get(value);
+    if (specialValue) {
+        return specialValue;
+    }
+    return JSON.stringify(value);
+}
+export function deserializeURLParam(value: string | undefined) {
+    if (value === undefined) return true;
+    let specialValue = specialStringValuesDecode.get(value);
+    if (specialValue) {
+        return specialValue;
+    }
+    if (!lookJSONEncoded(value)) {
+        return value;
+    }
+
+    try {
+        return JSON.parse(value);
+    } catch {
+        return value;
+    }
+}
+
+function lookJSONEncoded(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)
+    );
+}

package/src/library-components/renderToString.ts

@@ -0,0 +1,52 @@
+import debugbreak from "debugbreak";
+import { IS_NON_DIMENSIONAL, VirtualDOM, isFragment } from "../../src/4-dom/qreact";
+import { canHaveChildren } from "socket-function/src/types";
+
+export function renderToString(component: VirtualDOM): string {
+    if (Array.isArray(component)) {
+        return component.map(renderToString).join("");
+    }
+    if (!canHaveChildren(component)) {
+        if (component === false) return "";
+        if (component === undefined || component === null) return "";
+        return String(component);
+    }
+    if (isFragment(component)) {
+        return renderToString((component as any).props.children);
+    }
+    if (typeof component.type !== "string") {
+        // TODO: Support rendering components, just by calling .render
+        // TODO: Support functional components
+        // TODO: Support synced components, by making a promise variant of renderToString
+        throw new Error("Only string components are presently supported in renderToString");
+    }
+    let attributes = "";
+    for (let key in component.props) {
+        if (key === "children") continue;
+        let value = component.props[key];
+        if (key === "style" && canHaveChildren(value)) {
+            let style = "";
+            for (let [key, v] of Object.entries(value)) {
+                // Convert to dash case
+                key = key.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+                if (typeof v === "number" && !IS_NON_DIMENSIONAL.test(key)) {
+                    v = v + "px";
+                }
+                style += `${key}:${v};`;
+            }
+            value = style;
+        }
+        if (value === true) {
+            attributes += ` ${key}`;
+        } else if (value !== false) {
+            attributes += ` ${key}="${value}"`;
+        }
+    }
+    let childrenRaw = component.props.children;
+    let childrenArray = Array.isArray(childrenRaw) ? childrenRaw : [childrenRaw];
+    let children = "";
+    for (let child of childrenArray) {
+        children += renderToString(child);
+    }
+    return `<${component.type}${attributes}>${children}</${component.type}>`;
+}

package/src/misc/PromiseRace.ts

@@ -0,0 +1,101 @@
+/** 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 { }
+        }
+    });
+}

package/src/misc/color.ts

@@ -0,0 +1,30 @@
+
+/** hue: 0-360, saturation: 0-100, lightness: 0-100 */
+export function hslToRGB(color: { h: number; s: number; l: number }) {
+    let { h, s, l } = color;
+    h /= 360;
+    s /= 100;
+    l /= 100;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l; // achromatic
+    } else {
+        const hue2rgb = (p: number, q: number, t: number) => {
+            if (t < 0) t += 1;
+            if (t > 1) t -= 1;
+            if (t < 1 / 6) return p + (q - p) * 6 * t;
+            if (t < 1 / 2) return q;
+            if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+        if (b < 0) {
+            b = 0;
+        }
+    }
+    return { r: Math.floor(r * 255), g: Math.floor(g * 255), b: Math.floor(b * 255) };
+}

package/src/misc/getParentProcessId.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+using System.Runtime.InteropServices;
+
+public class PPIDService
+{
+    [DllImport("kernel32.dll")]
+    static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
+    [DllImport("kernel32.dll")]
+    static extern bool CloseHandle(IntPtr hObject);
+
+    [DllImport("ntdll.dll")]
+    static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, ref PROCESS_BASIC_INFORMATION pbi, int processInformationLength, out int returnLength);
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct PROCESS_BASIC_INFORMATION
+    {
+        public IntPtr Reserved1;
+        public IntPtr PebBaseAddress;
+        public IntPtr Reserved2_0;
+        public IntPtr Reserved2_1;
+        public IntPtr UniqueProcessId;
+        public IntPtr InheritedFromUniqueProcessId;
+    }
+
+    public static int GetParentProcessId(int pid)
+    {
+        IntPtr hProcess = OpenProcess(0x1000, false, pid);
+        if (hProcess == IntPtr.Zero)
+        {
+            return 0;
+        }
+
+        try
+        {
+            PROCESS_BASIC_INFORMATION pbi = new PROCESS_BASIC_INFORMATION();
+            int returnLength;
+            int status = NtQueryInformationProcess(hProcess, 0, ref pbi, Marshal.SizeOf(pbi), out returnLength);
+            if (status == 0)
+            {
+                return pbi.InheritedFromUniqueProcessId.ToInt32();
+            }
+        }
+        finally
+        {
+            CloseHandle(hProcess);
+        }
+
+        return 0;
+    }
+}

package/src/misc/getParentProcessId.ts

@@ -0,0 +1,53 @@
+import fs from "fs";
+
+import { lazy } from "socket-function/src/caching";
+import { runInSerial } from "socket-function/src/batching";
+import child_process from "child_process";
+import os from "os";
+import readline from "readline";
+import net from "net";
+
+const windowsGetPPID = lazy(async () => {
+    const powershellProcess = child_process.spawn("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "-",
+    ], { stdio: ["pipe", "pipe", "pipe"] });
+    powershellProcess.stderr.pipe(process.stderr);
+    // powershellProcess.stdout.pipe(process.stdout);
+
+    powershellProcess.on("error", (error) => {
+        console.error("Failed to spawn powershell process", error);
+    });
+
+    powershellProcess.stdin.write(`$inject = Get-Content -Raw -Path ${JSON.stringify(__dirname + "/getParentProcessId.cs")};\n`);
+    powershellProcess.stdin.write(`Add-Type -TypeDefinition $inject\n`);
+
+    return runInSerial((pid: number): Promise<number> => {
+        return new Promise((resolve) => {
+            powershellProcess.stdin.write(`[PPIDService]::GetParentProcessId(${pid})\n`);
+            powershellProcess.stdout.once("data", (data) => {
+                resolve(parseInt(data.toString()) || 0);
+            });
+        });
+    });
+});
+
+export async function getPPID(pid: number): Promise<number> {
+    const platform = os.platform();
+    if (platform === "win32") {
+        let getPPID = await windowsGetPPID();
+        return getPPID(pid);
+    } else if (platform === "darwin" || platform === "linux") {
+        try {
+            const statContent = await fs.promises.readFile(`/proc/${pid}/stat`, "utf8");
+            const ppid = parseInt(statContent.split(" ")[3], 10);
+            return isNaN(ppid) ? 0 : ppid;
+        } catch (error) {
+            return 0;
+        }
+    } else {
+        throw new Error("Unsupported operating system");
+    }
+}

package/src/misc/hash.ts

@@ -0,0 +1,83 @@
+import debugbreak from "debugbreak";
+
+export function fastHash(text: string): number {
+    // Murmur, but we try to use more than 32 bits, as a double can store far more than 32 bits.
+    let hash1 = 5380942 ^ text.length;
+    let hash2 = 9143241 ^ text.length;
+    for (let i = 0; i < text.length; i++) {
+        let ch = text.charCodeAt(i);
+        hash1 = addToMurmurHash(hash1, ch);
+        hash2 = addToMurmurHash(hash2, ch);
+    }
+    hash1 = finishMurmurHash(hash1);
+    hash2 = finishMurmurHash(hash2);
+    return Math.abs(hash1 * (2 ** 20) + hash2);
+}
+
+/** Hashes an object so the result is the same independent of key order
+ *      Ex, consistentHash({ x: 1, y: 2 }) === consistentHash({ y: 2, x: 1 })
+ *      - Works with nested values
+ *      - The hash isn't small, and is really just the JSON stringified re-ordered object
+ */
+export function consistentHash(obj: unknown): string {
+    return JSON.stringify(orderObjectKeys(obj));
+}
+function orderObjectKeys(obj: unknown): unknown {
+    if (typeof obj !== "object" || obj === null) return obj;
+    if (Array.isArray(obj)) return obj.map(x => orderObjectKeys(x));
+    let keys = Object.keys(obj);
+    keys.sort();
+    let newObj: Record<string, unknown> = {};
+    for (let key of keys) {
+        newObj[key] = orderObjectKeys((obj as any)[key]);
+    }
+    return newObj;
+}
+
+function addToMurmurHash(curHash: number, next: number) {
+    // murmurhash, 32 bit 
+    // https://github.com/mikolalysenko/murmurhash-js/blob/master/murmurhash2_gc.js
+    let h = curHash;
+    let k = next;
+    k = (((k & 0xffff) * 0x5bd1e995) + ((((k >>> 16) * 0x5bd1e995) & 0xffff) << 16));
+    k ^= k >>> 24;
+    k = (((k & 0xffff) * 0x5bd1e995) + ((((k >>> 16) * 0x5bd1e995) & 0xffff) << 16));
+    h = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16)) ^ k;
+
+    return h;
+}
+function finishMurmurHash(curHash: number) {
+    let h = curHash;
+    h ^= h >>> 13;
+    h = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16));
+    h ^= h >>> 15;
+    return h;
+}
+
+export function hashBufferRange32(buffer: Buffer, start: number, end: number) {
+    if (start < 0) start = 0;
+    if (end > buffer.byteLength) end = buffer.byteLength;
+
+    let len = end - start;
+    let len4 = len - (len % 4);
+    let hash = end - start;
+    for (let i = 0; i < len4; i += 4) {
+        hash = addToMurmurHash(hash, buffer.readUInt32LE(i + start));
+    }
+    for (let i = len4; i < len; i++) {
+        hash = addToMurmurHash(hash, buffer[i + start]);
+    }
+
+    return hash;
+}
+
+export function hashBufferRange64(buffer: Buffer, start: number, end: number) {
+    if (start < 0) start = 0;
+    if (end > buffer.byteLength) end = buffer.byteLength;
+    let size = end - start;
+    let middle = start + Math.ceil(size / 2);
+
+    let hash1 = hashBufferRange32(buffer, start, middle);
+    let hash2 = hashBufferRange32(buffer, middle, end);
+    return Math.abs(hash1 * (2 ** 20) + hash2);
+}

package/src/misc/ipPong.js

@@ -0,0 +1,13 @@
+// HTTP response with the caller IP
+
+const http = require("http");
+const port = 4283;
+
+const server = http.createServer((req, res) => {
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.end(req.socket.remoteAddress.split(":").pop());
+});
+
+server.listen(port, () => {
+    console.log(`Server running at http://localhost:${port}/`);
+});

package/src/misc/networking.ts

@@ -0,0 +1,2 @@
+import { testTCPIsListening, getExternalIP, getPublicIP } from "socket-function/src/networking";
+export { testTCPIsListening, getExternalIP, getPublicIP };

package/src/misc/random.ts

@@ -0,0 +1,45 @@
+import { isNode } from "socket-function/src/misc";
+import crypto from "crypto";
+
+export function getSeededRandom(seed: number): () => number {
+    // Multiply seed by a large prime
+    seed = (seed + 0x1235234894) * 0x1fffffff % 0x7fffffff;
+    let rand = sfc32(seed, seed, seed, seed);
+    // Run a few time, to fully seed it
+    for (let i = 0; i < 10; i++) {
+        rand();
+    }
+    return rand;
+    function sfc32(a: number, b: number, c: number, d: number) {
+        return function () {
+            a >>>= 0; b >>>= 0; c >>>= 0; d >>>= 0;
+            var t = (a + b) | 0;
+            a = b ^ b >>> 9;
+            b = c + (c << 3) | 0;
+            c = (c << 21 | c >>> 11);
+            d = d + 1 | 0;
+            t = t + d | 0;
+            c = c + t | 0;
+            return (t >>> 0) / 4294967296;
+        };
+    }
+}
+
+export function shuffle<T>(array: T[], seed: number) {
+    let rand = getSeededRandom(seed);
+    let indexes = Array(array.length).fill(0).map((x, i) => i);
+    let shuffleValue = indexes.map(() => rand());
+    indexes.sort((a, b) => shuffleValue[a] - shuffleValue[b]);
+    return indexes.map(i => array[i]);
+}
+
+let randomData = new Uint8Array(8);
+let randomDataF64 = new Float64Array(randomData.buffer);
+export function secureRandom(): number {
+    if (!isNode()) {
+        window.crypto.getRandomValues(randomData);
+    } else {
+        crypto.getRandomValues(randomData);
+    }
+    return randomDataF64[0];
+}

package/src/misc.ts

@@ -0,0 +1,19 @@
+// TIMING: About 20MB/s
+export function createRandomText(count: number): string {
+    let text = "";
+    let possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    for (let i = 0; i < count; i++) {
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    }
+    return text;
+}
+
+export function isEmpty(obj: unknown): boolean {
+    if (!obj) return false;
+    if (typeof obj !== "object") return false;
+    return Object.keys(obj).length === 0;
+}
+
+export function isDefined<T>(value: T | undefined | null): value is T {
+    return value !== undefined && value !== null;
+}