876 lines
30 KiB
JavaScript
876 lines
30 KiB
JavaScript
|
/*---------------------------------------------------------------------------------------------
|
||
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||
|
|
*--------------------------------------------------------------------------------------------*/
|
||
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
||
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
|
|
});
|
||
|
|
};
|
||
|
|
var __asyncValues = (this && this.__asyncValues) || function (o) {
|
||
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||
|
|
var m = o[Symbol.asyncIterator], i;
|
||
|
|
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||
|
|
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||
|
|
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||
|
|
};
|
||
|
|
import { CancellationTokenSource } from './cancellation.js';
|
||
|
|
import { CancellationError } from './errors.js';
|
||
|
|
import { Emitter, Event } from './event.js';
|
||
|
|
import { toDisposable } from './lifecycle.js';
|
||
|
|
import { setTimeout0 } from './platform.js';
|
||
|
|
import { MicrotaskDelay } from './symbols.js';
|
||
|
|
export function isThenable(obj) {
|
||
|
|
return !!obj && typeof obj.then === 'function';
|
||
|
|
}
|
||
|
|
export function createCancelablePromise(callback) {
|
||
|
|
const source = new CancellationTokenSource();
|
||
|
|
const thenable = callback(source.token);
|
||
|
|
const promise = new Promise((resolve, reject) => {
|
||
|
|
const subscription = source.token.onCancellationRequested(() => {
|
||
|
|
subscription.dispose();
|
||
|
|
source.dispose();
|
||
|
|
reject(new CancellationError());
|
||
|
|
});
|
||
|
|
Promise.resolve(thenable).then(value => {
|
||
|
|
subscription.dispose();
|
||
|
|
source.dispose();
|
||
|
|
resolve(value);
|
||
|
|
}, err => {
|
||
|
|
subscription.dispose();
|
||
|
|
source.dispose();
|
||
|
|
reject(err);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
return new class {
|
||
|
|
cancel() {
|
||
|
|
source.cancel();
|
||
|
|
}
|
||
|
|
then(resolve, reject) {
|
||
|
|
return promise.then(resolve, reject);
|
||
|
|
}
|
||
|
|
catch(reject) {
|
||
|
|
return this.then(undefined, reject);
|
||
|
|
}
|
||
|
|
finally(onfinally) {
|
||
|
|
return promise.finally(onfinally);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
export function raceCancellation(promise, token, defaultValue) {
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
const ref = token.onCancellationRequested(() => {
|
||
|
|
ref.dispose();
|
||
|
|
resolve(defaultValue);
|
||
|
|
});
|
||
|
|
promise.then(resolve, reject).finally(() => ref.dispose());
|
||
|
|
});
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* A helper to prevent accumulation of sequential async tasks.
|
||
|
|
*
|
||
|
|
* Imagine a mail man with the sole task of delivering letters. As soon as
|
||
|
|
* a letter submitted for delivery, he drives to the destination, delivers it
|
||
|
|
* and returns to his base. Imagine that during the trip, N more letters were submitted.
|
||
|
|
* When the mail man returns, he picks those N letters and delivers them all in a
|
||
|
|
* single trip. Even though N+1 submissions occurred, only 2 deliveries were made.
|
||
|
|
*
|
||
|
|
* The throttler implements this via the queue() method, by providing it a task
|
||
|
|
* factory. Following the example:
|
||
|
|
*
|
||
|
|
* const throttler = new Throttler();
|
||
|
|
* const letters = [];
|
||
|
|
*
|
||
|
|
* function deliver() {
|
||
|
|
* const lettersToDeliver = letters;
|
||
|
|
* letters = [];
|
||
|
|
* return makeTheTrip(lettersToDeliver);
|
||
|
|
* }
|
||
|
|
*
|
||
|
|
* function onLetterReceived(l) {
|
||
|
|
* letters.push(l);
|
||
|
|
* throttler.queue(deliver);
|
||
|
|
* }
|
||
|
|
*/
|
||
|
|
export class Throttler {
|
||
|
|
constructor() {
|
||
|
|
this.isDisposed = false;
|
||
|
|
this.activePromise = null;
|
||
|
|
this.queuedPromise = null;
|
||
|
|
this.queuedPromiseFactory = null;
|
||
|
|
}
|
||
|
|
queue(promiseFactory) {
|
||
|
|
if (this.isDisposed) {
|
||
|
|
throw new Error('Throttler is disposed');
|
||
|
|
}
|
||
|
|
if (this.activePromise) {
|
||
|
|
this.queuedPromiseFactory = promiseFactory;
|
||
|
|
if (!this.queuedPromise) {
|
||
|
|
const onComplete = () => {
|
||
|
|
this.queuedPromise = null;
|
||
|
|
if (this.isDisposed) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const result = this.queue(this.queuedPromiseFactory);
|
||
|
|
this.queuedPromiseFactory = null;
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
this.queuedPromise = new Promise(resolve => {
|
||
|
|
this.activePromise.then(onComplete, onComplete).then(resolve);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
this.queuedPromise.then(resolve, reject);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
this.activePromise = promiseFactory();
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
this.activePromise.then((result) => {
|
||
|
|
this.activePromise = null;
|
||
|
|
resolve(result);
|
||
|
|
}, (err) => {
|
||
|
|
this.activePromise = null;
|
||
|
|
reject(err);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
dispose() {
|
||
|
|
this.isDisposed = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const timeoutDeferred = (timeout, fn) => {
|
||
|
|
let scheduled = true;
|
||
|
|
const handle = setTimeout(() => {
|
||
|
|
scheduled = false;
|
||
|
|
fn();
|
||
|
|
}, timeout);
|
||
|
|
return {
|
||
|
|
isTriggered: () => scheduled,
|
||
|
|
dispose: () => {
|
||
|
|
clearTimeout(handle);
|
||
|
|
scheduled = false;
|
||
|
|
},
|
||
|
|
};
|
||
|
|
};
|
||
|
|
const microtaskDeferred = (fn) => {
|
||
|
|
let scheduled = true;
|
||
|
|
queueMicrotask(() => {
|
||
|
|
if (scheduled) {
|
||
|
|
scheduled = false;
|
||
|
|
fn();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return {
|
||
|
|
isTriggered: () => scheduled,
|
||
|
|
dispose: () => { scheduled = false; },
|
||
|
|
};
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* A helper to delay (debounce) execution of a task that is being requested often.
|
||
|
|
*
|
||
|
|
* Following the throttler, now imagine the mail man wants to optimize the number of
|
||
|
|
* trips proactively. The trip itself can be long, so he decides not to make the trip
|
||
|
|
* as soon as a letter is submitted. Instead he waits a while, in case more
|
||
|
|
* letters are submitted. After said waiting period, if no letters were submitted, he
|
||
|
|
* decides to make the trip. Imagine that N more letters were submitted after the first
|
||
|
|
* one, all within a short period of time between each other. Even though N+1
|
||
|
|
* submissions occurred, only 1 delivery was made.
|
||
|
|
*
|
||
|
|
* The delayer offers this behavior via the trigger() method, into which both the task
|
||
|
|
* to be executed and the waiting period (delay) must be passed in as arguments. Following
|
||
|
|
* the example:
|
||
|
|
*
|
||
|
|
* const delayer = new Delayer(WAITING_PERIOD);
|
||
|
|
* const letters = [];
|
||
|
|
*
|
||
|
|
* function letterReceived(l) {
|
||
|
|
* letters.push(l);
|
||
|
|
* delayer.trigger(() => { return makeTheTrip(); });
|
||
|
|
* }
|
||
|
|
*/
|
||
|
|
export class Delayer {
|
||
|
|
constructor(defaultDelay) {
|
||
|
|
this.defaultDelay = defaultDelay;
|
||
|
|
this.deferred = null;
|
||
|
|
this.completionPromise = null;
|
||
|
|
this.doResolve = null;
|
||
|
|
this.doReject = null;
|
||
|
|
this.task = null;
|
||
|
|
}
|
||
|
|
trigger(task, delay = this.defaultDelay) {
|
||
|
|
this.task = task;
|
||
|
|
this.cancelTimeout();
|
||
|
|
if (!this.completionPromise) {
|
||
|
|
this.completionPromise = new Promise((resolve, reject) => {
|
||
|
|
this.doResolve = resolve;
|
||
|
|
this.doReject = reject;
|
||
|
|
}).then(() => {
|
||
|
|
this.completionPromise = null;
|
||
|
|
this.doResolve = null;
|
||
|
|
if (this.task) {
|
||
|
|
const task = this.task;
|
||
|
|
this.task = null;
|
||
|
|
return task();
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
const fn = () => {
|
||
|
|
var _a;
|
||
|
|
this.deferred = null;
|
||
|
|
(_a = this.doResolve) === null || _a === void 0 ? void 0 : _a.call(this, null);
|
||
|
|
};
|
||
|
|
this.deferred = delay === MicrotaskDelay ? microtaskDeferred(fn) : timeoutDeferred(delay, fn);
|
||
|
|
return this.completionPromise;
|
||
|
|
}
|
||
|
|
isTriggered() {
|
||
|
|
var _a;
|
||
|
|
return !!((_a = this.deferred) === null || _a === void 0 ? void 0 : _a.isTriggered());
|
||
|
|
}
|
||
|
|
cancel() {
|
||
|
|
var _a;
|
||
|
|
this.cancelTimeout();
|
||
|
|
if (this.completionPromise) {
|
||
|
|
(_a = this.doReject) === null || _a === void 0 ? void 0 : _a.call(this, new CancellationError());
|
||
|
|
this.completionPromise = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cancelTimeout() {
|
||
|
|
var _a;
|
||
|
|
(_a = this.deferred) === null || _a === void 0 ? void 0 : _a.dispose();
|
||
|
|
this.deferred = null;
|
||
|
|
}
|
||
|
|
dispose() {
|
||
|
|
this.cancel();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* A helper to delay execution of a task that is being requested often, while
|
||
|
|
* preventing accumulation of consecutive executions, while the task runs.
|
||
|
|
*
|
||
|
|
* The mail man is clever and waits for a certain amount of time, before going
|
||
|
|
* out to deliver letters. While the mail man is going out, more letters arrive
|
||
|
|
* and can only be delivered once he is back. Once he is back the mail man will
|
||
|
|
* do one more trip to deliver the letters that have accumulated while he was out.
|
||
|
|
*/
|
||
|
|
export class ThrottledDelayer {
|
||
|
|
constructor(defaultDelay) {
|
||
|
|
this.delayer = new Delayer(defaultDelay);
|
||
|
|
this.throttler = new Throttler();
|
||
|
|
}
|
||
|
|
trigger(promiseFactory, delay) {
|
||
|
|
return this.delayer.trigger(() => this.throttler.queue(promiseFactory), delay);
|
||
|
|
}
|
||
|
|
cancel() {
|
||
|
|
this.delayer.cancel();
|
||
|
|
}
|
||
|
|
dispose() {
|
||
|
|
this.delayer.dispose();
|
||
|
|
this.throttler.dispose();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
export function timeout(millis, token) {
|
||
|
|
if (!token) {
|
||
|
|
return createCancelablePromise(token => timeout(millis, token));
|
||
|
|
}
|
||
|
|
return new Promise((resolve, reject) => {
|
||
|
|
const handle = setTimeout(() => {
|
||
|
|
disposable.dispose();
|
||
|
|
resolve();
|
||
|
|
}, millis);
|
||
|
|
const disposable = token.onCancellationRequested(() => {
|
||
|
|
clearTimeout(handle);
|
||
|
|
disposable.dispose();
|
||
|
|
reject(new CancellationError());
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
export function disposableTimeout(handler, timeout = 0) {
|
||
|
|
const timer = setTimeout(handler, timeout);
|
||
|
|
return toDisposable(() => clearTimeout(timer));
|
||
|
|
}
|
||
|
|
export function first(promiseFactories, shouldStop = t => !!t, defaultValue = null) {
|
||
|
|
let index = 0;
|
||
|
|
const len = promiseFactories.length;
|
||
|
|
const loop = () => {
|
||
|
|
if (index >= len) {
|
||
|
|
return Promise.resolve(defaultValue);
|
||
|
|
}
|
||
|
|
const factory = promiseFactories[index++];
|
||
|
|
const promise = Promise.resolve(factory());
|
||
|
|
return promise.then(result => {
|
||
|
|
if (shouldStop(result)) {
|
||
|
|
return Promise.resolve(result);
|
||
|
|
}
|
||
|
|
return loop();
|
||
|
|
});
|
||
|
|
};
|
||
|
|
return loop();
|
||
|
|
}
|
||
|
|
export class TimeoutTimer {
|
||
|
|
constructor(runner, timeout) {
|
||
|
|
this._token = -1;
|
||
|
|
if (typeof runner === 'function' && typeof timeout === 'number') {
|
||
|
|
this.setIfNotSet(runner, timeout);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
dispose() {
|
||
|
|
this.cancel();
|
||
|
|
}
|
||
|
|
cancel() {
|
||
|
|
if (this._token !== -1) {
|
||
|
|
clearTimeout(this._token);
|
||
|
|
this._token = -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cancelAndSet(runner, timeout) {
|
||
|
|
this.cancel();
|
||
|
|
this._token = setTimeout(() => {
|
||
|
|
this._token = -1;
|
||
|
|
runner();
|
||
|
|
}, timeout);
|
||
|
|
}
|
||
|
|
setIfNotSet(runner, timeout) {
|
||
|
|
if (this._token !== -1) {
|
||
|
|
// timer is already set
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
this._token = setTimeout(() => {
|
||
|
|
this._token = -1;
|
||
|
|
runner();
|
||
|
|
}, timeout);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
export class IntervalTimer {
|
||
|
|
constructor() {
|
||
|
|
this._token = -1;
|
||
|
|
}
|
||
|
|
dispose() {
|
||
|
|
this.cancel();
|
||
|
|
}
|
||
|
|
cancel() {
|
||
|
|
if (this._token !== -1) {
|
||
|
|
clearInterval(this._token);
|
||
|
|
this._token = -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
cancelAndSet(runner, interval) {
|
||
|
|
this.cancel();
|
||
|
|
this._token = setInterval(() => {
|
||
|
|
runner();
|
||
|
|
}, interval);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
export class RunOnceScheduler {
|
||
|
|
constructor(runner, delay) {
|
||
|
|
this.timeoutToken = -1;
|
||
|
|
this.runner = runner;
|
||
|
|
this.timeout = delay;
|
||
|
|
this.timeoutHandler = this.onTimeout.bind(this);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Dispose RunOnceScheduler
|
||
|
|
*/
|
||
|
|
dispose() {
|
||
|
|
this.cancel();
|
||
|
|
this.runner = null;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Cancel current scheduled runner (if any).
|
||
|
|
*/
|
||
|
|
cancel() {
|
||
|
|
if (this.isScheduled()) {
|
||
|
|
clearTimeout(this.timeoutToken);
|
||
|
|
this.timeoutToken = -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Cancel previous runner (if any) & schedule a new runner.
|
||
|
|
*/
|
||
|
|
schedule(delay = this.timeout) {
|
||
|
|
this.cancel();
|
||
|
|
this.timeoutToken = setTimeout(this.timeoutHandler, delay);
|
||
|
|
}
|
||
|
|
get delay() {
|
||
|
|
return this.timeout;
|
||
|
|
}
|
||
|
|
set delay(value) {
|
||
|
|
this.timeout = value;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Returns true if scheduled.
|
||
|
|
*/
|
||
|
|
isScheduled() {
|
||
|
|
return this.timeoutToken !== -1;
|
||
|
|
}
|
||
|
|
onTimeout() {
|
||
|
|
this.timeoutToken = -1;
|
||
|
|
if (this.runner) {
|
||
|
|
this.doRun();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
doRun() {
|
||
|
|
var _a;
|
||
|
|
(_a = this.runner) === null || _a === void 0 ? void 0 : _a.call(this);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Execute the callback the next time the browser is idle, returning an
|
||
|
|
* {@link IDisposable} that will cancel the callback when disposed. This wraps
|
||
|
|
* [requestIdleCallback] so it will fallback to [setTimeout] if the environment
|
||
|
|
* doesn't support it.
|
||
|
|
*
|
||
|
|
* @param callback The callback to run when idle, this includes an
|
||
|
|
* [IdleDeadline] that provides the time alloted for the idle callback by the
|
||
|
|
* browser. Not respecting this deadline will result in a degraded user
|
||
|
|
* experience.
|
||
|
|
* @param timeout A timeout at which point to queue no longer wait for an idle
|
||
|
|
* callback but queue it on the regular event loop (like setTimeout). Typically
|
||
|
|
* this should not be used.
|
||
|
|
*
|
||
|
|
* [IdleDeadline]: https://developer.mozilla.org/en-US/docs/Web/API/IdleDeadline
|
||
|
|
* [requestIdleCallback]: https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback
|
||
|
|
* [setTimeout]: https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout
|
||
|
|
*/
|
||
|
|
export let runWhenIdle;
|
||
|
|
(function () {
|
||
|
|
if (typeof requestIdleCallback !== 'function' || typeof cancelIdleCallback !== 'function') {
|
||
|
|
runWhenIdle = (runner) => {
|
||
|
|
setTimeout0(() => {
|
||
|
|
if (disposed) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const end = Date.now() + 15; // one frame at 64fps
|
||
|
|
runner(Object.freeze({
|
||
|
|
didTimeout: true,
|
||
|
|
timeRemaining() {
|
||
|
|
return Math.max(0, end - Date.now());
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
});
|
||
|
|
let disposed = false;
|
||
|
|
return {
|
||
|
|
dispose() {
|
||
|
|
if (disposed) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
disposed = true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
runWhenIdle = (runner, timeout) => {
|
||
|
|
const handle = requestIdleCallback(runner, typeof timeout === 'number' ? { timeout } : undefined);
|
||
|
|
let disposed = false;
|
||
|
|
return {
|
||
|
|
dispose() {
|
||
|
|
if (disposed) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
disposed = true;
|
||
|
|
cancelIdleCallback(handle);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
})();
|
||
|
|
/**
|
||
|
|
* An implementation of the "idle-until-urgent"-strategy as introduced
|
||
|
|
* here: https://philipwalton.com/articles/idle-until-urgent/
|
||
|
|
*/
|
||
|
|
export class IdleValue {
|
||
|
|
constructor(executor) {
|
||
|
|
this._didRun = false;
|
||
|
|
this._executor = () => {
|
||
|
|
try {
|
||
|
|
this._value = executor();
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
this._error = err;
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
this._didRun = true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
this._handle = runWhenIdle(() => this._executor());
|
||
|
|
}
|
||
|
|
dispose() {
|
||
|
|
this._handle.dispose();
|
||
|
|
}
|
||
|
|
get value() {
|
||
|
|
if (!this._didRun) {
|
||
|
|
this._handle.dispose();
|
||
|
|
this._executor();
|
||
|
|
}
|
||
|
|
if (this._error) {
|
||
|
|
throw this._error;
|
||
|
|
}
|
||
|
|
return this._value;
|
||
|
|
}
|
||
|
|
get isInitialized() {
|
||
|
|
return this._didRun;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Creates a promise whose resolution or rejection can be controlled imperatively.
|
||
|
|
*/
|
||
|
|
export class DeferredPromise {
|
||
|
|
get isRejected() {
|
||
|
|
var _a;
|
||
|
|
return ((_a = this.outcome) === null || _a === void 0 ? void 0 : _a.outcome) === 1 /* DeferredOutcome.Rejected */;
|
||
|
|
}
|
||
|
|
get isSettled() {
|
||
|
|
return !!this.outcome;
|
||
|
|
}
|
||
|
|
constructor() {
|
||
|
|
this.p = new Promise((c, e) => {
|
||
|
|
this.completeCallback = c;
|
||
|
|
this.errorCallback = e;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
complete(value) {
|
||
|
|
return new Promise(resolve => {
|
||
|
|
this.completeCallback(value);
|
||
|
|
this.outcome = { outcome: 0 /* DeferredOutcome.Resolved */, value };
|
||
|
|
resolve();
|
||
|
|
});
|
||
|
|
}
|
||
|
|
error(err) {
|
||
|
|
return new Promise(resolve => {
|
||
|
|
this.errorCallback(err);
|
||
|
|
this.outcome = { outcome: 1 /* DeferredOutcome.Rejected */, value: err };
|
||
|
|
resolve();
|
||
|
|
});
|
||
|
|
}
|
||
|
|
cancel() {
|
||
|
|
return this.error(new CancellationError());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//#endregion
|
||
|
|
//#region Promises
|
||
|
|
export var Promises;
|
||
|
|
(function (Promises) {
|
||
|
|
/**
|
||
|
|
* A drop-in replacement for `Promise.all` with the only difference
|
||
|
|
* that the method awaits every promise to either fulfill or reject.
|
||
|
|
*
|
||
|
|
* Similar to `Promise.all`, only the first error will be returned
|
||
|
|
* if any.
|
||
|
|
*/
|
||
|
|
function settled(promises) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
let firstError = undefined;
|
||
|
|
const result = yield Promise.all(promises.map(promise => promise.then(value => value, error => {
|
||
|
|
if (!firstError) {
|
||
|
|
firstError = error;
|
||
|
|
}
|
||
|
|
return undefined; // do not rethrow so that other promises can settle
|
||
|
|
})));
|
||
|
|
if (typeof firstError !== 'undefined') {
|
||
|
|
throw firstError;
|
||
|
|
}
|
||
|
|
return result; // cast is needed and protected by the `throw` above
|
||
|
|
});
|
||
|
|
}
|
||
|
|
Promises.settled = settled;
|
||
|
|
/**
|
||
|
|
* A helper to create a new `Promise<T>` with a body that is a promise
|
||
|
|
* itself. By default, an error that raises from the async body will
|
||
|
|
* end up as a unhandled rejection, so this utility properly awaits the
|
||
|
|
* body and rejects the promise as a normal promise does without async
|
||
|
|
* body.
|
||
|
|
*
|
||
|
|
* This method should only be used in rare cases where otherwise `async`
|
||
|
|
* cannot be used (e.g. when callbacks are involved that require this).
|
||
|
|
*/
|
||
|
|
function withAsyncBody(bodyFn) {
|
||
|
|
// eslint-disable-next-line no-async-promise-executor
|
||
|
|
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
try {
|
||
|
|
yield bodyFn(resolve, reject);
|
||
|
|
}
|
||
|
|
catch (error) {
|
||
|
|
reject(error);
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
Promises.withAsyncBody = withAsyncBody;
|
||
|
|
})(Promises || (Promises = {}));
|
||
|
|
/**
|
||
|
|
* A rich implementation for an `AsyncIterable<T>`.
|
||
|
|
*/
|
||
|
|
export class AsyncIterableObject {
|
||
|
|
static fromArray(items) {
|
||
|
|
return new AsyncIterableObject((writer) => {
|
||
|
|
writer.emitMany(items);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
static fromPromise(promise) {
|
||
|
|
return new AsyncIterableObject((emitter) => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
emitter.emitMany(yield promise);
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
static fromPromises(promises) {
|
||
|
|
return new AsyncIterableObject((emitter) => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
yield Promise.all(promises.map((p) => __awaiter(this, void 0, void 0, function* () { return emitter.emitOne(yield p); })));
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
static merge(iterables) {
|
||
|
|
return new AsyncIterableObject((emitter) => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
yield Promise.all(iterables.map((iterable) => { var _a, iterable_1, iterable_1_1; return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
var _b, e_1, _c, _d;
|
||
|
|
try {
|
||
|
|
for (_a = true, iterable_1 = __asyncValues(iterable); iterable_1_1 = yield iterable_1.next(), _b = iterable_1_1.done, !_b; _a = true) {
|
||
|
|
_d = iterable_1_1.value;
|
||
|
|
_a = false;
|
||
|
|
const item = _d;
|
||
|
|
emitter.emitOne(item);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (!_a && !_b && (_c = iterable_1.return)) yield _c.call(iterable_1);
|
||
|
|
}
|
||
|
|
finally { if (e_1) throw e_1.error; }
|
||
|
|
}
|
||
|
|
}); }));
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
constructor(executor) {
|
||
|
|
this._state = 0 /* AsyncIterableSourceState.Initial */;
|
||
|
|
this._results = [];
|
||
|
|
this._error = null;
|
||
|
|
this._onStateChanged = new Emitter();
|
||
|
|
queueMicrotask(() => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
const writer = {
|
||
|
|
emitOne: (item) => this.emitOne(item),
|
||
|
|
emitMany: (items) => this.emitMany(items),
|
||
|
|
reject: (error) => this.reject(error)
|
||
|
|
};
|
||
|
|
try {
|
||
|
|
yield Promise.resolve(executor(writer));
|
||
|
|
this.resolve();
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
this.reject(err);
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
writer.emitOne = undefined;
|
||
|
|
writer.emitMany = undefined;
|
||
|
|
writer.reject = undefined;
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
[Symbol.asyncIterator]() {
|
||
|
|
let i = 0;
|
||
|
|
return {
|
||
|
|
next: () => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
do {
|
||
|
|
if (this._state === 2 /* AsyncIterableSourceState.DoneError */) {
|
||
|
|
throw this._error;
|
||
|
|
}
|
||
|
|
if (i < this._results.length) {
|
||
|
|
return { done: false, value: this._results[i++] };
|
||
|
|
}
|
||
|
|
if (this._state === 1 /* AsyncIterableSourceState.DoneOK */) {
|
||
|
|
return { done: true, value: undefined };
|
||
|
|
}
|
||
|
|
yield Event.toPromise(this._onStateChanged.event);
|
||
|
|
} while (true);
|
||
|
|
})
|
||
|
|
};
|
||
|
|
}
|
||
|
|
static map(iterable, mapFn) {
|
||
|
|
return new AsyncIterableObject((emitter) => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
var _a, e_2, _b, _c;
|
||
|
|
try {
|
||
|
|
for (var _d = true, iterable_2 = __asyncValues(iterable), iterable_2_1; iterable_2_1 = yield iterable_2.next(), _a = iterable_2_1.done, !_a; _d = true) {
|
||
|
|
_c = iterable_2_1.value;
|
||
|
|
_d = false;
|
||
|
|
const item = _c;
|
||
|
|
emitter.emitOne(mapFn(item));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (!_d && !_a && (_b = iterable_2.return)) yield _b.call(iterable_2);
|
||
|
|
}
|
||
|
|
finally { if (e_2) throw e_2.error; }
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
map(mapFn) {
|
||
|
|
return AsyncIterableObject.map(this, mapFn);
|
||
|
|
}
|
||
|
|
static filter(iterable, filterFn) {
|
||
|
|
return new AsyncIterableObject((emitter) => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
var _a, e_3, _b, _c;
|
||
|
|
try {
|
||
|
|
for (var _d = true, iterable_3 = __asyncValues(iterable), iterable_3_1; iterable_3_1 = yield iterable_3.next(), _a = iterable_3_1.done, !_a; _d = true) {
|
||
|
|
_c = iterable_3_1.value;
|
||
|
|
_d = false;
|
||
|
|
const item = _c;
|
||
|
|
if (filterFn(item)) {
|
||
|
|
emitter.emitOne(item);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (!_d && !_a && (_b = iterable_3.return)) yield _b.call(iterable_3);
|
||
|
|
}
|
||
|
|
finally { if (e_3) throw e_3.error; }
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
filter(filterFn) {
|
||
|
|
return AsyncIterableObject.filter(this, filterFn);
|
||
|
|
}
|
||
|
|
static coalesce(iterable) {
|
||
|
|
return AsyncIterableObject.filter(iterable, item => !!item);
|
||
|
|
}
|
||
|
|
coalesce() {
|
||
|
|
return AsyncIterableObject.coalesce(this);
|
||
|
|
}
|
||
|
|
static toPromise(iterable) {
|
||
|
|
var _a, iterable_4, iterable_4_1;
|
||
|
|
var _b, e_4, _c, _d;
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
const result = [];
|
||
|
|
try {
|
||
|
|
for (_a = true, iterable_4 = __asyncValues(iterable); iterable_4_1 = yield iterable_4.next(), _b = iterable_4_1.done, !_b; _a = true) {
|
||
|
|
_d = iterable_4_1.value;
|
||
|
|
_a = false;
|
||
|
|
const item = _d;
|
||
|
|
result.push(item);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (!_a && !_b && (_c = iterable_4.return)) yield _c.call(iterable_4);
|
||
|
|
}
|
||
|
|
finally { if (e_4) throw e_4.error; }
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
toPromise() {
|
||
|
|
return AsyncIterableObject.toPromise(this);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The value will be appended at the end.
|
||
|
|
*
|
||
|
|
* **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
|
||
|
|
*/
|
||
|
|
emitOne(value) {
|
||
|
|
if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// it is important to add new values at the end,
|
||
|
|
// as we may have iterators already running on the array
|
||
|
|
this._results.push(value);
|
||
|
|
this._onStateChanged.fire();
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The values will be appended at the end.
|
||
|
|
*
|
||
|
|
* **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
|
||
|
|
*/
|
||
|
|
emitMany(values) {
|
||
|
|
if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// it is important to add new values at the end,
|
||
|
|
// as we may have iterators already running on the array
|
||
|
|
this._results = this._results.concat(values);
|
||
|
|
this._onStateChanged.fire();
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Calling `resolve()` will mark the result array as complete.
|
||
|
|
*
|
||
|
|
* **NOTE** `resolve()` must be called, otherwise all consumers of this iterable will hang indefinitely, similar to a non-resolved promise.
|
||
|
|
* **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
|
||
|
|
*/
|
||
|
|
resolve() {
|
||
|
|
if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
this._state = 1 /* AsyncIterableSourceState.DoneOK */;
|
||
|
|
this._onStateChanged.fire();
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Writing an error will permanently invalidate this iterable.
|
||
|
|
* The current users will receive an error thrown, as will all future users.
|
||
|
|
*
|
||
|
|
* **NOTE** If `resolve()` or `reject()` have already been called, this method has no effect.
|
||
|
|
*/
|
||
|
|
reject(error) {
|
||
|
|
if (this._state !== 0 /* AsyncIterableSourceState.Initial */) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
this._state = 2 /* AsyncIterableSourceState.DoneError */;
|
||
|
|
this._error = error;
|
||
|
|
this._onStateChanged.fire();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
AsyncIterableObject.EMPTY = AsyncIterableObject.fromArray([]);
|
||
|
|
export class CancelableAsyncIterableObject extends AsyncIterableObject {
|
||
|
|
constructor(_source, executor) {
|
||
|
|
super(executor);
|
||
|
|
this._source = _source;
|
||
|
|
}
|
||
|
|
cancel() {
|
||
|
|
this._source.cancel();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
export function createCancelableAsyncIterable(callback) {
|
||
|
|
const source = new CancellationTokenSource();
|
||
|
|
const innerIterable = callback(source.token);
|
||
|
|
return new CancelableAsyncIterableObject(source, (emitter) => __awaiter(this, void 0, void 0, function* () {
|
||
|
|
var _a, e_5, _b, _c;
|
||
|
|
const subscription = source.token.onCancellationRequested(() => {
|
||
|
|
subscription.dispose();
|
||
|
|
source.dispose();
|
||
|
|
emitter.reject(new CancellationError());
|
||
|
|
});
|
||
|
|
try {
|
||
|
|
try {
|
||
|
|
for (var _d = true, innerIterable_1 = __asyncValues(innerIterable), innerIterable_1_1; innerIterable_1_1 = yield innerIterable_1.next(), _a = innerIterable_1_1.done, !_a; _d = true) {
|
||
|
|
_c = innerIterable_1_1.value;
|
||
|
|
_d = false;
|
||
|
|
const item = _c;
|
||
|
|
if (source.token.isCancellationRequested) {
|
||
|
|
// canceled in the meantime
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
emitter.emitOne(item);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
||
|
|
finally {
|
||
|
|
try {
|
||
|
|
if (!_d && !_a && (_b = innerIterable_1.return)) yield _b.call(innerIterable_1);
|
||
|
|
}
|
||
|
|
finally { if (e_5) throw e_5.error; }
|
||
|
|
}
|
||
|
|
subscription.dispose();
|
||
|
|
source.dispose();
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
subscription.dispose();
|
||
|
|
source.dispose();
|
||
|
|
emitter.reject(err);
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
//#endregion
|