@amazon/vinyl-util 1.0.0

package/dist/types/current/util/async/TaskQueue.js

@@ -0,0 +1,124 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LinkedList } from '../../util/collection/LinkedList';
+import { createAbortSlot } from './Abort';
+import { withAbort } from './abortUtils';
+import { AbortError } from '../../error/AbortError';
+/**
+ * A TaskQueue runs actions in a sequence, with the ability to abort the queued tasks.
+ */
+export class TaskQueue {
+    comparator;
+    defaultPriority;
+    _simultaneous = 1;
+    _running = 0;
+    /**
+     * Use {@link createTaskQueue} to construct a new TaskQueue.
+     */
+    constructor(
+    /**
+     * A comparator for comparing two task priorities.
+     */
+    comparator, 
+    /**
+     * The default priority if not provided.
+     * If comparator is nullish priority values will have no effect.
+     */
+    defaultPriority) {
+        this.comparator = comparator;
+        this.defaultPriority = defaultPriority;
+    }
+    get simultaneous() {
+        return this._simultaneous;
+    }
+    /**
+     * How many simultaneous tasks may be run at a time.
+     * Reducing this will not abort currently running tasks.
+     */
+    set simultaneous(value) {
+        this._simultaneous = value;
+        this.checkQueue();
+    }
+    pending = new LinkedList();
+    abortSlot = createAbortSlot();
+    /**
+     * How many tasks are currently running.
+     */
+    get running() {
+        return this._running;
+    }
+    /**
+     * Enqueues the given task, returning a Promise that settles when the task is complete.
+     *
+     * @param task A function that is optionally asynchronous.
+     * @param priority The priority of the task. If not provided, `defaultPriority()` will be used.
+     */
+    enqueue(task, priority = this.defaultPriority) {
+        const abort = this.abortSlot.value;
+        return new Promise((resolve, reject) => {
+            this.pending.push({
+                priority,
+                execute: () => {
+                    if (abort.aborted()) {
+                        reject(abort.reason);
+                        this.checkQueue();
+                        return;
+                    }
+                    this._running++;
+                    let result;
+                    try {
+                        result = task(abort);
+                    }
+                    catch (error) {
+                        reject(error);
+                        this._running--;
+                        return;
+                    }
+                    withAbort(Promise.resolve(result), abort)
+                        .then(resolve)
+                        .catch(reject)
+                        .finally(() => {
+                        this._running--;
+                        this.checkQueue();
+                    });
+                },
+            });
+            this.checkQueue();
+        });
+    }
+    /**
+     * If the queue has any remaining actions and if there is additional capacity to execute, picks the next
+     * task with the highest priority according to this queue's comparator.
+     * @private
+     */
+    checkQueue() {
+        while (!this.pending.empty && this._running < this.simultaneous) {
+            let current = this.pending.head;
+            let highestPriorityNode = current;
+            if (this.comparator) {
+                current = current.next;
+                while (current != null) {
+                    if (this.comparator(highestPriorityNode.value.priority, current.value.priority) > 0) {
+                        highestPriorityNode = current;
+                    }
+                    current = current.next;
+                }
+            }
+            this.pending.remove(highestPriorityNode);
+            highestPriorityNode.value.execute();
+        }
+    }
+    /**
+     * Aborts all enqueued operations.
+     */
+    abort(reason = new AbortError()) {
+        if (!this.running)
+            return;
+        this.abortSlot.abort(reason);
+    }
+}
+export function createTaskQueue(comparator, defaultPriority) {
+    return new TaskQueue(comparator, defaultPriority);
+}

package/dist/types/current/util/async/TimeoutController.d.ts

@@ -0,0 +1,36 @@
+import type { Disposable } from '../../core/disposable';
+import { Abort, type ReadonlyAbort } from './Abort';
+import type { Maybe } from '../../util/type';
+/**
+ * A `TimeoutController` is an {@link ReadonlyAbort} implementation that will abort either after
+ * an elapsed timeout, an explicit abort call, or if the optional external abort signal fires.
+ *
+ * This allows a function (such as the network fetch layer) to abort from an externally provided
+ * abort signal, while maintaining its own timeout and abort logic internally.
+ */
+export declare class TimeoutController extends Abort implements ReadonlyAbort, Disposable {
+    readonly timeout: number;
+    private readonly message;
+    private readonly timeoutId;
+    private readonly abortSub;
+    private readonly startedAt;
+    /**
+     * @param timeout The number of seconds before the returned abort signal will abort with a
+     * {@link TimeoutError}.
+     * @param abort An abort signal to cascade.
+     * @param message The timeout message. Uses one token `{time}` which will be replaced by the
+     * timeout.
+     */
+    constructor(timeout: number, abort?: Maybe<ReadonlyAbort>, message?: string);
+    /**
+     * Aborts with a {@link TimeoutError}
+     */
+    abortWithTimeout(): void;
+    /**
+     * Sleeps the given amount of time, or immediately rejects if the sleep will cause a timeout.
+     * @param time The number of seconds to sleep.
+     */
+    sleep(time: number): Promise<void>;
+    dispose(): void;
+}
+//# sourceMappingURL=TimeoutController.d.ts.map

package/dist/types/current/util/async/TimeoutController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeoutController.d.ts","sourceRoot":"","sources":["../../../../../src/util/async/TimeoutController.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAGnD,OAAO,EAAE,KAAK,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAInD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;;GAMG;AACH,qBAAa,iBACT,SAAQ,KACR,YAAW,aAAa,EAAE,UAAU;IAehC,QAAQ,CAAC,OAAO,EAAE,MAAM;IAExB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAf5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAE9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAElD;;;;;;OAMG;gBAEU,OAAO,EAAE,MAAM,EACxB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,EACX,OAAO,SAA4B;IAYxD;;OAEG;IACH,gBAAgB;IAMhB;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASlC,OAAO;CAIV"}

package/dist/types/current/util/async/TimeoutController.js

@@ -0,0 +1,62 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TimeoutError } from '../../error/TimeoutError';
+import { Abort } from './Abort';
+import { sleep } from './sleep';
+import { substitute } from '../../util/string/string';
+/**
+ * A `TimeoutController` is an {@link ReadonlyAbort} implementation that will abort either after
+ * an elapsed timeout, an explicit abort call, or if the optional external abort signal fires.
+ *
+ * This allows a function (such as the network fetch layer) to abort from an externally provided
+ * abort signal, while maintaining its own timeout and abort logic internally.
+ */
+export class TimeoutController extends Abort {
+    timeout;
+    message;
+    timeoutId;
+    abortSub;
+    startedAt = Date.now();
+    /**
+     * @param timeout The number of seconds before the returned abort signal will abort with a
+     * {@link TimeoutError}.
+     * @param abort An abort signal to cascade.
+     * @param message The timeout message. Uses one token `{time}` which will be replaced by the
+     * timeout.
+     */
+    constructor(timeout, abort, message = 'Timed out after {time}s') {
+        super();
+        this.timeout = timeout;
+        this.message = message;
+        this.timeoutId = setTimeout(() => this.abortWithTimeout(), timeout * 1000);
+        const abortHandler = () => this.abort(abort.reason);
+        this.abortSub = abort?.on('abort', abortHandler) ?? null;
+        if (abort?.aborted())
+            abortHandler();
+    }
+    /**
+     * Aborts with a {@link TimeoutError}
+     */
+    abortWithTimeout() {
+        this.abort(new TimeoutError(substitute(this.message, { time: this.timeout })));
+    }
+    /**
+     * Sleeps the given amount of time, or immediately rejects if the sleep will cause a timeout.
+     * @param time The number of seconds to sleep.
+     */
+    sleep(time) {
+        const elapsed = (Date.now() - this.startedAt) / 1000;
+        if (elapsed + time >= this.timeout) {
+            this.abortWithTimeout();
+            return Promise.reject(this.reason);
+        }
+        return sleep(time, this);
+    }
+    dispose() {
+        clearTimeout(this.timeoutId);
+        if (this.abortSub)
+            this.abortSub();
+    }
+}

package/dist/types/current/util/async/TimeoutSlot.d.ts

@@ -0,0 +1,29 @@
+import type { Disposable } from '../../core/disposable';
+/**
+ * A TimeoutSlot provides a way to have a managed window timeout that can be added to a
+ * disposer, and guarantee that there is only one timeout active at a time.
+ */
+export declare class TimeoutSlot implements Disposable {
+    private timeoutId;
+    private disposed;
+    /**
+     * Returns true if there is an active timeout pending.
+     */
+    get active(): boolean;
+    /**
+     * Sets a timeout, clearing any existing timeout first.
+     *
+     * @param callback The callback to invoke after the given time has elapsed.
+     * @param time The amount of time to wait, in seconds.
+     */
+    set(callback: () => void, time?: number): void;
+    /**
+     * Clears the existing timeout.
+     */
+    clear(): void;
+    /**
+     * Clears the timeout and throws an error if a new one is attempted to be set.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=TimeoutSlot.d.ts.map

package/dist/types/current/util/async/TimeoutSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeoutSlot.d.ts","sourceRoot":"","sources":["../../../../../src/util/async/TimeoutSlot.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAInD;;;GAGG;AACH,qBAAa,WAAY,YAAW,UAAU;IAC1C,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,QAAQ,CAAQ;IAExB;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;;;;OAKG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM;IAYvC;;OAEG;IACH,KAAK;IAML;;OAEG;IACH,OAAO,IAAI,IAAI;CAIlB"}

package/dist/types/current/util/async/TimeoutSlot.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DisposedError } from '../../core/disposable';
+/**
+ * A TimeoutSlot provides a way to have a managed window timeout that can be added to a
+ * disposer, and guarantee that there is only one timeout active at a time.
+ */
+export class TimeoutSlot {
+    timeoutId = null;
+    disposed = false;
+    /**
+     * Returns true if there is an active timeout pending.
+     */
+    get active() {
+        return this.timeoutId != null;
+    }
+    /**
+     * Sets a timeout, clearing any existing timeout first.
+     *
+     * @param callback The callback to invoke after the given time has elapsed.
+     * @param time The amount of time to wait, in seconds.
+     */
+    set(callback, time) {
+        if (this.disposed)
+            throw new DisposedError();
+        this.clear();
+        this.timeoutId = setTimeout(() => {
+            this.timeoutId = null;
+            callback();
+        }, time == null ? time : time * 1000);
+    }
+    /**
+     * Clears the existing timeout.
+     */
+    clear() {
+        if (this.timeoutId == null)
+            return;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = null;
+    }
+    /**
+     * Clears the timeout and throws an error if a new one is attempted to be set.
+     */
+    dispose() {
+        this.clear();
+        this.disposed = true;
+    }
+}

package/dist/types/current/util/async/abortUtils.d.ts

@@ -0,0 +1,15 @@
+import type { ReadonlyAbort } from './Abort';
+import type { Maybe } from '../../util/type';
+/**
+ * Races a promise and an abort signal.
+ * Generally, it is better to write your promises in a way that they reject and cleanup after an
+ * abort event (see `promise`), however, external promises don't always provide this
+ * capability.
+ * Some browsers accept an abort signal for `fetch` and `addEventListener`, but this is not
+ * widely supported enough to be relied upon.
+ *
+ * If both the abort signal is in an aborted state, and the given promise is in a resolved state,
+ * the returned promise will be rejected with the abort reason.
+ */
+export declare function withAbort<T>(promise: Promise<T>, abort?: Maybe<ReadonlyAbort>): Promise<T>;
+//# sourceMappingURL=abortUtils.d.ts.map

package/dist/types/current/util/async/abortUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortUtils.d.ts","sourceRoot":"","sources":["../../../../../src/util/async/abortUtils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACvB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CAaZ"}

package/dist/types/current/util/async/abortUtils.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Races a promise and an abort signal.
+ * Generally, it is better to write your promises in a way that they reject and cleanup after an
+ * abort event (see `promise`), however, external promises don't always provide this
+ * capability.
+ * Some browsers accept an abort signal for `fetch` and `addEventListener`, but this is not
+ * widely supported enough to be relied upon.
+ *
+ * If both the abort signal is in an aborted state, and the given promise is in a resolved state,
+ * the returned promise will be rejected with the abort reason.
+ */
+export function withAbort(promise, abort) {
+    if (!abort)
+        return promise;
+    if (abort.aborted())
+        return Promise.reject(abort.reason);
+    return new Promise((resolve, reject) => {
+        const abortSub = abort.on('abort', () => {
+            reject(abort.reason);
+        }, { once: true });
+        promise.then(resolve).catch(reject).finally(abortSub);
+    });
+}

package/dist/types/current/util/async/never.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A promise that never settles.
+ */
+export declare const never: Promise<never>;
+//# sourceMappingURL=never.d.ts.map

package/dist/types/current/util/async/never.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"never.d.ts","sourceRoot":"","sources":["../../../../../src/util/async/never.ts"],"names":[],"mappings":"AA8BA;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,OAAO,CAAC,KAAK,CAAe,CAAA"}

package/dist/types/current/util/async/never.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class Never {
+    catch(_onrejected) {
+        return this;
+    }
+    then(_onfulfilled, _onrejected) {
+        return this;
+    }
+    finally(_onfinally) {
+        return this;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Never';
+    }
+}
+/**
+ * A promise that never settles.
+ */
+export const never = new Never();

package/dist/types/current/util/async/promise.d.ts

@@ -0,0 +1,53 @@
+import type { Unsubscribe } from '../../core/Unsubscribe';
+import { type ReadonlyAbort } from './Abort';
+import type { Maybe } from '../../util/type';
+import { type Disposable } from '../../core/disposable';
+/**
+ * Creates a promise that can be rejected early from an abort signal and can optionally provide
+ * cleanup handling when the promise is settled.
+ *
+ * Common cases that require clean-up would be promises based on event listeners that must be
+ * removed, or timers that need to be cleared.
+ *
+ * Promises are always expected to settle. They cannot be canceled, but they can be rejected.
+ * This promise wrapper can be given an {@link ReadonlyAbort} object which rejects the promise
+ * if abort is emitted before the promise settles.
+ *
+ * @param executor A method that will be invoked at most once immediately with two arguments,
+ * `resolve` and `reject`. `resolve` must be called when the promise should be resolved, reject
+ * may be called if the promise should be rejected. An optional function may be returned that
+ * performs any cleanup necessary when the promise settles. This is called immediately before
+ * resolve or reject. The executor may not be invoked if the abortSignal is already in an
+ * aborted state.
+ * @param abort If provided, will reject the returned promise with the signal's abort
+ * reason when aborted.
+ */
+export declare function promise<T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => Unsubscribe | void, abort?: Maybe<ReadonlyAbort>): Promise<T>;
+/**
+ * Determines whether a value implements the `PromiseLike<T>` interface.
+ *
+ * This function checks if the given value is a non-null object with a `then` method,
+ * which is the structural requirement for `PromiseLike` in TypeScript.
+ *
+ * @typeParam T - The type the promise resolves to (optional, used for type narrowing).
+ * @param value - The value to check.
+ * @returns `true` if the value is `PromiseLike<T>`, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * const maybePromise: unknown = Promise.resolve(42)
+ * if (isPromiseLike(maybePromise)) {
+ *   maybePromise.then(value => console.log(value)) // value is type-safe
+ * }
+ * ```
+ */
+export declare function isPromiseLike<T = any>(value: unknown): value is PromiseLike<T>;
+/**
+ * Wraps a `PromiseLike<Disposable>` with a `Disposable` interface.
+ * Disposing will abort the operation and dispose the resolved value (if/when it resolves).
+ *
+ * @param promise - A Promise-like object that resolves to a `Disposable`
+ * @returns An object that implements both `PromiseLike<T>` and `Disposable`
+ */
+export declare function toDisposablePromise<T extends PromiseLike<any>>(promise: T): T & Disposable;
+//# sourceMappingURL=promise.d.ts.map

package/dist/types/current/util/async/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../../../../../src/util/async/promise.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAS,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAEnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EAAE,KAAK,UAAU,EAA+B,MAAM,mBAAmB,CAAA;AAGhF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACrB,QAAQ,EAAE,CACN,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,EAC5C,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,KAC7B,WAAW,GAAG,IAAI,EACvB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CA8CZ;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,GAAG,EACjC,KAAK,EAAE,OAAO,GACf,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAMzB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,WAAW,CAAC,GAAG,CAAC,EAC1D,OAAO,EAAE,CAAC,GACX,CAAC,GAAG,UAAU,CA+BhB"}

package/dist/types/current/util/async/promise.js

@@ -0,0 +1,131 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Abort } from './Abort';
+import { Deferred } from './Deferred';
+import { DisposedError, isDisposable } from '../../core/disposable';
+import { withAbort } from '../../util/async/abortUtils';
+/**
+ * Creates a promise that can be rejected early from an abort signal and can optionally provide
+ * cleanup handling when the promise is settled.
+ *
+ * Common cases that require clean-up would be promises based on event listeners that must be
+ * removed, or timers that need to be cleared.
+ *
+ * Promises are always expected to settle. They cannot be canceled, but they can be rejected.
+ * This promise wrapper can be given an {@link ReadonlyAbort} object which rejects the promise
+ * if abort is emitted before the promise settles.
+ *
+ * @param executor A method that will be invoked at most once immediately with two arguments,
+ * `resolve` and `reject`. `resolve` must be called when the promise should be resolved, reject
+ * may be called if the promise should be rejected. An optional function may be returned that
+ * performs any cleanup necessary when the promise settles. This is called immediately before
+ * resolve or reject. The executor may not be invoked if the abortSignal is already in an
+ * aborted state.
+ * @param abort If provided, will reject the returned promise with the signal's abort
+ * reason when aborted.
+ */
+export function promise(executor, abort) {
+    if (abort?.aborted())
+        return Promise.reject(abort.reason);
+    const deferred = new Deferred();
+    let resolved = false;
+    let resolvedTo = undefined;
+    let rejected = false;
+    let rejectionReason = undefined;
+    const abortSub = abort?.on('abort', (e) => reject(e.reason), {
+        once: true,
+    });
+    function settled() {
+        return resolved || rejected;
+    }
+    function complete() {
+        if (resolved) {
+            deferred.resolve(resolvedTo);
+        }
+        else {
+            deferred.reject(rejectionReason);
+        }
+        if (unsub)
+            unsub();
+        if (abortSub)
+            abortSub();
+    }
+    function resolve(value) {
+        if (settled())
+            return;
+        resolved = true;
+        resolvedTo = value;
+        if (initialized)
+            complete();
+    }
+    function reject(reason) {
+        if (settled())
+            return;
+        rejected = true;
+        rejectionReason = reason;
+        if (initialized)
+            complete();
+    }
+    let initialized = false;
+    const unsub = executor(resolve, reject);
+    initialized = true;
+    if (settled())
+        complete();
+    return deferred;
+}
+/**
+ * Determines whether a value implements the `PromiseLike<T>` interface.
+ *
+ * This function checks if the given value is a non-null object with a `then` method,
+ * which is the structural requirement for `PromiseLike` in TypeScript.
+ *
+ * @typeParam T - The type the promise resolves to (optional, used for type narrowing).
+ * @param value - The value to check.
+ * @returns `true` if the value is `PromiseLike<T>`, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * const maybePromise: unknown = Promise.resolve(42)
+ * if (isPromiseLike(maybePromise)) {
+ *   maybePromise.then(value => console.log(value)) // value is type-safe
+ * }
+ * ```
+ */
+export function isPromiseLike(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.then === 'function');
+}
+/**
+ * Wraps a `PromiseLike<Disposable>` with a `Disposable` interface.
+ * Disposing will abort the operation and dispose the resolved value (if/when it resolves).
+ *
+ * @param promise - A Promise-like object that resolves to a `Disposable`
+ * @returns An object that implements both `PromiseLike<T>` and `Disposable`
+ */
+export function toDisposablePromise(promise) {
+    const abort = new Abort();
+    let disposed = false;
+    let resolved = null;
+    const wrapped = withAbort(new Promise((resolve, reject) => {
+        promise.then((result) => {
+            resolved = result;
+            if (disposed && isDisposable(result)) {
+                result.dispose();
+            }
+            resolve(result);
+        }, (err) => reject(err));
+    }), abort);
+    wrapped.dispose = () => {
+        if (disposed)
+            throw new DisposedError();
+        disposed = true;
+        abort.abort();
+        if (isDisposable(resolved)) {
+            resolved.dispose();
+        }
+    };
+    return wrapped;
+}

package/dist/types/current/util/async/sleep.d.ts

@@ -0,0 +1,27 @@
+import type { ReadonlyAbort } from './Abort';
+/**
+ * Returns a promise that resolves after the given amount of time.
+ *
+ * Usage example:
+ * ```
+ * async function doThingsWithAbort(abort) {
+ *   await foo();
+ *   await sleep(2, abort);
+ *   await foo();
+ *   await sleep(5, abort);
+ *   await foo();
+ * }
+ *
+ * const abort = new Abort();
+ * doThingsWithAbort(abort).catch(() => console.log('aborted'))';
+ *
+ * abort.abort();
+ * ```
+ *
+ * @param time The time to sleep, in seconds.
+ * @param abort If provided, will reject the returned promise with the signal's abort
+ * reason when aborted. If the signal is already aborted and time is less than or equal to zero,
+ * the abort signal takes precedence.
+ */
+export declare function sleep(time: number, abort?: ReadonlyAbort | null): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/types/current/util/async/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../../../src/util/async/sleep.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAG5C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CACjB,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,aAAa,GAAG,IAAI,GAC7B,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/types/current/util/async/sleep.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { promise } from './promise';
+/**
+ * Returns a promise that resolves after the given amount of time.
+ *
+ * Usage example:
+ * ```
+ * async function doThingsWithAbort(abort) {
+ *   await foo();
+ *   await sleep(2, abort);
+ *   await foo();
+ *   await sleep(5, abort);
+ *   await foo();
+ * }
+ *
+ * const abort = new Abort();
+ * doThingsWithAbort(abort).catch(() => console.log('aborted'))';
+ *
+ * abort.abort();
+ * ```
+ *
+ * @param time The time to sleep, in seconds.
+ * @param abort If provided, will reject the returned promise with the signal's abort
+ * reason when aborted. If the signal is already aborted and time is less than or equal to zero,
+ * the abort signal takes precedence.
+ */
+export function sleep(time, abort) {
+    if (abort?.aborted())
+        return Promise.reject(abort.reason);
+    if (time <= 0.0)
+        return Promise.resolve(void 0);
+    return promise((resolve) => {
+        const timeoutId = setTimeout(() => {
+            resolve(void 0);
+        }, time * 1000);
+        return () => clearTimeout(timeoutId);
+    }, abort);
+}