88 lines
2.6 KiB
JavaScript
88 lines
2.6 KiB
JavaScript
|
/**
|
||
|
|
* @license
|
||
|
|
* Copyright 2021 Google LLC
|
||
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
||
|
|
*/
|
||
|
|
// Note, this module is not included in package exports so that it's private to
|
||
|
|
// our first-party directives. If it ends up being useful, we can open it up and
|
||
|
|
// export it.
|
||
|
|
/**
|
||
|
|
* Helper to iterate an AsyncIterable in its own closure.
|
||
|
|
* @param iterable The iterable to iterate
|
||
|
|
* @param callback The callback to call for each value. If the callback returns
|
||
|
|
* `false`, the loop will be broken.
|
||
|
|
*/
|
||
|
|
const forAwaitOf = async (iterable, callback) => {
|
||
|
|
for await (const v of iterable) {
|
||
|
|
if ((await callback(v)) === false) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* Holds a reference to an instance that can be disconnected and reconnected,
|
||
|
|
* so that a closure over the ref (e.g. in a then function to a promise) does
|
||
|
|
* not strongly hold a ref to the instance. Approximates a WeakRef but must
|
||
|
|
* be manually connected & disconnected to the backing instance.
|
||
|
|
*/
|
||
|
|
class PseudoWeakRef {
|
||
|
|
constructor(ref) {
|
||
|
|
this._ref = ref;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Disassociates the ref with the backing instance.
|
||
|
|
*/
|
||
|
|
disconnect() {
|
||
|
|
this._ref = undefined;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Reassociates the ref with the backing instance.
|
||
|
|
*/
|
||
|
|
reconnect(ref) {
|
||
|
|
this._ref = ref;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Retrieves the backing instance (will be undefined when disconnected)
|
||
|
|
*/
|
||
|
|
deref() {
|
||
|
|
return this._ref;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* A helper to pause and resume waiting on a condition in an async function
|
||
|
|
*/
|
||
|
|
class Pauser {
|
||
|
|
constructor() {
|
||
|
|
this._promise = undefined;
|
||
|
|
this._resolve = undefined;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* When paused, returns a promise to be awaited; when unpaused, returns
|
||
|
|
* undefined. Note that in the microtask between the pauser being resumed
|
||
|
|
* an an await of this promise resolving, the pauser could be paused again,
|
||
|
|
* hence callers should check the promise in a loop when awaiting.
|
||
|
|
* @returns A promise to be awaited when paused or undefined
|
||
|
|
*/
|
||
|
|
get() {
|
||
|
|
return this._promise;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Creates a promise to be awaited
|
||
|
|
*/
|
||
|
|
pause() {
|
||
|
|
var _a;
|
||
|
|
(_a = this._promise) !== null && _a !== void 0 ? _a : (this._promise = new Promise((resolve) => (this._resolve = resolve)));
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Resolves the promise which may be awaited
|
||
|
|
*/
|
||
|
|
resume() {
|
||
|
|
var _a;
|
||
|
|
(_a = this._resolve) === null || _a === void 0 ? void 0 : _a.call(this);
|
||
|
|
this._promise = this._resolve = undefined;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
export { Pauser, PseudoWeakRef, forAwaitOf };
|
||
|
|
//# sourceMappingURL=private-async-helpers.js.map
|