@codingame/monaco-vscode-welcome-service-override 1.85.1

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/startupPage.js

@@ -0,0 +1,205 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { UNKNOWN_EMPTY_WINDOW_WORKSPACE, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+import { GettingStartedInput, gettingStartedInputTypeId } from './gettingStartedInput.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { getTelemetryLevel } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { RegisteredEditorPriority, IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+
+const restoreWalkthroughsConfigurationKey = 'workbench.welcomePage.restorableWalkthroughs';
+const configurationKey = 'workbench.startupEditor';
+const oldConfigurationKey = 'workbench.welcome.enabled';
+const telemetryOptOutStorageKey = 'workbench.telemetryOptOutShown';
+let StartupPageContribution = class StartupPageContribution {
+    constructor(instantiationService, configurationService, editorService, workingCopyBackupService, fileService, contextService, lifecycleService, layoutService, productService, commandService, environmentService, storageService, logService, notificationService, editorResolverService) {
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.editorService = editorService;
+        this.workingCopyBackupService = workingCopyBackupService;
+        this.fileService = fileService;
+        this.contextService = contextService;
+        this.lifecycleService = lifecycleService;
+        this.layoutService = layoutService;
+        this.productService = productService;
+        this.commandService = commandService;
+        this.environmentService = environmentService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this.notificationService = notificationService;
+        editorResolverService.registerEditor(`${GettingStartedInput.RESOURCE.scheme}:/**`, {
+            id: GettingStartedInput.ID,
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/welcomeGettingStarted/browser/startupPage',
+                'welcome.displayName',
+                "Welcome Page"
+            )),
+            priority: RegisteredEditorPriority.builtin,
+        }, {
+            singlePerResource: false,
+            canSupportResource: uri => uri.scheme === GettingStartedInput.RESOURCE.scheme,
+        }, {
+            createEditorInput: ({ resource, options }) => {
+                return {
+                    editor: this.instantiationService.createInstance(GettingStartedInput, options),
+                    options: {
+                        ...options,
+                        pinned: false
+                    }
+                };
+            }
+        });
+        this.run().then(undefined, onUnexpectedError);
+    }
+    async run() {
+        if (this.productService.enableTelemetry
+            && this.productService.showTelemetryOptOut
+            && getTelemetryLevel(this.configurationService) !== 0
+            && !this.environmentService.skipWelcome
+            && !this.storageService.get(telemetryOptOutStorageKey, 0 )) {
+            this.storageService.store(telemetryOptOutStorageKey, true, 0 , 0 );
+            await this.openGettingStarted(true);
+            return;
+        }
+        if (this.tryOpenWalkthroughForFolder()) {
+            return;
+        }
+        const enabled = isStartupPageEnabled(this.configurationService, this.contextService, this.environmentService);
+        if (enabled && this.lifecycleService.startupKind !== 3 ) {
+            const hasBackups = await this.workingCopyBackupService.hasBackups();
+            if (hasBackups) {
+                return;
+            }
+            if (!this.editorService.activeEditor || this.layoutService.openedDefaultEditors) {
+                const startupEditorSetting = this.configurationService.inspect(configurationKey);
+                const isStartupEditorReadme = startupEditorSetting.value === 'readme';
+                const isStartupEditorUserReadme = startupEditorSetting.userValue === 'readme';
+                const isStartupEditorDefaultReadme = startupEditorSetting.defaultValue === 'readme';
+                if (isStartupEditorReadme && (!isStartupEditorUserReadme || !isStartupEditorDefaultReadme)) {
+                    this.logService.warn(`Warning: 'workbench.startupEditor: readme' setting ignored due to being set somewhere other than user or default settings (user=${startupEditorSetting.userValue}, default=${startupEditorSetting.defaultValue})`);
+                }
+                const openWithReadme = isStartupEditorReadme && (isStartupEditorUserReadme || isStartupEditorDefaultReadme);
+                if (openWithReadme) {
+                    await this.openReadme();
+                }
+                else if (startupEditorSetting.value === 'welcomePage' || startupEditorSetting.value === 'welcomePageInEmptyWorkbench') {
+                    await this.openGettingStarted();
+                }
+            }
+        }
+    }
+    tryOpenWalkthroughForFolder() {
+        const toRestore = this.storageService.get(restoreWalkthroughsConfigurationKey, 0 );
+        if (!toRestore) {
+            return false;
+        }
+        else {
+            const restoreData = JSON.parse(toRestore);
+            const currentWorkspace = this.contextService.getWorkspace();
+            if (restoreData.folder === UNKNOWN_EMPTY_WINDOW_WORKSPACE.id || restoreData.folder === ( currentWorkspace.folders[0].uri.toString())) {
+                this.editorService.openEditor({
+                    resource: GettingStartedInput.RESOURCE,
+                    options: { selectedCategory: restoreData.category, selectedStep: restoreData.step, pinned: false },
+                });
+                this.storageService.remove(restoreWalkthroughsConfigurationKey, 0 );
+                return true;
+            }
+        }
+        return false;
+    }
+    async openReadme() {
+        const readmes = arrays.coalesce(await Promise.all(( this.contextService.getWorkspace().folders.map(async (folder) => {
+            const folderUri = folder.uri;
+            const folderStat = await this.fileService.resolve(folderUri).catch(onUnexpectedError);
+            const files = folderStat?.children ? ( folderStat.children.map(child => child.name)).sort() : [];
+            const file = files.find(file => file.toLowerCase() === 'readme.md') || files.find(file => file.toLowerCase().startsWith('readme'));
+            if (file) {
+                return joinPath(folderUri, file);
+            }
+            else {
+                return undefined;
+            }
+        }))));
+        if (!this.editorService.activeEditor) {
+            if (readmes.length) {
+                const isMarkDown = (readme) => readme.path.toLowerCase().endsWith('.md');
+                await Promise.all([
+                    this.commandService.executeCommand('markdown.showPreview', null, readmes.filter(isMarkDown), { locked: true }).catch(error => {
+                        this.notificationService.error(( localizeWithPath(
+                            'vs/workbench/contrib/welcomeGettingStarted/browser/startupPage',
+                            'startupPage.markdownPreviewError',
+                            'Could not open markdown preview: {0}.\n\nPlease make sure the markdown extension is enabled.',
+                            error.message
+                        )));
+                    }),
+                    this.editorService.openEditors(( readmes.filter(readme => !isMarkDown(readme)).map(readme => ({ resource: readme })))),
+                ]);
+            }
+            else {
+                await this.openGettingStarted();
+            }
+        }
+    }
+    async openGettingStarted(showTelemetryNotice) {
+        const startupEditorTypeID = gettingStartedInputTypeId;
+        const editor = this.editorService.activeEditor;
+        if (editor?.typeId === startupEditorTypeID || ( this.editorService.editors.some(e => e.typeId === startupEditorTypeID))) {
+            return;
+        }
+        const options = editor ? { pinned: false, index: 0 } : { pinned: false };
+        {
+            this.editorService.openEditor({
+                resource: GettingStartedInput.RESOURCE,
+                options: { showTelemetryNotice, ...options },
+            });
+        }
+    }
+};
+StartupPageContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, IWorkingCopyBackupService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IWorkspaceContextService)),
+    ( __param(6, ILifecycleService)),
+    ( __param(7, IWorkbenchLayoutService)),
+    ( __param(8, IProductService)),
+    ( __param(9, ICommandService)),
+    ( __param(10, IWorkbenchEnvironmentService)),
+    ( __param(11, IStorageService)),
+    ( __param(12, ILogService)),
+    ( __param(13, INotificationService)),
+    ( __param(14, IEditorResolverService))
+], StartupPageContribution));
+function isStartupPageEnabled(configurationService, contextService, environmentService) {
+    if (environmentService.skipWelcome) {
+        return false;
+    }
+    const startupEditor = configurationService.inspect(configurationKey);
+    if (!startupEditor.userValue && !startupEditor.workspaceValue) {
+        const welcomeEnabled = configurationService.inspect(oldConfigurationKey);
+        if (welcomeEnabled.value !== undefined && welcomeEnabled.value !== null) {
+            return welcomeEnabled.value;
+        }
+    }
+    return startupEditor.value === 'welcomePage'
+        || startupEditor.value === 'readme' && (startupEditor.userValue === 'readme' || startupEditor.defaultValue === 'readme')
+        || (contextService.getWorkbenchState() === 1  && startupEditor.value === 'welcomePageInEmptyWorkbench');
+}
+
+export { StartupPageContribution, restoreWalkthroughsConfigurationKey };

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/common/media/all.png.js

@@ -0,0 +1,8 @@
+var pngAssets = {
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/dark-hc.png': new URL('../../../../../../../../assets/dark-hc.png', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/dark.png': new URL('../../../../../../../../assets/dark.png', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/light-hc.png': new URL('../../../../../../../../assets/light-hc.png', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/light.png': new URL('../../../../../../../../assets/light.png', import.meta.url).href
+};
+
+export { pngAssets as default };

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/common/media/all.svg.js

@@ -0,0 +1,21 @@
+var svgAssets = {
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/commandPalette.svg': new URL('../../../../../../../../assets/commandPalette.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/debug.svg': new URL('../../../../../../../../assets/debug.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/extensions-web.svg': new URL('../../../../../../../../assets/extensions-web.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/extensions.svg': new URL('../../../../../../../../assets/extensions.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/git.svg': new URL('../../../../../../../../assets/git.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/languages.svg': new URL('../../../../../../../../assets/languages.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/learn.svg': new URL('../../../../../../../../assets/learn.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/menuBar.svg': new URL('../../../../../../../../assets/menuBar.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/openFolder.svg': new URL('../../../../../../../../assets/openFolder.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/profiles.svg': new URL('../../../../../../../../assets/profiles.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/runTask.svg': new URL('../../../../../../../../assets/runTask.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/search.svg': new URL('../../../../../../../../assets/search.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/settings.svg': new URL('../../../../../../../../assets/settings.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/settingsSync.svg': new URL('../../../../../../../../assets/settingsSync.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/shortcuts.svg': new URL('../../../../../../../../assets/shortcuts.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/terminal.svg': new URL('../../../../../../../../assets/terminal.svg', import.meta.url).href,
+  'vs/workbench/contrib/welcomeGettingStarted/common/media/workspaceTrust.svg': new URL('../../../../../../../../assets/workspaceTrust.svg', import.meta.url).href
+};
+
+export { svgAssets as default };

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/common/media/notebookProfile.js

@@ -0,0 +1,37 @@
+import { escape } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+
+const profileArg = (profile) => encodeURIComponent(JSON.stringify({ profile }));
+const imageSize = 400;
+var notebookProfile = () => `
+<vertically-centered>
+<checklist>
+	<checkbox on-checked="command:notebook.setProfile?${profileArg('default')}" checked-on="config.notebook.cellFocusIndicator == 'border' && config.notebook.insertToolbarLocation == 'both' && config.notebook.globalToolbar == false && config.notebook.compactView == true && config.notebook.showCellStatusBar == 'visible'">
+		<img width="${imageSize}" src="./notebookThemes/default.png"/>
+		${escape(( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/common/media/notebookProfile',
+    'default',
+    "Default"
+)))}
+	</checkbox>
+	<checkbox on-checked="command:notebook.setProfile?${profileArg('jupyter')}" checked-on="config.notebook.cellFocusIndicator == 'gutter' && config.notebook.insertToolbarLocation == 'notebookToolbar' && config.notebook.globalToolbar == true && config.notebook.compactView == true  && config.notebook.showCellStatusBar == 'visible'">
+		<img width="${imageSize}" src="./notebookThemes/jupyter.png"/>
+		${escape(( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/common/media/notebookProfile',
+    'jupyter',
+    "Jupyter"
+)))}
+	</checkbox>
+	<checkbox on-checked="command:notebook.setProfile?${profileArg('colab')}" checked-on="config.notebook.cellFocusIndicator == 'border' && config.notebook.insertToolbarLocation == 'betweenCells' && config.notebook.globalToolbar == false && config.notebook.compactView == false && config.notebook.showCellStatusBar == 'hidden'">
+		<img width="${imageSize}" src="./notebookThemes/colab.png"/>
+		${escape(( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/common/media/notebookProfile',
+    'colab',
+    "Colab"
+)))}
+	</checkbox>
+</checklist>
+</vertically-centered>
+`;
+
+export { notebookProfile as default };

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/common/media/theme_picker.js

@@ -0,0 +1,53 @@
+import { escape } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ThemeSettingDefaults } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
+
+var theme_picker = () => `
+<checklist>
+	<div class="theme-picker-row">
+		<checkbox when-checked="setTheme:${ThemeSettingDefaults.COLOR_THEME_DARK}" checked-on="config.workbench.colorTheme == '${ThemeSettingDefaults.COLOR_THEME_DARK}'">
+			<img width="200" src="./dark.png"/>
+			${escape(( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/common/media/theme_picker',
+    'dark',
+    "Dark Modern"
+)))}
+		</checkbox>
+		<checkbox when-checked="setTheme:${ThemeSettingDefaults.COLOR_THEME_LIGHT}" checked-on="config.workbench.colorTheme == '${ThemeSettingDefaults.COLOR_THEME_LIGHT}'">
+			<img width="200" src="./light.png"/>
+			${escape(( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/common/media/theme_picker',
+    'light',
+    "Light Modern"
+)))}
+		</checkbox>
+	</div>
+	<div class="theme-picker-row">
+		<checkbox when-checked="setTheme:${ThemeSettingDefaults.COLOR_THEME_HC_DARK}" checked-on="config.workbench.colorTheme == '${ThemeSettingDefaults.COLOR_THEME_HC_DARK}'">
+			<img width="200" src="./dark-hc.png"/>
+			${escape(( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/common/media/theme_picker',
+    'HighContrast',
+    "Dark High Contrast"
+)))}
+		</checkbox>
+		<checkbox when-checked="setTheme:${ThemeSettingDefaults.COLOR_THEME_HC_LIGHT}" checked-on="config.workbench.colorTheme == '${ThemeSettingDefaults.COLOR_THEME_HC_LIGHT}'">
+			<img width="200" src="./light-hc.png"/>
+			${escape(( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/common/media/theme_picker',
+    'HighContrastLight',
+    "Light High Contrast"
+)))}
+		</checkbox>
+	</div>
+</checklist>
+<checkbox class="theme-picker-link" when-checked="command:workbench.action.selectTheme" checked-on="false">
+	${escape(( localizeWithPath(
+    'vs/workbench/contrib/welcomeGettingStarted/common/media/theme_picker',
+    'seeMore',
+    "See More Themes..."
+)))}
+</checkbox>
+`;
+
+export { theme_picker as default };

package/vscode/src/vs/workbench/contrib/welcomeViews/common/newFile.contribution.js

@@ -0,0 +1,240 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId, MenuItemAction, MenuRegistry, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+
+var NewFileTemplatesManager_1;
+const builtInSource = ( localizeWithPath(
+    'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+    'Built-In',
+    "Built-In"
+));
+const category = { value: ( localizeWithPath(
+    'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+    'Create',
+    "Create"
+)), original: 'Create' };
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'welcome.showNewFileEntries',
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+                'welcome.newFile',
+                "New File..."
+            )), original: 'New File...' },
+            category,
+            f1: true,
+            keybinding: {
+                primary: 512  + 2048  + 256  + 44 ,
+                weight: 200 ,
+            },
+            menu: {
+                id: MenuId.MenubarFileMenu,
+                group: '1_new',
+                order: 2
+            }
+        });
+    }
+    async run(accessor) {
+        return assertIsDefined(NewFileTemplatesManager.Instance).run();
+    }
+});
+let NewFileTemplatesManager = class NewFileTemplatesManager extends Disposable {
+    static { NewFileTemplatesManager_1 = this; }
+    constructor(quickInputService, contextKeyService, commandService, keybindingService, menuService) {
+        super();
+        this.quickInputService = quickInputService;
+        this.contextKeyService = contextKeyService;
+        this.commandService = commandService;
+        this.keybindingService = keybindingService;
+        NewFileTemplatesManager_1.Instance = this;
+        this._register({ dispose() { if (NewFileTemplatesManager_1.Instance === this) {
+                NewFileTemplatesManager_1.Instance = undefined;
+            } } });
+        this.menu = menuService.createMenu(MenuId.NewFile, contextKeyService);
+    }
+    allEntries() {
+        const items = [];
+        for (const [groupName, group] of this.menu.getActions({ renderShortTitle: true })) {
+            for (const action of group) {
+                if (action instanceof MenuItemAction) {
+                    items.push({ commandID: action.item.id, from: action.item.source?.title ?? builtInSource, title: action.label, group: groupName });
+                }
+            }
+        }
+        return items;
+    }
+    async run() {
+        const entries = this.allEntries();
+        if (entries.length === 0) {
+            throw Error('Unexpected empty new items list');
+        }
+        else if (entries.length === 1) {
+            this.commandService.executeCommand(entries[0].commandID);
+            return true;
+        }
+        else {
+            return this.selectNewEntry(entries);
+        }
+    }
+    async selectNewEntry(entries) {
+        let resolveResult;
+        const resultPromise = ( new Promise(resolve => {
+            resolveResult = resolve;
+        }));
+        const disposables = ( new DisposableStore());
+        const qp = this.quickInputService.createQuickPick();
+        qp.title = ( localizeWithPath(
+            'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+            'newFileTitle',
+            "New File..."
+        ));
+        qp.placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+            'newFilePlaceholder',
+            "Select File Type or Enter File Name..."
+        ));
+        qp.sortByLabel = false;
+        qp.matchOnDetail = true;
+        qp.matchOnDescription = true;
+        const sortCategories = (a, b) => {
+            const categoryPriority = { 'file': 1, 'notebook': 2 };
+            if (categoryPriority[a.group] && categoryPriority[b.group]) {
+                if (categoryPriority[a.group] !== categoryPriority[b.group]) {
+                    return categoryPriority[b.group] - categoryPriority[a.group];
+                }
+            }
+            else if (categoryPriority[a.group]) {
+                return 1;
+            }
+            else if (categoryPriority[b.group]) {
+                return -1;
+            }
+            if (a.from === builtInSource) {
+                return 1;
+            }
+            if (b.from === builtInSource) {
+                return -1;
+            }
+            return a.from.localeCompare(b.from);
+        };
+        const displayCategory = {
+            'file': ( localizeWithPath(
+                'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+                'file',
+                "File"
+            )),
+            'notebook': ( localizeWithPath(
+                'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+                'notebook',
+                "Notebook"
+            )),
+        };
+        const refreshQp = (entries) => {
+            const items = [];
+            let lastSeparator;
+            entries
+                .sort((a, b) => -sortCategories(a, b))
+                .forEach((entry) => {
+                const command = entry.commandID;
+                const keybinding = this.keybindingService.lookupKeybinding(command || '', this.contextKeyService);
+                if (lastSeparator !== entry.group) {
+                    items.push({
+                        type: 'separator',
+                        label: displayCategory[entry.group] ?? entry.group
+                    });
+                    lastSeparator = entry.group;
+                }
+                items.push({
+                    ...entry,
+                    label: entry.title,
+                    type: 'item',
+                    keybinding,
+                    buttons: command ? [
+                        {
+                            iconClass: 'codicon codicon-gear',
+                            tooltip: ( localizeWithPath(
+                                'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+                                'change keybinding',
+                                "Configure Keybinding"
+                            ))
+                        }
+                    ] : [],
+                    detail: '',
+                    description: entry.from,
+                });
+            });
+            qp.items = items;
+        };
+        refreshQp(entries);
+        disposables.add(this.menu.onDidChange(() => refreshQp(this.allEntries())));
+        disposables.add(qp.onDidChangeValue((val) => {
+            if (val === '') {
+                refreshQp(entries);
+                return;
+            }
+            const currentTextEntry = {
+                commandID: 'workbench.action.files.newFile',
+                commandArgs: { languageId: undefined, viewType: undefined, fileName: val },
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+                    'miNewFileWithName',
+                    "Create New File ({0})",
+                    val
+                )),
+                group: 'file',
+                from: builtInSource,
+            };
+            refreshQp([currentTextEntry, ...entries]);
+        }));
+        disposables.add(qp.onDidAccept(async (e) => {
+            const selected = qp.selectedItems[0];
+            resolveResult(!!selected);
+            qp.hide();
+            if (selected) {
+                await this.commandService.executeCommand(selected.commandID, selected.commandArgs);
+            }
+        }));
+        disposables.add(qp.onDidHide(() => {
+            qp.dispose();
+            disposables.dispose();
+            resolveResult(false);
+        }));
+        disposables.add(qp.onDidTriggerItemButton(e => {
+            qp.hide();
+            this.commandService.executeCommand('workbench.action.openGlobalKeybindings', e.item.commandID);
+            resolveResult(false);
+        }));
+        qp.show();
+        return resultPromise;
+    }
+};
+NewFileTemplatesManager = NewFileTemplatesManager_1 = ( __decorate([
+    ( __param(0, IQuickInputService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IMenuService))
+], NewFileTemplatesManager));
+( Registry.as(Extensions.Workbench))
+    .registerWorkbenchContribution(NewFileTemplatesManager, 3 );
+MenuRegistry.appendMenuItem(MenuId.NewFile, {
+    group: 'file',
+    command: {
+        id: 'workbench.action.files.newUntitledFile',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+            'miNewFile2',
+            "Text File"
+        ))
+    },
+    order: 1
+});

package/vscode/src/vs/workbench/contrib/welcomeViews/common/viewsWelcome.contribution.js

@@ -0,0 +1,19 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { ViewsWelcomeContribution } from './viewsWelcomeContribution.js';
+import { viewsWelcomeExtensionPointDescriptor } from './viewsWelcomeExtensionPoint.js';
+import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+
+const extensionPoint = ( ExtensionsRegistry.registerExtensionPoint(viewsWelcomeExtensionPointDescriptor));
+let WorkbenchConfigurationContribution = class WorkbenchConfigurationContribution {
+    constructor(instantiationService) {
+        instantiationService.createInstance(ViewsWelcomeContribution, extensionPoint);
+    }
+};
+WorkbenchConfigurationContribution = ( __decorate([
+    ( __param(0, IInstantiationService))
+], WorkbenchConfigurationContribution));
+( Registry.as(Extensions.Workbench))
+    .registerWorkbenchContribution(WorkbenchConfigurationContribution, 3 );