ddcAdmin/node_modules/monaco-editor/esm/vs/language/html/languageFeatures.js

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
import * as htmlService from './_deps/vscode-html-languageservice/htmlLanguageService.js';
import { languages, Uri, Range } from './fillers/monaco-editor-core.js';
// --- completion ------
function fromPosition(position) {
    if (!position) {
        return void 0;
    }
    return { character: position.column - 1, line: position.lineNumber - 1 };
}
function fromRange(range) {
    if (!range) {
        return void 0;
    }
    return {
        start: fromPosition(range.getStartPosition()),
        end: fromPosition(range.getEndPosition())
    };
}
function toRange(range) {
    if (!range) {
        return void 0;
    }
    return new Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
}
function isInsertReplaceEdit(edit) {
    return (typeof edit.insert !== 'undefined' &&
        typeof edit.replace !== 'undefined');
}
function toCompletionItemKind(kind) {
    var mItemKind = languages.CompletionItemKind;
    switch (kind) {
        case htmlService.CompletionItemKind.Text:
            return mItemKind.Text;
        case htmlService.CompletionItemKind.Method:
            return mItemKind.Method;
        case htmlService.CompletionItemKind.Function:
            return mItemKind.Function;
        case htmlService.CompletionItemKind.Constructor:
            return mItemKind.Constructor;
        case htmlService.CompletionItemKind.Field:
            return mItemKind.Field;
        case htmlService.CompletionItemKind.Variable:
            return mItemKind.Variable;
        case htmlService.CompletionItemKind.Class:
            return mItemKind.Class;
        case htmlService.CompletionItemKind.Interface:
            return mItemKind.Interface;
        case htmlService.CompletionItemKind.Module:
            return mItemKind.Module;
        case htmlService.CompletionItemKind.Property:
            return mItemKind.Property;
        case htmlService.CompletionItemKind.Unit:
            return mItemKind.Unit;
        case htmlService.CompletionItemKind.Value:
            return mItemKind.Value;
        case htmlService.CompletionItemKind.Enum:
            return mItemKind.Enum;
        case htmlService.CompletionItemKind.Keyword:
            return mItemKind.Keyword;
        case htmlService.CompletionItemKind.Snippet:
            return mItemKind.Snippet;
        case htmlService.CompletionItemKind.Color:
            return mItemKind.Color;
        case htmlService.CompletionItemKind.File:
            return mItemKind.File;
        case htmlService.CompletionItemKind.Reference:
            return mItemKind.Reference;
    }
    return mItemKind.Property;
}
function fromCompletionItemKind(kind) {
    var mItemKind = languages.CompletionItemKind;
    switch (kind) {
        case mItemKind.Text:
            return htmlService.CompletionItemKind.Text;
        case mItemKind.Method:
            return htmlService.CompletionItemKind.Method;
        case mItemKind.Function:
            return htmlService.CompletionItemKind.Function;
        case mItemKind.Constructor:
            return htmlService.CompletionItemKind.Constructor;
        case mItemKind.Field:
            return htmlService.CompletionItemKind.Field;
        case mItemKind.Variable:
            return htmlService.CompletionItemKind.Variable;
        case mItemKind.Class:
            return htmlService.CompletionItemKind.Class;
        case mItemKind.Interface:
            return htmlService.CompletionItemKind.Interface;
        case mItemKind.Module:
            return htmlService.CompletionItemKind.Module;
        case mItemKind.Property:
            return htmlService.CompletionItemKind.Property;
        case mItemKind.Unit:
            return htmlService.CompletionItemKind.Unit;
        case mItemKind.Value:
            return htmlService.CompletionItemKind.Value;
        case mItemKind.Enum:
            return htmlService.CompletionItemKind.Enum;
        case mItemKind.Keyword:
            return htmlService.CompletionItemKind.Keyword;
        case mItemKind.Snippet:
            return htmlService.CompletionItemKind.Snippet;
        case mItemKind.Color:
            return htmlService.CompletionItemKind.Color;
        case mItemKind.File:
            return htmlService.CompletionItemKind.File;
        case mItemKind.Reference:
            return htmlService.CompletionItemKind.Reference;
    }
    return htmlService.CompletionItemKind.Property;
}
function toTextEdit(textEdit) {
    if (!textEdit) {
        return void 0;
    }
    return {
        range: toRange(textEdit.range),
        text: textEdit.newText
    };
}
function toCommand(c) {
    return c && c.command === 'editor.action.triggerSuggest' ? { id: c.command, title: c.title, arguments: c.arguments } : undefined;
}
var CompletionAdapter = /** @class */ (function () {
    function CompletionAdapter(_worker) {
        this._worker = _worker;
    }
    Object.defineProperty(CompletionAdapter.prototype, "triggerCharacters", {
        get: function () {
            return ['.', ':', '<', '"', '=', '/'];
        },
        enumerable: false,
        configurable: true
    });
    CompletionAdapter.prototype.provideCompletionItems = function (model, position, context, token) {
        var resource = model.uri;
        return this._worker(resource)
            .then(function (worker) {
            return worker.doComplete(resource.toString(), fromPosition(position));
        })
            .then(function (info) {
            if (!info) {
                return;
            }
            var wordInfo = model.getWordUntilPosition(position);
            var wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
            var items = info.items.map(function (entry) {
                var item = {
                    label: entry.label,
                    insertText: entry.insertText || entry.label,
                    sortText: entry.sortText,
                    filterText: entry.filterText,
                    documentation: entry.documentation,
                    command: toCommand(entry.command),
                    detail: entry.detail,
                    range: wordRange,
                    kind: toCompletionItemKind(entry.kind)
                };
                if (entry.textEdit) {
                    if (isInsertReplaceEdit(entry.textEdit)) {
                        item.range = {
                            insert: toRange(entry.textEdit.insert),
                            replace: toRange(entry.textEdit.replace)
                        };
                    }
                    else {
                        item.range = toRange(entry.textEdit.range);
                    }
                    item.insertText = entry.textEdit.newText;
                }
                if (entry.additionalTextEdits) {
                    item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
                }
                if (entry.insertTextFormat === htmlService.InsertTextFormat.Snippet) {
                    item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
                }
                return item;
            });
            return {
                isIncomplete: info.isIncomplete,
                suggestions: items
            };
        });
    };
    return CompletionAdapter;
}());
export { CompletionAdapter };
// --- hover ------
function isMarkupContent(thing) {
    return (thing &&
        typeof thing === 'object' &&
        typeof thing.kind === 'string');
}
function toMarkdownString(entry) {
    if (typeof entry === 'string') {
        return {
            value: entry
        };
    }
    if (isMarkupContent(entry)) {
        if (entry.kind === 'plaintext') {
            return {
                value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&')
            };
        }
        return {
            value: entry.value
        };
    }
    return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' };
}
function toMarkedStringArray(contents) {
    if (!contents) {
        return void 0;
    }
    if (Array.isArray(contents)) {
        return contents.map(toMarkdownString);
    }
    return [toMarkdownString(contents)];
}
var HoverAdapter = /** @class */ (function () {
    function HoverAdapter(_worker) {
        this._worker = _worker;
    }
    HoverAdapter.prototype.provideHover = function (model, position, token) {
        var resource = model.uri;
        return this._worker(resource)
            .then(function (worker) {
            return worker.doHover(resource.toString(), fromPosition(position));
        })
            .then(function (info) {
            if (!info) {
                return;
            }
            return {
                range: toRange(info.range),
                contents: toMarkedStringArray(info.contents)
            };
        });
    };
    return HoverAdapter;
}());
export { HoverAdapter };
// --- document highlights ------
function toHighlighKind(kind) {
    var mKind = languages.DocumentHighlightKind;
    switch (kind) {
        case htmlService.DocumentHighlightKind.Read:
            return mKind.Read;
        case htmlService.DocumentHighlightKind.Write:
            return mKind.Write;
        case htmlService.DocumentHighlightKind.Text:
            return mKind.Text;
    }
    return mKind.Text;
}
var DocumentHighlightAdapter = /** @class */ (function () {
    function DocumentHighlightAdapter(_worker) {
        this._worker = _worker;
    }
    DocumentHighlightAdapter.prototype.provideDocumentHighlights = function (model, position, token) {
        var resource = model.uri;
        return this._worker(resource)
            .then(function (worker) { return worker.findDocumentHighlights(resource.toString(), fromPosition(position)); })
            .then(function (items) {
            if (!items) {
                return;
            }
            return items.map(function (item) { return ({
                range: toRange(item.range),
                kind: toHighlighKind(item.kind)
            }); });
        });
    };
    return DocumentHighlightAdapter;
}());
export { DocumentHighlightAdapter };
// --- document symbols ------
function toSymbolKind(kind) {
    var mKind = languages.SymbolKind;
    switch (kind) {
        case htmlService.SymbolKind.File:
            return mKind.Array;
        case htmlService.SymbolKind.Module:
            return mKind.Module;
        case htmlService.SymbolKind.Namespace:
            return mKind.Namespace;
        case htmlService.SymbolKind.Package:
            return mKind.Package;
        case htmlService.SymbolKind.Class:
            return mKind.Class;
        case htmlService.SymbolKind.Method:
            return mKind.Method;
        case htmlService.SymbolKind.Property:
            return mKind.Property;
        case htmlService.SymbolKind.Field:
            return mKind.Field;
        case htmlService.SymbolKind.Constructor:
            return mKind.Constructor;
        case htmlService.SymbolKind.Enum:
            return mKind.Enum;
        case htmlService.SymbolKind.Interface:
            return mKind.Interface;
        case htmlService.SymbolKind.Function:
            return mKind.Function;
        case htmlService.SymbolKind.Variable:
            return mKind.Variable;
        case htmlService.SymbolKind.Constant:
            return mKind.Constant;
        case htmlService.SymbolKind.String:
            return mKind.String;
        case htmlService.SymbolKind.Number:
            return mKind.Number;
        case htmlService.SymbolKind.Boolean:
            return mKind.Boolean;
        case htmlService.SymbolKind.Array:
            return mKind.Array;
    }
    return mKind.Function;
}
var DocumentSymbolAdapter = /** @class */ (function () {
    function DocumentSymbolAdapter(_worker) {
        this._worker = _worker;
    }
    DocumentSymbolAdapter.prototype.provideDocumentSymbols = function (model, token) {
        var resource = model.uri;
        return this._worker(resource)
            .then(function (worker) { return worker.findDocumentSymbols(resource.toString()); })
            .then(function (items) {
            if (!items) {
                return;
            }
            return items.map(function (item) { return ({
                name: item.name,
                detail: '',
                containerName: item.containerName,
                kind: toSymbolKind(item.kind),
                tags: [],
                range: toRange(item.location.range),
                selectionRange: toRange(item.location.range)
            }); });
        });
    };
    return DocumentSymbolAdapter;
}());
export { DocumentSymbolAdapter };
var DocumentLinkAdapter = /** @class */ (function () {
    function DocumentLinkAdapter(_worker) {
        this._worker = _worker;
    }
    DocumentLinkAdapter.prototype.provideLinks = function (model, token) {
        var resource = model.uri;
        return this._worker(resource)
            .then(function (worker) { return worker.findDocumentLinks(resource.toString()); })
            .then(function (items) {
            if (!items) {
                return;
            }
            return {
                links: items.map(function (item) { return ({
                    range: toRange(item.range),
                    url: item.target
                }); })
            };
        });
    };
    return DocumentLinkAdapter;
}());
export { DocumentLinkAdapter };
function fromFormattingOptions(options) {
    return {
        tabSize: options.tabSize,
        insertSpaces: options.insertSpaces
    };
}
var DocumentFormattingEditProvider = /** @class */ (function () {
    function DocumentFormattingEditProvider(_worker) {
        this._worker = _worker;
    }
    DocumentFormattingEditProvider.prototype.provideDocumentFormattingEdits = function (model, options, token) {
        var resource = model.uri;
        return this._worker(resource).then(function (worker) {
            return worker
                .format(resource.toString(), null, fromFormattingOptions(options))
                .then(function (edits) {
                if (!edits || edits.length === 0) {
                    return;
                }
                return edits.map(toTextEdit);
            });
        });
    };
    return DocumentFormattingEditProvider;
}());
export { DocumentFormattingEditProvider };
var DocumentRangeFormattingEditProvider = /** @class */ (function () {
    function DocumentRangeFormattingEditProvider(_worker) {
        this._worker = _worker;
    }
    DocumentRangeFormattingEditProvider.prototype.provideDocumentRangeFormattingEdits = function (model, range, options, token) {
        var resource = model.uri;
        return this._worker(resource).then(function (worker) {
            return worker
                .format(resource.toString(), fromRange(range), fromFormattingOptions(options))
                .then(function (edits) {
                if (!edits || edits.length === 0) {
                    return;
                }
                return edits.map(toTextEdit);
            });
        });
    };
    return DocumentRangeFormattingEditProvider;
}());
export { DocumentRangeFormattingEditProvider };
var RenameAdapter = /** @class */ (function () {
    function RenameAdapter(_worker) {
        this._worker = _worker;
    }
    RenameAdapter.prototype.provideRenameEdits = function (model, position, newName, token) {
        var resource = model.uri;
        return this._worker(resource)
            .then(function (worker) {
            return worker.doRename(resource.toString(), fromPosition(position), newName);
        })
            .then(function (edit) {
            return toWorkspaceEdit(edit);
        });
    };
    return RenameAdapter;
}());
export { RenameAdapter };
function toWorkspaceEdit(edit) {
    if (!edit || !edit.changes) {
        return void 0;
    }
    var resourceEdits = [];
    for (var uri in edit.changes) {
        var _uri = Uri.parse(uri);
        for (var _i = 0, _a = edit.changes[uri]; _i < _a.length; _i++) {
            var e = _a[_i];
            resourceEdits.push({
                resource: _uri,
                edit: {
                    range: toRange(e.range),
                    text: e.newText
                }
            });
        }
    }
    return {
        edits: resourceEdits
    };
}
var FoldingRangeAdapter = /** @class */ (function () {
    function FoldingRangeAdapter(_worker) {
        this._worker = _worker;
    }
    FoldingRangeAdapter.prototype.provideFoldingRanges = function (model, context, token) {
        var resource = model.uri;
        return this._worker(resource)
            .then(function (worker) { return worker.getFoldingRanges(resource.toString(), context); })
            .then(function (ranges) {
            if (!ranges) {
                return;
            }
            return ranges.map(function (range) {
                var result = {
                    start: range.startLine + 1,
                    end: range.endLine + 1
                };
                if (typeof range.kind !== 'undefined') {
                    result.kind = toFoldingRangeKind(range.kind);
                }
                return result;
            });
        });
    };
    return FoldingRangeAdapter;
}());
export { FoldingRangeAdapter };
function toFoldingRangeKind(kind) {
    switch (kind) {
        case htmlService.FoldingRangeKind.Comment:
            return languages.FoldingRangeKind.Comment;
        case htmlService.FoldingRangeKind.Imports:
            return languages.FoldingRangeKind.Imports;
        case htmlService.FoldingRangeKind.Region:
            return languages.FoldingRangeKind.Region;
    }
}
var SelectionRangeAdapter = /** @class */ (function () {
    function SelectionRangeAdapter(_worker) {
        this._worker = _worker;
    }
    SelectionRangeAdapter.prototype.provideSelectionRanges = function (model, positions, token) {
        var resource = model.uri;
        return this._worker(resource)
            .then(function (worker) { return worker.getSelectionRanges(resource.toString(), positions.map(fromPosition)); })
            .then(function (selectionRanges) {
            if (!selectionRanges) {
                return;
            }
            return selectionRanges.map(function (selectionRange) {
                var result = [];
                while (selectionRange) {
                    result.push({ range: toRange(selectionRange.range) });
                    selectionRange = selectionRange.parent;
                }
                return result;
            });
        });
    };
    return SelectionRangeAdapter;
}());
export { SelectionRangeAdapter };