@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,216 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { coalesce } from '../../../../base/common/arrays.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { UNKNOWN_EMPTY_WINDOW_WORKSPACE, IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IWorkingCopyBackupService } from '../../../services/workingCopy/common/workingCopyBackup.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { joinPath } from '../../../../base/common/resources.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { GettingStartedInput, gettingStartedInputTypeId } from './gettingStartedInput.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { getTelemetryLevel } from '../../../../platform/telemetry/common/telemetryUtils.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+const restoreWalkthroughsConfigurationKey = 'workbench.welcomePage.restorableWalkthroughs';
+const configurationKey = 'workbench.startupEditor';
+const oldConfigurationKey = 'workbench.welcome.enabled';
+const telemetryOptOutStorageKey = 'workbench.telemetryOptOutShown';
+let StartupPageEditorResolverContribution = class StartupPageEditorResolverContribution {
+    static { this.ID = 'workbench.contrib.startupPageEditorResolver'; }
+    constructor(instantiationService, editorResolverService) {
+        this.instantiationService = instantiationService;
+        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
+                    }
+                };
+            }
+        });
+    }
+};
+StartupPageEditorResolverContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IEditorResolverService))
+], StartupPageEditorResolverContribution));
+let StartupPageRunnerContribution = class StartupPageRunnerContribution {
+    static { this.ID = 'workbench.contrib.startupPageRunner'; }
+    constructor(configurationService, editorService, workingCopyBackupService, fileService, contextService, lifecycleService, layoutService, productService, commandService, environmentService, storageService, logService, notificationService) {
+        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;
+        this.run().then(undefined, onUnexpectedError);
+    }
+    async run() {
+        await this.lifecycleService.when(3 );
+        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();
+                }
+                else if (startupEditorSetting.value === 'terminal') {
+                    this.commandService.executeCommand("workbench.action.createTerminalEditor" );
+                }
+            }
+        }
+    }
+    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 = 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 },
+            });
+        }
+    }
+};
+StartupPageRunnerContribution = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IWorkingCopyBackupService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, ILifecycleService)),
+    ( __param(6, IWorkbenchLayoutService)),
+    ( __param(7, IProductService)),
+    ( __param(8, ICommandService)),
+    ( __param(9, IWorkbenchEnvironmentService)),
+    ( __param(10, IStorageService)),
+    ( __param(11, ILogService)),
+    ( __param(12, INotificationService))
+], StartupPageRunnerContribution));
+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')
+        || startupEditor.value === 'terminal';
+}
+export { StartupPageEditorResolverContribution, StartupPageRunnerContribution, restoreWalkthroughsConfigurationKey };

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

@@ -0,0 +1,237 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { promiseWithResolvers } from '../../../../base/common/async.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { assertIsDefined } from '../../../../base/common/types.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { registerAction2, MenuRegistry, MenuId, MenuItemAction, Action2, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+var NewFileTemplatesManager_1;
+const builtInSource = ( localizeWithPath(
+    'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+    'Built-In',
+    "Built-In"
+));
+const category = ( localize2WithPath(
+    'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+    'Create',
+    'Create'
+));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'welcome.showNewFileEntries',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/welcomeViews/common/newFile.contribution',
+                'welcome.newFile',
+                '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) {
+        const { promise: resultPromise, resolve: resolveResult } = promiseWithResolvers();
+        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,18 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { ViewsWelcomeContribution } from './viewsWelcomeContribution.js';
+import { viewsWelcomeExtensionPointDescriptor } from './viewsWelcomeExtensionPoint.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+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 );

package/vscode/src/vs/workbench/contrib/welcomeViews/common/viewsWelcomeContribution.js

@@ -0,0 +1,73 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { ViewIdentifierMap } from './viewsWelcomeExtensionPoint.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../common/views.js';
+import { isProposedApiEnabled } from '../../../services/extensions/common/extensions.js';
+const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+class ViewsWelcomeContribution extends Disposable {
+    constructor(extensionPoint) {
+        super();
+        this.viewWelcomeContents = ( new Map());
+        extensionPoint.setHandler((_, { added, removed }) => {
+            for (const contribution of removed) {
+                for (const welcome of contribution.value) {
+                    const disposable = this.viewWelcomeContents.get(welcome);
+                    disposable?.dispose();
+                }
+            }
+            const welcomesByViewId = ( new Map());
+            for (const contribution of added) {
+                for (const welcome of contribution.value) {
+                    const { group, order } = parseGroupAndOrder(welcome, contribution);
+                    const precondition = ContextKeyExpr.deserialize(welcome.enablement);
+                    const id = ViewIdentifierMap[welcome.view] ?? welcome.view;
+                    let viewContentMap = welcomesByViewId.get(id);
+                    if (!viewContentMap) {
+                        viewContentMap = ( new Map());
+                        welcomesByViewId.set(id, viewContentMap);
+                    }
+                    viewContentMap.set(welcome, {
+                        content: welcome.contents,
+                        when: ContextKeyExpr.deserialize(welcome.when),
+                        precondition,
+                        group,
+                        order
+                    });
+                }
+            }
+            for (const [id, viewContentMap] of welcomesByViewId) {
+                const disposables = viewsRegistry.registerViewWelcomeContent2(id, viewContentMap);
+                for (const [welcome, disposable] of disposables) {
+                    this.viewWelcomeContents.set(welcome, disposable);
+                }
+            }
+        });
+    }
+}
+function parseGroupAndOrder(welcome, contribution) {
+    let group;
+    let order;
+    if (welcome.group) {
+        if (!isProposedApiEnabled(contribution.description, 'contribViewsWelcome')) {
+            contribution.collector.warn(( localizeWithPath(
+                'vs/workbench/contrib/welcomeViews/common/viewsWelcomeContribution',
+                'ViewsWelcomeExtensionPoint.proposedAPI',
+                "The viewsWelcome contribution in '{0}' requires 'enabledApiProposals: [\"contribViewsWelcome\"]' in order to use the 'group' proposed property.",
+                contribution.description.identifier.value
+            )));
+            return { group, order };
+        }
+        const idx = welcome.group.lastIndexOf('@');
+        if (idx > 0) {
+            group = welcome.group.substr(0, idx);
+            order = Number(welcome.group.substr(idx + 1)) || undefined;
+        }
+        else {
+            group = welcome.group;
+        }
+    }
+    return { group, order };
+}
+export { ViewsWelcomeContribution };

package/vscode/src/vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint.js

@@ -0,0 +1,97 @@
+import { localizeWithPath } from '../../../../nls.js';
+var ViewsWelcomeExtensionPointFields;
+( (function(ViewsWelcomeExtensionPointFields) {
+    ViewsWelcomeExtensionPointFields["view"] = "view";
+    ViewsWelcomeExtensionPointFields["contents"] = "contents";
+    ViewsWelcomeExtensionPointFields["when"] = "when";
+    ViewsWelcomeExtensionPointFields["group"] = "group";
+    ViewsWelcomeExtensionPointFields["enablement"] = "enablement";
+})(
+    ViewsWelcomeExtensionPointFields || (ViewsWelcomeExtensionPointFields = {})
+));
+const ViewIdentifierMap = {
+    'explorer': 'workbench.explorer.emptyView',
+    'debug': 'workbench.debug.welcome',
+    'scm': 'workbench.scm',
+    'testing': 'workbench.view.testing'
+};
+const viewsWelcomeExtensionPointSchema = ( Object.freeze({
+    type: 'array',
+    description: ( localizeWithPath(
+        'vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint',
+        'contributes.viewsWelcome',
+        "Contributed views welcome content. Welcome content will be rendered in tree based views whenever they have no meaningful content to display, ie. the File Explorer when no folder is open. Such content is useful as in-product documentation to drive users to use certain features before they are available. A good example would be a `Clone Repository` button in the File Explorer welcome view."
+    )),
+    items: {
+        type: 'object',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint',
+            'contributes.viewsWelcome.view',
+            "Contributed welcome content for a specific view."
+        )),
+        required: [
+            ViewsWelcomeExtensionPointFields.view,
+            ViewsWelcomeExtensionPointFields.contents
+        ],
+        properties: {
+            [ViewsWelcomeExtensionPointFields.view]: {
+                anyOf: [
+                    {
+                        type: 'string',
+                        description: ( localizeWithPath(
+                            'vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint',
+                            'contributes.viewsWelcome.view.view',
+                            "Target view identifier for this welcome content. Only tree based views are supported."
+                        ))
+                    },
+                    {
+                        type: 'string',
+                        description: ( localizeWithPath(
+                            'vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint',
+                            'contributes.viewsWelcome.view.view',
+                            "Target view identifier for this welcome content. Only tree based views are supported."
+                        )),
+                        enum: ( Object.keys(ViewIdentifierMap))
+                    }
+                ]
+            },
+            [ViewsWelcomeExtensionPointFields.contents]: {
+                type: 'string',
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint',
+                    'contributes.viewsWelcome.view.contents',
+                    "Welcome content to be displayed. The format of the contents is a subset of Markdown, with support for links only."
+                )),
+            },
+            [ViewsWelcomeExtensionPointFields.when]: {
+                type: 'string',
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint',
+                    'contributes.viewsWelcome.view.when',
+                    "Condition when the welcome content should be displayed."
+                )),
+            },
+            [ViewsWelcomeExtensionPointFields.group]: {
+                type: 'string',
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint',
+                    'contributes.viewsWelcome.view.group',
+                    "Group to which this welcome content belongs. Proposed API."
+                )),
+            },
+            [ViewsWelcomeExtensionPointFields.enablement]: {
+                type: 'string',
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/welcomeViews/common/viewsWelcomeExtensionPoint',
+                    'contributes.viewsWelcome.view.enablement',
+                    "Condition when the welcome content buttons and command links should be enabled."
+                )),
+            },
+        }
+    }
+}));
+const viewsWelcomeExtensionPointDescriptor = {
+    extensionPoint: 'viewsWelcome',
+    jsonSchema: viewsWelcomeExtensionPointSchema
+};
+export { ViewIdentifierMap, ViewsWelcomeExtensionPointFields, viewsWelcomeExtensionPointDescriptor };