socket-function 0.9.6 → 0.10.0

package/SetProcessVariables.ts

@@ -0,0 +1,6 @@
+module.allowclient = true;
+import { isNode } from "./src/misc";
+
+if (!isNode()) {
+    process.env.CBOR_NATIVE_ACCELERATION_DISABLED = "true";
+}

package/SocketFunction.ts

@@ -12,6 +12,7 @@ import { lazy } from "./src/caching";
 import { delay } from "./src/batching";
 import { blue, magenta } from "./src/formatting/logColors";
 import { JSONLACKS } from "./src/JSONLACKS/JSONLACKS";
+import "./SetProcessVariables";
 import cborx from "cbor-x";
 import { setFlag } from "./require/compileFlags";
 setFlag(require, "cbor-x", "allowclient", true);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.9.6",
+	"version": "0.10.0",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -10,7 +10,7 @@
 		"mobx": "^6.6.2",
 		"node-forge": "https://github.com/sliftist/forge#name",
 		"preact": "^10.10.6",
-		"typenode": "^4.9.4-j",
+		"typenode": "5.3.3",
 		"ws": "^8.8.0"
 	},
 	"optionalDependencies": {

package/require/require.js

@@ -9,6 +9,9 @@
                 // Mirror the tnode.js setting
                 NODE_ENV: "production"
             },
+            versions: {
+
+            },
         },
         setImmediate(callback) {
             setTimeout(callback, 0);

package/src/batching.ts

@@ -1,5 +1,6 @@
 import { isNode } from "./misc";
 import { measureWrap } from "./profiling/measure";
+import { MaybePromise } from "./types";
 
 /*
     "numbers" use setTimeout
@@ -35,6 +36,14 @@ export function delay(delayTime: DelayType): Promise<void> {
     }
 }
 
+// NOTE: This is an easy way to turn off batching, without having to strip the extra batch handling code
+export function batchFunctionNone<Arg, Result = void>(
+    config: unknown,
+    fnc: (arg: Arg[]) => (Promise<Result> | Result)
+): (arg: Arg) => Promise<Result> {
+    return async arg => fnc([arg]);
+}
+
 export function batchFunction<Arg, Result = void>(
     config: {
         delay: DelayType;

package/src/callHTTPHandler.ts

@@ -50,6 +50,8 @@ export function getNodeIdsFromRequest(request: http.IncomingMessage) {
 
 export async function httpCallHandler(request: http.IncomingMessage, response: http.ServerResponse) {
     try {
+        // Always set x-frame-options, to prevent iframe embedding click hijacking
+        response.setHeader("X-Frame-Options", "SAMEORIGIN");
 
         let urlBase = request.url;
         if (!urlBase) {

package/src/misc.ts

@@ -313,4 +313,53 @@ export function last<T>(arr: T[]): T | undefined {
 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;
+}
+
+export function sort<T>(arr: T[], sortKey: (obj: T) => unknown) {
+    if (arr.length <= 1) return arr;
+    arr.sort((a, b) => compare(sortKey(a), sortKey(b)));
+    return arr;
+}
+
+// NOTE: If there are duplicates, returns the first match.
+export function binarySearchIndex(listCount: number, compare: (lhsIndex: number) => number): number {
+    if (listCount === 0) {
+        return ~0;
+    }
+    let min = 0;
+    let max = listCount - 1;
+    while (min < max) {
+        let fingerIndex = Math.floor((max + min) / 2);
+        let comparisonValue = compare(fingerIndex);
+        if (comparisonValue < 0) {
+            min = fingerIndex + 1;
+        } else {
+            max = fingerIndex;
+        }
+    }
+    let comparison = compare(min);
+    if (comparison === 0) return min;
+    if (comparison > 0) return ~min;
+    return ~(min + 1);
+}
+
+export function compare(lhs: unknown, rhs: unknown): number {
+    if (typeof lhs !== typeof rhs) {
+        return compare(typeof lhs, typeof rhs);
+    }
+    if (lhs === rhs) return 0;
+    if (lhs as any < (rhs as any)) return -1;
+    return 1;
+}
+
+export function insertIntoSortedList<T>(list: T[], map: (val: T) => string | number, element: T) {
+    let searchValue = map(element);
+    let index = binarySearchIndex(list.length, i => compare(map(list[i]), searchValue));
+    if (index < 0) index = ~index;
+    list.splice(index, 0, element);
+}
+export function removeFromSortedList<T>(list: T[], map: (val: T) => string | number, searchValue: string | number) {
+    let index = binarySearchIndex(list.length, i => compare(map(list[i]), searchValue));
+    if (index < 0) return;
+    list.splice(index, 1);
 }

package/src/nodeCache.ts

@@ -50,9 +50,16 @@ export function getNodeIdLocation(nodeId: string): { address: string, port: numb
 }
 
 export function getNodeIdDomain(nodeId: string): string {
+    let result = getNodeIdDomainMaybeUndefined(nodeId);
+    if (result === undefined) {
+        throw new Error(`Cannot get domain from nodeId, which is only usable as a client. NodeId: ${JSON.stringify(nodeId)}`);
+    }
+    return result;
+}
+export function getNodeIdDomainMaybeUndefined(nodeId: string): string | undefined {
     let location = getNodeIdLocation(nodeId);
     if (!location) {
-        throw new Error(`Cannot get domain from nodeId, which is only usable as a client. NodeId: ${JSON.stringify(nodeId)}`);
+        return undefined;
     }
     return new URL(location.address).hostname.split(".").slice(-2).join(".");
 }