@codingame/monaco-vscode-api 15.0.0 → 15.0.2

package/vscode/src/vs/editor/contrib/gotoError/browser/markerNavigationService.js

@@ -0,0 +1,215 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { equals, binarySearch2 } from '../../../../base/common/arrays.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { LinkedList } from '../../../../base/common/linkedList.js';
+import { compare } from '../../../../base/common/strings.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Range } from '../../../common/core/range.js';
+import '../../../../platform/instantiation/common/extensions.js';
+import { MarkerSeverity } from '../../../../platform/markers/common/markers.js';
+import { IMarkerService } from '../../../../platform/markers/common/markers.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+
+class MarkerCoordinate {
+    constructor(marker, index, total) {
+        this.marker = marker;
+        this.index = index;
+        this.total = total;
+    }
+}
+let MarkerList = class MarkerList {
+    constructor(resourceFilter, _markerService, _configService) {
+        this._markerService = _markerService;
+        this._configService = _configService;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._dispoables = ( new DisposableStore());
+        this._markers = [];
+        this._nextIdx = -1;
+        if (URI.isUri(resourceFilter)) {
+            this._resourceFilter = uri => ( uri.toString()) === ( resourceFilter.toString());
+        }
+        else if (resourceFilter) {
+            this._resourceFilter = resourceFilter;
+        }
+        const compareOrder = this._configService.getValue('problems.sortOrder');
+        const compareMarker = (a, b) => {
+            let res = compare(( a.resource.toString()), ( b.resource.toString()));
+            if (res === 0) {
+                if (compareOrder === 'position') {
+                    res = Range.compareRangesUsingStarts(a, b) || MarkerSeverity.compare(a.severity, b.severity);
+                }
+                else {
+                    res = MarkerSeverity.compare(a.severity, b.severity) || Range.compareRangesUsingStarts(a, b);
+                }
+            }
+            return res;
+        };
+        const updateMarker = () => {
+            let newMarkers = this._markerService.read({
+                resource: URI.isUri(resourceFilter) ? resourceFilter : undefined,
+                severities: MarkerSeverity.Error | MarkerSeverity.Warning | MarkerSeverity.Info
+            });
+            if (typeof resourceFilter === 'function') {
+                newMarkers = newMarkers.filter(m => this._resourceFilter(m.resource));
+            }
+            newMarkers.sort(compareMarker);
+            if (equals(newMarkers, this._markers, (a, b) => ( a.resource.toString()) === ( b.resource.toString())
+                && a.startLineNumber === b.startLineNumber
+                && a.startColumn === b.startColumn
+                && a.endLineNumber === b.endLineNumber
+                && a.endColumn === b.endColumn
+                && a.severity === b.severity
+                && a.message === b.message)) {
+                return false;
+            }
+            this._markers = newMarkers;
+            return true;
+        };
+        updateMarker();
+        this._dispoables.add(_markerService.onMarkerChanged(uris => {
+            if (!this._resourceFilter || ( uris.some(uri => this._resourceFilter(uri)))) {
+                if (updateMarker()) {
+                    this._nextIdx = -1;
+                    this._onDidChange.fire();
+                }
+            }
+        }));
+    }
+    dispose() {
+        this._dispoables.dispose();
+        this._onDidChange.dispose();
+    }
+    matches(uri) {
+        if (!this._resourceFilter && !uri) {
+            return true;
+        }
+        if (!this._resourceFilter || !uri) {
+            return false;
+        }
+        return this._resourceFilter(uri);
+    }
+    get selected() {
+        const marker = this._markers[this._nextIdx];
+        return marker && ( new MarkerCoordinate(marker, this._nextIdx + 1, this._markers.length));
+    }
+    _initIdx(model, position, fwd) {
+        let idx = this._markers.findIndex(marker => isEqual(marker.resource, model.uri));
+        if (idx < 0) {
+            idx = binarySearch2(this._markers.length, idx => compare(( this._markers[idx].resource.toString()), ( model.uri.toString())));
+            if (idx < 0) {
+                idx = ~idx;
+            }
+            if (fwd) {
+                this._nextIdx = idx;
+            }
+            else {
+                this._nextIdx = (this._markers.length + idx - 1) % this._markers.length;
+            }
+        }
+        else {
+            let found = false;
+            let wentPast = false;
+            for (let i = idx; i < this._markers.length; i++) {
+                let range = Range.lift(this._markers[i]);
+                if (range.isEmpty()) {
+                    const word = model.getWordAtPosition(range.getStartPosition());
+                    if (word) {
+                        range = ( new Range(
+                            range.startLineNumber,
+                            word.startColumn,
+                            range.startLineNumber,
+                            word.endColumn
+                        ));
+                    }
+                }
+                if (position && (range.containsPosition(position) || position.isBeforeOrEqual(range.getStartPosition()))) {
+                    this._nextIdx = i;
+                    found = true;
+                    wentPast = !range.containsPosition(position);
+                    break;
+                }
+                if (( this._markers[i].resource.toString()) !== ( model.uri.toString())) {
+                    break;
+                }
+            }
+            if (!found) {
+                this._nextIdx = fwd ? 0 : this._markers.length - 1;
+            }
+            else if (wentPast && !fwd) {
+                this._nextIdx -= 1;
+            }
+        }
+        if (this._nextIdx < 0) {
+            this._nextIdx = this._markers.length - 1;
+        }
+    }
+    resetIndex() {
+        this._nextIdx = -1;
+    }
+    move(fwd, model, position) {
+        if (this._markers.length === 0) {
+            return false;
+        }
+        const oldIdx = this._nextIdx;
+        if (this._nextIdx === -1) {
+            this._initIdx(model, position, fwd);
+        }
+        else if (fwd) {
+            this._nextIdx = (this._nextIdx + 1) % this._markers.length;
+        }
+        else if (!fwd) {
+            this._nextIdx = (this._nextIdx - 1 + this._markers.length) % this._markers.length;
+        }
+        if (oldIdx !== this._nextIdx) {
+            return true;
+        }
+        return false;
+    }
+    find(uri, position) {
+        let idx = this._markers.findIndex(marker => ( marker.resource.toString()) === ( uri.toString()));
+        if (idx < 0) {
+            return undefined;
+        }
+        for (; idx < this._markers.length; idx++) {
+            if (Range.containsPosition(this._markers[idx], position)) {
+                return ( new MarkerCoordinate(this._markers[idx], idx + 1, this._markers.length));
+            }
+        }
+        return undefined;
+    }
+};
+MarkerList = ( __decorate([
+    ( __param(1, IMarkerService)),
+    ( __param(2, IConfigurationService))
+], MarkerList));
+let MarkerNavigationService = class MarkerNavigationService {
+    constructor(_markerService, _configService) {
+        this._markerService = _markerService;
+        this._configService = _configService;
+        this._provider = ( new LinkedList());
+    }
+    registerProvider(provider) {
+        const remove = this._provider.unshift(provider);
+        return toDisposable(() => remove());
+    }
+    getMarkerList(resource) {
+        for (const provider of this._provider) {
+            const result = provider.getMarkerList(resource);
+            if (result) {
+                return result;
+            }
+        }
+        return ( new MarkerList(resource, this._markerService, this._configService));
+    }
+};
+MarkerNavigationService = ( __decorate([
+    ( __param(0, IMarkerService)),
+    ( __param(1, IConfigurationService))
+], MarkerNavigationService));
+
+export { MarkerCoordinate, MarkerList, MarkerNavigationService };

package/vscode/src/vs/editor/contrib/gotoError/browser/markerNavigationService.service.d.ts

@@ -1,6 +1,6 @@
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
-import { IMarkerListProvider, MarkerList } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/editor/contrib/gotoError/browser/markerNavigationService";
+import { IMarkerListProvider, MarkerList } from "./markerNavigationService.js";
 export declare const IMarkerNavigationService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IMarkerNavigationService>;
 export interface IMarkerNavigationService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/editor/contrib/gotoSymbol/browser/symbolNavigation.d.ts

@@ -0,0 +1,26 @@
+import { ICodeEditor } from "../../../browser/editorBrowser.js";
+import { ICodeEditorService } from "../../../browser/services/codeEditorService.service.js";
+import { OneReference } from "./referencesModel.js";
+import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
+import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { IKeybindingService } from "../../../../platform/keybinding/common/keybinding.service.js";
+import { INotificationService } from "../../../../platform/notification/common/notification.service.js";
+import { ISymbolNavigationService } from "./symbolNavigation.service.js";
+export declare const ctxHasSymbols: RawContextKey<false>;
+export declare class SymbolNavigationService implements ISymbolNavigationService {
+    private readonly _editorService;
+    private readonly _notificationService;
+    private readonly _keybindingService;
+    readonly _serviceBrand: undefined;
+    private readonly _ctxHasSymbols;
+    private _currentModel?;
+    private _currentIdx;
+    private _currentState?;
+    private _currentMessage?;
+    private _ignoreEditorChange;
+    constructor(contextKeyService: IContextKeyService, _editorService: ICodeEditorService, _notificationService: INotificationService, _keybindingService: IKeybindingService);
+    reset(): void;
+    put(anchor: OneReference): void;
+    revealNext(source: ICodeEditor): Promise<any>;
+    private _showMessage;
+}

package/vscode/src/vs/editor/contrib/gotoSymbol/browser/symbolNavigation.js

@@ -0,0 +1,178 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { KeyCode } from '../../../../base/common/keyCodes.js';
+import { combinedDisposable, DisposableStore, dispose } from '../../../../base/common/lifecycle.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { registerEditorCommand, EditorCommand } from '../../../browser/editorExtensions.js';
+import { ICodeEditorService } from '../../../browser/services/codeEditorService.service.js';
+import { Range } from '../../../common/core/range.js';
+import { localize } from '../../../../nls.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { TextEditorSelectionRevealType } from '../../../../platform/editor/common/editor.js';
+import '../../../../platform/instantiation/common/extensions.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { KeybindingWeight, KeybindingsRegistry } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { ISymbolNavigationService } from './symbolNavigation.service.js';
+
+const ctxHasSymbols = ( new RawContextKey('hasSymbols', false, ( localize(
+    1124,
+    "Whether there are symbol locations that can be navigated via keyboard-only."
+))));
+let SymbolNavigationService = class SymbolNavigationService {
+    constructor(contextKeyService, _editorService, _notificationService, _keybindingService) {
+        this._editorService = _editorService;
+        this._notificationService = _notificationService;
+        this._keybindingService = _keybindingService;
+        this._currentModel = undefined;
+        this._currentIdx = -1;
+        this._ignoreEditorChange = false;
+        this._ctxHasSymbols = ctxHasSymbols.bindTo(contextKeyService);
+    }
+    reset() {
+        this._ctxHasSymbols.reset();
+        this._currentState?.dispose();
+        this._currentMessage?.dispose();
+        this._currentModel = undefined;
+        this._currentIdx = -1;
+    }
+    put(anchor) {
+        const refModel = anchor.parent.parent;
+        if (refModel.references.length <= 1) {
+            this.reset();
+            return;
+        }
+        this._currentModel = refModel;
+        this._currentIdx = refModel.references.indexOf(anchor);
+        this._ctxHasSymbols.set(true);
+        this._showMessage();
+        const editorState = ( new EditorState(this._editorService));
+        const listener = editorState.onDidChange(_ => {
+            if (this._ignoreEditorChange) {
+                return;
+            }
+            const editor = this._editorService.getActiveCodeEditor();
+            if (!editor) {
+                return;
+            }
+            const model = editor.getModel();
+            const position = editor.getPosition();
+            if (!model || !position) {
+                return;
+            }
+            let seenUri = false;
+            let seenPosition = false;
+            for (const reference of refModel.references) {
+                if (isEqual(reference.uri, model.uri)) {
+                    seenUri = true;
+                    seenPosition = seenPosition || Range.containsPosition(reference.range, position);
+                }
+                else if (seenUri) {
+                    break;
+                }
+            }
+            if (!seenUri || !seenPosition) {
+                this.reset();
+            }
+        });
+        this._currentState = combinedDisposable(editorState, listener);
+    }
+    revealNext(source) {
+        if (!this._currentModel) {
+            return Promise.resolve();
+        }
+        this._currentIdx += 1;
+        this._currentIdx %= this._currentModel.references.length;
+        const reference = this._currentModel.references[this._currentIdx];
+        this._showMessage();
+        this._ignoreEditorChange = true;
+        return this._editorService.openCodeEditor({
+            resource: reference.uri,
+            options: {
+                selection: Range.collapseToStart(reference.range),
+                selectionRevealType: TextEditorSelectionRevealType.NearTopIfOutsideViewport
+            }
+        }, source).finally(() => {
+            this._ignoreEditorChange = false;
+        });
+    }
+    _showMessage() {
+        this._currentMessage?.dispose();
+        const kb = this._keybindingService.lookupKeybinding('editor.gotoNextSymbolFromResult');
+        const message = kb
+            ? ( localize(
+            1125,
+            "Symbol {0} of {1}, {2} for next",
+            this._currentIdx + 1,
+            this._currentModel.references.length,
+            kb.getLabel()
+        ))
+            : ( localize(
+            1126,
+            "Symbol {0} of {1}",
+            this._currentIdx + 1,
+            this._currentModel.references.length
+        ));
+        this._currentMessage = this._notificationService.status(message);
+    }
+};
+SymbolNavigationService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, ICodeEditorService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IKeybindingService))
+], SymbolNavigationService));
+registerEditorCommand(new (class extends EditorCommand {
+    constructor() {
+        super({
+            id: 'editor.gotoNextSymbolFromResult',
+            precondition: ctxHasSymbols,
+            kbOpts: {
+                weight: KeybindingWeight.EditorContrib,
+                primary: KeyCode.F12
+            }
+        });
+    }
+    runEditorCommand(accessor, editor) {
+        return accessor.get(ISymbolNavigationService).revealNext(editor);
+    }
+}));
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'editor.gotoNextSymbolFromResult.cancel',
+    weight: KeybindingWeight.EditorContrib,
+    when: ctxHasSymbols,
+    primary: KeyCode.Escape,
+    handler(accessor) {
+        accessor.get(ISymbolNavigationService).reset();
+    }
+});
+let EditorState = class EditorState {
+    constructor(editorService) {
+        this._listener = ( new Map());
+        this._disposables = ( new DisposableStore());
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._disposables.add(editorService.onCodeEditorRemove(this._onDidRemoveEditor, this));
+        this._disposables.add(editorService.onCodeEditorAdd(this._onDidAddEditor, this));
+        editorService.listCodeEditors().forEach(this._onDidAddEditor, this);
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._onDidChange.dispose();
+        dispose(( this._listener.values()));
+    }
+    _onDidAddEditor(editor) {
+        this._listener.set(editor, combinedDisposable(editor.onDidChangeCursorPosition(_ => this._onDidChange.fire({ editor })), editor.onDidChangeModelContent(_ => this._onDidChange.fire({ editor }))));
+    }
+    _onDidRemoveEditor(editor) {
+        this._listener.get(editor)?.dispose();
+        this._listener.delete(editor);
+    }
+};
+EditorState = ( __decorate([
+    ( __param(0, ICodeEditorService))
+], EditorState));
+
+export { SymbolNavigationService, ctxHasSymbols };

package/vscode/src/vs/editor/contrib/gpu/browser/gpuActions.js

@@ -19,7 +19,7 @@ class DebugEditorGpuRendererAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.debugEditorGpuRenderer',
-            label: ( localize2(1124, "Developer: Debug Editor GPU Renderer")),
+            label: ( localize2(1127, "Developer: Debug Editor GPU Renderer")),
             precondition: ContextKeyExpr.true(),
         });
     }
@@ -28,15 +28,15 @@ class DebugEditorGpuRendererAction extends EditorAction {
         const quickInputService = accessor.get(IQuickInputService);
         const choice = await quickInputService.pick([
             {
-                label: ( localize(1125, "Log Texture Atlas Stats")),
+                label: ( localize(1128, "Log Texture Atlas Stats")),
                 id: 'logTextureAtlasStats',
             },
             {
-                label: ( localize(1126, "Save Texture Atlas")),
+                label: ( localize(1129, "Save Texture Atlas")),
                 id: 'saveTextureAtlas',
             },
             {
-                label: ( localize(1127, "Draw Glyph")),
+                label: ( localize(1130, "Draw Glyph")),
                 id: 'drawGlyph',
             },
         ], { canPickMany: false });

package/vscode/src/vs/editor/contrib/hover/browser/contentHoverRendered.js

@@ -250,19 +250,19 @@ let RenderedContentHoverParts = class RenderedContentHoverParts extends Disposab
             return '';
         }
         if (renderedPart.type === 'statusBar') {
-            const statusBarDescription = [( localize(1128, "This is a hover status bar."))];
+            const statusBarDescription = [( localize(1131, "This is a hover status bar."))];
             for (const action of renderedPart.actions) {
                 const keybinding = action.actionKeybindingLabel;
                 if (keybinding) {
                     statusBarDescription.push(( localize(
-                        1129,
+                        1132,
                         "It has an action with label {0} and keybinding {1}.",
                         action.actionLabel,
                         keybinding
                     )));
                 }
                 else {
-                    statusBarDescription.push(( localize(1130, "It has an action with label {0}.", action.actionLabel)));
+                    statusBarDescription.push(( localize(1133, "It has an action with label {0}.", action.actionLabel)));
                 }
             }
             return statusBarDescription.join('\n');

package/vscode/src/vs/editor/contrib/hover/browser/hoverAccessibleViews.js

@@ -20,12 +20,12 @@ import { labelForHoverVerbosityAction } from './markdownHoverParticipant.js';
 var HoverAccessibilityHelpNLS;
 (function (HoverAccessibilityHelpNLS) {
     HoverAccessibilityHelpNLS.increaseVerbosity = ( localize(
-        1131,
+        1134,
         '- The focused hover part verbosity level can be increased with the Increase Hover Verbosity command.',
         `<keybinding:${INCREASE_HOVER_VERBOSITY_ACTION_ID}>`
     ));
     HoverAccessibilityHelpNLS.decreaseVerbosity = ( localize(
-        1132,
+        1135,
         '- The focused hover part verbosity level can be decreased with the Decrease Hover Verbosity command.',
         `<keybinding:${DECREASE_HOVER_VERBOSITY_ACTION_ID}>`
     ));

package/vscode/src/vs/editor/contrib/hover/browser/hoverActionIds.js

@@ -14,9 +14,9 @@ const GO_TO_TOP_HOVER_ACTION_ID = 'editor.action.goToTopHover';
 const GO_TO_BOTTOM_HOVER_ACTION_ID = 'editor.action.goToBottomHover';
 const INCREASE_HOVER_VERBOSITY_ACTION_ID = 'editor.action.increaseHoverVerbosityLevel';
 const INCREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID = 'editor.action.increaseHoverVerbosityLevelFromAccessibleView';
-const INCREASE_HOVER_VERBOSITY_ACTION_LABEL = ( localize(1133, "Increase Hover Verbosity Level"));
+const INCREASE_HOVER_VERBOSITY_ACTION_LABEL = ( localize(1136, "Increase Hover Verbosity Level"));
 const DECREASE_HOVER_VERBOSITY_ACTION_ID = 'editor.action.decreaseHoverVerbosityLevel';
 const DECREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID = 'editor.action.decreaseHoverVerbosityLevelFromAccessibleView';
-const DECREASE_HOVER_VERBOSITY_ACTION_LABEL = ( localize(1134, "Decrease Hover Verbosity Level"));
+const DECREASE_HOVER_VERBOSITY_ACTION_LABEL = ( localize(1137, "Decrease Hover Verbosity Level"));
 
 export { DECREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_LABEL, GO_TO_BOTTOM_HOVER_ACTION_ID, GO_TO_TOP_HOVER_ACTION_ID, HIDE_HOVER_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACCESSIBLE_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_LABEL, PAGE_DOWN_HOVER_ACTION_ID, PAGE_UP_HOVER_ACTION_ID, SCROLL_DOWN_HOVER_ACTION_ID, SCROLL_LEFT_HOVER_ACTION_ID, SCROLL_RIGHT_HOVER_ACTION_ID, SCROLL_UP_HOVER_ACTION_ID, SHOW_DEFINITION_PREVIEW_HOVER_ACTION_ID, SHOW_OR_FOCUS_HOVER_ACTION_ID };