@mnaoumov/typescript-lib 0.0.0 → 1.0.1

package/dist/lib/esm/disposable.mjs

@@ -0,0 +1,324 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+ensureDisposeSymbols();
+})();
+
+import { createAggregateError } from "./aggregate-error.mjs";
+import { assertNever } from "./type-guards.mjs";
+var DisposeErrorBehavior = /* @__PURE__ */ ((DisposeErrorBehavior2) => {
+  DisposeErrorBehavior2[DisposeErrorBehavior2["Aggregate"] = 0] = "Aggregate";
+  DisposeErrorBehavior2[DisposeErrorBehavior2["FailFast"] = 1] = "FailFast";
+  return DisposeErrorBehavior2;
+})(DisposeErrorBehavior || {});
+var DisposeOrder = /* @__PURE__ */ ((DisposeOrder2) => {
+  DisposeOrder2[DisposeOrder2["Lifo"] = 0] = "Lifo";
+  DisposeOrder2[DisposeOrder2["Fifo"] = 1] = "Fifo";
+  return DisposeOrder2;
+})(DisposeOrder || {});
+var MultipleDisposeBehavior = /* @__PURE__ */ ((MultipleDisposeBehavior2) => {
+  MultipleDisposeBehavior2[MultipleDisposeBehavior2["Invoke"] = 0] = "Invoke";
+  MultipleDisposeBehavior2[MultipleDisposeBehavior2["Ignore"] = 1] = "Ignore";
+  MultipleDisposeBehavior2[MultipleDisposeBehavior2["Throw"] = 2] = "Throw";
+  return MultipleDisposeBehavior2;
+})(MultipleDisposeBehavior || {});
+class AsyncDisposableBase {
+  /**
+   * How the disposable behaves when disposed more than once.
+   *
+   * @default {@link MultipleDisposeBehavior.Ignore}
+   */
+  multipleDisposeBehavior = 1 /* Ignore */;
+  /**
+   * Whether this disposable has been disposed (its teardown has run at least once).
+   *
+   * @returns `true` once disposal has started.
+   */
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  _isDisposed = false;
+  /**
+   * Disposes the object. Convenience alias that delegates to `this[Symbol.asyncDispose]()`.
+   *
+   * @returns A {@link Promise} that resolves once teardown completes.
+   */
+  asyncDispose() {
+    return this[Symbol.asyncDispose]();
+  }
+  /**
+   * Disposes the object by running {@link AsyncDisposableBase.performDisposeAsync}, honoring the configured
+   * {@link MultipleDisposeBehavior} on a repeat dispose.
+   *
+   * @returns A {@link Promise} that resolves once teardown completes.
+   */
+  async [Symbol.asyncDispose]() {
+    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {
+      return;
+    }
+    this._isDisposed = true;
+    await this.performDisposeAsync();
+  }
+}
+class AsyncCallbackDisposable extends AsyncDisposableBase {
+  callback;
+  /**
+   * Creates a new instance of {@link AsyncCallbackDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.callback = params.callback;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
+  }
+  /**
+   * Runs the dispose callback.
+   *
+   * @returns A {@link Promise} that resolves once the callback completes.
+   */
+  async performDisposeAsync() {
+    await this.callback();
+  }
+}
+function dispose(disposable) {
+  disposable[Symbol.dispose]();
+}
+class DisposableBase {
+  /**
+   * How the disposable behaves when disposed more than once.
+   *
+   * @default {@link MultipleDisposeBehavior.Ignore}
+   */
+  multipleDisposeBehavior = 1 /* Ignore */;
+  /**
+   * Whether this disposable has been disposed (its teardown has run at least once).
+   *
+   * @returns `true` once disposal has started.
+   */
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  _isDisposed = false;
+  /**
+   * Disposes the object. Convenience alias that delegates to `this[Symbol.dispose]()`.
+   */
+  dispose() {
+    this[Symbol.dispose]();
+  }
+  /**
+   * Disposes the object by running {@link DisposableBase.performDispose}, honoring the configured
+   * {@link MultipleDisposeBehavior} on a repeat dispose.
+   */
+  [Symbol.dispose]() {
+    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {
+      return;
+    }
+    this._isDisposed = true;
+    this.performDispose();
+  }
+}
+class CallbackDisposable extends DisposableBase {
+  callback;
+  /**
+   * Creates a new instance of {@link CallbackDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.callback = params.callback;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
+  }
+  /**
+   * Runs the dispose callback.
+   */
+  performDispose() {
+    this.callback();
+  }
+}
+class CombineAsyncDisposable extends AsyncDisposableBase {
+  children;
+  disposeOrder;
+  errorBehavior;
+  /**
+   * Creates a new instance of {@link CombineAsyncDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.children = [...params.asyncDisposables];
+    this.disposeOrder = params.disposeOrder ?? 0 /* Lifo */;
+    this.errorBehavior = params.errorBehavior ?? 0 /* Aggregate */;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
+  }
+  /**
+   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+   * {@link DisposeErrorBehavior} when a child throws.
+   *
+   * @returns A {@link Promise} that resolves once all children have been disposed.
+   */
+  async performDisposeAsync() {
+    const errors = [];
+    for (const child of this.getOrderedChildren()) {
+      try {
+        await child[Symbol.asyncDispose]();
+      } catch (error) {
+        if (this.errorBehavior === 1 /* FailFast */) {
+          throw error;
+        }
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw createAggregateError(errors);
+    }
+  }
+  getOrderedChildren() {
+    switch (this.disposeOrder) {
+      case 1 /* Fifo */: {
+        return this.children;
+      }
+      case 0 /* Lifo */: {
+        return [...this.children].reverse();
+      }
+      default: {
+        assertNever(this.disposeOrder);
+      }
+    }
+  }
+}
+class CombineDisposable extends DisposableBase {
+  children;
+  disposeOrder;
+  errorBehavior;
+  /**
+   * Creates a new instance of {@link CombineDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.children = [...params.disposables];
+    this.disposeOrder = params.disposeOrder ?? 0 /* Lifo */;
+    this.errorBehavior = params.errorBehavior ?? 0 /* Aggregate */;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
+  }
+  /**
+   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
+   * {@link DisposeErrorBehavior} when a child throws.
+   */
+  performDispose() {
+    const errors = [];
+    for (const child of this.getOrderedChildren()) {
+      try {
+        child[Symbol.dispose]();
+      } catch (error) {
+        if (this.errorBehavior === 1 /* FailFast */) {
+          throw error;
+        }
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw createAggregateError(errors);
+    }
+  }
+  getOrderedChildren() {
+    switch (this.disposeOrder) {
+      case 1 /* Fifo */: {
+        return this.children;
+      }
+      case 0 /* Lifo */: {
+        return [...this.children].reverse();
+      }
+      default: {
+        assertNever(this.disposeOrder);
+      }
+    }
+  }
+}
+async function disposeAsync(asyncDisposable) {
+  await asyncDisposable[Symbol.asyncDispose]();
+}
+function isAsyncDisposable($unknown) {
+  const asyncDisposable = $unknown;
+  return !!asyncDisposable[Symbol.asyncDispose];
+}
+function isAsyncDisposableEx($unknown) {
+  const asyncDisposableEx = $unknown;
+  return isAsyncDisposable($unknown) && typeof asyncDisposableEx.asyncDispose === "function";
+}
+function isDisposable($unknown) {
+  const disposable = $unknown;
+  return !!disposable[Symbol.dispose];
+}
+function isDisposableEx($unknown) {
+  const disposableEx = $unknown;
+  return isDisposable($unknown) && typeof disposableEx.dispose === "function";
+}
+function toAsyncDisposableEx(asyncDisposable) {
+  return isAsyncDisposableEx(asyncDisposable) ? asyncDisposable : {
+    asyncDispose: asyncDisposeAdapted,
+    [Symbol.asyncDispose]: asyncDisposeAdapted
+  };
+  function asyncDisposeAdapted() {
+    return disposeAsync(asyncDisposable);
+  }
+}
+function toDisposableEx(disposable) {
+  return isDisposableEx(disposable) ? disposable : {
+    dispose: disposeAdapted,
+    [Symbol.dispose]: disposeAdapted
+  };
+  function disposeAdapted() {
+    dispose(disposable);
+  }
+}
+function shouldPerformDispose(isDisposed, multipleDisposeBehavior) {
+  if (!isDisposed) {
+    return true;
+  }
+  switch (multipleDisposeBehavior) {
+    case 1 /* Ignore */: {
+      return false;
+    }
+    case 0 /* Invoke */: {
+      return true;
+    }
+    case 2 /* Throw */: {
+      throw new Error("This disposable has already been disposed.");
+    }
+    default: {
+      assertNever(multipleDisposeBehavior);
+    }
+  }
+}
+export {
+  AsyncCallbackDisposable,
+  AsyncDisposableBase,
+  CallbackDisposable,
+  CombineAsyncDisposable,
+  CombineDisposable,
+  DisposableBase,
+  DisposeErrorBehavior,
+  DisposeOrder,
+  MultipleDisposeBehavior,
+  dispose,
+  disposeAsync,
+  isAsyncDisposable,
+  isAsyncDisposableEx,
+  isDisposable,
+  isDisposableEx,
+  toAsyncDisposableEx,
+  toDisposableEx
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/disposable.ts"],"sourcesContent":["/**\n * @file\n *\n * Disposable utilities for `using` / `await using` declarations.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { createAggregateError } from './aggregate-error.ts';\nimport { assertNever } from './type-guards.ts';\n\n/**\n * Determines the error semantics of a {@link CombineDisposable} or {@link CombineAsyncDisposable} when\n * one of its children throws while being disposed.\n */\nexport enum DisposeErrorBehavior {\n  /**\n   * Dispose every child even if some of them throw, collecting the thrown errors and re-throwing them\n   * as a single {@link AggregateError} once all children have been disposed.\n   */\n  Aggregate,\n\n  /**\n   * Re-throw the first error a child throws immediately, leaving the remaining children undisposed.\n   */\n  FailFast\n}\n\n/**\n * Determines the order in which a {@link CombineDisposable} or {@link CombineAsyncDisposable} disposes\n * its children.\n */\nexport enum DisposeOrder {\n  /**\n   * Dispose the last-registered child first (last-in, first-out), like nested `using` declarations\n   * unwinding in reverse.\n   */\n  Lifo,\n\n  /**\n   * Dispose the first-registered child first (first-in, first-out).\n   */\n  Fifo\n}\n\n/**\n * Determines how a {@link CallbackDisposable} or {@link AsyncCallbackDisposable} behaves when it is\n * disposed more than once.\n */\nexport enum MultipleDisposeBehavior {\n  /**\n   * Invoke the callback on every dispose.\n   */\n  Invoke,\n\n  /**\n   * Invoke the callback on the first dispose only; subsequent disposes are no-ops.\n   */\n  Ignore,\n\n  /**\n   * Invoke the callback on the first dispose only; subsequent disposes throw.\n   */\n  Throw\n}\n\n/**\n * The parameters for constructing an {@link AsyncCallbackDisposable}.\n */\nexport interface AsyncCallbackDisposableConstructorParams {\n  /**\n   * The callback to execute when disposed.\n   */\n  readonly callback: AsyncDisposeCallback;\n\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Ignore}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * An {@link AsyncDisposable} that additionally exposes a convenience {@link AsyncDisposableEx.asyncDispose}\n * method, so a stored handle can be disposed as `handle.asyncDispose()` instead of the clunkier\n * `handle[Symbol.asyncDispose]()`.\n */\nexport interface AsyncDisposableEx extends AsyncDisposable {\n  /**\n   * Disposes the object. Delegates to `this[Symbol.asyncDispose]()`.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  asyncDispose: () => Promise<void>;\n}\n\n/**\n * A callback invoked when an {@link AsyncCallbackDisposable} is disposed.\n */\nexport type AsyncDisposeCallback = () => Promisable<void>;\n\n/**\n * The parameters for constructing a {@link CallbackDisposable}.\n */\nexport interface CallbackDisposableConstructorParams {\n  /**\n   * The callback to execute when disposed.\n   */\n  readonly callback: DisposeCallback;\n\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Ignore}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * The parameters for constructing a {@link CombineAsyncDisposable}.\n */\nexport interface CombineAsyncDisposableConstructorParams {\n  /**\n   * The async disposables to dispose when the combiner is disposed.\n   */\n  readonly asyncDisposables: Iterable<AsyncDisposable>;\n\n  /**\n   * The order in which the children are disposed.\n   *\n   * @default {@link DisposeOrder.Lifo}\n   */\n  readonly disposeOrder?: DisposeOrder;\n\n  /**\n   * How the combiner behaves when one of its children throws while being disposed.\n   *\n   * @default {@link DisposeErrorBehavior.Aggregate}\n   */\n  readonly errorBehavior?: DisposeErrorBehavior;\n\n  /**\n   * How the combiner behaves when it is disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Ignore}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * The parameters for constructing a {@link CombineDisposable}.\n */\nexport interface CombineDisposableConstructorParams {\n  /**\n   * The disposables to dispose when the combiner is disposed.\n   */\n  readonly disposables: Iterable<Disposable>;\n\n  /**\n   * The order in which the children are disposed.\n   *\n   * @default {@link DisposeOrder.Lifo}\n   */\n  readonly disposeOrder?: DisposeOrder;\n\n  /**\n   * How the combiner behaves when one of its children throws while being disposed.\n   *\n   * @default {@link DisposeErrorBehavior.Aggregate}\n   */\n  readonly errorBehavior?: DisposeErrorBehavior;\n\n  /**\n   * How the combiner behaves when it is disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Ignore}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * A {@link Disposable} that additionally exposes a convenience {@link DisposableEx.dispose} method, so a\n * stored handle can be disposed as `handle.dispose()` instead of the clunkier `handle[Symbol.dispose]()`.\n */\nexport interface DisposableEx extends Disposable {\n  /**\n   * Disposes the object. Delegates to `this[Symbol.dispose]()`.\n   */\n  dispose: () => void;\n}\n\n/**\n * A callback invoked when a {@link CallbackDisposable} is disposed.\n */\nexport type DisposeCallback = () => void;\n\n/**\n * Abstract base for an {@link AsyncDisposableEx}: it carries the re-dispose guard (via\n * {@link MultipleDisposeBehavior}) and the {@link AsyncDisposableEx.asyncDispose} alias; a subclass only\n * implements {@link AsyncDisposableBase.performDisposeAsync}.\n */\nexport abstract class AsyncDisposableBase implements AsyncDisposableEx {\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Ignore}\n   */\n  protected multipleDisposeBehavior: MultipleDisposeBehavior = MultipleDisposeBehavior.Ignore;\n\n  /**\n   * Whether this disposable has been disposed (its teardown has run at least once).\n   *\n   * @returns `true` once disposal has started.\n   */\n  protected get isDisposed(): boolean {\n    return this._isDisposed;\n  }\n\n  private _isDisposed = false;\n\n  /**\n   * Disposes the object. Convenience alias that delegates to `this[Symbol.asyncDispose]()`.\n   *\n   * @returns A {@link Promise} that resolves once teardown completes.\n   */\n  public asyncDispose(): Promise<void> {\n    return this[Symbol.asyncDispose]();\n  }\n\n  /**\n   * Disposes the object by running {@link AsyncDisposableBase.performDisposeAsync}, honoring the configured\n   * {@link MultipleDisposeBehavior} on a repeat dispose.\n   *\n   * @returns A {@link Promise} that resolves once teardown completes.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {\n      return;\n    }\n\n    this._isDisposed = true;\n    await this.performDisposeAsync();\n  }\n\n  /**\n   * Performs the actual teardown. Called at most once unless {@link MultipleDisposeBehavior.Invoke} is set.\n   *\n   * @returns A {@link Promisable} that resolves once teardown completes.\n   */\n  protected abstract performDisposeAsync(): Promisable<void>;\n}\n\n/**\n * An async disposable that executes a callback when disposed via `await using` (or a manual\n * `await disposable[Symbol.asyncDispose]()`).\n */\nexport class AsyncCallbackDisposable extends AsyncDisposableBase {\n  private readonly callback: AsyncDisposeCallback;\n\n  /**\n   * Creates a new instance of {@link AsyncCallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: AsyncCallbackDisposableConstructorParams) {\n    super();\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Ignore;\n  }\n\n  /**\n   * Runs the dispose callback.\n   *\n   * @returns A {@link Promise} that resolves once the callback completes.\n   */\n  protected override async performDisposeAsync(): Promise<void> {\n    await this.callback();\n  }\n}\n\n/**\n * Disposes a {@link Disposable}.\n *\n * Prefer this over calling `disposable[Symbol.dispose]()` at the call site: it reads better and keeps the\n * well-known symbol referenced in a single place.\n *\n * @param disposable - the disposable to dispose\n */\nexport function dispose(disposable: Disposable): void {\n  disposable[Symbol.dispose]();\n}\n\n/**\n * Abstract base for a {@link DisposableEx}: it carries the re-dispose guard (via {@link MultipleDisposeBehavior})\n * and the {@link DisposableEx.dispose} alias; a subclass only implements {@link DisposableBase.performDispose}.\n */\nexport abstract class DisposableBase implements DisposableEx {\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Ignore}\n   */\n  protected multipleDisposeBehavior: MultipleDisposeBehavior = MultipleDisposeBehavior.Ignore;\n\n  /**\n   * Whether this disposable has been disposed (its teardown has run at least once).\n   *\n   * @returns `true` once disposal has started.\n   */\n  protected get isDisposed(): boolean {\n    return this._isDisposed;\n  }\n\n  private _isDisposed = false;\n\n  /**\n   * Disposes the object. Convenience alias that delegates to `this[Symbol.dispose]()`.\n   */\n  public dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  /**\n   * Disposes the object by running {@link DisposableBase.performDispose}, honoring the configured\n   * {@link MultipleDisposeBehavior} on a repeat dispose.\n   */\n  public [Symbol.dispose](): void {\n    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {\n      return;\n    }\n\n    this._isDisposed = true;\n    this.performDispose();\n  }\n\n  /**\n   * Performs the actual teardown. Called at most once unless {@link MultipleDisposeBehavior.Invoke} is set.\n   */\n  protected abstract performDispose(): void;\n}\n\n/**\n * A disposable that executes a callback when disposed.\n */\nexport class CallbackDisposable extends DisposableBase {\n  private readonly callback: DisposeCallback;\n\n  /**\n   * Creates a new instance of {@link CallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CallbackDisposableConstructorParams) {\n    super();\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Ignore;\n  }\n\n  /**\n   * Runs the dispose callback.\n   */\n  protected override performDispose(): void {\n    this.callback();\n  }\n}\n\n/**\n * An {@link AsyncDisposableEx} that combines multiple async disposables and disposes all of them when it\n * is disposed.\n */\nexport class CombineAsyncDisposable extends AsyncDisposableBase {\n  private readonly children: readonly AsyncDisposable[];\n  private readonly disposeOrder: DisposeOrder;\n  private readonly errorBehavior: DisposeErrorBehavior;\n\n  /**\n   * Creates a new instance of {@link CombineAsyncDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CombineAsyncDisposableConstructorParams) {\n    super();\n    this.children = [...params.asyncDisposables];\n    this.disposeOrder = params.disposeOrder ?? DisposeOrder.Lifo;\n    this.errorBehavior = params.errorBehavior ?? DisposeErrorBehavior.Aggregate;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Ignore;\n  }\n\n  /**\n   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured\n   * {@link DisposeErrorBehavior} when a child throws.\n   *\n   * @returns A {@link Promise} that resolves once all children have been disposed.\n   */\n  protected override async performDisposeAsync(): Promise<void> {\n    const errors: unknown[] = [];\n    for (const child of this.getOrderedChildren()) {\n      try {\n        await child[Symbol.asyncDispose]();\n      } catch (error) {\n        if (this.errorBehavior === DisposeErrorBehavior.FailFast) {\n          throw error;\n        }\n\n        errors.push(error);\n      }\n    }\n\n    if (errors.length > 0) {\n      throw createAggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly AsyncDisposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo: {\n        return this.children;\n      }\n      case DisposeOrder.Lifo: {\n        return [...this.children].reverse();\n      }\n      default: {\n        assertNever(this.disposeOrder);\n      }\n    }\n  }\n}\n\n/**\n * A {@link DisposableEx} that combines multiple disposables and disposes all of them when it is\n * disposed.\n */\nexport class CombineDisposable extends DisposableBase {\n  private readonly children: readonly Disposable[];\n  private readonly disposeOrder: DisposeOrder;\n  private readonly errorBehavior: DisposeErrorBehavior;\n\n  /**\n   * Creates a new instance of {@link CombineDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CombineDisposableConstructorParams) {\n    super();\n    this.children = [...params.disposables];\n    this.disposeOrder = params.disposeOrder ?? DisposeOrder.Lifo;\n    this.errorBehavior = params.errorBehavior ?? DisposeErrorBehavior.Aggregate;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Ignore;\n  }\n\n  /**\n   * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured\n   * {@link DisposeErrorBehavior} when a child throws.\n   */\n  protected override performDispose(): void {\n    const errors: unknown[] = [];\n    for (const child of this.getOrderedChildren()) {\n      try {\n        child[Symbol.dispose]();\n      } catch (error) {\n        if (this.errorBehavior === DisposeErrorBehavior.FailFast) {\n          throw error;\n        }\n\n        errors.push(error);\n      }\n    }\n\n    if (errors.length > 0) {\n      throw createAggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly Disposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo: {\n        return this.children;\n      }\n      case DisposeOrder.Lifo: {\n        return [...this.children].reverse();\n      }\n      default: {\n        assertNever(this.disposeOrder);\n      }\n    }\n  }\n}\n\n/**\n * Disposes an {@link AsyncDisposable}.\n *\n * Prefer this over calling `asyncDisposable[Symbol.asyncDispose]()` at the call site: it reads better and\n * keeps the well-known symbol referenced in a single place.\n *\n * @param asyncDisposable - the async disposable to dispose\n * @returns A {@link Promise} that resolves once the disposal completes.\n */\nexport async function disposeAsync(asyncDisposable: AsyncDisposable): Promise<void> {\n  await asyncDisposable[Symbol.asyncDispose]();\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposable} interface.\n *\n * @param $unknown - the object to check for the {@link AsyncDisposable} interface\n * @returns Whether the object implements the {@link AsyncDisposable} interface\n */\nexport function isAsyncDisposable($unknown: unknown): $unknown is AsyncDisposable {\n  const asyncDisposable = $unknown as Partial<AsyncDisposable>;\n  // eslint-disable-next-line unicorn/no-computed-property-existence-check -- `Object.hasOwn` is own-property-only, and `[Symbol.asyncDispose]` is a prototype method on every class-based disposable here.\n  return !!asyncDisposable[Symbol.asyncDispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposableEx} interface.\n *\n * @param $unknown - the object to check for the {@link AsyncDisposableEx} interface\n * @returns Whether the object implements the {@link AsyncDisposableEx} interface\n */\nexport function isAsyncDisposableEx($unknown: unknown): $unknown is AsyncDisposableEx {\n  const asyncDisposableEx = $unknown as Partial<AsyncDisposableEx>;\n  return isAsyncDisposable($unknown) && typeof asyncDisposableEx.asyncDispose === 'function';\n}\n\n/**\n * Type guard to check if an object implements the {@link Disposable} interface.\n *\n * @param $unknown - the object to check for the {@link Disposable} interface\n * @returns Whether the object implements the {@link Disposable} interface\n */\nexport function isDisposable($unknown: unknown): $unknown is Disposable {\n  const disposable = $unknown as Partial<Disposable>;\n  // eslint-disable-next-line unicorn/no-computed-property-existence-check -- `Object.hasOwn` is own-property-only, and `[Symbol.dispose]` is a prototype method on every class-based disposable here.\n  return !!disposable[Symbol.dispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link DisposableEx} interface.\n *\n * @param $unknown - the object to check for the {@link DisposableEx} interface\n * @returns Whether the object implements the {@link DisposableEx} interface\n */\nexport function isDisposableEx($unknown: unknown): $unknown is DisposableEx {\n  const disposableEx = $unknown as Partial<DisposableEx>;\n  return isDisposable($unknown) && typeof disposableEx.dispose === 'function';\n}\n\n/**\n * Adapts a plain {@link AsyncDisposable} into an {@link AsyncDisposableEx} by adding a convenience\n * {@link AsyncDisposableEx.asyncDispose} method that delegates to `Symbol.asyncDispose`.\n *\n * If the object already implements {@link AsyncDisposableEx}, it is returned unchanged.\n *\n * @param asyncDisposable - the async disposable to adapt\n * @returns An {@link AsyncDisposableEx} wrapping the async disposable.\n */\nexport function toAsyncDisposableEx(asyncDisposable: AsyncDisposable): AsyncDisposableEx {\n  return isAsyncDisposableEx(asyncDisposable)\n    ? asyncDisposable\n    : {\n      asyncDispose: asyncDisposeAdapted,\n      [Symbol.asyncDispose]: asyncDisposeAdapted\n    };\n\n  function asyncDisposeAdapted(): Promise<void> {\n    return disposeAsync(asyncDisposable);\n  }\n}\n\n/**\n * Adapts a plain {@link Disposable} into a {@link DisposableEx} by adding a convenience\n * {@link DisposableEx.dispose} method that delegates to `Symbol.dispose`.\n *\n * If the object already implements {@link DisposableEx}, it is returned unchanged.\n *\n * @param disposable - the disposable to adapt\n * @returns A {@link DisposableEx} wrapping the disposable.\n */\nexport function toDisposableEx(disposable: Disposable): DisposableEx {\n  return isDisposableEx(disposable)\n    ? disposable\n    : {\n      dispose: disposeAdapted,\n      [Symbol.dispose]: disposeAdapted\n    };\n\n  function disposeAdapted(): void {\n    dispose(disposable);\n  }\n}\n\n/**\n * Decides whether a disposable's teardown should run on the current dispose call, applying the\n * {@link MultipleDisposeBehavior} re-dispose policy. Single source of the guard shared by\n * {@link DisposableBase} and {@link AsyncDisposableBase}.\n *\n * @param isDisposed - Whether the disposable has already been disposed once.\n * @param multipleDisposeBehavior - The re-dispose behavior.\n * @returns `true` when the teardown should run, `false` when it should be skipped.\n */\nfunction shouldPerformDispose(isDisposed: boolean, multipleDisposeBehavior: MultipleDisposeBehavior): boolean {\n  if (!isDisposed) {\n    return true;\n  }\n\n  switch (multipleDisposeBehavior) {\n    case MultipleDisposeBehavior.Ignore: {\n      return false;\n    }\n    case MultipleDisposeBehavior.Invoke: {\n      return true;\n    }\n    case MultipleDisposeBehavior.Throw: {\n      throw new Error('This disposable has already been disposed.');\n    }\n    default: {\n      assertNever(multipleDisposeBehavior);\n    }\n  }\n}\n"],"mappings":"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","names":["DisposeErrorBehavior","DisposeOrder","MultipleDisposeBehavior"]}

package/dist/lib/esm/enum.d.mts

@@ -0,0 +1,24 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for enums.
+ */
+/**
+ * Get the key of an enum value.
+ *
+ * @typeParam T - The enum type.
+ * @param enumType - The enum type.
+ * @param value - The value to get the key of.
+ * @returns The key of the enum value.
+ */
+export declare function getEnumKey<T extends Record<string, string>>(enumType: T, value: T[keyof T]): keyof T;
+/**
+ * Get the value of an enum key.
+ *
+ * @typeParam T - The enum type.
+ * @param enumType - The enum type.
+ * @param key - The key to get the value of.
+ * @returns The value of the enum key.
+ */
+export declare function getEnumValue<T extends Record<string, string>>(enumType: T, key: string): T[keyof T];

package/dist/lib/esm/enum.mjs

@@ -0,0 +1,17 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { ensureNonNullable } from "./type-guards.mjs";
+function getEnumKey(enumType, value) {
+  return ensureNonNullable(Object.keys(enumType).find((k) => enumType[k] === value), `Invalid enum value: ${value}`);
+}
+function getEnumValue(enumType, key) {
+  return ensureNonNullable(enumType[key], `Invalid enum key: ${key}`);
+}
+export {
+  getEnumKey,
+  getEnumValue
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VudW0udHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBDb250YWlucyB1dGlsaXR5IGZ1bmN0aW9ucyBmb3IgZW51bXMuXG4gKi9cblxuaW1wb3J0IHsgZW5zdXJlTm9uTnVsbGFibGUgfSBmcm9tICcuL3R5cGUtZ3VhcmRzLnRzJztcblxuLyoqXG4gKiBHZXQgdGhlIGtleSBvZiBhbiBlbnVtIHZhbHVlLlxuICpcbiAqIEB0eXBlUGFyYW0gVCAtIFRoZSBlbnVtIHR5cGUuXG4gKiBAcGFyYW0gZW51bVR5cGUgLSBUaGUgZW51bSB0eXBlLlxuICogQHBhcmFtIHZhbHVlIC0gVGhlIHZhbHVlIHRvIGdldCB0aGUga2V5IG9mLlxuICogQHJldHVybnMgVGhlIGtleSBvZiB0aGUgZW51bSB2YWx1ZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldEVudW1LZXk8VCBleHRlbmRzIFJlY29yZDxzdHJpbmcsIHN0cmluZz4+KGVudW1UeXBlOiBULCB2YWx1ZTogVFtrZXlvZiBUXSk6IGtleW9mIFQge1xuICByZXR1cm4gZW5zdXJlTm9uTnVsbGFibGUoT2JqZWN0LmtleXMoZW51bVR5cGUpLmZpbmQoKGspID0+IGVudW1UeXBlW2tdID09PSB2YWx1ZSksIGBJbnZhbGlkIGVudW0gdmFsdWU6ICR7dmFsdWV9YCk7XG59XG5cbi8qKlxuICogR2V0IHRoZSB2YWx1ZSBvZiBhbiBlbnVtIGtleS5cbiAqXG4gKiBAdHlwZVBhcmFtIFQgLSBUaGUgZW51bSB0eXBlLlxuICogQHBhcmFtIGVudW1UeXBlIC0gVGhlIGVudW0gdHlwZS5cbiAqIEBwYXJhbSBrZXkgLSBUaGUga2V5IHRvIGdldCB0aGUgdmFsdWUgb2YuXG4gKiBAcmV0dXJucyBUaGUgdmFsdWUgb2YgdGhlIGVudW0ga2V5LlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0RW51bVZhbHVlPFQgZXh0ZW5kcyBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+PihlbnVtVHlwZTogVCwga2V5OiBzdHJpbmcpOiBUW2tleW9mIFRdIHtcbiAgcmV0dXJuIGVuc3VyZU5vbk51bGxhYmxlKGVudW1UeXBlW2tleV0sIGBJbnZhbGlkIGVudW0ga2V5OiAke2tleX1gKSBhcyBUW2tleW9mIFRdO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFNQSxTQUFTLHlCQUF5QjtBQVUzQixTQUFTLFdBQTZDLFVBQWEsT0FBNEI7QUFDcEcsU0FBTyxrQkFBa0IsT0FBTyxLQUFLLFFBQVEsRUFBRSxLQUFLLENBQUMsTUFBTSxTQUFTLENBQUMsTUFBTSxLQUFLLEdBQUcsdUJBQXVCLEtBQUssRUFBRTtBQUNuSDtBQVVPLFNBQVMsYUFBK0MsVUFBYSxLQUF5QjtBQUNuRyxTQUFPLGtCQUFrQixTQUFTLEdBQUcsR0FBRyxxQkFBcUIsR0FBRyxFQUFFO0FBQ3BFOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/error.d.mts

@@ -0,0 +1,182 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Contains utility functions for error handling.
+ */
+/**
+ * A message of the AsyncWrapperError.
+ */
+export declare const ASYNC_WRAPPER_ERROR_MESSAGE = "An unhandled error occurred executing async operation";
+/**
+ * Parameters for the {@link CustomStackTraceError} constructor.
+ */
+export interface CustomStackTraceErrorConstructorParams {
+    /**
+     * The cause of the error.
+     */
+    readonly cause: unknown;
+    /**
+     * The message of the error.
+     */
+    readonly message: string;
+    /**
+     * The stack trace of the error.
+     */
+    readonly stackTrace: string;
+}
+/**
+ * An error that wraps an error with a custom stack trace.
+ */
+export declare class CustomStackTraceError extends Error {
+    /**
+     * Creates a new CustomStackTraceError.
+     *
+     * @param params - The parameters for the error.
+     */
+    constructor(params: CustomStackTraceErrorConstructorParams);
+}
+/**
+ * An error that wraps a non-`Error` value that was thrown, preserving the original value in `cause`.
+ */
+export declare class ErrorWrapper extends Error {
+    /**
+     * Creates a new ErrorWrapper.
+     *
+     * @param thrownValue - The original non-`Error` value that was thrown.
+     */
+    constructor(thrownValue: unknown);
+    /**
+     * Normalizes any thrown value to an `Error`.
+     *
+     * Returns the value unchanged if it is already an `Error`, otherwise wraps it in an {@link ErrorWrapper}.
+     *
+     * @param thrownValue - The thrown value to normalize.
+     * @returns An `Error` instance: the original value if it is already an `Error`, otherwise an {@link ErrorWrapper}.
+     */
+    static create(thrownValue: unknown): Error;
+}
+/**
+ * An error that is not printed to the console.
+ */
+export declare class SilentError extends Error {
+    /**
+     * Creates a new SilentError.
+     *
+     * @param message - The message of the error.
+     */
+    constructor(message: string);
+}
+/**
+ * Empties the collection window opened by {@link startCollectingUnhandledAsyncErrors} and returns what it
+ * held, leaving the window **open** so errors emitted afterwards keep being collected.
+ *
+ * This is what the test setup's (`@mnaoumov/typescript-test-toolkit/setup`) `beforeEach` / `afterEach` use, rather than
+ * {@link stopCollectingUnhandledAsyncErrors}: an async error emitted in the gap between two tests (e.g. by a
+ * `setTimeout` the test left pending) would otherwise land on a closed window and vanish unreported.
+ *
+ * @returns The unhandled async errors collected so far, or an empty array if no window is open.
+ */
+export declare function drainCollectedUnhandledAsyncErrors(): unknown[];
+/**
+ * Emits an asynchronous error event.
+ *
+ * When a collection window is open (see {@link startCollectingUnhandledAsyncErrors}) the error is
+ * collected as unhandled unless it is ignored — either because `shouldIgnore` is `true` or an
+ * {@link startAsyncErrorIgnoreContext} scope is active. A registered consumer handler deliberately does
+ * **not** exempt the error: in production it shows the user a Notice, which is not a test asserting that
+ * the error was expected. {@link startAsyncErrorIgnoreContext} is the single, explicit opt-out.
+ *
+ * @param asyncError - The error to emit as an asynchronous error event.
+ * @param shouldIgnore - Whether to treat the error as expected and never collect it as unhandled, regardless of the active ignore context. Used to carry the schedule-time ignore decision of a deferred fire-and-forget rejection.
+ */
+export declare function emitAsyncErrorEvent(asyncError: unknown, shouldIgnore?: boolean): void;
+/**
+ * Converts an error to a string representation, including nested causes and the aggregated errors of
+ * an `AggregateError`, with indentation.
+ *
+ * @param error - The error to convert to a string.
+ * @returns The string representation of the error.
+ */
+export declare function errorToString(error: unknown): string;
+/**
+ * Gets the current stack trace as a string, excluding the current function call.
+ *
+ * @param framesToSkip - The number of frames to skip in the stack trace.
+ * @returns A string representation of the current stack trace, excluding the current function call.
+ */
+export declare function getStackTrace(framesToSkip?: number): string;
+/**
+ * Checks whether an {@link startAsyncErrorIgnoreContext} scope is currently active.
+ *
+ * @returns `true` if at least one ignore context is active, `false` otherwise.
+ */
+export declare function isAsyncErrorIgnoreContextActive(): boolean;
+/**
+ * Prints an error to the console, including nested causes and optional ANSI sequence clearing.
+ *
+ * @param error - The error to print.
+ * @param console - The console to print to (default: `globalThis.console`).
+ */
+export declare function printError(error: unknown, console?: Console): void;
+/**
+ * Registers an event handler for asynchronous errors.
+ *
+ * Registering a handler does not mark the errors it receives as expected — see
+ * {@link emitAsyncErrorEvent}. A test that deliberately triggers an async error opens a
+ * {@link startAsyncErrorIgnoreContext} scope regardless of who is listening.
+ *
+ * @param handler - The handler function to be called when an asynchronous error event occurs.
+ * @returns A {@link Disposable} that unregisters the handler when disposed, for use with `using`.
+ */
+export declare function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): Disposable;
+/**
+ * Opens an ignore context in which async errors are treated as expected rather than unhandled, so the
+ * test harness does not fail the test.
+ *
+ * While the returned disposable is held, an async error emitted directly (see
+ * {@link emitAsyncErrorEvent}) is not collected as unhandled. Crucially, a fire-and-forget operation
+ * scheduled within the scope (e.g. via {@link async!invokeAsyncSafely}) is also ignored when it later
+ * rejects — even after the scope has exited — because {@link async!addErrorHandler} captures the active
+ * ignore context at schedule time. A test therefore does not need to drain the operation itself:
+ *
+ * ```ts
+ * it('does not fail', () => {
+ *   using _ = startAsyncErrorIgnoreContext();
+ *   invokeAsyncSafely(() => Promise.reject(new Error('deliberately swallowed')));
+ * });
+ * ```
+ *
+ * Contexts nest; the ignore only ends once every open context has been disposed.
+ *
+ * @returns A {@link Disposable} that closes the ignore context when disposed, for use with `using`.
+ */
+export declare function startAsyncErrorIgnoreContext(): Disposable;
+/**
+ * Opens a window in which async errors emitted outside an ignore context are collected as unhandled
+ * (see {@link emitAsyncErrorEvent}), discarding anything collected by a previous window.
+ *
+ * Intended for the test harness only: the per-test setup opens a window before each test and empties it
+ * after each test via {@link drainCollectedUnhandledAsyncErrors}, closing it for good with
+ * {@link stopCollectingUnhandledAsyncErrors} once the file's last test has run. In production no window
+ * is open, so emitting an async error carries no bookkeeping overhead.
+ */
+export declare function startCollectingUnhandledAsyncErrors(): void;
+/**
+ * Closes the window opened by {@link startCollectingUnhandledAsyncErrors} and returns the unhandled
+ * async errors collected while it was open.
+ *
+ * Use {@link drainCollectedUnhandledAsyncErrors} instead wherever collection must continue afterwards —
+ * once the window is closed, a later async error is not collected by anyone.
+ *
+ * @returns The collected unhandled async errors, or an empty array if no window was open.
+ */
+export declare function stopCollectingUnhandledAsyncErrors(): unknown[];
+/**
+ * Throws an error with the specified message.
+ *
+ * @param error - The error to throw.
+ * @throws
+ */
+export declare function throwExpression(error: unknown): never;