@vue/language-core 3.2.1 → 3.2.3

package/lib/codegen/script/scriptSetup.js

@@ -387,7 +387,8 @@ function* generateModels(scriptSetup, scriptSetupRanges) {
         yield* codes;
     }
     yield `}${utils_1.endOfLine}`;
-    yield `const ${names.modelEmit} = defineEmits<${names.ModelEmit}>()${utils_1.endOfLine}`;
+    // avoid `defineModel<...>()` to prevent JS AST issues
+    yield `let ${names.modelEmit}!: __VLS_ShortEmits<${names.ModelEmit}>${utils_1.endOfLine}`;
 }
 function* generateModelProp(scriptSetup, defineModel, propName, modelType) {
     if (defineModel.comments) {

package/lib/codegen/template/element.js

@@ -58,6 +58,7 @@ function* generateComponent(options, ctx, node) {
     let { tag, props } = node;
     let [startTagOffset, endTagOffset] = (0, shared_2.getElementTagOffsets)(node, options.template);
     let isExpression = false;
+    let isIsShorthand = false;
     if (tag.includes('.')) {
         isExpression = true;
     }
@@ -67,7 +68,8 @@ function* generateComponent(options, ctx, node) {
                 && prop.name === 'bind'
                 && prop.arg?.loc.source === 'is'
                 && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                if (prop.arg.loc.end.offset === prop.exp.loc.end.offset) {
+                isIsShorthand = prop.arg.loc.end.offset === prop.exp.loc.end.offset;
+                if (isIsShorthand) {
                     ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(prop.exp.loc, 'is'));
                 }
                 isExpression = true;
@@ -82,7 +84,9 @@ function* generateComponent(options, ctx, node) {
     const componentVar = ctx.getInternalVariable();
     if (isExpression) {
         yield `const ${componentVar} = `;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, tag, startTagOffset, `(`, `)`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, isIsShorthand
+            ? codeFeatures_1.codeFeatures.withoutHighlightAndCompletion
+            : codeFeatures_1.codeFeatures.all, tag, startTagOffset, `(`, `)`);
         if (endTagOffset !== undefined) {
             yield ` || `;
             yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.withoutCompletion, tag, endTagOffset, `(`, `)`);
@@ -164,7 +168,7 @@ function* generateComponentBody(options, ctx, node, tag, tagOffset, props, compo
     const propsVar = ctx.getInternalVariable();
     yield `// @ts-ignore${utils_1.newLine}`;
     yield `const ${functionalVar} = ${options.vueCompilerOptions.checkUnknownProps ? '__VLS_asFunctionalComponent0' : '__VLS_asFunctionalComponent1'}(${componentVar}, new ${componentVar}({${utils_1.newLine}`;
-    yield* (0, muggle_string_1.toString)(propCodes);
+    yield (0, muggle_string_1.toString)(propCodes);
     yield `}))${utils_1.endOfLine}`;
     yield `const `;
     const token = yield* (0, boundary_1.startBoundary)('template', node.loc.start.offset, codeFeatures_1.codeFeatures.doNotReportTs6133);
@@ -266,18 +270,9 @@ function* generateStyleScopedClassReferences({ template, typescript: ts }, node)
         if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
             && prop.name === 'class'
             && prop.value) {
-            if (template.lang === 'pug') {
-                const getClassOffset = Reflect.get(prop.value.loc.start, 'getClassOffset');
-                const content = prop.value.loc.source.slice(1, -1);
-                for (const [className, pos] of forEachClassName(content)) {
-                    yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, className, getClassOffset(pos + 1));
-                }
-            }
-            else {
-                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);
-                }
+            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

package/lib/codegen/template/elementDirectives.js

@@ -46,14 +46,6 @@ const stringLiteralKey_1 = require("../utils/stringLiteralKey");
 const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
 const objectProperty_1 = require("./objectProperty");
-const builtInDirectives = new Set([
-    'cloak',
-    'html',
-    'memo',
-    'once',
-    'show',
-    'text',
-]);
 function* generateElementDirectives(options, ctx, node) {
     for (const prop of node.props) {
         if (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
@@ -83,9 +75,9 @@ function* generateIdentifier(options, ctx, prop) {
     yield `.`;
     yield* (0, camelized_1.generateCamelized)(rawName, 'template', prop.loc.start.offset, {
         ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
-        verification: options.vueCompilerOptions.checkUnknownDirectives && !builtInDirectives.has(prop.name),
+        verification: options.vueCompilerOptions.checkUnknownDirectives && !(0, shared_1.isBuiltInDirective)(prop.name),
     });
-    if (!builtInDirectives.has(prop.name)) {
+    if (!(0, shared_1.isBuiltInDirective)(prop.name)) {
         ctx.recordComponentAccess('template', (0, shared_1.camelize)(rawName), prop.loc.start.offset);
     }
     yield (0, boundary_1.endBoundary)(token, startOffset + rawName.length);

package/lib/codegen/template/elementProps.js

@@ -154,7 +154,16 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, fail
                 yield `...{ `;
             }
             const token = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
-            yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, features, shouldCamelize);
+            const prefix = options.template.content.slice(prop.loc.start.offset, prop.loc.start.offset + 1);
+            if (prefix === '.' || prefix === '#') {
+                // Pug shorthand syntax
+                for (const char of prop.name) {
+                    yield [char, 'template', prop.loc.start.offset, features];
+                }
+            }
+            else {
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, features, shouldCamelize);
+            }
             yield `: `;
             if (prop.name === 'style') {
                 yield `{}`;
@@ -197,7 +206,10 @@ function* generatePropExp(options, ctx, prop, exp) {
     else {
         const propVariableName = (0, shared_1.camelize)(exp.loc.source);
         if (utils_1.identifierRegex.test(propVariableName)) {
-            const codes = (0, camelized_1.generateCamelized)(exp.loc.source, 'template', exp.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
+            const codes = (0, camelized_1.generateCamelized)(exp.loc.source, 'template', exp.loc.start.offset, {
+                ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
+                __shorthandExpression: 'html',
+            });
             if (ctx.scopes.some(scope => scope.has(propVariableName))) {
                 yield* codes;
             }

package/lib/codegen/template/interpolation.js

@@ -69,7 +69,9 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
                 start + offset,
                 type === 'errorMappingOnly'
                     ? codeFeatures_1.codeFeatures.verification
-                    : data,
+                    : type === 'shorthand'
+                        ? { ...data, __shorthandExpression: 'js' }
+                        : data,
             ];
         }
         yield addSuffix;
@@ -100,7 +102,7 @@ function* forEachInterpolationSegment(ts, setupRefs, ctx, block, originalCode, s
                 yield names.ctx;
             }
             yield `.`;
-            yield [name, offset];
+            yield [name, offset, isShorthand ? 'shorthand' : undefined];
         }
         prevEnd = offset + name.length;
     }

package/lib/codegen/template/slotOutlet.js

@@ -121,7 +121,9 @@ function* generateSlotOutlet(options, ctx, node) {
             }
             const expVar = ctx.getInternalVariable();
             yield `var ${expVar} = __VLS_tryAsConstant(`;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, isShortHand
+                ? codeFeatures_1.codeFeatures.withoutHighlightAndCompletion
+                : codeFeatures_1.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset);
             yield `)${utils_1.endOfLine}`;
             ctx.dynamicSlots.push({
                 expVar: ctx.getHoistVariable(expVar),

package/lib/compilerOptions.js

@@ -119,25 +119,27 @@ class CompilerOptionsResolver {
                     }
                     break;
                 case 'plugins':
-                    this.plugins = (options.plugins ?? [])
-                        .flatMap((pluginPath) => {
+                    for (let raw of options.plugins ?? []) {
+                        raw = typeof raw === 'string' ? { name: raw } : raw;
                         try {
                             const resolve = require?.resolve;
-                            const resolvedPath = resolve?.(pluginPath, { paths: [rootDir] });
+                            const resolvedPath = resolve?.(raw.name, { paths: [rootDir] });
                             if (resolvedPath) {
                                 const plugin = require(resolvedPath);
-                                plugin.__moduleName = pluginPath;
-                                return plugin;
+                                const plugins = Array.isArray(plugin) ? plugin : [plugin];
+                                for (const plugin of plugins) {
+                                    plugin.__moduleConfig = raw;
+                                    this.plugins.push(plugin);
+                                }
                             }
                             else {
-                                console.warn('[Vue] Load plugin failed:', pluginPath);
+                                console.warn('[Vue] Load plugin failed:', raw.name);
                             }
                         }
                         catch (error) {
-                            console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
+                            console.warn('[Vue] Resolve plugin path failed:', raw.name, error);
                         }
-                        return [];
-                    });
+                    }
                     break;
                 default:
                     // @ts-expect-error

package/lib/plugins.js

@@ -55,15 +55,15 @@ function createPlugins(pluginContext) {
     const pluginInstances = plugins
         .flatMap(plugin => {
         try {
-            const instance = plugin(pluginContext);
-            const moduleName = plugin.__moduleName;
+            const moduleConfig = plugin.__moduleConfig ?? {};
+            const instance = plugin({ ...pluginContext, ...moduleConfig });
             if (Array.isArray(instance)) {
                 for (let i = 0; i < instance.length; i++) {
-                    instance[i].name ??= `${moduleName} (${i})`;
+                    instance[i].name ??= `${moduleConfig.name} (${i})`;
                 }
             }
             else {
-                instance.name ??= moduleName;
+                instance.name ??= moduleConfig.name;
             }
             return instance;
         }

package/lib/types.d.ts

@@ -9,10 +9,14 @@ export { VueEmbeddedCode };
 export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
     strictTemplates?: boolean;
     target?: 'auto' | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
-    plugins?: string[];
+    plugins?: RawPlugin[];
 };
+export type RawPlugin = string | (Record<string, any> & {
+    name: string;
+});
 export interface VueCodeInformation extends CodeInformation {
     __importCompletion?: boolean;
+    __shorthandExpression?: 'html' | 'js';
     __combineToken?: symbol;
     __linkedToken?: symbol;
 }
@@ -93,7 +97,7 @@ export interface VueLanguagePluginReturn {
     }[];
     resolveEmbeddedCode?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedCode): void;
 }
-export type VueLanguagePlugin = (ctx: {
+export type VueLanguagePlugin = (ctx: Record<string, any> & {
     modules: {
         typescript: typeof ts;
         '@vue/compiler-dom': typeof CompilerDOM;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.2.1",
+	"version": "3.2.3",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -28,5 +28,5 @@
 		"@volar/typescript": "2.4.27",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
-	"gitHead": "fad5a89205579e6a0902d7ee5bae3db7b510e2f4"
+	"gitHead": "efc6882ab62a518b41ab5c8dc1d762c41c862ebc"
 }

package/types/template-helpers.d.ts

@@ -93,6 +93,9 @@ declare global {
 			) => any;
 		}
 	>;
+	type __VLS_ShortEmits<E extends Record<string, any[]>> = __VLS_UnionToIntersection<
+		{ [K in keyof E]: (event: K, ...args: E[K]) => void }[keyof E]
+	>;
 	type __VLS_ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any }
 		: E;
 	type __VLS_ResolveEmits<
@@ -110,7 +113,7 @@ declare global {
 		: T extends string ? [string, number][]
 		: T extends (infer U)[] ? [U, number][]
 		: T extends Iterable<infer V> ? [V, number][]
-		: [T[keyof T], `${keyof T & (string | number)}`, number][];
+		: [T[keyof T], keyof T extends string ? keyof T : `${keyof T & (string | number)}`, number][];
 	function __VLS_vSlot<S, D extends S>(slot: S, decl?: D): D extends (...args: infer P) => any ? P : any[];
 	function __VLS_asFunctionalDirective<T, ObjectDirective>(
 		dir: T,