@hexclave/shared 1.0.0

package/dist/utils/results.js

@@ -0,0 +1,342 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let __promises_js = require("./promises.js");
+let __strings_js = require("./strings.js");
+
+//#region src/utils/results.tsx
+const Result = {
+	fromThrowing,
+	fromThrowingAsync,
+	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
+};
+(void 0)?.test("Result.ok and Result.error", ({ expect }) => {
+	const okResult = Result.ok(42);
+	expect(okResult.status).toBe("ok");
+	expect(okResult.data).toBe(42);
+	const error = /* @__PURE__ */ new Error("Test error");
+	const errorResult = Result.error(error);
+	expect(errorResult.status).toBe("error");
+	expect(errorResult.error).toBe(error);
+});
+(void 0)?.test("Result.or", ({ expect }) => {
+	expect(Result.or({
+		status: "ok",
+		data: 42
+	}, 0)).toBe(42);
+	expect(Result.or({
+		status: "error",
+		error: "error message"
+	}, 0)).toBe(0);
+});
+(void 0)?.test("Result.orThrow", ({ expect }) => {
+	expect(Result.orThrow({
+		status: "ok",
+		data: 42
+	})).toBe(42);
+	const error = /* @__PURE__ */ new Error("Test error");
+	const errorResult = {
+		status: "error",
+		error
+	};
+	expect(() => Result.orThrow(errorResult)).toThrow(error);
+});
+(void 0)?.test("Result.orThrowAsync", async ({ expect }) => {
+	const okPromise = Promise.resolve({
+		status: "ok",
+		data: 42
+	});
+	expect(await Result.orThrowAsync(okPromise)).toBe(42);
+	const error = /* @__PURE__ */ new Error("Test error");
+	const errorPromise = Promise.resolve({
+		status: "error",
+		error
+	});
+	await expect(Result.orThrowAsync(errorPromise)).rejects.toThrow(error);
+});
+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
+};
+(void 0)?.test("AsyncResult.or", ({ expect }) => {
+	expect(AsyncResult.or({
+		status: "ok",
+		data: 42
+	}, 0)).toBe(42);
+	expect(AsyncResult.or({
+		status: "error",
+		error: "error message"
+	}, 0)).toBe(0);
+	expect(AsyncResult.or({
+		status: "pending",
+		progress: void 0
+	}, 0)).toBe(0);
+});
+(void 0)?.test("AsyncResult.orThrow", ({ expect }) => {
+	expect(AsyncResult.orThrow({
+		status: "ok",
+		data: 42
+	})).toBe(42);
+	const error = /* @__PURE__ */ new Error("Test error");
+	const errorResult = {
+		status: "error",
+		error
+	};
+	expect(() => AsyncResult.orThrow(errorResult)).toThrow(error);
+	const pendingResult = {
+		status: "pending",
+		progress: void 0
+	};
+	expect(() => AsyncResult.orThrow(pendingResult)).toThrow("Result still pending");
+});
+function pending(progress) {
+	return {
+		status: "pending",
+		progress
+	};
+}
+(void 0)?.test("pending", ({ expect }) => {
+	const pendingResult = pending();
+	expect(pendingResult.status).toBe("pending");
+	expect(pendingResult.progress).toBe(void 0);
+	const progressValue = {
+		loaded: 50,
+		total: 100
+	};
+	const pendingWithProgress = pending(progressValue);
+	expect(pendingWithProgress.status).toBe("pending");
+	expect(pendingWithProgress.progress).toBe(progressValue);
+});
+async function promiseToResult(promise) {
+	try {
+		const value = await promise;
+		return Result.ok(value);
+	} catch (error) {
+		return Result.error(error);
+	}
+}
+(void 0)?.test("promiseToResult", async ({ expect }) => {
+	const resolvedResult = await promiseToResult(Promise.resolve(42));
+	expect(resolvedResult.status).toBe("ok");
+	if (resolvedResult.status === "ok") expect(resolvedResult.data).toBe(42);
+	const error = /* @__PURE__ */ new Error("Test error");
+	const rejectedResult = await promiseToResult(Promise.reject(error));
+	expect(rejectedResult.status).toBe("error");
+	if (rejectedResult.status === "error") expect(rejectedResult.error).toBe(error);
+});
+function fromThrowing(fn) {
+	try {
+		return Result.ok(fn());
+	} catch (error) {
+		return Result.error(error);
+	}
+}
+(void 0)?.test("fromThrowing", ({ expect }) => {
+	const successFn = () => 42;
+	const successResult = fromThrowing(successFn);
+	expect(successResult.status).toBe("ok");
+	if (successResult.status === "ok") expect(successResult.data).toBe(42);
+	const error = /* @__PURE__ */ 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(fn) {
+	try {
+		return Result.ok(await fn());
+	} catch (error) {
+		return Result.error(error);
+	}
+}
+(void 0)?.test("fromThrowingAsync", async ({ expect }) => {
+	const successFn = async () => 42;
+	const successResult = await fromThrowingAsync(successFn);
+	expect(successResult.status).toBe("ok");
+	if (successResult.status === "ok") expect(successResult.data).toBe(42);
+	const error = /* @__PURE__ */ 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(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));
+}
+(void 0)?.test("mapResult", ({ expect }) => {
+	const mappedOk = mapResult({
+		status: "ok",
+		data: 42
+	}, (n) => n * 2);
+	expect(mappedOk.status).toBe("ok");
+	if (mappedOk.status === "ok") expect(mappedOk.data).toBe(84);
+	const mappedError = mapResult({
+		status: "error",
+		error: "error message"
+	}, (n) => n * 2);
+	expect(mappedError.status).toBe("error");
+	if (mappedError.status === "error") expect(mappedError.error).toBe("error message");
+	expect(mapResult({
+		status: "pending",
+		progress: void 0
+	}, (n) => n * 2).status).toBe("pending");
+	const progressValue = {
+		loaded: 50,
+		total: 100
+	};
+	const mappedPendingWithProgress = mapResult({
+		status: "pending",
+		progress: progressValue
+	}, (n) => n * 2);
+	expect(mappedPendingWithProgress.status).toBe("pending");
+	if (mappedPendingWithProgress.status === "pending") expect(mappedPendingWithProgress.progress).toBe(progressValue);
+});
+var RetryError = class extends AggregateError {
+	constructor(errors) {
+		const strings = errors.map((e) => (0, __strings_js.nicify)(e));
+		const isAllSame = strings.length > 1 && strings.every((s) => s === strings[0]);
+		super(errors, __strings_js.deindent`
+      Error after ${errors.length} attempts.
+      
+      ${isAllSame ? __strings_js.deindent`
+        Attempts 1-${errors.length}:
+          ${strings[0]}
+      ` : strings.map((s, i) => __strings_js.deindent`
+          Attempt ${i + 1}:
+            ${s}
+        `).join("\n\n")}
+      `, { cause: errors[errors.length - 1] });
+		this.errors = errors;
+		this.name = "RetryError";
+	}
+	get attempts() {
+		return this.errors.length;
+	}
+};
+RetryError.prototype.name = "RetryError";
+(void 0)?.test("RetryError", ({ expect }) => {
+	const singleError = /* @__PURE__ */ 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");
+	const error1 = /* @__PURE__ */ new Error("Error 1");
+	const error2 = /* @__PURE__ */ 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");
+	const sameError = /* @__PURE__ */ 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(fn, totalAttempts, { exponentialDelayBase = 1e3 } = {}) {
+	const errors = [];
+	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 (0, __promises_js.wait)((Math.random() + .5) * exponentialDelayBase * 2 ** i);
+		}
+	}
+	return Object.assign(Result.error(new RetryError(errors)), { attempts: totalAttempts });
+}
+(void 0)?.test("retry", async ({ expect }) => {
+	const successFn = async () => Result.ok("success");
+	expect(await retry(successFn, 3, { exponentialDelayBase: 0 })).toEqual({
+		status: "ok",
+		data: "success",
+		attempts: 1
+	});
+	let attemptCount = 0;
+	const eventualSuccessFn = async () => {
+		return ++attemptCount < 2 ? Result.error(/* @__PURE__ */ new Error(`Attempt ${attemptCount} failed`)) : Result.ok("eventual success");
+	};
+	expect(await retry(eventualSuccessFn, 3, { exponentialDelayBase: 0 })).toEqual({
+		status: "ok",
+		data: "eventual success",
+		attempts: 2
+	});
+	const errors = [
+		/* @__PURE__ */ new Error("Error 1"),
+		/* @__PURE__ */ new Error("Error 2"),
+		/* @__PURE__ */ new Error("Error 3")
+	];
+	const allFailFn = async (attempt) => {
+		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.error;
+	expect(retryError.errors).toEqual(errors);
+	expect(retryError.attempts).toBe(3);
+});
+
+//#endregion
+exports.AsyncResult = AsyncResult;
+exports.Result = Result;
+//# sourceMappingURL=results.js.map

package/dist/utils/results.js.map

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

package/dist/utils/sentry.d.ts

@@ -0,0 +1,13 @@
+//#region src/utils/sentry.d.ts
+declare const sentryBaseConfig: {
+  ignoreErrors: string[];
+  normalizeDepth: number;
+  maxValueLength: number;
+  tracesSampleRate: number;
+  debug: boolean;
+  replaysOnErrorSampleRate: number;
+  replaysSessionSampleRate: number;
+};
+//#endregion
+export { sentryBaseConfig };
+//# sourceMappingURL=sentry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sentry.d.ts","names":[],"sources":["../../src/utils/sentry.tsx"],"mappings":";cAAa,gBAAA"}

package/dist/utils/sentry.js

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/sentry.tsx
+const sentryBaseConfig = {
+	ignoreErrors: ["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: 5e3,
+	tracesSampleRate: 1,
+	debug: false,
+	replaysOnErrorSampleRate: 1,
+	replaysSessionSampleRate: 1
+};
+
+//#endregion
+exports.sentryBaseConfig = sentryBaseConfig;
+//# sourceMappingURL=sentry.js.map

package/dist/utils/sentry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry.js","names":[],"sources":["../../src/utils/sentry.tsx"],"sourcesContent":["export const sentryBaseConfig = {\n  ignoreErrors: [\n    // React throws these errors when used with some browser extensions (eg. Google Translate)\n    \"NotFoundError: Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node.\",\n    \"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.\",\n  ],\n\n  normalizeDepth: 5,\n  maxValueLength: 5000,\n\n  // Adjust this value in production, or use tracesSampler for greater control\n  tracesSampleRate: 1.0,\n\n  // Setting this option to true will print useful information to the console while you're setting up Sentry.\n  debug: false,\n\n  replaysOnErrorSampleRate: 1.0,\n\n  replaysSessionSampleRate: 1.0,\n};\n"],"mappings":";;;AAAA,MAAa,mBAAmB;CAC9B,cAAc,CAEZ,iHACA,+IACD;CAED,gBAAgB;CAChB,gBAAgB;CAGhB,kBAAkB;CAGlB,OAAO;CAEP,0BAA0B;CAE1B,0BAA0B;CAC3B"}

package/dist/utils/stores.d.ts

@@ -0,0 +1,104 @@
+import { AsyncResult, Result } from "./results.js";
+import { ReactPromise } from "./promises.js";
+import { ReadWriteLock } from "./locks.js";
+
+//#region src/utils/stores.d.ts
+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;
+  };
+};
+type AsyncStoreStateChangeCallback<T> = (args: {
+  state: AsyncResult<T>;
+  oldState: AsyncResult<T>;
+  lastOkValue: T | undefined;
+}) => void;
+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;
+  };
+};
+declare class Store<T> implements ReadonlyStore<T> {
+  private _value;
+  private readonly _callbacks;
+  constructor(_value: T);
+  get(): T;
+  set(value: T): void;
+  update(updater: (value: T) => T): T;
+  onChange(callback: (value: T, oldValue: T | undefined) => void): {
+    unsubscribe: () => void;
+  };
+  onceChange(callback: (value: T, oldValue: T | undefined) => void): {
+    unsubscribe: () => void;
+  };
+}
+declare const storeLock: ReadWriteLock;
+declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
+  private _isAvailable;
+  private _mostRecentOkValue;
+  private _isRejected;
+  private _rejectionError;
+  private readonly _waitingRejectFunctions;
+  private readonly _callbacks;
+  private _updateCounter;
+  private _lastSuccessfulUpdate;
+  constructor(...args: [] | [T]);
+  isAvailable(): boolean;
+  isRejected(): boolean;
+  get(): ({
+    status: "error";
+    error: unknown;
+  } & {
+    status: "error";
+  }) | ({
+    status: "ok";
+    data: T;
+  } & {
+    status: "ok";
+  }) | ({
+    status: "pending";
+  } & {
+    progress: void;
+  } & {
+    status: "pending";
+  });
+  getOrWait(): ReactPromise<T>;
+  _setIfLatest(result: Result<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;
+  };
+  onStateChange(callback: AsyncStoreStateChangeCallback<T>): {
+    unsubscribe: () => void;
+  };
+  onceChange(callback: (value: T, oldValue: T | undefined) => void): {
+    unsubscribe: () => void;
+  };
+  onceStateChange(callback: AsyncStoreStateChangeCallback<T>): {
+    unsubscribe: () => void;
+  };
+}
+//#endregion
+export { AsyncStore, AsyncStoreStateChangeCallback, ReadonlyAsyncStore, ReadonlyStore, Store, storeLock };
+//# sourceMappingURL=stores.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stores.d.ts","names":[],"sources":["../../src/utils/stores.tsx"],"mappings":";;;;;KAKY,aAAA;EACV,GAAA,IAAO,CAAA;EACP,QAAA,CAAS,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;EACnE,UAAA,CAAW,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;AAAA;AAAA,KAG3D,6BAAA,OAAoC,IAAA;EAAQ,KAAA,EAAO,WAAA,CAAY,CAAA;EAAI,QAAA,EAAU,WAAA,CAAY,CAAA;EAAI,WAAA,EAAa,CAAA;AAAA;AAAA,KAE1G,kBAAA;EACV,WAAA;EACA,GAAA,IAAO,WAAA,CAAY,CAAA;EACnB,SAAA,IAAa,YAAA,CAAa,CAAA;EAC1B,QAAA,CAAS,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;EACnE,UAAA,CAAW,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;EACrE,aAAA,CAAc,QAAA,EAAU,6BAAA,CAA8B,CAAA;IAAO,WAAA;EAAA;EAC7D,eAAA,CAAgB,QAAA,EAAU,6BAAA,CAA8B,CAAA;IAAO,WAAA;EAAA;AAAA;AAAA,cAGpD,KAAA,eAAoB,aAAA,CAAc,CAAA;EAAA,QAInC,MAAA;EAAA,iBAHO,UAAA;cAGP,MAAA,EAAQ,CAAA;EAGlB,GAAA,CAAA,GAAO,CAAA;EAIP,GAAA,CAAI,KAAA,EAAO,CAAA;EAMX,MAAA,CAAO,OAAA,GAAU,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,CAAA;EAMlC,QAAA,CAAS,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;EAUnE,UAAA,CAAW,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;AAAA;AAAA,cAS1D,SAAA,EAAS,aAAA;AAAA,cAGT,UAAA,eAAyB,kBAAA,CAAmB,CAAA;EAAA,QAC/C,YAAA;EAAA,QACA,kBAAA;EAAA,QAEA,WAAA;EAAA,QACA,eAAA;EAAA,iBACS,uBAAA;EAAA,iBAEA,UAAA;EAAA,QAET,cAAA;EAAA,QACA,qBAAA;iBAEO,IAAA,QAAY,CAAA;EAS3B,WAAA,CAAA;EAIA,UAAA,CAAA;EAIA,GAAA,CAAA;;;;;;;;;;;;;;;;;EAUA,SAAA,CAAA,GAAa,YAAA,CAAa,CAAA;EAmB1B,YAAA,CAAa,MAAA,EAAQ,MAAA,CAAO,CAAA,GAAI,UAAA;EAuChC,GAAA,CAAI,KAAA,EAAO,CAAA;EAIX,MAAA,CAAO,OAAA,GAAU,KAAA,EAAO,CAAA,iBAAkB,CAAA,GAAI,CAAA;EAMxC,QAAA,CAAS,OAAA,EAAS,OAAA,CAAQ,CAAA,IAAK,OAAA;EAQrC,cAAA,CAAA;EAQA,WAAA,CAAY,KAAA;EAIZ,GAAA,GAAA,CAAO,MAAA,GAAS,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,UAAA,CAAW,CAAA;EAQ5C,QAAA,CAAS,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;EAQnE,aAAA,CAAc,QAAA,EAAU,6BAAA,CAA8B,CAAA;IAAO,WAAA;EAAA;EAU7D,UAAA,CAAW,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;EAQrE,eAAA,CAAgB,QAAA,EAAU,6BAAA,CAA8B,CAAA;IAAO,WAAA;EAAA;AAAA"}