@vue/language-core 3.1.3 → 3.1.5

package/lib/languagePlugin.js

@@ -7,32 +7,21 @@ const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const plugins_1 = require("./plugins");
 const vueFile_1 = require("./virtualFile/vueFile");
-const fileRegistries = [];
-function getVueFileRegistry(key, plugins) {
-    let fileRegistry = fileRegistries.find(r => r.key === key
-        && r.plugins.length === plugins.length
-        && r.plugins.every(plugin => plugins.includes(plugin)))?.files;
-    if (!fileRegistry) {
-        fileRegistry = new Map();
-        fileRegistries.push({
-            key: key,
-            plugins: plugins,
-            files: fileRegistry,
-        });
-    }
-    return fileRegistry;
-}
-function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
-    const values = [
+const fileRegistries = {};
+function getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins) {
+    const key = JSON.stringify([
+        ...plugins.map(plugin => plugin.name)
+            .filter(name => typeof name === 'string')
+            .sort(),
         ...Object.keys(vueCompilerOptions)
-            .sort()
             .filter(key => key !== 'plugins')
+            .sort()
             .map(key => [key, vueCompilerOptions[key]]),
-        [...new Set(plugins.map(plugin => plugin.requiredCompilerOptions ?? []).flat())]
+        ...[...new Set(plugins.flatMap(plugin => plugin.requiredCompilerOptions ?? []))]
             .sort()
             .map(key => [key, compilerOptions[key]]),
-    ];
-    return JSON.stringify(values);
+    ]);
+    return fileRegistries[key] ??= new Map();
 }
 function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFileName) {
     const pluginContext = {
@@ -44,7 +33,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
         vueCompilerOptions,
     };
     const plugins = (0, plugins_1.createPlugins)(pluginContext);
-    const fileRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
+    const fileRegistry = getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins);
     return {
         getLanguageId(scriptId) {
             const fileName = asFileName(scriptId);
@@ -70,10 +59,14 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
                 }
             }
         },
-        updateVirtualCode(_fileId, code, snapshot) {
+        updateVirtualCode(_scriptId, code, snapshot) {
             code.update(snapshot);
             return code;
         },
+        disposeVirtualCode(scriptId) {
+            const fileName = asFileName(scriptId);
+            fileRegistry.delete(fileName);
+        },
         typescript: {
             extraFileExtensions: getAllExtensions(vueCompilerOptions)
                 .map(ext => ({

package/lib/plugins/vue-template-html.js

@@ -2,38 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const shouldAddSuffix = /(?<=<[^>/]+)$/;
 const plugin = ({ modules }) => {
+    const CompilerDOM = modules['@vue/compiler-dom'];
     return {
         version: 2.2,
         compileSFCTemplate(lang, template, options) {
             if (lang === 'html' || lang === 'md') {
-                const compiler = modules['@vue/compiler-dom'];
                 let addedSuffix = false;
                 // #4583
                 if (shouldAddSuffix.test(template)) {
                     template += '>';
                     addedSuffix = true;
                 }
-                const result = compiler.compile(template, {
+                const ast = CompilerDOM.parse(template, {
                     ...options,
                     comments: true,
                 });
-                // @ts-expect-error
-                result.__addedSuffix = addedSuffix;
-                return result;
+                CompilerDOM.transform(ast, options);
+                return {
+                    ast,
+                    code: '',
+                    preamble: '',
+                    __addedSuffix: addedSuffix,
+                };
             }
         },
         updateSFCTemplate(oldResult, change) {
-            oldResult.code = oldResult.code.slice(0, change.start)
+            const newSource = oldResult.ast.source.slice(0, change.start)
                 + change.newText
-                + oldResult.code.slice(change.end);
+                + oldResult.ast.source.slice(change.end);
             // @ts-expect-error
             if (oldResult.__addedSuffix) {
-                const originalTemplate = oldResult.code.slice(0, -1); // remove added '>'
+                const originalTemplate = newSource.slice(0, -1); // remove added '>'
                 if (!shouldAddSuffix.test(originalTemplate)) {
                     return undefined;
                 }
             }
-            const CompilerDOM = modules['@vue/compiler-dom'];
             const lengthDiff = change.newText.length - (change.end - change.start);
             let hitNodes = [];
             if (tryUpdateNode(oldResult.ast) && hitNodes.length) {

package/lib/plugins/vue-template-inline-css.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const CompilerDOM = require("@vue/compiler-dom");
-const template_1 = require("../codegen/template");
-const shared_1 = require("./shared");
+const forEachTemplateNode_1 = require("../utils/forEachTemplateNode");
+const shared_1 = require("../utils/shared");
+const shared_2 = require("./shared");
 const codeFeatures = {
-    ...shared_1.allCodeFeatures,
+    ...shared_2.allCodeFeatures,
     format: false,
     structure: false,
 };
@@ -28,23 +29,16 @@ const plugin = () => {
 };
 exports.default = plugin;
 function* generate(templateAst) {
-    for (const node of (0, template_1.forEachElementNode)(templateAst)) {
+    for (const node of (0, forEachTemplateNode_1.forEachElementNode)(templateAst)) {
         for (const prop of node.props) {
-            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-                && prop.name === 'bind'
-                && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.arg.content === 'style'
-                && prop.exp.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
-                const endCrt = prop.arg.loc.source[prop.arg.loc.source.length - 1]; // " | '
-                const start = prop.arg.loc.source.indexOf(endCrt) + 1;
-                const end = prop.arg.loc.source.lastIndexOf(endCrt);
-                const content = prop.arg.loc.source.slice(start, end);
+            if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+                && prop.name === 'style'
+                && prop.value) {
                 yield `x { `;
                 yield [
-                    content,
+                    prop.value.content,
                     'template',
-                    prop.arg.loc.start.offset + start,
+                    (0, shared_1.getAttributeValueOffset)(prop.value),
                     codeFeatures,
                 ];
                 yield ` }\n`;

package/lib/plugins/vue-tsx.d.ts

@@ -180,10 +180,10 @@ export declare const tsCodegen: WeakMap<Sfc, {
             offset: number;
         }[]>;
         currentComponent: {
-            ctxVar: string;
-            used: boolean;
+            get ctxVar(): string;
+            get propsVar(): string;
         } | undefined;
-        singleRootElTypes: string[];
+        singleRootElTypes: Set<string>;
         singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
         addTemplateRef(name: string, typeExp: string, offset: number): void;
         accessExternalVariable(name: string, offset?: number): void;

package/lib/plugins/vue-tsx.js

@@ -18,7 +18,6 @@ const plugin = ctx => {
         version: 2.2,
         requiredCompilerOptions: [
             'noPropertyAccessFromIndexSignature',
-            'exactOptionalPropertyTypes',
         ],
         getEmbeddedCodes(fileName, sfc) {
             const codegen = useCodegen(fileName, sfc);

package/lib/utils/forEachTemplateNode.d.ts

@@ -0,0 +1,3 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;
+export declare function forEachInterpolationNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): Generator<CompilerDOM.InterpolationNode>;

package/lib/utils/forEachTemplateNode.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachElementNode = forEachElementNode;
+exports.forEachInterpolationNode = forEachInterpolationNode;
+const CompilerDOM = require("@vue/compiler-dom");
+function* forEachElementNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        yield node;
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        for (const branch of node.branches) {
+            for (const childNode of branch.children) {
+                yield* forEachElementNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+}
+function* forEachInterpolationNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
+        yield* forEachInterpolationNode(node.content);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
+        for (const child of node.children) {
+            if (typeof child === 'object') {
+                yield* forEachInterpolationNode(child);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
+        yield node;
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        for (const branch of node.branches) {
+            for (const childNode of branch.children) {
+                yield* forEachInterpolationNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+}
+//# sourceMappingURL=forEachTemplateNode.js.map

package/lib/utils/parseSfc.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = parse;
 const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("./shared");
 function parse(source) {
     const errors = [];
     const ast = CompilerDOM.parse(source, {
@@ -137,17 +138,11 @@ function parseAttr(p, node) {
     if (!p.value) {
         return true;
     }
-    const text = p.value.content;
-    const source = p.value.loc.source;
-    let offset = p.value.loc.start.offset - node.loc.start.offset;
-    const quotes = source.startsWith('"') || source.startsWith("'");
-    if (quotes) {
-        offset++;
-    }
+    const offset = (0, shared_1.getAttributeValueOffset)(p.value);
     return {
-        text,
-        offset,
-        quotes,
+        text: p.value.content,
+        offset: offset - node.loc.start.offset,
+        quotes: offset > p.value.loc.start.offset,
     };
 }
 //# sourceMappingURL=parseSfc.js.map

package/lib/utils/shared.d.ts

@@ -3,6 +3,7 @@ import type * as ts from 'typescript';
 import type { Sfc, TextRange } from '../types';
 export { hyphenate as hyphenateTag } from '@vue/shared';
 export declare function hyphenateAttr(str: string): string;
+export declare function getAttributeValueOffset(node: CompilerDOM.TextNode): number;
 export declare function getElementTagOffsets(node: CompilerDOM.ElementNode, template: NonNullable<Sfc['template']>): [number] | [number, number];
 export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): TextRange;
 export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;

package/lib/utils/shared.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hyphenateTag = void 0;
 exports.hyphenateAttr = hyphenateAttr;
+exports.getAttributeValueOffset = getAttributeValueOffset;
 exports.getElementTagOffsets = getElementTagOffsets;
 exports.getStartEnd = getStartEnd;
 exports.getNodeText = getNodeText;
@@ -16,6 +17,13 @@ function hyphenateAttr(str) {
     }
     return hyphencase;
 }
+function getAttributeValueOffset(node) {
+    let offset = node.loc.start.offset;
+    if (node.loc.source.startsWith('"') || node.loc.source.startsWith("'")) {
+        offset++;
+    }
+    return offset;
+}
 function getElementTagOffsets(node, template) {
     const tagOffsets = [
         template.content.indexOf(node.tag, node.loc.start.offset),

package/lib/virtualFile/computedSfc.d.ts

@@ -1,4 +1,4 @@
-import type * as CompilerDOM from '@vue/compiler-dom';
+import * as CompilerDOM from '@vue/compiler-dom';
 import type { SFCParseResult } from '@vue/compiler-sfc';
 import type * as ts from 'typescript';
 import type { Sfc, VueLanguagePluginReturn } from '../types';

package/lib/virtualFile/computedSfc.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.templateInlineTsAsts = void 0;
 exports.computedSfc = computedSfc;
+const CompilerDOM = require("@vue/compiler-dom");
 const alien_signals_1 = require("alien-signals");
 const signals_1 = require("../utils/signals");
 exports.templateInlineTsAsts = new WeakMap();
@@ -225,10 +226,13 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             }
             const errors = [];
             const warnings = [];
+            const [nodeTransforms, directiveTransforms] = CompilerDOM.getBaseTransformPreset();
             let options = {
-                onError: (err) => errors.push(err),
-                onWarn: (err) => warnings.push(err),
+                onError: err => errors.push(err),
+                onWarn: err => warnings.push(err),
                 expressionPlugins: ['typescript'],
+                nodeTransforms,
+                directiveTransforms,
             };
             for (const plugin of plugins) {
                 if (plugin.resolveTemplateCompilerOptions) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.1.3",
+	"version": "3.1.5",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -36,5 +36,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "0d7edee43568f1d90adae6e8fcda0f7f565b3f6a"
+	"gitHead": "d124a88fbf169e793c39ae4248da2092098de92d"
 }