@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

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

@@ -0,0 +1,159 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { compare, firstNonWhitespaceIndex, compareSubstring } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { SnippetParser } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetParser.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ISnippetsService } from './snippets.js';
+import { Snippet } from './snippetsFile.js';
+import { isPatternInWord } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import { getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+const markSnippetAsUsed = '_snippet.markAsUsed';
+CommandsRegistry.registerCommand(markSnippetAsUsed, (accessor, ...args) => {
+    const snippetsService = accessor.get(ISnippetsService);
+    const [first] = args;
+    if (first instanceof Snippet) {
+        snippetsService.updateUsageTimestamp(first);
+    }
+});
+class SnippetCompletion {
+    constructor(snippet, range) {
+        this.snippet = snippet;
+        this.label = { label: snippet.prefix, description: snippet.name };
+        this.detail = ( localize(
+            'detail.snippet',
+            "{0} ({1})",
+            snippet.description || snippet.name,
+            snippet.source
+        ));
+        this.insertText = snippet.codeSnippet;
+        this.extensionId = snippet.extensionId;
+        this.range = range;
+        this.sortText = `${snippet.snippetSource === 3  ? 'z' : 'a'}-${snippet.prefix}`;
+        this.kind = 27 ;
+        this.insertTextRules = 4 ;
+        this.command = { id: markSnippetAsUsed, title: '', arguments: [snippet] };
+    }
+    resolve() {
+        this.documentation = ( new MarkdownString()).appendCodeblock('', SnippetParser.asInsertText(this.snippet.codeSnippet));
+        return this;
+    }
+    static compareByLabel(a, b) {
+        return compare(a.label.label, b.label.label);
+    }
+}
+let SnippetCompletionProvider = class SnippetCompletionProvider {
+    constructor(_languageService, _snippets, _languageConfigurationService) {
+        this._languageService = _languageService;
+        this._snippets = _snippets;
+        this._languageConfigurationService = _languageConfigurationService;
+        this._debugDisplayName = 'snippetCompletions';
+    }
+    async provideCompletionItems(model, position, context) {
+        const sw = ( new StopWatch(true));
+        const languageId = this._getLanguageIdAtPosition(model, position);
+        const languageConfig = this._languageConfigurationService.getLanguageConfiguration(languageId);
+        const snippets = ( new Set(await this._snippets.getSnippets(languageId)));
+        const lineContentLow = model.getLineContent(position.lineNumber).toLowerCase();
+        const wordUntil = model.getWordUntilPosition(position).word.toLowerCase();
+        const suggestions = [];
+        const columnOffset = position.column - 1;
+        const triggerCharacterLow = context.triggerCharacter?.toLowerCase() ?? '';
+        snippet: for (const snippet of snippets) {
+            if (context.triggerKind === 1  && !snippet.prefixLow.startsWith(triggerCharacterLow)) {
+                continue snippet;
+            }
+            const word = getWordAtText(1, languageConfig.getWordDefinition(), snippet.prefixLow, 0);
+            if (wordUntil && word && !isPatternInWord(wordUntil, 0, wordUntil.length, snippet.prefixLow, 0, snippet.prefixLow.length)) {
+                continue snippet;
+            }
+            const minPos = firstNonWhitespaceIndex(snippet.prefixLow) === 0
+                ? Math.max(0, model.getLineFirstNonWhitespaceColumn(position.lineNumber) - 1)
+                : 0;
+            column: for (let pos = Math.max(minPos, columnOffset - snippet.prefixLow.length); pos < lineContentLow.length; pos++) {
+                if (!isPatternInWord(lineContentLow, pos, columnOffset, snippet.prefixLow, 0, snippet.prefixLow.length)) {
+                    continue column;
+                }
+                const prefixRestLen = snippet.prefixLow.length - (columnOffset - pos);
+                const endsWithPrefixRest = compareSubstring(lineContentLow, snippet.prefixLow, columnOffset, columnOffset + prefixRestLen, columnOffset - pos);
+                const startPosition = position.with(undefined, pos + 1);
+                if (wordUntil && position.equals(startPosition)) {
+                    continue snippet;
+                }
+                let endColumn = endsWithPrefixRest === 0 ? position.column + prefixRestLen : position.column;
+                if (columnOffset < lineContentLow.length) {
+                    const autoClosingPairs = languageConfig.getAutoClosingPairs();
+                    const standardAutoClosingPairConditionals = autoClosingPairs.autoClosingPairsCloseSingleChar.get(lineContentLow[columnOffset]);
+                    if (standardAutoClosingPairConditionals?.some(p =>
+                    p.open === lineContentLow[startPosition.column - 1] &&
+                        snippet.prefix.startsWith(p.open) &&
+                        snippet.prefix[snippet.prefix.length - 1] === p.close)) {
+                        endColumn++;
+                    }
+                }
+                const replace = Range.fromPositions(startPosition, { lineNumber: position.lineNumber, column: endColumn });
+                const insert = replace.setEndPosition(position.lineNumber, position.column);
+                suggestions.push(( new SnippetCompletion(snippet, { replace, insert })));
+                snippets.delete(snippet);
+                break;
+            }
+        }
+        if (!triggerCharacterLow) {
+            const endsInWhitespace = /\s/.test(lineContentLow[position.column - 2]);
+            if (endsInWhitespace || !lineContentLow ) {
+                for (const snippet of snippets) {
+                    const insert = Range.fromPositions(position);
+                    const replace = lineContentLow.indexOf(snippet.prefixLow, columnOffset) === columnOffset ? insert.setEndPosition(position.lineNumber, position.column + snippet.prefixLow.length) : insert;
+                    suggestions.push(( new SnippetCompletion(snippet, { replace, insert })));
+                }
+            }
+        }
+        suggestions.sort(SnippetCompletion.compareByLabel);
+        for (let i = 0; i < suggestions.length; i++) {
+            const item = suggestions[i];
+            let to = i + 1;
+            for (; to < suggestions.length && item.label === suggestions[to].label; to++) {
+                suggestions[to].label.label = ( localize(
+                    'snippetSuggest.longLabel',
+                    "{0}, {1}",
+                    suggestions[to].label.label,
+                    suggestions[to].snippet.name
+                ));
+            }
+            if (to > i + 1) {
+                suggestions[i].label.label = ( localize(
+                    'snippetSuggest.longLabel',
+                    "{0}, {1}",
+                    suggestions[i].label.label,
+                    suggestions[i].snippet.name
+                ));
+                i = to;
+            }
+        }
+        return {
+            suggestions,
+            duration: sw.elapsed()
+        };
+    }
+    resolveCompletionItem(item) {
+        return (item instanceof SnippetCompletion) ? item.resolve() : item;
+    }
+    _getLanguageIdAtPosition(model, position) {
+        model.tokenization.tokenizeIfCheap(position.lineNumber);
+        let languageId = model.getLanguageIdAtPosition(position.lineNumber, position.column);
+        if (!this._languageService.getLanguageName(languageId)) {
+            languageId = model.getLanguageId();
+        }
+        return languageId;
+    }
+};
+SnippetCompletionProvider = ( __decorate([
+    ( __param(0, ILanguageService)),
+    ( __param(1, ISnippetsService)),
+    ( __param(2, ILanguageConfigurationService))
+], SnippetCompletionProvider));
+export { SnippetCompletion, SnippetCompletionProvider };

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

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ISnippetsService = ( createDecorator('snippetService'));
+export { ISnippetsService };

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

@@ -0,0 +1,229 @@
+import { parse, getNodeType } from '../../../../base/common/json.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { extname, basename } from 'monaco-editor/esm/vs/base/common/path.js';
+import { SnippetParser, Placeholder, Variable, Text } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetParser.js';
+import { KnownSnippetVariableNames } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetVariables.js';
+import { IdleValue } from 'monaco-editor/esm/vs/base/common/async.js';
+import { relativePath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { tail } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+class SnippetBodyInsights {
+    constructor(body) {
+        this.isBogous = false;
+        this.isTrivial = false;
+        this.usesClipboardVariable = false;
+        this.usesSelectionVariable = false;
+        this.codeSnippet = body;
+        const textmateSnippet = ( new SnippetParser()).parse(body, false);
+        const placeholders = ( new Map());
+        let placeholderMax = 0;
+        for (const placeholder of textmateSnippet.placeholders) {
+            placeholderMax = Math.max(placeholderMax, placeholder.index);
+        }
+        if (textmateSnippet.placeholders.length === 0) {
+            this.isTrivial = true;
+        }
+        else if (placeholderMax === 0) {
+            const last = tail(textmateSnippet.children);
+            this.isTrivial = last instanceof Placeholder && last.isFinalTabstop;
+        }
+        const stack = [...textmateSnippet.children];
+        while (stack.length > 0) {
+            const marker = stack.shift();
+            if (marker instanceof Variable) {
+                if (marker.children.length === 0 && !KnownSnippetVariableNames[marker.name]) {
+                    const index = placeholders.has(marker.name) ? placeholders.get(marker.name) : ++placeholderMax;
+                    placeholders.set(marker.name, index);
+                    const synthetic = ( new Placeholder(index)).appendChild(( new Text(marker.name)));
+                    textmateSnippet.replace(marker, [synthetic]);
+                    this.isBogous = true;
+                }
+                switch (marker.name) {
+                    case 'CLIPBOARD':
+                        this.usesClipboardVariable = true;
+                        break;
+                    case 'SELECTION':
+                    case 'TM_SELECTED_TEXT':
+                        this.usesSelectionVariable = true;
+                        break;
+                }
+            }
+            else {
+                stack.push(...marker.children);
+            }
+        }
+        if (this.isBogous) {
+            this.codeSnippet = textmateSnippet.toTextmateString();
+        }
+    }
+}
+class Snippet {
+    constructor(isFileTemplate, scopes, name, prefix, description, body, source, snippetSource, snippetIdentifier, extensionId) {
+        this.isFileTemplate = isFileTemplate;
+        this.scopes = scopes;
+        this.name = name;
+        this.prefix = prefix;
+        this.description = description;
+        this.body = body;
+        this.source = source;
+        this.snippetSource = snippetSource;
+        this.snippetIdentifier = snippetIdentifier;
+        this.extensionId = extensionId;
+        this.prefixLow = prefix.toLowerCase();
+        this._bodyInsights = ( new IdleValue(() => ( new SnippetBodyInsights(this.body))));
+    }
+    get codeSnippet() {
+        return this._bodyInsights.value.codeSnippet;
+    }
+    get isBogous() {
+        return this._bodyInsights.value.isBogous;
+    }
+    get isTrivial() {
+        return this._bodyInsights.value.isTrivial;
+    }
+    get needsClipboard() {
+        return this._bodyInsights.value.usesClipboardVariable;
+    }
+    get usesSelection() {
+        return this._bodyInsights.value.usesSelectionVariable;
+    }
+}
+function isJsonSerializedSnippet(thing) {
+    return isObject(thing) && Boolean(thing.body);
+}
+class SnippetFile {
+    constructor(source, location, defaultScopes, _extension, _fileService, _extensionResourceLoaderService) {
+        this.source = source;
+        this.location = location;
+        this.defaultScopes = defaultScopes;
+        this._extension = _extension;
+        this._fileService = _fileService;
+        this._extensionResourceLoaderService = _extensionResourceLoaderService;
+        this.data = [];
+        this.isGlobalSnippets = extname(location.path) === '.code-snippets';
+        this.isUserSnippets = !this._extension;
+    }
+    select(selector, bucket) {
+        if (this.isGlobalSnippets || !this.isUserSnippets) {
+            this._scopeSelect(selector, bucket);
+        }
+        else {
+            this._filepathSelect(selector, bucket);
+        }
+    }
+    _filepathSelect(selector, bucket) {
+        if (selector + '.json' === basename(this.location.path)) {
+            bucket.push(...this.data);
+        }
+    }
+    _scopeSelect(selector, bucket) {
+        for (const snippet of this.data) {
+            const len = snippet.scopes.length;
+            if (len === 0) {
+                bucket.push(snippet);
+            }
+            else {
+                for (let i = 0; i < len; i++) {
+                    if (snippet.scopes[i] === selector) {
+                        bucket.push(snippet);
+                        break;
+                    }
+                }
+            }
+        }
+        const idx = selector.lastIndexOf('.');
+        if (idx >= 0) {
+            this._scopeSelect(selector.substring(0, idx), bucket);
+        }
+    }
+    async _load() {
+        if (this._extension) {
+            return this._extensionResourceLoaderService.readExtensionResource(this.location);
+        }
+        else {
+            const content = await this._fileService.readFile(this.location);
+            return ( content.value.toString());
+        }
+    }
+    load() {
+        if (!this._loadPromise) {
+            this._loadPromise = Promise.resolve(this._load()).then(content => {
+                const data = parse(content);
+                if (getNodeType(data) === 'object') {
+                    for (const [name, scopeOrTemplate] of Object.entries(data)) {
+                        if (isJsonSerializedSnippet(scopeOrTemplate)) {
+                            this._parseSnippet(name, scopeOrTemplate, this.data);
+                        }
+                        else {
+                            for (const [name, template] of Object.entries(scopeOrTemplate)) {
+                                this._parseSnippet(name, template, this.data);
+                            }
+                        }
+                    }
+                }
+                return this;
+            });
+        }
+        return this._loadPromise;
+    }
+    reset() {
+        this._loadPromise = undefined;
+        this.data.length = 0;
+    }
+    _parseSnippet(name, snippet, bucket) {
+        let { isFileTemplate, prefix, body, description } = snippet;
+        if (!prefix) {
+            prefix = '';
+        }
+        if (Array.isArray(body)) {
+            body = body.join('\n');
+        }
+        if (typeof body !== 'string') {
+            return;
+        }
+        if (Array.isArray(description)) {
+            description = description.join('\n');
+        }
+        let scopes;
+        if (this.defaultScopes) {
+            scopes = this.defaultScopes;
+        }
+        else if (typeof snippet.scope === 'string') {
+            scopes = ( snippet.scope.split(',').map(s => s.trim())).filter(Boolean);
+        }
+        else {
+            scopes = [];
+        }
+        let source;
+        if (this._extension) {
+            source = this._extension.displayName || this._extension.name;
+        }
+        else if (this.source === 2 ) {
+            source = ( localize('source.workspaceSnippetGlobal', "Workspace Snippet"));
+        }
+        else {
+            if (this.isGlobalSnippets) {
+                source = ( localize('source.userSnippetGlobal', "Global User Snippet"));
+            }
+            else {
+                source = ( localize('source.userSnippet', "User Snippet"));
+            }
+        }
+        for (const _prefix of Iterable.wrap(prefix)) {
+            bucket.push(( new Snippet(
+                Boolean(isFileTemplate),
+                scopes,
+                name,
+                _prefix,
+                description,
+                body,
+                source,
+                this.source,
+                this._extension ? `${relativePath(this._extension.extensionLocation, this.location)}/${name}` : `${basename(this.location.path)}/${name}`,
+                this._extension?.identifier
+            )));
+        }
+    }
+}
+export { Snippet, SnippetFile };