socket-function 0.155.0 → 0.157.0

package/src/profiling/stats.d.ts

@@ -0,0 +1,54 @@
+export interface StatsValue {
+    count: number;
+    sum: number;
+    sumSquares: number;
+    logn7Value: number;
+    logn7Count: number;
+    logn6Value: number;
+    logn6Count: number;
+    logn5Value: number;
+    logn5Count: number;
+    logn4Value: number;
+    logn4Count: number;
+    logn3Value: number;
+    logn3Count: number;
+    logn2Value: number;
+    logn2Count: number;
+    logn1Value: number;
+    logn1Count: number;
+    log0Value: number;
+    log0VCount: number;
+    log1Value: number;
+    log1VCount: number;
+    log2Value: number;
+    log2VCount: number;
+    log3Value: number;
+    log3VCount: number;
+    log4Value: number;
+    log4VCount: number;
+    log5Value: number;
+    log5VCount: number;
+    log6Value: number;
+    log6VCount: number;
+    log7Value: number;
+    log7VCount: number;
+    log8Value: number;
+    log8VCount: number;
+    log9Value: number;
+    log9VCount: number;
+}
+export declare function createStatsValue(): StatsValue;
+export declare function addToStatsValue(stats: StatsValue, value: number): void;
+export declare function addToStats(stats: StatsValue, other: StatsValue): void;
+export interface StatsTop {
+    countFraction: number;
+    valueFraction: number;
+    count: number;
+    value: number;
+    topHeavy: boolean;
+}
+/** Identifies cases where the value is concentrated in few instances. This indicates most of the value (time)
+ *      is not spent on the common case, but on an outlier. Which isn't a problem, it just means that the measurements
+ *      should be more precise, to pull that heavy case out.
+ */
+export declare function getStatsTop(stats: StatsValue): StatsTop;

package/src/profiling/statsFormat.d.ts

@@ -0,0 +1,7 @@
+import { StatsValue } from "./stats";
+export declare function percent(value: number): string;
+export declare function formatStats(stats: StatsValue, config?: {
+    noColor?: boolean;
+    noSum?: boolean;
+    noSpaces?: boolean;
+}): string;

package/src/profiling/tcpLagProxy.d.ts

@@ -0,0 +1,18 @@
+export declare function tcpLagProxy(config: {
+    localPort: number;
+    remoteHost: string;
+    remotePort: number;
+    lag: number;
+    networkWriteSize?: {
+        value: number;
+    };
+    networkReadSize?: {
+        value: number;
+    };
+    networkWritePackets?: {
+        value: number;
+    };
+    networkReadPackets?: {
+        value: number;
+    };
+}): Promise<void>;

package/src/promiseRace.d.ts

@@ -0,0 +1,10 @@
+export declare class PromiseLessLeaky<T> extends Promise<T> {
+    constructor(executor: ((resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) | undefined);
+}
+/** A promise race function which doesn't leak, unlike Promise.race
+
+    See https://github.com/nodejs/node/issues/17469
+    See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
+
+ */
+export declare function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>>;

package/src/runPromise.d.ts

@@ -0,0 +1,7 @@
+export declare const runAsync: typeof runPromise;
+export declare function runPromise(command: string, config?: {
+    cwd?: string;
+    quiet?: boolean;
+    nothrow?: boolean;
+    detach?: boolean;
+}): Promise<string>;

package/src/sniTest.d.ts

@@ -0,0 +1 @@
+export {};

package/src/storagePath.d.ts

@@ -0,0 +1,5 @@
+export declare const getAppFolder: {
+    (): string;
+    reset(): void;
+    set(newValue: string): void;
+};

package/src/tlsParsing.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare function parseTLSHello(buffer: Buffer): {
+    extensions: {
+        type: number;
+        data: Buffer;
+    }[];
+    missingBytes: number;
+};
+export declare const SNIType = 0;
+export declare function parseSNIExtension(data: Buffer): string[];

package/src/types.d.ts

@@ -0,0 +1,6 @@
+export type MaybePromise<T> = T | Promise<T>;
+export type Args<T> = T extends (...args: infer V) => any ? V : never;
+export type AnyFunction = (...args: any) => any;
+export declare function canHaveChildren(value: unknown): value is {
+    [key in PropertyKey]: unknown;
+};

package/src/webSocketServer.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import https from "https";
+import { Watchable } from "./misc";
+export type SocketServerConfig = (https.ServerOptions & {
+    key: string | Buffer;
+    cert: string | Buffer;
+    port: number;
+    /** You can also set `port: 0` if you don't care what port you want at all.  */
+    useAvailablePortIfPortInUse?: boolean;
+    public?: boolean;
+    /** Tries forwarding ports (using UPnP), if we detect they aren't externally reachable.
+     *      - This causes an extra request and delay during startup, so should only be used
+     *          during development.
+     *      - Ignored if public is false (in which case we mount on 127.0.0.1, so port forwarding
+     *          wouldn't matter anyways).
+    */
+    autoForwardPort?: boolean;
+    ip?: string;
+    allowHostnames?: string[];
+    allowHostnameFnc?: (hostname: string) => boolean;
+    /** If the SNI matches this domain, we use a different key/cert.
+     *      We remove subdomains until we find a match
+     */
+    SNICerts?: {
+        [domain: string]: Watchable<https.ServerOptions>;
+    };
+});
+export declare function startSocketServer(config: SocketServerConfig): Promise<string>;

package/src/websocketFactory.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import tls from "tls";
+import { SenderInterface } from "./CallFactory";
+import type * as ws from "ws";
+export declare function getTLSSocket(webSocket: ws.WebSocket): tls.TLSSocket;
+/** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
+ *      a different key/cert context.
+ */
+export declare function createWebsocketFactory(): (nodeId: string) => SenderInterface;

package/test.d.ts

@@ -0,0 +1 @@
+export {};

package/time/trueTimeShim.d.ts

@@ -0,0 +1,6 @@
+export declare function getTrueTime(): number;
+export declare function getTrueTimeOffset(): number;
+export declare function waitForFirstTimeSync(): Promise<void> | undefined;
+export declare function shimDateNow(): void;
+export declare function getBrowserTime(): number;
+export declare function setGetTimeOffsetBase(base: () => Promise<number>): void;

package/tsconfig.declarations.json

@@ -0,0 +1,18 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "declaration": true,
+        "emitDeclarationOnly": true,
+        "outDir": "./",
+        "rootDir": "./"
+    },
+    "include": [
+        "**/*.ts",
+        "**/*.tsx"
+    ],
+    "exclude": [
+        "node_modules",
+        "*_venv"
+    ]
+}
+