ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 18:46:40 -05:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Merge from vscode merge-base (#22769)" (#22779)

Browse Source 
This reverts commit 6bd0a17d3c.
This commit is contained in:
Karl Burtram
2023-04-18 21:44:05 -07:00
committed by GitHub
parent 6bd0a17d3c
commit 47a1745180
2389 changed files with 42588 additions and 92170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
src/vs/base/common/event.ts
View File

@@ -8,14 +8,13 @@ import { onUnexpectedError } from 'vs/base/common/errors';
import { once as onceFn } from 'vs/base/common/functional';
import { combinedDisposable, Disposable, DisposableStore, IDisposable, SafeDisposable, toDisposable } from 'vs/base/common/lifecycle';
import { LinkedList } from 'vs/base/common/linkedList';
import { IObservable, IObserver } from 'vs/base/common/observable';
import { StopWatch } from 'vs/base/common/stopwatch';
// -----------------------------------------------------------------------------------------------------------------------
// Uncomment the next line to print warnings whenever an emitter with listeners is disposed. That is a sign of code smell.
// -----------------------------------------------------------------------------------------------------------------------
const _enableDisposeWithListenerWarning = false;
let _enableDisposeWithListenerWarning = false;
// _enableDisposeWithListenerWarning = Boolean("TRUE"); // causes a linter warning so that it cannot be pushed
@@ -23,7 +22,7 @@ const _enableDisposeWithListenerWarning = false;
// Uncomment the next line to print warnings whenever a snapshotted event is used repeatedly without cleanup.
// See https://github.com/microsoft/vscode/issues/142851
// -----------------------------------------------------------------------------------------------------------------------
const _enableSnapshotPotentialLeakWarning = false;
let _enableSnapshotPotentialLeakWarning = false;
// _enableSnapshotPotentialLeakWarning = Boolean("TRUE"); // causes a linter warning so that it cannot be pushed
/**
@@ -61,7 +60,7 @@ export namespace Event {
return (listener, thisArgs = null, disposables?) => {
// we need this, in case the event fires during the listener call
let didFire = false;
let result: IDisposable | undefined = undefined;
let result: IDisposable;
result = event(e => {
if (didFire) {
return;
@@ -144,14 +143,14 @@ export namespace Event {
}
function snapshot<T>(event: Event<T>, disposable: DisposableStore | undefined): Event<T> {
let listener: IDisposable | undefined;
let listener: IDisposable;
const options: EmitterOptions | undefined = {
onFirstListenerAdd() {
listener = event(emitter.fire, emitter);
},
onLastListenerRemove() {
listener?.dispose();
listener.dispose();
}
};
@@ -161,7 +160,9 @@ export namespace Event {
const emitter = new Emitter<T>(options);
disposable?.add(emitter);
if (disposable) {
disposable.add(emitter);
}
return emitter.event;
}
@@ -222,7 +223,9 @@ export namespace Event {
const emitter = new Emitter<O>(options);
disposable?.add(emitter);
if (disposable) {
disposable.add(emitter);
}
return emitter.event;
}
@@ -273,7 +276,9 @@ export namespace Event {
});
const flush = () => {
buffer?.forEach(e => emitter.fire(e));
if (buffer) {
buffer.forEach(e => emitter.fire(e));
}
buffer = null;
};
@@ -305,7 +310,7 @@ export namespace Event {
return emitter.event;
}
export interface IChainableEvent<T> extends IDisposable {
export interface IChainableEvent<T> {
event: Event<T>;
map<O>(fn: (i: T) => O): IChainableEvent<O>;
@@ -322,36 +327,34 @@ export namespace Event {
class ChainableEvent<T> implements IChainableEvent<T> {
private readonly disposables = new DisposableStore();
constructor(readonly event: Event<T>) { }
map<O>(fn: (i: T) => O): IChainableEvent<O> {
return new ChainableEvent(map(this.event, fn, this.disposables));
return new ChainableEvent(map(this.event, fn));
}
forEach(fn: (i: T) => void): IChainableEvent<T> {
return new ChainableEvent(forEach(this.event, fn, this.disposables));
return new ChainableEvent(forEach(this.event, fn));
}
filter(fn: (e: T) => boolean): IChainableEvent<T>;
filter<R>(fn: (e: T | R) => e is R): IChainableEvent<R>;
filter(fn: (e: T) => boolean): IChainableEvent<T> {
return new ChainableEvent(filter(this.event, fn, this.disposables));
return new ChainableEvent(filter(this.event, fn));
}
reduce<R>(merge: (last: R | undefined, event: T) => R, initial?: R): IChainableEvent<R> {
return new ChainableEvent(reduce(this.event, merge, initial, this.disposables));
return new ChainableEvent(reduce(this.event, merge, initial));
}
latch(): IChainableEvent<T> {
return new ChainableEvent(latch(this.event, undefined, this.disposables));
return new ChainableEvent(latch(this.event));
}
debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
debounce<R>(merge: (last: R | undefined, event: T) => R, delay: number = 100, leading = false, leakWarningThreshold?: number): IChainableEvent<R> {
return new ChainableEvent(debounce(this.event, merge, delay, leading, leakWarningThreshold, this.disposables));
return new ChainableEvent(debounce(this.event, merge, delay, leading, leakWarningThreshold));
}
on(listener: (e: T) => any, thisArgs: any, disposables: IDisposable[] | DisposableStore) {
@@ -361,12 +364,11 @@ export namespace Event {
once(listener: (e: T) => any, thisArgs: any, disposables: IDisposable[]) {
return once(this.event)(listener, thisArgs, disposables);
}
dispose() {
this.disposables.dispose();
}
}
/**
* @deprecated DO NOT use, this leaks memory
*/
export function chain<T>(event: Event<T>): IChainableEvent<T> {
return new ChainableEvent(event);
}
@@ -424,55 +426,6 @@ export namespace Event {
store?.dispose();
});
}
class EmitterObserver<T> implements IObserver {
readonly emitter: Emitter<T>;
private _counter = 0;
private _hasChanged = false;
constructor(readonly obs: IObservable<T, any>, store: DisposableStore | undefined) {
const options = {
onFirstListenerAdd: () => {
obs.addObserver(this);
},
onLastListenerRemove: () => {
obs.removeObserver(this);
}
};
if (!store) {
_addLeakageTraceLogic(options);
}
this.emitter = new Emitter<T>(options);
if (store) {
store.add(this.emitter);
}
}
beginUpdate<T>(_observable: IObservable<T, void>): void {
// console.assert(_observable === this.obs);
this._counter++;
}
handleChange<T, TChange>(_observable: IObservable<T, TChange>, _change: TChange): void {
this._hasChanged = true;
}
endUpdate<T>(_observable: IObservable<T, void>): void {
if (--this._counter === 0) {
if (this._hasChanged) {
this._hasChanged = false;
this.emitter.fire(this.obs.get());
}
}
}
}
export function fromObservable<T>(obs: IObservable<T, any>, store?: DisposableStore): Event<T> {
const observer = new EmitterObserver(obs, store);
return observer.emitter.event;
}
}
export interface EmitterOptions {
@@ -737,7 +690,9 @@ export class Emitter<T> {
}
const result = listener.subscription.set(() => {
removeMonitor?.();
if (removeMonitor) {
removeMonitor();
}
if (!this._disposed) {
removeListener();
if (this._options && this._options.onLastListenerRemove) {
@@ -775,7 +730,7 @@ export class Emitter<T> {
this._deliveryQueue = new PrivateEventDeliveryQueue();
}
for (const listener of this._listeners) {
for (let listener of this._listeners) {
this._deliveryQueue.push(this, listener, event);
}