socket-function 0.97.0 → 0.99.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.97.0",
+	"version": "0.99.0",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/require/RequireController.ts

@@ -8,6 +8,7 @@ import zlib from "zlib";
 import { cacheLimited, lazy } from "../src/caching";
 import { formatNumber } from "../src/formatting/format";
 import { requireMain } from "./require";
+import path from "path";
 
 const COMPRESS_CACHE_SIZE = 1024 * 1024 * 128;
 
@@ -136,6 +137,11 @@ class RequireControllerBase {
         requireCalls?: string[];
         cacheTime?: number;
     }) {
+        if (!this.rootResolvePath) {
+            let dir = path.resolve(".");
+            dir = dir.replaceAll("\\", "/");
+            this.rootResolvePath = dir;
+        }
         let { requireCalls, cacheTime } = config || {};
         let result = resolvedHTMLFile();
         if (beforeEntryText.length > 0) {
@@ -405,8 +411,14 @@ declare global {
 }
 
 let baseController = new RequireControllerBase();
-export function setRequireBootRequire(path: string) {
-    baseController.rootResolvePath = path;
+/** @deprecated, not needed, as this defaults to ".", which is a lot easier to reason about anyways. */
+export function setRequireBootRequire(dir: string) {
+    dir = path.resolve(dir);
+    dir = dir.replaceAll("\\", "/");
+    if (!dir.endsWith("/")) {
+        dir += "/";
+    }
+    baseController.rootResolvePath = dir;
 }
 
 export const RequireController = SocketFunction.register(

package/src/misc.ts

@@ -406,4 +406,42 @@ export function removeFromSortedList<T>(list: T[], map: (val: T) => string | num
     let index = binarySearchIndex(list.length, i => compare(map(list[i]), searchValue));
     if (index < 0) return;
     list.splice(index, 1);
-}
+}
+
+
+
+export function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error) {
+    return new Promise<T>((resolve, reject) => {
+        let timeout = setTimeout(() => reject(err()), time);
+        p.then(resolve, reject).finally(() => clearTimeout(timeout));
+    });
+}
+
+// NOTE: Both errors and timeouts are converted to undefined
+export function timeoutToUndefined<T>(time: number, p: Promise<T>) {
+    return new Promise<T | undefined>((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            console.error(`timeoutToUndefined timed out after ${time}`);
+            resolve(undefined);
+        }, time);
+        p.then(resolve,
+            (err) => {
+                console.error(`timeoutToUndefined error: ${err.stack}`);
+                resolve(undefined);
+            }
+        ).finally(() => clearTimeout(timeout));
+    });
+}
+export function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>) {
+    return new Promise<T | undefined>((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            resolve(undefined);
+        }, time);
+        p.then(
+            resolve,
+            (err) => {
+                resolve(undefined);
+            }
+        ).finally(() => clearTimeout(timeout));
+    });
+}