@stackframe/stack-shared 1.0.0

package/dist/utils/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../src/utils/math.tsx"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dist/utils/math.js

@@ -0,0 +1,6 @@
+/**
+ * Similar to the modulo operator, but always returns a positive number (even when the input is negative).
+ */
+export function remainder(n, d) {
+    return ((n % d) + Math.abs(d)) % d;
+}

package/dist/utils/numbers.d.ts

@@ -0,0 +1,2 @@
+export declare function prettyPrintWithMagnitudes(num: number): string;
+export declare function toFixedMax(num: number, maxDecimals: number): string;

package/dist/utils/numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../src/utils/numbers.tsx"],"names":[],"mappings":"AAQA,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAY7D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAEnE"}

package/dist/utils/numbers.js

@@ -0,0 +1,26 @@
+const magnitudes = [
+    [1_000_000_000_000_000, "trln"],
+    [1_000_000_000_000, "bln"],
+    [1_000_000_000, "bn"],
+    [1_000_000, "M"],
+    [1_000, "k"],
+];
+export function prettyPrintWithMagnitudes(num) {
+    if (typeof num !== "number")
+        throw new Error("Expected a number");
+    if (Number.isNaN(num))
+        return "NaN";
+    if (num < 0)
+        return "-" + prettyPrintWithMagnitudes(-num);
+    if (!Number.isFinite(num))
+        return "∞";
+    for (const [magnitude, suffix] of magnitudes) {
+        if (num >= magnitude) {
+            return toFixedMax(num / magnitude, 1) + suffix;
+        }
+    }
+    return toFixedMax(num, 1); // Handle numbers less than 1,000 without suffix.
+}
+export function toFixedMax(num, maxDecimals) {
+    return num.toFixed(maxDecimals).replace(/\.?0+$/, "");
+}

package/dist/utils/objects.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
+ *
+ * Note that since they are assumed to be plain objects, this function does not compare prototypes.
+ */
+export declare function deepPlainEquals<T>(obj1: T, obj2: unknown): obj2 is T;
+export declare function typedEntries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
+export declare function typedFromEntries<T extends {}>(entries: [keyof T, T[keyof T]][]): Partial<T>;
+export declare function typedKeys<T extends {}>(obj: T): (keyof T)[];
+export declare function typedValues<T extends {}>(obj: T): T[keyof T][];
+export declare function typedAssign<T extends {}, U extends {}>(target: T, source: U): asserts target is T & U;
+/**
+ * Returns a new object with all undefined values removed. Useful when spreading optional parameters on an object, as
+ * TypeScript's `Partial<XYZ>` type allows `undefined` values.
+ */
+export declare function filterUndefined<T extends {}>(obj: T): {
+    [k in keyof T]+?: T[k] & ({} | null);
+};

package/dist/utils/objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/utils/objects.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,CAAC,CAgCpE;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAE1E;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAE3F;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAE3D;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAE9D;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,CAErG;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC;CAAE,CAE9F"}

package/dist/utils/objects.js

@@ -0,0 +1,63 @@
+/**
+ * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
+ *
+ * Note that since they are assumed to be plain objects, this function does not compare prototypes.
+ */
+export function deepPlainEquals(obj1, obj2) {
+    if (typeof obj1 !== typeof obj2)
+        return false;
+    if (obj1 === obj2)
+        return true;
+    switch (typeof obj1) {
+        case 'object': {
+            if (!obj1 || !obj2)
+                return false;
+            if (Array.isArray(obj1) || Array.isArray(obj2)) {
+                if (!Array.isArray(obj1) || !Array.isArray(obj2))
+                    return false;
+                if (obj1.length !== obj2.length)
+                    return false;
+                return obj1.every((v, i) => deepPlainEquals(v, obj2[i]));
+            }
+            const keys1 = Object.keys(obj1);
+            const keys2 = Object.keys(obj2);
+            if (keys1.length !== keys2.length)
+                return false;
+            return keys1.every((k) => k in obj2 && deepPlainEquals(obj1[k], obj2[k]));
+        }
+        case 'undefined':
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+        case 'symbol':
+        case 'function': {
+            return false;
+        }
+        default: {
+            throw new Error("Unexpected typeof " + typeof obj1);
+        }
+    }
+}
+export function typedEntries(obj) {
+    return Object.entries(obj);
+}
+export function typedFromEntries(entries) {
+    return Object.fromEntries(entries);
+}
+export function typedKeys(obj) {
+    return Object.keys(obj);
+}
+export function typedValues(obj) {
+    return Object.values(obj);
+}
+export function typedAssign(target, source) {
+    Object.assign(target, source);
+}
+/**
+ * Returns a new object with all undefined values removed. Useful when spreading optional parameters on an object, as
+ * TypeScript's `Partial<XYZ>` type allows `undefined` values.
+ */
+export function filterUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}

package/dist/utils/password.d.ts

@@ -0,0 +1,2 @@
+export declare function hashPassword(password: string): Promise<string>;
+export declare function comparePassword(password: string, hash: string): Promise<boolean>;

package/dist/utils/password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../src/utils/password.tsx"],"names":[],"mappings":"AAEA,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,mBAGlD;AAED,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,oBAEnE"}

package/dist/utils/password.js

@@ -0,0 +1,8 @@
+import bcrypt from 'bcrypt';
+export async function hashPassword(password) {
+    const salt = await bcrypt.genSalt(10);
+    return await bcrypt.hash(password, salt);
+}
+export async function comparePassword(password, hash) {
+    return await bcrypt.compare(password, hash);
+}

package/dist/utils/promises.d.ts

@@ -0,0 +1,49 @@
+import { Result } from "./results";
+import type { RejectedThenable, FulfilledThenable, PendingThenable } from "react";
+export type ReactPromise<T> = Promise<T> & (RejectedThenable<T> | FulfilledThenable<T> | PendingThenable<T>);
+type Resolve<T> = (value: T) => void;
+type Reject = (reason: unknown) => void;
+export declare function createPromise<T>(callback: (resolve: Resolve<T>, reject: Reject) => void): ReactPromise<T>;
+/**
+ * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook.
+ */
+export declare function resolved<T>(value: T): ReactPromise<T>;
+/**
+ * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook.
+ */
+export declare function rejected<T>(reason: unknown): ReactPromise<T>;
+export declare function neverResolve(): ReactPromise<never>;
+export declare function wait(ms: number): Promise<void>;
+export declare function waitUntil(date: Date): Promise<void>;
+export declare function runAsynchronously(promiseOrFunc: Promise<unknown> | (() => Promise<unknown>) | undefined): void;
+declare class TimeoutError extends Error {
+    readonly ms: number;
+    constructor(ms: number);
+}
+export declare function timeout<T>(promise: Promise<T>, ms: number): Promise<Result<T, TimeoutError>>;
+export declare function timeoutThrow<T>(promise: Promise<T>, ms: number): Promise<T>;
+export type RateLimitOptions = {
+    /**
+     * The number of requests to process in parallel. Currently only 1 is supported.
+     */
+    concurrency: 1;
+    /**
+     * If true, multiple requests waiting at the same time will be reduced to just one. Default is false.
+     */
+    batchCalls?: boolean;
+    /**
+     * Waits for throttleMs since the start of last request before starting the next request. Default is 0.
+     */
+    throttleMs?: number;
+    /**
+     * Waits for gapMs since the end of last request before starting the next request. Default is 0.
+     */
+    gapMs?: number;
+    /**
+     * Waits until there have been no new requests for debounceMs before starting a new request. Default is 0.
+     */
+    debounceMs?: number;
+};
+export declare function rateLimited<T>(func: () => Promise<T>, options: RateLimitOptions): () => Promise<T>;
+export declare function throttled<T, A extends any[]>(func: (...args: A) => Promise<T>, delayMs: number): (...args: A) => Promise<T>;
+export {};

package/dist/utils/promises.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.d.ts","sourceRoot":"","sources":["../../src/utils/promises.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAElF,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,CACvC,gBAAgB,CAAC,CAAC,CAAC,GACnB,iBAAiB,CAAC,CAAC,CAAC,GACpB,eAAe,CAAC,CAAC,CAAC,CACrB,CAAC;AAEF,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AACrC,KAAK,MAAM,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;AACxC,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,CA0BzG;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAKrD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,GAAG,YAAY,CAAC,CAAC,CAAC,CAK5D;AAED,wBAAgB,YAAY,IAAI,YAAY,CAAC,KAAK,CAAC,CAIlD;AAED,wBAAsB,IAAI,CAAC,EAAE,EAAE,MAAM,iBAEpC;AAED,wBAAsB,SAAS,CAAC,IAAI,EAAE,IAAI,iBAEzC;AAED,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAa9G;AAGD,cAAM,YAAa,SAAQ,KAAK;aACF,EAAE,EAAE,MAAM;gBAAV,EAAE,EAAE,MAAM;CAIvC;AAED,wBAAsB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAKlG;AAED,wBAAsB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAEjF;AAGD,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;OAEG;IACH,WAAW,EAAE,CAAC,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,OAAO,EAAE,gBAAgB,GACxB,MAAM,OAAO,CAAC,CAAC,CAAC,CAoDlB;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,GAAG,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAe3H"}

package/dist/utils/promises.js

@@ -0,0 +1,145 @@
+import { Result } from "./results";
+import { generateUuid } from "./uuids";
+export function createPromise(callback) {
+    let status = "pending";
+    let valueOrReason = undefined;
+    let resolve = null;
+    let reject = null;
+    const promise = new Promise((res, rej) => {
+        resolve = (value) => {
+            if (status !== "pending")
+                return;
+            status = "fulfilled";
+            valueOrReason = value;
+            res(value);
+        };
+        reject = (reason) => {
+            if (status !== "pending")
+                return;
+            status = "rejected";
+            valueOrReason = reason;
+            rej(reason);
+        };
+    });
+    callback(resolve, reject);
+    return Object.assign(promise, {
+        status: status,
+        ...status === "fulfilled" ? { value: valueOrReason } : {},
+        ...status === "rejected" ? { reason: valueOrReason } : {},
+    });
+}
+/**
+ * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook.
+ */
+export function resolved(value) {
+    return Object.assign(Promise.resolve(value), {
+        status: "fulfilled",
+        value,
+    });
+}
+/**
+ * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook.
+ */
+export function rejected(reason) {
+    return Object.assign(Promise.reject(reason), {
+        status: "rejected",
+        reason,
+    });
+}
+export function neverResolve() {
+    return Object.assign(new Promise(() => { }), {
+        status: "pending",
+    });
+}
+export async function wait(ms) {
+    return await new Promise(resolve => setTimeout(resolve, ms));
+}
+export async function waitUntil(date) {
+    return await wait(date.getTime() - Date.now());
+}
+export function runAsynchronously(promiseOrFunc) {
+    if (typeof promiseOrFunc === "function") {
+        promiseOrFunc = promiseOrFunc();
+    }
+    promiseOrFunc?.catch(error => {
+        const newError = new Error("Uncaught error in asynchronous function: " + error.toString(), {
+            cause: error,
+        });
+        console.error(newError);
+    });
+}
+class TimeoutError extends Error {
+    ms;
+    constructor(ms) {
+        super(`Timeout after ${ms}ms`);
+        this.ms = ms;
+        this.name = "TimeoutError";
+    }
+}
+export async function timeout(promise, ms) {
+    return await Promise.race([
+        promise.then(value => Result.ok(value)),
+        wait(ms).then(() => Result.error(new TimeoutError(ms))),
+    ]);
+}
+export async function timeoutThrow(promise, ms) {
+    return Result.orThrow(await timeout(promise, ms));
+}
+export function rateLimited(func, options) {
+    let waitUntil = performance.now();
+    let queue = [];
+    let addedToQueueCallbacks = new Map;
+    const next = async () => {
+        while (true) {
+            if (waitUntil > performance.now()) {
+                await wait(Math.max(1, waitUntil - performance.now() + 1));
+            }
+            else if (queue.length === 0) {
+                const uuid = generateUuid();
+                await new Promise(resolve => {
+                    addedToQueueCallbacks.set(uuid, resolve);
+                });
+                addedToQueueCallbacks.delete(uuid);
+            }
+            else {
+                break;
+            }
+        }
+        const nextFuncs = options.batchCalls ? queue.splice(0, queue.length) : [queue.shift()];
+        const start = performance.now();
+        const value = await Result.fromPromise(func());
+        const end = performance.now();
+        waitUntil = Math.max(waitUntil, start + (options.throttleMs ?? 0), end + (options.gapMs ?? 0));
+        for (const nextFunc of nextFuncs) {
+            value.status === "ok" ? nextFunc[0](value.data) : nextFunc[1](value.error);
+        }
+    };
+    runAsynchronously(async () => {
+        while (true) {
+            await next();
+        }
+    });
+    return () => {
+        return new Promise((resolve, reject) => {
+            waitUntil = Math.max(waitUntil, performance.now() + (options.debounceMs ?? 0));
+            queue.push([resolve, reject]);
+            addedToQueueCallbacks.forEach(cb => cb());
+        });
+    };
+}
+export function throttled(func, delayMs) {
+    let timeout = null;
+    let nextAvailable = null;
+    return async (...args) => {
+        while (nextAvailable !== null) {
+            await nextAvailable;
+        }
+        nextAvailable = new Promise(resolve => {
+            timeout = setTimeout(() => {
+                nextAvailable = null;
+                resolve(func(...args));
+            }, delayMs);
+        });
+        return await nextAvailable;
+    };
+}

package/dist/utils/react.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare function getNodeText(node: React.ReactNode): string;
+/**
+ * Suspends the currently rendered component indefinitely. Will not unsuspend unless the component rerenders.
+ *
+ * You can use this to translate older query- or AsyncResult-based code to new the Suspense system, for example: `if (query.isLoading) suspend();`
+ */
+export declare function suspend(): never;
+/**
+ * Use this in a component or a hook to disable SSR.
+ */
+export declare function suspendIfSsr(): void;

package/dist/utils/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/utils/react.tsx"],"names":[],"mappings":";AAIA,wBAAgB,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,GAAG,MAAM,CAczD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,IAAI,KAAK,CAG/B;AAGD;;GAEG;AACH,wBAAgB,YAAY,SAiB3B"}

package/dist/utils/react.js

@@ -0,0 +1,44 @@
+import { use } from "react";
+import { neverResolve } from "./promises";
+import { deindent } from "./strings";
+export function getNodeText(node) {
+    if (["number", "string"].includes(typeof node)) {
+        return `${node}`;
+    }
+    if (!node) {
+        return "";
+    }
+    if (Array.isArray(node)) {
+        return node.map(getNodeText).join("");
+    }
+    if (typeof node === "object" && "props" in node) {
+        return getNodeText(node.props.children);
+    }
+    throw new Error(`Unknown node type: ${typeof node}`);
+}
+/**
+ * Suspends the currently rendered component indefinitely. Will not unsuspend unless the component rerenders.
+ *
+ * You can use this to translate older query- or AsyncResult-based code to new the Suspense system, for example: `if (query.isLoading) suspend();`
+ */
+export function suspend() {
+    use(neverResolve());
+    throw new Error("Somehow a Promise that never resolves was resolved?");
+}
+/**
+ * Use this in a component or a hook to disable SSR.
+ */
+export function suspendIfSsr() {
+    if (typeof window === "undefined") {
+        const error = Object.assign(new Error(deindent `
+        This code path is not supported in SSR. This error should be caught by the closest Suspense boundary, and hence never be thrown on the client. If you still see the error, make sure the component is rendered inside a Suspense boundary.
+
+        See: https://react.dev/reference/react/Suspense#providing-a-fallback-for-server-errors-and-client-only-content
+      `), {
+            // set the digest so nextjs doesn't log the error
+            // https://github.com/vercel/next.js/blob/d01d6d9c35a8c2725b3d74c1402ab76d4779a6cf/packages/next/src/shared/lib/lazy-dynamic/bailout-to-csr.ts#L14
+            digest: "BAILOUT_TO_CLIENT_SIDE_RENDERING",
+        });
+        throw error;
+    }
+}

package/dist/utils/results.d.ts

@@ -0,0 +1,73 @@
+export type Result<T, E = unknown> = {
+    status: "ok";
+    data: T;
+} | {
+    status: "error";
+    error: E;
+};
+export type AsyncResult<T, E = unknown, P = void> = Result<T, E> | {
+    status: "pending";
+} & {
+    progress: P;
+};
+export declare const Result: {
+    fromThrowing: typeof fromThrowing;
+    fromPromise: typeof promiseToResult;
+    ok<T>(data: T): {
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    };
+    error<E>(error: E): {
+        status: "error";
+        error: E;
+    } & {
+        status: "error";
+    };
+    map: typeof mapResult;
+    or: <T_1, E_1, U>(result: Result<T_1, E_1>, fallback: U) => T_1 | U;
+    orThrow: <T_2, E_2>(result: Result<T_2, E_2>) => T_2;
+    orThrowAsync: <T_3, E_3>(result: Promise<Result<T_3, E_3>>) => Promise<T_3>;
+    retry: typeof retry;
+};
+export declare const AsyncResult: {
+    fromThrowing: typeof fromThrowing;
+    fromPromise: typeof promiseToResult;
+    ok: <T>(data: T) => {
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    };
+    error: <E>(error: E) => {
+        status: "error";
+        error: E;
+    } & {
+        status: "error";
+    };
+    pending: typeof pending;
+    map: typeof mapResult;
+    or: <T_1, E_1, P, U>(result: AsyncResult<T_1, E_1, P>, fallback: U) => T_1 | U;
+    orThrow: <T_2, E_2, P_1>(result: AsyncResult<T_2, E_2, P_1>) => T_2;
+    retry: typeof retry;
+};
+declare function pending(): AsyncResult<never, never, void> & {
+    status: "pending";
+};
+declare function pending<P>(progress: P): AsyncResult<never, never, P> & {
+    status: "pending";
+};
+declare function promiseToResult<T, E = unknown>(promise: Promise<T>): Promise<Result<T, E>>;
+declare function fromThrowing<T>(fn: () => T): Result<T, unknown>;
+declare function mapResult<T, U, E = unknown, P = unknown>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
+declare function mapResult<T, U, E = unknown, P = unknown>(result: AsyncResult<T, E, P>, fn: (data: T) => U): AsyncResult<U, E, P>;
+declare class RetryError extends Error {
+    readonly errors: unknown[];
+    constructor(errors: unknown[]);
+    get retries(): number;
+}
+declare function retry<T>(fn: () => Result<T> | Promise<Result<T>>, retries: number, { exponentialDelayBase }: {
+    exponentialDelayBase?: number | undefined;
+}): Promise<Result<T, RetryError>>;
+export {};

package/dist/utils/results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.d.ts","sourceRoot":"","sources":["../../src/utils/results.tsx"],"names":[],"mappings":"AAEA,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAC7B;IACE,MAAM,EAAE,IAAI,CAAC;IACb,IAAI,EAAE,CAAC,CAAC;CACT,GACD;IACE,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEN,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,IAAI,IAC5C,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GACV;IACE,MAAM,EAAE,SAAS,CAAC;CACnB,GACD;IACE,QAAQ,EAAE,CAAC,CAAC;CACb,CAAC;AAGR,eAAO,MAAM,MAAM;;;;gBAlBL,IAAI;;;gBAqB6B,IAAI;;;gBAjBrC,OAAO;;;gBAuB8B,OAAO;;;;;;;CAkBzD,CAAC;AAEF,eAAO,MAAM,WAAW;;;;gBA/CV,IAAI;;;gBAqB6B,IAAI;;;gBAjBrC,OAAO;;;gBAuB8B,OAAO;;;;;;;CAoCzD,CAAC;AAEF,iBAAS,OAAO,IAAI,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAC5E,iBAAS,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,GAAG;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAQvF,iBAAS,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAQnF;AAED,iBAAS,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAMxD;AAED,iBAAS,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC3G,iBAAS,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAe3H,cAAM,UAAW,SAAQ,KAAK;aACA,MAAM,EAAE,OAAO,EAAE;gBAAjB,MAAM,EAAE,OAAO,EAAE;IAK7C,IAAI,OAAO,WAEV;CACF;AAED,iBAAe,KAAK,CAAC,CAAC,EACpB,EAAE,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,EACf,EAAE,oBAA2B,EAAE;;CAAA,GAC9B,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAchC"}

package/dist/utils/results.js

@@ -0,0 +1,112 @@
+import { wait } from "./promises";
+export const Result = {
+    fromThrowing,
+    fromPromise: promiseToResult,
+    ok(data) {
+        return {
+            status: "ok",
+            data,
+        };
+    },
+    error(error) {
+        return {
+            status: "error",
+            error,
+        };
+    },
+    map: mapResult,
+    or: (result, fallback) => {
+        return result.status === "ok" ? result.data : fallback;
+    },
+    orThrow: (result) => {
+        if (result.status === "error")
+            throw result.error;
+        return result.data;
+    },
+    orThrowAsync: async (result) => {
+        return Result.orThrow(await result);
+    },
+    retry,
+};
+export const AsyncResult = {
+    fromThrowing,
+    fromPromise: promiseToResult,
+    ok: Result.ok,
+    error: Result.error,
+    pending,
+    map: mapResult,
+    or: (result, fallback) => {
+        if (result.status === "pending")
+            return fallback;
+        return Result.or(result, fallback);
+    },
+    orThrow: (result) => {
+        if (result.status === "pending")
+            throw new Error("Result still pending");
+        return Result.orThrow(result);
+    },
+    retry,
+};
+function pending(progress) {
+    return {
+        status: "pending",
+        progress: progress,
+    };
+}
+function promiseToResult(promise) {
+    return promise.then(data => ({
+        status: "ok",
+        data,
+    }), error => ({
+        status: "error",
+        error,
+    }));
+}
+function fromThrowing(fn) {
+    try {
+        return Result.ok(fn());
+    }
+    catch (error) {
+        return Result.error(error);
+    }
+}
+function mapResult(result, fn) {
+    if (result.status === "error")
+        return {
+            status: "error",
+            error: result.error,
+        };
+    if (result.status === "pending")
+        return {
+            status: "pending",
+            ..."progress" in result ? { progress: result.progress } : {},
+        };
+    return Result.ok(fn(result.data));
+}
+class RetryError extends Error {
+    errors;
+    constructor(errors) {
+        super(`Error after retrying ${errors.length} times.`, { cause: errors[errors.length - 1] });
+        this.errors = errors;
+        this.name = "RetryError";
+    }
+    get retries() {
+        return this.errors.length;
+    }
+}
+async function retry(fn, retries, { exponentialDelayBase = 2000 }) {
+    const errors = [];
+    for (let i = 0; i < retries; i++) {
+        const res = await fn();
+        if (res.status === "ok") {
+            return Result.ok(res.data);
+        }
+        else {
+            errors.push(res.error);
+            if (i < retries - 1) {
+                await wait(Math.random() * exponentialDelayBase * 2 ** i);
+            }
+        }
+    }
+    return Result.error(new RetryError(errors));
+}

package/dist/utils/stores.d.ts

@@ -0,0 +1,57 @@
+import { AsyncResult } from "./results";
+import { ReactPromise } from "./promises";
+export type ReadonlyAsyncStore<T> = {
+    isAvailable(): boolean;
+    get(): AsyncResult<T, unknown, void>;
+    getOrWait(): ReactPromise<T>;
+    onChange(callback: (value: T, oldValue: T | undefined) => void): {
+        unsubscribe: () => void;
+    };
+    onceChange(callback: (value: T, oldValue: T | undefined) => void): {
+        unsubscribe: () => void;
+    };
+};
+export declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
+    private _isAvailable;
+    private _value;
+    private _isRejected;
+    private _rejectionError;
+    private readonly _waitingRejectFunctions;
+    private readonly _callbacks;
+    private _updateCounter;
+    private _lastSuccessfulUpdate;
+    constructor(...args: [] | [T]);
+    isAvailable(): boolean;
+    isRejected(): boolean;
+    get(): ({
+        status: "pending";
+    } & {
+        progress: void;
+    } & {
+        status: "pending";
+    }) | ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
+    }) | ({
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    });
+    getOrWait(): ReactPromise<T>;
+    _setIfLatest(value: T, curCounter: number): boolean;
+    set(value: T): void;
+    update(updater: (value: T | undefined) => T): T;
+    setAsync(promise: Promise<T>): Promise<boolean>;
+    setUnavailable(): void;
+    setRejected(error: unknown): void;
+    map<U>(mapper: (value: T) => U): AsyncStore<U>;
+    onChange(callback: (value: T, oldValue: T | undefined) => void): {
+        unsubscribe: () => void;
+    };
+    onceChange(callback: (value: T, oldValue: T | undefined) => void): {
+        unsubscribe: () => void;
+    };
+}

package/dist/utils/stores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../src/utils/stores.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAAE,YAAY,EAAsB,MAAM,YAAY,CAAC;AAE9D,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI;IAClC,WAAW,IAAI,OAAO,CAAC;IACvB,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IACrC,SAAS,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,GAAG;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;IAC7F,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,GAAG;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;CAChG,CAAC;AAEF,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,kBAAkB,CAAC,CAAC,CAAC;IACzD,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,MAAM,CAA4B;IAE1C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAiD;IAEzF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyE;IAEpG,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,qBAAqB,CAAM;gBAEvB,GAAG,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;IAS7B,WAAW,IAAI,OAAO;IAItB,UAAU,IAAI,OAAO;IAIrB,GAAG;;;;;;;;;;;;;;;;;IAUH,SAAS,IAAI,YAAY,CAAC,CAAC,CAAC;IAqB5B,YAAY,CAAC,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM;IAgBzC,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAInB,MAAM,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,GAAG,CAAC;IAMzC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAMrD,cAAc,IAAI,IAAI;IAMtB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAOjC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAQ9C,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,GAAG;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE;IAU5F,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,GAAG;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE;CAO/F"}