tryharder 0.1.2 → 0.2.1

package/dist/shared/chunk-nw88v1ee.js

@@ -0,0 +1,123 @@
+var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
+var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError('Object expected to be assigned to "using" declaration');
+    var dispose;
+    if (async)
+      dispose = value[__asyncDispose];
+    if (dispose === undefined)
+      dispose = value[__dispose];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  }, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
+
+// src/lib/errors.ts
+var PanicMessages = {
+  ALL_CATCH_HANDLER_REJECT: "Panic: all() catch handler rejected",
+  ALL_CATCH_HANDLER_THROW: "Panic: all() catch handler threw",
+  FLOW_NO_EXIT: "flow() requires at least one task to call $exit().",
+  ORCHESTRATION_UNSUPPORTED_POLICY: "Orchestration does not support retry() or timeout() policies.",
+  RETRY_INVALID_LIMIT: "retry() requires a positive integer retry limit.",
+  RUN_CATCH_HANDLER_REJECT: "Panic: run() catch handler rejected",
+  RUN_CATCH_HANDLER_THROW: "Panic: run() catch handler threw",
+  RUN_SYNC_ASYNC_RETRY_POLICY: "This retry policy may run asynchronously. Use run() instead.",
+  RUN_SYNC_CATCH_HANDLER_THROW: "Panic: runSync() catch handler threw",
+  RUN_SYNC_CATCH_PROMISE: "runSync() catch cannot return a Promise. Use run() instead.",
+  RUN_SYNC_TRY_PROMISE: "runSync() cannot handle Promise values. Use run() instead.",
+  RUN_SYNC_WRAPPED_RESULT_PROMISE: "Wrapped runSync() execution returned a Promise. Use run() instead.",
+  TASK_INVALID_HANDLER: "Task runner expected a function handler.",
+  TASK_SELF_REFERENCE: "Task cannot await its own result.",
+  TASK_UNKNOWN_REFERENCE: "Task attempted to read an unknown task result.",
+  TIMEOUT_INVALID_MS: "timeout() requires a non-negative finite millisecond value.",
+  UNREACHABLE_RETRY_POLICY_BACKOFF: "Panic: unreachable retry policy backoff"
+};
+
+class ControlError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ControlError";
+  }
+}
+
+class CancellationError extends ControlError {
+  constructor(message = "Execution was cancelled", options) {
+    super(message, options);
+    this.name = "CancellationError";
+  }
+}
+
+class TimeoutError extends ControlError {
+  constructor(message = "Execution timed out", options) {
+    super(message, options);
+    this.name = "TimeoutError";
+  }
+}
+
+class RetryExhaustedError extends Error {
+  constructor(message = "Retry attempts exhausted", options) {
+    super(message, options);
+    this.name = "RetryExhaustedError";
+  }
+}
+
+class UnhandledException extends Error {
+  constructor(message = "Unhandled exception", options) {
+    super(message, options);
+    this.name = "UnhandledException";
+  }
+}
+
+class Panic extends Error {
+  code;
+  constructor(code, options = {}) {
+    const { message, ...errorOptions } = options;
+    super(message ?? PanicMessages[code], errorOptions);
+    this.code = code;
+    this.name = "Panic";
+  }
+}
+function isCancellationError(error) {
+  return error instanceof CancellationError || Error.isError(error) && error.name === "CancellationError";
+}
+function isTimeoutError(error) {
+  return error instanceof TimeoutError || Error.isError(error) && error.name === "TimeoutError";
+}
+function isRetryExhaustedError(error) {
+  return error instanceof RetryExhaustedError || Error.isError(error) && error.name === "RetryExhaustedError";
+}
+function isUnhandledException(error) {
+  return error instanceof UnhandledException || Error.isError(error) && error.name === "UnhandledException";
+}
+function isPanic(error) {
+  return error instanceof Panic || Error.isError(error) && error.name === "Panic" && "code" in error && typeof error.code === "string";
+}
+
+export { __using, __callDispose, ControlError, CancellationError, TimeoutError, RetryExhaustedError, UnhandledException, Panic, isCancellationError, isTimeoutError, isRetryExhaustedError, isUnhandledException, isPanic };
+
+//# debugId=D2D093C868939DB764756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/lib/errors.ts"],
  "sourcesContent": [
    "export type PanicCode =\n  | \"ALL_CATCH_HANDLER_REJECT\"\n  | \"ALL_CATCH_HANDLER_THROW\"\n  | \"FLOW_NO_EXIT\"\n  | \"ORCHESTRATION_UNSUPPORTED_POLICY\"\n  | \"RETRY_INVALID_LIMIT\"\n  | \"RUN_CATCH_HANDLER_REJECT\"\n  | \"RUN_CATCH_HANDLER_THROW\"\n  | \"RUN_SYNC_ASYNC_RETRY_POLICY\"\n  | \"RUN_SYNC_CATCH_HANDLER_THROW\"\n  | \"RUN_SYNC_CATCH_PROMISE\"\n  | \"RUN_SYNC_TRY_PROMISE\"\n  | \"RUN_SYNC_WRAPPED_RESULT_PROMISE\"\n  | \"TASK_INVALID_HANDLER\"\n  | \"TASK_SELF_REFERENCE\"\n  | \"TIMEOUT_INVALID_MS\"\n  | \"TASK_UNKNOWN_REFERENCE\"\n  | \"UNREACHABLE_RETRY_POLICY_BACKOFF\"\n\nexport const PanicMessages = {\n  ALL_CATCH_HANDLER_REJECT: \"Panic: all() catch handler rejected\",\n  ALL_CATCH_HANDLER_THROW: \"Panic: all() catch handler threw\",\n  FLOW_NO_EXIT: \"flow() requires at least one task to call $exit().\",\n  ORCHESTRATION_UNSUPPORTED_POLICY: \"Orchestration does not support retry() or timeout() policies.\",\n  RETRY_INVALID_LIMIT: \"retry() requires a positive integer retry limit.\",\n  RUN_CATCH_HANDLER_REJECT: \"Panic: run() catch handler rejected\",\n  RUN_CATCH_HANDLER_THROW: \"Panic: run() catch handler threw\",\n  RUN_SYNC_ASYNC_RETRY_POLICY: \"This retry policy may run asynchronously. Use run() instead.\",\n  RUN_SYNC_CATCH_HANDLER_THROW: \"Panic: runSync() catch handler threw\",\n  RUN_SYNC_CATCH_PROMISE: \"runSync() catch cannot return a Promise. Use run() instead.\",\n  RUN_SYNC_TRY_PROMISE: \"runSync() cannot handle Promise values. Use run() instead.\",\n  RUN_SYNC_WRAPPED_RESULT_PROMISE:\n    \"Wrapped runSync() execution returned a Promise. Use run() instead.\",\n  TASK_INVALID_HANDLER: \"Task runner expected a function handler.\",\n  TASK_SELF_REFERENCE: \"Task cannot await its own result.\",\n  TASK_UNKNOWN_REFERENCE: \"Task attempted to read an unknown task result.\",\n  TIMEOUT_INVALID_MS: \"timeout() requires a non-negative finite millisecond value.\",\n  UNREACHABLE_RETRY_POLICY_BACKOFF: \"Panic: unreachable retry policy backoff\",\n} as const satisfies Record<PanicCode, string>\nexport type PanicMessages = typeof PanicMessages\n\n/**\n * @internal\n */\nexport class ControlError extends Error {\n  constructor(message?: string, options?: ErrorOptions) {\n    super(message, options)\n    this.name = \"ControlError\"\n  }\n}\n\nexport class CancellationError extends ControlError {\n  constructor(message = \"Execution was cancelled\", options?: ErrorOptions) {\n    super(message, options)\n    this.name = \"CancellationError\"\n  }\n}\n\nexport class TimeoutError extends ControlError {\n  constructor(message = \"Execution timed out\", options?: ErrorOptions) {\n    super(message, options)\n    this.name = \"TimeoutError\"\n  }\n}\n\nexport class RetryExhaustedError extends Error {\n  constructor(message = \"Retry attempts exhausted\", options?: ErrorOptions) {\n    super(message, options)\n    this.name = \"RetryExhaustedError\"\n  }\n}\n\n// oxlint-disable-next-line unicorn/custom-error-definition -- Public error name is intentional.\nexport class UnhandledException extends Error {\n  constructor(message = \"Unhandled exception\", options?: ErrorOptions) {\n    super(message, options)\n    this.name = \"UnhandledException\"\n  }\n}\n\n// oxlint-disable-next-line unicorn/custom-error-definition -- Public error name is intentional.\nexport class Panic extends Error {\n  readonly code: PanicCode\n\n  constructor(code: PanicCode, options: ErrorOptions & { message?: string } = {}) {\n    const { message, ...errorOptions } = options\n\n    super(message ?? PanicMessages[code], errorOptions)\n    this.code = code\n    this.name = \"Panic\"\n  }\n}\n\n// Type guards below match by `error.name` in addition to instanceof, so they\n// keep working when two copies of tryharder end up in one dependency graph\n// (or across realms), where instanceof silently fails. They are the\n// recommended way to identify tryharder errors.\n//\n// Caveat: name matching means a foreign Error that happens to use the same\n// `name` also passes. Within the unions returned by tryharder APIs this cannot\n// occur.\n\nexport function isCancellationError(error: unknown): error is CancellationError {\n  return (\n    error instanceof CancellationError ||\n    (Error.isError(error) && error.name === \"CancellationError\")\n  )\n}\n\nexport function isTimeoutError(error: unknown): error is TimeoutError {\n  return error instanceof TimeoutError || (Error.isError(error) && error.name === \"TimeoutError\")\n}\n\nexport function isRetryExhaustedError(error: unknown): error is RetryExhaustedError {\n  return (\n    error instanceof RetryExhaustedError ||\n    (Error.isError(error) && error.name === \"RetryExhaustedError\")\n  )\n}\n\nexport function isUnhandledException(error: unknown): error is UnhandledException {\n  return (\n    error instanceof UnhandledException ||\n    (Error.isError(error) && error.name === \"UnhandledException\")\n  )\n}\n\nexport function isPanic(error: unknown): error is Panic {\n  return (\n    error instanceof Panic ||\n    (Error.isError(error) &&\n      error.name === \"Panic\" &&\n      \"code\" in error &&\n      typeof error.code === \"string\")\n  )\n}\n"
  ],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBO,IAAM,gBAAgB;AAAA,EAC3B,0BAA0B;AAAA,EAC1B,yBAAyB;AAAA,EACzB,cAAc;AAAA,EACd,kCAAkC;AAAA,EAClC,qBAAqB;AAAA,EACrB,0BAA0B;AAAA,EAC1B,yBAAyB;AAAA,EACzB,6BAA6B;AAAA,EAC7B,8BAA8B;AAAA,EAC9B,wBAAwB;AAAA,EACxB,sBAAsB;AAAA,EACtB,iCACE;AAAA,EACF,sBAAsB;AAAA,EACtB,qBAAqB;AAAA,EACrB,wBAAwB;AAAA,EACxB,oBAAoB;AAAA,EACpB,kCAAkC;AACpC;AAAA;AAMO,MAAM,qBAAqB,MAAM;AAAA,EACtC,WAAW,CAAC,SAAkB,SAAwB;AAAA,IACpD,MAAM,SAAS,OAAO;AAAA,IACtB,KAAK,OAAO;AAAA;AAEhB;AAAA;AAEO,MAAM,0BAA0B,aAAa;AAAA,EAClD,WAAW,CAAC,UAAU,2BAA2B,SAAwB;AAAA,IACvE,MAAM,SAAS,OAAO;AAAA,IACtB,KAAK,OAAO;AAAA;AAEhB;AAAA;AAEO,MAAM,qBAAqB,aAAa;AAAA,EAC7C,WAAW,CAAC,UAAU,uBAAuB,SAAwB;AAAA,IACnE,MAAM,SAAS,OAAO;AAAA,IACtB,KAAK,OAAO;AAAA;AAEhB;AAAA;AAEO,MAAM,4BAA4B,MAAM;AAAA,EAC7C,WAAW,CAAC,UAAU,4BAA4B,SAAwB;AAAA,IACxE,MAAM,SAAS,OAAO;AAAA,IACtB,KAAK,OAAO;AAAA;AAEhB;AAAA;AAGO,MAAM,2BAA2B,MAAM;AAAA,EAC5C,WAAW,CAAC,UAAU,uBAAuB,SAAwB;AAAA,IACnE,MAAM,SAAS,OAAO;AAAA,IACtB,KAAK,OAAO;AAAA;AAEhB;AAAA;AAGO,MAAM,cAAc,MAAM;AAAA,EACtB;AAAA,EAET,WAAW,CAAC,MAAiB,UAA+C,CAAC,GAAG;AAAA,IAC9E,QAAQ,YAAY,iBAAiB;AAAA,IAErC,MAAM,WAAW,cAAc,OAAO,YAAY;AAAA,IAClD,KAAK,OAAO;AAAA,IACZ,KAAK,OAAO;AAAA;AAEhB;AAWO,SAAS,mBAAmB,CAAC,OAA4C;AAAA,EAC9E,OACE,iBAAiB,qBAChB,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS;AAAA;AAIrC,SAAS,cAAc,CAAC,OAAuC;AAAA,EACpE,OAAO,iBAAiB,gBAAiB,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS;AAAA;AAG3E,SAAS,qBAAqB,CAAC,OAA8C;AAAA,EAClF,OACE,iBAAiB,uBAChB,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS;AAAA;AAIrC,SAAS,oBAAoB,CAAC,OAA6C;AAAA,EAChF,OACE,iBAAiB,sBAChB,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS;AAAA;AAIrC,SAAS,OAAO,CAAC,OAAgC;AAAA,EACtD,OACE,iBAAiB,SAChB,MAAM,QAAQ,KAAK,KAClB,MAAM,SAAS,WACf,UAAU,SACV,OAAO,MAAM,SAAS;AAAA;",
  "debugId": "D2D093C868939DB764756E2164756E21",
  "names": []
}

package/dist/types.d.ts

@@ -1,9 +1,18 @@
 interface AsyncDisposer extends AsyncDisposable {
-	add(fn: () => void | PromiseLike<void>): void;
-	cleanup(): Promise<void>;
+	/**
+	* Registers a cleanup callback. Callbacks run in reverse registration order (LIFO) when the
+	* disposer is disposed.
+	*/
 	defer(fn: () => void | PromiseLike<void>): void;
+	/**
+	* Tracks a disposable resource and returns it.
+	*/
 	use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): T;
-	disposeAsync(): Promise<void>;
+	/**
+	* Runs all registered teardown in reverse registration order. Equivalent to leaving an `await
+	* using` scope.
+	*/
+	dispose(): Promise<void>;
 }
 declare const FLOW_EXIT_BRAND: unique symbol;
 type FlowExit<T> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharder",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "A better try/catch for TypeScript",
   "keywords": [
     "abort-signal",
@@ -57,17 +57,17 @@
     "version": "changeset version && bun run format"
   },
   "devDependencies": {
-    "@changesets/cli": "2.29.8",
-    "@clack/prompts": "1.0.1",
-    "@types/bun": "1.3.9",
-    "adamantite": "0.32.3",
-    "bunup": "0.16.29",
-    "knip": "6.23.0",
+    "@changesets/cli": "2.31.1",
+    "@clack/prompts": "1.7.0",
+    "@types/bun": "1.3.14",
+    "adamantite": "^0.33.0",
+    "bunup": "0.16.32",
+    "knip": "6.29.0",
     "mitata": "^1.0.34",
-    "oxfmt": "0.57.0",
-    "oxlint": "1.72.0",
-    "oxlint-tsgolint": "0.24.0",
-    "typescript": "5.9.3"
+    "oxfmt": "0.60.0",
+    "oxlint": "1.75.0",
+    "oxlint-tsgolint": "7.0.2001",
+    "typescript": "7.0.2"
   },
-  "packageManager": "bun@1.3.1"
+  "packageManager": "bun@1.3.14"
 }

package/dist/shared/chunk-f024nrjy.js

@@ -1,108 +0,0 @@
-var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
-var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
-var __using = (stack, value, async) => {
-  if (value != null) {
-    if (typeof value !== "object" && typeof value !== "function")
-      throw TypeError('Object expected to be assigned to "using" declaration');
-    var dispose;
-    if (async)
-      dispose = value[__asyncDispose];
-    if (dispose === undefined)
-      dispose = value[__dispose];
-    if (typeof dispose !== "function")
-      throw TypeError("Object not disposable");
-    stack.push([async, dispose, value]);
-  } else if (async) {
-    stack.push([async]);
-  }
-  return value;
-};
-var __callDispose = (stack, error, hasError) => {
-  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
-    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
-  }, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
-    while (it = stack.pop()) {
-      try {
-        var result = it[1] && it[1].call(it[2]);
-        if (it[0])
-          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
-      } catch (e) {
-        fail(e);
-      }
-    }
-    if (hasError)
-      throw error;
-  };
-  return next();
-};
-
-// src/lib/errors.ts
-var PanicMessages = {
-  ALL_CATCH_HANDLER_REJECT: "Panic: all() catch handler rejected",
-  ALL_CATCH_HANDLER_THROW: "Panic: all() catch handler threw",
-  FLOW_NO_EXIT: "flow() requires at least one task to call $exit().",
-  ORCHESTRATION_UNSUPPORTED_POLICY: "Orchestration does not support retry() or timeout() policies.",
-  RETRY_INVALID_LIMIT: "retry() requires a non-negative finite retry limit.",
-  RUN_CATCH_HANDLER_REJECT: "Panic: run() catch handler rejected",
-  RUN_CATCH_HANDLER_THROW: "Panic: run() catch handler threw",
-  RUN_SYNC_ASYNC_RETRY_POLICY: "This retry policy may run asynchronously. Use run() instead.",
-  RUN_SYNC_CATCH_HANDLER_THROW: "Panic: runSync() catch handler threw",
-  RUN_SYNC_CATCH_PROMISE: "runSync() catch cannot return a Promise. Use run() instead.",
-  RUN_SYNC_TRY_PROMISE: "runSync() cannot handle Promise values. Use run() instead.",
-  RUN_SYNC_WRAPPED_RESULT_PROMISE: "Wrapped runSync() execution returned a Promise. Use run() instead.",
-  TASK_INVALID_HANDLER: "Task runner expected a function handler.",
-  TASK_SELF_REFERENCE: "Task cannot await its own result.",
-  TASK_UNKNOWN_REFERENCE: "Task attempted to read an unknown task result.",
-  TIMEOUT_INVALID_MS: "timeout() requires a non-negative finite millisecond value.",
-  UNREACHABLE_RETRY_POLICY_BACKOFF: "Panic: unreachable retry policy backoff"
-};
-
-class ControlError extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ControlError";
-  }
-}
-
-class CancellationError extends ControlError {
-  constructor(message = "Execution was cancelled", options) {
-    super(message, options);
-    this.name = "CancellationError";
-  }
-}
-
-class TimeoutError extends ControlError {
-  constructor(message = "Execution timed out", options) {
-    super(message, options);
-    this.name = "TimeoutError";
-  }
-}
-
-class RetryExhaustedError extends Error {
-  constructor(message = "Retry attempts exhausted", options) {
-    super(message, options);
-    this.name = "RetryExhaustedError";
-  }
-}
-
-class UnhandledException extends Error {
-  constructor(message = "Unhandled exception", options) {
-    super(message, options);
-    this.name = "UnhandledException";
-  }
-}
-
-class Panic extends Error {
-  code;
-  constructor(code, options = {}) {
-    const { message, ...errorOptions } = options;
-    super(message ?? PanicMessages[code], errorOptions);
-    this.code = code;
-    this.name = "Panic";
-  }
-}
-
-export { __using, __callDispose, ControlError, CancellationError, TimeoutError, RetryExhaustedError, UnhandledException, Panic };
-
-//# debugId=B1559E370003654764756E2164756E21
-//# sourceMappingURL=data:application/json;base64,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