@vue/language-core 3.3.6 → 3.3.7

package/lib/codegen/style/index.js

@@ -22,7 +22,7 @@ function generate(options) {
 function* generateWorker(options, ctx) {
     const scope = ctx.scope();
     scope.declare(...options.setupConsts);
-    yield* (0, scopedClasses_1.generateStyleScopedClasses)(options);
+    yield* (0, scopedClasses_1.generateStyleScopedClasses)(options, ctx);
     yield* (0, modules_1.generateStyleModules)(options, ctx);
     yield* generateCssVars(options, ctx);
     yield* scope.end();

package/lib/codegen/style/modules.d.ts

@@ -1,4 +1,4 @@
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from '../template/context';
 import type { StyleCodegenOptions } from '.';
-export declare function generateStyleModules({ styles, vueCompilerOptions }: StyleCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;
+export declare function generateStyleModules({ vueCompilerOptions, styles }: StyleCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/style/modules.js

@@ -5,7 +5,7 @@ const codeFeatures_1 = require("../codeFeatures");
 const names_1 = require("../names");
 const utils_1 = require("../utils");
 const common_1 = require("./common");
-function* generateStyleModules({ styles, vueCompilerOptions }, ctx) {
+function* generateStyleModules({ vueCompilerOptions, styles }, ctx) {
     const styleModules = styles.filter(style => style.module);
     if (!styleModules.length) {
         return;

package/lib/codegen/style/scopedClasses.d.ts

@@ -1,3 +1,4 @@
 import type { Code } from '../../types';
+import type { TemplateCodegenContext } from '../template/context';
 import type { StyleCodegenOptions } from '.';
-export declare function generateStyleScopedClasses({ vueCompilerOptions, styles }: StyleCodegenOptions): Generator<Code>;
+export declare function generateStyleScopedClasses({ vueCompilerOptions, styles }: StyleCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/style/scopedClasses.js

@@ -5,7 +5,7 @@ const names_1 = require("../names");
 const styleScopedClasses_1 = require("../template/styleScopedClasses");
 const utils_1 = require("../utils");
 const common_1 = require("./common");
-function* generateStyleScopedClasses({ vueCompilerOptions, styles }) {
+function* generateStyleScopedClasses({ vueCompilerOptions, styles }, ctx) {
     const { resolveStyleClassNames, resolveStyleImports } = vueCompilerOptions;
     if (!resolveStyleClassNames) {
         return;
@@ -14,8 +14,9 @@ function* generateStyleScopedClasses({ vueCompilerOptions, styles }) {
     if (!scopedStyles.length) {
         return;
     }
+    ctx.generatedTypes.add(names_1.names.StyleScopedClasses);
     const visited = new Set();
-    const deferredGenerations = [];
+    const deferredGenerates = [];
     yield `type ${names_1.names.StyleScopedClasses} = {}`;
     for (const style of scopedStyles) {
         if (resolveStyleImports) {
@@ -27,12 +28,12 @@ function* generateStyleScopedClasses({ vueCompilerOptions, styles }) {
                 yield* (0, common_1.generateClassProperty)(style.name, className.text, className.offset, 'boolean');
             }
             else {
-                deferredGenerations.push((0, styleScopedClasses_1.generateStyleScopedClassReference)(style, className.text.slice(1), className.offset + 1));
+                deferredGenerates.push((0, styleScopedClasses_1.generateStyleScopedClassReference)(style, className.text.slice(1), className.offset + 1));
             }
         }
     }
     yield utils_1.endOfLine;
-    for (const generate of deferredGenerations) {
+    for (const generate of deferredGenerates) {
         yield* generate;
     }
 }

package/lib/codegen/template/element.js

@@ -229,7 +229,7 @@ function* generateComponent(options, ctx, node) {
             ctx.inheritedAttrVars.add(getPropsVar());
         }
     }
-    yield* generateStyleScopedClassReferences(options, node);
+    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(options, node);
     const slotDir = node.props.find(CompilerDOM.isVSlot);
     if (slotDir || node.children.length) {
         yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, getCtxVar());
@@ -275,7 +275,7 @@ function* generateElement(options, ctx, node) {
     if (hasVBindAttrs(options, ctx, node)) {
         ctx.inheritedAttrVars.add(`${names_1.names.intrinsics}.${node.tag}`);
     }
-    yield* generateStyleScopedClassReferences(options, node);
+    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(options, node);
     for (const child of node.children) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
     }
@@ -296,92 +296,6 @@ function* generateFragment(options, ctx, node) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
     }
 }
-function* generateStyleScopedClassReferences({ template, typescript: ts }, node) {
-    for (const prop of node.props) {
-        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
-            && prop.name === 'class'
-            && prop.value) {
-            const [text, start] = (0, shared_2.normalizeAttributeValue)(prop.value);
-            for (const [className, offset] of forEachClassName(text)) {
-                yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, className, start + offset);
-            }
-        }
-        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-            && prop.arg.content === 'class') {
-            const content = '(' + prop.exp.content + ')';
-            const startOffset = prop.exp.loc.start.offset - 1;
-            const ast = (0, utils_1.getTypeScriptAST)(ts, template, content);
-            const literals = [];
-            for (const node of (0, utils_1.forEachNode)(ts, ast)) {
-                if (!ts.isExpressionStatement(node)
-                    || !ts.isParenthesizedExpression(node.expression)) {
-                    continue;
-                }
-                const { expression } = node.expression;
-                if (ts.isStringLiteralLike(expression)) {
-                    literals.push(expression);
-                }
-                else if (ts.isArrayLiteralExpression(expression)) {
-                    yield* walkArrayLiteral(expression);
-                }
-                else if (ts.isObjectLiteralExpression(expression)) {
-                    yield* walkObjectLiteral(expression);
-                }
-            }
-            for (const literal of literals) {
-                const start = literal.end - literal.text.length - 1 + startOffset;
-                for (const [className, offset] of forEachClassName(literal.text)) {
-                    yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, className, start + offset);
-                }
-            }
-            function* walkArrayLiteral(node) {
-                const { elements } = node;
-                for (const element of elements) {
-                    if (ts.isStringLiteralLike(element)) {
-                        literals.push(element);
-                    }
-                    else if (ts.isObjectLiteralExpression(element)) {
-                        yield* walkObjectLiteral(element);
-                    }
-                }
-            }
-            function* walkObjectLiteral(node) {
-                const { properties } = node;
-                for (const property of properties) {
-                    if (ts.isPropertyAssignment(property)) {
-                        const { name } = property;
-                        if (ts.isIdentifier(name)) {
-                            const text = (0, shared_2.getNodeText)(ts, name, ast);
-                            yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, text, name.end - text.length + startOffset);
-                        }
-                        else if (ts.isStringLiteral(name)) {
-                            literals.push(name);
-                        }
-                        else if (ts.isComputedPropertyName(name)) {
-                            const { expression } = name;
-                            if (ts.isStringLiteralLike(expression)) {
-                                literals.push(expression);
-                            }
-                        }
-                    }
-                    else if (ts.isShorthandPropertyAssignment(property)) {
-                        const text = (0, shared_2.getNodeText)(ts, property.name, ast);
-                        yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, text, property.name.end - text.length + startOffset);
-                    }
-                }
-            }
-        }
-    }
-}
-function* forEachClassName(content) {
-    let offset = 0;
-    for (const className of content.split(' ')) {
-        yield [className, offset];
-        offset += className.length + 1;
-    }
-}
 function* generateFailedExpressions(options, ctx, failedPropExps) {
     for (const { node, prefix, suffix } of failedPropExps) {
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, node.loc.source, node.loc.start.offset, prefix, suffix);

package/lib/codegen/template/elementEvents.js

@@ -154,9 +154,13 @@ function* generateEventExpression(options, ctx, prop) {
             scope.declare('$event');
             yield* ctx.generateConditionGuards();
             if (isSingleExpression(options.typescript, ast)) {
-                yield `return `;
+                yield `return (`;
+                yield* interpolation;
+                yield `)`;
+            }
+            else {
+                yield* interpolation;
             }
-            yield* interpolation;
             yield utils_2.endOfLine;
             yield* scope.end();
             yield `}`;

package/lib/codegen/template/styleScopedClasses.d.ts

@@ -1,3 +1,6 @@
+import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code, IRBlock } from '../../types';
+import type { TemplateCodegenOptions } from './index';
 export declare const references: WeakMap<IRBlock, [version: string, [className: string, offset: number][]]>;
+export declare function generateStyleScopedClassReferences({ template, typescript: ts }: TemplateCodegenOptions, node: CompilerDOM.ElementNode): Generator<Code>;
 export declare function generateStyleScopedClassReference(block: IRBlock, className: string, offset: number, fullStart?: number): Generator<Code>;

package/lib/codegen/template/styleScopedClasses.js

@@ -1,7 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.references = void 0;
+exports.generateStyleScopedClassReferences = generateStyleScopedClassReferences;
 exports.generateStyleScopedClassReference = generateStyleScopedClassReference;
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+const shared_1 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const names_1 = require("../names");
 const utils_1 = require("../utils");
@@ -10,6 +46,92 @@ const escaped_1 = require("../utils/escaped");
 const classNameEscapeRE = /([\\'])/;
 // For language-service/lib/plugins/vue-scoped-class-links.ts usage
 exports.references = new WeakMap();
+function* generateStyleScopedClassReferences({ template, typescript: ts }, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'class'
+            && prop.value) {
+            const [text, start] = (0, shared_1.normalizeAttributeValue)(prop.value);
+            for (const [className, offset] of forEachClassName(text)) {
+                yield* generateStyleScopedClassReference(template, className, start + offset);
+            }
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.arg.content === 'class') {
+            const content = '(' + prop.exp.content + ')';
+            const startOffset = prop.exp.loc.start.offset - 1;
+            const ast = (0, utils_1.getTypeScriptAST)(ts, template, content);
+            const literals = [];
+            for (const node of (0, utils_1.forEachNode)(ts, ast)) {
+                if (!ts.isExpressionStatement(node)
+                    || !ts.isParenthesizedExpression(node.expression)) {
+                    continue;
+                }
+                const { expression } = node.expression;
+                if (ts.isStringLiteralLike(expression)) {
+                    literals.push(expression);
+                }
+                else if (ts.isArrayLiteralExpression(expression)) {
+                    yield* walkArrayLiteral(expression);
+                }
+                else if (ts.isObjectLiteralExpression(expression)) {
+                    yield* walkObjectLiteral(expression);
+                }
+            }
+            for (const literal of literals) {
+                const start = literal.end - literal.text.length - 1 + startOffset;
+                for (const [className, offset] of forEachClassName(literal.text)) {
+                    yield* generateStyleScopedClassReference(template, className, start + offset);
+                }
+            }
+            function* walkArrayLiteral(node) {
+                const { elements } = node;
+                for (const element of elements) {
+                    if (ts.isStringLiteralLike(element)) {
+                        literals.push(element);
+                    }
+                    else if (ts.isObjectLiteralExpression(element)) {
+                        yield* walkObjectLiteral(element);
+                    }
+                }
+            }
+            function* walkObjectLiteral(node) {
+                const { properties } = node;
+                for (const property of properties) {
+                    if (ts.isPropertyAssignment(property)) {
+                        const { name } = property;
+                        if (ts.isIdentifier(name)) {
+                            const text = (0, shared_1.getNodeText)(ts, name, ast);
+                            yield* generateStyleScopedClassReference(template, text, name.end - text.length + startOffset);
+                        }
+                        else if (ts.isStringLiteral(name)) {
+                            literals.push(name);
+                        }
+                        else if (ts.isComputedPropertyName(name)) {
+                            const { expression } = name;
+                            if (ts.isStringLiteralLike(expression)) {
+                                literals.push(expression);
+                            }
+                        }
+                    }
+                    else if (ts.isShorthandPropertyAssignment(property)) {
+                        const text = (0, shared_1.getNodeText)(ts, property.name, ast);
+                        yield* generateStyleScopedClassReference(template, text, property.name.end - text.length + startOffset);
+                    }
+                }
+            }
+        }
+    }
+}
+function* forEachClassName(content) {
+    let offset = 0;
+    for (const className of content.split(' ')) {
+        yield [className, offset];
+        offset += className.length + 1;
+    }
+}
 function* generateStyleScopedClassReference(block, className, offset, fullStart = offset) {
     if (!className) {
         yield `/** @type {${names_1.names.StyleScopedClasses}['`;

package/lib/types.d.ts

@@ -71,7 +71,7 @@ export interface VueCompilerOptions {
 }
 export declare const validVersions: readonly [2, 2.1, 2.2];
 export interface VueLanguagePluginReturn {
-    version: (typeof validVersions)[number];
+    version: typeof validVersions[number];
     name?: string;
     order?: number;
     requiredCompilerOptions?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.3.6",
+	"version": "3.3.7",
 	"license": "MIT",
 	"files": [
 		"index.d.ts",
@@ -22,17 +22,17 @@
 		"@volar/language-core": "2.4.28",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/shared": "^3.5.0",
-		"alien-signals": "^3.2.0",
+		"alien-signals": "^3.2.1",
 		"muggle-string": "^0.4.1",
 		"path-browserify": "^1.0.1",
 		"picomatch": "^4.0.4"
 	},
 	"devDependencies": {
-		"@types/node": "^24.1.0",
+		"@types/node": "^26.0.1",
 		"@types/path-browserify": "^1.0.3",
 		"@types/picomatch": "^4.0.3",
 		"@volar/typescript": "2.4.28",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
-	"gitHead": "4893ec6a4b5ca0d00f8add9aa36c17c47085f05a"
+	"gitHead": "f6cc297eb9b2fddb3bed535b099b9697c909764d"
 }