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

package/{out → lib}/types.d.ts

@@ -1,12 +1,27 @@
 import type * as CompilerDOM from '@vue/compiler-dom';
 import type { SFCParseResult } from '@vue/compiler-sfc';
-import type * as ts from 'typescript/lib/tsserverlibrary';
-import type { VueEmbeddedFile } from './virtualFile/embeddedFile';
+import type * as ts from 'typescript';
+import type { VueEmbeddedCode } from './virtualFile/embeddedFile';
+import type { CodeInformation, Segment } from '@volar/language-core';
 export type { SFCParseResult } from '@vue/compiler-sfc';
 export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
     target?: 'auto' | 2 | 2.7 | 3 | 3.3;
     plugins?: string[];
 };
+export interface VueCodeInformation extends CodeInformation {
+    __referencesCodeLens?: boolean;
+    __displayWithLink?: boolean;
+    __hint?: {
+        setting: string;
+        label: string;
+        tooltip: string;
+        paddingRight?: boolean;
+        paddingLeft?: boolean;
+    };
+    __combineLastMappping?: boolean;
+}
+export type CodeAndStack = [code: Code, stack: string];
+export type Code = Segment<VueCodeInformation>;
 export interface VueCompilerOptions {
     target: number;
     lib: string;
@@ -28,23 +43,23 @@ export interface VueCompilerOptions {
         withDefaults: string[];
     };
     plugins: VueLanguagePlugin[];
-    hooks: string[];
     experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
     experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
     experimentalUseElementAccessInTemplate: boolean;
-    experimentalAdditionalLanguageModules: string[];
 }
+export declare const pluginVersion = 2;
 export type VueLanguagePlugin = (ctx: {
     modules: {
-        typescript: typeof import('typescript/lib/tsserverlibrary');
+        typescript: typeof import('typescript');
         '@vue/compiler-dom': typeof import('@vue/compiler-dom');
     };
     compilerOptions: ts.CompilerOptions;
     vueCompilerOptions: VueCompilerOptions;
     codegenStack: boolean;
+    globalTypesHolder: string | undefined;
 }) => {
-    version: 1;
+    version: typeof pluginVersion;
     name?: string;
     order?: number;
     requiredCompilerOptions?: string[];
@@ -61,8 +76,11 @@ export type VueLanguagePlugin = (ctx: {
         end: number;
         newText: string;
     }): CompilerDOM.CodegenResult | undefined;
-    getEmbeddedFileNames?(fileName: string, sfc: Sfc): string[];
-    resolveEmbeddedFile?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedFile): void;
+    getEmbeddedCodes?(fileName: string, sfc: Sfc): {
+        id: string;
+        lang: string;
+    }[];
+    resolveEmbeddedCode?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedCode): void;
 };
 export interface SfcBlock {
     name: string;
@@ -122,4 +140,3 @@ export interface TextRange {
     start: number;
     end: number;
 }
-//# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginVersion = void 0;
+exports.pluginVersion = 2;
+//# sourceMappingURL=types.js.map

package/{out → lib}/utils/parseCssClassNames.d.ts

@@ -2,4 +2,3 @@ export declare function parseCssClassNames(styleContent: string): Generator<{
     offset: number;
     text: string;
 }, void, unknown>;
-//# sourceMappingURL=parseCssClassNames.d.ts.map

package/{out → lib}/utils/parseCssVars.d.ts

@@ -3,4 +3,3 @@ export declare function parseCssVars(styleContent: string): Generator<{
     text: string;
 }, void, unknown>;
 export declare function clearComments(css: string): string;
-//# sourceMappingURL=parseCssVars.d.ts.map

package/{out → lib}/utils/parseSfc.d.ts

@@ -1,3 +1,2 @@
 import type { SFCParseResult } from '@vue/compiler-sfc';
 export declare function parse(source: string): SFCParseResult;
-//# sourceMappingURL=parseSfc.d.ts.map

package/{out → lib}/utils/parseSfc.js

@@ -9,20 +9,7 @@ function parse(source) {
         isNativeTag: () => true,
         // preserve all whitespaces
         isPreTag: () => true,
-        getTextMode: ({ tag, props }, parent) => {
-            if ((!parent && tag !== 'template')
-                || (tag === 'template'
-                    && props.some(p => p.type === 6 /* compiler.NodeTypes.ATTRIBUTE */ &&
-                        p.name === 'lang' &&
-                        p.value &&
-                        p.value.content &&
-                        p.value.content !== 'html'))) {
-                return 2 /* compiler.TextModes.RAWTEXT */;
-            }
-            else {
-                return 0 /* compiler.TextModes.DATA */;
-            }
-        },
+        parseMode: 'sfc',
         onError: e => {
             errors.push(e);
         },
@@ -41,13 +28,12 @@ function parse(source) {
         shouldForceReload: () => false,
     };
     ast.children.forEach(node => {
-        if (node.type !== 1 /* compiler.NodeTypes.ELEMENT */) {
+        if (node.type !== compiler.NodeTypes.ELEMENT) {
             return;
         }
         switch (node.tag) {
             case 'template':
-                const templateBlock = (descriptor.template = createBlock(node, source));
-                templateBlock.ast = node;
+                descriptor.template = createBlock(node, source);
                 break;
             case 'script':
                 const scriptBlock = createBlock(node, source);
@@ -109,7 +95,7 @@ function createBlock(node, source) {
         attrs
     };
     node.props.forEach(p => {
-        if (p.type === 6 /* compiler.NodeTypes.ATTRIBUTE */) {
+        if (p.type === compiler.NodeTypes.ATTRIBUTE) {
             attrs[p.name] = p.value ? p.value.content || true : true;
             if (p.name === 'lang') {
                 block.lang = p.value && p.value.content;

package/{out → lib}/utils/shared.d.ts

@@ -1,4 +1,3 @@
 export declare function getSlotsPropertyName(vueVersion: number): "$scopedSlots" | "$slots";
 export { hyphenate as hyphenateTag } from '@vue/shared';
 export declare function hyphenateAttr(str: string): string;
-//# sourceMappingURL=shared.d.ts.map

package/lib/utils/transform.d.ts

@@ -0,0 +1,8 @@
+import type * as ts from 'typescript';
+import type { VueCompilerOptions } from '../types';
+export declare function eachInterpolationSegment(ts: typeof import('typescript'), code: string, ast: ts.SourceFile, localVars: Map<string, number>, identifiers: Set<string>, vueOptions: VueCompilerOptions, ctxVars?: {
+    text: string;
+    isShorthand: boolean;
+    offset: number;
+}[]): Generator<[fragment: string, offset: number | undefined, isJustForErrorMapping?: boolean]>;
+export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, result: string[]): void;

package/{out → lib}/utils/transform.js

@@ -1,94 +1,94 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectVars = exports.walkInterpolationFragment = void 0;
+exports.collectVars = exports.eachInterpolationSegment = void 0;
 const shared_1 = require("@vue/shared");
-function walkInterpolationFragment(ts, code, ast, cb, localVars, identifiers, vueOptions) {
-    let ctxVars = [];
+const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+function* eachInterpolationSegment(ts, code, ast, localVars, identifiers, vueOptions, ctxVars = []) {
     const varCb = (id, isShorthand) => {
-        if (localVars.get(id.text) ||
+        const text = (0, scriptSetupRanges_1.getNodeText)(ts, id, ast);
+        if (localVars.get(text) ||
             // https://github.com/vuejs/core/blob/245230e135152900189f13a4281302de45fdcfaa/packages/compiler-core/src/transforms/transformExpression.ts#L342-L352
-            (0, shared_1.isGloballyWhitelisted)(id.text) ||
-            id.text === 'require' ||
-            id.text.startsWith('__VLS_')) {
+            (0, shared_1.isGloballyWhitelisted)(text) ||
+            text === 'require' ||
+            text.startsWith('__VLS_')) {
             // localVarOffsets.push(localVar.getStart(ast));
         }
         else {
             ctxVars.push({
-                text: id.text,
+                text,
                 isShorthand: isShorthand,
-                offset: id.getStart(ast),
+                offset: (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start,
             });
-            identifiers.add(id.text);
+            identifiers.add(text);
         }
     };
-    ast.forEachChild(node => walkIdentifiers(ts, node, varCb, localVars));
+    ts.forEachChild(ast, node => walkIdentifiers(ts, node, ast, varCb, localVars));
     ctxVars = ctxVars.sort((a, b) => a.offset - b.offset);
     if (ctxVars.length) {
         if (ctxVars[0].isShorthand) {
-            cb(code.substring(0, ctxVars[0].offset + ctxVars[0].text.length), 0);
-            cb(': ', undefined);
+            yield [code.substring(0, ctxVars[0].offset + ctxVars[0].text.length), 0];
+            yield [': ', undefined];
         }
         else {
-            cb(code.substring(0, ctxVars[0].offset), 0);
+            yield [code.substring(0, ctxVars[0].offset), 0];
         }
         for (let i = 0; i < ctxVars.length - 1; i++) {
             // fix https://github.com/vuejs/language-tools/issues/1205
             // fix https://github.com/vuejs/language-tools/issues/1264
-            cb('', ctxVars[i + 1].offset, true);
+            yield ['', ctxVars[i + 1].offset, true];
             if (vueOptions.experimentalUseElementAccessInTemplate) {
                 const varStart = ctxVars[i].offset;
                 const varEnd = ctxVars[i].offset + ctxVars[i].text.length;
-                cb('__VLS_ctx[', undefined);
-                cb('', varStart, true);
-                cb("'", undefined);
-                cb(code.substring(varStart, varEnd), varStart);
-                cb("'", undefined);
-                cb('', varEnd, true);
-                cb(']', undefined);
+                yield ['__VLS_ctx[', undefined];
+                yield ['', varStart, true];
+                yield ["'", undefined];
+                yield [code.substring(varStart, varEnd), varStart];
+                yield ["'", undefined];
+                yield ['', varEnd, true];
+                yield [']', undefined];
                 if (ctxVars[i + 1].isShorthand) {
-                    cb(code.substring(varEnd, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), varEnd);
-                    cb(': ', undefined);
+                    yield [code.substring(varEnd, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), varEnd];
+                    yield [': ', undefined];
                 }
                 else {
-                    cb(code.substring(varEnd, ctxVars[i + 1].offset), varEnd);
+                    yield [code.substring(varEnd, ctxVars[i + 1].offset), varEnd];
                 }
             }
             else {
-                cb('__VLS_ctx.', undefined);
+                yield ['__VLS_ctx.', undefined];
                 if (ctxVars[i + 1].isShorthand) {
-                    cb(code.substring(ctxVars[i].offset, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), ctxVars[i].offset);
-                    cb(': ', undefined);
+                    yield [code.substring(ctxVars[i].offset, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), ctxVars[i].offset];
+                    yield [': ', undefined];
                 }
                 else {
-                    cb(code.substring(ctxVars[i].offset, ctxVars[i + 1].offset), ctxVars[i].offset);
+                    yield [code.substring(ctxVars[i].offset, ctxVars[i + 1].offset), ctxVars[i].offset];
                 }
             }
         }
         if (vueOptions.experimentalUseElementAccessInTemplate) {
             const varStart = ctxVars[ctxVars.length - 1].offset;
             const varEnd = ctxVars[ctxVars.length - 1].offset + ctxVars[ctxVars.length - 1].text.length;
-            cb('__VLS_ctx[', undefined);
-            cb('', varStart, true);
-            cb("'", undefined);
-            cb(code.substring(varStart, varEnd), varStart);
-            cb("'", undefined);
-            cb('', varEnd, true);
-            cb(']', undefined);
-            cb(code.substring(varEnd), varEnd);
+            yield ['__VLS_ctx[', undefined];
+            yield ['', varStart, true];
+            yield ["'", undefined];
+            yield [code.substring(varStart, varEnd), varStart];
+            yield ["'", undefined];
+            yield ['', varEnd, true];
+            yield [']', undefined];
+            yield [code.substring(varEnd), varEnd];
         }
         else {
-            cb('', ctxVars[ctxVars.length - 1].offset, true);
-            cb('__VLS_ctx.', undefined);
-            cb(code.substring(ctxVars[ctxVars.length - 1].offset), ctxVars[ctxVars.length - 1].offset);
+            yield ['', ctxVars[ctxVars.length - 1].offset, true];
+            yield ['__VLS_ctx.', undefined];
+            yield [code.substring(ctxVars[ctxVars.length - 1].offset), ctxVars[ctxVars.length - 1].offset];
         }
     }
     else {
-        cb(code, 0);
+        yield [code, 0];
     }
-    return ctxVars;
 }
-exports.walkInterpolationFragment = walkInterpolationFragment;
-function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true) {
+exports.eachInterpolationSegment = eachInterpolationSegment;
+function walkIdentifiers(ts, node, ast, cb, localVars, blockVars = [], isRoot = true) {
     if (ts.isIdentifier(node)) {
         cb(node, false);
     }
@@ -96,27 +96,27 @@ function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true)
         cb(node.name, true);
     }
     else if (ts.isPropertyAccessExpression(node)) {
-        walkIdentifiers(ts, node.expression, cb, localVars, blockVars, false);
+        walkIdentifiers(ts, node.expression, ast, cb, localVars, blockVars, false);
     }
     else if (ts.isVariableDeclaration(node)) {
-        collectVars(ts, node.name, blockVars);
+        collectVars(ts, node.name, ast, blockVars);
         for (const varName of blockVars) {
             localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
         }
         if (node.initializer)
-            walkIdentifiers(ts, node.initializer, cb, localVars, blockVars, false);
+            walkIdentifiers(ts, node.initializer, ast, cb, localVars, blockVars, false);
     }
     else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
         const functionArgs = [];
         for (const param of node.parameters) {
-            collectVars(ts, param.name, functionArgs);
+            collectVars(ts, param.name, ast, functionArgs);
             if (param.type) {
-                walkIdentifiers(ts, param.type, cb, localVars, blockVars, false);
+                walkIdentifiers(ts, param.type, ast, cb, localVars, blockVars, false);
             }
         }
         for (const varName of functionArgs)
             localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
-        walkIdentifiers(ts, node.body, cb, localVars, blockVars, false);
+        walkIdentifiers(ts, node.body, ast, cb, localVars, blockVars, false);
         for (const varName of functionArgs)
             localVars.set(varName, localVars.get(varName) - 1);
     }
@@ -125,31 +125,31 @@ function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true)
             if (ts.isPropertyAssignment(prop)) {
                 // fix https://github.com/vuejs/language-tools/issues/1176
                 if (ts.isComputedPropertyName(prop.name)) {
-                    walkIdentifiers(ts, prop.name.expression, cb, localVars, blockVars, false);
+                    walkIdentifiers(ts, prop.name.expression, ast, cb, localVars, blockVars, false);
                 }
-                walkIdentifiers(ts, prop.initializer, cb, localVars, blockVars, false);
+                walkIdentifiers(ts, prop.initializer, ast, cb, localVars, blockVars, false);
             }
             // fix https://github.com/vuejs/language-tools/issues/1156
             else if (ts.isShorthandPropertyAssignment(prop)) {
-                walkIdentifiers(ts, prop, cb, localVars, blockVars, false);
+                walkIdentifiers(ts, prop, ast, cb, localVars, blockVars, false);
             }
             // fix https://github.com/vuejs/language-tools/issues/1148#issuecomment-1094378126
             else if (ts.isSpreadAssignment(prop)) {
                 // TODO: cannot report "Spread types may only be created from object types.ts(2698)"
-                walkIdentifiers(ts, prop.expression, cb, localVars, blockVars, false);
+                walkIdentifiers(ts, prop.expression, ast, cb, localVars, blockVars, false);
             }
         }
     }
     else if (ts.isTypeReferenceNode(node)) {
         // fix https://github.com/vuejs/language-tools/issues/1422
-        node.forEachChild(node => walkIdentifiersInTypeReference(ts, node, cb));
+        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
     }
     else {
         const _blockVars = blockVars;
         if (ts.isBlock(node)) {
             blockVars = [];
         }
-        node.forEachChild(node => walkIdentifiers(ts, node, cb, localVars, blockVars, false));
+        ts.forEachChild(node, node => walkIdentifiers(ts, node, ast, cb, localVars, blockVars, false));
         if (ts.isBlock(node)) {
             for (const varName of blockVars) {
                 localVars.set(varName, localVars.get(varName) - 1);
@@ -168,27 +168,27 @@ function walkIdentifiersInTypeReference(ts, node, cb) {
         cb(node.exprName, false);
     }
     else {
-        node.forEachChild(node => walkIdentifiersInTypeReference(ts, node, cb));
+        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
     }
 }
-function collectVars(ts, node, result) {
+function collectVars(ts, node, ast, result) {
     if (ts.isIdentifier(node)) {
-        result.push(node.text);
+        result.push((0, scriptSetupRanges_1.getNodeText)(ts, node, ast));
     }
     else if (ts.isObjectBindingPattern(node)) {
         for (const el of node.elements) {
-            collectVars(ts, el.name, result);
+            collectVars(ts, el.name, ast, result);
         }
     }
     else if (ts.isArrayBindingPattern(node)) {
         for (const el of node.elements) {
             if (ts.isBindingElement(el)) {
-                collectVars(ts, el.name, result);
+                collectVars(ts, el.name, ast, result);
             }
         }
     }
     else {
-        node.forEachChild(node => collectVars(ts, node, result));
+        ts.forEachChild(node, node => collectVars(ts, node, ast, result));
     }
 }
 exports.collectVars = collectVars;

package/{out → lib}/utils/ts.d.ts

@@ -1,9 +1,8 @@
-import type * as ts from 'typescript/lib/tsserverlibrary';
+import type * as ts from 'typescript';
 import type { VueCompilerOptions } from '../types';
 export type ParsedCommandLine = ts.ParsedCommandLine & {
     vueOptions: Partial<VueCompilerOptions>;
 };
-export declare function createParsedCommandLineByJson(ts: typeof import('typescript/lib/tsserverlibrary'), parseConfigHost: ts.ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
-export declare function createParsedCommandLine(ts: typeof import('typescript/lib/tsserverlibrary'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string): ParsedCommandLine;
+export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
+export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string): ParsedCommandLine;
 export declare function resolveVueCompilerOptions(vueOptions: Partial<VueCompilerOptions>): VueCompilerOptions;
-//# sourceMappingURL=ts.d.ts.map

package/{out → lib}/utils/ts.js

@@ -132,16 +132,6 @@ function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
             .flat(Infinity);
         result.plugins = plugins;
     }
-    if (rawOptions.hooks) {
-        result.hooks = rawOptions.hooks
-            .map(resolvePath)
-            .filter((hook) => !!hook);
-    }
-    if (rawOptions.experimentalAdditionalLanguageModules) {
-        result.experimentalAdditionalLanguageModules = rawOptions.experimentalAdditionalLanguageModules
-            .map(resolvePath)
-            .filter((module) => !!module);
-    }
     return result;
     function resolvePath(scriptPath) {
         try {
@@ -213,10 +203,8 @@ function resolveVueCompilerOptions(vueOptions) {
             ...vueOptions.macros,
         },
         plugins: vueOptions.plugins ?? [],
-        hooks: vueOptions.hooks ?? [],
         // experimental
         experimentalDefinePropProposal: vueOptions.experimentalDefinePropProposal ?? false,
-        experimentalAdditionalLanguageModules: vueOptions.experimentalAdditionalLanguageModules ?? [],
         experimentalResolveStyleCssClasses: vueOptions.experimentalResolveStyleCssClasses ?? 'scoped',
         // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
         // https://vuejs.org/guide/essentials/forms.html#form-input-bindings

package/lib/utils/vue2TemplateCompiler.d.ts

@@ -0,0 +1,2 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+export declare const compile: typeof CompilerDOM.compile;

package/{out → lib}/utils/vue2TemplateCompiler.js

@@ -3,7 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compile = void 0;
 const CompilerDOM = require("@vue/compiler-dom");
 const Vue2TemplateCompiler = require('vue-template-compiler/build');
-function compile(template, options = {}) {
+const compile = (template, options = {}) => {
+    if (typeof template !== 'string') {
+        throw new Error(`[@vue/language-core] compile() first argument must be string.`);
+    }
     const onError = options.onError;
     const onWarn = options.onWarn;
     options.onError = (error) => {
@@ -51,7 +54,7 @@ function compile(template, options = {}) {
         ],
         directiveTransforms: Object.assign({}, CompilerDOM.DOMDirectiveTransforms, options.directiveTransforms || {}),
     }));
-}
+};
 exports.compile = compile;
 function baseCompile(template, options = {}) {
     const onError = options.onError || ((error) => { throw error; });

package/{out → lib}/virtualFile/computedFiles.d.ts

@@ -1,4 +1,3 @@
-import { VirtualFile } from '@volar/language-core';
+import { VirtualCode } from '@volar/language-core';
 import type { Sfc, VueLanguagePlugin } from '../types';
-export declare function computedFiles(plugins: ReturnType<VueLanguagePlugin>[], fileName: string, sfc: Sfc, codegenStack: boolean): () => VirtualFile[];
-//# sourceMappingURL=computedFiles.d.ts.map
+export declare function computedFiles(plugins: ReturnType<VueLanguagePlugin>[], fileName: string, sfc: Sfc, codegenStack: boolean): () => VirtualCode[];