Что такое using и Disposable в TypeScript 5.2?

// ❌ Без using — нужен try/finally

function readConfig() {
  const file = openFile("config.json");
  try {
    return file.read();
  } finally {
    file.close(); // легко забыть
  }
}

// Объект должен реализовать Disposable

class FileHandle implements Disposable {
  private handle: number;

  constructor(path: string) {
    this.handle = openRawFile(path);
    console.log(`Opened: ${path}`);
  }

  read(): string {
    return readFromHandle(this.handle);
  }

  [Symbol.dispose](): void {
    closeRawFile(this.handle);
    console.log("File closed");
  }
}

function readConfig() {
  using file = new FileHandle("config.json");
  return file.read();
  // [Symbol.dispose]() вызывается автоматически при выходе из блока
}

class DbConnection implements AsyncDisposable {
  private connection: RawConnection;

  private constructor(conn: RawConnection) {
    this.connection = conn;
  }

  static async connect(url: string): Promise<DbConnection> {
    const conn = await rawConnect(url);
    return new DbConnection(conn);
  }

  async query(sql: string): Promise<unknown[]> {
    return this.connection.execute(sql);
  }

  async [Symbol.asyncDispose](): Promise<void> {
    await this.connection.close();
    console.log("Connection closed");
  }
}

// await using — для AsyncDisposable
async function getUsers() {
  await using db = await DbConnection.connect("postgres:// localhost/app");
  return db.query("SELECT * FROM users"); // соединение закроется автоматически
}

async function transfer() {
  await using source = await DbConnection.connect("postgres:// source");
  await using target = await DbConnection.connect("postgres:// target");

  const data = await source.query("SELECT * FROM accounts");
  // ... перенос данных ...

  // Порядок dispose: target первым, потом source (LIFO)
}

function createTempDir(): Disposable & { path: string } {
  const path = mkdtempSync("/tmp/app-");
  console.log(`Created: ${path}`);

  return {
    path,
    [Symbol.dispose]() {
      rmSync(path, { recursive: true });
      console.log(`Removed: ${path}`);
    },
  };
}

function buildProject() {
  using tmp = createTempDir(); // используем tmp.path для временных файлов
  // при выходе из функции папка удалится
}

class Mutex {
  private locked = false;
  private waiters: (() => void)[] = [];

  async acquire(): Promise<Disposable> {
    while (this.locked) {
      await new Promise<void>((resolve) => this.waiters.push(resolve));
    }
    this.locked = true;

    return {
      [Symbol.dispose]: () => {
        this.locked = false;
        this.waiters.shift()?.();
      },
    };
  }
}

const mutex = new Mutex();

async function criticalSection() {
  using lock = await mutex.acquire(); // безопасная работа с общим ресурсом
  // лок автоматически отпустится
}

// ❌ Обычный const — dispose не вызовется
const file = new FileHandle("data.txt"); // file[Symbol.dispose]() не вызовется автоматически

// ✅ using — dispose вызовется при выходе из скоупа
using file2 = new FileHandle("data.txt");