src/vs/base/common/observableInternal/observables/baseObservable.ts
193 LOC · 153 covered · 40 uncovered · 31 ranges · 6771 concepts · 12 introducers · 3467 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
devToolsLogger.ts ×24
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { IObservableWithChange, IObserver, IReader, IObservable } from '../base.js';
7
>
import { DisposableStore } from '../commonFacade/deps.js';
8
>
import { DebugLocation } from '../debugLocation.js';
9
>
import { DebugOwner, getFunctionName } from '../debugName.js';
10
>
import { debugGetObservableGraph } from '../logging/debugGetDependencyGraph.js';
11
>
import { getLogger, logObservable } from '../logging/logging.js';
12
>
import type { keepObserved, recomputeInitiallyAndOnChange } from '../utils/utils.js';
13
>
import { derivedOpts } from './derived.js';
14
>
15
>
let _derived: typeof derivedOpts;
16
>
/**
17
>
* @internal
18
>
* This is to allow splitting files.
19
>
*/
20
>
export function _setDerivedOpts(derived: typeof _derived) {
21
>
_derived = derived;
22
>
}
23
>
24
>
let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;
25
>
export function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange) {
26
>
_recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
27
>
}
28
>
29
>
let _keepObserved: typeof keepObserved;
30
>
export function _setKeepObserved(keepObserved: typeof _keepObserved) {
31
>
_keepObserved = keepObserved;
32
>
}
33
>
34
>
let _debugGetObservableGraph: typeof debugGetObservableGraph;
35
>
export function _setDebugGetObservableGraph(debugGetObservableGraph: typeof _debugGetObservableGraph) {
36
>
_debugGetObservableGraph = debugGetObservableGraph;
37
>
}
38
>
39
>
export abstract class ConvenientObservable<T, TChange> implements IObservableWithChange<T, TChange> {
40
>
get TChange(): TChange { return null!; }
41
>
42
>
public abstract get(): T;
43
>
44
>
public reportChanges(): void {
46
>
}
48
>
public abstract addObserver(observer: IObserver): void;
49
>
public abstract removeObserver(observer: IObserver): void;
50
>
51
>
/** @sealed */
52
>
public read(reader: IReader | undefined): T {
57
>
}
60
>
/** @sealed */
61
>
public map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
62
>
public map<TNew>(owner: DebugOwner, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
63
>
public map<TNew>(fnOrOwner: DebugOwner | ((value: T, reader: IReader) => TNew), fnOrUndefined?: (value: T, reader: IReader) => TNew, debugLocation: DebugLocation = DebugLocation.ofCaller()): IObservable<TNew> {
64
>
const owner = fnOrUndefined === undefined ? undefined : fnOrOwner as DebugOwner;
baseObservable.ts ×2
65
>
const fn = fnOrUndefined === undefined ? fnOrOwner as (value: T, reader: IReader) => TNew : fnOrUndefined;
66
>
67
>
return _derived(
68
>
{
69
>
owner,
70
>
debugName: () => {
71
const name = getFunctionName(fn);
72
if (name !== undefined) {
73
return name;
74
}
75
76
// regexp to match `x => x.y` or `x => x?.y` where x and y can be arbitrary identifiers (uses backref):
77
const regexp = /^\s*\(?\s*([a-zA-Z_$][a-zA-Z_$0-9]*)\s*\)?\s*=>\s*\1(?:\??)\.([a-zA-Z_$][a-zA-Z_$0-9]*)\s*$/;
78
const match = regexp.exec(fn.toString());
79
if (match) {
80
return `${this.debugName}.${match[2]}`;
81
}
82
if (!owner) {
83
return `${this.debugName} (mapped)`;
84
}
85
return undefined;
86
},
88
>
},
89
>
(reader) => fn(this.read(reader), reader),
90
>
debugLocation,
91
>
);
92
>
}
94
>
public abstract log(): IObservableWithChange<T, TChange>;
95
>
96
>
/**
97
>
* @sealed
98
>
* Converts an observable of an observable value into a direct observable of the value.
99
>
*/
100
>
public flatten<TNew>(this: IObservable<IObservableWithChange<TNew, any>>): IObservable<TNew> {
101
return _derived(
102
{
103
owner: undefined,
104
debugName: () => `${this.debugName} (flattened)`,
105
},
106
(reader) => this.read(reader).read(reader)
107
);
108
}
110
>
public recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T> {
112
>
return this;
113
>
}
115
>
/**
116
>
* Ensures that this observable is observed. This keeps the cache alive.
117
>
* However, in case of deriveds, it does not force eager evaluation (only when the value is read/get).
118
>
* Use `recomputeInitiallyAndOnChange` for eager evaluation.
119
>
*/
120
>
public keepObserved(store: DisposableStore): IObservable<T> {
122
>
return this;
123
>
}
125
>
public abstract get debugName(): string;
126
>
127
>
protected get debugValue() {
128
return this.get();
129
}
131
>
get debug(): DebugHelper {
132
return new DebugHelper(this);
133
}
135
>
136
>
class DebugHelper {
137
>
constructor(public readonly observable: IObservableWithChange<any, any>) {
138
}
140
>
getDependencyGraph(): string {
141
return _debugGetObservableGraph(this.observable, { type: 'dependencies' });
142
}
144
>
getObserverGraph(): string {
145
return _debugGetObservableGraph(this.observable, { type: 'observers' });
146
}
148
>
149
>
export abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
150
>
protected readonly _observers = new Set<IObserver>();
151
>
152
>
constructor(debugLocation: DebugLocation) {
154
>
getLogger()?.handleObservableCreated(this, debugLocation);
155
>
}
157
>
public addObserver(observer: IObserver): void {
159
>
this._observers.add(observer);
160
>
if (len === 0) {
161
>
this.onFirstObserverAdded();
162
>
}
163
>
if (len !== this._observers.size) {
164
>
getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
165
>
}
166
>
}
168
>
public removeObserver(observer: IObserver): void {
170
>
if (deleted && this._observers.size === 0) {
171
>
this.onLastObserverRemoved();
172
>
}
173
>
if (deleted) {
174
>
getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
175
>
}
176
>
}
178
>
protected onFirstObserverAdded(): void { }
179
>
protected onLastObserverRemoved(): void { }
180
>
181
>
public override log(): IObservableWithChange<T, TChange> {
182
const hadLogger = !!getLogger();
183
logObservable(this);
184
if (!hadLogger) {
185
getLogger()?.handleObservableCreated(this, DebugLocation.ofCaller());
186
}
187
return this;
188
}
190
>
public debugGetObservers() {
192
>
}