@volar/monaco 1.3.0-alpha.0

package/out/utils/protocol2monaco.js

@@ -0,0 +1,490 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asPosition = exports.asInlayHintLabelPart = exports.asInlayHintLabel = exports.asInlayHintKind = exports.asInlayHint = exports.asSelectionRange = exports.asFoldingRange = exports.asColorPresentation = exports.asColorInformation = exports.asLink = exports.asCodeAction = exports.asCodeLens = exports.asDocumentHighlightKind = exports.asDocumentHighlight = exports.asSymbolKind = exports.asSymbolTag = exports.asDocumentSymbol = exports.asWorkspaceEdit = exports.asMarkerSeverity = exports.asRelatedInformation = exports.asMarkerTag = exports.asMarkerData = exports.asParameterInformation = exports.asSignatureInformation = exports.asSignatureHelp = exports.asUri = exports.asLocation = exports.asMarkdownString = exports.asHover = exports.asRange = exports.asCompletionItemRange = exports.asTextEdit = exports.asCommand = exports.asCompletionItem = exports.asCompletionItemKind = exports.asCompletionList = void 0;
+const monaco_editor_core_1 = require("monaco-editor-core");
+const protocol = require("vscode-languageserver-protocol");
+function asCompletionList(list, range) {
+    return {
+        incomplete: list.isIncomplete,
+        suggestions: list.items.map(item => asCompletionItem(item, range)),
+    };
+}
+exports.asCompletionList = asCompletionList;
+function asCompletionItemKind(kind) {
+    switch (kind) {
+        case protocol.CompletionItemKind.Method:
+            return monaco_editor_core_1.languages.CompletionItemKind.Method;
+        case protocol.CompletionItemKind.Function:
+            return monaco_editor_core_1.languages.CompletionItemKind.Function;
+        case protocol.CompletionItemKind.Constructor:
+            return monaco_editor_core_1.languages.CompletionItemKind.Constructor;
+        case protocol.CompletionItemKind.Field:
+            return monaco_editor_core_1.languages.CompletionItemKind.Field;
+        case protocol.CompletionItemKind.Variable:
+            return monaco_editor_core_1.languages.CompletionItemKind.Variable;
+        case protocol.CompletionItemKind.Class:
+            return monaco_editor_core_1.languages.CompletionItemKind.Class;
+        case protocol.CompletionItemKind.Interface:
+            return monaco_editor_core_1.languages.CompletionItemKind.Interface;
+        case protocol.CompletionItemKind.Module:
+            return monaco_editor_core_1.languages.CompletionItemKind.Module;
+        case protocol.CompletionItemKind.Property:
+            return monaco_editor_core_1.languages.CompletionItemKind.Property;
+        case protocol.CompletionItemKind.Unit:
+            return monaco_editor_core_1.languages.CompletionItemKind.Unit;
+        case protocol.CompletionItemKind.Value:
+            return monaco_editor_core_1.languages.CompletionItemKind.Value;
+        case protocol.CompletionItemKind.Enum:
+            return monaco_editor_core_1.languages.CompletionItemKind.Enum;
+        case protocol.CompletionItemKind.Keyword:
+            return monaco_editor_core_1.languages.CompletionItemKind.Keyword;
+        case protocol.CompletionItemKind.Snippet:
+            return monaco_editor_core_1.languages.CompletionItemKind.Snippet;
+        case protocol.CompletionItemKind.Text:
+            return monaco_editor_core_1.languages.CompletionItemKind.Text;
+        case protocol.CompletionItemKind.Color:
+            return monaco_editor_core_1.languages.CompletionItemKind.Color;
+        case protocol.CompletionItemKind.File:
+            return monaco_editor_core_1.languages.CompletionItemKind.File;
+        case protocol.CompletionItemKind.Reference:
+            return monaco_editor_core_1.languages.CompletionItemKind.Reference;
+        case protocol.CompletionItemKind.Folder:
+            return monaco_editor_core_1.languages.CompletionItemKind.Folder;
+        case protocol.CompletionItemKind.EnumMember:
+            return monaco_editor_core_1.languages.CompletionItemKind.EnumMember;
+        case protocol.CompletionItemKind.Constant:
+            return monaco_editor_core_1.languages.CompletionItemKind.Constant;
+        case protocol.CompletionItemKind.Struct:
+            return monaco_editor_core_1.languages.CompletionItemKind.Struct;
+        case protocol.CompletionItemKind.Event:
+            return monaco_editor_core_1.languages.CompletionItemKind.Event;
+        case protocol.CompletionItemKind.Operator:
+            return monaco_editor_core_1.languages.CompletionItemKind.Operator;
+        case protocol.CompletionItemKind.TypeParameter:
+            return monaco_editor_core_1.languages.CompletionItemKind.TypeParameter;
+        default:
+            return monaco_editor_core_1.languages.CompletionItemKind.Text;
+    }
+}
+exports.asCompletionItemKind = asCompletionItemKind;
+function asCompletionItem(item, range) {
+    var _a, _b, _c, _d;
+    return {
+        label: item.label,
+        kind: asCompletionItemKind(item.kind),
+        tags: item.tags,
+        detail: item.detail,
+        documentation: item.documentation,
+        sortText: item.sortText,
+        filterText: item.filterText,
+        preselect: item.preselect,
+        insertText: (_c = (_b = (_a = item.textEdit) === null || _a === void 0 ? void 0 : _a.newText) !== null && _b !== void 0 ? _b : item.insertText) !== null && _c !== void 0 ? _c : item.label,
+        insertTextRules: monaco_editor_core_1.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        range: item.textEdit ? asCompletionItemRange(item.textEdit) : asRange(range),
+        commitCharacters: item.commitCharacters,
+        additionalTextEdits: (_d = item.additionalTextEdits) === null || _d === void 0 ? void 0 : _d.map(asTextEdit),
+        command: item.command ? asCommand(item.command) : undefined,
+    };
+}
+exports.asCompletionItem = asCompletionItem;
+function asCommand(command) {
+    return {
+        id: command.command,
+        title: command.title,
+        arguments: command.arguments,
+    };
+}
+exports.asCommand = asCommand;
+function asTextEdit(edit) {
+    return {
+        range: asRange(edit.range),
+        text: edit.newText,
+    };
+}
+exports.asTextEdit = asTextEdit;
+function asCompletionItemRange(textEdit) {
+    if (protocol.InsertReplaceEdit.is(textEdit)) {
+        const result = {
+            insert: asRange(textEdit.insert),
+            replace: asRange(textEdit.replace),
+        };
+        return result;
+    }
+    return asRange(textEdit.range);
+}
+exports.asCompletionItemRange = asCompletionItemRange;
+function asRange(range) {
+    return {
+        startLineNumber: range.start.line + 1,
+        startColumn: range.start.character + 1,
+        endLineNumber: range.end.line + 1,
+        endColumn: range.end.character + 1,
+    };
+}
+exports.asRange = asRange;
+function asHover(hover) {
+    return {
+        contents: asMarkdownString(hover.contents),
+        range: hover.range ? asRange(hover.range) : undefined,
+    };
+}
+exports.asHover = asHover;
+function asMarkdownString(markdownString) {
+    if (typeof markdownString === 'string') {
+        return [{ value: markdownString }];
+    }
+    else if (Array.isArray(markdownString)) {
+        return markdownString.map(asMarkdownString).flat();
+    }
+    else {
+        return [markdownString];
+    }
+}
+exports.asMarkdownString = asMarkdownString;
+function asLocation(definition) {
+    if (protocol.LocationLink.is(definition)) {
+        return {
+            uri: asUri(definition.targetUri),
+            range: asRange(definition.targetSelectionRange),
+        };
+    }
+    else {
+        return {
+            uri: asUri(definition.uri),
+            range: asRange(definition.range),
+        };
+    }
+}
+exports.asLocation = asLocation;
+function asUri(uri) {
+    return monaco_editor_core_1.Uri.parse(uri);
+}
+exports.asUri = asUri;
+function asSignatureHelp(signatureHelp) {
+    var _a, _b;
+    return {
+        signatures: signatureHelp.signatures.map(asSignatureInformation),
+        activeSignature: (_a = signatureHelp.activeSignature) !== null && _a !== void 0 ? _a : 0,
+        activeParameter: (_b = signatureHelp.activeParameter) !== null && _b !== void 0 ? _b : 0,
+    };
+}
+exports.asSignatureHelp = asSignatureHelp;
+function asSignatureInformation(signatureInformation) {
+    return {
+        label: signatureInformation.label,
+        documentation: signatureInformation.documentation,
+        parameters: signatureInformation.parameters
+            ? signatureInformation.parameters.map(asParameterInformation)
+            : [],
+        activeParameter: signatureInformation.activeParameter,
+    };
+}
+exports.asSignatureInformation = asSignatureInformation;
+function asParameterInformation(parameterInformation) {
+    return {
+        label: parameterInformation.label,
+        documentation: parameterInformation.documentation,
+    };
+}
+exports.asParameterInformation = asParameterInformation;
+function asMarkerData(diagnostic) {
+    var _a, _b, _c;
+    return Object.assign(Object.assign({ code: (_a = diagnostic.code) === null || _a === void 0 ? void 0 : _a.toString(), severity: asMarkerSeverity(diagnostic.severity), message: diagnostic.message, source: diagnostic.source }, asRange(diagnostic.range)), { relatedInformation: (_b = diagnostic.relatedInformation) === null || _b === void 0 ? void 0 : _b.map(asRelatedInformation), tags: (_c = diagnostic.tags) === null || _c === void 0 ? void 0 : _c.map(asMarkerTag) });
+}
+exports.asMarkerData = asMarkerData;
+function asMarkerTag(tag) {
+    switch (tag) {
+        case protocol.DiagnosticTag.Unnecessary:
+            return monaco_editor_core_1.MarkerTag.Unnecessary;
+        case protocol.DiagnosticTag.Deprecated:
+            return monaco_editor_core_1.MarkerTag.Deprecated;
+    }
+}
+exports.asMarkerTag = asMarkerTag;
+function asRelatedInformation(relatedInformation) {
+    return Object.assign({ resource: asUri(relatedInformation.location.uri), message: relatedInformation.message }, asRange(relatedInformation.location.range));
+}
+exports.asRelatedInformation = asRelatedInformation;
+function asMarkerSeverity(severity) {
+    switch (severity) {
+        case protocol.DiagnosticSeverity.Error:
+            return monaco_editor_core_1.MarkerSeverity.Error;
+        case protocol.DiagnosticSeverity.Warning:
+            return monaco_editor_core_1.MarkerSeverity.Warning;
+        case protocol.DiagnosticSeverity.Information:
+            return monaco_editor_core_1.MarkerSeverity.Info;
+        case protocol.DiagnosticSeverity.Hint:
+            return monaco_editor_core_1.MarkerSeverity.Hint;
+        default:
+            return monaco_editor_core_1.MarkerSeverity.Info;
+    }
+}
+exports.asMarkerSeverity = asMarkerSeverity;
+function asWorkspaceEdit(workspaceEdit) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    const result = {
+        edits: [],
+    };
+    if (workspaceEdit.changes) {
+        for (const uri in workspaceEdit.changes) {
+            const edits = workspaceEdit.changes[uri];
+            for (const edit of edits) {
+                result.edits.push({
+                    resource: asUri(uri),
+                    textEdit: asTextEdit(edit),
+                    versionId: undefined,
+                });
+            }
+        }
+    }
+    if (workspaceEdit.documentChanges) {
+        for (const documentChange of workspaceEdit.documentChanges) {
+            if (protocol.TextDocumentEdit.is(documentChange)) {
+                for (const edit of documentChange.edits) {
+                    result.edits.push({
+                        resource: asUri(documentChange.textDocument.uri),
+                        textEdit: asTextEdit(edit),
+                        versionId: (_a = documentChange.textDocument.version) !== null && _a !== void 0 ? _a : undefined,
+                    });
+                }
+            }
+            else if (protocol.CreateFile.is(documentChange)) {
+                result.edits.push({
+                    newResource: asUri(documentChange.uri),
+                    options: {
+                        overwrite: (_c = (_b = documentChange.options) === null || _b === void 0 ? void 0 : _b.overwrite) !== null && _c !== void 0 ? _c : false,
+                        ignoreIfExists: (_e = (_d = documentChange.options) === null || _d === void 0 ? void 0 : _d.ignoreIfExists) !== null && _e !== void 0 ? _e : false,
+                    },
+                });
+            }
+            else if (protocol.RenameFile.is(documentChange)) {
+                result.edits.push({
+                    oldResource: asUri(documentChange.oldUri),
+                    newResource: asUri(documentChange.newUri),
+                    options: {
+                        overwrite: (_g = (_f = documentChange.options) === null || _f === void 0 ? void 0 : _f.overwrite) !== null && _g !== void 0 ? _g : false,
+                        ignoreIfExists: (_j = (_h = documentChange.options) === null || _h === void 0 ? void 0 : _h.ignoreIfExists) !== null && _j !== void 0 ? _j : false,
+                    },
+                });
+            }
+            else if (protocol.DeleteFile.is(documentChange)) {
+                result.edits.push({
+                    oldResource: asUri(documentChange.uri),
+                    options: {
+                        recursive: (_l = (_k = documentChange.options) === null || _k === void 0 ? void 0 : _k.recursive) !== null && _l !== void 0 ? _l : false,
+                        ignoreIfNotExists: (_o = (_m = documentChange.options) === null || _m === void 0 ? void 0 : _m.ignoreIfNotExists) !== null && _o !== void 0 ? _o : false,
+                    },
+                });
+            }
+        }
+    }
+    return result;
+}
+exports.asWorkspaceEdit = asWorkspaceEdit;
+function asDocumentSymbol(symbol) {
+    var _a, _b;
+    return {
+        name: symbol.name,
+        detail: '',
+        kind: asSymbolKind(symbol.kind),
+        tags: (_b = (_a = symbol.tags) === null || _a === void 0 ? void 0 : _a.map(asSymbolTag)) !== null && _b !== void 0 ? _b : [],
+        range: asRange(symbol.range),
+        selectionRange: asRange(symbol.selectionRange),
+        children: symbol.children
+            ? symbol.children.map(asDocumentSymbol)
+            : undefined,
+    };
+}
+exports.asDocumentSymbol = asDocumentSymbol;
+function asSymbolTag(tag) {
+    switch (tag) {
+        case protocol.SymbolTag.Deprecated:
+            return monaco_editor_core_1.languages.SymbolTag.Deprecated;
+    }
+}
+exports.asSymbolTag = asSymbolTag;
+function asSymbolKind(kind) {
+    switch (kind) {
+        case protocol.SymbolKind.File:
+            return monaco_editor_core_1.languages.SymbolKind.File;
+        case protocol.SymbolKind.Module:
+            return monaco_editor_core_1.languages.SymbolKind.Module;
+        case protocol.SymbolKind.Namespace:
+            return monaco_editor_core_1.languages.SymbolKind.Namespace;
+        case protocol.SymbolKind.Package:
+            return monaco_editor_core_1.languages.SymbolKind.Package;
+        case protocol.SymbolKind.Class:
+            return monaco_editor_core_1.languages.SymbolKind.Class;
+        case protocol.SymbolKind.Method:
+            return monaco_editor_core_1.languages.SymbolKind.Method;
+        case protocol.SymbolKind.Property:
+            return monaco_editor_core_1.languages.SymbolKind.Property;
+        case protocol.SymbolKind.Field:
+            return monaco_editor_core_1.languages.SymbolKind.Field;
+        case protocol.SymbolKind.Constructor:
+            return monaco_editor_core_1.languages.SymbolKind.Constructor;
+        case protocol.SymbolKind.Enum:
+            return monaco_editor_core_1.languages.SymbolKind.Enum;
+        case protocol.SymbolKind.Interface:
+            return monaco_editor_core_1.languages.SymbolKind.Interface;
+        case protocol.SymbolKind.Function:
+            return monaco_editor_core_1.languages.SymbolKind.Function;
+        case protocol.SymbolKind.Variable:
+            return monaco_editor_core_1.languages.SymbolKind.Variable;
+        case protocol.SymbolKind.Constant:
+            return monaco_editor_core_1.languages.SymbolKind.Constant;
+        case protocol.SymbolKind.String:
+            return monaco_editor_core_1.languages.SymbolKind.String;
+        case protocol.SymbolKind.Number:
+            return monaco_editor_core_1.languages.SymbolKind.Number;
+        case protocol.SymbolKind.Boolean:
+            return monaco_editor_core_1.languages.SymbolKind.Boolean;
+        case protocol.SymbolKind.Array:
+            return monaco_editor_core_1.languages.SymbolKind.Array;
+        case protocol.SymbolKind.Object:
+            return monaco_editor_core_1.languages.SymbolKind.Object;
+        case protocol.SymbolKind.Key:
+            return monaco_editor_core_1.languages.SymbolKind.Key;
+        case protocol.SymbolKind.Null:
+            return monaco_editor_core_1.languages.SymbolKind.Null;
+        case protocol.SymbolKind.EnumMember:
+            return monaco_editor_core_1.languages.SymbolKind.EnumMember;
+        case protocol.SymbolKind.Struct:
+            return monaco_editor_core_1.languages.SymbolKind.Struct;
+        case protocol.SymbolKind.Event:
+            return monaco_editor_core_1.languages.SymbolKind.Event;
+        case protocol.SymbolKind.Operator:
+            return monaco_editor_core_1.languages.SymbolKind.Operator;
+        case protocol.SymbolKind.TypeParameter:
+            return monaco_editor_core_1.languages.SymbolKind.TypeParameter;
+        default:
+            return monaco_editor_core_1.languages.SymbolKind.File;
+    }
+}
+exports.asSymbolKind = asSymbolKind;
+function asDocumentHighlight(highlight) {
+    return {
+        range: asRange(highlight.range),
+        kind: asDocumentHighlightKind(highlight.kind),
+    };
+}
+exports.asDocumentHighlight = asDocumentHighlight;
+function asDocumentHighlightKind(kind) {
+    switch (kind) {
+        case protocol.DocumentHighlightKind.Text:
+            return monaco_editor_core_1.languages.DocumentHighlightKind.Text;
+        case protocol.DocumentHighlightKind.Read:
+            return monaco_editor_core_1.languages.DocumentHighlightKind.Read;
+        case protocol.DocumentHighlightKind.Write:
+            return monaco_editor_core_1.languages.DocumentHighlightKind.Write;
+        default:
+            return monaco_editor_core_1.languages.DocumentHighlightKind.Text;
+    }
+}
+exports.asDocumentHighlightKind = asDocumentHighlightKind;
+function asCodeLens(item) {
+    return {
+        range: asRange(item.range),
+        command: item.command ? asCommand(item.command) : undefined,
+    };
+}
+exports.asCodeLens = asCodeLens;
+function asCodeAction(item) {
+    var _a;
+    return {
+        title: item.title,
+        command: item.command ? asCommand(item.command) : undefined,
+        edit: item.edit ? asWorkspaceEdit(item.edit) : undefined,
+        diagnostics: item.diagnostics
+            ? item.diagnostics.map(asMarkerData)
+            : undefined,
+        kind: item.kind,
+        isPreferred: item.isPreferred,
+        disabled: (_a = item.disabled) === null || _a === void 0 ? void 0 : _a.reason,
+    };
+}
+exports.asCodeAction = asCodeAction;
+function asLink(item) {
+    return {
+        range: asRange(item.range),
+        url: item.target,
+        tooltip: item.tooltip,
+    };
+}
+exports.asLink = asLink;
+function asColorInformation(item) {
+    return {
+        range: asRange(item.range),
+        color: item.color,
+    };
+}
+exports.asColorInformation = asColorInformation;
+function asColorPresentation(item) {
+    return {
+        label: item.label,
+        textEdit: item.textEdit ? asTextEdit(item.textEdit) : undefined,
+        additionalTextEdits: item.additionalTextEdits
+            ? item.additionalTextEdits.map(asTextEdit)
+            : undefined,
+    };
+}
+exports.asColorPresentation = asColorPresentation;
+function asFoldingRange(item) {
+    var _a;
+    return {
+        start: item.startLine + 1,
+        end: item.endLine + 1,
+        kind: {
+            value: (_a = item.kind) !== null && _a !== void 0 ? _a : '',
+        },
+    };
+}
+exports.asFoldingRange = asFoldingRange;
+function asSelectionRange(item) {
+    return {
+        range: asRange(item.range),
+    };
+}
+exports.asSelectionRange = asSelectionRange;
+function asInlayHint(item) {
+    return {
+        label: asInlayHintLabel(item.label),
+        tooltip: item.tooltip,
+        position: asPosition(item.position),
+        kind: item.kind ? asInlayHintKind(item.kind) : undefined,
+        paddingLeft: item.paddingLeft,
+        paddingRight: item.paddingRight,
+    };
+}
+exports.asInlayHint = asInlayHint;
+function asInlayHintKind(kind) {
+    switch (kind) {
+        case protocol.InlayHintKind.Parameter:
+            return monaco_editor_core_1.languages.InlayHintKind.Parameter;
+        case protocol.InlayHintKind.Type:
+            return monaco_editor_core_1.languages.InlayHintKind.Type;
+    }
+}
+exports.asInlayHintKind = asInlayHintKind;
+function asInlayHintLabel(label) {
+    if (typeof label === 'string') {
+        return label;
+    }
+    else {
+        return label.map(asInlayHintLabelPart);
+    }
+}
+exports.asInlayHintLabel = asInlayHintLabel;
+function asInlayHintLabelPart(part) {
+    return {
+        label: part.value,
+        tooltip: part.tooltip,
+        command: part.command ? asCommand(part.command) : undefined,
+        location: part.location ? asLocation(part.location) : undefined,
+    };
+}
+exports.asInlayHintLabelPart = asInlayHintLabelPart;
+function asPosition(position) {
+    return new monaco_editor_core_1.Position(position.line + 1, position.character + 1);
+}
+exports.asPosition = asPosition;
+//# sourceMappingURL=protocol2monaco.js.map

package/out/utils/provider.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageService } from '@volar/language-service';
+import type { editor, languages } from 'monaco-editor-core';
+export declare function createLanguageFeaturesProvider(worker: editor.MonacoWebWorker<LanguageService>): Promise<languages.HoverProvider & languages.DocumentSymbolProvider & languages.DocumentHighlightProvider & languages.LinkedEditingRangeProvider & languages.DefinitionProvider & languages.ImplementationProvider & languages.TypeDefinitionProvider & languages.CodeLensProvider & languages.CodeActionProvider & Omit<languages.DocumentFormattingEditProvider, 'displayName'> & Omit<languages.DocumentRangeFormattingEditProvider, 'displayName'> & languages.OnTypeFormattingEditProvider & languages.LinkProvider & languages.CompletionItemProvider & languages.DocumentColorProvider & languages.FoldingRangeProvider & languages.DeclarationProvider & languages.SignatureHelpProvider & languages.RenameProvider & languages.ReferenceProvider & languages.SelectionRangeProvider & languages.InlayHintsProvider>;