@vue/language-service 1.9.0-alpha.3 → 2.0.1

package/lib/plugins/css.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const volar_service_css_1 = require("volar-service-css");
+function create() {
+    const base = (0, volar_service_css_1.create)({ scssDocumentSelector: ['scss', 'postcss'] });
+    return {
+        ...base,
+        create(context) {
+            const baseInstance = base.create(context);
+            return {
+                ...baseInstance,
+                async provideDiagnostics(document, token) {
+                    let diagnostics = await baseInstance.provideDiagnostics?.(document, token) ?? [];
+                    if (document.languageId === 'postcss') {
+                        diagnostics = diagnostics.filter(diag => diag.code !== 'css-semicolonexpected');
+                        diagnostics = diagnostics.filter(diag => diag.code !== 'css-ruleorselectorexpected');
+                        diagnostics = diagnostics.filter(diag => diag.code !== 'unknownAtRules');
+                    }
+                    return diagnostics;
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=css.js.map

package/{out → lib}/plugins/data.d.ts

@@ -1,5 +1,4 @@
-import * as html from 'vscode-html-languageservice';
+import type * as html from 'vscode-html-languageservice';
 export declare function loadTemplateData(lang: string): html.HTMLDataV1;
 export declare function loadLanguageBlocks(lang: string): html.HTMLDataV1;
 export declare function loadModelModifiersData(lang: string): html.HTMLDataV1;
-//# sourceMappingURL=data.d.ts.map

package/lib/plugins/vue-autoinsert-dotvalue.d.ts

@@ -0,0 +1,10 @@
+import type { ServicePlugin } from '@volar/language-service';
+import type * as ts from 'typescript';
+import type * as vscode from 'vscode-languageserver-protocol';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function create(ts: typeof import('typescript')): ServicePlugin;
+export declare function isCharacterTyping(document: TextDocument, lastChange: {
+    range: vscode.Range;
+    text: string;
+}): boolean;
+export declare function isBlacklistNode(ts: typeof import('typescript'), node: ts.Node, pos: number, allowAccessDotValue: boolean): boolean;

package/{out → lib}/plugins/vue-autoinsert-dotvalue.js

@@ -2,62 +2,78 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBlacklistNode = exports.isCharacterTyping = exports.create = void 0;
 const language_core_1 = require("@vue/language-core");
-const plugin = (context, modules) => {
-    if (!modules?.typescript)
-        return {};
-    const ts = modules.typescript;
+const namedPipeClient = require("@vue/typescript-plugin/lib/client");
+const asts = new WeakMap();
+function getAst(ts, fileName, snapshot, scriptKind) {
+    let ast = asts.get(snapshot);
+    if (!ast) {
+        ast = ts.createSourceFile(fileName, snapshot.getText(0, snapshot.getLength()), ts.ScriptTarget.Latest, undefined, scriptKind);
+        asts.set(snapshot, ast);
+    }
+    return ast;
+}
+function create(ts) {
     return {
-        async provideAutoInsertionEdit(document, position, insertContext) {
-            if (!isTsDocument(document))
-                return;
-            if (!isCharacterTyping(document, insertContext))
-                return;
-            const enabled = await context.env.getConfiguration?.('vue.autoInsert.dotValue') ?? true;
-            if (!enabled)
-                return;
-            const program = context.inject('typescript/languageService').getProgram();
-            if (!program)
-                return;
-            const sourceFile = program.getSourceFile(context.env.uriToFileName(document.uri));
-            if (!sourceFile)
-                return;
-            if (isBlacklistNode(ts, sourceFile, document.offsetAt(position), false))
-                return;
-            const node = findPositionIdentifier(sourceFile, sourceFile, document.offsetAt(position));
-            if (!node)
-                return;
-            const token = context.inject('typescript/languageServiceHost').getCancellationToken?.();
-            if (token) {
-                context.inject('typescript/languageService').getQuickInfoAtPosition(context.env.uriToFileName(document.uri), node.end);
-                if (token?.isCancellationRequested()) {
-                    return; // check cancel here because type checker do not use cancel token
-                }
-            }
-            const checker = program.getTypeChecker();
-            const type = checker.getTypeAtLocation(node);
-            const props = type.getProperties();
-            if (props.some(prop => prop.name === 'value')) {
-                return '${1:.value}';
-            }
-            function findPositionIdentifier(sourceFile, node, offset) {
-                let result;
-                node.forEachChild(child => {
-                    if (!result) {
-                        if (child.end === offset && ts.isIdentifier(child)) {
-                            result = child;
+        name: 'vue-autoinsert-dotvalue',
+        create(context) {
+            let currentReq = 0;
+            return {
+                async provideAutoInsertionEdit(document, position, lastChange) {
+                    if (!isTsDocument(document))
+                        return;
+                    if (!isCharacterTyping(document, lastChange))
+                        return;
+                    const req = ++currentReq;
+                    // Wait for tsserver to sync
+                    await sleep(250);
+                    if (req !== currentReq)
+                        return;
+                    const enabled = await context.env.getConfiguration?.('vue.autoInsert.dotValue') ?? true;
+                    if (!enabled)
+                        return;
+                    const [code, file] = context.documents.getVirtualCodeByUri(document.uri);
+                    if (!file)
+                        return;
+                    let ast;
+                    let sourceCodeOffset = document.offsetAt(position);
+                    const fileName = context.env.typescript.uriToFileName(file.id);
+                    if (file?.generated) {
+                        const script = file.generated.languagePlugin.typescript?.getScript(file.generated.code);
+                        if (script?.code !== code) {
+                            return;
                         }
-                        else if (child.end >= offset && child.getStart(sourceFile) < offset) {
-                            result = findPositionIdentifier(sourceFile, child, offset);
+                        ast = getAst(ts, fileName, script.code.snapshot, script.scriptKind);
+                        let mapped = false;
+                        for (const [_1, [_2, map]] of context.language.files.getMaps(code)) {
+                            const sourceOffset = map.getSourceOffset(document.offsetAt(position));
+                            if (sourceOffset !== undefined) {
+                                sourceCodeOffset = sourceOffset[0];
+                                mapped = true;
+                                break;
+                            }
+                        }
+                        if (!mapped) {
+                            return;
                         }
                     }
-                });
-                return result;
-            }
+                    else {
+                        ast = getAst(ts, fileName, file.snapshot);
+                    }
+                    if (isBlacklistNode(ts, ast, document.offsetAt(position), false))
+                        return;
+                    const props = await namedPipeClient.getPropertiesAtLocation(fileName, sourceCodeOffset) ?? [];
+                    if (props.some(prop => prop === 'value')) {
+                        return '${1:.value}';
+                    }
+                },
+            };
         },
     };
-};
-const create = () => plugin;
+}
 exports.create = create;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
 function isTsDocument(document) {
     return document.languageId === 'javascript' ||
         document.languageId === 'typescript' ||
@@ -65,12 +81,12 @@ function isTsDocument(document) {
         document.languageId === 'typescriptreact';
 }
 const charReg = /\w/;
-function isCharacterTyping(document, options) {
-    const lastCharacter = options.lastChange.text[options.lastChange.text.length - 1];
-    const rangeStart = options.lastChange.range.start;
+function isCharacterTyping(document, lastChange) {
+    const lastCharacter = lastChange.text[lastChange.text.length - 1];
+    const rangeStart = lastChange.range.start;
     const position = {
         line: rangeStart.line,
-        character: rangeStart.character + options.lastChange.text.length,
+        character: rangeStart.character + lastChange.text.length,
     };
     const nextCharacter = document.getText({
         start: position,
@@ -79,7 +95,7 @@ function isCharacterTyping(document, options) {
     if (lastCharacter === undefined) { // delete text
         return false;
     }
-    if (options.lastChange.text.indexOf('\n') >= 0) { // multi-line change
+    if (lastChange.text.indexOf('\n') >= 0) { // multi-line change
         return false;
     }
     return charReg.test(lastCharacter) && !charReg.test(nextCharacter);

package/lib/plugins/vue-autoinsert-parentheses.d.ts

@@ -0,0 +1,2 @@
+import type { ServicePlugin } from '@volar/language-service';
+export declare function create(ts: typeof import('typescript')): ServicePlugin;

package/lib/plugins/vue-autoinsert-parentheses.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const vue_autoinsert_dotvalue_1 = require("./vue-autoinsert-dotvalue");
+function create(ts) {
+    return {
+        name: 'vue-autoinsert-parentheses',
+        create(context) {
+            return {
+                async provideAutoInsertionEdit(document, position, lastChange) {
+                    const enabled = await context.env.getConfiguration?.('vue.autoInsert.parentheses') ?? false;
+                    if (!enabled)
+                        return;
+                    if (!(0, vue_autoinsert_dotvalue_1.isCharacterTyping)(document, lastChange))
+                        return;
+                    const [virtualCode] = context.documents.getVirtualCodeByUri(document.uri);
+                    if (virtualCode?.id !== 'template_format')
+                        return;
+                    const offset = document.offsetAt(position);
+                    for (const mappedRange of virtualCode.mappings) {
+                        const generatedCodeEnd = mappedRange.generatedOffsets[mappedRange.generatedOffsets.length - 1]
+                            + mappedRange.lengths[mappedRange.lengths.length - 1];
+                        if (generatedCodeEnd === offset) {
+                            const text = document.getText().substring(mappedRange.generatedOffsets[0], generatedCodeEnd);
+                            const ast = ts.createSourceFile('', text, ts.ScriptTarget.Latest);
+                            if (ast.statements.length === 1) {
+                                const statement = ast.statements[0];
+                                if (ts.isExpressionStatement(statement)
+                                    && ((ts.isAsExpression(statement.expression)
+                                        && ts.isTypeReferenceNode(statement.expression.type)
+                                        && ts.isIdentifier(statement.expression.type.typeName)
+                                        && statement.expression.type.typeName.text)
+                                        || (ts.isBinaryExpression(statement.expression)
+                                            && statement.expression.right.getText(ast)
+                                            && statement.expression.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword)
+                                        || (ts.isTypeOfExpression(statement.expression)
+                                            && statement.expression.expression.getText(ast)))) {
+                                    // https://code.visualstudio.com/docs/editor/userdefinedsnippets#_grammar
+                                    const escapedText = text
+                                        .replaceAll('\\', '\\\\')
+                                        .replaceAll('$', '\\$')
+                                        .replaceAll('}', '\\}');
+                                    return {
+                                        range: {
+                                            start: document.positionAt(mappedRange.generatedOffsets[0]),
+                                            end: document.positionAt(generatedCodeEnd),
+                                        },
+                                        newText: '(' + escapedText + '$0' + ')',
+                                    };
+                                }
+                            }
+                        }
+                    }
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-autoinsert-parentheses.js.map

package/lib/plugins/vue-autoinsert-space.d.ts

@@ -0,0 +1,2 @@
+import type { ServicePlugin } from '@volar/language-service';
+export declare function create(): ServicePlugin;

package/lib/plugins/vue-autoinsert-space.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+function create() {
+    return {
+        name: 'vue-autoinsert-space',
+        create(context) {
+            return {
+                async provideAutoInsertionEdit(document, _, lastChange) {
+                    if (document.languageId === 'html' || document.languageId === 'jade') {
+                        const enabled = await context.env.getConfiguration?.('vue.autoInsert.bracketSpacing') ?? true;
+                        if (!enabled)
+                            return;
+                        if (lastChange.text === '{}'
+                            && document.getText({
+                                start: { line: lastChange.range.start.line, character: lastChange.range.start.character - 1 },
+                                end: { line: lastChange.range.start.line, character: lastChange.range.start.character + 3 }
+                            }) === '{{}}') {
+                            return {
+                                newText: ` $0 `,
+                                range: {
+                                    start: { line: lastChange.range.start.line, character: lastChange.range.start.character + 1 },
+                                    end: { line: lastChange.range.start.line, character: lastChange.range.start.character + 1 }
+                                },
+                            };
+                        }
+                    }
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-autoinsert-space.js.map

package/lib/plugins/vue-codelens-references.d.ts

@@ -0,0 +1,2 @@
+import type { ServicePlugin } from '@volar/language-service';
+export declare function create(): ServicePlugin;

package/lib/plugins/vue-codelens-references.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const language_core_1 = require("@vue/language-core");
+function create() {
+    return {
+        name: 'vue-codelens-references',
+        create(context) {
+            return {
+                provideReferencesCodeLensRanges(document) {
+                    return worker(document.uri, virtualCode => {
+                        const result = [];
+                        for (const map of context.documents.getMaps(virtualCode) ?? []) {
+                            for (const mapping of map.map.mappings) {
+                                if (!mapping.data.__referencesCodeLens)
+                                    continue;
+                                result.push({
+                                    start: document.positionAt(mapping.generatedOffsets[0]),
+                                    end: document.positionAt(mapping.generatedOffsets[mapping.generatedOffsets.length - 1]
+                                        + mapping.lengths[mapping.lengths.length - 1]),
+                                });
+                            }
+                        }
+                        return result;
+                    });
+                },
+            };
+            function worker(uri, callback) {
+                const [virtualCode, sourceFile] = context.documents.getVirtualCodeByUri(uri);
+                if (!(sourceFile?.generated?.code instanceof language_core_1.VueGeneratedCode) || !sourceFile)
+                    return;
+                return callback(virtualCode, sourceFile);
+            }
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-codelens-references.js.map

package/lib/plugins/vue-directive-comments.d.ts

@@ -0,0 +1,2 @@
+import type { ServicePlugin } from '@volar/language-service';
+export declare function create(): ServicePlugin;

package/lib/plugins/vue-directive-comments.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const cmds = [
+    'vue-ignore',
+    'vue-skip',
+    'vue-expect-error',
+];
+const directiveCommentReg = /<!--\s*@/;
+function create() {
+    return {
+        name: 'vue-directive-comments',
+        triggerCharacters: ['@'],
+        create() {
+            return {
+                provideCompletionItems(document, position) {
+                    if (document.languageId !== 'html')
+                        return;
+                    const line = document.getText({ start: { line: position.line, character: 0 }, end: position });
+                    const cmdStart = line.match(directiveCommentReg);
+                    if (!cmdStart)
+                        return;
+                    const startIndex = cmdStart.index + cmdStart[0].length;
+                    const remainText = line.substring(startIndex);
+                    const result = [];
+                    for (const cmd of cmds) {
+                        let match = true;
+                        for (let i = 0; i < remainText.length; i++) {
+                            if (remainText[i] !== cmd[i]) {
+                                console.log(JSON.stringify(remainText[i]), JSON.stringify(cmd[i]));
+                                match = false;
+                                break;
+                            }
+                        }
+                        if (match) {
+                            result.push({
+                                label: '@' + cmd,
+                                textEdit: {
+                                    range: {
+                                        start: {
+                                            line: position.line,
+                                            character: startIndex - 1,
+                                        },
+                                        end: position,
+                                    },
+                                    newText: '@' + cmd,
+                                },
+                            });
+                        }
+                    }
+                    return {
+                        isIncomplete: false,
+                        items: result,
+                    };
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-directive-comments.js.map

package/lib/plugins/vue-document-drop.d.ts

@@ -0,0 +1,2 @@
+import { ServicePlugin } from '../types';
+export declare function create(ts: typeof import('typescript')): ServicePlugin;

package/lib/plugins/vue-document-drop.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const language_core_1 = require("@vue/language-core");
+const shared_1 = require("@vue/shared");
+const path = require("path-browserify");
+const vue_extract_file_1 = require("../plugins/vue-extract-file");
+const types_1 = require("../types");
+function create(ts) {
+    return {
+        name: 'vue-document-drop',
+        create(context) {
+            let casing = types_1.TagNameCasing.Pascal; // TODO
+            return {
+                async provideDocumentDropEdits(document, _position, dataTransfer) {
+                    if (document.languageId !== 'html')
+                        return;
+                    const [virtualCode, sourceFile] = context.documents.getVirtualCodeByUri(document.uri);
+                    const vueVirtualCode = sourceFile?.generated?.code;
+                    if (!virtualCode || !(vueVirtualCode instanceof language_core_1.VueGeneratedCode))
+                        return;
+                    let importUri;
+                    for (const [mimeType, item] of dataTransfer) {
+                        if (mimeType === 'text/uri-list') {
+                            importUri = item.value;
+                        }
+                    }
+                    if (!importUri?.endsWith('.vue'))
+                        return;
+                    let baseName = importUri.substring(importUri.lastIndexOf('/') + 1);
+                    baseName = baseName.substring(0, baseName.lastIndexOf('.'));
+                    const newName = (0, shared_1.capitalize)((0, shared_1.camelize)(baseName));
+                    const { sfc } = vueVirtualCode;
+                    const script = sfc.scriptSetup ?? sfc.script;
+                    if (!script)
+                        return;
+                    const additionalEdit = {};
+                    const code = [...(0, language_core_1.forEachEmbeddedCode)(vueVirtualCode)].find(code => code.id === (sfc.scriptSetup ? 'scriptSetupFormat' : 'scriptFormat'));
+                    const lastImportNode = (0, vue_extract_file_1.getLastImportNode)(ts, script.ast);
+                    let importPath = path.relative(path.dirname(document.uri), importUri)
+                        || importUri.substring(importUri.lastIndexOf('/') + 1);
+                    if (!importPath.startsWith('./') && !importPath.startsWith('../')) {
+                        importPath = './' + importPath;
+                    }
+                    additionalEdit.changes ??= {};
+                    additionalEdit.changes[context.documents.getVirtualCodeUri(sourceFile.id, code.id)] = [];
+                    additionalEdit.changes[context.documents.getVirtualCodeUri(sourceFile.id, code.id)].push({
+                        range: lastImportNode ? {
+                            start: script.ast.getLineAndCharacterOfPosition(lastImportNode.end),
+                            end: script.ast.getLineAndCharacterOfPosition(lastImportNode.end),
+                        } : {
+                            start: script.ast.getLineAndCharacterOfPosition(0),
+                            end: script.ast.getLineAndCharacterOfPosition(0),
+                        },
+                        newText: `\nimport ${newName} from '${importPath}'`
+                            + (lastImportNode ? '' : '\n'),
+                    });
+                    if (sfc.script) {
+                        const edit = (0, vue_extract_file_1.createAddComponentToOptionEdit)(ts, sfc.script.ast, newName);
+                        if (edit) {
+                            additionalEdit.changes[context.documents.getVirtualCodeUri(sourceFile.id, code.id)].push({
+                                range: {
+                                    start: document.positionAt(edit.range.start),
+                                    end: document.positionAt(edit.range.end),
+                                },
+                                newText: edit.newText,
+                            });
+                        }
+                    }
+                    return {
+                        insertText: `<${casing === types_1.TagNameCasing.Kebab ? (0, shared_1.hyphenate)(newName) : newName}$0 />`,
+                        insertTextFormat: 2,
+                        additionalEdit,
+                    };
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=vue-document-drop.js.map

package/lib/plugins/vue-extract-file.d.ts

@@ -0,0 +1,8 @@
+import type { ServicePlugin } from '@volar/language-service';
+import type * as ts from 'typescript';
+export declare function create(ts: typeof import('typescript')): ServicePlugin;
+export declare function getLastImportNode(ts: typeof import('typescript'), sourceFile: ts.SourceFile): ts.Node | undefined;
+export declare function createAddComponentToOptionEdit(ts: typeof import('typescript'), ast: ts.SourceFile, componentName: string): {
+    range: import("@vue/language-core").TextRange;
+    newText: string;
+} | undefined;