socket-function 0.9.0 → 0.9.2

package/src/callManager.ts

@@ -1,135 +1,135 @@
-import { CallerContext, CallType, ClientHookContext, FullCallType, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
-import { _setSocketContext } from "../SocketFunction";
-import { isNode } from "./misc";
-import debugbreak from "debugbreak";
-import { measureWrap } from "./profiling/measure";
-
-let classes: {
-    [classGuid: string]: {
-        controller: SocketExposedInterface;
-        shape: SocketExposedShape;
-    }
-} = {};
-let exposedClasses = new Set<string>();
-
-let globalHooks: SocketFunctionHook[] = [];
-let globalClientHooks: SocketFunctionClientHook[] = [];
-
-export async function performLocalCall(
-    config: {
-        call: FullCallType;
-        caller: CallerContext;
-    }
-): Promise<unknown> {
-    const { call, caller } = config;
-    let classDef = classes[call.classGuid];
-
-    if (!classDef) {
-        throw new Error(`Class ${call.classGuid} not found`);
-    }
-
-    if (!exposedClasses.has(call.classGuid)) {
-        throw new Error(`Class ${call.classGuid} not exposed`);
-    }
-
-    let controller = classDef.controller;
-    let functionShape = classDef.shape[call.functionName];
-    if (!functionShape) {
-        throw new Error(`Function ${call.functionName} not exposed`);
-    }
-
-    if (!controller[call.functionName]) {
-        throw new Error(`Function ${call.functionName} does not exist`);
-    }
-
-    let serverContext = await runServerHooks(call, caller, functionShape);
-    if ("overrideResult" in serverContext) {
-        return serverContext.overrideResult;
-    }
-
-    // NOTE: We purposely don't await inside _setSocketContext, so the context is reset synchronously
-    let result = _setSocketContext(caller, () => {
-        return controller[call.functionName](...call.args);
-    });
-
-    return await result;
-}
-
-export function isDataImmutable(call: CallType) {
-    return !!classes[call.classGuid]?.shape[call.functionName]?.dataImmutable;
-}
-
-export function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape) {
-    if (classes[classGuid]) {
-        throw new Error(`Class ${classGuid} already registered`);
-    }
-
-    classes[classGuid] = {
-        controller,
-        shape,
-    };
-}
-
-export function exposeClass(exposedClass: SocketRegistered) {
-    exposedClasses.add(exposedClass._classGuid);
-}
-
-export function registerGlobalHook(hook: SocketFunctionHook) {
-    globalHooks.push(hook);
-}
-export function unregisterGlobalHook(hook: SocketFunctionHook) {
-    let index = globalHooks.indexOf(hook);
-    if (index >= 0) {
-        globalHooks.splice(index, 1);
-    }
-}
-export function registerGlobalClientHook(hook: SocketFunctionClientHook) {
-    globalClientHooks.push(hook);
-}
-export function unregisterGlobalClientHook(hook: SocketFunctionClientHook) {
-    let index = globalClientHooks.indexOf(hook);
-    if (index >= 0) {
-        globalClientHooks.splice(index, 1);
-    }
-}
-
-export const runClientHooks = measureWrap(async function runClientHooks(
-    callType: FullCallType,
-    hooks: SocketExposedShape[""],
-    connectionId: { nodeId: string },
-): Promise<ClientHookContext> {
-    let context: ClientHookContext = { call: callType, connectionId };
-
-    let clientHooks = (
-        globalClientHooks
-            .concat(hooks.clientHooks || [])
-    );
-    for (let otherClientHook of globalHooks.concat(hooks.hooks || []).map(x => x.clientHook)) {
-        if (otherClientHook) {
-            clientHooks.push(otherClientHook);
-        }
-    }
-    for (let hook of clientHooks) {
-        await hook(context);
-        if ("overrideResult" in context) {
-            break;
-        }
-    }
-
-    return context;
-});
-
-export const runServerHooks = measureWrap(async function runServerHooks(
-    callType: FullCallType,
-    caller: CallerContext,
-    hooks: SocketExposedShape[""],
-): Promise<HookContext> {
-    let hookContext: HookContext = { call: callType };
-    for (let hook of globalHooks.concat(hooks.hooks || [])) {
-        await _setSocketContext(caller, () => hook(hookContext));
-        if ("overrideResult" in hookContext) {
-            break;
-        }
-    }
-    return hookContext;
+import { CallerContext, CallType, ClientHookContext, FullCallType, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+import { _setSocketContext } from "../SocketFunction";
+import { isNode } from "./misc";
+import debugbreak from "debugbreak";
+import { measureWrap } from "./profiling/measure";
+
+let classes: {
+    [classGuid: string]: {
+        controller: SocketExposedInterface;
+        shape: SocketExposedShape;
+    }
+} = {};
+let exposedClasses = new Set<string>();
+
+let globalHooks: SocketFunctionHook[] = [];
+let globalClientHooks: SocketFunctionClientHook[] = [];
+
+export async function performLocalCall(
+    config: {
+        call: FullCallType;
+        caller: CallerContext;
+    }
+): Promise<unknown> {
+    const { call, caller } = config;
+    let classDef = classes[call.classGuid];
+
+    if (!classDef) {
+        throw new Error(`Class ${call.classGuid} not found`);
+    }
+
+    if (!exposedClasses.has(call.classGuid)) {
+        throw new Error(`Class ${call.classGuid} not exposed`);
+    }
+
+    let controller = classDef.controller;
+    let functionShape = classDef.shape[call.functionName];
+    if (!functionShape) {
+        throw new Error(`Function ${call.functionName} not exposed`);
+    }
+
+    if (!controller[call.functionName]) {
+        throw new Error(`Function ${call.functionName} does not exist`);
+    }
+
+    let serverContext = await runServerHooks(call, caller, functionShape);
+    if ("overrideResult" in serverContext) {
+        return serverContext.overrideResult;
+    }
+
+    // NOTE: We purposely don't await inside _setSocketContext, so the context is reset synchronously
+    let result = _setSocketContext(caller, () => {
+        return controller[call.functionName](...call.args);
+    });
+
+    return await result;
+}
+
+export function isDataImmutable(call: CallType) {
+    return !!classes[call.classGuid]?.shape[call.functionName]?.dataImmutable;
+}
+
+export function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape) {
+    if (classes[classGuid]) {
+        throw new Error(`Class ${classGuid} already registered`);
+    }
+
+    classes[classGuid] = {
+        controller,
+        shape,
+    };
+}
+
+export function exposeClass(exposedClass: SocketRegistered) {
+    exposedClasses.add(exposedClass._classGuid);
+}
+
+export function registerGlobalHook(hook: SocketFunctionHook) {
+    globalHooks.push(hook);
+}
+export function unregisterGlobalHook(hook: SocketFunctionHook) {
+    let index = globalHooks.indexOf(hook);
+    if (index >= 0) {
+        globalHooks.splice(index, 1);
+    }
+}
+export function registerGlobalClientHook(hook: SocketFunctionClientHook) {
+    globalClientHooks.push(hook);
+}
+export function unregisterGlobalClientHook(hook: SocketFunctionClientHook) {
+    let index = globalClientHooks.indexOf(hook);
+    if (index >= 0) {
+        globalClientHooks.splice(index, 1);
+    }
+}
+
+export const runClientHooks = measureWrap(async function runClientHooks(
+    callType: FullCallType,
+    hooks: SocketExposedShape[""],
+    connectionId: { nodeId: string },
+): Promise<ClientHookContext> {
+    let context: ClientHookContext = { call: callType, connectionId };
+
+    let clientHooks = (
+        globalClientHooks
+            .concat(hooks.clientHooks || [])
+    );
+    for (let otherClientHook of globalHooks.concat(hooks.hooks || []).map(x => x.clientHook)) {
+        if (otherClientHook) {
+            clientHooks.push(otherClientHook);
+        }
+    }
+    for (let hook of clientHooks) {
+        await hook(context);
+        if ("overrideResult" in context) {
+            break;
+        }
+    }
+
+    return context;
+});
+
+export const runServerHooks = measureWrap(async function runServerHooks(
+    callType: FullCallType,
+    caller: CallerContext,
+    hooks: SocketExposedShape[""],
+): Promise<HookContext> {
+    let hookContext: HookContext = { call: callType };
+    for (let hook of globalHooks.concat(hooks.hooks || [])) {
+        await _setSocketContext(caller, () => hook(hookContext));
+        if ("overrideResult" in hookContext) {
+            break;
+        }
+    }
+    return hookContext;
 });

package/src/certStore.ts

@@ -1,30 +1,30 @@
-import * as tls from "tls";
-import { isNode, sha256Hash } from "./misc";
-
-let trustedCerts = new Set<string>();
-let watchCallbacks = new Set<(certs: string[]) => void>();
-
-/** Must be populated before the server starts */
-export function trustCertificate(cert: string | Buffer) {
-    cert = cert.toString();
-    if (trustedCerts.has(cert)) return;
-    trustedCerts.add(cert);
-    let certs = getTrustedCertificates();
-    for (let callback of watchCallbacks) {
-        callback(certs);
-    }
-}
-export function getTrustedCertificates(): string[] {
-    let certs: string[] = [];
-    if (isNode()) {
-        certs.push(...tls.rootCertificates);
-    }
-    certs.push(...Array.from(trustedCerts));
-    return certs;
-}
-
-export function watchTrustedCertificates(callback: (certs: string[]) => void) {
-    watchCallbacks.add(callback);
-    callback(getTrustedCertificates());
-    return () => watchCallbacks.delete(callback);
+import * as tls from "tls";
+import { isNode, sha256Hash } from "./misc";
+
+let trustedCerts = new Set<string>();
+let watchCallbacks = new Set<(certs: string[]) => void>();
+
+/** Must be populated before the server starts */
+export function trustCertificate(cert: string | Buffer) {
+    cert = cert.toString();
+    if (trustedCerts.has(cert)) return;
+    trustedCerts.add(cert);
+    let certs = getTrustedCertificates();
+    for (let callback of watchCallbacks) {
+        callback(certs);
+    }
+}
+export function getTrustedCertificates(): string[] {
+    let certs: string[] = [];
+    if (isNode()) {
+        certs.push(...tls.rootCertificates);
+    }
+    certs.push(...Array.from(trustedCerts));
+    return certs;
+}
+
+export function watchTrustedCertificates(callback: (certs: string[]) => void) {
+    watchCallbacks.add(callback);
+    callback(getTrustedCertificates());
+    return () => watchCallbacks.delete(callback);
 }

package/src/fixLargeNetworkCalls.ts

@@ -1,9 +1,9 @@
-const arrayIsSplitable = Symbol.for("arrayIsSplitable");
-export function markArrayAsSplitable<T>(data: T[]): T[] {
-    (data as any)[arrayIsSplitable] = true;
-    return data;
-}
-export function isSplitableArray<T>(data: T): data is T & (unknown[]) {
-    if (!Array.isArray(data)) return false;
-    return !!(data as any)[arrayIsSplitable];
+const arrayIsSplitable = Symbol.for("arrayIsSplitable");
+export function markArrayAsSplitable<T>(data: T[]): T[] {
+    (data as any)[arrayIsSplitable] = true;
+    return data;
+}
+export function isSplitableArray<T>(data: T): data is T & (unknown[]) {
+    if (!Array.isArray(data)) return false;
+    return !!(data as any)[arrayIsSplitable];
 }

package/src/formatting/colors.ts

@@ -1,79 +1,79 @@
-export type HSL = { h: number, s: number, l: number };
-export function hslText(color: HSL): string {
-    return `hsl(${color.h}, ${color.s}%, ${color.l}%)`;
-}
-
-export function hslToRGB(color: HSL) {
-    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) };
-}
-
-export function hslToHex(color: HSL) {
-    let { r, g, b } = hslToRGB(color);
-    const toHex = (x: number) => {
-        const hex = x.toString(16);
-        return hex.length === 1 ? "0" + hex : hex;
-    };
-    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-}
-
-// Consider 
-export function hslLightenGamma(hsl: HSL, fraction: number) {
-    let l = ((hsl.l ** 2) * (1 + fraction)) ** 0.5;
-    if (l > 255) l = 255;
-    if (!l || l < 0) l = 0;
-    return { h: hsl.h, s: hsl.s, l };
-}
-export function hslLightenLinear(hsl: HSL, lightness: number) {
-    let l = hsl.l + lightness;
-    if (l > 255) l = 255;
-    if (!l || l < 0) l = 0;
-    return { h: hsl.h, s: hsl.s, l };
-}
-export function hslDarkenGamma(hsl: HSL, fraction: number) {
-    return hslLightenGamma(hsl, -fraction);
-}
-export function hslDarkenLinear(hsl: HSL, lightness: number) {
-    return hslLightenLinear(hsl, -lightness);
-}
-
-export function hslAddSaturate(hsl: HSL, saturation: number) {
-    // If something has ZERO saturation, the color is meaningless, so increasing the saturation
-    //  will likely not give the desired impact. Instead, darken the grey, which should give the desire effect.
-    if (hsl.s === 0) {
-        return hslDarkenGamma(hsl, 0.2);
-    }
-    return { h: hsl.h, s: hsl.s + saturation, l: hsl.l };
-}
-export function hslSetSaturate(hsl: HSL, saturation: number) {
-    // If something has ZERO saturation, the color is meaningless, so increasing the saturation
-    //  will likely not give the desired impact. Instead, set the lightness.
-    if (hsl.s === 0) {
-        return { h: hsl.h, s: hsl.s, l: 100 - saturation };
-    }
-    return { h: hsl.h, s: saturation, l: hsl.l };
+export type HSL = { h: number, s: number, l: number };
+export function hslText(color: HSL): string {
+    return `hsl(${color.h}, ${color.s}%, ${color.l}%)`;
+}
+
+export function hslToRGB(color: HSL) {
+    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) };
+}
+
+export function hslToHex(color: HSL) {
+    let { r, g, b } = hslToRGB(color);
+    const toHex = (x: number) => {
+        const hex = x.toString(16);
+        return hex.length === 1 ? "0" + hex : hex;
+    };
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+
+// Consider 
+export function hslLightenGamma(hsl: HSL, fraction: number) {
+    let l = ((hsl.l ** 2) * (1 + fraction)) ** 0.5;
+    if (l > 255) l = 255;
+    if (!l || l < 0) l = 0;
+    return { h: hsl.h, s: hsl.s, l };
+}
+export function hslLightenLinear(hsl: HSL, lightness: number) {
+    let l = hsl.l + lightness;
+    if (l > 255) l = 255;
+    if (!l || l < 0) l = 0;
+    return { h: hsl.h, s: hsl.s, l };
+}
+export function hslDarkenGamma(hsl: HSL, fraction: number) {
+    return hslLightenGamma(hsl, -fraction);
+}
+export function hslDarkenLinear(hsl: HSL, lightness: number) {
+    return hslLightenLinear(hsl, -lightness);
+}
+
+export function hslAddSaturate(hsl: HSL, saturation: number) {
+    // If something has ZERO saturation, the color is meaningless, so increasing the saturation
+    //  will likely not give the desired impact. Instead, darken the grey, which should give the desire effect.
+    if (hsl.s === 0) {
+        return hslDarkenGamma(hsl, 0.2);
+    }
+    return { h: hsl.h, s: hsl.s + saturation, l: hsl.l };
+}
+export function hslSetSaturate(hsl: HSL, saturation: number) {
+    // If something has ZERO saturation, the color is meaningless, so increasing the saturation
+    //  will likely not give the desired impact. Instead, set the lightness.
+    if (hsl.s === 0) {
+        return { h: hsl.h, s: hsl.s, l: 100 - saturation };
+    }
+    return { h: hsl.h, s: saturation, l: hsl.l };
 }