@codingame/monaco-vscode-notebook-service-override 4.1.0 → 4.1.2

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n as default };

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/notebook.js

@@ -1,30 +1,30 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
-import { NotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookServiceImpl';
+import { NotebookService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookServiceImpl.js';
 import { INotebookEditorModelResolverService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService';
 import { INotebookEditorWorkerService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService';
-import { NotebookEditorWorkerServiceImpl } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl';
+import { NotebookEditorWorkerServiceImpl } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.js';
 import { INotebookCellStatusBarService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
 import { NotebookCellStatusBarService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookCellStatusBarServiceImpl.js';
 import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
-import { NotebookEditorWidgetService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorServiceImpl';
-import { NotebookModelResolverServiceImpl } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl';
+import { NotebookEditorWidgetService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookEditorServiceImpl.js';
+import { NotebookModelResolverServiceImpl } from './vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js';
 import { INotebookKernelService, INotebookKernelHistoryService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
-import { NotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookKernelServiceImpl';
-import { NotebookRendererMessagingService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookRendererMessagingServiceImpl';
+import { NotebookKernelService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelServiceImpl.js';
+import { NotebookRendererMessagingService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookRendererMessagingServiceImpl.js';
 import { INotebookRendererMessagingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookRendererMessagingService';
-import { NotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookExecutionStateServiceImpl';
-import { NotebookExecutionService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookExecutionServiceImpl';
+import { NotebookExecutionStateService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookExecutionStateServiceImpl.js';
+import { NotebookExecutionService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookExecutionServiceImpl.js';
 import { INotebookExecutionService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
 import { INotebookKeymapService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKeymapService';
-import { NotebookKeymapService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl';
+import { NotebookKeymapService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl.js';
 import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-import { NotebookKernelHistoryService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookKernelHistoryServiceImpl';
+import { NotebookKernelHistoryService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelHistoryServiceImpl.js';
 import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService';
-import { NotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl';
+import { NotebookLoggingService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl.js';
 import { INotebookSearchService } from 'vscode/vscode/vs/workbench/contrib/search/common/notebookSearch';
 import { NotebookSearchService } from 'vscode/vscode/vs/workbench/contrib/search/browser/notebookSearch/notebookSearchService';
-import 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebook.contribution';
+import './vscode/src/vs/workbench/contrib/notebook/browser/notebook.contribution.js';
 import { INotebookDocumentService, NotebookDocumentWorkbenchService } from 'vscode/vscode/vs/workbench/services/notebook/common/notebookDocumentService';
 
 function getServiceOverride() {

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,10 @@
+export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-notebook-service-override",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.2"
   },
   "exports": {
     ".": {

package/vscode/src/vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-editor .contentWidgets .empty-editor-hint{color:var(--vscode-input-placeholderForeground)}.monaco-editor .contentWidgets .empty-editor-hint a{color:var(--vscode-textLink-foreground)}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint.js

@@ -0,0 +1,391 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import './emptyTextEditorHint.css.js';
+import { addDisposableListener, EventType, $ as $$1 } from 'vscode/vscode/vs/base/browser/dom';
+import { DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { ChangeLanguageAction } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorStatus';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { PLAINTEXT_LANGUAGE_ID } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { renderFormattedText } from 'vscode/vscode/vs/base/browser/formattedTextRenderer';
+import { ApplyFileSnippetAction } from 'vscode/vscode/vs/workbench/contrib/snippets/browser/commands/fileTemplateSnippets';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService';
+import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { KeybindingLabel } from 'vscode/vscode/vs/base/browser/ui/keybindingLabel/keybindingLabel';
+import { OS } from 'vscode/vscode/vs/base/common/platform';
+import { status } from 'vscode/vscode/vs/base/browser/ui/aria/aria';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/configuration';
+import { OUTPUT_MODE_ID, LOG_MODE_ID } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { SEARCH_RESULT_LANGUAGE_ID } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { setupCustomHover } from 'vscode/vscode/vs/base/browser/ui/hover/updatableHoverWidget';
+import { getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+
+const $ = $$1;
+( Registry.as(Extensions.ConfigurationMigration))
+    .registerConfigurationMigrations([{
+        key: 'workbench.editor.untitled.hint',
+        migrateFn: (value, _accessor) => ([
+            [emptyTextEditorHintSetting, { value }],
+            ['workbench.editor.untitled.hint', { value: undefined }]
+        ])
+    },
+    {
+        key: 'accessibility.verbosity.untitledHint',
+        migrateFn: (value, _accessor) => ([
+            ["accessibility.verbosity.emptyEditorHint" , { value }],
+            ['accessibility.verbosity.untitledHint', { value: undefined }]
+        ])
+    }]);
+const emptyTextEditorHintSetting = 'workbench.editor.empty.hint';
+let EmptyTextEditorHintContribution = class EmptyTextEditorHintContribution {
+    static { this.ID = 'editor.contrib.emptyTextEditorHint'; }
+    constructor(editor, editorGroupsService, commandService, configurationService, keybindingService, inlineChatSessionService, inlineChatService, telemetryService, productService) {
+        this.editor = editor;
+        this.editorGroupsService = editorGroupsService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.inlineChatSessionService = inlineChatSessionService;
+        this.inlineChatService = inlineChatService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.toDispose = [];
+        this.toDispose.push(this.editor.onDidChangeModel(() => this.update()));
+        this.toDispose.push(this.editor.onDidChangeModelLanguage(() => this.update()));
+        this.toDispose.push(this.editor.onDidChangeModelContent(() => this.update()));
+        this.toDispose.push(this.inlineChatService.onDidChangeProviders(() => this.update()));
+        this.toDispose.push(this.editor.onDidChangeModelDecorations(() => this.update()));
+        this.toDispose.push(this.editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(91 )) {
+                this.update();
+            }
+        }));
+        this.toDispose.push(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(emptyTextEditorHintSetting)) {
+                this.update();
+            }
+        }));
+        this.toDispose.push(inlineChatSessionService.onWillStartSession(editor => {
+            if (this.editor === editor) {
+                this.textHintContentWidget?.dispose();
+            }
+        }));
+        this.toDispose.push(inlineChatSessionService.onDidEndSession(e => {
+            if (this.editor === e.editor) {
+                this.update();
+            }
+        }));
+    }
+    _getOptions() {
+        return { clickable: true };
+    }
+    _shouldRenderHint() {
+        const configValue = this.configurationService.getValue(emptyTextEditorHintSetting);
+        if (configValue === 'hidden') {
+            return false;
+        }
+        if (this.editor.getOption(91 )) {
+            return false;
+        }
+        const model = this.editor.getModel();
+        const languageId = model?.getLanguageId();
+        if (!model || languageId === OUTPUT_MODE_ID || languageId === LOG_MODE_ID || languageId === SEARCH_RESULT_LANGUAGE_ID) {
+            return false;
+        }
+        if (this.inlineChatSessionService.getSession(this.editor, model.uri)) {
+            return false;
+        }
+        if (this.editor.getModel()?.getValueLength()) {
+            return false;
+        }
+        const hasConflictingDecorations = Boolean(this.editor.getLineDecorations(1)?.find((d) => d.options.beforeContentClassName
+            || d.options.afterContentClassName
+            || d.options.before?.content
+            || d.options.after?.content));
+        if (hasConflictingDecorations) {
+            return false;
+        }
+        const inlineChatProviders = [...this.inlineChatService.getAllProvider()];
+        const shouldRenderDefaultHint = model?.uri.scheme === Schemas.untitled && languageId === PLAINTEXT_LANGUAGE_ID && !inlineChatProviders.length;
+        return inlineChatProviders.length > 0 || shouldRenderDefaultHint;
+    }
+    update() {
+        const shouldRenderHint = this._shouldRenderHint();
+        if (shouldRenderHint && !this.textHintContentWidget) {
+            this.textHintContentWidget = ( new EmptyTextEditorHintContentWidget(
+                this.editor,
+                this._getOptions(),
+                this.editorGroupsService,
+                this.commandService,
+                this.configurationService,
+                this.keybindingService,
+                this.inlineChatService,
+                this.telemetryService,
+                this.productService
+            ));
+        }
+        else if (!shouldRenderHint && this.textHintContentWidget) {
+            this.textHintContentWidget.dispose();
+            this.textHintContentWidget = undefined;
+        }
+    }
+    dispose() {
+        dispose(this.toDispose);
+        this.textHintContentWidget?.dispose();
+    }
+};
+EmptyTextEditorHintContribution = ( __decorate([
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IInlineChatSessionService)),
+    ( __param(6, IInlineChatService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IProductService))
+], EmptyTextEditorHintContribution));
+class EmptyTextEditorHintContentWidget {
+    static { this.ID = 'editor.widget.emptyHint'; }
+    constructor(editor, options, editorGroupsService, commandService, configurationService, keybindingService, inlineChatService, telemetryService, productService) {
+        this.editor = editor;
+        this.options = options;
+        this.editorGroupsService = editorGroupsService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.inlineChatService = inlineChatService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.isVisible = false;
+        this.ariaLabel = '';
+        this.toDispose = ( new DisposableStore());
+        this.toDispose.add(this.editor.onDidChangeConfiguration((e) => {
+            if (this.domNode && e.hasChanged(50 )) {
+                this.editor.applyFontInfo(this.domNode);
+            }
+        }));
+        const onDidFocusEditorText = Event.debounce(this.editor.onDidFocusEditorText, () => undefined, 500);
+        this.toDispose.add(onDidFocusEditorText(() => {
+            if (this.editor.hasTextFocus() && this.isVisible && this.ariaLabel && this.configurationService.getValue("accessibility.verbosity.emptyEditorHint" )) {
+                status(this.ariaLabel);
+            }
+        }));
+        this.editor.addContentWidget(this);
+    }
+    getId() {
+        return EmptyTextEditorHintContentWidget.ID;
+    }
+    _getHintInlineChat(providers) {
+        const providerName = (providers.length === 1 ? providers[0].label : undefined) ?? this.productService.nameShort;
+        const inlineChatId = 'inlineChat.start';
+        let ariaLabel = `Ask ${providerName} something or start typing to dismiss.`;
+        const handleClick = () => {
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: 'inlineChat.hintAction',
+                from: 'hint'
+            });
+            this.commandService.executeCommand(inlineChatId, { from: 'hint' });
+        };
+        const hintHandler = {
+            disposables: this.toDispose,
+            callback: (index, _event) => {
+                switch (index) {
+                    case '0':
+                        handleClick();
+                        break;
+                }
+            }
+        };
+        const hintElement = $('empty-hint-text');
+        hintElement.style.display = 'block';
+        const keybindingHint = this.keybindingService.lookupKeybinding(inlineChatId);
+        const keybindingHintLabel = keybindingHint?.getLabel();
+        if (keybindingHint && keybindingHintLabel) {
+            const actionPart = ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+                'emptyHintText',
+                'Press {0} to ask {1} to do something. ',
+                keybindingHintLabel,
+                providerName
+            ));
+            const [before, after] = ( actionPart.split(keybindingHintLabel).map((fragment) => {
+                if (this.options.clickable) {
+                    const hintPart = $('a', undefined, fragment);
+                    hintPart.style.fontStyle = 'italic';
+                    hintPart.style.cursor = 'pointer';
+                    this.toDispose.add(addDisposableListener(hintPart, EventType.CLICK, handleClick));
+                    return hintPart;
+                }
+                else {
+                    const hintPart = $('span', undefined, fragment);
+                    hintPart.style.fontStyle = 'italic';
+                    return hintPart;
+                }
+            }));
+            hintElement.appendChild(before);
+            const label = hintHandler.disposables.add(( new KeybindingLabel(hintElement, OS)));
+            label.set(keybindingHint);
+            label.element.style.width = 'min-content';
+            label.element.style.display = 'inline';
+            if (this.options.clickable) {
+                label.element.style.cursor = 'pointer';
+                this.toDispose.add(addDisposableListener(label.element, EventType.CLICK, handleClick));
+            }
+            hintElement.appendChild(after);
+            const typeToDismiss = ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+                'emptyHintTextDismiss',
+                'Start typing to dismiss.'
+            ));
+            const textHint2 = $('span', undefined, typeToDismiss);
+            textHint2.style.fontStyle = 'italic';
+            hintElement.appendChild(textHint2);
+            ariaLabel = actionPart.concat(typeToDismiss);
+        }
+        else {
+            const hintMsg = ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+                {
+                    key: 'inlineChatHint',
+                    comment: [
+                        'Preserve double-square brackets and their order',
+                    ]
+                },
+                '[[Ask {0} to do something]] or start typing to dismiss.',
+                providerName
+            ));
+            const rendered = renderFormattedText(hintMsg, { actionHandler: hintHandler });
+            hintElement.appendChild(rendered);
+        }
+        return { ariaLabel, hintHandler, hintElement };
+    }
+    _getHintDefault() {
+        const hintHandler = {
+            disposables: this.toDispose,
+            callback: (index, event) => {
+                switch (index) {
+                    case '0':
+                        languageOnClickOrTap(event.browserEvent);
+                        break;
+                    case '1':
+                        snippetOnClickOrTap(event.browserEvent);
+                        break;
+                    case '2':
+                        chooseEditorOnClickOrTap(event.browserEvent);
+                        break;
+                    case '3':
+                        dontShowOnClickOrTap();
+                        break;
+                }
+            }
+        };
+        const languageOnClickOrTap = async (e) => {
+            e.stopPropagation();
+            this.editor.focus();
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: ChangeLanguageAction.ID,
+                from: 'hint'
+            });
+            await this.commandService.executeCommand(ChangeLanguageAction.ID, { from: 'hint' });
+            this.editor.focus();
+        };
+        const snippetOnClickOrTap = async (e) => {
+            e.stopPropagation();
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: ApplyFileSnippetAction.Id,
+                from: 'hint'
+            });
+            await this.commandService.executeCommand(ApplyFileSnippetAction.Id);
+        };
+        const chooseEditorOnClickOrTap = async (e) => {
+            e.stopPropagation();
+            const activeEditorInput = this.editorGroupsService.activeGroup.activeEditor;
+            this.telemetryService.publicLog2('workbenchActionExecuted', {
+                id: 'welcome.showNewFileEntries',
+                from: 'hint'
+            });
+            const newEditorSelected = await this.commandService.executeCommand('welcome.showNewFileEntries', { from: 'hint' });
+            if (newEditorSelected && activeEditorInput !== null && activeEditorInput.resource?.scheme === Schemas.untitled) {
+                this.editorGroupsService.activeGroup.closeEditor(activeEditorInput, { preserveFocus: true });
+            }
+        };
+        const dontShowOnClickOrTap = () => {
+            this.configurationService.updateValue(emptyTextEditorHintSetting, 'hidden');
+            this.dispose();
+            this.editor.focus();
+        };
+        const hintMsg = ( localizeWithPath(
+            'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+            {
+                key: 'message',
+                comment: [
+                    'Preserve double-square brackets and their order',
+                    'language refers to a programming language'
+                ]
+            },
+            '[[Select a language]], or [[fill with template]], or [[open a different editor]] to get started.\nStart typing to dismiss or [[don\'t show]] this again.'
+        ));
+        const hintElement = renderFormattedText(hintMsg, {
+            actionHandler: hintHandler,
+            renderCodeSegments: false,
+        });
+        hintElement.style.fontStyle = 'italic';
+        const keybindingsLookup = [ChangeLanguageAction.ID, ApplyFileSnippetAction.Id, 'welcome.showNewFileEntries'];
+        const keybindingLabels = ( keybindingsLookup.map((id) => this.keybindingService.lookupKeybinding(id)?.getLabel() ?? id));
+        const ariaLabel = ( localizeWithPath(
+            'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+            'defaultHintAriaLabel',
+            'Execute {0} to select a language, execute {1} to fill with template, or execute {2} to open a different editor and get started. Start typing to dismiss.',
+            ...keybindingLabels
+        ));
+        for (const anchor of hintElement.querySelectorAll('a')) {
+            anchor.style.cursor = 'pointer';
+            const id = keybindingsLookup.shift();
+            const title = id && this.keybindingService.lookupKeybinding(id)?.getLabel();
+            hintHandler.disposables.add(setupCustomHover(getDefaultHoverDelegate('mouse'), anchor, title ?? ''));
+        }
+        return { hintElement, ariaLabel };
+    }
+    getDomNode() {
+        if (!this.domNode) {
+            this.domNode = $('.empty-editor-hint');
+            this.domNode.style.width = 'max-content';
+            this.domNode.style.paddingLeft = '4px';
+            const inlineChatProviders = [...this.inlineChatService.getAllProvider()];
+            const { hintElement, ariaLabel } = !inlineChatProviders.length ? this._getHintDefault() : this._getHintInlineChat(inlineChatProviders);
+            this.domNode.append(hintElement);
+            this.ariaLabel = ariaLabel.concat(( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/emptyTextEditorHint/emptyTextEditorHint',
+                'disableHint',
+                ' Toggle {0} in settings to disable this hint.',
+                "accessibility.verbosity.emptyEditorHint"
+            )));
+            this.toDispose.add(addDisposableListener(this.domNode, 'click', () => {
+                this.editor.focus();
+            }));
+            this.editor.applyFontInfo(this.domNode);
+        }
+        return this.domNode;
+    }
+    getPosition() {
+        return {
+            position: { lineNumber: 1, column: 1 },
+            preference: [0 ]
+        };
+    }
+    dispose() {
+        this.editor.removeContentWidget(this);
+        dispose(this.toDispose);
+    }
+}
+registerEditorContribution(EmptyTextEditorHintContribution.ID, EmptyTextEditorHintContribution, 0 );
+
+export { EmptyTextEditorHintContribution, emptyTextEditorHintSetting };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/contributedStatusBarItemController.js

@@ -0,0 +1,109 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Throttler } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { NotebookVisibleCellObserver } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/notebookVisibleCellObserver';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { INotebookCellStatusBarService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
+
+let ContributedStatusBarItemController = class ContributedStatusBarItemController extends Disposable {
+    static { this.id = 'workbench.notebook.statusBar.contributed'; }
+    constructor(_notebookEditor, _notebookCellStatusBarService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._notebookCellStatusBarService = _notebookCellStatusBarService;
+        this._visibleCells = ( new Map());
+        this._observer = this._register(( new NotebookVisibleCellObserver(this._notebookEditor)));
+        this._register(this._observer.onDidChangeVisibleCells(this._updateVisibleCells, this));
+        this._updateEverything();
+        this._register(this._notebookCellStatusBarService.onDidChangeProviders(this._updateEverything, this));
+        this._register(this._notebookCellStatusBarService.onDidChangeItems(this._updateEverything, this));
+    }
+    _updateEverything() {
+        const newCells = this._observer.visibleCells.filter(cell => !( this._visibleCells.has(cell.handle)));
+        const visibleCellHandles = ( new Set(( this._observer.visibleCells.map(item => item.handle))));
+        const currentCellHandles = Array.from(( this._visibleCells.keys()));
+        const removedCells = currentCellHandles.filter(handle => !( visibleCellHandles.has(handle)));
+        const itemsToUpdate = currentCellHandles.filter(handle => ( visibleCellHandles.has(handle)));
+        this._updateVisibleCells({ added: newCells, removed: ( removedCells.map(handle => ({ handle }))) });
+        itemsToUpdate.forEach(handle => this._visibleCells.get(handle)?.update());
+    }
+    _updateVisibleCells(e) {
+        const vm = this._notebookEditor.getViewModel();
+        if (!vm) {
+            return;
+        }
+        for (const newCell of e.added) {
+            const helper = ( new CellStatusBarHelper(vm, newCell, this._notebookCellStatusBarService));
+            this._visibleCells.set(newCell.handle, helper);
+        }
+        for (const oldCell of e.removed) {
+            this._visibleCells.get(oldCell.handle)?.dispose();
+            this._visibleCells.delete(oldCell.handle);
+        }
+    }
+    dispose() {
+        super.dispose();
+        this._visibleCells.forEach(cell => cell.dispose());
+        this._visibleCells.clear();
+    }
+};
+ContributedStatusBarItemController = ( __decorate([
+    ( __param(1, INotebookCellStatusBarService))
+], ContributedStatusBarItemController));
+class CellStatusBarHelper extends Disposable {
+    constructor(_notebookViewModel, _cell, _notebookCellStatusBarService) {
+        super();
+        this._notebookViewModel = _notebookViewModel;
+        this._cell = _cell;
+        this._notebookCellStatusBarService = _notebookCellStatusBarService;
+        this._currentItemIds = [];
+        this._currentItemLists = [];
+        this._isDisposed = false;
+        this._updateThrottler = this._register(( new Throttler()));
+        this._register(toDisposable(() => this._activeToken?.dispose(true)));
+        this._updateSoon();
+        this._register(this._cell.model.onDidChangeContent(() => this._updateSoon()));
+        this._register(this._cell.model.onDidChangeLanguage(() => this._updateSoon()));
+        this._register(this._cell.model.onDidChangeMetadata(() => this._updateSoon()));
+        this._register(this._cell.model.onDidChangeInternalMetadata(() => this._updateSoon()));
+        this._register(this._cell.model.onDidChangeOutputs(() => this._updateSoon()));
+    }
+    update() {
+        this._updateSoon();
+    }
+    _updateSoon() {
+        setTimeout(() => {
+            if (!this._isDisposed) {
+                this._updateThrottler.queue(() => this._update());
+            }
+        }, 0);
+    }
+    async _update() {
+        const cellIndex = this._notebookViewModel.getCellIndex(this._cell);
+        const docUri = this._notebookViewModel.notebookDocument.uri;
+        const viewType = this._notebookViewModel.notebookDocument.viewType;
+        this._activeToken?.dispose(true);
+        const tokenSource = this._activeToken = ( new CancellationTokenSource());
+        const itemLists = await this._notebookCellStatusBarService.getStatusBarItemsForCell(docUri, cellIndex, viewType, tokenSource.token);
+        if (tokenSource.token.isCancellationRequested) {
+            itemLists.forEach(itemList => itemList.dispose && itemList.dispose());
+            return;
+        }
+        const items = ( itemLists.map(itemList => itemList.items)).flat();
+        const newIds = this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{ handle: this._cell.handle, items }]);
+        this._currentItemLists.forEach(itemList => itemList.dispose && itemList.dispose());
+        this._currentItemLists = itemLists;
+        this._currentItemIds = newIds;
+    }
+    dispose() {
+        super.dispose();
+        this._isDisposed = true;
+        this._activeToken?.dispose(true);
+        this._notebookViewModel.deltaCellStatusBarItems(this._currentItemIds, [{ handle: this._cell.handle, items: [] }]);
+        this._currentItemLists.forEach(itemList => itemList.dispose && itemList.dispose());
+    }
+}
+registerNotebookContribution(ContributedStatusBarItemController.id, ContributedStatusBarItemController);
+
+export { ContributedStatusBarItemController };