@vue/language-core 2.0.0 → 2.0.2

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/lib/utils/transform.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectVars = exports.eachInterpolationSegment = void 0;
+const shared_1 = require("@vue/shared");
+const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+function* eachInterpolationSegment(ts, code, ast, localVars, identifiers, vueOptions, ctxVars = []) {
+    const varCb = (id, isShorthand) => {
+        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)(text) ||
+            text === 'require' ||
+            text.startsWith('__VLS_')) {
+            // localVarOffsets.push(localVar.getStart(ast));
+        }
+        else {
+            ctxVars.push({
+                text,
+                isShorthand: isShorthand,
+                offset: (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start,
+            });
+            identifiers.add(text);
+        }
+    };
+    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) {
+            yield [code.substring(0, ctxVars[0].offset + ctxVars[0].text.length), 0];
+            yield [': ', undefined];
+        }
+        else {
+            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
+            yield ['', ctxVars[i + 1].offset, true];
+            if (vueOptions.experimentalUseElementAccessInTemplate) {
+                const varStart = ctxVars[i].offset;
+                const varEnd = ctxVars[i].offset + ctxVars[i].text.length;
+                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) {
+                    yield [code.substring(varEnd, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), varEnd];
+                    yield [': ', undefined];
+                }
+                else {
+                    yield [code.substring(varEnd, ctxVars[i + 1].offset), varEnd];
+                }
+            }
+            else {
+                yield ['__VLS_ctx.', undefined];
+                if (ctxVars[i + 1].isShorthand) {
+                    yield [code.substring(ctxVars[i].offset, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), ctxVars[i].offset];
+                    yield [': ', undefined];
+                }
+                else {
+                    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;
+            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 {
+            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 {
+        yield [code, 0];
+    }
+}
+exports.eachInterpolationSegment = eachInterpolationSegment;
+function walkIdentifiers(ts, node, ast, cb, localVars, blockVars = [], isRoot = true) {
+    if (ts.isIdentifier(node)) {
+        cb(node, false);
+    }
+    else if (ts.isShorthandPropertyAssignment(node)) {
+        cb(node.name, true);
+    }
+    else if (ts.isPropertyAccessExpression(node)) {
+        walkIdentifiers(ts, node.expression, ast, cb, localVars, blockVars, false);
+    }
+    else if (ts.isVariableDeclaration(node)) {
+        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, 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, ast, functionArgs);
+            if (param.type) {
+                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, ast, cb, localVars, blockVars, false);
+        for (const varName of functionArgs)
+            localVars.set(varName, localVars.get(varName) - 1);
+    }
+    else if (ts.isObjectLiteralExpression(node)) {
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop)) {
+                // fix https://github.com/vuejs/language-tools/issues/1176
+                if (ts.isComputedPropertyName(prop.name)) {
+                    walkIdentifiers(ts, prop.name.expression, ast, 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, 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, ast, cb, localVars, blockVars, false);
+            }
+        }
+    }
+    else if (ts.isTypeReferenceNode(node)) {
+        // fix https://github.com/vuejs/language-tools/issues/1422
+        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
+    }
+    else {
+        const _blockVars = blockVars;
+        if (ts.isBlock(node)) {
+            blockVars = [];
+        }
+        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);
+            }
+        }
+        blockVars = _blockVars;
+    }
+    if (isRoot) {
+        for (const varName of blockVars) {
+            localVars.set(varName, localVars.get(varName) - 1);
+        }
+    }
+}
+function walkIdentifiersInTypeReference(ts, node, cb) {
+    if (ts.isTypeQueryNode(node) && ts.isIdentifier(node.exprName)) {
+        cb(node.exprName, false);
+    }
+    else {
+        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
+    }
+}
+function collectVars(ts, node, ast, result) {
+    if (ts.isIdentifier(node)) {
+        result.push((0, scriptSetupRanges_1.getNodeText)(ts, node, ast));
+    }
+    else if (ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            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, ast, result);
+            }
+        }
+    }
+    else {
+        ts.forEachChild(node, node => collectVars(ts, node, ast, result));
+    }
+}
+exports.collectVars = collectVars;
+//# sourceMappingURL=transform.js.map

package/lib/utils/ts.d.ts

@@ -0,0 +1,8 @@
+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'), 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;

package/lib/utils/ts.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVueCompilerOptions = exports.createParsedCommandLine = exports.createParsedCommandLineByJson = void 0;
+const path = require("path-browserify");
+function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json') {
+    const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
+    ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
+    let vueOptions = {};
+    for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
+        try {
+            vueOptions = {
+                ...vueOptions,
+                ...getPartialVueCompilerOptions(ts, ts.readJsonConfigFile(extendPath, proxyHost.host.readFile)),
+            };
+        }
+        catch (err) { }
+    }
+    const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, (vueOptions.extensions ?? ['.vue']).map(extension => ({
+        extension: extension.slice(1),
+        isMixedContent: true,
+        scriptKind: ts.ScriptKind.Deferred,
+    })));
+    // fix https://github.com/vuejs/language-tools/issues/1786
+    // https://github.com/microsoft/TypeScript/issues/30457
+    // patching ts server broke with outDir + rootDir + composite/incremental
+    parsed.options.outDir = undefined;
+    return {
+        ...parsed,
+        vueOptions,
+    };
+}
+exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
+function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
+    try {
+        const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
+        const config = ts.readJsonConfigFile(tsConfigPath, proxyHost.host.readFile);
+        ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath);
+        let vueOptions = {};
+        for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
+            try {
+                vueOptions = {
+                    ...vueOptions,
+                    ...getPartialVueCompilerOptions(ts, ts.readJsonConfigFile(extendPath, proxyHost.host.readFile)),
+                };
+            }
+            catch (err) { }
+        }
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, (vueOptions.extensions ?? ['.vue']).map(extension => ({
+            extension: extension.slice(1),
+            isMixedContent: true,
+            scriptKind: ts.ScriptKind.Deferred,
+        })));
+        // fix https://github.com/vuejs/language-tools/issues/1786
+        // https://github.com/microsoft/TypeScript/issues/30457
+        // patching ts server broke with outDir + rootDir + composite/incremental
+        parsed.options.outDir = undefined;
+        return {
+            ...parsed,
+            vueOptions,
+        };
+    }
+    catch (err) {
+        // console.warn('Failed to resolve tsconfig path:', tsConfigPath, err);
+        return {
+            fileNames: [],
+            options: {},
+            vueOptions: resolveVueCompilerOptions({}),
+            errors: [],
+        };
+    }
+}
+exports.createParsedCommandLine = createParsedCommandLine;
+function proxyParseConfigHostForExtendConfigPaths(parseConfigHost) {
+    const extendConfigPaths = [];
+    const host = new Proxy(parseConfigHost, {
+        get(target, key) {
+            if (key === 'readFile') {
+                return (fileName) => {
+                    if (!fileName.endsWith('/package.json') && !extendConfigPaths.includes(fileName)) {
+                        extendConfigPaths.push(fileName);
+                    }
+                    return target.readFile(fileName);
+                };
+            }
+            return target[key];
+        }
+    });
+    return {
+        host,
+        extendConfigPaths,
+    };
+}
+function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
+    const folder = path.dirname(tsConfigSourceFile.fileName);
+    const obj = ts.convertToObject(tsConfigSourceFile, []);
+    const rawOptions = obj?.vueCompilerOptions ?? {};
+    const result = {
+        ...rawOptions,
+    };
+    const target = rawOptions.target ?? 'auto';
+    if (target === 'auto') {
+        const resolvedPath = resolvePath('vue/package.json');
+        if (resolvedPath) {
+            const vuePackageJson = require(resolvedPath);
+            const versionNumbers = vuePackageJson.version.split('.');
+            result.target = Number(versionNumbers[0] + '.' + versionNumbers[1]);
+        }
+        else {
+            // console.warn('Load vue/package.json failed from', folder);
+        }
+    }
+    else {
+        result.target = target;
+    }
+    if (rawOptions.plugins) {
+        const plugins = rawOptions.plugins
+            .map((pluginPath) => {
+            try {
+                const resolvedPath = resolvePath(pluginPath);
+                if (resolvedPath) {
+                    return require(resolvedPath);
+                }
+                else {
+                    console.warn('Load plugin failed:', pluginPath);
+                }
+            }
+            catch (error) {
+                console.warn('Load plugin failed:', pluginPath, error);
+            }
+            return [];
+        })
+            .flat(Infinity);
+        result.plugins = plugins;
+    }
+    return result;
+    function resolvePath(scriptPath) {
+        try {
+            if (require?.resolve) {
+                return require.resolve(scriptPath, { paths: [folder] });
+            }
+            else {
+                // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
+            }
+        }
+        catch (error) {
+            // console.warn(error);
+        }
+    }
+}
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element
+const HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +
+    'header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,' +
+    'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +
+    'data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,' +
+    'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +
+    'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +
+    'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +
+    'option,output,progress,select,textarea,details,dialog,menu,' +
+    'summary,template,blockquote,iframe,tfoot';
+// https://developer.mozilla.org/en-US/docs/Web/SVG/Element
+const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +
+    'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +
+    'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +
+    'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +
+    'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +
+    'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +
+    'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +
+    'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +
+    'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +
+    'text,textPath,title,tspan,unknown,use,view';
+function resolveVueCompilerOptions(vueOptions) {
+    const target = vueOptions.target ?? 3.3;
+    const lib = vueOptions.lib || (target < 2.7 ? '@vue/runtime-dom' : 'vue');
+    return {
+        ...vueOptions,
+        target,
+        extensions: vueOptions.extensions ?? ['.vue'],
+        lib,
+        jsxSlots: vueOptions.jsxSlots ?? false,
+        strictTemplates: vueOptions.strictTemplates ?? false,
+        skipTemplateCodegen: vueOptions.skipTemplateCodegen ?? false,
+        nativeTags: vueOptions.nativeTags ?? [...new Set([
+                ...HTML_TAGS.split(','),
+                ...SVG_TAGS.split(','),
+                // fix https://github.com/johnsoncodehk/volar/issues/1340
+                'hgroup',
+                'slot',
+                'component',
+            ])],
+        dataAttributes: vueOptions.dataAttributes ?? [],
+        htmlAttributes: vueOptions.htmlAttributes ?? ['aria-*'],
+        optionsWrapper: vueOptions.optionsWrapper ?? (target >= 2.7
+            ? [`(await import('${lib}')).defineComponent(`, `)`]
+            : [`(await import('vue')).default.extend(`, `)`]),
+        macros: {
+            defineProps: ['defineProps'],
+            defineSlots: ['defineSlots'],
+            defineEmits: ['defineEmits'],
+            defineExpose: ['defineExpose'],
+            defineModel: ['defineModel'],
+            defineOptions: ['defineOptions'],
+            withDefaults: ['withDefaults'],
+            ...vueOptions.macros,
+        },
+        plugins: vueOptions.plugins ?? [],
+        // experimental
+        experimentalDefinePropProposal: vueOptions.experimentalDefinePropProposal ?? false,
+        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
+        experimentalModelPropName: vueOptions.experimentalModelPropName ?? {
+            '': {
+                input: true
+            },
+            value: {
+                input: { type: 'text' },
+                textarea: true,
+                select: true
+            }
+        },
+        experimentalUseElementAccessInTemplate: vueOptions.experimentalUseElementAccessInTemplate ?? false,
+    };
+}
+exports.resolveVueCompilerOptions = resolveVueCompilerOptions;
+//# sourceMappingURL=ts.js.map

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/lib/utils/vue2TemplateCompiler.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+const Vue2TemplateCompiler = require('vue-template-compiler/build');
+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) => {
+        if (error.code === 33 // :key binding allowed in v-for template child in vue 2
+            || error.code === 29 // fix https://github.com/vuejs/language-tools/issues/1638
+        ) {
+            return;
+        }
+        if (onError) {
+            onError(error);
+        }
+        else {
+            throw error;
+        }
+    };
+    const vue2Result = Vue2TemplateCompiler.compile(template, { outputSourceRange: true });
+    for (const error of vue2Result.errors) {
+        onError?.({
+            code: 'vue-template-compiler',
+            name: '',
+            message: error.msg,
+            loc: {
+                source: '',
+                start: { column: -1, line: -1, offset: error.start },
+                end: { column: -1, line: -1, offset: error.end ?? error.start },
+            },
+        });
+    }
+    for (const error of vue2Result.tips) {
+        onWarn?.({
+            code: 'vue-template-compiler',
+            name: '',
+            message: error.msg,
+            loc: {
+                source: '',
+                start: { column: -1, line: -1, offset: error.start },
+                end: { column: -1, line: -1, offset: error.end ?? error.start },
+            },
+        });
+    }
+    return baseCompile(template, Object.assign({}, CompilerDOM.parserOptions, options, {
+        nodeTransforms: [
+            ...CompilerDOM.DOMNodeTransforms,
+            ...(options.nodeTransforms || [])
+        ],
+        directiveTransforms: Object.assign({}, CompilerDOM.DOMDirectiveTransforms, options.directiveTransforms || {}),
+    }));
+};
+exports.compile = compile;
+function baseCompile(template, options = {}) {
+    const onError = options.onError || ((error) => { throw error; });
+    const isModuleMode = options.mode === 'module';
+    const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
+    if (!prefixIdentifiers && options.cacheHandlers) {
+        onError(CompilerDOM.createCompilerError(49));
+    }
+    if (options.scopeId && !isModuleMode) {
+        onError(CompilerDOM.createCompilerError(50));
+    }
+    const ast = CompilerDOM.baseParse(template, options);
+    const [nodeTransforms, directiveTransforms] = CompilerDOM.getBaseTransformPreset(prefixIdentifiers);
+    // v-for > v-if in vue 2
+    const transformIf = nodeTransforms[1];
+    const transformFor = nodeTransforms[3];
+    nodeTransforms[1] = transformFor;
+    nodeTransforms[3] = transformIf;
+    CompilerDOM.transform(ast, Object.assign({}, options, {
+        prefixIdentifiers,
+        nodeTransforms: [
+            ...nodeTransforms,
+            ...(options.nodeTransforms || []) // user transforms
+        ],
+        directiveTransforms: Object.assign({}, directiveTransforms, options.directiveTransforms || {} // user transforms
+        )
+    }));
+    return CompilerDOM.generate(ast, Object.assign({}, options, {
+        prefixIdentifiers
+    }));
+}
+//# sourceMappingURL=vue2TemplateCompiler.js.map

package/lib/virtualFile/computedFiles.d.ts

@@ -0,0 +1,3 @@
+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): () => VirtualCode[];