@codingame/monaco-vscode-api 1.80.0 → 1.80.1

package/dist/vscode/vs/workbench/contrib/snippets/browser/commands/configureSnippets.js

@@ -0,0 +1,264 @@
+import { isValidBasename } from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { extname } from 'monaco-editor/esm/vs/base/common/path.js';
+import { basename, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { SnippetsAction } from './abstractSnippetsActions.js';
+import { ISnippetsService } from '../snippets.js';
+import { ITextFileService } from '../../../../services/textfile/common/textfiles.js';
+import { IUserDataProfileService } from '../../../../services/userDataProfile/common/userDataProfile.js';
+var ISnippetPick;
+( (function(ISnippetPick) {
+    function is(thing) {
+        return !!thing && URI.isUri(thing.filepath);
+    }
+    ISnippetPick.is = is;
+})(ISnippetPick || (ISnippetPick = {})));
+async function computePicks(snippetService, userDataProfileService, languageService, labelService) {
+    const existing = [];
+    const future = [];
+    const seen = ( new Set());
+    const added = ( new Map());
+    for (const file of await snippetService.getSnippetFiles()) {
+        if (file.source === 3 ) {
+            continue;
+        }
+        if (file.isGlobalSnippets) {
+            await file.load();
+            const names = ( new Set());
+            let source;
+            outer: for (const snippet of file.data) {
+                if (!source) {
+                    source = snippet.source;
+                }
+                for (const scope of snippet.scopes) {
+                    const name = languageService.getLanguageName(scope);
+                    if (name) {
+                        if (names.size >= 4) {
+                            names.add(`${name}...`);
+                            break outer;
+                        }
+                        else {
+                            names.add(name);
+                        }
+                    }
+                }
+            }
+            const snippet = {
+                label: basename(file.location),
+                filepath: file.location,
+                description: names.size === 0
+                    ? ( nls.localize('global.scope', "(global)"))
+                    : ( nls.localize('global.1', "({0})", [...names].join(', ')))
+            };
+            existing.push(snippet);
+            if (!source) {
+                continue;
+            }
+            const detail = ( nls.localize(
+                'detail.label',
+                "({0}) {1}",
+                source,
+                labelService.getUriLabel(file.location, { relative: true })
+            ));
+            const lastItem = added.get(basename(file.location));
+            if (lastItem) {
+                snippet.detail = detail;
+                lastItem.snippet.detail = lastItem.detail;
+            }
+            added.set(basename(file.location), { snippet, detail });
+        }
+        else {
+            const mode = basename(file.location).replace(/\.json$/, '');
+            existing.push({
+                label: basename(file.location),
+                description: `(${languageService.getLanguageName(mode)})`,
+                filepath: file.location
+            });
+            seen.add(mode);
+        }
+    }
+    const dir = userDataProfileService.currentProfile.snippetsHome;
+    for (const languageId of languageService.getRegisteredLanguageIds()) {
+        const label = languageService.getLanguageName(languageId);
+        if (label && !( seen.has(languageId))) {
+            future.push({
+                label: languageId,
+                description: `(${label})`,
+                filepath: joinPath(dir, `${languageId}.json`),
+                hint: true
+            });
+        }
+    }
+    existing.sort((a, b) => {
+        const a_ext = extname(a.filepath.path);
+        const b_ext = extname(b.filepath.path);
+        if (a_ext === b_ext) {
+            return a.label.localeCompare(b.label);
+        }
+        else if (a_ext === '.code-snippets') {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    });
+    future.sort((a, b) => {
+        return a.label.localeCompare(b.label);
+    });
+    return { existing, future };
+}
+async function createSnippetFile(scope, defaultPath, quickInputService, fileService, textFileService, opener) {
+    function createSnippetUri(input) {
+        const filename = extname(input) !== '.code-snippets'
+            ? `${input}.code-snippets`
+            : input;
+        return joinPath(defaultPath, filename);
+    }
+    await fileService.createFolder(defaultPath);
+    const input = await quickInputService.input({
+        placeHolder: ( nls.localize('name', "Type snippet file name")),
+        async validateInput(input) {
+            if (!input) {
+                return ( nls.localize('bad_name1', "Invalid file name"));
+            }
+            if (!isValidBasename(input)) {
+                return ( nls.localize('bad_name2', "'{0}' is not a valid file name", input));
+            }
+            if (await fileService.exists(createSnippetUri(input))) {
+                return ( nls.localize('bad_name3', "'{0}' already exists", input));
+            }
+            return undefined;
+        }
+    });
+    if (!input) {
+        return undefined;
+    }
+    const resource = createSnippetUri(input);
+    await textFileService.write(resource, [
+        '{',
+        '\t// Place your ' + scope + ' snippets here. Each snippet is defined under a snippet name and has a scope, prefix, body and ',
+        '\t// description. Add comma separated ids of the languages where the snippet is applicable in the scope field. If scope ',
+        '\t// is left empty or omitted, the snippet gets applied to all languages. The prefix is what is ',
+        '\t// used to trigger the snippet and the body will be expanded and inserted. Possible variables are: ',
+        '\t// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. ',
+        '\t// Placeholders with the same ids are connected.',
+        '\t// Example:',
+        '\t// "Print to console": {',
+        '\t// \t"scope": "javascript,typescript",',
+        '\t// \t"prefix": "log",',
+        '\t// \t"body": [',
+        '\t// \t\t"console.log(\'$1\');",',
+        '\t// \t\t"$2"',
+        '\t// \t],',
+        '\t// \t"description": "Log output to console"',
+        '\t// }',
+        '}'
+    ].join('\n'));
+    await opener.open(resource);
+    return undefined;
+}
+async function createLanguageSnippetFile(pick, fileService, textFileService) {
+    if (await fileService.exists(pick.filepath)) {
+        return;
+    }
+    const contents = [
+        '{',
+        '\t// Place your snippets for ' + pick.label + ' here. Each snippet is defined under a snippet name and has a prefix, body and ',
+        '\t// description. The prefix is what is used to trigger the snippet and the body will be expanded and inserted. Possible variables are:',
+        '\t// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. Placeholders with the ',
+        '\t// same ids are connected.',
+        '\t// Example:',
+        '\t// "Print to console": {',
+        '\t// \t"prefix": "log",',
+        '\t// \t"body": [',
+        '\t// \t\t"console.log(\'$1\');",',
+        '\t// \t\t"$2"',
+        '\t// \t],',
+        '\t// \t"description": "Log output to console"',
+        '\t// }',
+        '}'
+    ].join('\n');
+    await textFileService.write(pick.filepath, contents);
+}
+class ConfigureSnippets extends SnippetsAction {
+    constructor() {
+        super({
+            id: 'workbench.action.openSnippets',
+            title: {
+                value: ( nls.localize('openSnippet.label', "Configure User Snippets")),
+                original: 'Configure User Snippets'
+            },
+            shortTitle: {
+                value: ( nls.localize('userSnippets', "User Snippets")),
+                mnemonicTitle: ( nls.localize(
+                    { key: 'miOpenSnippets', comment: ['&& denotes a mnemonic'] },
+                    "User &&Snippets"
+                )),
+                original: 'User Snippets'
+            },
+            f1: true,
+            menu: [
+                { id: MenuId.MenubarPreferencesMenu, group: '2_configuration', order: 4 },
+                { id: MenuId.GlobalActivity, group: '2_configuration', order: 4 },
+            ]
+        });
+    }
+    async run(accessor) {
+        const snippetService = accessor.get(ISnippetsService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const opener = accessor.get(IOpenerService);
+        const languageService = accessor.get(ILanguageService);
+        const userDataProfileService = accessor.get(IUserDataProfileService);
+        const workspaceService = accessor.get(IWorkspaceContextService);
+        const fileService = accessor.get(IFileService);
+        const textFileService = accessor.get(ITextFileService);
+        const labelService = accessor.get(ILabelService);
+        const picks = await computePicks(snippetService, userDataProfileService, languageService, labelService);
+        const existing = picks.existing;
+        const globalSnippetPicks = [{
+                scope: ( nls.localize('new.global_scope', 'global')),
+                label: ( nls.localize('new.global', "New Global Snippets file...")),
+                uri: userDataProfileService.currentProfile.snippetsHome
+            }];
+        const workspaceSnippetPicks = [];
+        for (const folder of workspaceService.getWorkspace().folders) {
+            workspaceSnippetPicks.push({
+                scope: ( nls.localize('new.workspace_scope', "{0} workspace", folder.name)),
+                label: ( nls.localize('new.folder', "New Snippets file for '{0}'...", folder.name)),
+                uri: folder.toResource('.vscode')
+            });
+        }
+        if (existing.length > 0) {
+            existing.unshift({ type: 'separator', label: ( nls.localize('group.global', "Existing Snippets")) });
+            existing.push({ type: 'separator', label: ( nls.localize('new.global.sep', "New Snippets")) });
+        }
+        else {
+            existing.push({ type: 'separator', label: ( nls.localize('new.global.sep', "New Snippets")) });
+        }
+        const pick = await quickInputService.pick([].concat(existing, globalSnippetPicks, workspaceSnippetPicks, picks.future), {
+            placeHolder: ( nls.localize('openSnippet.pickLanguage', "Select Snippets File or Create Snippets")),
+            matchOnDescription: true
+        });
+        if (globalSnippetPicks.indexOf(pick) >= 0) {
+            return createSnippetFile(pick.scope, pick.uri, quickInputService, fileService, textFileService, opener);
+        }
+        else if (workspaceSnippetPicks.indexOf(pick) >= 0) {
+            return createSnippetFile(pick.scope, pick.uri, quickInputService, fileService, textFileService, opener);
+        }
+        else if (ISnippetPick.is(pick)) {
+            if (pick.hint) {
+                await createLanguageSnippetFile(pick, fileService, textFileService);
+            }
+            return opener.open(pick.filepath);
+        }
+    }
+}
+export { ConfigureSnippets };

package/dist/vscode/vs/workbench/contrib/snippets/browser/commands/fileTemplateSnippets.js

@@ -0,0 +1,87 @@
+import { isFalsyOrEmpty, groupBy } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { SnippetsAction } from './abstractSnippetsActions.js';
+import { ISnippetsService } from '../snippets.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+class ApplyFileSnippetAction extends SnippetsAction {
+    constructor() {
+        super({
+            id: ApplyFileSnippetAction.Id,
+            title: {
+                value: ( localize('label', 'Fill File with Snippet')),
+                original: 'Fill File with Snippet'
+            },
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const snippetService = accessor.get(ISnippetsService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const editorService = accessor.get(IEditorService);
+        const langService = accessor.get(ILanguageService);
+        const editor = getCodeEditor(editorService.activeTextEditorControl);
+        if (!editor || !editor.hasModel()) {
+            return;
+        }
+        const snippets = await snippetService.getSnippets(undefined, { fileTemplateSnippets: true, noRecencySort: true, includeNoPrefixSnippets: true });
+        if (snippets.length === 0) {
+            return;
+        }
+        const selection = await this._pick(quickInputService, langService, snippets);
+        if (!selection) {
+            return;
+        }
+        if (editor.hasModel()) {
+            SnippetController2.get(editor)?.apply([{
+                    range: editor.getModel().getFullModelRange(),
+                    template: selection.snippet.body
+                }]);
+            editor.getModel().setLanguage(langService.createById(selection.langId), ApplyFileSnippetAction.Id);
+            editor.focus();
+        }
+    }
+    async _pick(quickInputService, langService, snippets) {
+        const all = [];
+        for (const snippet of snippets) {
+            if (isFalsyOrEmpty(snippet.scopes)) {
+                all.push({ langId: '', snippet });
+            }
+            else {
+                for (const langId of snippet.scopes) {
+                    all.push({ langId, snippet });
+                }
+            }
+        }
+        const picks = [];
+        const groups = groupBy(all, (a, b) => compare(a.langId, b.langId));
+        for (const group of groups) {
+            let first = true;
+            for (const item of group) {
+                if (first) {
+                    picks.push({
+                        type: 'separator',
+                        label: langService.getLanguageName(item.langId) ?? item.langId
+                    });
+                    first = false;
+                }
+                picks.push({
+                    snippet: item,
+                    label: item.snippet.prefix || item.snippet.name,
+                    detail: item.snippet.description
+                });
+            }
+        }
+        const pick = await quickInputService.pick(picks, {
+            placeHolder: ( localize('placeholder', 'Select a snippet')),
+            matchOnDetail: true,
+        });
+        return pick?.snippet;
+    }
+}
+ApplyFileSnippetAction.Id = 'workbench.action.populateFileFromSnippet';
+export { ApplyFileSnippetAction };

package/dist/vscode/vs/workbench/contrib/snippets/browser/commands/insertSnippet.js

@@ -0,0 +1,126 @@
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { SnippetEditorAction } from './abstractSnippetsActions.js';
+import { pickSnippet } from '../snippetPicker.js';
+import { ISnippetsService } from '../snippets.js';
+import { Snippet } from '../snippetsFile.js';
+class Args {
+    static fromUser(arg) {
+        if (!arg || typeof arg !== 'object') {
+            return Args._empty;
+        }
+        let { snippet, name, langId } = arg;
+        if (typeof snippet !== 'string') {
+            snippet = undefined;
+        }
+        if (typeof name !== 'string') {
+            name = undefined;
+        }
+        if (typeof langId !== 'string') {
+            langId = undefined;
+        }
+        return ( new Args(snippet, name, langId));
+    }
+    constructor(snippet, name, langId) {
+        this.snippet = snippet;
+        this.name = name;
+        this.langId = langId;
+    }
+}
+Args._empty = ( new Args(undefined, undefined, undefined));
+class InsertSnippetAction extends SnippetEditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.insertSnippet',
+            title: {
+                value: ( nls.localize('snippet.suggestions.label', "Insert Snippet")),
+                original: 'Insert Snippet'
+            },
+            f1: true,
+            precondition: EditorContextKeys.writable,
+            description: {
+                description: `Insert Snippet`,
+                args: [{
+                        name: 'args',
+                        schema: {
+                            'type': 'object',
+                            'properties': {
+                                'snippet': {
+                                    'type': 'string'
+                                },
+                                'langId': {
+                                    'type': 'string',
+                                },
+                                'name': {
+                                    'type': 'string'
+                                }
+                            },
+                        }
+                    }]
+            }
+        });
+    }
+    async runEditorCommand(accessor, editor, arg) {
+        const languageService = accessor.get(ILanguageService);
+        const snippetService = accessor.get(ISnippetsService);
+        if (!editor.hasModel()) {
+            return;
+        }
+        const clipboardService = accessor.get(IClipboardService);
+        const instaService = accessor.get(IInstantiationService);
+        const snippet = await ( new Promise((resolve, reject) => {
+            const { lineNumber, column } = editor.getPosition();
+            const { snippet, name, langId } = Args.fromUser(arg);
+            if (snippet) {
+                return resolve(( new Snippet(
+                    false,
+                    [],
+                    '',
+                    '',
+                    '',
+                    snippet,
+                    '',
+                    1 ,
+                    `random/${Math.random()}`
+                )));
+            }
+            let languageId;
+            if (langId) {
+                if (!languageService.isRegisteredLanguageId(langId)) {
+                    return resolve(undefined);
+                }
+                languageId = langId;
+            }
+            else {
+                editor.getModel().tokenization.tokenizeIfCheap(lineNumber);
+                languageId = editor.getModel().getLanguageIdAtPosition(lineNumber, column);
+                if (!languageService.getLanguageName(languageId)) {
+                    languageId = editor.getModel().getLanguageId();
+                }
+            }
+            if (name) {
+                snippetService.getSnippets(languageId, { includeNoPrefixSnippets: true })
+                    .then(snippets => snippets.find(snippet => snippet.name === name))
+                    .then(resolve, reject);
+            }
+            else {
+                resolve(instaService.invokeFunction(pickSnippet, languageId));
+            }
+        }));
+        if (!snippet) {
+            return;
+        }
+        let clipboardText;
+        if (snippet.needsClipboard) {
+            clipboardText = await clipboardService.readText();
+        }
+        editor.focus();
+        SnippetController2.get(editor)?.insert(snippet.codeSnippet, { clipboardText });
+        snippetService.updateUsageTimestamp(snippet);
+    }
+}
+export { InsertSnippetAction };

package/dist/vscode/vs/workbench/contrib/snippets/browser/commands/surroundWithSnippet.js

@@ -0,0 +1,56 @@
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { SnippetEditorAction } from './abstractSnippetsActions.js';
+import { pickSnippet } from '../snippetPicker.js';
+import { ISnippetsService } from '../snippets.js';
+async function getSurroundableSnippets(snippetsService, model, position, includeDisabledSnippets) {
+    const { lineNumber, column } = position;
+    model.tokenization.tokenizeIfCheap(lineNumber);
+    const languageId = model.getLanguageIdAtPosition(lineNumber, column);
+    const allSnippets = await snippetsService.getSnippets(languageId, { includeNoPrefixSnippets: true, includeDisabledSnippets });
+    return allSnippets.filter(snippet => snippet.usesSelection);
+}
+class SurroundWithSnippetEditorAction extends SnippetEditorAction {
+    constructor() {
+        super({
+            ...SurroundWithSnippetEditorAction.options,
+            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasNonEmptySelection)),
+            f1: true,
+        });
+    }
+    async runEditorCommand(accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const instaService = accessor.get(IInstantiationService);
+        const snippetsService = accessor.get(ISnippetsService);
+        const clipboardService = accessor.get(IClipboardService);
+        const snippets = await getSurroundableSnippets(snippetsService, editor.getModel(), editor.getPosition(), true);
+        if (!snippets.length) {
+            return;
+        }
+        const snippet = await instaService.invokeFunction(pickSnippet, snippets);
+        if (!snippet) {
+            return;
+        }
+        let clipboardText;
+        if (snippet.needsClipboard) {
+            clipboardText = await clipboardService.readText();
+        }
+        editor.focus();
+        SnippetController2.get(editor)?.insert(snippet.codeSnippet, { clipboardText });
+        snippetsService.updateUsageTimestamp(snippet);
+    }
+}
+SurroundWithSnippetEditorAction.options = {
+    id: 'editor.action.surroundWithSnippet',
+    title: {
+        value: ( localize('label', 'Surround With Snippet...')),
+        original: 'Surround With Snippet...'
+    }
+};
+export { SurroundWithSnippetEditorAction, getSurroundableSnippets };

package/dist/vscode/vs/workbench/contrib/snippets/browser/snippetCodeActionProvider.js

@@ -0,0 +1,133 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { CodeActionKind } from 'monaco-editor/esm/vs/editor/contrib/codeAction/common/types.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ApplyFileSnippetAction } from './commands/fileTemplateSnippets.js';
+import { SurroundWithSnippetEditorAction, getSurroundableSnippets } from './commands/surroundWithSnippet.js';
+import { ISnippetsService } from './snippets.js';
+let SurroundWithSnippetCodeActionProvider = class SurroundWithSnippetCodeActionProvider {
+    constructor(_snippetService) {
+        this._snippetService = _snippetService;
+    }
+    async provideCodeActions(model, range) {
+        if (range.isEmpty()) {
+            return undefined;
+        }
+        const position = Selection.isISelection(range) ? range.getPosition() : range.getStartPosition();
+        const snippets = await getSurroundableSnippets(this._snippetService, model, position, false);
+        if (!snippets.length) {
+            return undefined;
+        }
+        const actions = [];
+        for (const snippet of snippets) {
+            if (actions.length >= SurroundWithSnippetCodeActionProvider._MAX_CODE_ACTIONS) {
+                actions.push(SurroundWithSnippetCodeActionProvider._overflowCommandCodeAction);
+                break;
+            }
+            actions.push({
+                title: ( localize('codeAction', "Surround With: {0}", snippet.name)),
+                kind: CodeActionKind.SurroundWith.value,
+                edit: asWorkspaceEdit(model, range, snippet)
+            });
+        }
+        return {
+            actions,
+            dispose() { }
+        };
+    }
+};
+SurroundWithSnippetCodeActionProvider._MAX_CODE_ACTIONS = 4;
+SurroundWithSnippetCodeActionProvider._overflowCommandCodeAction = {
+    kind: CodeActionKind.SurroundWith.value,
+    title: SurroundWithSnippetEditorAction.options.title.value,
+    command: {
+        id: SurroundWithSnippetEditorAction.options.id,
+        title: SurroundWithSnippetEditorAction.options.title.value,
+    },
+};
+SurroundWithSnippetCodeActionProvider = ( __decorate([
+    ( __param(0, ISnippetsService))
+], SurroundWithSnippetCodeActionProvider));
+let FileTemplateCodeActionProvider = class FileTemplateCodeActionProvider {
+    constructor(_snippetService) {
+        this._snippetService = _snippetService;
+        this.providedCodeActionKinds = [CodeActionKind.SurroundWith.value];
+    }
+    async provideCodeActions(model) {
+        if (model.getValueLength() !== 0) {
+            return undefined;
+        }
+        const snippets = await this._snippetService.getSnippets(model.getLanguageId(), { fileTemplateSnippets: true, includeNoPrefixSnippets: true });
+        const actions = [];
+        for (const snippet of snippets) {
+            if (actions.length >= FileTemplateCodeActionProvider._MAX_CODE_ACTIONS) {
+                actions.push(FileTemplateCodeActionProvider._overflowCommandCodeAction);
+                break;
+            }
+            actions.push({
+                title: ( localize('title', 'Start with: {0}', snippet.name)),
+                kind: CodeActionKind.SurroundWith.value,
+                edit: asWorkspaceEdit(model, model.getFullModelRange(), snippet)
+            });
+        }
+        return {
+            actions,
+            dispose() { }
+        };
+    }
+};
+FileTemplateCodeActionProvider._MAX_CODE_ACTIONS = 4;
+FileTemplateCodeActionProvider._overflowCommandCodeAction = {
+    title: ( localize('overflow.start.title', 'Start with Snippet')),
+    kind: CodeActionKind.SurroundWith.value,
+    command: {
+        id: ApplyFileSnippetAction.Id,
+        title: ''
+    }
+};
+FileTemplateCodeActionProvider = ( __decorate([
+    ( __param(0, ISnippetsService))
+], FileTemplateCodeActionProvider));
+function asWorkspaceEdit(model, range, snippet) {
+    return {
+        edits: [{
+                versionId: model.getVersionId(),
+                resource: model.uri,
+                textEdit: {
+                    range,
+                    text: snippet.body,
+                    insertAsSnippet: true,
+                }
+            }]
+    };
+}
+let SnippetCodeActions = class SnippetCodeActions {
+    constructor(instantiationService, languageFeaturesService, configService) {
+        this._store = ( new DisposableStore());
+        const setting = 'editor.snippets.codeActions.enabled';
+        const sessionStore = ( new DisposableStore());
+        const update = () => {
+            sessionStore.clear();
+            if (configService.getValue(setting)) {
+                sessionStore.add(languageFeaturesService.codeActionProvider.register('*', instantiationService.createInstance(SurroundWithSnippetCodeActionProvider)));
+                sessionStore.add(languageFeaturesService.codeActionProvider.register('*', instantiationService.createInstance(FileTemplateCodeActionProvider)));
+            }
+        };
+        update();
+        this._store.add(configService.onDidChangeConfiguration(e => e.affectsConfiguration(setting) && update()));
+        this._store.add(sessionStore);
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+SnippetCodeActions = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, IConfigurationService))
+], SnippetCodeActions));
+export { SnippetCodeActions };