AbortController

const controller = new AbortController();

const response = await fetch("https://example.com", {
  signal: controller.signal
});

controller.abort();

const http = require("node:http");

const server = http.createServer((request, response) => {
  // Імітуємо повільний HTTP-сервер
  setTimeout(() => {
    response.writeHead(200, {
      "Content-Type": "application/json"
    });

    response.end(JSON.stringify({ message: "Готово" }));
  }, 3000);
});

server.listen(0, async () => {
  const { port } = server.address();
  const controller = new AbortController();

  const cancelTimer = setTimeout(() => {
    controller.abort();
  }, 500);

  try {
    const response = await fetch(`http://localhost:${port}`, {
      signal: controller.signal
    });

    const data = await response.json();
    console.log(data);
  } catch (error) {
    if (controller.signal.aborted) {
      console.log("Запит скасовано");
    } else {
      console.error("Сталася помилка запиту:", error);
    }
  } finally {
    clearTimeout(cancelTimer);
    server.close();
  }
});

async function loadUser(userId, { signal } = {}) {
  const response = await fetch(
    `https://api.example.com/users/${userId}`,
    { signal }
  );

  if (!response.ok) {
    throw new Error(`HTTP-помилка: ${response.status}`);
  }

  return response.json();
}

async function main() {
  const controller = new AbortController();

  setTimeout(() => {
    controller.abort();
  }, 1000);

  try {
    const user = await loadUser(42, {
      signal: controller.signal
    });

    console.log(user);
  } catch (error) {
    if (controller.signal.aborted) {
      console.log("Завантаження користувача скасовано");
    } else {
      throw error;
    }
  }
}

main().catch((error) => {
  console.error("Непередбачена помилка:", error);
});

const controller = new AbortController();

controller.abort(new Error("Користувач залишив сторінку"));

const controller = new AbortController();

controller.abort("Операція більше не потрібна");

console.log(controller.signal.aborted); // true
console.log(controller.signal.reason);  // "Операція більше не потрібна"

async function loadData() {
  const signal = AbortSignal.timeout(2000);

  try {
    const response = await fetch("https://example.com", {
      signal
    });

    return await response.text();
  } catch (error) {
    if (signal.aborted) {
      console.log("Запит перевищив допустимий час");
      return null;
    }

    throw error;
  }
}

loadData().catch((error) => {
  console.error("Помилка:", error);
});

const { setTimeout: delay } = require("node:timers/promises");

async function run() {
  const controller = new AbortController();

  const timer = setTimeout(() => {
    controller.abort();
  }, 500);

  try {
    await delay(3000, undefined, {
      signal: controller.signal
    });

    console.log("Очікування завершено");
  } catch (error) {
    if (controller.signal.aborted) {
      console.log("Очікування скасовано");
    } else {
      throw error;
    }
  } finally {
    clearTimeout(timer);
  }
}

run().catch(console.error);

async function processData({ signal } = {}) {
  if (signal?.aborted) {
    throw signal.reason ?? new Error("Операцію скасовано");
  }

  // Виконання тривалої операції
  return "Результат";
}

async function main() {
  const controller = new AbortController();
  controller.abort();

  try {
    await processData({
      signal: controller.signal
    });
  } catch (error) {
    if (controller.signal.aborted) {
      console.log("Операцію не було запущено");
    } else {
      throw error;
    }
  }
}

main();

const controller = new AbortController();

const firstRequest = fetch("https://example.com/first", {
  signal: controller.signal
});

const secondRequest = fetch("https://example.com/second", {
  signal: controller.signal
});

setTimeout(() => {
  controller.abort();
}, 1000);

try {
  const response = await fetch(url, {
    signal
  });

  return await response.json();
} catch (error) {
  if (signal.aborted) {
    return null;
  }

  throw error;
}

try {
  await fetch(url, { signal });
} catch {
  // Погано: тут приховуються також проблеми мережі та програмні помилки
}

async function loadData(signal) {
  const controller = new AbortController();

  return fetch(url, {
    signal: controller.signal
  });
}

async function loadData(signal) {
  return fetch(url, { signal });
}

fetch(url, {
  signal: controller
});

fetch(url, {
  signal: controller.signal
});

const controller = new AbortController();

controller.abort();

// Цей запит одразу буде скасовано
fetch(url, {
  signal: controller.signal
});

const newController = new AbortController();

fetch(url, {
  signal: newController.signal
});

function customOperation() {
  return new Promise((resolve) => {
    setTimeout(resolve, 3000);
  });
}

function customOperation({ signal } = {}) {
  return new Promise((resolve, reject) => {
    if (signal?.aborted) {
      reject(signal.reason ?? new Error("Операцію скасовано"));
      return;
    }

    const timer = setTimeout(() => {
      cleanup();
      resolve("Готово");
    }, 3000);

    const onAbort = () => {
      clearTimeout(timer);
      cleanup();
      reject(signal.reason ?? new Error("Операцію скасовано"));
    };

    const cleanup = () => {
      signal?.removeEventListener("abort", onAbort);
    };

    signal?.addEventListener("abort", onAbort, { once: true });
  });
}