@vue/language-core 2.1.10 → 2.2.2

package/lib/codegen/template/elementChildren.js

@@ -2,26 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateElementChildren = generateElementChildren;
 const CompilerDOM = require("@vue/compiler-dom");
-const common_1 = require("../common");
+const utils_1 = require("../utils");
 const templateChild_1 = require("./templateChild");
-function* generateElementChildren(options, ctx, node, currentComponent, componentCtxVar) {
+function* generateElementChildren(options, ctx, node, isDefaultSlot = false) {
     yield* ctx.resetDirectiveComments('end of element children start');
     let prev;
     for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
         prev = childNode;
     }
     yield* ctx.generateAutoImportCompletion();
     // fix https://github.com/vuejs/language-tools/issues/932
-    if (componentCtxVar
-        && !ctx.hasSlotElements.has(node)
+    if (ctx.currentComponent
+        && isDefaultSlot
         && node.children.length
-        && node.tagType !== CompilerDOM.ElementTypes.ELEMENT
-        && node.tagType !== CompilerDOM.ElementTypes.TEMPLATE) {
-        ctx.usedComponentCtxVars.add(componentCtxVar);
-        yield `__VLS_nonNullable(${componentCtxVar}.slots).`;
-        yield* (0, common_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
-        yield common_1.endOfLine;
+        && node.tagType === CompilerDOM.ElementTypes.COMPONENT) {
+        ctx.currentComponent.used = true;
+        yield `${ctx.currentComponent.ctxVar}.slots!.`;
+        yield* (0, utils_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
+        yield utils_1.endOfLine;
     }
 }
 //# sourceMappingURL=elementChildren.js.map

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

@@ -3,3 +3,4 @@ import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
 export declare function generateElementDirectives(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
+export declare function generateModifiers(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode, propertyName?: string): Generator<Code>;

package/lib/codegen/template/elementDirectives.js

@@ -1,14 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateElementDirectives = generateElementDirectives;
+exports.generateModifiers = generateModifiers;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("@vue/shared");
 const shared_2 = require("../../utils/shared");
-const common_1 = require("../common");
-const camelized_1 = require("./camelized");
+const codeFeatures_1 = require("../codeFeatures");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
+const stringLiteralKey_1 = require("../utils/stringLiteralKey");
 const interpolation_1 = require("./interpolation");
 const objectProperty_1 = require("./objectProperty");
-const stringLiteralKey_1 = require("./stringLiteralKey");
+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
@@ -21,24 +31,22 @@ function* generateElementDirectives(options, ctx, node) {
             continue;
         }
         ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
-        yield* (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, `__VLS_asFunctionalDirective(`, ...generateIdentifier(ctx, prop), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...generateArg(options, ctx, prop), ...generateModifiers(options, ctx, prop), ...generateValue(options, ctx, prop), `}, null!, null!)`);
-        yield common_1.endOfLine;
+        yield* (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, `__VLS_asFunctionalDirective(`, ...generateIdentifier(options, ctx, prop), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...generateArg(options, ctx, prop), ...generateModifiers(options, ctx, prop), ...generateValue(options, ctx, prop), ` }, null!, null!)`);
+        yield utils_1.endOfLine;
     }
 }
-function* generateIdentifier(ctx, prop) {
+function* generateIdentifier(options, ctx, prop) {
     const rawName = 'v-' + prop.name;
-    yield* (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + rawName.length, ctx.codeFeatures.verification, `__VLS_directives.`, ...(0, camelized_1.generateCamelized)(rawName, prop.loc.start.offset, {
-        ...ctx.codeFeatures.all,
-        verification: false,
-        completion: {
-            // fix https://github.com/vuejs/language-tools/issues/1905
-            isAdditional: true,
-        },
+    yield* (0, utils_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + rawName.length, ctx.codeFeatures.verification, `__VLS_directives.`, ...(0, camelized_1.generateCamelized)(rawName, prop.loc.start.offset, ctx.resolveCodeFeatures({
+        ...codeFeatures_1.codeFeatures.withoutHighlight,
+        // fix https://github.com/vuejs/language-tools/issues/1905
+        ...codeFeatures_1.codeFeatures.additionalCompletion,
+        verification: options.vueCompilerOptions.checkUnknownDirectives && !builtInDirectives.has(prop.name),
         navigation: {
             resolveRenameNewName: shared_1.camelize,
             resolveRenameEditText: getPropRenameApply(prop.name),
         },
-    }));
+    })));
 }
 function* generateArg(options, ctx, prop) {
     const { arg } = prop;
@@ -46,34 +54,39 @@ function* generateArg(options, ctx, prop) {
         return;
     }
     const startOffset = arg.loc.start.offset + arg.loc.source.indexOf(arg.content);
-    yield* (0, common_1.wrapWith)(startOffset, startOffset + arg.content.length, ctx.codeFeatures.verification, 'arg');
-    yield ': ';
+    yield* (0, utils_1.wrapWith)(startOffset, startOffset + arg.content.length, ctx.codeFeatures.verification, `arg`);
+    yield `: `;
     if (arg.isStatic) {
-        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, ctx.codeFeatures.withoutHighlight);
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, ctx.codeFeatures.all);
     }
     else {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, arg.content, arg.loc, startOffset, ctx.codeFeatures.all, '(', ')');
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, arg.content, startOffset, arg.loc, `(`, `)`);
     }
-    yield ', ';
+    yield `, `;
 }
-function* generateModifiers(options, ctx, prop) {
-    if (options.vueCompilerOptions.target < 3.5) {
+function* generateModifiers(options, ctx, prop, propertyName = 'modifiers') {
+    const { modifiers } = prop;
+    if (!modifiers.length) {
         return;
     }
-    yield 'modifiers: { ';
-    for (const mod of prop.modifiers) {
-        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, ctx.codeFeatures.withoutHighlight);
-        yield ': true, ';
+    const startOffset = modifiers[0].loc.start.offset - 1;
+    const endOffset = modifiers.at(-1).loc.end.offset;
+    yield* (0, utils_1.wrapWith)(startOffset, endOffset, ctx.codeFeatures.verification, propertyName);
+    yield `: { `;
+    for (const mod of modifiers) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, ctx.codeFeatures.withoutHighlightAndNavigation);
+        yield `: true, `;
     }
-    yield '}, ';
+    yield `}, `;
 }
 function* generateValue(options, ctx, prop) {
-    if (prop.exp?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+    const { exp } = prop;
+    if (exp?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         return;
     }
-    yield* (0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, 'value');
-    yield ': ';
-    yield* (0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, ...(0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')'));
+    yield* (0, utils_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, `value`);
+    yield `: `;
+    yield* (0, utils_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, ...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, exp.content, exp.loc.start.offset, exp.loc, `(`, `)`));
 }
 function getPropRenameApply(oldName) {
     return oldName === (0, shared_2.hyphenateAttr)(oldName) ? shared_2.hyphenateAttr : undefined;

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

@@ -3,7 +3,7 @@ import type * as ts from 'typescript';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentVar: string, componentInstanceVar: string, emitVar: string, eventsVar: string): Generator<Code>;
-export declare function generateEventArg(ctx: TemplateCodegenContext, arg: CompilerDOM.SimpleExpressionNode, enableHover: boolean): Generator<Code>;
+export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentVar: string, componentInstanceVar: string, eventsVar: string): Generator<Code, boolean>;
+export declare function generateEventArg(ctx: TemplateCodegenContext, name: string, start: number, directive?: string): Generator<Code>;
 export declare function generateEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
 export declare function isCompoundExpression(ts: typeof import('typescript'), ast: ts.SourceFile): boolean;

package/lib/codegen/template/elementEvents.js

@@ -6,11 +6,10 @@ exports.generateEventExpression = generateEventExpression;
 exports.isCompoundExpression = isCompoundExpression;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("@vue/shared");
-const shared_2 = require("../../utils/shared");
-const common_1 = require("../common");
-const camelized_1 = require("./camelized");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
 const interpolation_1 = require("./interpolation");
-function* generateElementEvents(options, ctx, node, componentVar, componentInstanceVar, emitVar, eventsVar) {
+function* generateElementEvents(options, ctx, node, componentVar, componentInstanceVar, eventsVar) {
     let usedComponentEventsVar = false;
     let propsVar;
     for (const prop of node.props) {
@@ -22,71 +21,39 @@ function* generateElementEvents(options, ctx, node, componentVar, componentInsta
             usedComponentEventsVar = true;
             if (!propsVar) {
                 propsVar = ctx.getInternalVariable();
-                yield `let ${propsVar}!: __VLS_FunctionalComponentProps<typeof ${componentVar}, typeof ${componentInstanceVar}>${common_1.endOfLine}`;
+                yield `let ${propsVar}!: __VLS_FunctionalComponentProps<typeof ${componentVar}, typeof ${componentInstanceVar}>${utils_1.endOfLine}`;
             }
-            const originalPropName = (0, shared_1.camelize)('on-' + prop.arg.loc.source);
-            const originalPropNameObjectKey = common_1.variableNameRegex.test(originalPropName)
-                ? originalPropName
-                : `'${originalPropName}'`;
-            yield `const ${ctx.getInternalVariable()}: `;
-            if (!options.vueCompilerOptions.strictTemplates) {
-                yield `Record<string, unknown> & `;
+            let source = prop.arg.loc.source;
+            let start = prop.arg.loc.start.offset;
+            let propPrefix = 'on';
+            let emitPrefix = '';
+            if (source.startsWith('vue:')) {
+                source = source.slice('vue:'.length);
+                start = start + 'vue:'.length;
+                propPrefix = 'onVnode';
+                emitPrefix = 'vnode-';
             }
-            yield `(${common_1.newLine}`;
-            yield `__VLS_IsFunction<typeof ${propsVar}, '${originalPropName}'> extends true${common_1.newLine}`;
-            yield `? typeof ${propsVar}${common_1.newLine}`;
-            yield `: __VLS_IsFunction<typeof ${eventsVar}, '${prop.arg.loc.source}'> extends true${common_1.newLine}`;
-            yield `? {${common_1.newLine}`;
-            yield `/**__VLS_emit,${emitVar},${prop.arg.loc.source}*/${common_1.newLine}`;
-            yield `${originalPropNameObjectKey}?: typeof ${eventsVar}['${prop.arg.loc.source}']${common_1.newLine}`;
-            yield `}${common_1.newLine}`;
-            if (prop.arg.loc.source !== (0, shared_1.camelize)(prop.arg.loc.source)) {
-                yield `: __VLS_IsFunction<typeof ${eventsVar}, '${(0, shared_1.camelize)(prop.arg.loc.source)}'> extends true${common_1.newLine}`;
-                yield `? {${common_1.newLine}`;
-                yield `/**__VLS_emit,${emitVar},${(0, shared_1.camelize)(prop.arg.loc.source)}*/${common_1.newLine}`;
-                yield `${originalPropNameObjectKey}?: typeof ${eventsVar}['${(0, shared_1.camelize)(prop.arg.loc.source)}']${common_1.newLine}`;
-                yield `}${common_1.newLine}`;
-            }
-            yield `: typeof ${propsVar}${common_1.newLine}`;
-            yield `) = {${common_1.newLine}`;
-            yield* generateEventArg(ctx, prop.arg, true);
+            yield `const ${ctx.getInternalVariable()}: __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${eventsVar}, '${(0, shared_1.camelize)(propPrefix + '-' + source)}', '${emitPrefix}${source}', '${(0, shared_1.camelize)(emitPrefix + source)}'> = {${utils_1.newLine}`;
+            yield* generateEventArg(ctx, source, start, propPrefix);
             yield `: `;
             yield* generateEventExpression(options, ctx, prop);
-            yield `}${common_1.endOfLine}`;
+            yield `}${utils_1.endOfLine}`;
         }
     }
     return usedComponentEventsVar;
 }
-const eventArgFeatures = {
-    navigation: {
-        // @click-outside -> onClickOutside
-        resolveRenameNewName(newName) {
-            return (0, shared_1.camelize)('on-' + newName);
-        },
-        // onClickOutside -> @click-outside
-        resolveRenameEditText(newName) {
-            const hName = (0, shared_2.hyphenateAttr)(newName);
-            if ((0, shared_2.hyphenateAttr)(newName).startsWith('on-')) {
-                return (0, shared_1.camelize)(hName.slice('on-'.length));
-            }
-            return newName;
-        },
-    },
-};
-function* generateEventArg(ctx, arg, enableHover) {
-    const features = enableHover
-        ? {
-            ...ctx.codeFeatures.withoutHighlightAndCompletion,
-            ...eventArgFeatures,
-        }
-        : eventArgFeatures;
-    if (common_1.variableNameRegex.test((0, shared_1.camelize)(arg.loc.source))) {
-        yield ['', 'template', arg.loc.start.offset, features];
-        yield `on`;
-        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(arg.loc.source), arg.loc.start.offset, common_1.combineLastMapping);
+function* generateEventArg(ctx, name, start, directive = 'on') {
+    const features = {
+        ...ctx.codeFeatures.withoutHighlightAndCompletion,
+        ...ctx.codeFeatures.navigationWithoutRename,
+    };
+    if (utils_1.variableNameRegex.test((0, shared_1.camelize)(name))) {
+        yield ['', 'template', start, features];
+        yield directive;
+        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), start, utils_1.combineLastMapping);
     }
     else {
-        yield* (0, common_1.wrapWith)(arg.loc.start.offset, arg.loc.end.offset, features, `'`, ['', 'template', arg.loc.start.offset, common_1.combineLastMapping], 'on', ...(0, camelized_1.generateCamelized)((0, shared_1.capitalize)(arg.loc.source), arg.loc.start.offset, common_1.combineLastMapping), `'`);
+        yield* (0, utils_1.wrapWith)(start, start + name.length, features, `'`, ['', 'template', start, utils_1.combineLastMapping], directive, ...(0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), start, utils_1.combineLastMapping), `'`);
     }
 }
 function* generateEventExpression(options, ctx, prop) {
@@ -94,18 +61,18 @@ function* generateEventExpression(options, ctx, prop) {
         let prefix = '(';
         let suffix = ')';
         let isFirstMapping = true;
-        const ast = (0, common_1.createTsAst)(options.ts, prop.exp, prop.exp.content);
+        const ast = (0, utils_1.createTsAst)(options.ts, prop.exp, prop.exp.content);
         const _isCompoundExpression = isCompoundExpression(options.ts, ast);
         if (_isCompoundExpression) {
-            yield `(...[$event]) => {${common_1.newLine}`;
+            yield `(...[$event]) => {${utils_1.newLine}`;
             ctx.addLocalVariable('$event');
             prefix = '';
             suffix = '';
             for (const blockCondition of ctx.blockConditions) {
-                prefix += `if (!(${blockCondition})) return${common_1.endOfLine}`;
+                prefix += `if (!(${blockCondition})) return${utils_1.endOfLine}`;
             }
         }
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, offset => {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', offset => {
             if (_isCompoundExpression && isFirstMapping) {
                 isFirstMapping = false;
                 ctx.inlayHints.push({
@@ -122,10 +89,10 @@ function* generateEventExpression(options, ctx, prop) {
                 });
             }
             return ctx.codeFeatures.all;
-        }, prefix, suffix);
+        }, prop.exp.content, prop.exp.loc.start.offset, prop.exp.loc, prefix, suffix);
         if (_isCompoundExpression) {
             ctx.removeLocalVariable('$event');
-            yield common_1.endOfLine;
+            yield utils_1.endOfLine;
             yield* ctx.generateAutoImportCompletion();
             yield `}`;
         }

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

@@ -1,9 +1,11 @@
 import * as CompilerDOM from '@vue/compiler-dom';
-import type { Code } from '../../types';
+import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateElementProps(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, props: CompilerDOM.ElementNode['props'], enableCodeFeatures: boolean, propsFailedExps?: {
+export interface FailedPropExpression {
     node: CompilerDOM.SimpleExpressionNode;
     prefix: string;
     suffix: string;
-}[]): Generator<Code>;
+}
+export declare function generateElementProps(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, props: CompilerDOM.ElementNode['props'], strictPropsCheck: boolean, enableCodeFeatures: boolean, failedPropExps?: FailedPropExpression[]): Generator<Code>;
+export declare function generatePropExp(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode, exp: CompilerDOM.SimpleExpressionNode | undefined, features: VueCodeInformation, enableCodeFeatures: boolean): Generator<Code>;