querysub 0.433.0 → 0.436.0

package/src/path.ts

@@ -1,256 +1,256 @@
-/**
- *  Overview
- *      We escape path segments so we can quickly create a str representing
- *          that path. We do this by escaping some special character and then using a that
- *          character to indicate special values.
- *          - This appears to be faster than JSON.stringify
- *              - A random benchmark showed 140ns per, compared to 260ns for a JSON.stringify call
- *                  - ALSO, using "appendToPathStr(rootPathStr, str)" instead of getPathStr([str]) is even
- *                      faster, about 70ns per.
- *          - This lets us extend existing stres without recreating the entire str,
- *              which is significantly faster than JSON.stringify.
- *          - ALSO, escapes "." and "$", letting us use this to escape keys for mongodb usage.
- */
-
-// TODO: Change our escaping so we can turn paths into valid mongodb key names see:
-//  https://stackoverflow.com/questions/7975185/mongodb-query-over-a-str-with-special-chars-in-keys/7976235#7976235
-
-const specialChar = ".";
-
-// The character after this character is special, forming a 2 character sequence.
-export const PATH_SPECIAL_CHAR = specialChar;
-
-const pathDelimitChar = ",";
-const specialCharEscape = specialChar + "_";
-
-
-// NOTE: Our paths end up looking something like: pathDelimitEscaped + arr[0] + pathDelimitEscaped + arr[1] + pathDelimitEscaped,
-//  with the delimitter at both ends and between all elements (and with everything escaped properly).
-
-const pathDelimitEscaped = specialChar + pathDelimitChar;
-
-const afterChildSuffix = specialChar + String.fromCharCode(pathDelimitChar.charCodeAt(0) + 1);
-
-export const rootPathStr = getPathStr([]);
-
-function regexEscape(text: string) {
-    text = text.replace(/\./g, "\\.");
-    text = text.replace(/\$/g, "\\$");
-    return text;
-}
-
-let regexSpecialChar = new RegExp(regexEscape(specialChar), "g");
-let regexUnescapeSpecialChar = new RegExp(regexEscape(specialCharEscape), "g");
-
-export function escapePathPart(part: string | number | boolean | undefined | null) {
-    if (typeof part !== "string") return part;
-    if (isValidPathStr(part)) {
-        if (part.indexOf(specialChar) < 0) {
-            return part;
-        }
-    }
-    return part.replace(regexSpecialChar, specialCharEscape);
-}
-function unescapePathPart(part: string) {
-    part = part.replace(regexUnescapeSpecialChar, specialChar);
-    return part;
-}
-
-
-
-export function getPathStr(path: (string | number | boolean | undefined | null)[]) {
-    return pathDelimitEscaped + path.map(x => escapePathPart(x) + pathDelimitEscaped).join("");
-}
-/** Equivalent to getPathStr([path0]), except a bit faster */
-export function getPathStr1(path0: string) {
-    return appendToPathStr(rootPathStr, path0);
-}
-/** Equivalent to getPathStr([path0, path1]), except a bit faster */
-export function getPathStr2(path0: string, path1: string) {
-    // TODO: Benchmark this again. If I recall correctly, if we are ONLY string paths, this is about
-    //  twice as fast as getPathStr([path0, path1])? This is because allocating arrays is slow.
-    return appendToPathStr(appendToPathStr(rootPathStr, path0), path1);
-}
-/** Equivalent to getPathStr([path0, path1, path2]), except a bit faster */
-export function getPathStr3(path0: string, path1: string, path2: string) {
-    return appendToPathStr(appendToPathStr(appendToPathStr(rootPathStr, path0), path1), path2);
-}
-export function getPathStr4(path0: string, path1: string, path2: string, path3: string) {
-    let value = rootPathStr;
-    value = appendToPathStr(value, path0);
-    value = appendToPathStr(value, path1);
-    value = appendToPathStr(value, path2);
-    value = appendToPathStr(value, path3);
-    return value;
-}
-
-export function appendToPathStr(pathStr: string, pathPart: string) {
-    if (pathStr[pathStr.length - 1] !== pathDelimitChar) {
-        // Might be a hacked path
-        pathStr = hack_stripPackedPath(pathStr);
-    }
-    return pathStr + escapePathPart(pathPart) + pathDelimitEscaped;
-}
-export function prependToPathStr(pathStr: string, pathPart: string) {
-    return pathDelimitEscaped + escapePathPart(pathPart) + pathStr;
-}
-
-export function pathStrIncludesValue(pathStr: string, value: string) {
-    value = String(escapePathPart(value));
-    return pathStr.includes(value);
-}
-
-export function joinPathStres(lhsStr: string, rhsStr: string) {
-    return lhsStr + rhsStr.slice(rootPathStr.length);
-}
-
-export function getPathIndexAssert(pathStr: string, index: number): string {
-    let value = getPathIndex(pathStr, index);
-    if (value === undefined) {
-        throw new Error(`Path index ${index} was undefined in pathStr ${pathStr}`);
-    }
-    return value;
-}
-export function getPathIndex(pathStr: string, index: number) {
-    let parts = pathStr.split(pathDelimitEscaped);
-    if (parts.length - 2 <= index) {
-        return undefined;
-    }
-    if (index < 0) {
-        index = parts.length - 2 + index;
-    }
-    let part = parts[index + 1];
-    if (part === undefined) {
-        return undefined;
-    }
-    return unescapePathPart(part);
-}
-export function getPathFromStr(pathStr: string) {
-    return pathStr.split(pathDelimitEscaped).slice(1, -1).map(x => unescapePathPart(x));
-}
-
-export function isValidPathStr(pathStr: string) {
-    return pathStr.startsWith(pathDelimitEscaped) && pathStr.endsWith(pathDelimitEscaped);
-}
-
-/** Gets the path after all children of the pathStr, BUT, before the next sibling (when sorting lexicographically by path str). */
-export function getPathAfterLastChild(pathStr: string) {
-    if (pathStr === "") {
-        return afterChildSuffix;
-    }
-    // NOTE: assertArg isn't used, to reduce the readLocks of path.ts, which is used itself by assertArg.
-    if (!pathStr.endsWith(pathDelimitEscaped)) {
-        throw new Error(`pathStr must end with ${JSON.stringify(pathDelimitEscaped)}, was ${JSON.stringify(pathStr)}`);
-    }
-    // Any sibling before us, will lexicographically be < us BEFORE the last character, the same as any sibling after us.
-    //  However, children't will match all the way to our suffix, and then be < our modified suffix.
-    return pathStr.slice(0, -pathDelimitEscaped.length) + afterChildSuffix;
-}
-
-function getStartOfLastPart(pathStr: string) {
-    // I'm not sure if this is what we should be doing for hacked paths. In theory, a hacked path basically represents select these children, selecting specific children. So, in theory, that should mean... The parent is the parent of those children. However, we also use it to keep track of the parent sync, in which case we are syncing the parent. And so the parent we want, if we ever recall this, would be actually the parent of that. So I think in theory we should uncomment this code, but in practice we need to keep it commented. 
-    // if(hack_isPackedPath(pathStr)) {
-    //     let index = pathStr.lastIndexOf(pathDelimitEscaped);
-    //     if(index < 0) return pathStr.length;
-    //     return index + pathDelimitEscaped.length;
-    // }
-    let index = pathStr.lastIndexOf(pathDelimitEscaped);
-    if (index < 0) return pathStr.length;
-    let index2 = pathStr.lastIndexOf(pathDelimitEscaped, index - 1);
-    if (index2 < 0) return 0;
-    return index2 + pathDelimitEscaped.length;
-}
-
-/** === getPathStr(getPathFromStr(pathStr).slice(0, -1)), getParentPathStr(rootPathStr) === rootPathStr */
-export function getParentPathStr(pathStr: string) {
-    // Allow empty string? Better than throwing on it, I guess
-    if (pathStr === "") {
-        return "";
-    }
-    //  an additional check.
-    return pathStr.slice(0, getStartOfLastPart(pathStr));
-}
-
-/** === getPathFromStr(pathStr).slice(-1)[0] || "" */
-export function getLastPathPart(pathStr: string) {
-    let lastPartIndex = pathStr.lastIndexOf(pathDelimitEscaped);
-    if (lastPartIndex < 0) return "";
-    return unescapePathPart(
-        pathStr.slice(
-            getStartOfLastPart(pathStr),
-            lastPartIndex,
-        )
-    );
-}
-
-/** === getPathStr(getPathFromStr(pathStr).slice(0, -1)) */
-export function removePathLastPart(pathStr: string) {
-    return pathStr.slice(0, getStartOfLastPart(pathStr));
-}
-
-let lastPastPath = { path: "", depth: 0 };
-/** getPathDepth(pathStr) === getPathFromStr(pathStr).length */
-export function getPathDepth(pathStr: string): number {
-    if (lastPastPath.path === pathStr) {
-        return lastPastPath.depth;
-    }
-    // Start at 1, to skip the first pathDelimit
-    let index = 1;
-    // Start at -1, as the last loop doesn't have pathDelimitEscaped, but is still incremented
-    let count = -1;
-    while (index > 0) {
-        count++;
-        index = pathStr.indexOf(pathDelimitEscaped, index) + 1;
-    }
-    lastPastPath.path = pathStr;
-    lastPastPath.depth = count;
-    return count;
-}
-
-export const getPathPrefix = trimPathStrToDepth;
-export function trimPathStrToDepth(pathStr: string, depth: number): string {
-    let index = 0;
-    let count = 0;
-    while (count < depth) {
-        let nextIndex = pathStr.indexOf(pathDelimitEscaped, index + 1);
-        if (nextIndex < 0) break;
-        count++;
-        index = nextIndex;
-    }
-    return pathStr.slice(0, index + pathDelimitEscaped.length);
-}
-export const slicePathStrToDepth = trimPathStrToDepth;
-export function getPathSuffix(pathStr: string, depth: number): string {
-    let index = 0;
-    let count = 0;
-    while (count < depth) {
-        let nextIndex = pathStr.indexOf(pathDelimitEscaped, index + 1);
-        if (nextIndex < 0) break;
-        count++;
-        index = nextIndex;
-    }
-    return pathStr.slice(index);
-}
-
-/** A hack, which breaks some path functions, but... which works with enough to save a
- *      lot of code and time when we need a bit more information that shouldn't count as
- *      path information. */
-export function hack_setPackedPathSuffix(path: string, suffix: string): string {
-    return path + suffix;
-}
-export function hack_isPackedPath(path: string) {
-    return !path.endsWith(pathDelimitEscaped);
-}
-export function hack_getPackedPathSuffix(path: string): string {
-    if (!hack_isPackedPath(path)) {
-        return "";
-    }
-    return getPathSuffix(path, getPathDepth(path)).slice(pathDelimitEscaped.length);
-}
-export function hack_stripPackedPath(path: string): string {
-    if (!hack_isPackedPath(path)) {
-        return path;
-    }
-    let suffix = hack_getPackedPathSuffix(path);
-    return path.slice(0, -suffix.length);
+/**
+ *  Overview
+ *      We escape path segments so we can quickly create a str representing
+ *          that path. We do this by escaping some special character and then using a that
+ *          character to indicate special values.
+ *          - This appears to be faster than JSON.stringify
+ *              - A random benchmark showed 140ns per, compared to 260ns for a JSON.stringify call
+ *                  - ALSO, using "appendToPathStr(rootPathStr, str)" instead of getPathStr([str]) is even
+ *                      faster, about 70ns per.
+ *          - This lets us extend existing stres without recreating the entire str,
+ *              which is significantly faster than JSON.stringify.
+ *          - ALSO, escapes "." and "$", letting us use this to escape keys for mongodb usage.
+ */
+
+// TODO: Change our escaping so we can turn paths into valid mongodb key names see:
+//  https://stackoverflow.com/questions/7975185/mongodb-query-over-a-str-with-special-chars-in-keys/7976235#7976235
+
+const specialChar = ".";
+
+// The character after this character is special, forming a 2 character sequence.
+export const PATH_SPECIAL_CHAR = specialChar;
+
+const pathDelimitChar = ",";
+const specialCharEscape = specialChar + "_";
+
+
+// NOTE: Our paths end up looking something like: pathDelimitEscaped + arr[0] + pathDelimitEscaped + arr[1] + pathDelimitEscaped,
+//  with the delimitter at both ends and between all elements (and with everything escaped properly).
+
+const pathDelimitEscaped = specialChar + pathDelimitChar;
+
+const afterChildSuffix = specialChar + String.fromCharCode(pathDelimitChar.charCodeAt(0) + 1);
+
+export const rootPathStr = getPathStr([]);
+
+function regexEscape(text: string) {
+    text = text.replace(/\./g, "\\.");
+    text = text.replace(/\$/g, "\\$");
+    return text;
+}
+
+let regexSpecialChar = new RegExp(regexEscape(specialChar), "g");
+let regexUnescapeSpecialChar = new RegExp(regexEscape(specialCharEscape), "g");
+
+export function escapePathPart(part: string | number | boolean | undefined | null) {
+    if (typeof part !== "string") return part;
+    if (isValidPathStr(part)) {
+        if (part.indexOf(specialChar) < 0) {
+            return part;
+        }
+    }
+    return part.replace(regexSpecialChar, specialCharEscape);
+}
+function unescapePathPart(part: string) {
+    part = part.replace(regexUnescapeSpecialChar, specialChar);
+    return part;
+}
+
+
+
+export function getPathStr(path: (string | number | boolean | undefined | null)[]) {
+    return pathDelimitEscaped + path.map(x => escapePathPart(x) + pathDelimitEscaped).join("");
+}
+/** Equivalent to getPathStr([path0]), except a bit faster */
+export function getPathStr1(path0: string) {
+    return appendToPathStr(rootPathStr, path0);
+}
+/** Equivalent to getPathStr([path0, path1]), except a bit faster */
+export function getPathStr2(path0: string, path1: string) {
+    // TODO: Benchmark this again. If I recall correctly, if we are ONLY string paths, this is about
+    //  twice as fast as getPathStr([path0, path1])? This is because allocating arrays is slow.
+    return appendToPathStr(appendToPathStr(rootPathStr, path0), path1);
+}
+/** Equivalent to getPathStr([path0, path1, path2]), except a bit faster */
+export function getPathStr3(path0: string, path1: string, path2: string) {
+    return appendToPathStr(appendToPathStr(appendToPathStr(rootPathStr, path0), path1), path2);
+}
+export function getPathStr4(path0: string, path1: string, path2: string, path3: string) {
+    let value = rootPathStr;
+    value = appendToPathStr(value, path0);
+    value = appendToPathStr(value, path1);
+    value = appendToPathStr(value, path2);
+    value = appendToPathStr(value, path3);
+    return value;
+}
+
+export function appendToPathStr(pathStr: string, pathPart: string) {
+    if (pathStr[pathStr.length - 1] !== pathDelimitChar) {
+        // Might be a hacked path
+        pathStr = hack_stripPackedPath(pathStr);
+    }
+    return pathStr + escapePathPart(pathPart) + pathDelimitEscaped;
+}
+export function prependToPathStr(pathStr: string, pathPart: string) {
+    return pathDelimitEscaped + escapePathPart(pathPart) + pathStr;
+}
+
+export function pathStrIncludesValue(pathStr: string, value: string) {
+    value = String(escapePathPart(value));
+    return pathStr.includes(value);
+}
+
+export function joinPathStres(lhsStr: string, rhsStr: string) {
+    return lhsStr + rhsStr.slice(rootPathStr.length);
+}
+
+export function getPathIndexAssert(pathStr: string, index: number): string {
+    let value = getPathIndex(pathStr, index);
+    if (value === undefined) {
+        throw new Error(`Path index ${index} was undefined in pathStr ${pathStr}`);
+    }
+    return value;
+}
+export function getPathIndex(pathStr: string, index: number) {
+    let parts = pathStr.split(pathDelimitEscaped);
+    if (parts.length - 2 <= index) {
+        return undefined;
+    }
+    if (index < 0) {
+        index = parts.length - 2 + index;
+    }
+    let part = parts[index + 1];
+    if (part === undefined) {
+        return undefined;
+    }
+    return unescapePathPart(part);
+}
+export function getPathFromStr(pathStr: string) {
+    return pathStr.split(pathDelimitEscaped).slice(1, -1).map(x => unescapePathPart(x));
+}
+
+export function isValidPathStr(pathStr: string) {
+    return pathStr.startsWith(pathDelimitEscaped) && pathStr.endsWith(pathDelimitEscaped);
+}
+
+/** Gets the path after all children of the pathStr, BUT, before the next sibling (when sorting lexicographically by path str). */
+export function getPathAfterLastChild(pathStr: string) {
+    if (pathStr === "") {
+        return afterChildSuffix;
+    }
+    // NOTE: assertArg isn't used, to reduce the readLocks of path.ts, which is used itself by assertArg.
+    if (!pathStr.endsWith(pathDelimitEscaped)) {
+        throw new Error(`pathStr must end with ${JSON.stringify(pathDelimitEscaped)}, was ${JSON.stringify(pathStr)}`);
+    }
+    // Any sibling before us, will lexicographically be < us BEFORE the last character, the same as any sibling after us.
+    //  However, children't will match all the way to our suffix, and then be < our modified suffix.
+    return pathStr.slice(0, -pathDelimitEscaped.length) + afterChildSuffix;
+}
+
+function getStartOfLastPart(pathStr: string) {
+    // I'm not sure if this is what we should be doing for hacked paths. In theory, a hacked path basically represents select these children, selecting specific children. So, in theory, that should mean... The parent is the parent of those children. However, we also use it to keep track of the parent sync, in which case we are syncing the parent. And so the parent we want, if we ever recall this, would be actually the parent of that. So I think in theory we should uncomment this code, but in practice we need to keep it commented. 
+    // if(hack_isPackedPath(pathStr)) {
+    //     let index = pathStr.lastIndexOf(pathDelimitEscaped);
+    //     if(index < 0) return pathStr.length;
+    //     return index + pathDelimitEscaped.length;
+    // }
+    let index = pathStr.lastIndexOf(pathDelimitEscaped);
+    if (index < 0) return pathStr.length;
+    let index2 = pathStr.lastIndexOf(pathDelimitEscaped, index - 1);
+    if (index2 < 0) return 0;
+    return index2 + pathDelimitEscaped.length;
+}
+
+/** === getPathStr(getPathFromStr(pathStr).slice(0, -1)), getParentPathStr(rootPathStr) === rootPathStr */
+export function getParentPathStr(pathStr: string) {
+    // Allow empty string? Better than throwing on it, I guess
+    if (pathStr === "") {
+        return "";
+    }
+    //  an additional check.
+    return pathStr.slice(0, getStartOfLastPart(pathStr));
+}
+
+/** === getPathFromStr(pathStr).slice(-1)[0] || "" */
+export function getLastPathPart(pathStr: string) {
+    let lastPartIndex = pathStr.lastIndexOf(pathDelimitEscaped);
+    if (lastPartIndex < 0) return "";
+    return unescapePathPart(
+        pathStr.slice(
+            getStartOfLastPart(pathStr),
+            lastPartIndex,
+        )
+    );
+}
+
+/** === getPathStr(getPathFromStr(pathStr).slice(0, -1)) */
+export function removePathLastPart(pathStr: string) {
+    return pathStr.slice(0, getStartOfLastPart(pathStr));
+}
+
+let lastPastPath = { path: "", depth: 0 };
+/** getPathDepth(pathStr) === getPathFromStr(pathStr).length */
+export function getPathDepth(pathStr: string): number {
+    if (lastPastPath.path === pathStr) {
+        return lastPastPath.depth;
+    }
+    // Start at 1, to skip the first pathDelimit
+    let index = 1;
+    // Start at -1, as the last loop doesn't have pathDelimitEscaped, but is still incremented
+    let count = -1;
+    while (index > 0) {
+        count++;
+        index = pathStr.indexOf(pathDelimitEscaped, index) + 1;
+    }
+    lastPastPath.path = pathStr;
+    lastPastPath.depth = count;
+    return count;
+}
+
+export const getPathPrefix = trimPathStrToDepth;
+export function trimPathStrToDepth(pathStr: string, depth: number): string {
+    let index = 0;
+    let count = 0;
+    while (count < depth) {
+        let nextIndex = pathStr.indexOf(pathDelimitEscaped, index + 1);
+        if (nextIndex < 0) break;
+        count++;
+        index = nextIndex;
+    }
+    return pathStr.slice(0, index + pathDelimitEscaped.length);
+}
+export const slicePathStrToDepth = trimPathStrToDepth;
+export function getPathSuffix(pathStr: string, depth: number): string {
+    let index = 0;
+    let count = 0;
+    while (count < depth) {
+        let nextIndex = pathStr.indexOf(pathDelimitEscaped, index + 1);
+        if (nextIndex < 0) break;
+        count++;
+        index = nextIndex;
+    }
+    return pathStr.slice(index);
+}
+
+/** A hack, which breaks some path functions, but... which works with enough to save a
+ *      lot of code and time when we need a bit more information that shouldn't count as
+ *      path information. */
+export function hack_setPackedPathSuffix(path: string, suffix: string): string {
+    return path + suffix;
+}
+export function hack_isPackedPath(path: string) {
+    return !path.endsWith(pathDelimitEscaped);
+}
+export function hack_getPackedPathSuffix(path: string): string {
+    if (!hack_isPackedPath(path)) {
+        return "";
+    }
+    return getPathSuffix(path, getPathDepth(path)).slice(pathDelimitEscaped.length);
+}
+export function hack_stripPackedPath(path: string): string {
+    if (!hack_isPackedPath(path)) {
+        return path;
+    }
+    let suffix = hack_getPackedPathSuffix(path);
+    return path.slice(0, -suffix.length);
 }

package/src/persistentLocalStore.ts

@@ -1,42 +1,42 @@
-module.allowclient = true;
-
-import { isNode } from "socket-function/src/misc";
-import fs from "fs";
-import { getStorageDir, getSubFolder } from "./fs";
-import { isClient } from "./config2";
-import { getDomain } from "./config";
-import os from "os";
-
-export function createKeyStore<T>(key: string): {
-    value: T | null;
-} {
-    if (isNode()) {
-        let keyStoreDir = os.homedir() + "/querysub/";
-        if (!fs.existsSync(keyStoreDir)) {
-            fs.mkdirSync(keyStoreDir);
-        }
-        let path = keyStoreDir + key + ".json";
-        return {
-            get value() {
-                let contents: string | undefined = undefined;
-                try { contents = fs.readFileSync(path, "utf8"); } catch { }
-                if (!contents) return null;
-                return JSON.parse(contents) as T;
-            },
-            set value(value: T | null) {
-                fs.writeFileSync(path, JSON.stringify(value));
-            }
-        };
-    } else {
-        return {
-            get value() {
-                let json = localStorage.getItem(key);
-                if (!json) return null;
-                return JSON.parse(json) as T;
-            },
-            set value(value: T | null) {
-                localStorage.setItem(key, JSON.stringify(value));
-            }
-        };
-    }
+module.allowclient = true;
+
+import { isNode } from "socket-function/src/misc";
+import fs from "fs";
+import { getStorageDir, getSubFolder } from "./fs";
+import { isClient } from "./config2";
+import { getDomain } from "./config";
+import os from "os";
+
+export function createKeyStore<T>(key: string): {
+    value: T | null;
+} {
+    if (isNode()) {
+        let keyStoreDir = os.homedir() + "/querysub/";
+        if (!fs.existsSync(keyStoreDir)) {
+            fs.mkdirSync(keyStoreDir);
+        }
+        let path = keyStoreDir + key + ".json";
+        return {
+            get value() {
+                let contents: string | undefined = undefined;
+                try { contents = fs.readFileSync(path, "utf8"); } catch { }
+                if (!contents) return null;
+                return JSON.parse(contents) as T;
+            },
+            set value(value: T | null) {
+                fs.writeFileSync(path, JSON.stringify(value));
+            }
+        };
+    } else {
+        return {
+            get value() {
+                let json = localStorage.getItem(key);
+                if (!json) return null;
+                return JSON.parse(json) as T;
+            },
+            set value(value: T | null) {
+                localStorage.setItem(key, JSON.stringify(value));
+            }
+        };
+    }
 }

package/src/promise.ts

@@ -1,15 +1,15 @@
-export class PromiseObj<T = void> {
-    public promise: Promise<T>;
-    public resolve!: (value: T | PromiseLike<T>) => void;
-    public reject!: (reason?: any) => void;
-    public resolved = false;
-    public rejected = false;
-    constructor() {
-        this.promise = new Promise<T>((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
-        });
-        void this.promise.finally(() => this.resolved = true);
-        this.promise.catch(() => this.rejected = true);
-    }
+export class PromiseObj<T = void> {
+    public promise: Promise<T>;
+    public resolve!: (value: T | PromiseLike<T>) => void;
+    public reject!: (reason?: any) => void;
+    public resolved = false;
+    public rejected = false;
+    constructor() {
+        this.promise = new Promise<T>((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+        void this.promise.finally(() => this.resolved = true);
+        this.promise.catch(() => this.rejected = true);
+    }
 }