@codingame/monaco-vscode-telemetry-service-override 32.0.2 → 33.0.9

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

@@ -0,0 +1,292 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { reverseOrder, compareBy, numberComparator, sumBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { IntervalTimer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IUserAttentionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userAttention/common/userAttentionService.service';
+import { EditTelemetryReportInlineEditArcSender, EditTelemetryReportEditArcForChatOrInlineChatSender, CreateSuggestionIdForChatOrInlineChatCaller } from './arcTelemetrySender.js';
+import { createDocWithJustReason } from '../helpers/documentWithAnnotatedEdits.js';
+import { DocumentEditSourceTracker } from './editTracker.js';
+import { sumByCategory } from '../helpers/utils.js';
+import { ScmAdapter } from './scmAdapter.js';
+import { IRandomService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/randomService.service';
+import { mapObservableArrayCached } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+
+let EditSourceTrackingImpl = class EditSourceTrackingImpl extends Disposable {
+    constructor(_statsEnabled, _annotatedDocuments, _instantiationService) {
+        super();
+        this._statsEnabled = _statsEnabled;
+        this._annotatedDocuments = _annotatedDocuments;
+        this._instantiationService = _instantiationService;
+        const scmBridge = this._instantiationService.createInstance(ScmAdapter);
+        this._states = mapObservableArrayCached(this, this._annotatedDocuments.documents, (doc, store) => {
+            return [doc.document, store.add(
+                this._instantiationService.createInstance(TrackedDocumentInfo, doc, scmBridge, this._statsEnabled)
+            )];
+        });
+        this.docsState = ( this._states.map(entries => ( new Map(entries))));
+        this.docsState.recomputeInitiallyAndOnChange(this._store);
+    }
+};
+EditSourceTrackingImpl = ( __decorate([( __param(2, IInstantiationService))], EditSourceTrackingImpl));
+let TrackedDocumentInfo = class TrackedDocumentInfo extends Disposable {
+    constructor(
+        _doc,
+        _scm,
+        _statsEnabled,
+        _instantiationService,
+        _telemetryService,
+        _randomService,
+        _userAttentionService
+    ) {
+        super();
+        this._doc = _doc;
+        this._scm = _scm;
+        this._statsEnabled = _statsEnabled;
+        this._instantiationService = _instantiationService;
+        this._telemetryService = _telemetryService;
+        this._randomService = _randomService;
+        this._userAttentionService = _userAttentionService;
+        this._repo = derived(this, reader => this._scm.getRepo(_doc.document.uri, reader));
+        const docWithJustReason = createDocWithJustReason(_doc.documentWithAnnotations, this._store);
+        const longtermResetSignal = observableSignal("resetSignal");
+        let longtermReason = "closed";
+        this.longtermTracker = derived(reader => {
+            if (!this._statsEnabled.read(reader)) {
+                return undefined;
+            }
+            longtermResetSignal.read(reader);
+            const t = reader.store.add(( new DocumentEditSourceTracker(docWithJustReason, undefined)));
+            const startFocusTime = this._userAttentionService.totalFocusTimeMs;
+            const startTime = Date.now();
+            reader.store.add(toDisposable(() => {
+                if (!t.isEmpty()) {
+                    this.sendTelemetry(
+                        "longterm",
+                        longtermReason,
+                        t,
+                        this._userAttentionService.totalFocusTimeMs - startFocusTime,
+                        Date.now() - startTime
+                    );
+                }
+                t.dispose();
+            }));
+            return t;
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._store.add(( new IntervalTimer())).cancelAndSet(() => {
+            longtermReason = "10hours";
+            longtermResetSignal.trigger(undefined);
+            longtermReason = "closed";
+        }, 10 * 60 * 60 * 1000);
+        this._store.add(autorun(reader => {
+            const repo = this._repo.read(reader);
+            if (repo) {
+                reader.store.add(runOnChange(repo.headCommitHashObs, () => {
+                    longtermReason = "hashChange";
+                    longtermResetSignal.trigger(undefined);
+                    longtermReason = "closed";
+                }));
+                reader.store.add(runOnChange(repo.headBranchNameObs, () => {
+                    longtermReason = "branchChange";
+                    longtermResetSignal.trigger(undefined);
+                    longtermReason = "closed";
+                }));
+            }
+        }));
+        this._store.add(this._instantiationService.createInstance(
+            EditTelemetryReportInlineEditArcSender,
+            _doc.documentWithAnnotations,
+            this._repo
+        ));
+        this._store.add(this._instantiationService.createInstance(
+            EditTelemetryReportEditArcForChatOrInlineChatSender,
+            _doc.documentWithAnnotations,
+            this._repo
+        ));
+        this._store.add(
+            this._instantiationService.createInstance(CreateSuggestionIdForChatOrInlineChatCaller, _doc.documentWithAnnotations)
+        );
+        const resetSignal = observableSignal("resetSignal");
+        this.windowedTracker = derived(reader => {
+            if (!this._statsEnabled.read(reader)) {
+                return undefined;
+            }
+            if (!this._doc.isVisible.read(reader)) {
+                return undefined;
+            }
+            resetSignal.read(reader);
+            reader.store.add(
+                this._userAttentionService.fireAfterGivenFocusTimePassed(10 * 60 * 1000, () => {
+                    resetSignal.trigger(undefined);
+                })
+            );
+            const t = reader.store.add(( new DocumentEditSourceTracker(docWithJustReason, undefined)));
+            const startFocusTime = this._userAttentionService.totalFocusTimeMs;
+            const startTime = Date.now();
+            reader.store.add(toDisposable(async () => {
+                this.sendTelemetry(
+                    "10minFocusWindow",
+                    "time",
+                    t,
+                    this._userAttentionService.totalFocusTimeMs - startFocusTime,
+                    Date.now() - startTime
+                );
+                t.dispose();
+            }));
+            return t;
+        }).recomputeInitiallyAndOnChange(this._store);
+        const focusResetSignal = observableSignal("focusResetSignal");
+        this.windowedFocusTracker = derived(reader => {
+            if (!this._statsEnabled.read(reader)) {
+                return undefined;
+            }
+            if (!this._doc.isVisible.read(reader)) {
+                return undefined;
+            }
+            focusResetSignal.read(reader);
+            reader.store.add(
+                this._userAttentionService.fireAfterGivenFocusTimePassed(20 * 60 * 1000, () => {
+                    focusResetSignal.trigger(undefined);
+                })
+            );
+            const t = reader.store.add(( new DocumentEditSourceTracker(docWithJustReason, undefined)));
+            const startFocusTime = this._userAttentionService.totalFocusTimeMs;
+            const startTime = Date.now();
+            reader.store.add(toDisposable(async () => {
+                this.sendTelemetry(
+                    "20minFocusWindow",
+                    "time",
+                    t,
+                    this._userAttentionService.totalFocusTimeMs - startFocusTime,
+                    Date.now() - startTime
+                );
+                t.dispose();
+            }));
+            return t;
+        }).recomputeInitiallyAndOnChange(this._store);
+    }
+    async sendTelemetry(mode, trigger, t, focusTime, actualTime) {
+        const ranges = t.getTrackedRanges();
+        const keys = t.getAllKeys();
+        if (keys.length === 0) {
+            return;
+        }
+        const data = this.getTelemetryData(ranges);
+        const statsUuid = this._randomService.generateUuid();
+        const sums = sumByCategory(ranges, r => r.range.length, r => r.sourceKey);
+        const entries = Object.entries(sums).filter(([key, value]) => value !== undefined);
+        entries.sort(reverseOrder(compareBy(([key, value]) => value, numberComparator)));
+        entries.length = mode === "longterm" ? 30 : 10;
+        for (const key of keys) {
+            if (!sums[key]) {
+                sums[key] = 0;
+            }
+        }
+        for (const [key, value] of Object.entries(sums)) {
+            if (value === undefined) {
+                continue;
+            }
+            const repr = t.getRepresentative(key);
+            const deltaModifiedCount = t.getTotalInsertedCharactersCount(key);
+            this._telemetryService.publicLog2("editTelemetry.editSources.details", {
+                mode,
+                sourceKey: key,
+                sourceKeyCleaned: repr.toKey(1, {
+                    $extensionId: false,
+                    $extensionVersion: false,
+                    $modelId: false
+                }),
+                extensionId: repr.props.$extensionId,
+                extensionVersion: repr.props.$extensionVersion,
+                modelId: repr.props.$modelId,
+                trigger,
+                languageId: this._doc.document.languageId.get(),
+                statsUuid: statsUuid,
+                conversationId: repr.props.$$sessionId,
+                requestId: repr.props.$$requestId,
+                modifiedCount: value,
+                deltaModifiedCount: deltaModifiedCount,
+                totalModifiedCount: data.totalModifiedCharactersInFinalState
+            });
+        }
+        const isTrackedByGit = await data.isTrackedByGit;
+        this._telemetryService.publicLog2("editTelemetry.editSources.stats", {
+            mode,
+            languageId: this._doc.document.languageId.get(),
+            statsUuid: statsUuid,
+            nesModifiedCount: data.nesModifiedCount,
+            inlineCompletionsCopilotModifiedCount: data.inlineCompletionsCopilotModifiedCount,
+            inlineCompletionsNESModifiedCount: data.inlineCompletionsNESModifiedCount,
+            otherAIModifiedCount: data.otherAIModifiedCount,
+            unknownModifiedCount: data.unknownModifiedCount,
+            userModifiedCount: data.userModifiedCount,
+            ideModifiedCount: data.ideModifiedCount,
+            totalModifiedCharacters: data.totalModifiedCharactersInFinalState,
+            externalModifiedCount: data.externalModifiedCount,
+            isTrackedByGit: isTrackedByGit ? 1 : 0,
+            focusTime,
+            actualTime,
+            trigger
+        });
+    }
+    getTelemetryData(ranges) {
+        const getEditCategory = source => {
+            if (source.category === "ai" && source.kind === "nes") {
+                return "nes";
+            }
+            if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot") {
+                return "inlineCompletionsCopilot";
+            }
+            if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot-chat" && source.providerId === "completions") {
+                return "inlineCompletionsCopilot";
+            }
+            if (source.category === "ai" && source.kind === "completion" && source.extensionId === "github.copilot-chat" && source.providerId === "nes") {
+                return "inlineCompletionsNES";
+            }
+            if (source.category === "ai" && source.kind === "completion") {
+                return "inlineCompletionsOther";
+            }
+            if (source.category === "ai") {
+                return "otherAI";
+            }
+            if (source.category === "user") {
+                return "user";
+            }
+            if (source.category === "ide") {
+                return "ide";
+            }
+            if (source.category === "external") {
+                return "external";
+            }
+            if (source.category === "unknown") {
+                return "unknown";
+            }
+            return "unknown";
+        };
+        const sums = sumByCategory(ranges, r => r.range.length, r => getEditCategory(r.source));
+        const totalModifiedCharactersInFinalState = sumBy(ranges, r => r.range.length);
+        return {
+            nesModifiedCount: sums.nes ?? 0,
+            inlineCompletionsCopilotModifiedCount: sums.inlineCompletionsCopilot ?? 0,
+            inlineCompletionsNESModifiedCount: sums.inlineCompletionsNES ?? 0,
+            otherAIModifiedCount: sums.otherAI ?? 0,
+            userModifiedCount: sums.user ?? 0,
+            ideModifiedCount: sums.ide ?? 0,
+            unknownModifiedCount: sums.unknown ?? 0,
+            externalModifiedCount: sums.external ?? 0,
+            totalModifiedCharactersInFinalState,
+            languageId: this._doc.document.languageId.get(),
+            isTrackedByGit: this._repo.get()?.isIgnored(this._doc.document.uri)
+        };
+    }
+};
+TrackedDocumentInfo = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, ITelemetryService)), ( __param(5, IRandomService)), ( __param(6, IUserAttentionService))], TrackedDocumentInfo));
+
+export { EditSourceTrackingImpl };

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

@@ -0,0 +1,41 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { OffsetRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange";
+import { TextModelEditSource } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource";
+import { IDocumentWithAnnotatedEdits, EditSource } from "../helpers/documentWithAnnotatedEdits.js";
+/**
+ * Tracks a single document.
+*/
+export declare class DocumentEditSourceTracker<T = void> extends Disposable {
+    private readonly _doc;
+    readonly data: T;
+    private _edits;
+    private _pendingExternalEdits;
+    private readonly _update;
+    private readonly _representativePerKey;
+    private readonly _sumAddedCharactersPerKey;
+    constructor(_doc: IDocumentWithAnnotatedEdits, data: T);
+    private _applyEdit;
+    waitForQueue(): Promise<void>;
+    getTotalInsertedCharactersCount(key: string): number;
+    getAllKeys(): string[];
+    getRepresentative(key: string): TextModelEditSource | undefined;
+    getTrackedRanges(reader?: IReader): TrackedEdit[];
+    isEmpty(): boolean;
+    _getDebugVisualization(): {
+        value: string;
+        decorations: {
+            range: number[];
+            color: string;
+        }[];
+        $fileExtension: string;
+    };
+}
+export declare class TrackedEdit {
+    readonly originalRange: OffsetRange;
+    readonly range: OffsetRange;
+    readonly sourceKey: string;
+    readonly source: EditSource;
+    readonly sourceRepresentative: TextModelEditSource;
+    constructor(originalRange: OffsetRange, range: OffsetRange, sourceKey: string, source: EditSource, sourceRepresentative: TextModelEditSource);
+}

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

@@ -0,0 +1,99 @@
+
+import { Disposable } 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 { 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';
+
+class DocumentEditSourceTracker extends Disposable {
+    constructor(_doc, data) {
+        super();
+        this._doc = _doc;
+        this.data = data;
+        this._edits = AnnotatedStringEdit.empty;
+        this._pendingExternalEdits = AnnotatedStringEdit.empty;
+        this._update = observableSignal(this);
+        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)));
+            if (eComposed.replacements.every(e => e.data.source.category === "external")) {
+                if (this._edits.isEmpty())
+                    ; else {
+                    this._pendingExternalEdits = this._pendingExternalEdits.compose(eComposed);
+                }
+            } else {
+                if (!this._pendingExternalEdits.isEmpty()) {
+                    this._applyEdit(this._pendingExternalEdits);
+                    this._pendingExternalEdits = AnnotatedStringEdit.empty;
+                }
+                this._applyEdit(eComposed);
+            }
+            this._update.trigger(undefined);
+        }));
+    }
+    _applyEdit(e) {
+        for (const r of e.replacements) {
+            let existing = this._sumAddedCharactersPerKey.get(r.data.key);
+            if (existing === undefined) {
+                existing = 0;
+                this._representativePerKey.set(r.data.key, r.data.representative);
+            }
+            const newCount = existing + r.getNewLength();
+            this._sumAddedCharactersPerKey.set(r.data.key, newCount);
+        }
+        this._edits = this._edits.compose(e);
+    }
+    async waitForQueue() {
+        await this._doc.waitForQueue();
+    }
+    getTotalInsertedCharactersCount(key) {
+        const val = this._sumAddedCharactersPerKey.get(key);
+        return val ?? 0;
+    }
+    getAllKeys() {
+        return Array.from(( this._sumAddedCharactersPerKey.keys()));
+    }
+    getRepresentative(key) {
+        return this._representativePerKey.get(key);
+    }
+    getTrackedRanges(reader) {
+        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));
+            return te;
+        }));
+    }
+    isEmpty() {
+        return this._edits.isEmpty();
+    }
+    _getDebugVisualization() {
+        const ranges = this.getTrackedRanges();
+        const txt = this._doc.value.get().value;
+        return {
+            ...{
+                $fileExtension: "text.w"
+            },
+            "value": txt,
+            "decorations": ( ranges.map(r => {
+                return {
+                    range: [r.range.start, r.range.endExclusive],
+                    color: r.source.getColor()
+                };
+            }))
+        };
+    }
+}
+class TrackedEdit {
+    constructor(originalRange, range, sourceKey, source, sourceRepresentative) {
+        this.originalRange = originalRange;
+        this.range = range;
+        this.sourceKey = sourceKey;
+        this.source = source;
+        this.sourceRepresentative = sourceRepresentative;
+    }
+}
+
+export { DocumentEditSourceTracker, TrackedEdit };

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

@@ -0,0 +1,18 @@
+import { IReader, IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ISCMRepository } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm";
+import { ISCMService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm.service";
+export declare class ScmAdapter {
+    private readonly _scmService;
+    private readonly _repos;
+    private readonly _reposChangedSignal;
+    constructor(_scmService: ISCMService);
+    getRepo(uri: URI, reader: IReader | undefined): ScmRepoAdapter | undefined;
+}
+export declare class ScmRepoAdapter {
+    private readonly _repo;
+    readonly headBranchNameObs: IObservable<string | undefined>;
+    readonly headCommitHashObs: IObservable<string | undefined>;
+    constructor(_repo: ISCMRepository);
+    isIgnored(uri: URI): Promise<boolean>;
+}

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

@@ -0,0 +1,44 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { WeakCachedFunction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cache';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ISCMService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm.service';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+let ScmAdapter = class ScmAdapter {
+    constructor(_scmService) {
+        this._scmService = _scmService;
+        this._repos = ( new WeakCachedFunction(repo => ( new ScmRepoAdapter(repo))));
+        this._reposChangedSignal = observableSignalFromEvent(this, Event.any(
+            this._scmService.onDidAddRepository,
+            this._scmService.onDidRemoveRepository
+        ));
+    }
+    getRepo(uri, reader) {
+        this._reposChangedSignal.read(reader);
+        const repo = this._scmService.getRepository(uri);
+        if (!repo) {
+            return undefined;
+        }
+        return this._repos.get(repo);
+    }
+};
+ScmAdapter = ( __decorate([( __param(0, ISCMService))], ScmAdapter));
+class ScmRepoAdapter {
+    constructor(_repo) {
+        this._repo = _repo;
+        this.headBranchNameObs = derived(
+            reader => this._repo.provider.historyProvider.read(reader)?.historyItemRef.read(reader)?.name
+        );
+        this.headCommitHashObs = derived(
+            reader => this._repo.provider.historyProvider.read(reader)?.historyItemRef.read(reader)?.revision
+        );
+    }
+    async isIgnored(uri) {
+        return false;
+    }
+}
+
+export { ScmAdapter, ScmRepoAdapter };

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

@@ -0,0 +1,29 @@
+import { BaseStringEdit, IEditData } 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);
+    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

@@ -0,0 +1,64 @@
+
+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';
+
+class ArcTracker {
+    constructor(_valueBeforeTrackedEdit, trackedEdit) {
+        this._valueBeforeTrackedEdit = _valueBeforeTrackedEdit;
+        this._trackedEdit = trackedEdit.removeCommonSuffixPrefix(_valueBeforeTrackedEdit.getValue());
+        this._updatedTrackedEdit = this._trackedEdit.mapData(() => ( new IsTrackedEditData(true)));
+    }
+    getOriginalCharacterCount() {
+        return sumBy(this._trackedEdit.replacements, e => e.getNewLength());
+    }
+    handleEdits(edit) {
+        const e = edit.mapData(_d => ( new IsTrackedEditData(false)));
+        const composedEdit = this._updatedTrackedEdit.compose(e);
+        this._updatedTrackedEdit = composedEdit;
+    }
+    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
+            })))
+        };
+    }
+    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
+        };
+    }
+    getValues() {
+        return {
+            arc: this.getAcceptedRestrainedCharactersCount(),
+            ...this.getLineCountInfo()
+        };
+    }
+}
+class IsTrackedEditData {
+    constructor(isTrackedEdit) {
+        this.isTrackedEdit = isTrackedEdit;
+    }
+    join(data) {
+        if (this.isTrackedEdit !== data.isTrackedEdit) {
+            return undefined;
+        }
+        return this;
+    }
+}
+
+export { ArcTracker, IsTrackedEditData };

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(13776, "Show Telemetry")),
+                    title: ( localize2(13906, "Show Telemetry")),
                     category: Categories.Developer,
                     f1: true
                 });