@codingame/monaco-vscode-api 1.83.1 → 1.83.3-next.0

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

@@ -0,0 +1,137 @@
+function countMapFrom(values) {
+    const map = ( new Map());
+    for (const value of values) {
+        map.set(value, (map.get(value) ?? 0) + 1);
+    }
+    return map;
+}
+class TfIdfCalculator {
+    constructor() {
+        this.chunkCount = 0;
+        this.chunkOccurrences = ( new Map());
+        this.documents = ( new Map());
+    }
+    calculateScores(query, token) {
+        const embedding = this.computeEmbedding(query);
+        const idfCache = ( new Map());
+        const scores = [];
+        for (const [key, doc] of this.documents) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            for (const chunk of doc.chunks) {
+                const score = this.computeSimilarityScore(chunk, embedding, idfCache);
+                if (score > 0) {
+                    scores.push({ key, score });
+                }
+            }
+        }
+        return scores;
+    }
+    static termFrequencies(input) {
+        return countMapFrom(TfIdfCalculator.splitTerms(input));
+    }
+    static *splitTerms(input) {
+        const normalize = (word) => word.toLowerCase();
+        for (const [word] of input.matchAll(/\b\p{Letter}[\p{Letter}\d]{2,}\b/gu)) {
+            yield normalize(word);
+            const camelParts = word.split(/(?<=[a-z])(?=[A-Z])/g);
+            if (camelParts.length > 1) {
+                for (const part of camelParts) {
+                    if (part.length > 2 && /\p{Letter}{3,}/gu.test(part)) {
+                        yield normalize(part);
+                    }
+                }
+            }
+        }
+    }
+    updateDocuments(documents) {
+        for (const { key } of documents) {
+            this.deleteDocument(key);
+        }
+        for (const doc of documents) {
+            const chunks = [];
+            for (const text of doc.textChunks) {
+                const tf = TfIdfCalculator.termFrequencies(text);
+                for (const term of ( tf.keys())) {
+                    this.chunkOccurrences.set(term, (this.chunkOccurrences.get(term) ?? 0) + 1);
+                }
+                chunks.push({ text, tf });
+            }
+            this.chunkCount += chunks.length;
+            this.documents.set(doc.key, { chunks });
+        }
+        return this;
+    }
+    deleteDocument(key) {
+        const doc = this.documents.get(key);
+        if (!doc) {
+            return;
+        }
+        this.documents.delete(key);
+        this.chunkCount -= doc.chunks.length;
+        for (const chunk of doc.chunks) {
+            for (const term of ( chunk.tf.keys())) {
+                const currentOccurrences = this.chunkOccurrences.get(term);
+                if (typeof currentOccurrences === 'number') {
+                    const newOccurrences = currentOccurrences - 1;
+                    if (newOccurrences <= 0) {
+                        this.chunkOccurrences.delete(term);
+                    }
+                    else {
+                        this.chunkOccurrences.set(term, newOccurrences);
+                    }
+                }
+            }
+        }
+    }
+    computeSimilarityScore(chunk, queryEmbedding, idfCache) {
+        let sum = 0;
+        for (const [term, termTfidf] of Object.entries(queryEmbedding)) {
+            const chunkTf = chunk.tf.get(term);
+            if (!chunkTf) {
+                continue;
+            }
+            let chunkIdf = idfCache.get(term);
+            if (typeof chunkIdf !== 'number') {
+                chunkIdf = this.computeIdf(term);
+                idfCache.set(term, chunkIdf);
+            }
+            const chunkTfidf = chunkTf * chunkIdf;
+            sum += chunkTfidf * termTfidf;
+        }
+        return sum;
+    }
+    computeEmbedding(input) {
+        const tf = TfIdfCalculator.termFrequencies(input);
+        return this.computeTfidf(tf);
+    }
+    computeIdf(term) {
+        const chunkOccurrences = this.chunkOccurrences.get(term) ?? 0;
+        return chunkOccurrences > 0
+            ? Math.log((this.chunkCount + 1) / chunkOccurrences)
+            : 0;
+    }
+    computeTfidf(termFrequencies) {
+        const embedding = Object.create(null);
+        for (const [word, occurrences] of termFrequencies) {
+            const idf = this.computeIdf(word);
+            if (idf > 0) {
+                embedding[word] = occurrences * idf;
+            }
+        }
+        return embedding;
+    }
+}
+function normalizeTfIdfScores(scores) {
+    const result = scores.slice(0);
+    result.sort((a, b) => b.score - a.score);
+    const max = result[0]?.score ?? 0;
+    if (max > 0) {
+        for (const score of result) {
+            score.score /= max;
+        }
+    }
+    return result;
+}
+export { TfIdfCalculator, normalizeTfIdfScores };

package/vscode/src/vs/editor/contrib/quickAccess/browser/commandsQuickAccess.js

@@ -0,0 +1,23 @@
+import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { AbstractCommandsQuickAccessProvider } from '../../../../platform/quickinput/browser/commandsQuickAccess.js';
+class AbstractEditorCommandsQuickAccessProvider extends AbstractCommandsQuickAccessProvider {
+    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
+        super(options, instantiationService, keybindingService, commandService, telemetryService, dialogService);
+    }
+    getCodeEditorCommandPicks() {
+        const activeTextEditorControl = this.activeTextEditorControl;
+        if (!activeTextEditorControl) {
+            return [];
+        }
+        const editorCommandPicks = [];
+        for (const editorAction of activeTextEditorControl.getSupportedActions()) {
+            editorCommandPicks.push({
+                commandId: editorAction.id,
+                commandAlias: editorAction.alias,
+                label: stripIcons(editorAction.label) || editorAction.id,
+            });
+        }
+        return editorCommandPicks;
+    }
+}
+export { AbstractEditorCommandsQuickAccessProvider };

package/vscode/src/vs/editor/contrib/quickAccess/browser/editorNavigationQuickAccess.js

@@ -0,0 +1,115 @@
+import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { MutableDisposable, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { getCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { OverviewRulerLane } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { overviewRulerRangeHighlight } from 'monaco-editor/esm/vs/editor/common/core/editorColorRegistry.js';
+import { themeColorFromId } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { status } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+class AbstractEditorNavigationQuickAccessProvider {
+    constructor(options) {
+        this.options = options;
+        this.rangeHighlightDecorationId = undefined;
+    }
+    provide(picker, token) {
+        const disposables = ( new DisposableStore());
+        picker.canAcceptInBackground = !!this.options?.canAcceptInBackground;
+        picker.matchOnLabel = picker.matchOnDescription = picker.matchOnDetail = picker.sortByLabel = false;
+        const pickerDisposable = disposables.add(( new MutableDisposable()));
+        pickerDisposable.value = this.doProvide(picker, token);
+        disposables.add(this.onDidActiveTextEditorControlChange(() => {
+            pickerDisposable.value = undefined;
+            pickerDisposable.value = this.doProvide(picker, token);
+        }));
+        return disposables;
+    }
+    doProvide(picker, token) {
+        const disposables = ( new DisposableStore());
+        const editor = this.activeTextEditorControl;
+        if (editor && this.canProvideWithTextEditor(editor)) {
+            const context = { editor };
+            const codeEditor = getCodeEditor(editor);
+            if (codeEditor) {
+                let lastKnownEditorViewState = editor.saveViewState() ?? undefined;
+                disposables.add(codeEditor.onDidChangeCursorPosition(() => {
+                    lastKnownEditorViewState = editor.saveViewState() ?? undefined;
+                }));
+                context.restoreViewState = () => {
+                    if (lastKnownEditorViewState && editor === this.activeTextEditorControl) {
+                        editor.restoreViewState(lastKnownEditorViewState);
+                    }
+                };
+                disposables.add(createSingleCallFunction(token.onCancellationRequested)(() => context.restoreViewState?.()));
+            }
+            disposables.add(toDisposable(() => this.clearDecorations(editor)));
+            disposables.add(this.provideWithTextEditor(context, picker, token));
+        }
+        else {
+            disposables.add(this.provideWithoutTextEditor(picker, token));
+        }
+        return disposables;
+    }
+    canProvideWithTextEditor(editor) {
+        return true;
+    }
+    gotoLocation({ editor }, options) {
+        editor.setSelection(options.range);
+        editor.revealRangeInCenter(options.range, 0 );
+        if (!options.preserveFocus) {
+            editor.focus();
+        }
+        const model = editor.getModel();
+        if (model && 'getLineContent' in model) {
+            status(`${model.getLineContent(options.range.startLineNumber)}`);
+        }
+    }
+    getModel(editor) {
+        return isDiffEditor(editor) ?
+            editor.getModel()?.modified :
+            editor.getModel();
+    }
+    addDecorations(editor, range) {
+        editor.changeDecorations(changeAccessor => {
+            const deleteDecorations = [];
+            if (this.rangeHighlightDecorationId) {
+                deleteDecorations.push(this.rangeHighlightDecorationId.overviewRulerDecorationId);
+                deleteDecorations.push(this.rangeHighlightDecorationId.rangeHighlightId);
+                this.rangeHighlightDecorationId = undefined;
+            }
+            const newDecorations = [
+                {
+                    range,
+                    options: {
+                        description: 'quick-access-range-highlight',
+                        className: 'rangeHighlight',
+                        isWholeLine: true
+                    }
+                },
+                {
+                    range,
+                    options: {
+                        description: 'quick-access-range-highlight-overview',
+                        overviewRuler: {
+                            color: themeColorFromId(overviewRulerRangeHighlight),
+                            position: OverviewRulerLane.Full
+                        }
+                    }
+                }
+            ];
+            const [rangeHighlightId, overviewRulerDecorationId] = changeAccessor.deltaDecorations(deleteDecorations, newDecorations);
+            this.rangeHighlightDecorationId = { rangeHighlightId, overviewRulerDecorationId };
+        });
+    }
+    clearDecorations(editor) {
+        const rangeHighlightDecorationId = this.rangeHighlightDecorationId;
+        if (rangeHighlightDecorationId) {
+            editor.changeDecorations(changeAccessor => {
+                changeAccessor.deltaDecorations([
+                    rangeHighlightDecorationId.overviewRulerDecorationId,
+                    rangeHighlightDecorationId.rangeHighlightId
+                ], []);
+            });
+            this.rangeHighlightDecorationId = undefined;
+        }
+    }
+}
+export { AbstractEditorNavigationQuickAccessProvider };

package/vscode/src/vs/editor/contrib/quickAccess/browser/gotoLineQuickAccess.js

@@ -0,0 +1,112 @@
+import { Disposable, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { AbstractEditorNavigationQuickAccessProvider } from './editorNavigationQuickAccess.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+class AbstractGotoLineQuickAccessProvider extends AbstractEditorNavigationQuickAccessProvider {
+    static { this.PREFIX = ':'; }
+    constructor() {
+        super({ canAcceptInBackground: true });
+    }
+    provideWithoutTextEditor(picker) {
+        const label = localizeWithPath('vs/editor/contrib/quickAccess/browser/gotoLineQuickAccess', 'cannotRunGotoLine', "Open a text editor first to go to a line.");
+        picker.items = [{ label }];
+        picker.ariaLabel = label;
+        return Disposable.None;
+    }
+    provideWithTextEditor(context, picker, token) {
+        const editor = context.editor;
+        const disposables = ( new DisposableStore());
+        disposables.add(picker.onDidAccept(event => {
+            const [item] = picker.selectedItems;
+            if (item) {
+                if (!this.isValidLineNumber(editor, item.lineNumber)) {
+                    return;
+                }
+                this.gotoLocation(context, { range: this.toRange(item.lineNumber, item.column), keyMods: picker.keyMods, preserveFocus: event.inBackground });
+                if (!event.inBackground) {
+                    picker.hide();
+                }
+            }
+        }));
+        const updatePickerAndEditor = () => {
+            const position = this.parsePosition(editor, picker.value.trim().substr(AbstractGotoLineQuickAccessProvider.PREFIX.length));
+            const label = this.getPickLabel(editor, position.lineNumber, position.column);
+            picker.items = [{
+                    lineNumber: position.lineNumber,
+                    column: position.column,
+                    label
+                }];
+            picker.ariaLabel = label;
+            if (!this.isValidLineNumber(editor, position.lineNumber)) {
+                this.clearDecorations(editor);
+                return;
+            }
+            const range = this.toRange(position.lineNumber, position.column);
+            editor.revealRangeInCenter(range, 0 );
+            this.addDecorations(editor, range);
+        };
+        updatePickerAndEditor();
+        disposables.add(picker.onDidChangeValue(() => updatePickerAndEditor()));
+        const codeEditor = getCodeEditor(editor);
+        if (codeEditor) {
+            const options = codeEditor.getOptions();
+            const lineNumbers = options.get(67 );
+            if (lineNumbers.renderType === 2 ) {
+                codeEditor.updateOptions({ lineNumbers: 'on' });
+                disposables.add(toDisposable(() => codeEditor.updateOptions({ lineNumbers: 'relative' })));
+            }
+        }
+        return disposables;
+    }
+    toRange(lineNumber = 1, column = 1) {
+        return {
+            startLineNumber: lineNumber,
+            startColumn: column,
+            endLineNumber: lineNumber,
+            endColumn: column
+        };
+    }
+    parsePosition(editor, value) {
+        const numbers = ( value.split(/,|:|#/).map(part => parseInt(part, 10))).filter(part => !isNaN(part));
+        const endLine = this.lineCount(editor) + 1;
+        return {
+            lineNumber: numbers[0] > 0 ? numbers[0] : endLine + numbers[0],
+            column: numbers[1]
+        };
+    }
+    getPickLabel(editor, lineNumber, column) {
+        if (this.isValidLineNumber(editor, lineNumber)) {
+            if (this.isValidColumn(editor, lineNumber, column)) {
+                return localizeWithPath('vs/editor/contrib/quickAccess/browser/gotoLineQuickAccess', 'gotoLineColumnLabel', "Go to line {0} and character {1}.", lineNumber, column);
+            }
+            return localizeWithPath('vs/editor/contrib/quickAccess/browser/gotoLineQuickAccess', 'gotoLineLabel', "Go to line {0}.", lineNumber);
+        }
+        const position = editor.getPosition() || { lineNumber: 1, column: 1 };
+        const lineCount = this.lineCount(editor);
+        if (lineCount > 1) {
+            return localizeWithPath('vs/editor/contrib/quickAccess/browser/gotoLineQuickAccess', 'gotoLineLabelEmptyWithLimit', "Current Line: {0}, Character: {1}. Type a line number between 1 and {2} to navigate to.", position.lineNumber, position.column, lineCount);
+        }
+        return localizeWithPath('vs/editor/contrib/quickAccess/browser/gotoLineQuickAccess', 'gotoLineLabelEmpty', "Current Line: {0}, Character: {1}. Type a line number to navigate to.", position.lineNumber, position.column);
+    }
+    isValidLineNumber(editor, lineNumber) {
+        if (!lineNumber || typeof lineNumber !== 'number') {
+            return false;
+        }
+        return lineNumber > 0 && lineNumber <= this.lineCount(editor);
+    }
+    isValidColumn(editor, lineNumber, column) {
+        if (!column || typeof column !== 'number') {
+            return false;
+        }
+        const model = this.getModel(editor);
+        if (!model) {
+            return false;
+        }
+        const positionCandidate = { lineNumber, column };
+        return model.validatePosition(positionCandidate).equals(positionCandidate);
+    }
+    lineCount(editor) {
+        return this.getModel(editor)?.getLineCount() ?? 0;
+    }
+}
+export { AbstractGotoLineQuickAccessProvider };