@codingame/monaco-vscode-base-service-override 25.1.2 → 26.0.0

package/index.js

@@ -39,6 +39,8 @@ import { MarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/
 import { IUserAttentionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userAttention/common/userAttentionService.service';
 import { UserAttentionService } from './vscode/src/vs/workbench/services/userAttention/browser/userAttentionBrowser.js';
 import { EditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/editorWorkerService';
+import { IRenameSymbolTrackerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/renameSymbolTrackerService.service';
+import { RenameSymbolTrackerService } from './vscode/src/vs/workbench/contrib/inlineCompletions/browser/renameSymbolTrackerService.js';
 
 let BrowserPathServiceOverride = class BrowserPathServiceOverride extends AbstractPathService {
     constructor(remoteAgentService, environmentService, contextService) {
@@ -67,7 +69,8 @@ function getServiceOverride() {
         [IEditorWorkerService.toString()]: new SyncDescriptor(EditorWorkerService, [], true),
         [IInlineCompletionsUnificationService.toString()]: new SyncDescriptor(InlineCompletionsUnificationImpl, [], true),
         [IMarkdownRendererService.toString()]: new SyncDescriptor(MarkdownRendererService, [], true),
-        [IUserAttentionService.toString()]: new SyncDescriptor(UserAttentionService, [], true)
+        [IUserAttentionService.toString()]: new SyncDescriptor(UserAttentionService, [], true),
+        [IRenameSymbolTrackerService.toString()]: new SyncDescriptor(RenameSymbolTrackerService, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-base-service-override",
-  "version": "25.1.2",
+  "version": "26.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - base service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "25.1.2"
+    "@codingame/monaco-vscode-api": "26.0.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/base/common/observableInternal/experimental/time.js

@@ -16,8 +16,7 @@ class TotalTrueTimeObservable extends Disposable {
             const isTrue = this.value.read(reader);
             if (isTrue) {
                 this._startTime = Date.now();
-            }
-            else {
+            } else {
                 if (this._startTime !== undefined) {
                     const delta = Date.now() - this._startTime;
                     this._totalTime += delta;
@@ -65,7 +64,7 @@ class TotalTrueTimeObservable extends Disposable {
     }
 }
 function wasTrueRecently(obs, timeMs, store) {
-    const result = observableValue('wasTrueRecently', false);
+    const result = observableValue("wasTrueRecently", false);
     let timeout;
     store.add(autorun(reader => {
         const value = obs.read(reader);
@@ -75,8 +74,7 @@ function wasTrueRecently(obs, timeMs, store) {
                 clearTimeout(timeout);
                 timeout = undefined;
             }
-        }
-        else {
+        } else {
             timeout = setTimeout(() => {
                 result.set(false, undefined);
                 timeout = undefined;

package/vscode/src/vs/base/parts/request/common/requestImpl.js

@@ -9,70 +9,68 @@ async function request(options, token, isOnline) {
     }
     const cancellation = ( new AbortController());
     const disposable = token.onCancellationRequested(() => cancellation.abort());
-    const signal = options.timeout ? AbortSignal.any([
-        cancellation.signal,
-        AbortSignal.timeout(options.timeout),
-    ]) : cancellation.signal;
+    const signal = options.timeout ? AbortSignal.any([cancellation.signal, AbortSignal.timeout(options.timeout)]) : cancellation.signal;
     try {
         const fetchInit = {
-            method: options.type || 'GET',
+            method: options.type || "GET",
             headers: getRequestHeaders(options),
             body: options.data,
             signal
         };
         if (options.disableCache) {
-            fetchInit.cache = 'no-store';
+            fetchInit.cache = "no-store";
         }
-        const res = await fetch(options.url || '', fetchInit);
+        const res = await fetch(options.url || "", fetchInit);
         return {
             res: {
                 statusCode: res.status,
-                headers: getResponseHeaders(res),
+                headers: getResponseHeaders(res)
             },
-            stream: bufferToStream(VSBuffer.wrap(( new Uint8Array(await res.arrayBuffer())))),
+            stream: bufferToStream(VSBuffer.wrap(( new Uint8Array(await res.arrayBuffer()))))
         };
-    }
-    catch (err) {
+    } catch (err) {
         if (isOnline && !isOnline()) {
             throw ( new OfflineError());
         }
-        if (err?.name === 'AbortError') {
+        if (err?.name === "AbortError") {
             throw canceled();
         }
-        if (err?.name === 'TimeoutError') {
+        if (err?.name === "TimeoutError") {
             throw ( new Error(`Fetch timeout: ${options.timeout}ms`));
         }
         throw err;
-    }
-    finally {
+    } finally {
         disposable.dispose();
     }
 }
 function getRequestHeaders(options) {
     if (options.headers || options.user || options.password || options.proxyAuthorization) {
         const headers = ( new Headers());
-        outer: for (const k in options.headers) {
+        outer:
+        for (const k in options.headers) {
             switch (k.toLowerCase()) {
-                case 'user-agent':
-                case 'accept-encoding':
-                case 'content-length':
-                    continue outer;
+            case "user-agent":
+            case "accept-encoding":
+            case "content-length":
+                continue outer;
             }
             const header = options.headers[k];
-            if (typeof header === 'string') {
+            if (typeof header === "string") {
                 headers.set(k, header);
-            }
-            else if (Array.isArray(header)) {
+            } else if (Array.isArray(header)) {
                 for (const h of header) {
                     headers.append(k, h);
                 }
             }
         }
         if (options.user || options.password) {
-            headers.set('Authorization', 'Basic ' + btoa(`${options.user || ''}:${options.password || ''}`));
+            headers.set(
+                "Authorization",
+                "Basic " + btoa(`${options.user || ""}:${options.password || ""}`)
+            );
         }
         if (options.proxyAuthorization) {
-            headers.set('Proxy-Authorization', options.proxyAuthorization);
+            headers.set("Proxy-Authorization", options.proxyAuthorization);
         }
         return headers;
     }
@@ -84,12 +82,10 @@ function getResponseHeaders(res) {
         if (headers[key]) {
             if (Array.isArray(headers[key])) {
                 headers[key].push(value);
-            }
-            else {
+            } else {
                 headers[key] = [headers[key], value];
             }
-        }
-        else {
+        } else {
             headers[key] = value;
         }
     });

package/vscode/src/vs/platform/download/common/downloadService.js

@@ -16,20 +16,19 @@ let DownloadService = class DownloadService {
             await this.fileService.copy(resource, target);
             return;
         }
-        const options = { type: 'GET', url: ( resource.toString(true)) };
+        const options = {
+            type: "GET",
+            url: ( resource.toString(true))
+        };
         const context = await this.requestService.request(options, cancellationToken);
         if (context.res.statusCode === 200) {
             await this.fileService.writeFile(target, context.stream);
-        }
-        else {
+        } else {
             const message = await asTextOrError(context);
             throw ( new Error(`Expected 200, got back ${context.res.statusCode} instead.\n\n${message}`));
         }
     }
 };
-DownloadService = ( __decorate([
-    ( __param(0, IRequestService)),
-    ( __param(1, IFileService))
-], DownloadService));
+DownloadService = ( __decorate([( __param(0, IRequestService)), ( __param(1, IFileService))], DownloadService));
 
 export { DownloadService };

package/vscode/src/vs/platform/request/common/requestIpc.js

@@ -7,20 +7,23 @@ class RequestChannelClient {
         this.channel = channel;
     }
     async request(options, token) {
-        const [res, buffer] = await this.channel.call('request', [options], token);
-        return { res, stream: bufferToStream(buffer) };
+        const [res, buffer] = await this.channel.call("request", [options], token);
+        return {
+            res,
+            stream: bufferToStream(buffer)
+        };
     }
     async resolveProxy(url) {
-        return this.channel.call('resolveProxy', [url]);
+        return this.channel.call("resolveProxy", [url]);
     }
     async lookupAuthorization(authInfo) {
-        return this.channel.call('lookupAuthorization', [authInfo]);
+        return this.channel.call("lookupAuthorization", [authInfo]);
     }
     async lookupKerberosAuthorization(url) {
-        return this.channel.call('lookupKerberosAuthorization', [url]);
+        return this.channel.call("lookupKerberosAuthorization", [url]);
     }
     async loadCertificates() {
-        return this.channel.call('loadCertificates');
+        return this.channel.call("loadCertificates");
     }
 }
 

package/vscode/src/vs/workbench/contrib/inlineCompletions/browser/renameSymbolTrackerService.d.ts

@@ -0,0 +1,18 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
+import { type ITrackedWord } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/renameSymbolTrackerService";
+import { IRenameSymbolTrackerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/renameSymbolTrackerService.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+export declare class RenameSymbolTrackerService extends Disposable implements IRenameSymbolTrackerService {
+    private readonly _codeEditorService;
+    private readonly _modelService;
+    _serviceBrand: undefined;
+    private readonly _modelTrackers;
+    private readonly _editorFocusTrackingDisposables;
+    private readonly _focusedModelTracker;
+    readonly trackedWord: IObservable<ITrackedWord | undefined>;
+    constructor(_codeEditorService: ICodeEditorService, _modelService: IModelService);
+    private _setupEditorTracking;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/inlineCompletions/browser/renameSymbolTrackerService.js

@@ -0,0 +1,240 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { observableCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/observableCodeEditor';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { StandardTokenType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/encodedTokenAttributes';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+function isUserEdit(event) {
+    if (event.isUndoing || event.isRedoing || event.isFlush) {
+        return false;
+    }
+    for (const source of event.detailedReasons) {
+        if (!isUserEditSource(source)) {
+            return false;
+        }
+    }
+    return event.detailedReasons.length > 0;
+}
+const userEditKinds = ( new Set([
+    "type",
+    "paste",
+    "cut",
+    "executeCommands",
+    "executeCommand",
+    "compositionType",
+    "compositionEnd"
+]));
+function isUserEditSource(source) {
+    const metadata = source.metadata;
+    if (metadata.source !== "cursor") {
+        return false;
+    }
+    const kind = metadata.kind;
+    return ( userEditKinds.has(kind));
+}
+class ModelSymbolRenameTracker extends Disposable {
+    constructor(_model) {
+        super();
+        this._model = _model;
+        this._trackedWord = observableValue(this, undefined);
+        this.trackedWord = this._trackedWord;
+        this._capturedWord = undefined;
+        this._lastWordBeforeEdit = undefined;
+        this._pendingContentChange = false;
+        this._lastCursorPosition = undefined;
+        this._register(this._model.onDidChangeContent(e => {
+            if (!isUserEdit(e)) {
+                const position = this._lastCursorPosition;
+                this.reset();
+                if (position !== undefined) {
+                    this.updateCursorPosition(position);
+                }
+                return;
+            }
+            this._pendingContentChange = true;
+        }));
+    }
+    updateCursorPosition(position) {
+        this._lastCursorPosition = position;
+        const wordAtPosition = this._model.getWordAtPosition(position);
+        if (!wordAtPosition) {
+            this._lastWordBeforeEdit = undefined;
+            this._pendingContentChange = false;
+            return;
+        }
+        if (this._isPositionInComment(position)) {
+            this._lastWordBeforeEdit = undefined;
+            this._pendingContentChange = false;
+            return;
+        }
+        const currentWord = {
+            word: wordAtPosition.word,
+            range: ( new Range(
+                position.lineNumber,
+                wordAtPosition.startColumn,
+                position.lineNumber,
+                wordAtPosition.endColumn
+            )),
+            position
+        };
+        const contentChanged = this._pendingContentChange;
+        this._pendingContentChange = false;
+        if (!contentChanged) {
+            this._lastWordBeforeEdit = currentWord;
+            return;
+        }
+        if (!this._capturedWord) {
+            const originalWord = this._lastWordBeforeEdit ?? currentWord;
+            this._capturedWord = {
+                ...originalWord
+            };
+            this._trackedWord.set({
+                model: this._model,
+                originalWord: originalWord.word,
+                originalPosition: originalWord.position,
+                originalRange: originalWord.range,
+                currentWord: currentWord.word,
+                currentRange: currentWord.range
+            }, undefined);
+            this._lastWordBeforeEdit = currentWord;
+            return;
+        }
+        const capturedWord = this._capturedWord;
+        const isOnSameWord = this._rangesOverlap(capturedWord.range, currentWord.range) || this._isAdjacent(capturedWord.range, currentWord.range);
+        if (isOnSameWord) {
+            this._trackedWord.set({
+                model: this._model,
+                originalWord: capturedWord.word,
+                originalPosition: capturedWord.position,
+                originalRange: capturedWord.range,
+                currentWord: currentWord.word,
+                currentRange: currentWord.range
+            }, undefined);
+        } else {
+            const originalWord = this._lastWordBeforeEdit ?? currentWord;
+            this._capturedWord = {
+                ...originalWord
+            };
+            this._trackedWord.set({
+                model: this._model,
+                originalWord: originalWord.word,
+                originalPosition: originalWord.position,
+                originalRange: originalWord.range,
+                currentWord: currentWord.word,
+                currentRange: currentWord.range
+            }, undefined);
+        }
+        this._lastWordBeforeEdit = currentWord;
+    }
+    reset() {
+        this._trackedWord.set(undefined, undefined);
+        this._capturedWord = undefined;
+        this._lastWordBeforeEdit = undefined;
+        this._pendingContentChange = false;
+        this._lastCursorPosition = undefined;
+    }
+    _isPositionInComment(position) {
+        this._model.tokenization.tokenizeIfCheap(position.lineNumber);
+        const tokens = this._model.tokenization.getLineTokens(position.lineNumber);
+        const tokenIndex = tokens.findTokenIndexAtOffset(position.column - 1);
+        const tokenType = tokens.getStandardTokenType(tokenIndex);
+        return tokenType === StandardTokenType.Comment;
+    }
+    _rangesOverlap(a, b) {
+        if (a.startLineNumber !== b.startLineNumber) {
+            return false;
+        }
+        return !(a.endColumn < b.startColumn || b.endColumn < a.startColumn);
+    }
+    _isAdjacent(a, b) {
+        if (a.startLineNumber !== b.startLineNumber) {
+            return false;
+        }
+        return a.endColumn === b.startColumn || b.endColumn === a.startColumn;
+    }
+}
+let RenameSymbolTrackerService = class RenameSymbolTrackerService extends Disposable {
+    constructor(_codeEditorService, _modelService) {
+        super();
+        this._codeEditorService = _codeEditorService;
+        this._modelService = _modelService;
+        this._modelTrackers = ( new Map());
+        this._editorFocusTrackingDisposables = ( new Map());
+        this._focusedModelTracker = observableValue(this, undefined);
+        this.trackedWord = derived(this, reader => {
+            const tracker = this._focusedModelTracker.read(reader);
+            return tracker?.trackedWord.read(reader);
+        });
+        for (const editor of this._codeEditorService.listCodeEditors()) {
+            this._setupEditorTracking(editor);
+        }
+        this._register(this._codeEditorService.onCodeEditorAdd(editor => {
+            this._setupEditorTracking(editor);
+        }));
+        this._register(this._codeEditorService.onCodeEditorRemove(editor => {
+            const focusDisposable = this._editorFocusTrackingDisposables.get(editor);
+            if (focusDisposable) {
+                focusDisposable.dispose();
+                this._editorFocusTrackingDisposables.delete(editor);
+            }
+        }));
+        this._register(this._modelService.onModelRemoved(model => {
+            const tracker = this._modelTrackers.get(model);
+            if (tracker) {
+                tracker.dispose();
+                this._modelTrackers.delete(model);
+            }
+        }));
+    }
+    _setupEditorTracking(editor) {
+        if (editor.isSimpleWidget) {
+            return;
+        }
+        if (!( this._editorFocusTrackingDisposables.has(editor))) {
+            const obsEditor = observableCodeEditor(editor);
+            const focusDisposable = autorun(reader => {
+                const isFocused = obsEditor.isFocused.read(reader);
+                const model = obsEditor.model.read(reader);
+                const cursorPosition = obsEditor.cursorPosition.read(reader);
+                if (!isFocused || !model) {
+                    return;
+                }
+                let tracker = this._modelTrackers.get(model);
+                if (!tracker) {
+                    tracker = ( new ModelSymbolRenameTracker(model));
+                    this._modelTrackers.set(model, tracker);
+                }
+                if (this._focusedModelTracker.read(undefined) !== tracker) {
+                    this._focusedModelTracker.set(tracker, undefined);
+                }
+                if (cursorPosition) {
+                    tracker.updateCursorPosition(cursorPosition);
+                }
+            });
+            this._editorFocusTrackingDisposables.set(editor, focusDisposable);
+        }
+    }
+    dispose() {
+        for (const tracker of ( this._modelTrackers.values())) {
+            tracker.dispose();
+        }
+        this._modelTrackers.clear();
+        for (const disposable of ( this._editorFocusTrackingDisposables.values())) {
+            disposable.dispose();
+        }
+        this._editorFocusTrackingDisposables.clear();
+        super.dispose();
+    }
+};
+RenameSymbolTrackerService = ( __decorate([( __param(0, ICodeEditorService)), ( __param(1, IModelService))], RenameSymbolTrackerService));
+
+export { RenameSymbolTrackerService };

package/vscode/src/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -16,7 +16,12 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/ext
 import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
 
 let JSONEditingService = class JSONEditingService {
-    constructor(fileService, textModelResolverService, textFileService, filesConfigurationService) {
+    constructor(
+        fileService,
+        textModelResolverService,
+        textFileService,
+        filesConfigurationService
+    ) {
         this.fileService = fileService;
         this.textModelResolverService = textModelResolverService;
         this.textFileService = textFileService;
@@ -30,8 +35,7 @@ let JSONEditingService = class JSONEditingService {
         const reference = await this.resolveAndValidate(resource, true);
         try {
             await this.writeToBuffer(reference.object.textEditorModel, values);
-        }
-        finally {
+        } finally {
             reference.dispose();
         }
     }
@@ -47,8 +51,7 @@ let JSONEditingService = class JSONEditingService {
             if (hasEdits) {
                 return this.textFileService.save(model.uri);
             }
-        }
-        finally {
+        } finally {
             disposable?.dispose();
         }
         return undefined;
@@ -76,29 +79,44 @@ let JSONEditingService = class JSONEditingService {
         return false;
     }
     getEdits(model, configurationValue) {
-        const { tabSize, insertSpaces } = model.getOptions();
+        const {
+            tabSize,
+            insertSpaces
+        } = model.getOptions();
         const eol = model.getEOL();
-        const { path, value } = configurationValue;
+        const {
+            path,
+            value
+        } = configurationValue;
         if (!path.length) {
-            const content = JSON.stringify(value, null, insertSpaces ? ' '.repeat(tabSize) : '\t');
+            const content = JSON.stringify(value, null, insertSpaces ? " ".repeat(tabSize) : "\t");
             return [{
-                    content,
-                    length: content.length,
-                    offset: 0
-                }];
+                content,
+                length: content.length,
+                offset: 0
+            }];
         }
-        return setProperty(model.getValue(), path, value, { tabSize, insertSpaces, eol });
+        return setProperty(model.getValue(), path, value, {
+            tabSize,
+            insertSpaces,
+            eol
+        });
     }
     async resolveModelReference(resource) {
         const exists = await this.fileService.exists(resource);
         if (!exists) {
-            await this.textFileService.write(resource, '{}', { encoding: 'utf8' });
+            await this.textFileService.write(resource, "{}", {
+                encoding: "utf8"
+            });
         }
         return this.textModelResolverService.createModelReference(resource);
     }
     hasParseErrors(model) {
         const parseErrors = [];
-        parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
+        parse(model.getValue(), parseErrors, {
+            allowTrailingComma: true,
+            allowEmptyContent: true
+        });
         return parseErrors.length > 0;
     }
     async resolveAndValidate(resource, checkDirty) {
@@ -116,20 +134,16 @@ let JSONEditingService = class JSONEditingService {
     }
     toErrorMessage(error) {
         switch (error) {
-            case JSONEditingErrorCode.ERROR_INVALID_FILE: {
+        case JSONEditingErrorCode.ERROR_INVALID_FILE:
+            {
                 return localize(
-                    13800,
+                    14187,
                     "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again."
                 );
             }
         }
     }
 };
-JSONEditingService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, ITextModelService)),
-    ( __param(2, ITextFileService)),
-    ( __param(3, IFilesConfigurationService))
-], JSONEditingService));
+JSONEditingService = ( __decorate([( __param(0, IFileService)), ( __param(1, ITextModelService)), ( __param(2, ITextFileService)), ( __param(3, IFilesConfigurationService))], JSONEditingService));
 
 export { JSONEditingService };