@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/files/common/files.js

@@ -1,12 +1,73 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ContextKeyExpr, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
 import { InputFocusedContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 const VIEWLET_ID = 'workbench.view.explorer';
+const VIEW_ID = 'workbench.explorer.fileView';
+const ExplorerViewletVisibleContext = ( new RawContextKey(
+    'explorerViewletVisible',
+    true,
+    { type: 'boolean', description: ( localize('explorerViewletVisible', "True when the EXPLORER viewlet is visible.")) }
+));
 const FoldersViewVisibleContext = ( new RawContextKey('foldersViewVisible', true, { type: 'boolean', description: ( localize(
     'foldersViewVisible',
     "True when the FOLDERS view (the file tree within the explorer view container) is visible."
 )) }));
+const ExplorerFolderContext = ( new RawContextKey(
+    'explorerResourceIsFolder',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceIsFolder',
+        "True when the focused item in the EXPLORER is a folder."
+    )) }
+));
+const ExplorerResourceReadonlyContext = ( new RawContextKey(
+    'explorerResourceReadonly',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceReadonly',
+        "True when the focused item in the EXPLORER is readonly."
+    )) }
+));
+const ExplorerResourceNotReadonlyContext = ( ExplorerResourceReadonlyContext.toNegated());
+const ExplorerResourceAvailableEditorIdsContext = ( new RawContextKey('explorerResourceAvailableEditorIds', ''));
+const ExplorerRootContext = ( new RawContextKey(
+    'explorerResourceIsRoot',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceIsRoot',
+        "True when the focused item in the EXPLORER is a root folder."
+    )) }
+));
+const ExplorerResourceCut = ( new RawContextKey(
+    'explorerResourceCut',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceCut',
+        "True when an item in the EXPLORER has been cut for cut and paste."
+    )) }
+));
+const ExplorerResourceMoveableToTrash = ( new RawContextKey(
+    'explorerResourceMoveableToTrash',
+    false,
+    { type: 'boolean', description: ( localize(
+        'explorerResourceMoveableToTrash',
+        "True when the focused item in the EXPLORER can be moved to trash."
+    )) }
+));
 const FilesExplorerFocusedContext = ( new RawContextKey('filesExplorerFocus', true, { type: 'boolean', description: ( localize('filesExplorerFocus', "True when the focus is inside the EXPLORER view.")) }));
+const OpenEditorsVisibleContext = ( new RawContextKey(
+    'openEditorsVisible',
+    false,
+    { type: 'boolean', description: ( localize('openEditorsVisible', "True when the OPEN EDITORS view is visible.")) }
+));
 const ExplorerFocusedContext = ( new RawContextKey(
     'explorerViewletFocus',
     true,
@@ -15,12 +76,44 @@ const ExplorerFocusedContext = ( new RawContextKey(
         "True when the focus is inside the EXPLORER viewlet."
     )) }
 ));
-( ContextKeyExpr.and(
+const ExplorerCompressedFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedFocus',
+    true,
+    { type: 'boolean', description: ( localize(
+        'explorerViewletCompressedFocus',
+        "True when the focused item in the EXPLORER view is a compact item."
+    )) }
+));
+const ExplorerCompressedFirstFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedFirstFocus',
+    true,
+    { type: 'boolean', description: ( localize(
+        'explorerViewletCompressedFirstFocus',
+        "True when the focus is inside a compact item's first part in the EXPLORER view."
+    )) }
+));
+const ExplorerCompressedLastFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedLastFocus',
+    true,
+    { type: 'boolean', description: ( localize(
+        'explorerViewletCompressedLastFocus',
+        "True when the focus is inside a compact item's last part in the EXPLORER view."
+    )) }
+));
+const ViewHasSomeCollapsibleRootItemContext = ( new RawContextKey(
+    'viewHasSomeCollapsibleItem',
+    false,
+    { type: 'boolean', description: ( localize(
+        'viewHasSomeCollapsibleItem',
+        "True when a workspace in the EXPLORER view has some collapsible root child."
+    )) }
+));
+const FilesExplorerFocusCondition = ( ContextKeyExpr.and(
     FoldersViewVisibleContext,
     FilesExplorerFocusedContext,
     ContextKeyExpr.not(InputFocusedContextKey)
 ));
-( ContextKeyExpr.and(
+const ExplorerFocusCondition = ( ContextKeyExpr.and(
     FoldersViewVisibleContext,
     ExplorerFocusedContext,
     ContextKeyExpr.not(InputFocusedContextKey)
@@ -29,4 +122,102 @@ const TEXT_FILE_EDITOR_ID = 'workbench.editors.files.textFileEditor';
 const FILE_EDITOR_INPUT_ID = 'workbench.editors.files.fileEditorInput';
 const BINARY_FILE_EDITOR_ID = 'workbench.editors.files.binaryFileEditor';
 const BINARY_TEXT_FILE_MODE = 'code-text-binary';
-export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerFocusedContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusedContext, FoldersViewVisibleContext, TEXT_FILE_EDITOR_ID, VIEWLET_ID };
+let TextFileContentProvider = class TextFileContentProvider extends Disposable {
+    constructor(textFileService, fileService, languageService, modelService) {
+        super();
+        this.textFileService = textFileService;
+        this.fileService = fileService;
+        this.languageService = languageService;
+        this.modelService = modelService;
+        this.fileWatcherDisposable = this._register(( new MutableDisposable()));
+    }
+    static async open(resource, scheme, label, editorService, options) {
+        await editorService.openEditor({
+            original: { resource: TextFileContentProvider.resourceToTextFile(scheme, resource) },
+            modified: { resource },
+            label,
+            options
+        });
+    }
+    static resourceToTextFile(scheme, resource) {
+        return resource.with({ scheme, query: JSON.stringify({ scheme: resource.scheme, query: resource.query }) });
+    }
+    static textFileToResource(resource) {
+        const { scheme, query } = JSON.parse(resource.query);
+        return resource.with({ scheme, query });
+    }
+    async provideTextContent(resource) {
+        if (!resource.query) {
+            return null;
+        }
+        const savedFileResource = TextFileContentProvider.textFileToResource(resource);
+        const codeEditorModel = await this.resolveEditorModel(resource);
+        if (!this.fileWatcherDisposable.value) {
+            this.fileWatcherDisposable.value = this.fileService.onDidFilesChange(changes => {
+                if (changes.contains(savedFileResource, 0 )) {
+                    this.resolveEditorModel(resource, false );
+                }
+            });
+            if (codeEditorModel) {
+                once(codeEditorModel.onWillDispose)(() => this.fileWatcherDisposable.clear());
+            }
+        }
+        return codeEditorModel;
+    }
+    async resolveEditorModel(resource, createAsNeeded = true) {
+        const savedFileResource = TextFileContentProvider.textFileToResource(resource);
+        const content = await this.textFileService.readStream(savedFileResource);
+        let codeEditorModel = this.modelService.getModel(resource);
+        if (codeEditorModel) {
+            this.modelService.updateModel(codeEditorModel, content.value);
+        }
+        else if (createAsNeeded) {
+            const textFileModel = this.modelService.getModel(savedFileResource);
+            let languageSelector;
+            if (textFileModel) {
+                languageSelector = this.languageService.createById(textFileModel.getLanguageId());
+            }
+            else {
+                languageSelector = this.languageService.createByFilepathOrFirstLine(savedFileResource);
+            }
+            codeEditorModel = this.modelService.createModel(content.value, languageSelector, resource);
+        }
+        return codeEditorModel;
+    }
+};
+TextFileContentProvider = ( __decorate([
+    ( __param(0, ITextFileService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IModelService))
+], TextFileContentProvider));
+class OpenEditor {
+    constructor(_editor, _group) {
+        this._editor = _editor;
+        this._group = _group;
+        this.id = OpenEditor.COUNTER++;
+    }
+    get editor() {
+        return this._editor;
+    }
+    get group() {
+        return this._group;
+    }
+    get groupId() {
+        return this._group.id;
+    }
+    getId() {
+        return `openeditor:${this.groupId}:${this.id}`;
+    }
+    isPreview() {
+        return !this._group.isPinned(this.editor);
+    }
+    isSticky() {
+        return this._group.isSticky(this.editor);
+    }
+    getResource() {
+        return EditorResourceAccessor.getOriginalUri(this.editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+    }
+}
+OpenEditor.COUNTER = 0;
+export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerCompressedFirstFocusContext, ExplorerCompressedFocusContext, ExplorerCompressedLastFocusContext, ExplorerFocusCondition, ExplorerFocusedContext, ExplorerFolderContext, ExplorerResourceAvailableEditorIdsContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerResourceNotReadonlyContext, ExplorerResourceReadonlyContext, ExplorerRootContext, ExplorerViewletVisibleContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusCondition, FilesExplorerFocusedContext, FoldersViewVisibleContext, OpenEditor, OpenEditorsVisibleContext, TEXT_FILE_EDITOR_ID, TextFileContentProvider, VIEWLET_ID, VIEW_ID, ViewHasSomeCollapsibleRootItemContext };

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/interactiveSessionFollowups.js

@@ -0,0 +1,30 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Button } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const $ = dom.$;
+class InteractiveSessionFollowups extends Disposable {
+    constructor(container, followups, options, clickHandler) {
+        super();
+        this.options = options;
+        this.clickHandler = clickHandler;
+        const followupsContainer = dom.append(container, $('.interactive-session-followups'));
+        followups.forEach(followup => this.renderFollowup(followupsContainer, followup));
+    }
+    renderFollowup(container, followup) {
+        const tooltip = 'tooltip' in followup ? followup.tooltip : undefined;
+        const button = this._register(( new Button(container, { ...this.options, supportIcons: true, title: tooltip })));
+        if (followup.kind === 'reply') {
+            button.element.classList.add('interactive-followup-reply');
+        }
+        else if (followup.kind === 'command') {
+            button.element.classList.add('interactive-followup-command');
+        }
+        const label = followup.kind === 'reply' ?
+            '$(sparkle) ' + (followup.title || followup.message) :
+            followup.title;
+        button.label = ( new MarkdownString(label, { supportThemeIcons: true }));
+        this._register(button.onDidClick(() => this.clickHandler(followup)));
+    }
+}
+export { InteractiveSessionFollowups };

package/dist/vscode/vs/workbench/contrib/interactiveSession/browser/interactiveSessionInputPart.js

@@ -0,0 +1,196 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as aria from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { HistoryNavigator } from 'monaco-editor/esm/vs/base/common/history.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import "../../../../../../assets/interactiveSession.css";
+import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { MenuWorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { registerAndCreateHistoryNavigationContext } from 'monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { DEFAULT_FONT_FAMILY } from '../../../browser/style.js';
+import { getSimpleCodeEditorWidgetOptions, getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
+import { InteractiveSessionFollowups } from './interactiveSessionFollowups.js';
+import { CONTEXT_INTERACTIVE_INPUT_HAS_TEXT, CONTEXT_IN_INTERACTIVE_INPUT } from '../common/interactiveSessionContextKeys.js';
+import { IInteractiveSessionWidgetHistoryService } from '../common/interactiveSessionWidgetHistoryService.js';
+const $ = dom.$;
+const INPUT_EDITOR_MAX_HEIGHT = 250;
+let InteractiveSessionInputPart = class InteractiveSessionInputPart extends Disposable {
+    get inputEditor() {
+        return this._inputEditor;
+    }
+    constructor(historyService, modelService, instantiationService, contextKeyService) {
+        super();
+        this.historyService = historyService;
+        this.modelService = modelService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(( new Emitter()));
+        this.onDidBlur = this._onDidBlur.event;
+        this._onDidAcceptFollowup = this._register(( new Emitter()));
+        this.onDidAcceptFollowup = this._onDidAcceptFollowup.event;
+        this.inputEditorHeight = 0;
+        this.followupsDisposables = this._register(( new DisposableStore()));
+        this.inputUri = ( URI.parse(
+            `${InteractiveSessionInputPart.INPUT_SCHEME}:input-${InteractiveSessionInputPart._counter++}`
+        ));
+        this.inputEditorHasText = CONTEXT_INTERACTIVE_INPUT_HAS_TEXT.bindTo(contextKeyService);
+        this.history = ( new HistoryNavigator([], 5));
+        this._register(this.historyService.onDidClearHistory(() => this.history.clear()));
+    }
+    setState(providerId, inputValue) {
+        this.providerId = providerId;
+        const history = this.historyService.getHistory(providerId);
+        this.history = ( new HistoryNavigator(history, 50));
+        this.setValue(inputValue);
+    }
+    get element() {
+        return this.container;
+    }
+    showPreviousValue() {
+        this.navigateHistory(true);
+    }
+    showNextValue() {
+        this.navigateHistory(false);
+    }
+    navigateHistory(previous) {
+        const historyInput = (previous ?
+            (this.history.previous() ?? this.history.first()) : this.history.next())
+            ?? '';
+        aria.status(historyInput);
+        this.setValue(historyInput);
+        this.setHistoryNavigationEnablement(true);
+    }
+    setValue(value) {
+        this.inputEditor.setValue(value);
+        this.inputEditor.setPosition({ lineNumber: 1, column: value.length + 1 });
+    }
+    focus() {
+        this._inputEditor.focus();
+    }
+    async acceptInput(query) {
+        const editorValue = this._inputEditor.getValue();
+        if (!query && editorValue) {
+            this.history.add(editorValue);
+        }
+        this._inputEditor.focus();
+        this._inputEditor.setValue('');
+    }
+    render(container, initialValue, widget) {
+        this.container = dom.append(container, $('.interactive-input-part'));
+        this.followupsContainer = dom.append(this.container, $('.interactive-input-followups'));
+        const inputContainer = dom.append(this.container, $('.interactive-input-and-toolbar'));
+        const inputScopedContextKeyService = this._register(this.contextKeyService.createScoped(inputContainer));
+        CONTEXT_IN_INTERACTIVE_INPUT.bindTo(inputScopedContextKeyService).set(true);
+        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, inputScopedContextKeyService])));
+        const { historyNavigationBackwardsEnablement, historyNavigationForwardsEnablement } = this._register(registerAndCreateHistoryNavigationContext(inputScopedContextKeyService, this));
+        this.setHistoryNavigationEnablement = enabled => {
+            historyNavigationBackwardsEnablement.set(enabled);
+            historyNavigationForwardsEnablement.set(enabled);
+        };
+        const options = getSimpleEditorOptions();
+        options.readOnly = false;
+        options.ariaLabel = ( localize('interactiveSessionInput', "Interactive Session Input"));
+        options.fontFamily = DEFAULT_FONT_FAMILY;
+        options.fontSize = 13;
+        options.lineHeight = 20;
+        options.padding = { top: 8, bottom: 7 };
+        options.cursorWidth = 1;
+        options.wrappingStrategy = 'advanced';
+        options.bracketPairColorization = { enabled: false };
+        options.suggest = { showIcons: false };
+        options.scrollbar = { ...(options.scrollbar ?? {}), vertical: 'hidden' };
+        const inputEditorElement = dom.append(inputContainer, $('.interactive-input-editor'));
+        this._inputEditor = this._register(scopedInstantiationService.createInstance(CodeEditorWidget, inputEditorElement, options, getSimpleCodeEditorWidgetOptions()));
+        this._register(this._inputEditor.onDidChangeModelContent(() => {
+            const currentHeight = Math.min(this._inputEditor.getContentHeight(), INPUT_EDITOR_MAX_HEIGHT);
+            if (currentHeight !== this.inputEditorHeight) {
+                this.inputEditorHeight = currentHeight;
+                this._onDidChangeHeight.fire();
+            }
+            const model = this._inputEditor.getModel();
+            const inputHasText = !!model && model.getValue() !== '';
+            this.setHistoryNavigationEnablement(!inputHasText);
+            this.inputEditorHasText.set(inputHasText);
+        }));
+        this._register(this._inputEditor.onDidFocusEditorText(() => {
+            this._onDidFocus.fire();
+            inputContainer.classList.toggle('focused', true);
+        }));
+        this._register(this._inputEditor.onDidBlurEditorText(() => {
+            inputContainer.classList.toggle('focused', false);
+            this._onDidBlur.fire();
+        }));
+        const toolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, inputContainer, MenuId.InteractiveSessionExecute, {
+            menuOptions: {
+                shouldForwardArgs: true
+            }
+        }));
+        toolbar.getElement().classList.add('interactive-execute-toolbar');
+        toolbar.context = { widget };
+        this.inputModel = this.modelService.getModel(this.inputUri) || this.modelService.createModel('', null, this.inputUri, true);
+        this.inputModel.updateOptions({ bracketColorizationOptions: { enabled: false, independentColorPoolPerBracketType: false } });
+        this._inputEditor.setModel(this.inputModel);
+        if (initialValue) {
+            this.inputModel.setValue(initialValue);
+            const lineNumber = this.inputModel.getLineCount();
+            this._inputEditor.setPosition({ lineNumber, column: this.inputModel.getLineMaxColumn(lineNumber) });
+        }
+    }
+    async renderFollowups(items) {
+        this.followupsDisposables.clear();
+        dom.clearNode(this.followupsContainer);
+        if (items && items.length > 0) {
+            this.followupsDisposables.add(( new InteractiveSessionFollowups(
+                this.followupsContainer,
+                items,
+                undefined,
+                followup => this._onDidAcceptFollowup.fire(followup)
+            )));
+        }
+    }
+    layout(height, width) {
+        return this._layout(height, width);
+    }
+    _layout(height, width, allowRecurse = true) {
+        const followupsHeight = this.followupsContainer.offsetHeight;
+        const inputPartBorder = 1;
+        const inputPartPadding = 24;
+        const inputEditorHeight = Math.min(this._inputEditor.getContentHeight(), height - followupsHeight - inputPartPadding - inputPartBorder, INPUT_EDITOR_MAX_HEIGHT);
+        const inputEditorBorder = 2;
+        const inputPartHeight = followupsHeight + inputEditorHeight + inputPartPadding + inputPartBorder + inputEditorBorder;
+        const editorBorder = 2;
+        const editorPadding = 8;
+        const executeToolbarWidth = 25;
+        const initialEditorScrollWidth = this._inputEditor.getScrollWidth();
+        this._inputEditor.layout({ width: width - inputPartPadding - editorBorder - editorPadding - executeToolbarWidth, height: inputEditorHeight });
+        if (allowRecurse && initialEditorScrollWidth < 10) {
+            return this._layout(height, width, false);
+        }
+        return inputPartHeight;
+    }
+    saveState() {
+        const inputHistory = this.history.getHistory();
+        this.historyService.saveHistory(this.providerId, inputHistory);
+    }
+};
+InteractiveSessionInputPart.INPUT_SCHEME = 'interactiveSessionInput';
+InteractiveSessionInputPart._counter = 0;
+InteractiveSessionInputPart = ( __decorate([
+    ( __param(0, IInteractiveSessionWidgetHistoryService)),
+    ( __param(1, IModelService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IContextKeyService))
+], InteractiveSessionInputPart));
+export { InteractiveSessionInputPart };