@codingame/monaco-vscode-telemetry-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/editTracker.js

@@ -1,25 +1,55 @@
 
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { AnnotatedStringEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit';
+import { EditKeySourceData, EditSourceBase } from '../helpers/documentWithAnnotatedEdits.js';
 import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
 import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
 
+const EXTERNAL_OBSERVATION_KEY_PREFIX = "external-observation:";
 class DocumentEditSourceTracker extends Disposable {
-    constructor(_doc, data) {
+    constructor(
+        _doc,
+        data,
+        _externalEditCorrelation,
+        _externalEditCorrelationPolicy = "suppress"
+    ) {
         super();
         this._doc = _doc;
         this.data = data;
+        this._externalEditCorrelation = _externalEditCorrelation;
+        this._externalEditCorrelationPolicy = _externalEditCorrelationPolicy;
         this._edits = AnnotatedStringEdit.empty;
         this._pendingExternalEdits = AnnotatedStringEdit.empty;
         this._update = observableSignal(this);
+        this._documentStore = this._register(( new DisposableStore()));
         this._representativePerKey = ( new Map());
         this._sumAddedCharactersPerKey = ( new Map());
-        this._register(runOnChange(this._doc.value, (_val, _prevVal, edits) => {
-            const eComposed = AnnotatedStringEdit.compose(( edits.map(e => e.edit)));
+        this._externalObservationIds = ( new Set());
+        this._ignoredInitialExternalObservationIds = ( new Set());
+        this._suppressedExternalObservationIds = ( new Set());
+        this._invalidatedExternalObservationIds = ( new Set());
+        this._reattributedExternalObservations = ( new Map());
+        this._documentStore.add(runOnChange(this._doc.value, (_val, _prevVal, edits) => {
+            let eComposed = AnnotatedStringEdit.compose(( edits.map(e => e.edit)));
             if (eComposed.replacements.every(e => e.data.source.category === "external")) {
-                if (this._edits.isEmpty())
+                if (this._edits.isEmpty() && !this._externalEditCorrelation)
                     ; else {
+                    if (this._externalEditCorrelation) {
+                        const observationId = this._externalEditCorrelation.register(_prevVal.value, _val.value);
+                        this._externalObservationIds.add(observationId);
+                        if (this._edits.isEmpty()) {
+                            this._ignoredInitialExternalObservationIds.add(observationId);
+                        }
+                        const resolution = this._externalEditCorrelation.getResolution?.(observationId);
+                        if (resolution) {
+                            this._resolveExternalObservation(resolution);
+                        } else if (this._externalEditCorrelationPolicy === "suppress" && this._externalEditCorrelation.isSuppressed(observationId)) {
+                            this._suppressedExternalObservationIds.add(observationId);
+                        }
+                        const key = `${EXTERNAL_OBSERVATION_KEY_PREFIX}${observationId}`;
+                        eComposed = eComposed.mapData(replacement => ( new EditKeySourceData(key, replacement.data.source, replacement.data.representative)));
+                    }
                     this._pendingExternalEdits = this._pendingExternalEdits.compose(eComposed);
                 }
             } else {
@@ -31,6 +61,40 @@ class DocumentEditSourceTracker extends Disposable {
             }
             this._update.trigger(undefined);
         }));
+        if (this._externalEditCorrelation) {
+            if (this._externalEditCorrelation.onDidResolve) {
+                this._register(
+                    this._externalEditCorrelation.onDidResolve(resolution => this._resolveExternalObservation(resolution))
+                );
+            } else {
+                this._register(this._externalEditCorrelation.onDidSuppress(observationId => {
+                    if (( this._externalObservationIds.has(observationId)) && this._externalEditCorrelationPolicy === "suppress") {
+                        this._suppressedExternalObservationIds.add(observationId);
+                        this._update.trigger(undefined);
+                    }
+                }));
+            }
+            this._register(this._externalEditCorrelation.onDidInvalidate(observationId => {
+                if (( this._externalObservationIds.has(observationId))) {
+                    this._suppressedExternalObservationIds.delete(observationId);
+                    this._reattributedExternalObservations.delete(observationId);
+                    this._invalidatedExternalObservationIds.add(observationId);
+                    this._update.trigger(undefined);
+                }
+            }));
+        }
+    }
+    releaseExternalEditCorrelations() {
+        for (const observationId of this._externalObservationIds) {
+            this._externalEditCorrelation?.release(observationId);
+        }
+        this._externalObservationIds.clear();
+    }
+    stopTracking() {
+        this._documentStore.clear();
+    }
+    async waitForExternalEditCorrelations(timeoutMs) {
+        await this._externalEditCorrelation?.waitForResolution?.(Array.from(this._externalObservationIds), timeoutMs);
     }
     _applyEdit(e) {
         for (const r of e.replacements) {
@@ -47,27 +111,76 @@ class DocumentEditSourceTracker extends Disposable {
     async waitForQueue() {
         await this._doc.waitForQueue();
     }
-    getTotalInsertedCharactersCount(key) {
+    getTotalInsertedCharactersCount(key, includeSuppressed = false) {
+        if (!this._shouldIncludeKey(key, includeSuppressed)) {
+            return 0;
+        }
         const val = this._sumAddedCharactersPerKey.get(key);
         return val ?? 0;
     }
-    getAllKeys() {
-        return Array.from(( this._sumAddedCharactersPerKey.keys()));
+    getAllKeys(includeSuppressed = false) {
+        return Array.from(( this._sumAddedCharactersPerKey.keys())).filter(key => this._shouldIncludeKey(key, includeSuppressed));
     }
     getRepresentative(key) {
+        const observationId = getExternalObservationId(key);
+        if (observationId) {
+            return this._reattributedExternalObservations.get(observationId) ?? this._representativePerKey.get(key);
+        }
         return this._representativePerKey.get(key);
     }
-    getTrackedRanges(reader) {
+    applyPendingExternalEdits() {
+        if (this._pendingExternalEdits.isEmpty()) {
+            return;
+        }
+        this._applyEdit(this._pendingExternalEdits);
+        this._pendingExternalEdits = AnnotatedStringEdit.empty;
+        this._update.trigger(undefined);
+    }
+    getTrackedRanges(reader, includeSuppressed = false) {
         this._update.read(reader);
         const ranges = this._edits.getNewRanges();
         return ( ranges.map((r, idx) => {
             const e = this._edits.replacements[idx];
-            const te = ( new TrackedEdit(e.replaceRange, r, e.data.key, e.data.source, e.data.representative));
+            const representative = this.getRepresentative(e.data.key) ?? e.data.representative;
+            const source = representative === e.data.representative ? e.data.source : EditSourceBase.create(representative);
+            const te = ( new TrackedEdit(e.replaceRange, r, e.data.key, source, representative));
             return te;
-        }));
+        })).filter(edit => this._shouldIncludeKey(edit.sourceKey, includeSuppressed));
     }
     isEmpty() {
-        return this._edits.isEmpty();
+        return this.getAllKeys().length === 0;
+    }
+    _shouldIncludeKey(key, includeSuppressed) {
+        const observationId = getExternalObservationId(key);
+        if (!observationId) {
+            return true;
+        }
+        if (( this._reattributedExternalObservations.has(observationId))) {
+            return true;
+        }
+        if (( this._invalidatedExternalObservationIds.has(observationId))) {
+            return true;
+        }
+        const isSuppressed = ( this._suppressedExternalObservationIds.has(observationId));
+        if (( this._ignoredInitialExternalObservationIds.has(observationId))) {
+            if (this._externalEditCorrelationPolicy === "reattribute") {
+                return true;
+            }
+            return includeSuppressed && isSuppressed;
+        }
+        return includeSuppressed || !isSuppressed;
+    }
+    _resolveExternalObservation(resolution) {
+        if (!( this._externalObservationIds.has(resolution.id))) {
+            return;
+        }
+        this._invalidatedExternalObservationIds.delete(resolution.id);
+        if (this._externalEditCorrelationPolicy === "suppress") {
+            this._suppressedExternalObservationIds.add(resolution.id);
+        } else if (resolution.source) {
+            this._reattributedExternalObservations.set(resolution.id, resolution.source);
+        }
+        this._update.trigger(undefined);
     }
     _getDebugVisualization() {
         const ranges = this.getTrackedRanges();
@@ -86,6 +199,9 @@ class DocumentEditSourceTracker extends Disposable {
         };
     }
 }
+function getExternalObservationId(key) {
+    return key.startsWith(EXTERNAL_OBSERVATION_KEY_PREFIX) ? key.substring(EXTERNAL_OBSERVATION_KEY_PREFIX.length) : undefined;
+}
 class TrackedEdit {
     constructor(originalRange, range, sourceKey, source, sourceRepresentative) {
         this.originalRange = originalRange;

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/scmAdapter.d.ts

@@ -7,9 +7,14 @@ export declare class ScmAdapter {
     private readonly _repos;
     private readonly _reposChangedSignal;
     constructor(_scmService: ISCMService);
-    getRepo(uri: URI, reader: IReader | undefined): ScmRepoAdapter | undefined;
+    getRepo(uri: URI, reader: IReader | undefined): IScmRepoAdapter | undefined;
 }
-export declare class ScmRepoAdapter {
+export interface IScmRepoAdapter {
+    readonly headBranchNameObs: IObservable<string | undefined>;
+    readonly headCommitHashObs: IObservable<string | undefined>;
+    isIgnored(uri: URI): Promise<boolean>;
+}
+export declare class ScmRepoAdapter implements IScmRepoAdapter {
     private readonly _repo;
     readonly headBranchNameObs: IObservable<string | undefined>;
     readonly headCommitHashObs: IObservable<string | undefined>;

package/vscode/src/vs/workbench/contrib/editTelemetry/common/arcTracker.d.ts

@@ -1,29 +1,21 @@
-import { BaseStringEdit, IEditData } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit";
+import { BaseStringEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit";
 import { AbstractText } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/text/abstractText";
 /**
  * The ARC (accepted and retained characters) counts how many characters inserted by the initial suggestion (trackedEdit)
  * stay unmodified after a certain amount of time after acceptance.
 */
 export declare class ArcTracker {
-    private readonly _valueBeforeTrackedEdit;
-    private _updatedTrackedEdit;
-    private _trackedEdit;
-    constructor(_valueBeforeTrackedEdit: AbstractText, trackedEdit: BaseStringEdit);
+    private readonly _tracker;
+    constructor(valueBeforeTrackedEdit: AbstractText, trackedEdit: BaseStringEdit);
     getOriginalCharacterCount(): number;
     /**
      * edit must apply to _updatedTrackedEdit.apply(_valueBeforeTrackedEdit)
     */
     handleEdits(edit: BaseStringEdit): void;
     getAcceptedRestrainedCharactersCount(): number;
-    getDebugState(): unknown;
     getLineCountInfo(): {
         deletedLineCounts: number;
         insertedLineCounts: number;
     };
     getValues(): unknown;
 }
-export declare class IsTrackedEditData implements IEditData<IsTrackedEditData> {
-    readonly isTrackedEdit: boolean;
-    constructor(isTrackedEdit: boolean);
-    join(data: IsTrackedEditData): IsTrackedEditData | undefined;
-}

package/vscode/src/vs/workbench/contrib/editTelemetry/common/arcTracker.js

@@ -1,64 +1,34 @@
 
-import { sumBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { LineEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/lineEdit';
+import { EditArcTracker } from '../../../../base/common/editArcTracker.js';
 
 class ArcTracker {
-    constructor(_valueBeforeTrackedEdit, trackedEdit) {
-        this._valueBeforeTrackedEdit = _valueBeforeTrackedEdit;
-        this._trackedEdit = trackedEdit.removeCommonSuffixPrefix(_valueBeforeTrackedEdit.getValue());
-        this._updatedTrackedEdit = this._trackedEdit.mapData(() => ( new IsTrackedEditData(true)));
+    constructor(valueBeforeTrackedEdit, trackedEdit) {
+        this._tracker = ( new EditArcTracker(valueBeforeTrackedEdit.getValue(), toArcTextEdit(trackedEdit)));
     }
     getOriginalCharacterCount() {
-        return sumBy(this._trackedEdit.replacements, e => e.getNewLength());
+        return this._tracker.getOriginalCharacterCount();
     }
     handleEdits(edit) {
-        const e = edit.mapData(_d => ( new IsTrackedEditData(false)));
-        const composedEdit = this._updatedTrackedEdit.compose(e);
-        this._updatedTrackedEdit = composedEdit;
+        this._tracker.handleEdits(toArcTextEdit(edit));
     }
     getAcceptedRestrainedCharactersCount() {
-        const s = sumBy(
-            this._updatedTrackedEdit.replacements,
-            e => e.data.isTrackedEdit ? e.getNewLength() : 0
-        );
-        return s;
-    }
-    getDebugState() {
-        return {
-            edits: ( this._updatedTrackedEdit.replacements.map(e => ({
-                range: ( e.replaceRange.toString()),
-                newText: e.newText,
-                isTrackedEdit: e.data.isTrackedEdit
-            })))
-        };
+        return this._tracker.getAcceptedRestrainedCharactersCount();
     }
     getLineCountInfo() {
-        const e = this._updatedTrackedEdit.toStringEdit(r => r.data.isTrackedEdit);
-        const le = LineEdit.fromStringEdit(e, this._valueBeforeTrackedEdit);
-        const deletedLineCount = sumBy(le.replacements, r => r.lineRange.length);
-        const insertedLineCount = sumBy(le.getNewLineRanges(), r => r.length);
-        return {
-            deletedLineCounts: deletedLineCount,
-            insertedLineCounts: insertedLineCount
-        };
+        return this._tracker.getLineCountInfo();
     }
     getValues() {
-        return {
-            arc: this.getAcceptedRestrainedCharactersCount(),
-            ...this.getLineCountInfo()
-        };
+        return this._tracker.getValues();
     }
 }
-class IsTrackedEditData {
-    constructor(isTrackedEdit) {
-        this.isTrackedEdit = isTrackedEdit;
-    }
-    join(data) {
-        if (this.isTrackedEdit !== data.isTrackedEdit) {
-            return undefined;
-        }
-        return this;
-    }
+function toArcTextEdit(edit) {
+    return {
+        replacements: ( edit.replacements.map(replacement => ({
+            start: replacement.replaceRange.start,
+            endExclusive: replacement.replaceRange.endExclusive,
+            text: replacement.newText
+        })))
+    };
 }
 
-export { ArcTracker, IsTrackedEditData };
+export { ArcTracker };

package/vscode/src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.js

@@ -176,7 +176,7 @@ let TelemetryContribution = class TelemetryContribution extends Disposable {
             constructor() {
                 super({
                     id: "workbench.action.showTelemetry",
-                    title: ( localize2(14739, "Show Telemetry")),
+                    title: ( localize2(16498, "Show Telemetry")),
                     category: Categories.Developer,
                     f1: true
                 });
@@ -270,6 +270,18 @@ let ConfigurationTelemetryContribution = class ConfigurationTelemetryContributio
                 source
             });
             return;
+        case LayoutSettings.MODERN_UI:
+            this.telemetryService.publicLog2("workbench.experimental.modernUI", {
+                settingValue: this.getValueToReport(key, target),
+                source
+            });
+            return;
+        case LayoutSettings.MODERN_UI_DENSITY:
+            this.telemetryService.publicLog2("window.density.layout", {
+                settingValue: this.getValueToReport(key, target),
+                source
+            });
+            return;
         case AutoUpdateConfigurationKey:
             this.telemetryService.publicLog2("extensions.autoUpdate", {
                 settingValue: this.getValueToReport(key, target),
@@ -335,7 +347,6 @@ let ConfigurationTelemetryContribution = class ConfigurationTelemetryContributio
             });
             return;
         case TerminalContribSettingId.AgentSandboxEnabled:
-        case TerminalContribSettingId.DeprecatedAgentSandboxEnabled:
             this.telemetryService.publicLog2("chat.agent.sandbox", {
                 settingValue: this.getValueToReport(key, target),
                 source

package/vscode/src/vs/workbench/services/telemetry/browser/telemetryService.d.ts

@@ -28,7 +28,7 @@ export declare class TelemetryService extends Disposable implements ITelemetrySe
      */
     private initializeService;
     setExperimentProperty(name: string, value: string): void;
-    setCommonProperty(name: string, value: string | boolean): void;
+    setCommonProperty(name: string, value: string | boolean | undefined): void;
     get telemetryLevel(): TelemetryLevel;
     publicLog(eventName: string, data?: ITelemetryData): void;
     publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;

package/vscode/src/vs/workbench/services/dataChannel/browser/dataChannelService.d.ts

@@ -1,10 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { CoreDataChannel, IDataChannelEvent } from "@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel";
-import { IDataChannelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel.service";
-export declare class DataChannelService extends Disposable implements IDataChannelService {
-    readonly _serviceBrand: undefined;
-    private readonly _onDidSendData;
-    readonly onDidSendData: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<IDataChannelEvent<unknown>>;
-    constructor();
-    getDataChannel<T>(channelId: string): CoreDataChannel<T>;
-}

package/vscode/src/vs/workbench/services/dataChannel/browser/dataChannelService.js

@@ -1,30 +0,0 @@
-
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
-
-class DataChannelService extends Disposable {
-    constructor() {
-        super();
-        this._onDidSendData = this._register(( new Emitter()));
-        this.onDidSendData = this._onDidSendData.event;
-    }
-    getDataChannel(channelId) {
-        return ( new CoreDataChannelImpl(channelId, this._onDidSendData));
-    }
-}
-class CoreDataChannelImpl {
-    constructor(channelId, _onDidSendData) {
-        this.channelId = channelId;
-        this._onDidSendData = _onDidSendData;
-    }
-    sendData(data) {
-        this._onDidSendData.fire({
-            channelId: this.channelId,
-            data
-        });
-    }
-}
-
-export { DataChannelService };