@codingame/monaco-vscode-scm-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/scm/browser/scmInput.js

@@ -0,0 +1,828 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as scm from './media/scm.css';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MutableDisposable, DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { append, $, Dimension, trackFocus } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { InputValidationType, SCMInputChangeReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm';
+import { ISCMViewService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IContextMenuService, IContextViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { RawContextKey, ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { MenuItemAction, MenuId, registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { ActionRunner, Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ThrottledDelayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { CodeEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { getSimpleEditorOptions, setupSimpleEditorSelectionStyling } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { EditorExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { MenuPreventer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/menuPreventer';
+import { SelectionClipboardContributionID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/selectionClipboard';
+import { EditorDictation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation';
+import { ContextMenuController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/contextmenu/browser/contextmenu';
+import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { format } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { SuggestController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/suggest/browser/suggestController';
+import { SnippetController2 } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/snippet/browser/snippetController2';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { ColorDetector } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/colorPicker/browser/colorDetector';
+import { LinkDetector } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/links/browser/links';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { DEFAULT_FONT_FAMILY } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/fonts';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/contextview/contextview';
+import { getFlatActionBarActions, createActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { openLinkFromMarkdown } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer';
+import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
+import { DragAndDropController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/dnd/browser/dnd';
+import { CopyPasteController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/dropOrPasteInto/browser/copyPasteController';
+import { DropIntoEditorController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/dropOrPasteInto/browser/dropIntoEditorController';
+import { MessageController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/message/browser/messageController';
+import { InlineCompletionsController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController';
+import { CodeActionController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/codeAction/browser/codeActionController';
+import { FormatOnType } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/format/browser/formatActions';
+import { EditorOptions, EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { EditOperation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation';
+import { WorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { DropdownWithPrimaryActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem';
+import { clamp } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
+import { ContentHoverController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/hover/browser/contentHoverController';
+import { GlyphHoverController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/hover/browser/glyphHoverController';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { PlaceholderTextContribution } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/placeholderText/browser/placeholderTextContribution';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { AccessibilityCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/common/accessibilityCommands';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { CHAT_SETUP_SUPPORT_ANONYMOUS_ACTION_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { AnchorAlignment } from '@codingame/monaco-vscode-api/vscode/vs/base/common/layout';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var SCMInputWidget_1;
+registerCss(scm);
+const SCMInputContextKeys = {
+    SCMInputHasValidationMessage: ( new RawContextKey("scmInputHasValidationMessage", false))
+};
+var SCMInputWidgetCommandId;
+(function(SCMInputWidgetCommandId) {
+    SCMInputWidgetCommandId["CancelAction"] = "scm.input.cancelAction";
+    SCMInputWidgetCommandId["SetupAction"] = "scm.input.triggerSetup";
+})(SCMInputWidgetCommandId || (SCMInputWidgetCommandId = {}));
+var SCMInputWidgetStorageKey;
+(function(SCMInputWidgetStorageKey) {
+    SCMInputWidgetStorageKey["LastActionId"] = "scm.input.lastActionId";
+})(SCMInputWidgetStorageKey || (SCMInputWidgetStorageKey = {}));
+let SCMInputWidgetActionRunner = class SCMInputWidgetActionRunner extends ActionRunner {
+    get runningActions() {
+        return this._runningActions;
+    }
+    constructor(input, storageService) {
+        super();
+        this.input = input;
+        this.storageService = storageService;
+        this._runningActions = ( new Set());
+    }
+    async runAction(action) {
+        try {
+            if (this.runningActions.size !== 0) {
+                this._cts?.cancel();
+                if (action.id === SCMInputWidgetCommandId.CancelAction) {
+                    return;
+                }
+            }
+            const context = [];
+            for (const group of this.input.repository.provider.groups) {
+                context.push({
+                    resourceGroupId: group.id,
+                    resources: [...( group.resources.map(r => r.sourceUri))]
+                });
+            }
+            this._runningActions.add(action);
+            this._cts = ( new CancellationTokenSource());
+            await action.run(...[this.input.repository.provider.rootUri, context, this._cts.token]);
+        } finally {
+            this._runningActions.delete(action);
+            if (this._runningActions.size === 0) {
+                const actionId = action.id === SCMInputWidgetCommandId.SetupAction ? product.defaultChatAgent?.generateCommitMessageCommand ?? action.id : action.id;
+                this.storageService.store(
+                    SCMInputWidgetStorageKey.LastActionId,
+                    actionId,
+                    StorageScope.PROFILE,
+                    StorageTarget.USER
+                );
+            }
+        }
+    }
+};
+SCMInputWidgetActionRunner = ( __decorate([( __param(1, IStorageService))], SCMInputWidgetActionRunner));
+let SCMInputWidgetToolbar = class SCMInputWidgetToolbar extends WorkbenchToolBar {
+    get dropdownActions() {
+        return this._dropdownActions;
+    }
+    get dropdownAction() {
+        return this._dropdownAction;
+    }
+    constructor(
+        container,
+        options,
+        menuService,
+        contextKeyService,
+        contextMenuService,
+        commandService,
+        keybindingService,
+        storageService,
+        telemetryService
+    ) {
+        super(
+            container,
+            options,
+            menuService,
+            contextKeyService,
+            contextMenuService,
+            keybindingService,
+            commandService,
+            telemetryService
+        );
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.storageService = storageService;
+        this._dropdownActions = [];
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._disposables = this._register(( new MutableDisposable()));
+        this._dropdownAction = ( new Action("scmInputMoreActions", ( localize(11874, "More Actions...")), "codicon-chevron-down"));
+        this._cancelAction = ( new MenuItemAction({
+            id: SCMInputWidgetCommandId.CancelAction,
+            title: ( localize(11875, "Cancel")),
+            icon: Codicon.stopCircle
+        }, undefined, undefined, undefined, undefined, contextKeyService, commandService));
+    }
+    setInput(input) {
+        this._disposables.value = ( new DisposableStore());
+        const contextKeyService = this.contextKeyService.createOverlay([
+            ["scmProvider", input.repository.provider.providerId],
+            ["scmProviderRootUri", input.repository.provider.rootUri?.toString()],
+            ["scmProviderHasRootUri", !!input.repository.provider.rootUri]
+        ]);
+        const menu = this._disposables.value.add(this.menuService.createMenu(MenuId.SCMInputBox, contextKeyService, {
+            emitEventsForSubmenuChanges: true
+        }));
+        const isEnabled = () => {
+            return ( input.repository.provider.groups.some(g => g.resources.length > 0));
+        };
+        const updateToolbar = () => {
+            const actions = getFlatActionBarActions(menu.getActions({
+                shouldForwardArgs: true
+            }));
+            for (const action of actions) {
+                action.enabled = isEnabled();
+            }
+            this._dropdownAction.enabled = isEnabled();
+            let primaryAction = undefined;
+            if (this.actionRunner.runningActions.size !== 0) {
+                primaryAction = this._cancelAction;
+            } else if (actions.length === 1) {
+                primaryAction = actions[0];
+            } else if (actions.length > 1) {
+                const lastActionId = this.storageService.get(SCMInputWidgetStorageKey.LastActionId, StorageScope.PROFILE, "");
+                primaryAction = actions.find(a => a.id === lastActionId) ?? actions[0];
+            }
+            this._dropdownActions = actions.length === 1 ? [] : actions;
+            super.setActions(primaryAction ? [primaryAction] : [], []);
+            this._onDidChange.fire();
+        };
+        this._disposables.value.add(menu.onDidChange(() => updateToolbar()));
+        this._disposables.value.add(input.repository.provider.onDidChangeResources(() => updateToolbar()));
+        this._disposables.value.add(this.storageService.onDidChangeValue(
+            StorageScope.PROFILE,
+            SCMInputWidgetStorageKey.LastActionId,
+            this._disposables.value
+        )(() => updateToolbar()));
+        this.actionRunner = this._disposables.value.add(( new SCMInputWidgetActionRunner(input, this.storageService)));
+        this._disposables.value.add(this.actionRunner.onWillRun(e => {
+            if (this.actionRunner.runningActions.size === 0) {
+                super.setActions([this._cancelAction], []);
+                this._onDidChange.fire();
+            }
+        }));
+        this._disposables.value.add(this.actionRunner.onDidRun(e => {
+            if (this.actionRunner.runningActions.size === 0) {
+                updateToolbar();
+            }
+        }));
+        updateToolbar();
+    }
+};
+SCMInputWidgetToolbar = ( __decorate([( __param(2, IMenuService)), ( __param(3, IContextKeyService)), ( __param(4, IContextMenuService)), ( __param(5, ICommandService)), ( __param(6, IKeybindingService)), ( __param(7, IStorageService)), ( __param(8, ITelemetryService))], SCMInputWidgetToolbar));
+class SCMInputWidgetEditorOptions {
+    constructor(overflowWidgetsDomNode, configurationService) {
+        this.overflowWidgetsDomNode = overflowWidgetsDomNode;
+        this.configurationService = configurationService;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.defaultInputFontFamily = DEFAULT_FONT_FAMILY;
+        this._disposables = ( new DisposableStore());
+        const onDidChangeConfiguration = Event.filter(this.configurationService.onDidChangeConfiguration, e => {
+            return e.affectsConfiguration("editor.accessibilitySupport") || e.affectsConfiguration("editor.cursorBlinking") || e.affectsConfiguration("editor.cursorStyle") || e.affectsConfiguration("editor.cursorWidth") || e.affectsConfiguration("editor.emptySelectionClipboard") || e.affectsConfiguration("editor.fontFamily") || e.affectsConfiguration("editor.rulers") || e.affectsConfiguration("editor.wordWrap") || e.affectsConfiguration("editor.wordSegmenterLocales") || e.affectsConfiguration("scm.inputFontFamily") || e.affectsConfiguration("scm.inputFontSize");
+        }, this._disposables);
+        this._disposables.add(onDidChangeConfiguration(() => this._onDidChange.fire()));
+    }
+    getEditorConstructionOptions() {
+        return {
+            ...getSimpleEditorOptions(this.configurationService),
+            ...this.getEditorOptions(),
+            dragAndDrop: true,
+            dropIntoEditor: {
+                enabled: true
+            },
+            formatOnType: true,
+            lineDecorationsWidth: 6,
+            overflowWidgetsDomNode: this.overflowWidgetsDomNode,
+            padding: {
+                top: 2,
+                bottom: 2
+            },
+            quickSuggestions: false,
+            renderWhitespace: "none",
+            scrollbar: {
+                alwaysConsumeMouseWheel: false,
+                vertical: "hidden"
+            },
+            wrappingIndent: "none",
+            wrappingStrategy: "advanced"
+        };
+    }
+    getEditorOptions() {
+        const fontFamily = this._getEditorFontFamily();
+        const fontSize = this._getEditorFontSize();
+        const lineHeight = this._getEditorLineHeight(fontSize);
+        const wordSegmenterLocales = this.configurationService.getValue("editor.wordSegmenterLocales");
+        const accessibilitySupport = this.configurationService.getValue("editor.accessibilitySupport");
+        const cursorBlinking = this.configurationService.getValue("editor.cursorBlinking");
+        const cursorStyle = this.configurationService.getValue("editor.cursorStyle");
+        const cursorWidth = this.configurationService.getValue("editor.cursorWidth") ?? 1;
+        const emptySelectionClipboard = this.configurationService.getValue("editor.emptySelectionClipboard") === true;
+        return {
+            ...this._getEditorLanguageConfiguration(),
+            accessibilitySupport,
+            cursorBlinking,
+            cursorStyle,
+            cursorWidth,
+            fontFamily,
+            fontSize,
+            lineHeight,
+            emptySelectionClipboard,
+            wordSegmenterLocales
+        };
+    }
+    _getEditorFontFamily() {
+        const inputFontFamily = this.configurationService.getValue("scm.inputFontFamily").trim();
+        if (inputFontFamily.toLowerCase() === "editor") {
+            return this.configurationService.getValue("editor.fontFamily").trim();
+        }
+        if (inputFontFamily.length !== 0 && inputFontFamily.toLowerCase() !== "default") {
+            return inputFontFamily;
+        }
+        return this.defaultInputFontFamily;
+    }
+    _getEditorFontSize() {
+        return this.configurationService.getValue("scm.inputFontSize");
+    }
+    _getEditorLanguageConfiguration() {
+        const rulersConfig = this.configurationService.inspect("editor.rulers", {
+            overrideIdentifier: "scminput"
+        });
+        const rulers = rulersConfig.overrideIdentifiers?.includes("scminput") ? EditorOptions.rulers.validate(rulersConfig.value) : [];
+        const wordWrapConfig = this.configurationService.inspect("editor.wordWrap", {
+            overrideIdentifier: "scminput"
+        });
+        const wordWrap = wordWrapConfig.overrideIdentifiers?.includes("scminput") ? EditorOptions.wordWrap.validate(wordWrapConfig.value) : "on";
+        return {
+            rulers,
+            wordWrap
+        };
+    }
+    _getEditorLineHeight(fontSize) {
+        return Math.round(fontSize * 1.5);
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._onDidChange.dispose();
+    }
+}
+let SCMInputWidget = class SCMInputWidget {
+    static {
+        SCMInputWidget_1 = this;
+    }
+    static {
+        this.ValidationTimeouts = {
+            [InputValidationType.Information]: 5000,
+            [InputValidationType.Warning]: 8000,
+            [InputValidationType.Error]: 10000
+        };
+    }
+    get input() {
+        return this.model?.input;
+    }
+    set input(input) {
+        if (input === this.input) {
+            return;
+        }
+        this.clearValidation();
+        this.element.classList.remove("synthetic-focus");
+        this.repositoryDisposables.clear();
+        this.repositoryIdContextKey.set(input?.repository.id);
+        if (!input) {
+            this.inputEditor.setModel(undefined);
+            this.model = undefined;
+            return;
+        }
+        const textModel = input.repository.provider.inputBoxTextModel;
+        this.inputEditor.setModel(textModel);
+        if (this.configurationService.getValue("editor.wordBasedSuggestions", {
+            resource: textModel.uri
+        }) !== "off") {
+            this.configurationService.updateValue("editor.wordBasedSuggestions", "off", {
+                resource: textModel.uri
+            }, ConfigurationTarget.MEMORY);
+        }
+        const validationDelayer = ( new ThrottledDelayer(200));
+        const validate = async () => {
+            const position = this.inputEditor.getSelection()?.getStartPosition();
+            const offset = position && textModel.getOffsetAt(position);
+            const value = textModel.getValue();
+            this.setValidation(await input.validateInput(value, offset || 0));
+        };
+        const triggerValidation = () => validationDelayer.trigger(validate);
+        this.repositoryDisposables.add(validationDelayer);
+        this.repositoryDisposables.add(this.inputEditor.onDidChangeCursorPosition(triggerValidation));
+        const opts = this.modelService.getCreationOptions(textModel.getLanguageId(), textModel.uri, textModel.isForSimpleWidget);
+        const onEnter = Event.filter(
+            this.inputEditor.onKeyDown,
+            e => e.keyCode === KeyCode.Enter,
+            this.repositoryDisposables
+        );
+        this.repositoryDisposables.add(
+            onEnter(() => textModel.detectIndentation(opts.insertSpaces, opts.tabSize))
+        );
+        textModel.setValue(input.value);
+        this.repositoryDisposables.add(input.onDidChange((
+            {
+                value,
+                reason
+            }
+        ) => {
+            const currentValue = textModel.getValue();
+            if (value === currentValue) {
+                return;
+            }
+            textModel.pushStackElement();
+            textModel.pushEditOperations(
+                null,
+                [EditOperation.replaceMove(textModel.getFullModelRange(), value)],
+                () => []
+            );
+            const position = reason === SCMInputChangeReason.HistoryPrevious ? textModel.getFullModelRange().getStartPosition() : textModel.getFullModelRange().getEndPosition();
+            this.inputEditor.setPosition(position);
+            this.inputEditor.revealPositionInCenterIfOutsideViewport(position);
+        }));
+        this.repositoryDisposables.add(input.onDidChangeFocus(() => this.focus()));
+        this.repositoryDisposables.add(input.onDidChangeValidationMessage(e => this.setValidation(e, {
+            focus: true,
+            timeout: true
+        })));
+        this.repositoryDisposables.add(input.onDidChangeValidateInput(e => triggerValidation()));
+        this.repositoryDisposables.add(input.onDidClearValidation(() => this.clearValidation()));
+        this.repositoryDisposables.add(textModel.onDidChangeContent(() => {
+            input.setValue(textModel.getValue(), true);
+            triggerValidation();
+        }));
+        const accessibilityVerbosityConfig = observableConfigValue(
+            AccessibilityVerbositySettingId.SourceControl,
+            true,
+            this.configurationService
+        );
+        const getAriaLabel = (placeholder, verbosity) => {
+            verbosity = verbosity ?? accessibilityVerbosityConfig.get();
+            if (!verbosity || !this.accessibilityService.isScreenReaderOptimized()) {
+                return placeholder;
+            }
+            const kbLabel = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
+            return kbLabel ? ( localize(
+                11876,
+                "{0}, Use {1} to open Source Control Accessibility Help.",
+                placeholder,
+                kbLabel
+            )) : ( localize(
+                11877,
+                "{0}, Run the Open Accessibility Help command for more information.",
+                placeholder
+            ));
+        };
+        const getPlaceholderText = () => {
+            const binding = this.keybindingService.lookupKeybinding("scm.acceptInput");
+            const label = binding ? binding.getLabel() : (isMacintosh ? "Cmd+Enter" : "Ctrl+Enter");
+            return format(input.placeholder, label);
+        };
+        const updatePlaceholderText = () => {
+            const placeholder = getPlaceholderText();
+            const ariaLabel = getAriaLabel(placeholder);
+            this.inputEditor.updateOptions({
+                ariaLabel,
+                placeholder
+            });
+        };
+        this.repositoryDisposables.add(input.onDidChangePlaceholder(updatePlaceholderText));
+        this.repositoryDisposables.add(this.keybindingService.onDidUpdateKeybindings(updatePlaceholderText));
+        this.repositoryDisposables.add(runOnChange(accessibilityVerbosityConfig, verbosity => {
+            const placeholder = getPlaceholderText();
+            const ariaLabel = getAriaLabel(placeholder, verbosity);
+            this.inputEditor.updateOptions({
+                ariaLabel
+            });
+        }));
+        updatePlaceholderText();
+        let commitTemplate = "";
+        this.repositoryDisposables.add(autorun(reader => {
+            if (!input.visible) {
+                return;
+            }
+            const oldCommitTemplate = commitTemplate;
+            commitTemplate = input.repository.provider.commitTemplate.read(reader);
+            const value = textModel.getValue();
+            if (value && value !== oldCommitTemplate) {
+                return;
+            }
+            textModel.setValue(commitTemplate);
+        }));
+        const updateEnablement = enabled => {
+            this.inputEditor.updateOptions({
+                readOnly: !enabled
+            });
+        };
+        this.repositoryDisposables.add(input.onDidChangeEnablement(enabled => updateEnablement(enabled)));
+        updateEnablement(input.enabled);
+        this.toolbar.setInput(input);
+        this.model = {
+            input,
+            textModel
+        };
+    }
+    get selections() {
+        return this.inputEditor.getSelections();
+    }
+    set selections(selections) {
+        if (selections) {
+            this.inputEditor.setSelections(selections);
+        }
+    }
+    setValidation(validation, options) {
+        if (this._validationTimer) {
+            clearTimeout(this._validationTimer);
+            this._validationTimer = undefined;
+        }
+        this.validation = validation;
+        this.renderValidation();
+        if (options?.focus && !this.hasFocus()) {
+            this.focus();
+        }
+        if (validation && options?.timeout) {
+            this._validationTimer = setTimeout(
+                () => this.setValidation(undefined),
+                SCMInputWidget_1.ValidationTimeouts[validation.type]
+            );
+        }
+    }
+    constructor(
+        container,
+        overflowWidgetsDomNode,
+        contextKeyService,
+        instantiationService,
+        modelService,
+        keybindingService,
+        configurationService,
+        scmViewService,
+        contextViewService,
+        openerService,
+        accessibilityService,
+        markdownRendererService
+    ) {
+        this.modelService = modelService;
+        this.keybindingService = keybindingService;
+        this.configurationService = configurationService;
+        this.scmViewService = scmViewService;
+        this.contextViewService = contextViewService;
+        this.openerService = openerService;
+        this.accessibilityService = accessibilityService;
+        this.markdownRendererService = markdownRendererService;
+        this.disposables = ( new DisposableStore());
+        this.repositoryDisposables = ( new DisposableStore());
+        this.validationHasFocus = false;
+        this.lastLayoutWasTrash = false;
+        this.shouldFocusAfterLayout = false;
+        this.element = append(container, $(".scm-editor"));
+        this.editorContainer = append(this.element, $(".scm-editor-container"));
+        this.toolbarContainer = append(this.element, $(".scm-editor-toolbar"));
+        this.contextKeyService = this.disposables.add(contextKeyService.createScoped(this.element));
+        this.repositoryIdContextKey = this.contextKeyService.createKey("scmRepository", undefined);
+        this.validationMessageContextKey = SCMInputContextKeys.SCMInputHasValidationMessage.bindTo(this.contextKeyService);
+        this.inputEditorOptions = ( new SCMInputWidgetEditorOptions(overflowWidgetsDomNode, this.configurationService));
+        this.disposables.add(this.inputEditorOptions.onDidChange(this.onDidChangeEditorOptions, this));
+        this.disposables.add(this.inputEditorOptions);
+        const codeEditorWidgetOptions = {
+            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                CodeActionController.ID,
+                ColorDetector.ID,
+                ContextMenuController.ID,
+                CopyPasteController.ID,
+                DragAndDropController.ID,
+                DropIntoEditorController.ID,
+                EditorDictation.ID,
+                FormatOnType.ID,
+                ContentHoverController.ID,
+                GlyphHoverController.ID,
+                InlineCompletionsController.ID,
+                LinkDetector.ID,
+                MenuPreventer.ID,
+                MessageController.ID,
+                PlaceholderTextContribution.ID,
+                SelectionClipboardContributionID,
+                SnippetController2.ID,
+                SuggestController.ID
+            ]),
+            isSimpleWidget: true
+        };
+        const services = ( new ServiceCollection([IContextKeyService, this.contextKeyService]));
+        const instantiationService2 = instantiationService.createChild(services, this.disposables);
+        const editorConstructionOptions = this.inputEditorOptions.getEditorConstructionOptions();
+        this.inputEditor = instantiationService2.createInstance(
+            CodeEditorWidget,
+            this.editorContainer,
+            editorConstructionOptions,
+            codeEditorWidgetOptions
+        );
+        this.disposables.add(this.inputEditor);
+        this.disposables.add(this.inputEditor.onDidFocusEditorText(() => {
+            if (this.input?.repository) {
+                this.scmViewService.focus(this.input.repository);
+            }
+            this.element.classList.add("synthetic-focus");
+            this.renderValidation();
+        }));
+        this.disposables.add(this.inputEditor.onDidBlurEditorText(() => {
+            this.element.classList.remove("synthetic-focus");
+            setTimeout(() => {
+                if (!this.validation || !this.validationHasFocus) {
+                    this.clearValidation();
+                }
+            }, 0);
+        }));
+        this.disposables.add(this.inputEditor.onDidBlurEditorWidget(() => {
+            CopyPasteController.get(this.inputEditor)?.clearWidgets();
+            DropIntoEditorController.get(this.inputEditor)?.clearWidgets();
+        }));
+        const firstLineKey = this.contextKeyService.createKey("scmInputIsInFirstPosition", false);
+        const lastLineKey = this.contextKeyService.createKey("scmInputIsInLastPosition", false);
+        this.disposables.add(this.inputEditor.onDidChangeCursorPosition((
+            {
+                position
+            }
+        ) => {
+            const viewModel = this.inputEditor._getViewModel();
+            const lastLineNumber = viewModel.getLineCount();
+            const lastLineCol = viewModel.getLineLength(lastLineNumber) + 1;
+            const viewPosition = viewModel.coordinatesConverter.convertModelPositionToViewPosition(position);
+            firstLineKey.set(viewPosition.lineNumber === 1 && viewPosition.column === 1);
+            lastLineKey.set(
+                viewPosition.lineNumber === lastLineNumber && viewPosition.column === lastLineCol
+            );
+        }));
+        this.disposables.add(this.inputEditor.onDidScrollChange(e => {
+            this.toolbarContainer.classList.toggle("scroll-decoration", e.scrollTop > 0);
+        }));
+        Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration("scm.showInputActionButton")
+        )(() => this.layout(), this, this.disposables);
+        this.onDidChangeContentHeight = Event.signal(Event.filter(
+            this.inputEditor.onDidContentSizeChange,
+            e => e.contentHeightChanged,
+            this.disposables
+        ));
+        this.toolbar = instantiationService2.createInstance(SCMInputWidgetToolbar, this.toolbarContainer, {
+            actionViewItemProvider: (action, options) => {
+                if (action instanceof MenuItemAction && this.toolbar.dropdownActions.length > 1) {
+                    return instantiationService.createInstance(
+                        DropdownWithPrimaryActionViewItem,
+                        action,
+                        this.toolbar.dropdownAction,
+                        this.toolbar.dropdownActions,
+                        "",
+                        {
+                            actionRunner: this.toolbar.actionRunner,
+                            hoverDelegate: options.hoverDelegate
+                        }
+                    );
+                }
+                return createActionViewItem(instantiationService, action, options);
+            },
+            hiddenItemStrategy: HiddenItemStrategy.NoHide,
+            menuOptions: {
+                shouldForwardArgs: true
+            }
+        });
+        this.disposables.add(this.toolbar.onDidChange(() => this.layout()));
+        this.disposables.add(this.toolbar);
+    }
+    getContentHeight() {
+        const lineHeight = this.inputEditor.getOption(EditorOption.lineHeight);
+        const {
+            top,
+            bottom
+        } = this.inputEditor.getOption(EditorOption.padding);
+        const inputMinLinesConfig = this.configurationService.getValue("scm.inputMinLineCount");
+        const inputMinLines = typeof inputMinLinesConfig === "number" ? clamp(inputMinLinesConfig, 1, 50) : 1;
+        const editorMinHeight = inputMinLines * lineHeight + top + bottom;
+        const inputMaxLinesConfig = this.configurationService.getValue("scm.inputMaxLineCount");
+        const inputMaxLines = typeof inputMaxLinesConfig === "number" ? clamp(inputMaxLinesConfig, 1, 50) : 10;
+        const editorMaxHeight = inputMaxLines * lineHeight + top + bottom;
+        return clamp(this.inputEditor.getContentHeight(), editorMinHeight, editorMaxHeight);
+    }
+    layout() {
+        const editorHeight = this.getContentHeight();
+        const toolbarWidth = this.getToolbarWidth();
+        const dimension = ( new Dimension(this.element.clientWidth - toolbarWidth, editorHeight));
+        if (dimension.width < 0) {
+            this.lastLayoutWasTrash = true;
+            return;
+        }
+        this.lastLayoutWasTrash = false;
+        this.inputEditor.layout(dimension);
+        this.renderValidation();
+        const showInputActionButton = this.configurationService.getValue("scm.showInputActionButton") === true;
+        this.toolbarContainer.classList.toggle("hidden", !showInputActionButton || this.toolbar?.isEmpty() === true);
+        if (this.shouldFocusAfterLayout) {
+            this.shouldFocusAfterLayout = false;
+            this.focus();
+        }
+    }
+    focus() {
+        if (this.lastLayoutWasTrash) {
+            this.lastLayoutWasTrash = false;
+            this.shouldFocusAfterLayout = true;
+            return;
+        }
+        this.inputEditor.focus();
+        this.element.classList.add("synthetic-focus");
+    }
+    hasFocus() {
+        return this.inputEditor.hasTextFocus();
+    }
+    onDidChangeEditorOptions() {
+        this.inputEditor.updateOptions(this.inputEditorOptions.getEditorOptions());
+    }
+    renderValidation() {
+        this.clearValidation();
+        this.element.classList.toggle(
+            "validation-info",
+            this.validation?.type === InputValidationType.Information
+        );
+        this.element.classList.toggle(
+            "validation-warning",
+            this.validation?.type === InputValidationType.Warning
+        );
+        this.element.classList.toggle("validation-error", this.validation?.type === InputValidationType.Error);
+        if (!this.validation || !this.inputEditor.hasTextFocus()) {
+            return;
+        }
+        this.validationMessageContextKey.set(true);
+        const disposables = ( new DisposableStore());
+        this.validationContextView = this.contextViewService.showContextView({
+            getAnchor: () => this.element,
+            render: container => {
+                this.element.style.borderBottomLeftRadius = "0";
+                this.element.style.borderBottomRightRadius = "0";
+                const validationContainer = append(container, $(".scm-editor-validation-container"));
+                validationContainer.classList.toggle(
+                    "validation-info",
+                    this.validation.type === InputValidationType.Information
+                );
+                validationContainer.classList.toggle("validation-warning", this.validation.type === InputValidationType.Warning);
+                validationContainer.classList.toggle("validation-error", this.validation.type === InputValidationType.Error);
+                validationContainer.style.width = `${this.element.clientWidth + 2}px`;
+                const element = append(validationContainer, $(".scm-editor-validation"));
+                const message = this.validation.message;
+                if (typeof message === "string") {
+                    element.textContent = message;
+                } else {
+                    const tracker = trackFocus(element);
+                    disposables.add(tracker);
+                    disposables.add(tracker.onDidFocus(() => (this.validationHasFocus = true)));
+                    disposables.add(tracker.onDidBlur(() => {
+                        this.validationHasFocus = false;
+                        this.element.style.borderBottomLeftRadius = "2px";
+                        this.element.style.borderBottomRightRadius = "2px";
+                        this.contextViewService.hideContextView();
+                    }));
+                    const renderedMarkdown = this.markdownRendererService.render(message, {
+                        actionHandler: (link, mdStr) => {
+                            openLinkFromMarkdown(this.openerService, link, mdStr.isTrusted);
+                            this.element.style.borderBottomLeftRadius = "2px";
+                            this.element.style.borderBottomRightRadius = "2px";
+                            this.contextViewService.hideContextView();
+                        }
+                    });
+                    disposables.add(renderedMarkdown);
+                    element.appendChild(renderedMarkdown.element);
+                }
+                const actionsContainer = append(validationContainer, $(".scm-editor-validation-actions"));
+                const actionbar = ( new ActionBar(actionsContainer));
+                const action = ( new Action("scmInputWidget.validationMessage.close", ( localize(11878, "Close")), ThemeIcon.asClassName(Codicon.close), true, () => {
+                    this.contextViewService.hideContextView();
+                    this.element.style.borderBottomLeftRadius = "2px";
+                    this.element.style.borderBottomRightRadius = "2px";
+                }));
+                disposables.add(actionbar);
+                actionbar.push(action, {
+                    icon: true,
+                    label: false
+                });
+                return Disposable.None;
+            },
+            onHide: () => {
+                this.validationHasFocus = false;
+                this.element.style.borderBottomLeftRadius = "2px";
+                this.element.style.borderBottomRightRadius = "2px";
+                disposables.dispose();
+            },
+            anchorAlignment: AnchorAlignment.LEFT
+        });
+    }
+    getToolbarWidth() {
+        const showInputActionButton = this.configurationService.getValue("scm.showInputActionButton");
+        if (!this.toolbar || !showInputActionButton || this.toolbar?.isEmpty() === true) {
+            return 0;
+        }
+        return this.toolbar.dropdownActions.length === 0 ? 26  : 39 ;
+    }
+    clearValidation() {
+        this.validationContextView?.close();
+        this.validationContextView = undefined;
+        this.validationHasFocus = false;
+        this.validationMessageContextKey.set(false);
+    }
+    dispose() {
+        this.input = undefined;
+        this.repositoryDisposables.dispose();
+        this.clearValidation();
+        this.disposables.dispose();
+    }
+};
+SCMInputWidget = SCMInputWidget_1 = ( __decorate([( __param(2, IContextKeyService)), ( __param(3, IInstantiationService)), ( __param(4, IModelService)), ( __param(5, IKeybindingService)), ( __param(6, IConfigurationService)), ( __param(7, ISCMViewService)), ( __param(8, IContextViewService)), ( __param(9, IOpenerService)), ( __param(10, IAccessibilityService)), ( __param(11, IMarkdownRendererService))], SCMInputWidget));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: SCMInputWidgetCommandId.SetupAction,
+            title: ( localize(11879, "Generate Commit Message")),
+            icon: Codicon.sparkle,
+            f1: false,
+            menu: {
+                id: MenuId.SCMInputBox,
+                when: ( ContextKeyExpr.and(( ChatContextKeys.Setup.hidden.negate()), ( ChatContextKeys.Setup.disabled.negate()), ( ChatContextKeys.Setup.installed.negate()), ( ContextKeyExpr.equals("scmProvider", "git"))))
+            }
+        });
+    }
+    async run(accessor, ...args) {
+        const commandService = accessor.get(ICommandService);
+        const result = await commandService.executeCommand(CHAT_SETUP_SUPPORT_ANONYMOUS_ACTION_ID);
+        if (!result) {
+            return;
+        }
+        const command = product.defaultChatAgent?.generateCommitMessageCommand;
+        if (!command) {
+            return;
+        }
+        await commandService.executeCommand(command, ...args);
+    }
+});
+setupSimpleEditorSelectionStyling(".scm-view .scm-editor-container");
+
+export { SCMInputContextKeys, SCMInputWidget };