@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.6

package/dist/vscode/vs/workbench/contrib/bulkEdit/browser/bulkTextEdits.js

@@ -1,257 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
-import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
-import { SingleModelEditStackElement, MultiModelEditStackElement } from 'monaco-editor/esm/vs/editor/common/model/editStack.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ResourceTextEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
-import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
-import { SnippetParser } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetParser.js';
-class ModelEditTask {
-    constructor(_modelReference) {
-        this._modelReference = _modelReference;
-        this.model = this._modelReference.object.textEditorModel;
-        this._edits = [];
-    }
-    dispose() {
-        this._modelReference.dispose();
-    }
-    isNoOp() {
-        if (this._edits.length > 0) {
-            return false;
-        }
-        if (this._newEol !== undefined && this._newEol !== this.model.getEndOfLineSequence()) {
-            return false;
-        }
-        return true;
-    }
-    addEdit(resourceEdit) {
-        this._expectedModelVersionId = resourceEdit.versionId;
-        const { textEdit } = resourceEdit;
-        if (typeof textEdit.eol === 'number') {
-            this._newEol = textEdit.eol;
-        }
-        if (!textEdit.range && !textEdit.text) {
-            return;
-        }
-        if (Range.isEmpty(textEdit.range) && !textEdit.text) {
-            return;
-        }
-        let range;
-        if (!textEdit.range) {
-            range = this.model.getFullModelRange();
-        }
-        else {
-            range = Range.lift(textEdit.range);
-        }
-        this._edits.push({ ...EditOperation.replaceMove(range, textEdit.text), insertAsSnippet: textEdit.insertAsSnippet });
-    }
-    validate() {
-        if (typeof this._expectedModelVersionId === 'undefined' || this.model.getVersionId() === this._expectedModelVersionId) {
-            return { canApply: true };
-        }
-        return { canApply: false, reason: this.model.uri };
-    }
-    getBeforeCursorState() {
-        return null;
-    }
-    apply() {
-        if (this._edits.length > 0) {
-            this._edits = (
-            this._edits
-                .map(this._transformSnippetStringToInsertText, this))
-                .sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
-            this.model.pushEditOperations(null, this._edits, () => null);
-        }
-        if (this._newEol !== undefined) {
-            this.model.pushEOL(this._newEol);
-        }
-    }
-    _transformSnippetStringToInsertText(edit) {
-        if (!edit.insertAsSnippet) {
-            return edit;
-        }
-        if (!edit.text) {
-            return edit;
-        }
-        const text = SnippetParser.asInsertText(edit.text);
-        return { ...edit, insertAsSnippet: false, text };
-    }
-}
-class EditorEditTask extends ModelEditTask {
-    constructor(modelReference, editor) {
-        super(modelReference);
-        this._editor = editor;
-    }
-    getBeforeCursorState() {
-        return this._canUseEditor() ? this._editor.getSelections() : null;
-    }
-    apply() {
-        if (!this._canUseEditor()) {
-            super.apply();
-            return;
-        }
-        if (this._edits.length > 0) {
-            const snippetCtrl = SnippetController2.get(this._editor);
-            if (snippetCtrl && ( this._edits.some(edit => edit.insertAsSnippet))) {
-                const snippetEdits = [];
-                for (const edit of this._edits) {
-                    if (edit.range && edit.text !== null) {
-                        snippetEdits.push({
-                            range: Range.lift(edit.range),
-                            template: edit.insertAsSnippet ? edit.text : SnippetParser.escape(edit.text)
-                        });
-                    }
-                }
-                snippetCtrl.apply(snippetEdits);
-            }
-            else {
-                this._edits = (
-                this._edits
-                    .map(this._transformSnippetStringToInsertText, this))
-                    .sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
-                this._editor.executeEdits('', this._edits);
-            }
-        }
-        if (this._newEol !== undefined) {
-            if (this._editor.hasModel()) {
-                this._editor.getModel().pushEOL(this._newEol);
-            }
-        }
-    }
-    _canUseEditor() {
-        return this._editor?.getModel()?.uri.toString() === ( this.model.uri.toString());
-    }
-}
-let BulkTextEdits = class BulkTextEdits {
-    constructor(_label, _code, _editor, _undoRedoGroup, _undoRedoSource, _progress, _token, edits, _editorWorker, _modelService, _textModelResolverService, _undoRedoService) {
-        this._label = _label;
-        this._code = _code;
-        this._editor = _editor;
-        this._undoRedoGroup = _undoRedoGroup;
-        this._undoRedoSource = _undoRedoSource;
-        this._progress = _progress;
-        this._token = _token;
-        this._editorWorker = _editorWorker;
-        this._modelService = _modelService;
-        this._textModelResolverService = _textModelResolverService;
-        this._undoRedoService = _undoRedoService;
-        this._edits = ( new ResourceMap());
-        for (const edit of edits) {
-            let array = this._edits.get(edit.resource);
-            if (!array) {
-                array = [];
-                this._edits.set(edit.resource, array);
-            }
-            array.push(edit);
-        }
-    }
-    _validateBeforePrepare() {
-        for (const array of ( this._edits.values())) {
-            for (const edit of array) {
-                if (typeof edit.versionId === 'number') {
-                    const model = this._modelService.getModel(edit.resource);
-                    if (model && model.getVersionId() !== edit.versionId) {
-                        throw new Error(`${model.uri.toString()} has changed in the meantime`);
-                    }
-                }
-            }
-        }
-    }
-    async _createEditsTasks() {
-        const tasks = [];
-        const promises = [];
-        for (const [key, value] of this._edits) {
-            const promise = this._textModelResolverService.createModelReference(key).then(async (ref) => {
-                let task;
-                let makeMinimal = false;
-                if (this._editor?.getModel()?.uri.toString() === ( ref.object.textEditorModel.uri.toString())) {
-                    task = ( new EditorEditTask(ref, this._editor));
-                    makeMinimal = true;
-                }
-                else {
-                    task = ( new ModelEditTask(ref));
-                }
-                for (const edit of value) {
-                    if (makeMinimal && !edit.textEdit.insertAsSnippet) {
-                        const newEdits = await this._editorWorker.computeMoreMinimalEdits(edit.resource, [edit.textEdit]);
-                        if (!newEdits) {
-                            task.addEdit(edit);
-                        }
-                        else {
-                            for (const moreMinialEdit of newEdits) {
-                                task.addEdit(( new ResourceTextEdit(edit.resource, moreMinialEdit, edit.versionId, edit.metadata)));
-                            }
-                        }
-                    }
-                    else {
-                        task.addEdit(edit);
-                    }
-                }
-                tasks.push(task);
-            });
-            promises.push(promise);
-        }
-        await Promise.all(promises);
-        return tasks;
-    }
-    _validateTasks(tasks) {
-        for (const task of tasks) {
-            const result = task.validate();
-            if (!result.canApply) {
-                return result;
-            }
-        }
-        return { canApply: true };
-    }
-    async apply() {
-        this._validateBeforePrepare();
-        const tasks = await this._createEditsTasks();
-        try {
-            if (this._token.isCancellationRequested) {
-                return [];
-            }
-            const resources = [];
-            const validation = this._validateTasks(tasks);
-            if (!validation.canApply) {
-                throw new Error(`${validation.reason.toString()} has changed in the meantime`);
-            }
-            if (tasks.length === 1) {
-                const task = tasks[0];
-                if (!task.isNoOp()) {
-                    const singleModelEditStackElement = ( new SingleModelEditStackElement(this._label, this._code, task.model, task.getBeforeCursorState()));
-                    this._undoRedoService.pushElement(singleModelEditStackElement, this._undoRedoGroup, this._undoRedoSource);
-                    task.apply();
-                    singleModelEditStackElement.close();
-                    resources.push(task.model.uri);
-                }
-                this._progress.report(undefined);
-            }
-            else {
-                const multiModelEditStackElement = ( new MultiModelEditStackElement(this._label, this._code, ( tasks.map(t => ( new SingleModelEditStackElement(this._label, this._code, t.model, t.getBeforeCursorState()))))));
-                this._undoRedoService.pushElement(multiModelEditStackElement, this._undoRedoGroup, this._undoRedoSource);
-                for (const task of tasks) {
-                    task.apply();
-                    this._progress.report(undefined);
-                    resources.push(task.model.uri);
-                }
-                multiModelEditStackElement.close();
-            }
-            return resources;
-        }
-        finally {
-            dispose(tasks);
-        }
-    }
-};
-BulkTextEdits = ( __decorate([
-    ( __param(8, IEditorWorkerService)),
-    ( __param(9, IModelService)),
-    ( __param(10, ITextModelService)),
-    ( __param(11, IUndoRedoService))
-], BulkTextEdits));
-export { BulkTextEdits };

package/dist/vscode/vs/workbench/contrib/callHierarchy/browser/callHierarchy.contribution.js

@@ -1,259 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { CallHierarchyProviderRegistry, CallHierarchyModel } from '../common/callHierarchy.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { CallHierarchyTreePeekWidget } from './callHierarchyPeek.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { registerEditorContribution, EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
-import { ContextKeyExpr, RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
-import { PeekContext } from 'monaco-editor/esm/vs/editor/contrib/peekView/browser/peekView.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { registerAction2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-const _ctxHasCallHierarchyProvider = ( new RawContextKey('editorHasCallHierarchyProvider', false, ( localize(
-    'editorHasCallHierarchyProvider',
-    'Whether a call hierarchy provider is available'
-))));
-const _ctxCallHierarchyVisible = ( new RawContextKey('callHierarchyVisible', false, ( localize('callHierarchyVisible', 'Whether call hierarchy peek is currently showing'))));
-const _ctxCallHierarchyDirection = ( new RawContextKey(
-    'callHierarchyDirection',
-    undefined,
-    { type: 'string', description: ( localize(
-        'callHierarchyDirection',
-        'Whether call hierarchy shows incoming or outgoing calls'
-    )) }
-));
-function sanitizedDirection(candidate) {
-    return candidate === "outgoingCalls"  || candidate === "incomingCalls"
-        ? candidate
-        : "incomingCalls" ;
-}
-let CallHierarchyController = class CallHierarchyController {
-    static get(editor) {
-        return editor.getContribution(CallHierarchyController.Id);
-    }
-    constructor(_editor, _contextKeyService, _storageService, _editorService, _instantiationService) {
-        this._editor = _editor;
-        this._contextKeyService = _contextKeyService;
-        this._storageService = _storageService;
-        this._editorService = _editorService;
-        this._instantiationService = _instantiationService;
-        this._dispoables = ( new DisposableStore());
-        this._sessionDisposables = ( new DisposableStore());
-        this._ctxIsVisible = _ctxCallHierarchyVisible.bindTo(this._contextKeyService);
-        this._ctxHasProvider = _ctxHasCallHierarchyProvider.bindTo(this._contextKeyService);
-        this._ctxDirection = _ctxCallHierarchyDirection.bindTo(this._contextKeyService);
-        this._dispoables.add(Event.any(_editor.onDidChangeModel, _editor.onDidChangeModelLanguage, CallHierarchyProviderRegistry.onDidChange)(() => {
-            this._ctxHasProvider.set(_editor.hasModel() && ( CallHierarchyProviderRegistry.has(_editor.getModel())));
-        }));
-        this._dispoables.add(this._sessionDisposables);
-    }
-    dispose() {
-        this._ctxHasProvider.reset();
-        this._ctxIsVisible.reset();
-        this._dispoables.dispose();
-    }
-    async startCallHierarchyFromEditor() {
-        this._sessionDisposables.clear();
-        if (!this._editor.hasModel()) {
-            return;
-        }
-        const document = this._editor.getModel();
-        const position = this._editor.getPosition();
-        if (!( CallHierarchyProviderRegistry.has(document))) {
-            return;
-        }
-        const cts = ( new CancellationTokenSource());
-        const model = CallHierarchyModel.create(document, position, cts.token);
-        const direction = sanitizedDirection(this._storageService.get(CallHierarchyController._StorageDirection, 0 , "incomingCalls" ));
-        this._showCallHierarchyWidget(position, direction, model, cts);
-    }
-    async startCallHierarchyFromCallHierarchy() {
-        if (!this._widget) {
-            return;
-        }
-        const model = this._widget.getModel();
-        const call = this._widget.getFocused();
-        if (!call || !model) {
-            return;
-        }
-        const newEditor = await this._editorService.openCodeEditor({ resource: call.item.uri }, this._editor);
-        if (!newEditor) {
-            return;
-        }
-        const newModel = model.fork(call.item);
-        this._sessionDisposables.clear();
-        CallHierarchyController.get(newEditor)?._showCallHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
-    }
-    _showCallHierarchyWidget(position, direction, model, cts) {
-        this._ctxIsVisible.set(true);
-        this._ctxDirection.set(direction);
-        Event.any(this._editor.onDidChangeModel, this._editor.onDidChangeModelLanguage)(this.endCallHierarchy, this, this._sessionDisposables);
-        this._widget = this._instantiationService.createInstance(CallHierarchyTreePeekWidget, this._editor, position, direction);
-        this._widget.showLoading();
-        this._sessionDisposables.add(this._widget.onDidClose(() => {
-            this.endCallHierarchy();
-            this._storageService.store(CallHierarchyController._StorageDirection, this._widget.direction, 0 , 0 );
-        }));
-        this._sessionDisposables.add({ dispose() { cts.dispose(true); } });
-        this._sessionDisposables.add(this._widget);
-        model.then(model => {
-            if (cts.token.isCancellationRequested) {
-                return;
-            }
-            if (model) {
-                this._sessionDisposables.add(model);
-                this._widget.showModel(model);
-            }
-            else {
-                this._widget.showMessage(( localize('no.item', "No results")));
-            }
-        }).catch(err => {
-            if (isCancellationError(err)) {
-                this.endCallHierarchy();
-                return;
-            }
-            this._widget.showMessage(( localize('error', "Failed to show call hierarchy")));
-        });
-    }
-    showOutgoingCalls() {
-        this._widget?.updateDirection("outgoingCalls" );
-        this._ctxDirection.set("outgoingCalls" );
-    }
-    showIncomingCalls() {
-        this._widget?.updateDirection("incomingCalls" );
-        this._ctxDirection.set("incomingCalls" );
-    }
-    endCallHierarchy() {
-        this._sessionDisposables.clear();
-        this._ctxIsVisible.set(false);
-        this._editor.focus();
-    }
-};
-CallHierarchyController.Id = 'callHierarchy';
-CallHierarchyController._StorageDirection = 'callHierarchy/defaultDirection';
-CallHierarchyController = ( __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, ICodeEditorService)),
-    ( __param(4, IInstantiationService))
-], CallHierarchyController));
-registerEditorContribution(CallHierarchyController.Id, CallHierarchyController, 0 );
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.showCallHierarchy',
-            title: { value: ( localize('title', "Peek Call Hierarchy")), original: 'Peek Call Hierarchy' },
-            menu: {
-                id: MenuId.EditorContextPeek,
-                group: 'navigation',
-                order: 1000,
-                when: ( ContextKeyExpr.and(_ctxHasCallHierarchyProvider, PeekContext.notInPeekEditor)),
-            },
-            keybinding: {
-                when: EditorContextKeys.editorTextFocus,
-                weight: 200 ,
-                primary: 1024  + 512  + 38
-            },
-            precondition: ( ContextKeyExpr.and(_ctxHasCallHierarchyProvider, PeekContext.notInPeekEditor))
-        });
-    }
-    async runEditorCommand(_accessor, editor) {
-        return CallHierarchyController.get(editor)?.startCallHierarchyFromEditor();
-    }
-});
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.showIncomingCalls',
-            title: { value: ( localize('title.incoming', "Show Incoming Calls")), original: 'Show Incoming Calls' },
-            icon: ( registerIcon('callhierarchy-incoming', Codicon.callIncoming, ( localize(
-                'showIncomingCallsIcons',
-                'Icon for incoming calls in the call hierarchy view.'
-            )))),
-            precondition: ( ContextKeyExpr.and(_ctxCallHierarchyVisible, ( _ctxCallHierarchyDirection.isEqualTo("outgoingCalls" )))),
-            keybinding: {
-                weight: 200 ,
-                primary: 1024  + 512  + 38 ,
-            },
-            menu: {
-                id: CallHierarchyTreePeekWidget.TitleMenu,
-                when: ( _ctxCallHierarchyDirection.isEqualTo("outgoingCalls" )),
-                order: 1,
-            }
-        });
-    }
-    runEditorCommand(_accessor, editor) {
-        return CallHierarchyController.get(editor)?.showIncomingCalls();
-    }
-});
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.showOutgoingCalls',
-            title: { value: ( localize('title.outgoing', "Show Outgoing Calls")), original: 'Show Outgoing Calls' },
-            icon: ( registerIcon('callhierarchy-outgoing', Codicon.callOutgoing, ( localize(
-                'showOutgoingCallsIcon',
-                'Icon for outgoing calls in the call hierarchy view.'
-            )))),
-            precondition: ( ContextKeyExpr.and(_ctxCallHierarchyVisible, ( _ctxCallHierarchyDirection.isEqualTo("incomingCalls" )))),
-            keybinding: {
-                weight: 200 ,
-                primary: 1024  + 512  + 38 ,
-            },
-            menu: {
-                id: CallHierarchyTreePeekWidget.TitleMenu,
-                when: ( _ctxCallHierarchyDirection.isEqualTo("incomingCalls" )),
-                order: 1
-            }
-        });
-    }
-    runEditorCommand(_accessor, editor) {
-        return CallHierarchyController.get(editor)?.showOutgoingCalls();
-    }
-});
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.refocusCallHierarchy',
-            title: { value: ( localize('title.refocus', "Refocus Call Hierarchy")), original: 'Refocus Call Hierarchy' },
-            precondition: _ctxCallHierarchyVisible,
-            keybinding: {
-                weight: 200 ,
-                primary: 1024  + 3
-            }
-        });
-    }
-    async runEditorCommand(_accessor, editor) {
-        return CallHierarchyController.get(editor)?.startCallHierarchyFromCallHierarchy();
-    }
-});
-registerAction2(class extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'editor.closeCallHierarchy',
-            title: ( localize('close', 'Close')),
-            icon: Codicon.close,
-            precondition: _ctxCallHierarchyVisible,
-            keybinding: {
-                weight: 200  + 10,
-                primary: 9 ,
-                when: ContextKeyExpr.not('config.editor.stablePeek')
-            },
-            menu: {
-                id: CallHierarchyTreePeekWidget.TitleMenu,
-                order: 1000
-            }
-        });
-    }
-    runEditorCommand(_accessor, editor) {
-        return CallHierarchyController.get(editor)?.endCallHierarchy();
-    }
-});