obsidian-dev-utils 86.1.2 → 86.2.0

package/dist/lib/cjs/disposable.cjs

@@ -126,9 +126,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var disposable_exports = {};
 __export(disposable_exports, {
   AsyncCallbackDisposable: () => AsyncCallbackDisposable,
+  AsyncDisposableBase: () => AsyncDisposableBase,
   CallbackDisposable: () => CallbackDisposable,
   CombineAsyncDisposable: () => CombineAsyncDisposable,
   CombineDisposable: () => CombineDisposable,
+  DisposableBase: () => DisposableBase,
   DisposeErrorBehavior: () => DisposeErrorBehavior,
   DisposeOrder: () => DisposeOrder,
   MultipleDisposeBehavior: () => MultipleDisposeBehavior,
@@ -157,148 +159,141 @@ var MultipleDisposeBehavior = /* @__PURE__ */ ((MultipleDisposeBehavior2) => {
   MultipleDisposeBehavior2[MultipleDisposeBehavior2["Throw"] = 2] = "Throw";
   return MultipleDisposeBehavior2;
 })(MultipleDisposeBehavior || {});
-class AsyncCallbackDisposable {
-  callback;
-  isDisposed = false;
-  multipleDisposeBehavior;
+class AsyncDisposableBase {
   /**
-   * Creates a new instance of {@link AsyncCallbackDisposable}.
+   * How the disposable behaves when disposed more than once.
    *
-   * @param params - The parameters.
+   * @default {@link MultipleDisposeBehavior.Ignore}
    */
-  constructor(params) {
-    this.callback = params.callback;
-    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 0 /* Invoke */;
+  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 by executing the callback. Convenience alias that delegates to
-   * `this[Symbol.asyncDispose]()`.
+   * Disposes the object. Convenience alias that delegates to `this[Symbol.asyncDispose]()`.
    *
-   * @returns A {@link Promise} that resolves once the callback completes.
+   * @returns A {@link Promise} that resolves once teardown completes.
    */
   asyncDispose() {
     return this[Symbol.asyncDispose]();
   }
   /**
-   * Disposes the object by executing the callback.
+   * Disposes the object by running {@link AsyncDisposableBase.performDisposeAsync}, honoring the configured
+   * {@link MultipleDisposeBehavior} on a repeat dispose.
    *
-   * This method is called automatically when the object is used in an `await using` declaration. It
-   * can also be called manually. The behavior on a second and later dispose is controlled by
-   * {@link AsyncCallbackDisposableConstructorParams.multipleDisposeBehavior}.
-   *
-   * @returns A {@link Promise} that resolves once the callback completes.
+   * @returns A {@link Promise} that resolves once teardown completes.
    */
   async [Symbol.asyncDispose]() {
-    if (this.isDisposed) {
-      switch (this.multipleDisposeBehavior) {
-        case 1 /* Ignore */:
-          return;
-        case 0 /* Invoke */:
-          break;
-        case 2 /* Throw */:
-          throw new Error("This AsyncCallbackDisposable has already been disposed.");
-        default:
-          (0, import_type_guards.assertNever)(this.multipleDisposeBehavior);
-      }
+    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {
+      return;
     }
-    this.isDisposed = true;
-    await this.callback();
+    this._isDisposed = true;
+    await this.performDisposeAsync();
   }
 }
-class CallbackDisposable {
+class AsyncCallbackDisposable extends AsyncDisposableBase {
   callback;
-  isDisposed = false;
-  multipleDisposeBehavior;
   /**
-   * Creates a new instance of {@link CallbackDisposable}.
+   * Creates a new instance of {@link AsyncCallbackDisposable}.
    *
    * @param params - The parameters.
    */
   constructor(params) {
+    super();
     this.callback = params.callback;
-    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 0 /* Invoke */;
+    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();
   }
+}
+class DisposableBase {
   /**
-   * Disposes the object by executing the callback. Convenience alias that delegates to
-   * `this[Symbol.dispose]()`.
+   * 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 executing the callback.
-   *
-   * This method is called automatically when the object is used in a `using` declaration. It can also
-   * be called manually. The behavior on a second and later dispose is controlled by
-   * {@link CallbackDisposableConstructorParams.multipleDisposeBehavior}.
+   * Disposes the object by running {@link DisposableBase.performDispose}, honoring the configured
+   * {@link MultipleDisposeBehavior} on a repeat dispose.
    */
   [Symbol.dispose]() {
-    if (this.isDisposed) {
-      switch (this.multipleDisposeBehavior) {
-        case 1 /* Ignore */:
-          return;
-        case 0 /* Invoke */:
-          break;
-        case 2 /* Throw */:
-          throw new Error("This CallbackDisposable has already been disposed.");
-        default:
-          (0, import_type_guards.assertNever)(this.multipleDisposeBehavior);
-      }
+    if (!shouldPerformDispose(this._isDisposed, this.multipleDisposeBehavior)) {
+      return;
     }
-    this.isDisposed = true;
+    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 {
+class CombineAsyncDisposable extends AsyncDisposableBase {
   children;
   disposeOrder;
   errorBehavior;
-  isDisposed = false;
-  multipleDisposeBehavior;
   /**
    * 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 ?? 0 /* Invoke */;
-  }
-  /**
-   * Disposes all combined children. Convenience alias that delegates to
-   * `this[Symbol.asyncDispose]()`.
-   *
-   * @returns A {@link Promise} that resolves once all children have been disposed.
-   */
-  asyncDispose() {
-    return this[Symbol.asyncDispose]();
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
   }
   /**
    * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
    * {@link DisposeErrorBehavior} when a child throws.
    *
-   * This method is called automatically when the object is used in an `await using` declaration. It can
-   * also be called manually. The behavior on a second and later dispose is controlled by
-   * {@link CombineAsyncDisposableConstructorParams.multipleDisposeBehavior}.
-   *
    * @returns A {@link Promise} that resolves once all children have been disposed.
    */
-  async [Symbol.asyncDispose]() {
-    if (this.isDisposed) {
-      switch (this.multipleDisposeBehavior) {
-        case 1 /* Ignore */:
-          return;
-        case 0 /* Invoke */:
-          break;
-        case 2 /* Throw */:
-          throw new Error("This CombineAsyncDisposable has already been disposed.");
-        default:
-          (0, import_type_guards.assertNever)(this.multipleDisposeBehavior);
-      }
-    }
-    this.isDisposed = true;
+  async performDisposeAsync() {
     const errors = [];
     for (const child of this.getOrderedChildren()) {
       try {
@@ -325,51 +320,27 @@ class CombineAsyncDisposable {
     }
   }
 }
-class CombineDisposable {
+class CombineDisposable extends DisposableBase {
   children;
   disposeOrder;
   errorBehavior;
-  isDisposed = false;
-  multipleDisposeBehavior;
   /**
    * 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 ?? 0 /* Invoke */;
-  }
-  /**
-   * Disposes all combined children. Convenience alias that delegates to `this[Symbol.dispose]()`.
-   */
-  dispose() {
-    this[Symbol.dispose]();
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 1 /* Ignore */;
   }
   /**
    * Disposes all combined children in the configured {@link DisposeOrder}, applying the configured
    * {@link DisposeErrorBehavior} when a child throws.
-   *
-   * This method is called automatically when the object is used in a `using` declaration. It can also
-   * be called manually. The behavior on a second and later dispose is controlled by
-   * {@link CombineDisposableConstructorParams.multipleDisposeBehavior}.
    */
-  [Symbol.dispose]() {
-    if (this.isDisposed) {
-      switch (this.multipleDisposeBehavior) {
-        case 1 /* Ignore */:
-          return;
-        case 0 /* Invoke */:
-          break;
-        case 2 /* Throw */:
-          throw new Error("This CombineDisposable has already been disposed.");
-        default:
-          (0, import_type_guards.assertNever)(this.multipleDisposeBehavior);
-      }
-    }
-    this.isDisposed = true;
+  performDispose() {
     const errors = [];
     for (const child of this.getOrderedChildren()) {
       try {
@@ -436,12 +407,29 @@ function toDisposableEx(disposable) {
     disposable[Symbol.dispose]();
   }
 }
+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:
+      (0, import_type_guards.assertNever)(multipleDisposeBehavior);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AsyncCallbackDisposable,
+  AsyncDisposableBase,
   CallbackDisposable,
   CombineAsyncDisposable,
   CombineDisposable,
+  DisposableBase,
   DisposeErrorBehavior,
   DisposeOrder,
   MultipleDisposeBehavior,
@@ -452,4 +440,4 @@ function toDisposableEx(disposable) {
   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 { 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.Invoke}\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 = (this: void) => 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.Invoke}\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.Invoke}\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.Invoke}\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 = (this: void) => void;\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 implements AsyncDisposableEx {\n  private readonly callback: AsyncDisposeCallback;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link AsyncCallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: AsyncCallbackDisposableConstructorParams) {\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes the object by executing the callback. Convenience alias that delegates to\n   * `this[Symbol.asyncDispose]()`.\n   *\n   * @returns A {@link Promise} that resolves once the callback completes.\n   */\n  public asyncDispose(): Promise<void> {\n    return this[Symbol.asyncDispose]();\n  }\n\n  /**\n   * Disposes the object by executing the callback.\n   *\n   * This method is called automatically when the object is used in an `await using` declaration. It\n   * can also be called manually. The behavior on a second and later dispose is controlled by\n   * {@link AsyncCallbackDisposableConstructorParams.multipleDisposeBehavior}.\n   *\n   * @returns A {@link Promise} that resolves once the callback completes.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This AsyncCallbackDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n    await this.callback();\n  }\n}\n\n/**\n * A disposable that executes a callback when disposed.\n */\nexport class CallbackDisposable implements DisposableEx {\n  private readonly callback: DisposeCallback;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link CallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CallbackDisposableConstructorParams) {\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes the object by executing the callback. Convenience alias that delegates to\n   * `this[Symbol.dispose]()`.\n   */\n  public dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  /**\n   * Disposes the object by executing the callback.\n   *\n   * This method is called automatically when the object is used in a `using` declaration. It can also\n   * be called manually. The behavior on a second and later dispose is controlled by\n   * {@link CallbackDisposableConstructorParams.multipleDisposeBehavior}.\n   */\n  public [Symbol.dispose](): void {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This CallbackDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\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 implements AsyncDisposableEx {\n  private readonly children: readonly AsyncDisposable[];\n  private readonly disposeOrder: DisposeOrder;\n  private readonly errorBehavior: DisposeErrorBehavior;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link CombineAsyncDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CombineAsyncDisposableConstructorParams) {\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.Invoke;\n  }\n\n  /**\n   * Disposes all combined children. Convenience alias that delegates to\n   * `this[Symbol.asyncDispose]()`.\n   *\n   * @returns A {@link Promise} that resolves once all children have been disposed.\n   */\n  public asyncDispose(): Promise<void> {\n    return this[Symbol.asyncDispose]();\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   * This method is called automatically when the object is used in an `await using` declaration. It can\n   * also be called manually. The behavior on a second and later dispose is controlled by\n   * {@link CombineAsyncDisposableConstructorParams.multipleDisposeBehavior}.\n   *\n   * @returns A {@link Promise} that resolves once all children have been disposed.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This CombineAsyncDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n\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 new AggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly AsyncDisposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo:\n        return this.children;\n      case DisposeOrder.Lifo:\n        return [...this.children].reverse();\n      default:\n        assertNever(this.disposeOrder);\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 implements DisposableEx {\n  private readonly children: readonly Disposable[];\n  private readonly disposeOrder: DisposeOrder;\n  private readonly errorBehavior: DisposeErrorBehavior;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link CombineDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CombineDisposableConstructorParams) {\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.Invoke;\n  }\n\n  /**\n   * Disposes all combined children. Convenience alias that delegates to `this[Symbol.dispose]()`.\n   */\n  public dispose(): void {\n    this[Symbol.dispose]();\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   * This method is called automatically when the object is used in a `using` declaration. It can also\n   * be called manually. The behavior on a second and later dispose is controlled by\n   * {@link CombineDisposableConstructorParams.multipleDisposeBehavior}.\n   */\n  public [Symbol.dispose](): void {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This CombineDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n\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 new AggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly Disposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo:\n        return this.children;\n      case DisposeOrder.Lifo:\n        return [...this.children].reverse();\n      default:\n        assertNever(this.disposeOrder);\n    }\n  }\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposable} interface.\n *\n * @param obj - the object to check for the {@link AsyncDisposable} interface\n * @returns Whether the object implements the {@link AsyncDisposable} interface\n */\nexport function isAsyncDisposable(obj: unknown): obj is AsyncDisposable {\n  const asyncDisposable = obj as Partial<AsyncDisposable>;\n  return !!asyncDisposable[Symbol.asyncDispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposableEx} interface.\n *\n * @param obj - the object to check for the {@link AsyncDisposableEx} interface\n * @returns Whether the object implements the {@link AsyncDisposableEx} interface\n */\nexport function isAsyncDisposableEx(obj: unknown): obj is AsyncDisposableEx {\n  const asyncDisposableEx = obj as Partial<AsyncDisposableEx>;\n  return isAsyncDisposable(obj) && typeof asyncDisposableEx.asyncDispose === 'function';\n}\n\n/**\n * Type guard to check if an object implements the {@link Disposable} interface.\n *\n * @param obj - the object to check for the {@link Disposable} interface\n * @returns Whether the object implements the {@link Disposable} interface\n */\nexport function isDisposable(obj: unknown): obj is Disposable {\n  const disposable = obj as Partial<Disposable>;\n  return !!disposable[Symbol.dispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link DisposableEx} interface.\n *\n * @param obj - the object to check for the {@link DisposableEx} interface\n * @returns Whether the object implements the {@link DisposableEx} interface\n */\nexport function isDisposableEx(obj: unknown): obj is DisposableEx {\n  const disposableEx = obj as Partial<DisposableEx>;\n  return isDisposable(obj) && 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  if (isAsyncDisposableEx(asyncDisposable)) {\n    return asyncDisposable;\n  }\n\n  return {\n    asyncDispose,\n    [Symbol.asyncDispose]: asyncDispose\n  };\n\n  function asyncDispose(): Promise<void> {\n    return Promise.resolve(asyncDisposable[Symbol.asyncDispose]());\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  if (isDisposableEx(disposable)) {\n    return disposable;\n  }\n\n  return {\n    dispose,\n    [Symbol.dispose]: dispose\n  };\n\n  function dispose(): void {\n    disposable[Symbol.dispose]();\n  }\n}\n"],
  "mappings": "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",
  "names": ["DisposeErrorBehavior", "DisposeOrder", "MultipleDisposeBehavior"]
}

+//# 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 { 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 = (this: void) => 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 = (this: void) => 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 * 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 new AggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly AsyncDisposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo:\n        return this.children;\n      case DisposeOrder.Lifo:\n        return [...this.children].reverse();\n      default:\n        assertNever(this.disposeOrder);\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 new AggregateError(errors);\n    }\n  }\n\n  private getOrderedChildren(): readonly Disposable[] {\n    switch (this.disposeOrder) {\n      case DisposeOrder.Fifo:\n        return this.children;\n      case DisposeOrder.Lifo:\n        return [...this.children].reverse();\n      default:\n        assertNever(this.disposeOrder);\n    }\n  }\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposable} interface.\n *\n * @param obj - the object to check for the {@link AsyncDisposable} interface\n * @returns Whether the object implements the {@link AsyncDisposable} interface\n */\nexport function isAsyncDisposable(obj: unknown): obj is AsyncDisposable {\n  const asyncDisposable = obj as Partial<AsyncDisposable>;\n  return !!asyncDisposable[Symbol.asyncDispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposableEx} interface.\n *\n * @param obj - the object to check for the {@link AsyncDisposableEx} interface\n * @returns Whether the object implements the {@link AsyncDisposableEx} interface\n */\nexport function isAsyncDisposableEx(obj: unknown): obj is AsyncDisposableEx {\n  const asyncDisposableEx = obj as Partial<AsyncDisposableEx>;\n  return isAsyncDisposable(obj) && typeof asyncDisposableEx.asyncDispose === 'function';\n}\n\n/**\n * Type guard to check if an object implements the {@link Disposable} interface.\n *\n * @param obj - the object to check for the {@link Disposable} interface\n * @returns Whether the object implements the {@link Disposable} interface\n */\nexport function isDisposable(obj: unknown): obj is Disposable {\n  const disposable = obj as Partial<Disposable>;\n  return !!disposable[Symbol.dispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link DisposableEx} interface.\n *\n * @param obj - the object to check for the {@link DisposableEx} interface\n * @returns Whether the object implements the {@link DisposableEx} interface\n */\nexport function isDisposableEx(obj: unknown): obj is DisposableEx {\n  const disposableEx = obj as Partial<DisposableEx>;\n  return isDisposable(obj) && 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  if (isAsyncDisposableEx(asyncDisposable)) {\n    return asyncDisposable;\n  }\n\n  return {\n    asyncDispose,\n    [Symbol.asyncDispose]: asyncDispose\n  };\n\n  function asyncDispose(): Promise<void> {\n    return Promise.resolve(asyncDisposable[Symbol.asyncDispose]());\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  if (isDisposableEx(disposable)) {\n    return disposable;\n  }\n\n  return {\n    dispose,\n    [Symbol.dispose]: dispose\n  };\n\n  function dispose(): void {\n    disposable[Symbol.dispose]();\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    case MultipleDisposeBehavior.Invoke:\n      return true;\n    case MultipleDisposeBehavior.Throw:\n      throw new Error('This disposable has already been disposed.');\n    default:\n      assertNever(multipleDisposeBehavior);\n  }\n}\n"],
  "mappings": "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",
  "names": ["DisposeErrorBehavior", "DisposeOrder", "MultipleDisposeBehavior"]
}
