dispose

import { DisposableStack } from "https://deno.land/x/dispose/mod.ts";

const stack = new DisposableStack();
console.log(stack.disposed); // Output: false

use<T extends Disposable | null | undefined>(value: T): T;

// block scope
{
  using stack = new DisposableStack();
  const resource = getResource();
  stack.use(resource);
}

adopt<T>(value: T, onDispose: (value: T) => void): T;

const stack = new DisposableStack();
const value = "someValue";
stack.adopt("someValue", (v) => {
  console.log(`Disposing of value: ${v}`);
});

defer(onDispose: () => void): void

const stack = new DisposableStack();
stack.defer(() => {
  console.log("Stack has been disposed.");
});

move(): DisposableStack;

using stack1 = new DisposableStack();

// Add some resources to stack1...

const stack2 = stack1.move();
// stack2 now contains the resources, and stack1 is disposed of.

dispose(): void;

const stack = new DisposableStack();
// Add resources...
stack.dispose();

import { AsyncDisposableStack } from "https://deno.land/x/dispose/mod.ts";

await using stack = new AsyncDisposableStack();

while (!stack.disposed) {
  // ... add some asynchronous resources here ...
  const resource = await stack.use(getResource());
}

// stack is disposed of here
console.log(stack.disposed);

async use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): Promise<T>;

await using stack = new AsyncDisposableStack();
await stack.adopt("value", async (v) => {
  // some asynchronous cleanup operation await new Promise((resolve) =>
  setTimeout(resolve, 500);
  console.log(`Asynchronously disposing of value: ${v}`);
});

async adopt<T>(value: T, onDisposeAsync: (value: T) => PromiseLike<void> | void): Promise<T>

await using stack = new AsyncDisposableStack();

const tmp = await stack.adopt(await Deno.makeTempFile(), async (v) => {
  // some asynchronous cleanup operation
  await new Promise((resolve) => setTimeout(resolve, 500));
  console.log(`Asynchronously disposing of temp file: ${v}`);
  // remove the temp file
  await Deno.remove(v);
});

// do some work with the temp file...
await tmp.stat();

async defer(onDisposeAsync: () => PromiseLike<void> | void): Promise<void>

await using stack = new AsyncDisposableStack();

await stack.defer(async () => {
  // some asynchronous cleanup operation
  await new Promise((resolve) => setTimeout(resolve, 500));
  console.log("Stack has been asynchronously disposed.");
});

async move(): Promise<AsyncDisposableStack>

await using stack1 = new AsyncDisposableStack();

// Add some async resources to stack1...

const stack2 = await stack1.move();
// stack2 now contains the resources, and stack1 is disposed of.

async disposeAsync(): Promise<void>;

const stack = new AsyncDisposableStack();

// Add async resources...

await stack.disposeAsync();

import type { Disposable } from "https://deno.land/x/dispose/mod.ts";

interface Disposable {
  [Symbol.dispose](): void;
}

import type { AsyncDisposable } from "https://deno.land/x/dispose/mod.ts";

interface AsyncDisposable {
  [Symbol.asyncDispose](): PromiseLike<void> | void;
}

import "https://deno.land/x/dispose/symbol.ts";

import {
  type AsyncDisposable,
  AsyncDisposableStack,
} from "https://deno.land/x/dispose/mod.ts";

class AsyncConstruct implements AsyncDisposable {
  #resourceA: AsyncDisposable;
  #resourceB: AsyncDisposable;
  #resources: AsyncDisposableStack;

  get resourceA() {
    return this.#resourceA;
  }

  get resourceB() {
    return this.#resourceB;
  }

  async init(): Promise<void> {
    // stack will be disposed when exiting this method for any reason
    await using stack = new AsyncDisposableStack();

    // adopts an async resource, adding it to the stack. this lets us utilize
    // resource management APIs with existing features that may not support the
    // bleeding-edge features like `AsyncDisposable` yet. In this case, we're
    // adding a temporary file (as a string), with a removal function that will
    // clean up the file when the stack is disposed (or this function exits).
    this.#resourceA = await stack.adopt(
      await Deno.makeTempFile(),
      async (path) => await Deno.remove(path),
    );

    // do some work with the resource
    await Deno.writeTextFile(this.#resourceA, JSON.stringify({ foo: "bar" }));

    // Acquire a second resource. If this fails, both `stack` and `#resourceA`
    // will be disposed. Notice we use the `.use` method here, since we're
    // acquiring a resource that implements the `AsyncDisposable` interface.
    this.#resourceB = await stack.use(await this.get());

    // all operations succeeded, move resources out of `stack` so that they aren't disposed
    // when this function exits. we can now use the resources as we please, and
    // they will be disposed when the parent object is disposed.
    this.#resources = stack.move();
  }

  async get(): Promise<AsyncDisposable> {
    console.log("acquiring resource B");
    const resource = {
      data: JSON.parse(await Deno.readTextFile(this.#resourceA)),
    };
    return Object.create({
      async [Symbol.asyncDispose]() {
        console.log("disposing resource B");
        resource.data = null!;
        return await Promise.resolve();
      },
    }, { resource: { value: resource, enumerable: true } });
  }

  async [Symbol.asyncDispose]() {
    await this.#resources.disposeAsync();
  }
}

{
  await using construct = new AsyncConstruct();
  await construct.init();
  console.log("resource A:", construct.resourceA);
  console.log("resource B:", construct.resourceB);
  console.log("We're done here.");
}

import {
  type Disposable,
  DisposableStack,
} from "https://deno.land/x/dispose/mod.ts";

class Construct implements Disposable {
  #resourceA: Disposable;
  #resourceB: Disposable;
  #resources: DisposableStack;
  constructor() {
    // stack will be disposed when exiting constructor for any reason
    using stack = new DisposableStack();

    // get first resource
    this.#resourceA = stack.use(getResource1());

    // get second resource. If this fails, both `stack` and `#resourceA` will be disposed.
    this.#resourceB = stack.use(getResource2());

    // all operations succeeded, move resources out of `stack` so that they aren't disposed
    // when constructor exits
    this.#resources = stack.move();
  }

  [Symbol.dispose]() {
    this.#resources.dispose();
  }
}