@hexclave/shared 1.0.3 → 1.0.5

package/src/utils/results.tsx

@@ -0,0 +1,411 @@
+import { wait } from "./promises";
+import { deindent, nicify } from "./strings";
+
+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 const Result = {
+  fromThrowing,
+  fromThrowingAsync,
+  fromPromise: promiseToResult,
+  ok<T>(data: T): Result<T, never> & { status: "ok" } {
+    return {
+      status: "ok",
+      data,
+    };
+  },
+  error<E>(error: E): Result<never, E> & { status: "error" } {
+    return {
+      status: "error",
+      error,
+    };
+  },
+  map: mapResult,
+  or: <T, E, U>(result: Result<T, E>, fallback: U): T | U => {
+    return result.status === "ok" ? result.data : fallback;
+  },
+  orThrow: <T, E>(result: Result<T, E>): T => {
+    if (result.status === "error") {
+      throw result.error;
+    }
+    return result.data;
+  },
+  orThrowAsync: async <T, E>(result: Promise<Result<T, E>>): Promise<T> => {
+    return Result.orThrow(await result);
+  },
+  retry,
+};
+import.meta.vitest?.test("Result.ok and Result.error", ({ expect }) => {
+  // Test Result.ok
+  const okResult = Result.ok(42);
+  expect(okResult.status).toBe("ok");
+  expect(okResult.data).toBe(42);
+
+  // Test Result.error
+  const error = new Error("Test error");
+  const errorResult = Result.error(error);
+  expect(errorResult.status).toBe("error");
+  expect(errorResult.error).toBe(error);
+});
+
+import.meta.vitest?.test("Result.or", ({ expect }) => {
+  // Test with ok result
+  const okResult: Result<number, string> = { status: "ok", data: 42 };
+  expect(Result.or(okResult, 0)).toBe(42);
+
+  // Test with error result
+  const errorResult: Result<number, string> = { status: "error", error: "error message" };
+  expect(Result.or(errorResult, 0)).toBe(0);
+});
+
+import.meta.vitest?.test("Result.orThrow", ({ expect }) => {
+  // Test with ok result
+  const okResult: Result<number, Error> = { status: "ok", data: 42 };
+  expect(Result.orThrow(okResult)).toBe(42);
+
+  // Test with error result
+  const error = new Error("Test error");
+  const errorResult: Result<number, Error> = { status: "error", error };
+  expect(() => Result.orThrow(errorResult)).toThrow(error);
+});
+
+import.meta.vitest?.test("Result.orThrowAsync", async ({ expect }) => {
+  // Test with ok result
+  const okPromise = Promise.resolve({ status: "ok", data: 42 } as Result<number, Error>);
+  expect(await Result.orThrowAsync(okPromise)).toBe(42);
+
+  // Test with error result
+  const error = new Error("Test error");
+  const errorPromise = Promise.resolve({ status: "error", error } as Result<number, Error>);
+  await expect(Result.orThrowAsync(errorPromise)).rejects.toThrow(error);
+});
+
+export const AsyncResult = {
+  fromThrowing,
+  fromPromise: promiseToResult,
+  ok: Result.ok,
+  error: Result.error,
+  pending,
+  map: mapResult,
+  or: <T, E, P, U>(result: AsyncResult<T, E, P>, fallback: U): T | U => {
+    if (result.status === "pending") {
+      return fallback;
+    }
+    return Result.or(result, fallback);
+  },
+  orThrow: <T, E, P>(result: AsyncResult<T, E, P>): T => {
+    if (result.status === "pending") {
+      throw new Error("Result still pending");
+    }
+    return Result.orThrow(result);
+  },
+  retry,
+};
+import.meta.vitest?.test("AsyncResult.or", ({ expect }) => {
+  // Test with ok result
+  const okResult: AsyncResult<number, string> = { status: "ok", data: 42 };
+  expect(AsyncResult.or(okResult, 0)).toBe(42);
+
+  // Test with error result
+  const errorResult: AsyncResult<number, string> = { status: "error", error: "error message" };
+  expect(AsyncResult.or(errorResult, 0)).toBe(0);
+
+  // Test with pending result
+  const pendingResult: AsyncResult<number, string> = { status: "pending", progress: undefined };
+  expect(AsyncResult.or(pendingResult, 0)).toBe(0);
+});
+
+import.meta.vitest?.test("AsyncResult.orThrow", ({ expect }) => {
+  // Test with ok result
+  const okResult: AsyncResult<number, Error> = { status: "ok", data: 42 };
+  expect(AsyncResult.orThrow(okResult)).toBe(42);
+
+  // Test with error result
+  const error = new Error("Test error");
+  const errorResult: AsyncResult<number, Error> = { status: "error", error };
+  expect(() => AsyncResult.orThrow(errorResult)).toThrow(error);
+
+  // Test with pending result
+  const pendingResult: AsyncResult<number, Error> = { status: "pending", progress: undefined };
+  expect(() => AsyncResult.orThrow(pendingResult)).toThrow("Result still pending");
+});
+
+function pending(): AsyncResult<never, never, void> & { status: "pending" };
+function pending<P>(progress: P): AsyncResult<never, never, P> & { status: "pending" };
+function pending<P>(progress?: P): AsyncResult<never, never, P> & { status: "pending" } {
+  return {
+    status: "pending",
+    progress: progress!,
+  };
+}
+import.meta.vitest?.test("pending", ({ expect }) => {
+  // Test without progress
+  const pendingResult = pending();
+  expect(pendingResult.status).toBe("pending");
+  expect(pendingResult.progress).toBe(undefined);
+
+  // Test with progress
+  const progressValue = { loaded: 50, total: 100 };
+  const pendingWithProgress = pending(progressValue);
+  expect(pendingWithProgress.status).toBe("pending");
+  expect(pendingWithProgress.progress).toBe(progressValue);
+});
+
+async function promiseToResult<T>(promise: Promise<T>): Promise<Result<T>> {
+  try {
+    const value = await promise;
+    return Result.ok(value);
+  } catch (error) {
+    return Result.error(error);
+  }
+}
+import.meta.vitest?.test("promiseToResult", async ({ expect }) => {
+  // Test with resolved promise
+  const resolvedPromise = Promise.resolve(42);
+  const resolvedResult = await promiseToResult(resolvedPromise);
+  expect(resolvedResult.status).toBe("ok");
+  if (resolvedResult.status === "ok") {
+    expect(resolvedResult.data).toBe(42);
+  }
+
+  // Test with rejected promise
+  const error = new Error("Test error");
+  const rejectedPromise = Promise.reject(error);
+  const rejectedResult = await promiseToResult(rejectedPromise);
+  expect(rejectedResult.status).toBe("error");
+  if (rejectedResult.status === "error") {
+    expect(rejectedResult.error).toBe(error);
+  }
+});
+
+function fromThrowing<T>(fn: () => T): Result<T, unknown> {
+  try {
+    return Result.ok(fn());
+  } catch (error) {
+    return Result.error(error);
+  }
+}
+import.meta.vitest?.test("fromThrowing", ({ expect }) => {
+  // Test with function that succeeds
+  const successFn = () => 42;
+  const successResult = fromThrowing(successFn);
+  expect(successResult.status).toBe("ok");
+  if (successResult.status === "ok") {
+    expect(successResult.data).toBe(42);
+  }
+
+  // Test with function that throws
+  const error = new Error("Test error");
+  const errorFn = () => {
+    throw error;
+  };
+  const errorResult = fromThrowing(errorFn);
+  expect(errorResult.status).toBe("error");
+  if (errorResult.status === "error") {
+    expect(errorResult.error).toBe(error);
+  }
+});
+
+async function fromThrowingAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>> {
+  try {
+    return Result.ok(await fn());
+  } catch (error) {
+    return Result.error(error);
+  }
+}
+import.meta.vitest?.test("fromThrowingAsync", async ({ expect }) => {
+  // Test with async function that succeeds
+  const successFn = async () => 42;
+  const successResult = await fromThrowingAsync(successFn);
+  expect(successResult.status).toBe("ok");
+  if (successResult.status === "ok") {
+    expect(successResult.data).toBe(42);
+  }
+
+  // Test with async function that throws
+  const error = new Error("Test error");
+  const errorFn = async () => {
+    throw error;
+  };
+  const errorResult = await fromThrowingAsync(errorFn);
+  expect(errorResult.status).toBe("error");
+  if (errorResult.status === "error") {
+    expect(errorResult.error).toBe(error);
+  }
+});
+
+function mapResult<T, U, E = unknown, P = unknown>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
+function mapResult<T, U, E = unknown, P = unknown>(result: AsyncResult<T, E, P>, fn: (data: T) => U): AsyncResult<U, E, P>;
+function mapResult<T, U, E = unknown, P = unknown>(result: AsyncResult<T, E, P>, fn: (data: T) => U): AsyncResult<U, E, P> {
+  if (result.status === "error") return {
+    status: "error",
+    error: result.error,
+  };
+  if (result.status === "pending") return {
+    status: "pending",
+    ..."progress" in result ? { progress: result.progress } : {},
+  } as any;
+
+  return Result.ok(fn(result.data));
+}
+import.meta.vitest?.test("mapResult", ({ expect }) => {
+  // Test with ok result
+  const okResult: Result<number, string> = { status: "ok", data: 42 };
+  const mappedOk = mapResult(okResult, (n: number) => n * 2);
+  expect(mappedOk.status).toBe("ok");
+  if (mappedOk.status === "ok") {
+    expect(mappedOk.data).toBe(84);
+  }
+
+  // Test with error result
+  const errorResult: Result<number, string> = { status: "error", error: "error message" };
+  const mappedError = mapResult(errorResult, (n: number) => n * 2);
+  expect(mappedError.status).toBe("error");
+  if (mappedError.status === "error") {
+    expect(mappedError.error).toBe("error message");
+  }
+
+  // Test with pending result (no progress)
+  const pendingResult: AsyncResult<number, string, void> = { status: "pending", progress: undefined };
+  const mappedPending = mapResult(pendingResult, (n: number) => n * 2);
+  expect(mappedPending.status).toBe("pending");
+
+  // Test with pending result (with progress)
+  const progressValue = { loaded: 50, total: 100 };
+  const pendingWithProgress: AsyncResult<number, string, typeof progressValue> = {
+    status: "pending",
+    progress: progressValue
+  };
+  const mappedPendingWithProgress = mapResult(pendingWithProgress, (n: number) => n * 2);
+  expect(mappedPendingWithProgress.status).toBe("pending");
+  if (mappedPendingWithProgress.status === "pending") {
+    expect(mappedPendingWithProgress.progress).toBe(progressValue);
+  }
+});
+
+
+class RetryError<E = unknown> extends AggregateError {
+  constructor(public readonly errors: E[]) {
+    const strings = errors.map(e => nicify(e));
+    const isAllSame = strings.length > 1 && strings.every(s => s === strings[0]);
+    super(
+      errors,
+      deindent`
+      Error after ${errors.length} attempts.
+      
+      ${isAllSame ? deindent`
+        Attempts 1-${errors.length}:
+          ${strings[0]}
+      ` : strings.map((s, i) => deindent`
+          Attempt ${i + 1}:
+            ${s}
+        `).join("\n\n")}
+      `,
+      { cause: errors[errors.length - 1] }
+    );
+    this.name = "RetryError";
+  }
+
+  get attempts() {
+    return this.errors.length;
+  }
+}
+RetryError.prototype.name = "RetryError";
+
+import.meta.vitest?.test("RetryError", ({ expect }) => {
+  // Test with single error
+  const singleError = new Error("Single error");
+  const retryErrorSingle = new RetryError([singleError]);
+  expect(retryErrorSingle.name).toBe("RetryError");
+  expect(retryErrorSingle.errors).toEqual([singleError]);
+  expect(retryErrorSingle.attempts).toBe(1);
+  expect(retryErrorSingle.cause).toBe(singleError);
+  expect(retryErrorSingle.message).toContain("Error after 1 attempts");
+
+  // Test with multiple different errors
+  const error1 = new Error("Error 1");
+  const error2 = new Error("Error 2");
+  const retryErrorMultiple = new RetryError([error1, error2]);
+  expect(retryErrorMultiple.name).toBe("RetryError");
+  expect(retryErrorMultiple.errors).toEqual([error1, error2]);
+  expect(retryErrorMultiple.attempts).toBe(2);
+  expect(retryErrorMultiple.cause).toBe(error2);
+  expect(retryErrorMultiple.message).toContain("Error after 2 attempts");
+  expect(retryErrorMultiple.message).toContain("Attempt 1");
+  expect(retryErrorMultiple.message).toContain("Attempt 2");
+
+  // Test with multiple identical errors
+  const sameError = new Error("Same error");
+  const retryErrorSame = new RetryError([sameError, sameError]);
+  expect(retryErrorSame.name).toBe("RetryError");
+  expect(retryErrorSame.errors).toEqual([sameError, sameError]);
+  expect(retryErrorSame.attempts).toBe(2);
+  expect(retryErrorSame.cause).toBe(sameError);
+  expect(retryErrorSame.message).toContain("Error after 2 attempts");
+  expect(retryErrorSame.message).toContain("Attempts 1-2");
+});
+
+async function retry<T, E>(
+  fn: (attemptIndex: number) => Result<T, E> | Promise<Result<T, E>>,
+  totalAttempts: number,
+  { exponentialDelayBase = 1000 } = {},
+): Promise<Result<T, RetryError<E>> & { attempts: number }> {
+  const errors: E[] = [];
+  for (let i = 0; i < totalAttempts; i++) {
+    const res = await fn(i);
+    if (res.status === "ok") {
+      return Object.assign(Result.ok(res.data), { attempts: i + 1 });
+    } else {
+      errors.push(res.error);
+      if (i < totalAttempts - 1) {
+        await wait((Math.random() + 0.5) * exponentialDelayBase * (2 ** i));
+      }
+    }
+  }
+  return Object.assign(Result.error(new RetryError(errors)), { attempts: totalAttempts });
+}
+import.meta.vitest?.test("retry", async ({ expect }) => {
+  // Test successful on first attempt
+  const successFn = async () => Result.ok("success");
+  const successResult = await retry(successFn, 3, { exponentialDelayBase: 0 });
+    expect(successResult).toEqual({ status: "ok", data: "success", attempts: 1 });
+
+    // Test successful after failures
+    let attemptCount = 0;
+    const eventualSuccessFn = async () => {
+      return ++attemptCount < 2 ? Result.error(new Error(`Attempt ${attemptCount} failed`))
+        : Result.ok("eventual success");
+    };
+    const eventualSuccessResult = await retry(eventualSuccessFn, 3, { exponentialDelayBase: 0 });
+    expect(eventualSuccessResult).toEqual({ status: "ok", data: "eventual success", attempts: 2 });
+
+    // Test all attempts fail
+    const errors = [new Error("Error 1"), new Error("Error 2"), new Error("Error 3")];
+    const allFailFn = async (attempt: number) => {
+      return Result.error(errors[attempt]);
+    };
+    const allFailResult = await retry(allFailFn, 3, { exponentialDelayBase: 0 });
+    expect(allFailResult).toEqual({ status: "error", error: expect.any(RetryError), attempts: 3 });
+    const retryError = (allFailResult as any).error as RetryError;
+    expect(retryError.errors).toEqual(errors);
+    expect(retryError.attempts).toBe(3);
+});

package/src/utils/sentry.tsx

@@ -0,0 +1,20 @@
+export const sentryBaseConfig = {
+  ignoreErrors: [
+    // React throws these errors when used with some browser extensions (eg. Google Translate)
+    "NotFoundError: Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node.",
+    "NotFoundError: Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.",
+  ],
+
+  normalizeDepth: 5,
+  maxValueLength: 5000,
+
+  // Adjust this value in production, or use tracesSampler for greater control
+  tracesSampleRate: 1.0,
+
+  // Setting this option to true will print useful information to the console while you're setting up Sentry.
+  debug: false,
+
+  replaysOnErrorSampleRate: 1.0,
+
+  replaysSessionSampleRate: 1.0,
+};

package/src/utils/stores.tsx

@@ -0,0 +1,238 @@
+import { ReadWriteLock } from "./locks";
+import { ReactPromise, pending, rejected, resolved } from "./promises";
+import { AsyncResult, Result } from "./results";
+import { generateUuid } from "./uuids";
+
+export type ReadonlyStore<T> = {
+  get(): T,
+  onChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void },
+  onceChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void },
+};
+
+export type AsyncStoreStateChangeCallback<T> = (args: { state: AsyncResult<T>, oldState: AsyncResult<T>, lastOkValue: T | undefined }) => void;
+
+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 },
+  onStateChange(callback: AsyncStoreStateChangeCallback<T>): { unsubscribe: () => void },
+  onceStateChange(callback: AsyncStoreStateChangeCallback<T>): { unsubscribe: () => void },
+};
+
+export class Store<T> implements ReadonlyStore<T> {
+  private readonly _callbacks: Map<string, ((value: T, oldValue: T | undefined) => void)> = new Map();
+
+  constructor(
+    private _value: T
+  ) {}
+
+  get(): T {
+    return this._value;
+  }
+
+  set(value: T): void {
+    const oldValue = this._value;
+    this._value = value;
+    this._callbacks.forEach((callback) => callback(value, oldValue));
+  }
+
+  update(updater: (value: T) => T): T {
+    const value = updater(this._value);
+    this.set(value);
+    return value;
+  }
+
+  onChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {
+    const uuid = generateUuid();
+    this._callbacks.set(uuid, callback);
+    return {
+      unsubscribe: () => {
+        this._callbacks.delete(uuid);
+      },
+    };
+  }
+
+  onceChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {
+    const { unsubscribe } = this.onChange((...args) => {
+      unsubscribe();
+      callback(...args);
+    });
+    return { unsubscribe };
+  }
+}
+
+export const storeLock = new ReadWriteLock();
+
+
+export class AsyncStore<T> implements ReadonlyAsyncStore<T> {
+  private _isAvailable: boolean;
+  private _mostRecentOkValue: T | undefined = undefined;
+
+  private _isRejected = false;
+  private _rejectionError: unknown;
+  private readonly _waitingRejectFunctions = new Map<string, ((error: unknown) => void)>();
+
+  private readonly _callbacks: Map<string, AsyncStoreStateChangeCallback<T>> = new Map();
+
+  private _updateCounter = 0;
+  private _lastSuccessfulUpdate = -1;
+
+  constructor(...args: [] | [T]) {
+    if (args.length === 0) {
+      this._isAvailable = false;
+    } else {
+      this._isAvailable = true;
+      this._mostRecentOkValue = args[0];
+    }
+  }
+
+  isAvailable(): boolean {
+    return this._isAvailable;
+  }
+
+  isRejected(): boolean {
+    return this._isRejected;
+  }
+
+  get() {
+    if (this.isRejected()) {
+      return AsyncResult.error(this._rejectionError);
+    } else if (this.isAvailable()) {
+      return AsyncResult.ok(this._mostRecentOkValue as T);
+    } else {
+      return AsyncResult.pending();
+    }
+  }
+
+  getOrWait(): ReactPromise<T> {
+    const uuid = generateUuid();
+    if (this.isRejected()) {
+      return rejected(this._rejectionError);
+    } else if (this.isAvailable()) {
+      return resolved(this._mostRecentOkValue as T);
+    }
+    const promise = new Promise<T>((resolve, reject) => {
+      this.onceChange((value) => {
+        resolve(value);
+      });
+      this._waitingRejectFunctions.set(uuid, reject);
+    });
+    const withFinally = promise.finally(() => {
+      this._waitingRejectFunctions.delete(uuid);
+    });
+    return pending(withFinally);
+  }
+
+  _setIfLatest(result: Result<T>, curCounter: number) {
+    const oldState = this.get();
+    const oldValue = this._mostRecentOkValue;
+    if (curCounter > this._lastSuccessfulUpdate) {
+      switch (result.status) {
+        case "ok": {
+          if (!this._isAvailable || this._isRejected || this._mostRecentOkValue !== result.data) {
+            this._lastSuccessfulUpdate = curCounter;
+            this._isAvailable = true;
+            this._isRejected = false;
+            this._mostRecentOkValue = result.data;
+            this._rejectionError = undefined;
+            this._callbacks.forEach((callback) => callback({
+              state: this.get(),
+              oldState,
+              lastOkValue: oldValue,
+            }));
+            return true;
+          }
+          return false;
+        }
+        case "error": {
+          this._lastSuccessfulUpdate = curCounter;
+          this._isAvailable = false;
+          this._isRejected = true;
+          this._rejectionError = result.error;
+          this._waitingRejectFunctions.forEach((reject) => reject(result.error));
+          this._callbacks.forEach((callback) => callback({
+            state: this.get(),
+            oldState,
+            lastOkValue: oldValue,
+          }));
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  set(value: T): void {
+    this._setIfLatest(Result.ok(value), ++this._updateCounter);
+  }
+
+  update(updater: (value: T | undefined) => T): T {
+    const value = updater(this._mostRecentOkValue);
+    this.set(value);
+    return value;
+  }
+
+  async setAsync(promise: Promise<T>): Promise<boolean> {
+    return await storeLock.withReadLock(async () => {
+      const curCounter = ++this._updateCounter;
+      const result = await Result.fromPromise(promise);
+      return this._setIfLatest(result, curCounter);
+    });
+  }
+
+  setUnavailable(): void {
+    this._lastSuccessfulUpdate = ++this._updateCounter;
+    this._mostRecentOkValue = undefined;
+    this._isAvailable = false;
+    this._isRejected = false;
+    this._rejectionError = undefined;
+  }
+
+  setRejected(error: unknown): void {
+    this._setIfLatest(Result.error(error), ++this._updateCounter);
+  }
+
+  map<U>(mapper: (value: T) => U): AsyncStore<U> {
+    const store = new AsyncStore<U>();
+    this.onChange((value) => {
+      store.set(mapper(value));
+    });
+    return store;
+  }
+
+  onChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {
+    return this.onStateChange(({ state, lastOkValue }) => {
+      if (state.status === "ok") {
+        callback(state.data, lastOkValue);
+      }
+    });
+  }
+
+  onStateChange(callback: AsyncStoreStateChangeCallback<T>): { unsubscribe: () => void } {
+    const uuid = generateUuid();
+    this._callbacks.set(uuid, callback);
+    return {
+      unsubscribe: () => {
+        this._callbacks.delete(uuid);
+      },
+    };
+  }
+
+  onceChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {
+    const { unsubscribe } = this.onChange((...args) => {
+      unsubscribe();
+      callback(...args);
+    });
+    return { unsubscribe };
+  }
+
+  onceStateChange(callback: AsyncStoreStateChangeCallback<T>): { unsubscribe: () => void } {
+    const { unsubscribe } = this.onStateChange((...args) => {
+      unsubscribe();
+      callback(...args);
+    });
+    return { unsubscribe };
+  }
+}