Copilot instructions

1---
2description: Guidelines for writing code using observables and deriveds.
3---
4 
5```ts
6class MyService extends Disposable {
7    private _myData1 = observableValue(/* always put `this` here */ this, /* initial value*/ 0);
8    private _myData2 = observableValue(/* always put `this` here */ this, /* initial value*/ 42);
9 
10    // Deriveds can combine/derive from other observables/deriveds
11    private _myDerivedData = derived(this, reader => {
12		// Use observable.read(reader) to access the value and track the dependency.
13        return this._myData1.read(reader) * this._myData2.read(reader);
14	});
15 
16	private _myDerivedDataWithLifetime = derived(this, reader => {
17		// The reader.store will get cleared just before the derived is re-evaluated or gets unsubscribed.
18		return reader.store.add(new SomeDisposable(this._myDerivedData.read(reader)));
19	});
20 
21    constructor() {
22        this._register(autorun((reader) => { // like mobx autorun, they run immediately and on change
23            const data = this._myData1.read(reader); // but you only get the data if you pass in the reader!
24 
25            console.log(data);
26 
27			// also has reader.store
28        }))
29    }
30 
31    getData(): number {
32        return this._myData1.get(); // use get if you don't have a reader, but try to avoid it since the dependency is not tracked.
33    }
34 
35	setData1() {
36		this._myData1.set(42, undefined); // use set to update the value. The second paramater is the transaction, which is undefined here.
37	}
38 
39	setData2() {
40		transaction(tx => {
41			// you can use transaction to batch updates, so they are only notified once.
42			// Whenever multiple observables are synchronously updated together, use transaction!
43			this._myData1.set(42, tx);
44			this._myData2.set(43, tx);
45		});
46	}
47}
48```
49 
50 
51Most important symbols:
52* `observableValue`
53* `disposableObservableValue`
54* `derived`
55* `autorun`
56* `transaction`
57* `observableFromEvent`
58* `observableSignalFromEvent`
59* `observableSignal(...): IObservable<void>` - use `.trigger(tx)` to trigger a change
60 
61 
62* Check src\vs\base\common\observableInternal\index.ts for a list of all observable utitilies
63 
64 
65* Important learnings:
66	* [1] Avoid glitches
67	* [2] **Choose the right observable value type:**
68		* Use `observableValue(owner, initialValue)` for regular values
69		* Use `disposableObservableValue(owner, initialValue)` when storing disposable values - it automatically disposes the previous value when a new one is set, and disposes the current value when the observable itself is disposed (similar to `MutableDisposable` behavior)
70	* [3] **Choose the right event observable pattern:**
71		* Use `observableFromEvent(owner, event, valueComputer)` when you need to track a computed value that changes with the event, and you want updates only when the computed value actually changes
72		* Use `observableSignalFromEvent(owner, event)` when you need to force re-computation every time the event fires, regardless of value stability. This is important when the computed value might not change but dependent computations need fresh context (e.g., workspace folder changes where the folder array reference might be the same but file path calculations need to be refreshed)
73