Context7 Platform -- Up-to-date docs for AI agents
import { Context7Error } from "@error";
export type AbortState = {
signal?: AbortSignal;
timedOut: () => boolean;
cleanup: () => void;
};
export function validateTimeout(timeout: number | false): void {
if (timeout !== false && (!Number.isFinite(timeout) || timeout <= 0)) {
throw new TypeError("timeout must be a positive number or false");
}
}
export function resolveSignal(signal?: AbortSignal | (() => AbortSignal)): AbortSignal | undefined {
return typeof signal === "function" ? signal() : signal;
}
export function createAbortState(
signals: Array<AbortSignal | undefined>,
timeout: number | false
): AbortState {
validateTimeout(timeout);
const activeSignals = [
...new Set(signals.filter((signal): signal is AbortSignal => signal !== undefined)),
];
if (timeout === false && activeSignals.length === 0) {
return { timedOut: () => false, cleanup: () => undefined };
}
const controller = new AbortController();
let didTimeOut = false;
const listeners = new Map<AbortSignal, () => void>();
for (const signal of activeSignals) {
const abort = () => controller.abort(signal.reason);
if (signal.aborted) {
abort();
break;
}
signal.addEventListener("abort", abort, { once: true });
listeners.set(signal, abort);
}
const timer =
timeout === false
? undefined
: setTimeout(() => {
didTimeOut = true;
controller.abort(new Error(`Request timed out after ${timeout}ms`));
}, timeout);
return {
signal: controller.signal,
timedOut: () => didTimeOut,
cleanup: () => {
if (timer !== undefined) clearTimeout(timer);
for (const [signal, listener] of listeners) {
signal.removeEventListener("abort", listener);
}
},
};
}
export function abortError(cause: unknown, timedOut: boolean): Context7Error {
return new Context7Error(timedOut ? "Request timed out" : "Request was aborted", {
code: timedOut ? "request_timeout" : "request_aborted",
retryable: timedOut,
cause,
});
}
export function isContext7AbortError(error: unknown): boolean {
return (
error instanceof Context7Error &&
(error.code === "request_aborted" || error.code === "request_timeout")
);
}
/** Stop waiting on a value when cancelled, without cancelling its underlying work. */
export async function awaitWithSignal<T>(
value: T | PromiseLike<T>,
signal?: AbortSignal
): Promise<T> {
if (!signal) return value;
let onAbort!: () => void;
const aborted = new Promise<never>((_resolve, reject) => {
onAbort = () => reject(signal.reason);
if (signal.aborted) onAbort();
else signal.addEventListener("abort", onAbort, { once: true });
});
try {
// Keep a rejection handler on the provider even if cancellation wins the race.
return await Promise.race([value, aborted]);
} finally {
signal.removeEventListener("abort", onAbort);
}
}
export async function wait(milliseconds: number, signal?: AbortSignal): Promise<void> {
if (milliseconds <= 0) return;
await new Promise<void>((resolve, reject) => {
const finish = () => {
signal?.removeEventListener("abort", abort);
resolve();
};
const timer = setTimeout(finish, milliseconds);
const abort = () => {
clearTimeout(timer);
signal?.removeEventListener("abort", abort);
reject(signal?.reason ?? new Error("Request was aborted"));
};
if (signal?.aborted) {
abort();
return;
}
signal?.addEventListener("abort", abort, { once: true });
});
}