@codingame/monaco-vscode-api 16.1.1 → 17.1.0

package/vscode/src/vs/base/common/async.js

@@ -2,7 +2,7 @@
 import { CancellationTokenSource } from './cancellation.js';
 import { CancellationError, BugIndicatingError } from './errors.js';
 import { Emitter, Event } from './event.js';
-import { toDisposable, DisposableMap } from './lifecycle.js';
+import { isDisposable, toDisposable, DisposableMap } from './lifecycle.js';
 import { extUri } from './resources.js';
 import { setTimeout0 } from './platform.js';
 import { MicrotaskDelay } from './symbols.js';
@@ -14,15 +14,22 @@ function isThenable(obj) {
 function createCancelablePromise(callback) {
     const source = ( new CancellationTokenSource());
     const thenable = callback(source.token);
+    let isCancelled = false;
     const promise = ( new Promise((resolve, reject) => {
         const subscription = source.token.onCancellationRequested(() => {
+            isCancelled = true;
             subscription.dispose();
             reject(( new CancellationError()));
         });
         Promise.resolve(thenable).then(value => {
             subscription.dispose();
             source.dispose();
-            resolve(value);
+            if (!isCancelled) {
+                resolve(value);
+            }
+            else if (isDisposable(value)) {
+                value.dispose();
+            }
         }, err => {
             subscription.dispose();
             source.dispose();

package/vscode/src/vs/base/common/codicons.d.ts

@@ -642,4 +642,9 @@ export declare const Codicon: {
     readonly flag: ThemeIcon;
     readonly lightbulbEmpty: ThemeIcon;
     readonly symbolMethodArrow: ThemeIcon;
+    readonly copilotUnavailable: ThemeIcon;
+    readonly repoPinned: ThemeIcon;
+    readonly keyboardTabAbove: ThemeIcon;
+    readonly keyboardTabBelow: ThemeIcon;
+    readonly gitPullRequestDone: ThemeIcon;
 };

package/vscode/src/vs/base/common/codiconsLibrary.d.ts

@@ -582,4 +582,9 @@ export declare const codiconsLibrary: {
     readonly flag: import("./themables.js").ThemeIcon;
     readonly lightbulbEmpty: import("./themables.js").ThemeIcon;
     readonly symbolMethodArrow: import("./themables.js").ThemeIcon;
+    readonly copilotUnavailable: import("./themables.js").ThemeIcon;
+    readonly repoPinned: import("./themables.js").ThemeIcon;
+    readonly keyboardTabAbove: import("./themables.js").ThemeIcon;
+    readonly keyboardTabBelow: import("./themables.js").ThemeIcon;
+    readonly gitPullRequestDone: import("./themables.js").ThemeIcon;
 };

package/vscode/src/vs/base/common/codiconsLibrary.js

@@ -585,6 +585,11 @@ const codiconsLibrary = {
     flag: register('flag', 0xec3f),
     lightbulbEmpty: register('lightbulb-empty', 0xec40),
     symbolMethodArrow: register('symbol-method-arrow', 0xec41),
+    copilotUnavailable: register('copilot-unavailable', 0xec42),
+    repoPinned: register('repo-pinned', 0xec43),
+    keyboardTabAbove: register('keyboard-tab-above', 0xec44),
+    keyboardTabBelow: register('keyboard-tab-below', 0xec45),
+    gitPullRequestDone: register('git-pull-request-done', 0xec46),
 };
 
 export { codiconsLibrary };

package/vscode/src/vs/base/common/color.d.ts

@@ -57,6 +57,7 @@ export declare class Color {
     isOpaque(): boolean;
     opposite(): Color;
     blend(c: Color): Color;
+    mix(color: Color, factor?: number): Color;
     makeOpaque(opaqueBackground: Color): Color;
     flatten(...backgrounds: Color[]): Color;
     private static _flatten;

package/vscode/src/vs/base/common/color.js

@@ -325,6 +325,16 @@ class Color {
         const b = this.rgba.b * thisA / a + rgba.b * colorA * (1 - thisA) / a;
         return ( new Color(( new RGBA(r, g, b, a))));
     }
+    mix(color, factor = 0.5) {
+        const normalize = Math.min(Math.max(factor, 0), 1);
+        const thisRGBA = this.rgba;
+        const otherRGBA = color.rgba;
+        const r = thisRGBA.r + (otherRGBA.r - thisRGBA.r) * normalize;
+        const g = thisRGBA.g + (otherRGBA.g - thisRGBA.g) * normalize;
+        const b = thisRGBA.b + (otherRGBA.b - thisRGBA.b) * normalize;
+        const a = thisRGBA.a + (otherRGBA.a - thisRGBA.a) * normalize;
+        return ( new Color(( new RGBA(r, g, b, a))));
+    }
     makeOpaque(opaqueBackground) {
         if (this.isOpaque() || opaqueBackground.rgba.a !== 1) {
             return this;

package/vscode/src/vs/base/common/comparers.d.ts

@@ -2,12 +2,12 @@ export declare function compareFileNames(one: string | null, other: string | nul
 export declare function compareFileNamesDefault(one: string | null, other: string | null): number;
 export declare function compareFileNamesUpper(one: string | null, other: string | null): number;
 export declare function compareFileNamesLower(one: string | null, other: string | null): number;
-export declare function compareFileNamesUnicode(one: string | null, other: string | null): 0 | 1 | -1;
+export declare function compareFileNamesUnicode(one: string | null, other: string | null): 1 | 0 | -1;
 export declare function compareFileExtensions(one: string | null, other: string | null): number;
 export declare function compareFileExtensionsDefault(one: string | null, other: string | null): number;
 export declare function compareFileExtensionsUpper(one: string | null, other: string | null): number;
 export declare function compareFileExtensionsLower(one: string | null, other: string | null): number;
-export declare function compareFileExtensionsUnicode(one: string | null, other: string | null): 0 | 1 | -1;
+export declare function compareFileExtensionsUnicode(one: string | null, other: string | null): 1 | 0 | -1;
 export declare function comparePaths(one: string, other: string, caseSensitive?: boolean): number;
 export declare function compareAnything(one: string, other: string, lookFor: string): number;
 export declare function compareByPrefix(one: string, other: string, lookFor: string): number;

package/vscode/src/vs/base/common/decorators.d.ts

@@ -4,4 +4,4 @@ export interface IDebounceReducer<T> {
 }
 export declare function debounce<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): MethodDecorator;
 export declare function throttle<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): MethodDecorator;
-export { cancelPreviousCalls } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/base/common/decorators/cancelPreviousCalls";
+export { cancelPreviousCalls } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/decorators/cancelPreviousCalls";

package/vscode/src/vs/base/common/glob.d.ts

@@ -17,6 +17,9 @@ export type ParsedExpression = (path: string, basename?: string, hasSibling?: (n
 interface IGlobOptions {
     trimForExclusions?: boolean;
 }
+declare const FALSE: () => boolean;
+declare const NULL: () => string | null;
+export declare const isEmptyPattern: (pattern: ParsedPattern | ParsedExpression) => pattern is (typeof FALSE | typeof NULL);
 export declare function match(pattern: string | IRelativePattern, path: string): boolean;
 export declare function match(expression: IExpression, path: string, hasSibling?: (name: string) => boolean): string;
 export declare function parse(pattern: string | IRelativePattern, options?: IGlobOptions): ParsedPattern;

package/vscode/src/vs/base/common/glob.js

@@ -164,6 +164,15 @@ const FALSE = function () {
 const NULL = function () {
     return null;
 };
+const isEmptyPattern = (pattern) => {
+    if (pattern === FALSE) {
+        return true;
+    }
+    if (pattern === NULL) {
+        return true;
+    }
+    return false;
+};
 function parsePattern(arg1, options) {
     if (!arg1) {
         return NULL;
@@ -514,4 +523,4 @@ function aggregateBasenameMatches(parsedPatterns, result) {
     return aggregatedPatterns;
 }
 
-export { GLOBSTAR, GLOB_SPLIT, getEmptyExpression, isRelativePattern, match, parse, splitGlobAware };
+export { GLOBSTAR, GLOB_SPLIT, getEmptyExpression, isEmptyPattern, isRelativePattern, match, parse, splitGlobAware };

package/vscode/src/vs/base/common/marshallingIds.d.ts

@@ -21,5 +21,6 @@ export declare enum MarshalledId {
     LanguageModelToolResult = 20,
     LanguageModelTextPart = 21,
     LanguageModelPromptTsxPart = 22,
-    LanguageModelDataPart = 23
+    LanguageModelDataPart = 23,
+    LanguageModelExtraDataPart = 24
 }

package/vscode/src/vs/base/common/marshallingIds.js

@@ -25,6 +25,7 @@ var MarshalledId;
     MarshalledId[MarshalledId["LanguageModelTextPart"] = 21] = "LanguageModelTextPart";
     MarshalledId[MarshalledId["LanguageModelPromptTsxPart"] = 22] = "LanguageModelPromptTsxPart";
     MarshalledId[MarshalledId["LanguageModelDataPart"] = 23] = "LanguageModelDataPart";
+    MarshalledId[MarshalledId["LanguageModelExtraDataPart"] = 24] = "LanguageModelExtraDataPart";
 })(MarshalledId || (MarshalledId = {}));
 
 export { MarshalledId };

package/vscode/src/vs/base/common/observableInternal/autorun.d.ts

@@ -1,15 +1,14 @@
-import { IChangeContext, IObservable, IObservableWithChange, IObserver, IReader } from "./base.js";
+import { IObservable, IObservableWithChange, IObserver, IReader } from "./base.js";
 import { DebugNameData, IDebugNameData } from "./debugName.js";
 import { DisposableStore, IDisposable } from "./commonFacade/deps.js";
+import { IChangeTracker } from "./changeTracker.js";
 export declare function autorun(fn: (reader: IReader) => void): IDisposable;
 export declare function autorunOpts(options: IDebugNameData & {}, fn: (reader: IReader) => void): IDisposable;
 export declare function autorunHandleChanges<TChangeSummary>(options: IDebugNameData & {
-    createEmptyChangeSummary?: () => TChangeSummary;
-    handleChange: (context: IChangeContext, changeSummary: TChangeSummary) => boolean;
+    changeTracker: IChangeTracker<TChangeSummary>;
 }, fn: (reader: IReader, changeSummary: TChangeSummary) => void): IDisposable;
 export declare function autorunWithStoreHandleChanges<TChangeSummary>(options: IDebugNameData & {
-    createEmptyChangeSummary?: () => TChangeSummary;
-    handleChange: (context: IChangeContext, changeSummary: TChangeSummary) => boolean;
+    changeTracker: IChangeTracker<TChangeSummary>;
 }, fn: (reader: IReader, changeSummary: TChangeSummary, store: DisposableStore) => void): IDisposable;
 export declare function autorunWithStore(fn: (reader: IReader, store: DisposableStore) => void): IDisposable;
 export declare function autorunDelta<T>(observable: IObservable<T>, handler: (args: {
@@ -28,8 +27,7 @@ export declare enum AutorunState {
 export declare class AutorunObserver<TChangeSummary = any> implements IObserver, IReader, IDisposable {
     readonly _debugNameData: DebugNameData;
     readonly _runFn: (reader: IReader, changeSummary: TChangeSummary) => void;
-    private readonly createChangeSummary;
-    private readonly _handleChange;
+    private readonly _changeTracker;
     private _state;
     private _updateCount;
     private _disposed;
@@ -38,7 +36,7 @@ export declare class AutorunObserver<TChangeSummary = any> implements IObserver,
     private _changeSummary;
     private _isRunning;
     get debugName(): string;
-    constructor(_debugNameData: DebugNameData, _runFn: (reader: IReader, changeSummary: TChangeSummary) => void, createChangeSummary: (() => TChangeSummary) | undefined, _handleChange: ((context: IChangeContext, summary: TChangeSummary) => boolean) | undefined);
+    constructor(_debugNameData: DebugNameData, _runFn: (reader: IReader, changeSummary: TChangeSummary) => void, _changeTracker: IChangeTracker<TChangeSummary> | undefined);
     dispose(): void;
     private _run;
     toString(): string;

package/vscode/src/vs/base/common/observableInternal/autorun.js

@@ -8,13 +8,13 @@ import { DisposableStore, toDisposable, trackDisposable, markAsDisposed } from '
 import { getLogger } from './logging/logging.js';
 
 function autorun(fn) {
-    return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined, undefined));
+    return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined));
 }
 function autorunOpts(options, fn) {
-    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, undefined, undefined));
+    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, undefined));
 }
 function autorunHandleChanges(options, fn) {
-    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.createEmptyChangeSummary, options.handleChange));
+    return ( new AutorunObserver(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? fn)), fn, options.changeTracker));
 }
 function autorunWithStoreHandleChanges(options, fn) {
     const store = ( new DisposableStore());
@@ -22,8 +22,7 @@ function autorunWithStoreHandleChanges(options, fn) {
         owner: options.owner,
         debugName: options.debugName,
         debugReferenceFn: options.debugReferenceFn ?? fn,
-        createEmptyChangeSummary: options.createEmptyChangeSummary,
-        handleChange: options.handleChange,
+        changeTracker: options.changeTracker,
     }, (reader, changeSummary) => {
         store.clear();
         fn(reader, changeSummary, store);
@@ -90,23 +89,25 @@ class AutorunObserver {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? '(anonymous)';
     }
-    constructor(_debugNameData, _runFn, createChangeSummary, _handleChange) {
+    constructor(_debugNameData, _runFn, _changeTracker) {
         this._debugNameData = _debugNameData;
         this._runFn = _runFn;
-        this.createChangeSummary = createChangeSummary;
-        this._handleChange = _handleChange;
+        this._changeTracker = _changeTracker;
         this._state = AutorunState.stale;
         this._updateCount = 0;
         this._disposed = false;
         this._dependencies = ( new Set());
         this._dependenciesToBeRemoved = ( new Set());
         this._isRunning = false;
-        this._changeSummary = this.createChangeSummary?.();
+        this._changeSummary = this._changeTracker?.createChangeSummary(undefined);
         getLogger()?.handleAutorunCreated(this);
         this._run();
         trackDisposable(this);
     }
     dispose() {
+        if (this._disposed) {
+            return;
+        }
         this._disposed = true;
         for (const o of this._dependencies) {
             o.removeObserver(this);
@@ -125,8 +126,11 @@ class AutorunObserver {
                 getLogger()?.handleAutorunStarted(this);
                 const changeSummary = this._changeSummary;
                 try {
-                    this._changeSummary = this.createChangeSummary?.();
                     this._isRunning = true;
+                    if (this._changeTracker) {
+                        this._changeTracker.beforeUpdate?.(this, changeSummary);
+                        this._changeSummary = this._changeTracker.createChangeSummary(changeSummary);
+                    }
                     this._runFn(this, changeSummary);
                 }
                 catch (e) {
@@ -189,7 +193,7 @@ class AutorunObserver {
         if (this._isDependency(observable)) {
             getLogger()?.handleAutorunDependencyChanged(this, observable, change);
             try {
-                const shouldReact = this._handleChange ? this._handleChange({
+                const shouldReact = this._changeTracker ? this._changeTracker.handleChange({
                     changedObservable: observable,
                     change,
                     didChange: (o) => o === observable,

package/vscode/src/vs/base/common/observableInternal/base.d.ts

@@ -107,14 +107,4 @@ export declare class DisposableObservableValue<T extends IDisposable | undefined
     protected _setValue(newValue: T): void;
     dispose(): void;
 }
-export interface IChangeTracker {
-    handleChange(context: IChangeContext): boolean;
-}
-export interface IChangeContext {
-    readonly changedObservable: IObservableWithChange<any, any>;
-    readonly change: unknown;
-    didChange<T, TChange>(observable: IObservableWithChange<T, TChange>): this is {
-        change: TChange;
-    };
-}
 export {};

package/vscode/src/vs/base/common/observableInternal/changeTracker.d.ts

@@ -0,0 +1,23 @@
+import { IObservableWithChange, IReader } from "./base.js";
+export interface IChangeTracker<TChangeSummary> {
+    createChangeSummary(previousChangeSummary: TChangeSummary | undefined): TChangeSummary;
+    handleChange(ctx: IChangeContext, change: TChangeSummary): boolean;
+    beforeUpdate?(reader: IReader, change: TChangeSummary): void;
+}
+export interface IChangeContext {
+    readonly changedObservable: IObservableWithChange<any, any>;
+    readonly change: unknown;
+    didChange<T, TChange>(observable: IObservableWithChange<T, TChange>): this is {
+        change: TChange;
+    };
+}
+export declare function recordChanges<TObs extends Record<any, IObservableWithChange<any, any>>>(obs: TObs): IChangeTracker<{
+    [TKey in keyof TObs]: ReturnType<TObs[TKey]["get"]>;
+} & {
+    changes: readonly ({
+        [TKey in keyof TObs]: {
+            key: TKey;
+            change: TObs[TKey]["TChange"];
+        };
+    }[keyof TObs])[];
+}>;

package/vscode/src/vs/base/common/observableInternal/changeTracker.js

@@ -0,0 +1,30 @@
+
+import { BugIndicatingError } from '../errors.js';
+
+function recordChanges(obs) {
+    return {
+        createChangeSummary: (_previousChangeSummary) => {
+            return {
+                changes: [],
+            };
+        },
+        handleChange(ctx, changeSummary) {
+            for (const key in obs) {
+                if (ctx.didChange(obs[key])) {
+                    changeSummary.changes.push({ key, change: ctx.change });
+                }
+            }
+            return true;
+        },
+        beforeUpdate(reader, changeSummary) {
+            for (const key in obs) {
+                if (key === 'changes') {
+                    throw ( new BugIndicatingError('property name "changes" is reserved for change tracking'));
+                }
+                changeSummary[key] = obs[key].read(reader);
+            }
+        }
+    };
+}
+
+export { recordChanges };

package/vscode/src/vs/base/common/observableInternal/derived.d.ts

@@ -1,16 +1,19 @@
-import { BaseObservable, IChangeContext, IObservable, IObservableWithChange, IObserver, IReader, ISettableObservable, ITransaction } from "./base.js";
+import { BaseObservable, IObservable, IObservableWithChange, IObserver, IReader, ISettableObservable, ITransaction } from "./base.js";
 import { DebugNameData, DebugOwner, IDebugNameData } from "./debugName.js";
 import { DisposableStore, EqualityComparer, IDisposable } from "./commonFacade/deps.js";
-export declare function derived<T>(computeFn: (reader: IReader) => T): IObservable<T>;
-export declare function derived<T>(owner: DebugOwner, computeFn: (reader: IReader) => T): IObservable<T>;
+import { IChangeTracker } from "./changeTracker.js";
+export interface IDerivedReader<TChange = void> extends IReader {
+    reportChange(change: TChange): void;
+}
+export declare function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>) => T): IObservable<T>;
+export declare function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T): IObservable<T>;
 export declare function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void): ISettableObservable<T>;
 export declare function derivedOpts<T>(options: IDebugNameData & {
     equalsFn?: EqualityComparer<T>;
     onLastObserverRemoved?: (() => void);
 }, computeFn: (reader: IReader) => T): IObservable<T>;
 export declare function derivedHandleChanges<T, TChangeSummary>(options: IDebugNameData & {
-    createEmptyChangeSummary: () => TChangeSummary;
-    handleChange: (context: IChangeContext, changeSummary: TChangeSummary) => boolean;
+    changeTracker: IChangeTracker<TChangeSummary>;
     equalityComparer?: EqualityComparer<T>;
 }, computeFn: (reader: IReader, changeSummary: TChangeSummary) => T): IObservable<T>;
 export declare function derivedWithStore<T>(computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
@@ -23,11 +26,10 @@ export declare enum DerivedState {
     stale = 2,
     upToDate = 3
 }
-export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T, void> implements IReader, IObserver {
+export declare class Derived<T, TChangeSummary = any, TChange = void> extends BaseObservable<T, TChange> implements IDerivedReader<TChange>, IObserver {
     readonly _debugNameData: DebugNameData;
-    readonly _computeFn: (reader: IReader, changeSummary: TChangeSummary) => T;
-    private readonly createChangeSummary;
-    private readonly _handleChange;
+    readonly _computeFn: (reader: IDerivedReader<TChange>, changeSummary: TChangeSummary) => T;
+    private readonly _changeTracker;
     private readonly _handleLastObserverRemoved;
     private readonly _equalityComparator;
     private _state;
@@ -38,8 +40,9 @@ export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T,
     private _changeSummary;
     private _isUpdating;
     private _isComputing;
+    private _didReportChange;
     get debugName(): string;
-    constructor(_debugNameData: DebugNameData, _computeFn: (reader: IReader, changeSummary: TChangeSummary) => T, createChangeSummary: (() => TChangeSummary) | undefined, _handleChange: ((context: IChangeContext, summary: TChangeSummary) => boolean) | undefined, _handleLastObserverRemoved: (() => void) | undefined, _equalityComparator: EqualityComparer<T>);
+    constructor(_debugNameData: DebugNameData, _computeFn: (reader: IDerivedReader<TChange>, changeSummary: TChangeSummary) => T, _changeTracker: IChangeTracker<TChangeSummary> | undefined, _handleLastObserverRemoved: (() => void) | undefined, _equalityComparator: EqualityComparer<T>);
     protected onLastObserverRemoved(): void;
     get(): T;
     private _recompute;
@@ -51,6 +54,7 @@ export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T,
     handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
     private _isReaderValid;
     readObservable<T>(observable: IObservable<T>): T;
+    reportChange(change: TChange): void;
     addObserver(observer: IObserver): void;
     removeObserver(observer: IObserver): void;
     debugGetState(): {
@@ -61,8 +65,9 @@ export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T,
         value: T | undefined;
     };
     debugSetValue(newValue: unknown): void;
+    setValue(newValue: T, tx: ITransaction, change: TChange): void;
 }
-export declare class DerivedWithSetter<T, TChangeSummary = any> extends Derived<T, TChangeSummary> implements ISettableObservable<T> {
-    readonly set: (value: T, tx: ITransaction | undefined) => void;
-    constructor(debugNameData: DebugNameData, computeFn: (reader: IReader, changeSummary: TChangeSummary) => T, createChangeSummary: (() => TChangeSummary) | undefined, handleChange: ((context: IChangeContext, summary: TChangeSummary) => boolean) | undefined, handleLastObserverRemoved: (() => void) | undefined, equalityComparator: EqualityComparer<T>, set: (value: T, tx: ITransaction | undefined) => void);
+export declare class DerivedWithSetter<T, TChangeSummary = any, TOutChanges = any> extends Derived<T, TChangeSummary, TOutChanges> implements ISettableObservable<T, TOutChanges> {
+    readonly set: (value: T, tx: ITransaction | undefined, change: TOutChanges) => void;
+    constructor(debugNameData: DebugNameData, computeFn: (reader: IDerivedReader<TOutChanges>, changeSummary: TChangeSummary) => T, changeTracker: IChangeTracker<TChangeSummary> | undefined, handleLastObserverRemoved: (() => void) | undefined, equalityComparator: EqualityComparer<T>, set: (value: T, tx: ITransaction | undefined, change: TOutChanges) => void);
 }

package/vscode/src/vs/base/common/observableInternal/derived.js

@@ -10,19 +10,19 @@ import { getLogger } from './logging/logging.js';
 
 function derived(computeFnOrOwner, computeFn) {
     if (computeFn !== undefined) {
-        return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, undefined, strictEquals));
+        return ( new Derived(( new DebugNameData(computeFnOrOwner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals));
     }
-    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, undefined, strictEquals));
+    return ( new Derived(( new DebugNameData(undefined, undefined, computeFnOrOwner)), computeFnOrOwner, undefined, undefined, strictEquals));
 }
 function derivedWithSetter(owner, computeFn, setter) {
-    return ( new DerivedWithSetter(( new DebugNameData(owner, undefined, computeFn)), computeFn, undefined, undefined, undefined, strictEquals, setter));
+    return ( new DerivedWithSetter(( new DebugNameData(owner, undefined, computeFn)), computeFn, undefined, undefined, strictEquals, setter));
 }
 function derivedOpts(options, computeFn) {
-    return ( new Derived(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn)), computeFn, undefined, undefined, options.onLastObserverRemoved, options.equalsFn ?? strictEquals));
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn)), computeFn, undefined, options.onLastObserverRemoved, options.equalsFn ?? strictEquals));
 }
 _setDerivedOpts(derivedOpts);
 function derivedHandleChanges(options, computeFn) {
-    return ( new Derived(( new DebugNameData(options.owner, options.debugName, undefined)), computeFn, options.createEmptyChangeSummary, options.handleChange, undefined, options.equalityComparer ?? strictEquals));
+    return ( new Derived(( new DebugNameData(options.owner, options.debugName, undefined)), computeFn, options.changeTracker, undefined, options.equalityComparer ?? strictEquals));
 }
 function derivedWithStore(computeFnOrOwner, computeFnOrUndefined) {
     let computeFn;
@@ -44,7 +44,7 @@ function derivedWithStore(computeFnOrOwner, computeFnOrUndefined) {
             store.clear();
         }
         return computeFn(r, store);
-    }, undefined, undefined, () => store.dispose(), strictEquals));
+    }, undefined, () => store.dispose(), strictEquals));
 }
 function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
     let computeFn;
@@ -70,7 +70,7 @@ function derivedDisposable(computeFnOrOwner, computeFnOrUndefined) {
             store.add(result);
         }
         return result;
-    }, undefined, undefined, () => {
+    }, undefined, () => {
         if (store) {
             store.dispose();
             store = undefined;
@@ -88,12 +88,11 @@ class Derived extends BaseObservable {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? '(anonymous)';
     }
-    constructor(_debugNameData, _computeFn, createChangeSummary, _handleChange, _handleLastObserverRemoved = undefined, _equalityComparator) {
+    constructor(_debugNameData, _computeFn, _changeTracker, _handleLastObserverRemoved = undefined, _equalityComparator) {
         super();
         this._debugNameData = _debugNameData;
         this._computeFn = _computeFn;
-        this.createChangeSummary = createChangeSummary;
-        this._handleChange = _handleChange;
+        this._changeTracker = _changeTracker;
         this._handleLastObserverRemoved = _handleLastObserverRemoved;
         this._equalityComparator = _equalityComparator;
         this._state = DerivedState.initial;
@@ -104,9 +103,10 @@ class Derived extends BaseObservable {
         this._changeSummary = undefined;
         this._isUpdating = false;
         this._isComputing = false;
+        this._didReportChange = false;
         this._removedObserverToCallEndUpdateOn = null;
         this._isReaderValid = false;
-        this._changeSummary = this.createChangeSummary?.();
+        this._changeSummary = this._changeTracker?.createChangeSummary(undefined);
     }
     onLastObserverRemoved() {
         this._state = DerivedState.initial;
@@ -123,7 +123,12 @@ class Derived extends BaseObservable {
             let result;
             try {
                 this._isReaderValid = true;
-                result = this._computeFn(this, this.createChangeSummary?.());
+                let changeSummary = undefined;
+                if (this._changeTracker) {
+                    changeSummary = this._changeTracker.createChangeSummary(undefined);
+                    this._changeTracker.beforeUpdate?.(this, changeSummary);
+                }
+                result = this._computeFn(this, changeSummary);
             }
             finally {
                 this._isReaderValid = false;
@@ -160,11 +165,15 @@ class Derived extends BaseObservable {
         this._state = DerivedState.upToDate;
         let didChange = false;
         this._isComputing = true;
+        this._didReportChange = false;
         try {
             const changeSummary = this._changeSummary;
-            this._changeSummary = this.createChangeSummary?.();
             try {
                 this._isReaderValid = true;
+                if (this._changeTracker) {
+                    this._changeTracker.beforeUpdate?.(this, changeSummary);
+                    this._changeSummary = this._changeTracker?.createChangeSummary(changeSummary);
+                }
                 this._value = this._computeFn(this, changeSummary);
             }
             finally {
@@ -174,7 +183,7 @@ class Derived extends BaseObservable {
                 }
                 this._dependenciesToBeRemoved.clear();
             }
-            didChange = hadValue && !(this._equalityComparator(oldValue, this._value));
+            didChange = this._didReportChange || (hadValue && !(this._equalityComparator(oldValue, this._value)));
             getLogger()?.handleObservableUpdated(this, {
                 oldValue,
                 newValue: this._value,
@@ -187,11 +196,14 @@ class Derived extends BaseObservable {
             onBugIndicatingError(e);
         }
         this._isComputing = false;
-        if (didChange) {
+        if (!this._didReportChange && didChange) {
             for (const r of this._observers) {
                 r.handleChange(this, undefined);
             }
         }
+        else {
+            this._didReportChange = false;
+        }
     }
     toString() {
         return `LazyDerived<${this.debugName}>`;
@@ -252,7 +264,7 @@ class Derived extends BaseObservable {
             getLogger()?.handleDerivedDependencyChanged(this, observable, change);
             let shouldReact = false;
             try {
-                shouldReact = this._handleChange ? this._handleChange({
+                shouldReact = this._changeTracker ? this._changeTracker.handleChange({
                     changedObservable: observable,
                     change,
                     didChange: (o) => o === observable,
@@ -282,6 +294,15 @@ class Derived extends BaseObservable {
         this._dependenciesToBeRemoved.delete(observable);
         return value;
     }
+    reportChange(change) {
+        if (!this._isReaderValid) {
+            throw ( new BugIndicatingError('The reader object cannot be used outside its compute function!'));
+        }
+        this._didReportChange = true;
+        for (const r of this._observers) {
+            r.handleChange(this, change);
+        }
+    }
     addObserver(observer) {
         const shouldCallBeginUpdate = !( this._observers.has(observer)) && this._updateCount > 0;
         super.addObserver(observer);
@@ -315,10 +336,18 @@ class Derived extends BaseObservable {
     debugSetValue(newValue) {
         this._value = newValue;
     }
+    setValue(newValue, tx, change) {
+        this._value = newValue;
+        const observers = this._observers;
+        tx.updateObserver(this, this);
+        for (const d of observers) {
+            d.handleChange(this, change);
+        }
+    }
 }
 class DerivedWithSetter extends Derived {
-    constructor(debugNameData, computeFn, createChangeSummary, handleChange, handleLastObserverRemoved = undefined, equalityComparator, set) {
-        super(debugNameData, computeFn, createChangeSummary, handleChange, handleLastObserverRemoved, equalityComparator);
+    constructor(debugNameData, computeFn, changeTracker, handleLastObserverRemoved = undefined, equalityComparator, set) {
+        super(debugNameData, computeFn, changeTracker, handleLastObserverRemoved, equalityComparator);
         this.set = set;
     }
 }

package/vscode/src/vs/base/common/observableInternal/index.d.ts

@@ -1,8 +1,9 @@
 export { observableValueOpts } from "./api.js";
-export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges } from "./autorun.js";
-export { asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction, TransactionImpl, type IChangeContext, type IChangeTracker, type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction, } from "./base.js";
-export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from "./derived.js";
-export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "@codingame/monaco-vscode-ae8a8ca1-f243-508b-9c37-c88ebbd295fa-common/vscode/vs/base/common/observableInternal/promise";
+export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta } from "./autorun.js";
+export { asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction, TransactionImpl, type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction, } from "./base.js";
+export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore, type IDerivedReader } from "./derived.js";
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "./promise.js";
 export { derivedWithCancellationToken, waitForState } from "./utilsCancellation.js";
-export { constObservable, debouncedObservableDeprecated, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithStore, signalFromObservable, ValueWithChangeEventFromObservable, wasEventTriggeredRecently, type IObservableSignal, } from "./utils.js";
+export { constObservable, debouncedObservableDeprecated, debouncedObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithStore, runOnChangeWithCancellationToken, signalFromObservable, ValueWithChangeEventFromObservable, wasEventTriggeredRecently, type IObservableSignal, } from "./utils.js";
 export { type DebugOwner } from "./debugName.js";
+export { type IChangeContext, type IChangeTracker, recordChanges } from "./changeTracker.js";

package/vscode/src/vs/base/common/observableInternal/index.js

@@ -3,10 +3,10 @@ import '../arrays.js';
 import '../event.js';
 import '../lifecycle.js';
 import { setLogObservableFn, addLogger } from './logging/logging.js';
-export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges } from './autorun.js';
+export { autorun, autorunDelta, autorunHandleChanges, autorunIterableDelta, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges } from './autorun.js';
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from './derived.js';
 import '../cancellation.js';
-export { ValueWithChangeEventFromObservable, constObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithStore, wasEventTriggeredRecently } from './utils.js';
+export { ValueWithChangeEventFromObservable, constObservable, debouncedObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, wasEventTriggeredRecently } from './utils.js';
 import { logObservableToConsole } from './logging/consoleObservableLogger.js';
 import { DevToolsLogger } from './logging/debugger/devToolsLogger.js';
 import { env } from '../process.js';